Merge pull request #68 from saleor/feat/add-events-to-report

feat: add events to report

.changeset/green-spoons-breathe.md

@@ -0,0 +1,5 @@
+---
+"saleor-app-authorize-net": minor
+---
+
+Added support for priorAuthCapture.created and void.created Authorize events.

.changeset/strange-brooms-promise.md

@@ -0,0 +1,5 @@
+---
+"saleor-app-authorize-net": patch
+---
+
+Fixed the missing argument TypeScript issue in `webhook-manager-service.ts`.

src/modules/authorize-net/webhook/authorize-net-webhook-handler.ts

@@ -7,7 +7,7 @@ import { getAuthorizeConfig, type AuthorizeConfig } from "../authorize-net-confi
 import { AuthorizeNetInvalidWebhookSignatureError } from "../authorize-net-error";
 import { authorizeNetEventSchema } from "./authorize-net-webhook-client";
 import { MissingAuthDataError } from "./authorize-net-webhook-errors";
-import { AuthorizeNetWebhookTransactionSynchronizer } from "./authorize-net-webhook-transaction-synchronizer";
+import { TransactionEventReporter } from "./transaction-reporter";
 import { saleorApp } from "@/saleor-app";
 import { createLogger } from "@/lib/logger";
 import { createServerClient } from "@/lib/create-graphq-client";
@@ -109,20 +109,20 @@ export class AuthorizeNetWebhookHandler {
 
   private async processAuthorizeWebhook(eventPayload: EventPayload) {
     const authData = await this.getAuthData();
-
     const client = createServerClient(authData.saleorApiUrl, authData.token);
 
-    const synchronizer = new AuthorizeNetWebhookTransactionSynchronizer({
+    const reporter = new TransactionEventReporter({
       client,
     });
-    return synchronizer.synchronizeTransaction(eventPayload);
+
+    return reporter.reportEvent(eventPayload);
   }
 
   async handle() {
     await this.verifyWebhook();
     const eventPayload = await this.parseWebhookBody();
     await this.processAuthorizeWebhook(eventPayload);
 
-    this.logger.info("Finished processing webhook");
+    this.logger.debug("Finished processing webhook");
   }
 }

src/modules/authorize-net/webhook/authorize-net-webhook-transaction-synchronizer.ts → src/modules/authorize-net/webhook/transaction-reporter.ts

@@ -10,31 +10,45 @@ import {
   type TransactionEventReportMutation,
   type TransactionEventReportMutationVariables,
 } from "generated/graphql";
+import { createLogger } from "@/lib/logger";
 
 const TransactionEventReportMutationError = AuthorizeNetError.subclass(
   "TransactionEventReportMutationError",
 );
 
+const TransactionEventReportUnsupportedTypeError = AuthorizeNetError.subclass(
+  "TransactionEventReportUnsupportedTypeError",
+);
+
 /**
  * @description This class is used to synchronize Authorize.net transactions with Saleor transactions
  */
-export class AuthorizeNetWebhookTransactionSynchronizer {
+export class TransactionEventReporter {
   private client: Client;
+  private logger = createLogger({
+    name: "TransactionEventReporter",
+  });
 
   constructor({ client }: { client: Client }) {
     this.client = client;
   }
 
   private mapEventType(authorizeTransactionType: AuthorizeNetEvent): TransactionEventTypeEnum {
+    this.logger.debug({ authorizeTransactionType }, "Mapping Authorize transaction event type");
     switch (authorizeTransactionType) {
-      // todo:
+      case "net.authorize.payment.priorAuthCapture.created":
+        return TransactionEventTypeEnum.ChargeSuccess;
+      case "net.authorize.payment.void.created":
+        return TransactionEventTypeEnum.ChargeFailure;
       default:
-        return TransactionEventTypeEnum.AuthorizationActionRequired;
+        throw new TransactionEventReportUnsupportedTypeError(
+          `${authorizeTransactionType} is not a supported transaction event type`,
+        );
     }
   }
 
   private async transactionEventReport(variables: TransactionEventReportMutationVariables) {
-    const { error: mutationError } = await this.client
+    const { data, error: mutationError } = await this.client
       .mutation<TransactionEventReportMutation>(TransactionEventReportDocument, variables)
       .toPromise();
 
@@ -44,14 +58,16 @@ export class AuthorizeNetWebhookTransactionSynchronizer {
         { cause: mutationError.message },
       );
     }
+
+    this.logger.trace({ data }, "Transaction event response");
   }
 
   private getAuthorizeTransaction({ id }: { id: string }) {
     const transactionDetailsClient = new TransactionDetailsClient();
     return transactionDetailsClient.getTransactionDetailsRequest({ transactionId: id });
   }
 
-  async synchronizeTransaction(eventPayload: EventPayload) {
+  async reportEvent(eventPayload: EventPayload) {
     const id = eventPayload.payload.id;
     const authorizeTransaction = await this.getAuthorizeTransaction({ id });
 
@@ -61,13 +77,19 @@ export class AuthorizeNetWebhookTransactionSynchronizer {
 
     const type = this.mapEventType(eventPayload.eventType);
 
-    await this.transactionEventReport({
+    const eventReportPayload = {
       amount: authorizeTransaction.transaction.authAmount,
       availableActions: [],
       pspReference: authorizeTransactionId,
-      time: authorizeTransaction.transaction.submitTimeLocal,
+      time: eventPayload.eventDate,
       transactionId: saleorTransactionId,
       type,
-    });
+    };
+
+    this.logger.debug({ eventReportPayload }, "Reporting transaction event");
+
+    await this.transactionEventReport(eventReportPayload);
+
+    this.logger.info("Successfully synchronized Saleor transaction with Authorize transaction");
   }
 }

src/modules/webhooks/transaction-process-session.ts

@@ -41,6 +41,7 @@ export class TransactionProcessSessionService {
     saleorTransactionId: string;
     authorizeTransactionId: string;
   }) {
+    // todo: do I even need it? or can I read transactionid from pspreference?
     const metadataManager = new TransactionMetadataManager({ apiClient: this.apiClient });
 
     await metadataManager.saveTransactionId({

src/modules/webhooks/webhook-manager-service.ts

@@ -59,9 +59,7 @@ export class AppWebhookManager implements PaymentsWebhooks {
   async transactionCancelationRequested(
     payload: TransactionCancelationRequestedEventFragment,
   ): Promise<TransactionCancelationRequestedResponse> {
-    const service = new TransactionCancelationRequestedService({
-      apiClient: this.apiClient,
-    });
+    const service = new TransactionCancelationRequestedService();
 
     return service.execute(payload);
   }