@paykit-sdk/medusajs 1.0.11 → 1.0.13

package/dist/index.js

@@ -7,7 +7,7 @@ var core = require('@paykit-sdk/core');
 var zod = require('zod');
 
 // src/index.ts
-var medusaStatus$InboundSchema = (status) => {
+var PaymentStatus$inboundSchema = (status) => {
   switch (status) {
     case "pending":
     case "processing":
@@ -31,17 +31,20 @@ var medusaStatus$InboundSchema = (status) => {
 var optionsSchema = zod.z.object({
   /**
    * The underlying PayKit provider instance (Stripe, PayPal, etc.)
-   * This is required and must be a valid PayKit provider instance
    */
   provider: core.providerSchema,
   /**
-   * The webhook secret for the provider
-   * This is required and must be a valid webhook secret
+   * The webhook secret for the provider.
    */
-  webhookSecret: zod.z.string(),
+  webhookSecret: zod.z.string().nullable().default(null),
+  /**
+   * Multiplier applied to the amount before sending to the payment provider.
+   * Use this when your provider expects amounts in the smallest currency unit (e.g. cents)
+   * but Medusa is passing amounts in the major unit (e.g. euros).
+   */
+  amountToCentsMultiplier: zod.z.number().min(1).default(1),
   /**
    * Whether to enable debug mode
-   * If enabled, the adapter will log debug information to the console
    */
   debug: zod.z.boolean().optional()
 });
@@ -52,30 +55,49 @@ var PaykitMedusaJSAdapter = class extends utils.AbstractPaymentProvider {
    */
   static identifier = "paykit";
   paykit;
-  provider;
   options;
   static validateOptions(options) {
     const { error } = optionsSchema.safeParse(options);
     if (error) {
-      throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, error.message);
+      throw new utils.MedusaError(
+        utils.MedusaError.Types.INVALID_DATA,
+        error.message
+      );
     }
     return;
   }
   /**
-   * Constructor receives Medusa's container and provider options
-   *
    * @param cradle - Medusa's dependency injection container
    * @param options - PayKit provider configuration
    */
   constructor(cradle, options) {
     super(cradle, options);
     this.options = options;
-    this.provider = options.provider;
-    this.paykit = new core.PayKit(this.provider);
+    this.paykit = new core.PayKit(options.provider);
     if (this.options.debug) {
-      console.info(`[PayKit] Initialized with provider: ${this.provider.providerName}`);
+      console.info(
+        `[PayKit] Initialized with provider: ${this.paykit.providerName}`
+      );
     }
   }
+  async exec(promise, context, options) {
+    const [result, error] = await core.tryCatchAsync(promise);
+    if (error) {
+      if (options?.allowUnsupported && error.name === "ProviderNotSupportedError") {
+        if (this.options.debug) {
+          console.warn(
+            `[PayKit ${context}] Operation not supported by ${this.paykit.providerName}.`
+          );
+        }
+        return null;
+      }
+      throw new utils.MedusaError(
+        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
+        `[PayKit ${context}] ${error.message}`
+      );
+    }
+    return result;
+  }
   initiatePayment = async ({
     context,
     amount,
@@ -85,325 +107,338 @@ var PaykitMedusaJSAdapter = class extends utils.AbstractPaymentProvider {
     if (this.options.debug) {
       console.info("[PayKit] Initiating payment", {
         context,
-        amount,
+        amount: Number(amount) * this.options.amountToCentsMultiplier,
         currency_code,
         data
       });
     }
-    const intent = {
-      amount: Number(amount),
-      currency: currency_code,
-      metadata: { ...data?.metadata ?? {}, session_id: data?.session_id ?? null },
-      provider_metadata: data?.provider_metadata,
-      capture_method: "manual",
-      item_id: data?.item_id
-    };
-    let customer;
+    const hasProviderCustomer = !!context?.account_holder?.data?.id;
+    let customer = null;
     if (context?.account_holder?.data?.id) {
-      customer = context.account_holder.data.id;
-    }
-    if (data?.email) {
+      customer = { id: context.account_holder.data.id };
+    } else if (context?.customer?.email) {
+      customer = { email: context.customer.email };
+    } else if (data?.email) {
       customer = { email: data.email };
     }
-    if (!customer) {
+    if (!customer || !core.isIdCustomer(customer) && !core.isEmailCustomer(customer)) {
       throw new utils.MedusaError(
         utils.MedusaError.Types.INVALID_DATA,
-        "Required: customer ID (account_holder) or email (data)"
+        "Customer ID (account_holder) or Email (context.customer or data.email) required"
       );
     }
-    if (typeof customer === "object" && "email" in customer) {
-      const customerName = data?.name ? data.name : customer.email.split("@")[0];
-      const [createdCustomer, createError] = await core.tryCatchAsync(
+    if (!hasProviderCustomer && core.isEmailCustomer(customer)) {
+      const { fullName } = core.parseCustomerName({
+        name: `${context?.customer?.first_name ?? ""} ${context?.customer?.last_name ?? ""}`.trim(),
+        email: customer.email
+      });
+      const billingInfo = core.billingSchema.safeParse(data?.billing);
+      if (data?.billing && !billingInfo.success) {
+        throw new utils.MedusaError(
+          utils.MedusaError.Types.INVALID_DATA,
+          `Invalid billing information, ${billingInfo.error.message} `
+        );
+      }
+      const created = await this.exec(
         this.paykit.customers.create({
           email: customer.email,
-          phone: data?.phone ?? "",
-          name: customerName,
+          name: fullName,
+          phone: data?.phone ?? null,
+          billing: billingInfo.data ?? null,
           metadata: {
-            PAYKIT_METADATA_KEY: JSON.stringify({ source: "medusa-paykit-adapter" })
+            [core.PAYKIT_METADATA_KEY]: JSON.stringify({
+              source: "medusa-paykit-adapter"
+            })
           }
-        })
+        }),
+        "Customer Creation",
+        { allowUnsupported: true }
       );
-      if (createError) {
-        if (createError.name === "ProviderNotSupportedError") {
-          if (this.options.debug) {
-            console.info(
-              `[PayKit] Provider ${this.provider.providerName} doesn't support customer creation, using email object`
-            );
-          }
-        } else {
-          throw new utils.MedusaError(
-            utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-            `Failed to create customer: ${createError.message}`
-          );
-        }
-      } else {
-        customer = createdCustomer.id;
+      if (created) {
+        customer = {
+          ..."id" in created ? { id: created.id } : {},
+          ..."email" in created ? { email: created.email } : {}
+        };
       }
-    } else {
-      customer = customer;
     }
-    intent.customer = customer;
-    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
-      this.paykit.payments.create(intent)
+    const payment = await this.exec(
+      this.paykit.payments.create({
+        amount: Number(amount) * this.options.amountToCentsMultiplier,
+        currency: currency_code.toUpperCase(),
+        customer,
+        item_id: data?.item_id ?? null,
+        capture_method: "manual",
+        metadata: {
+          ...data?.metadata,
+          session_id: data?.session_id
+        },
+        ...data?.billing ? { billing: data.billing } : {},
+        provider_metadata: data?.provider_metadata
+      }),
+      "Initiate"
     );
-    if (paymentIntentError) {
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        paymentIntentError.message
-      );
-    }
-    if (paymentIntentResult.requires_action && paymentIntentResult.payment_url) {
-      return {
-        id: paymentIntentResult.id,
-        status: utils.PaymentSessionStatus.REQUIRES_MORE,
-        data: {
-          payment_url: paymentIntentResult.payment_url
-        }
-      };
-    }
     return {
-      id: paymentIntentResult.id,
-      status: medusaStatus$InboundSchema(paymentIntentResult.status)
+      id: payment.id,
+      status: payment.requires_action ? utils.PaymentSessionStatus.REQUIRES_MORE : PaymentStatus$inboundSchema(payment.status),
+      data: { ...payment, payment_url: payment.payment_url }
     };
   };
   capturePayment = async (input) => {
     if (this.options.debug) {
       console.info("[PayKit] Capturing payment", input);
     }
-    const { id, amount } = core.validateRequiredKeys(
+    const { id: paymentId, amount } = core.validateRequiredKeys(
       ["id", "amount"],
-      input?.data ?? {},
+      input.data ?? {},
       "Missing required fields: {keys}",
       (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
     );
-    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
-      this.paykit.payments.capture(id, { amount: Number(amount) })
+    const data = await this.exec(
+      this.paykit.payments.capture(paymentId, {
+        amount: Number(amount) * this.options.amountToCentsMultiplier
+      }),
+      "Capture"
     );
-    if (paymentIntentError)
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        paymentIntentError.message
-      );
-    return { data: paymentIntentResult };
+    return {
+      data
+    };
   };
   authorizePayment = async (input) => {
-    if (this.options.debug) {
-      console.info("[PayKit] Authorizing payment", input);
+    const { id: paymentId } = core.validateRequiredKeys(
+      ["id"],
+      input.data ?? {},
+      "Missing required fields: {keys}",
+      (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
+    );
+    const payment = await this.exec(
+      this.paykit.payments.retrieve(paymentId),
+      "Authorize"
+    );
+    if (!payment) {
+      throw new utils.MedusaError(
+        utils.MedusaError.Types.NOT_FOUND,
+        "Payment not found"
+      );
     }
-    return this.getPaymentStatus(input);
+    const resolvedStatus = (() => {
+      if (payment.requires_action)
+        return utils.PaymentSessionStatus.REQUIRES_MORE;
+      if (payment.status === "succeeded")
+        return utils.PaymentSessionStatus.AUTHORIZED;
+      return PaymentStatus$inboundSchema(payment.status);
+    })();
+    return {
+      status: resolvedStatus,
+      data: payment
+    };
   };
   cancelPayment = async (input) => {
     if (this.options.debug) {
       console.info("[PayKit] Canceling payment", input);
     }
-    const { id } = core.validateRequiredKeys(
+    const { id: paymentId } = core.validateRequiredKeys(
       ["id"],
-      input?.data ?? {},
+      input.data ?? {},
       "Missing required fields: {keys}",
       (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
     );
-    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
-      this.paykit.payments.cancel(id)
+    const data = await this.exec(
+      this.paykit.payments.cancel(paymentId),
+      "Cancel"
     );
-    if (paymentIntentError)
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        paymentIntentError.message
-      );
-    return { data: paymentIntentResult };
+    return { data };
   };
   deletePayment = async (input) => {
-    return this.cancelPayment(input);
+    if (this.options.debug) {
+      console.info(
+        "[PayKit] Deleting payment (attempting cancel)",
+        input
+      );
+    }
+    const paymentId = input.data?.id;
+    if (!paymentId) {
+      return {};
+    }
+    const data = await this.exec(
+      this.paykit.payments.cancel(paymentId),
+      "Cancel",
+      { allowUnsupported: true }
+    );
+    return { data };
   };
   getPaymentStatus = async (input) => {
-    const { id } = core.validateRequiredKeys(
+    const { id: paymentId } = core.validateRequiredKeys(
       ["id"],
-      input?.data ?? {},
+      input.data ?? {},
       "Missing required fields: {keys}",
       (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
     );
-    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
-      this.paykit.payments.retrieve(id)
+    const payment = await this.exec(
+      this.paykit.payments.retrieve(paymentId),
+      "Status"
     );
-    if (paymentIntentError)
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        paymentIntentError.message
-      );
-    if (!paymentIntentResult)
+    if (!payment)
       throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
+        utils.MedusaError.Types.NOT_FOUND,
         "Payment not found"
       );
     return {
-      status: medusaStatus$InboundSchema(paymentIntentResult.status),
-      data: paymentIntentResult
+      status: PaymentStatus$inboundSchema(payment.status),
+      data: payment
     };
   };
   refundPayment = async (input) => {
     if (this.options.debug) {
       console.info("[PayKit] Refunding payment", input);
     }
-    const { id: paymentId } = core.validateRequiredKeys(
-      ["id"],
-      input?.data ?? {},
+    const { id: paymentId, reason = "customer_request" } = core.validateRequiredKeys(
+      ["id", "reason"],
+      input.data ?? {},
       "Missing required fields: {keys}",
       (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
     );
-    const [refundResult, refundError] = await core.tryCatchAsync(
+    const refund = await this.exec(
       this.paykit.refunds.create({
         payment_id: paymentId,
-        amount: Number(input.amount),
-        reason: null,
-        metadata: input.data?.metadata ? input.data.metadata : null,
-        provider_metadata: input.data?.provider_metadata ? input.data.provider_metadata : void 0
-      })
+        amount: Number(input.amount) * this.options.amountToCentsMultiplier,
+        reason,
+        metadata: input.data?.metadata ?? null,
+        provider_metadata: input.data?.provider_metadata ?? void 0
+      }),
+      "Refund"
     );
-    if (refundError)
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        refundError.message
-      );
-    return { data: refundResult };
+    return { data: refund };
   };
   retrievePayment = async (input) => {
     if (this.options.debug) {
       console.info("[PayKit] Retrieving payment", input);
     }
-    const { id } = core.validateRequiredKeys(
+    const { id: paymentId } = core.validateRequiredKeys(
       ["id"],
-      input?.data ?? {},
+      input.data ?? {},
       "Missing required fields: {keys}",
       (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
     );
-    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
-      this.paykit.payments.retrieve(id)
+    const payment = await this.exec(
+      this.paykit.payments.retrieve(paymentId),
+      "Retrieve"
     );
-    if (paymentIntentError)
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        paymentIntentError.message
-      );
-    return { data: paymentIntentResult };
+    return { data: payment };
   };
   updatePayment = async (input) => {
     if (this.options.debug) {
       console.info("[PayKit] Updating payment", input);
     }
-    const { amount, currency_code } = core.validateRequiredKeys(
-      ["amount", "currency_code"],
-      input,
+    const {
+      amount,
+      id: paymentId,
+      currency_code: currencyCode
+    } = core.validateRequiredKeys(
+      ["amount", "currency_code", "id"],
+      input.data ?? {},
       "Missing required fields: {keys}",
       (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
     );
-    const { id: paymentId } = core.validateRequiredKeys(
-      ["id"],
-      input.data,
-      "Missing required fields: {keys}",
-      (message) => new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, message)
-    );
-    const metadata = input.data?.metadata ?? {};
-    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
+    const data = await this.exec(
       this.paykit.payments.update(paymentId, {
-        amount: Number(amount),
-        currency: currency_code,
-        metadata: core.stringifyMetadataValues(metadata),
-        provider_metadata: input.data?.provider_metadata ? input.data.provider_metadata : void 0
-      })
+        amount: Number(amount) * this.options.amountToCentsMultiplier,
+        currency: currencyCode.toUpperCase(),
+        provider_metadata: input.data?.provider_metadata
+      }),
+      "Update"
     );
-    if (paymentIntentError)
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        paymentIntentError.message
-      );
-    return { data: paymentIntentResult };
+    return { data };
   };
   getWebhookActionAndData = async (payload) => {
     if (this.options.debug) {
-      console.info("[PayKit] Getting webhook action and data", payload);
+      console.info(
+        "[PayKit] Resolving webhook action and data",
+        payload
+      );
     }
     const { rawData, headers } = payload;
-    const bodyString = Buffer.isBuffer(rawData) ? rawData.toString("utf8") : rawData;
+    const body = Buffer.isBuffer(rawData) ? rawData.toString("utf8") : rawData;
+    const headersMap = Object.fromEntries(
+      Object.entries(headers).map(([k, v]) => [k, String(v)])
+    );
+    let result = {
+      action: utils.PaymentActions.NOT_SUPPORTED
+    };
+    const statusMap = {
+      pending: utils.PaymentActions.PENDING,
+      processing: utils.PaymentActions.PENDING,
+      requires_action: utils.PaymentActions.REQUIRES_MORE,
+      requires_capture: utils.PaymentActions.AUTHORIZED,
+      succeeded: utils.PaymentActions.SUCCESSFUL,
+      failed: utils.PaymentActions.FAILED,
+      canceled: utils.PaymentActions.CANCELED
+    };
     const webhook = this.paykit.webhooks.setup({ webhookSecret: this.options.webhookSecret }).on("payment.created", async (event) => {
-      return {
-        action: utils.PaymentActions.PENDING,
+      result = {
+        action: statusMap[event?.data?.status ?? "pending"],
         data: {
           session_id: event.data?.metadata?.session_id,
-          amount: event.data?.amount
+          amount: event.data?.amount ? event.data?.amount * this.options.amountToCentsMultiplier : 0
         }
       };
     }).on("payment.updated", async (event) => {
-      const statusActionMap = {
-        pending: utils.PaymentActions.PENDING,
-        processing: utils.PaymentActions.PENDING,
-        requires_action: utils.PaymentActions.REQUIRES_MORE,
-        requires_capture: utils.PaymentActions.AUTHORIZED,
-        succeeded: utils.PaymentActions.SUCCESSFUL,
-        failed: utils.PaymentActions.FAILED,
-        canceled: utils.PaymentActions.CANCELED
-      };
-      return {
-        action: event.data?.status ? statusActionMap[event.data.status] : utils.PaymentActions.PENDING,
+      result = {
+        action: statusMap[event?.data?.status ?? "pending"],
         data: {
           session_id: event.data?.metadata?.session_id,
-          amount: event.data?.amount
+          amount: event.data?.amount ? event.data?.amount * this.options.amountToCentsMultiplier : 0
         }
       };
-    }).on("payment.canceled", async (event) => {
-      return {
+    }).on("payment.failed", async (event) => {
+      result = {
         action: utils.PaymentActions.CANCELED,
         data: {
-          session_id: event.data?.metadata?.session_id,
-          amount: event.data?.amount
+          amount: event.data?.amount ? event.data?.amount * this.options.amountToCentsMultiplier : 0,
+          session_id: event.data?.metadata?.session_id
         }
       };
     });
-    const stringifiedHeaders = Object.fromEntries(
-      Object.entries(headers).map(([key, value]) => [key, String(value)])
-    );
-    const webhookEvents = await webhook.handle({
-      body: bodyString,
-      headers: new Headers(stringifiedHeaders),
-      fullUrl: core.getURLFromHeaders(stringifiedHeaders)
+    await webhook.handle({
+      body,
+      headersAsObject: headersMap,
+      fullUrl: core.getURLFromHeaders(headersMap)
     });
-    return webhookEvents;
+    return result;
   };
   createAccountHolder = async ({
     context,
     data
   }) => {
+    if (context.account_holder?.data?.id) {
+      return { id: context.account_holder.data.id };
+    }
     if (this.options.debug) {
       console.info("[PayKit] Creating account holder", context, data);
     }
-    const { customer, account_holder } = context;
-    if (account_holder?.data?.id) {
-      return { id: account_holder.data.id };
-    }
-    if (!customer) {
+    const { fullName } = core.parseCustomerName({
+      email: context.customer?.email
+    });
+    const billingInfo = core.billingSchema.safeParse(data?.billing);
+    if (data?.billing && !billingInfo.success) {
       throw new utils.MedusaError(
         utils.MedusaError.Types.INVALID_DATA,
-        "Customer not found in context"
+        `Invalid billing information, ${billingInfo.error.message} `
       );
     }
-    const [accountHolderResult, accountHolderError] = await core.tryCatchAsync(
+    const res = await this.exec(
       this.paykit.customers.create({
-        email: customer.email,
-        name: customer.email.split("@")[0],
-        phone: customer.phone,
-        metadata: {
-          PAYKIT_METADATA_KEY: JSON.stringify({ source: "medusa-paykit-adapter" })
-        }
-      })
+        email: context.customer?.email,
+        name: fullName,
+        phone: context.customer?.phone ?? null,
+        billing: billingInfo.data ?? null
+      }),
+      "Create Account Holder",
+      { allowUnsupported: true }
     );
-    if (accountHolderError) {
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        accountHolderError.message
-      );
-    }
+    if (!res) return {};
     return {
-      id: accountHolderResult.id,
-      data: accountHolderResult
+      id: res.id,
+      data: res
     };
   };
   updateAccountHolder = async ({
@@ -413,36 +448,32 @@ var PaykitMedusaJSAdapter = class extends utils.AbstractPaymentProvider {
     if (this.options.debug) {
       console.info("[PayKit] Updating account holder", context, data);
     }
-    const { account_holder, customer, idempotency_key } = context;
+    const { account_holder, customer } = context;
     if (!account_holder.data?.id) {
       throw new utils.MedusaError(
         utils.MedusaError.Types.INVALID_DATA,
         "Account holder not found in context"
       );
     }
-    if (!customer) {
-      return {};
-    }
-    const accountHolderId = account_holder.data.id;
-    const [accountHolderResult, accountHolderError] = await core.tryCatchAsync(
-      this.paykit.customers.update(accountHolderId, {
-        email: customer.email,
-        name: customer.email.split("@")[0],
-        phone: customer.phone,
-        ...data?.metadata && {
-          metadata: core.stringifyMetadataValues(
-            data?.metadata ?? {}
-          )
-        }
-      })
+    if (!customer) return {};
+    const res = await this.exec(
+      this.paykit.customers.update(account_holder.data.id, {
+        ...data?.billing != null ? {
+          billing: core.billingSchema.safeParse(data.billing).data ?? null
+        } : {},
+        ...data?.email != null ? { email: data.email } : {},
+        ...data?.name != null ? { name: data.name } : {},
+        ...data?.phone != null ? { phone: data.phone } : {},
+        ...data?.metadata != null ? {
+          metadata: data.metadata
+        } : {},
+        ...data?.provider_metadata != null ? {
+          provider_metadata: data.provider_metadata
+        } : {}
+      }),
+      "Update Account Holder"
     );
-    if (accountHolderError) {
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        accountHolderError.message
-      );
-    }
-    return { data: accountHolderResult };
+    return { data: res };
   };
   deleteAccountHolder = async ({
     context,
@@ -458,17 +489,11 @@ var PaykitMedusaJSAdapter = class extends utils.AbstractPaymentProvider {
         "Account holder not found in context"
       );
     }
-    const accountHolderId = account_holder.data.id;
-    const [accountHolderResult, accountHolderError] = await core.tryCatchAsync(
-      this.paykit.customers.delete(accountHolderId)
+    const res = await this.exec(
+      this.paykit.customers.delete(account_holder.data.id),
+      "Delete Account Holder"
     );
-    if (accountHolderError) {
-      throw new utils.MedusaError(
-        utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR,
-        accountHolderError.message
-      );
-    }
-    return { data: accountHolderResult };
+    return { data: res };
   };
 };