@paykit-sdk/medusajs 1.0.0

package/dist/providers/paykit-provider.js

@@ -0,0 +1,303 @@
+'use strict';
+
+var utils = require('@medusajs/framework/utils');
+var core = require('@paykit-sdk/core');
+var zod = require('zod');
+
+// src/providers/paykit-provider.ts
+var medusaStatus$InboundSchema = (status) => {
+  switch (status) {
+    case "pending":
+    case "processing":
+      return utils.PaymentSessionStatus.PENDING;
+    case "requires_action":
+      return utils.PaymentSessionStatus.REQUIRES_MORE;
+    case "requires_capture":
+      return utils.PaymentSessionStatus.AUTHORIZED;
+    case "succeeded":
+      return utils.PaymentSessionStatus.CAPTURED;
+    case "canceled":
+      return utils.PaymentSessionStatus.CANCELED;
+    case "failed":
+      return utils.PaymentSessionStatus.ERROR;
+    default:
+      return utils.PaymentSessionStatus.PENDING;
+  }
+};
+
+// src/providers/paykit-provider.ts
+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
+   */
+  webhookSecret: zod.z.string(),
+  /**
+   * Whether to enable debug mode
+   * If enabled, the adapter will log debug information to the console
+   */
+  debug: zod.z.boolean().optional()
+});
+var PaykitMedusaJSAdapter = class extends utils.AbstractPaymentProvider {
+  /**
+   * The unique identifier for this payment provider
+   * Will be stored as `pp_paykit_{id}` in Medusa
+   */
+  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);
+    }
+    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);
+    if (this.options.debug) {
+      console.info(`[PayKit] Initialized with provider: ${this.provider.providerName}`);
+    }
+  }
+  initiatePayment = async ({
+    context,
+    amount,
+    currency_code,
+    data
+  }) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Initiating payment", { context, amount, currency_code, data });
+    }
+    const intent = {
+      status: "pending",
+      amount: Number(amount),
+      currency: currency_code,
+      metadata: { ...data?.metadata ?? {}, session_id: data?.session_id ?? "" },
+      provider_metadata: data?.provider_metadata ?? void 0
+    };
+    let customer;
+    if (context?.account_holder?.data?.id) {
+      customer = context.account_holder.data.id;
+    } else if (data?.email) {
+      customer = { email: data.email };
+    }
+    if (!customer) {
+      throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Required: customer ID (account_holder) or email (data)");
+    }
+    if (typeof customer === "object" && "email" in customer) {
+      await core.tryCatchAsync(
+        this.paykit.customers.create({
+          email: customer.email,
+          phone: data?.phone ?? "",
+          name: data?.name ? data.name : customer.email.split("@")[0],
+          metadata: { PAYKIT_METADATA_KEY: JSON.stringify({ source: "medusa" }) }
+        })
+      );
+    } else {
+      customer = customer;
+    }
+    intent.customer = customer;
+    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
+      this.paykit.payments.create(intent)
+    );
+    if (paymentIntentError)
+      throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { id: paymentIntentResult.id, status: medusaStatus$InboundSchema(paymentIntentResult.status) };
+  };
+  capturePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Capturing payment", input);
+    }
+    const { id, amount } = core.validateRequiredKeys(
+      ["id", "amount"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    if (!amount) throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required payment amount");
+    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
+      this.paykit.payments.capture(id, { amount: Number(amount) })
+    );
+    if (paymentIntentError)
+      throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  authorizePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Authorizing payment", input);
+    }
+    return this.getPaymentStatus(input);
+  };
+  cancelPayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Canceling payment", input);
+    }
+    const { id } = core.validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(this.paykit.payments.cancel(id));
+    if (paymentIntentError)
+      throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  deletePayment = async (input) => {
+    return this.cancelPayment(input);
+  };
+  getPaymentStatus = async (input) => {
+    const { id } = core.validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(this.paykit.payments.retrieve(id));
+    if (paymentIntentError)
+      throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    if (!paymentIntentResult) throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, "Payment not found");
+    return {
+      status: medusaStatus$InboundSchema(paymentIntentResult.status),
+      data: paymentIntentResult
+    };
+  };
+  refundPayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Refunding payment", input);
+    }
+    const { id: paymentId } = core.validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!paymentId) throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [refundResult, refundError] = await core.tryCatchAsync(
+      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
+      })
+    );
+    if (refundError) throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, refundError.message);
+    return { data: refundResult };
+  };
+  retrievePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Retrieving payment", input);
+    }
+    const { id } = core.validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(this.paykit.payments.retrieve(id));
+    if (paymentIntentError)
+      throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  updatePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Updating payment", input);
+    }
+    const { amount, currency_code } = core.validateRequiredKeys(
+      ["amount", "currency_code"],
+      input,
+      "Missing required payment ID"
+    );
+    if (!amount || !currency_code)
+      throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required amount or currency code");
+    const { id: paymentId } = core.validateRequiredKeys(
+      ["id"],
+      input.data,
+      "Missing required payment ID"
+    );
+    if (!paymentId) throw new utils.MedusaError(utils.MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await core.tryCatchAsync(
+      this.paykit.payments.update(paymentId, {
+        amount: Number(amount),
+        currency: currency_code,
+        metadata: input.data?.metadata ? input.data.metadata : {},
+        provider_metadata: input.data?.provider_metadata ? input.data.provider_metadata : void 0
+      })
+    );
+    if (paymentIntentError)
+      throw new utils.MedusaError(utils.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  getWebhookActionAndData = async (payload) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Getting webhook action and data", payload);
+    }
+    const { rawData, headers } = payload;
+    const fullUrl = (() => {
+      if (headers["origin"]) {
+        return headers["origin"];
+      }
+      if (headers["x-forwarded-host"]) {
+        const protocol = headers["x-forwarded-proto"] || "https";
+        const host = headers["x-forwarded-host"];
+        const path = headers["x-forwarded-path"] || "";
+        return `${protocol}://${host}${path}`;
+      }
+      if (headers["host"]) {
+        const protocol = headers["x-forwarded-proto"] || (String(headers["host"]).includes("localhost") ? "http" : "https");
+        const host = headers["host"];
+        const path = headers["x-original-url"] || headers["x-forwarded-path"] || "";
+        return `${protocol}://${host}${path}`;
+      }
+      return "";
+    })();
+    const webhook = this.paykit.webhooks.setup({ webhookSecret: this.options.webhookSecret }).on("payment.created", async (event) => {
+      return {
+        action: utils.PaymentActions.PENDING,
+        data: { session_id: event.data?.metadata?.session_id, amount: event.data?.amount }
+      };
+    }).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,
+        data: { session_id: event.data?.metadata?.session_id, amount: event.data?.amount }
+      };
+    }).on("payment.canceled", async (event) => {
+      return {
+        action: utils.PaymentActions.CANCELED,
+        data: { session_id: event.data?.metadata?.session_id, amount: event.data?.amount }
+      };
+    });
+    const webhookEvents = await webhook.handle({
+      body: rawData,
+      headers,
+      fullUrl
+    });
+    return webhookEvents;
+  };
+};
+
+exports.PaykitMedusaJSAdapter = PaykitMedusaJSAdapter;

package/dist/providers/paykit-provider.mjs

@@ -0,0 +1,301 @@
+import { AbstractPaymentProvider, MedusaError, PaymentActions, PaymentSessionStatus } from '@medusajs/framework/utils';
+import { providerSchema, PayKit, tryCatchAsync, validateRequiredKeys } from '@paykit-sdk/core';
+import { z } from 'zod';
+
+// src/providers/paykit-provider.ts
+var medusaStatus$InboundSchema = (status) => {
+  switch (status) {
+    case "pending":
+    case "processing":
+      return PaymentSessionStatus.PENDING;
+    case "requires_action":
+      return PaymentSessionStatus.REQUIRES_MORE;
+    case "requires_capture":
+      return PaymentSessionStatus.AUTHORIZED;
+    case "succeeded":
+      return PaymentSessionStatus.CAPTURED;
+    case "canceled":
+      return PaymentSessionStatus.CANCELED;
+    case "failed":
+      return PaymentSessionStatus.ERROR;
+    default:
+      return PaymentSessionStatus.PENDING;
+  }
+};
+
+// src/providers/paykit-provider.ts
+var optionsSchema = z.object({
+  /**
+   * The underlying PayKit provider instance (Stripe, PayPal, etc.)
+   * This is required and must be a valid PayKit provider instance
+   */
+  provider: providerSchema,
+  /**
+   * The webhook secret for the provider
+   * This is required and must be a valid webhook secret
+   */
+  webhookSecret: z.string(),
+  /**
+   * Whether to enable debug mode
+   * If enabled, the adapter will log debug information to the console
+   */
+  debug: z.boolean().optional()
+});
+var PaykitMedusaJSAdapter = class extends AbstractPaymentProvider {
+  /**
+   * The unique identifier for this payment provider
+   * Will be stored as `pp_paykit_{id}` in Medusa
+   */
+  static identifier = "paykit";
+  paykit;
+  provider;
+  options;
+  static validateOptions(options) {
+    const { error } = optionsSchema.safeParse(options);
+    if (error) {
+      throw new MedusaError(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 PayKit(this.provider);
+    if (this.options.debug) {
+      console.info(`[PayKit] Initialized with provider: ${this.provider.providerName}`);
+    }
+  }
+  initiatePayment = async ({
+    context,
+    amount,
+    currency_code,
+    data
+  }) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Initiating payment", { context, amount, currency_code, data });
+    }
+    const intent = {
+      status: "pending",
+      amount: Number(amount),
+      currency: currency_code,
+      metadata: { ...data?.metadata ?? {}, session_id: data?.session_id ?? "" },
+      provider_metadata: data?.provider_metadata ?? void 0
+    };
+    let customer;
+    if (context?.account_holder?.data?.id) {
+      customer = context.account_holder.data.id;
+    } else if (data?.email) {
+      customer = { email: data.email };
+    }
+    if (!customer) {
+      throw new MedusaError(MedusaError.Types.INVALID_DATA, "Required: customer ID (account_holder) or email (data)");
+    }
+    if (typeof customer === "object" && "email" in customer) {
+      await tryCatchAsync(
+        this.paykit.customers.create({
+          email: customer.email,
+          phone: data?.phone ?? "",
+          name: data?.name ? data.name : customer.email.split("@")[0],
+          metadata: { PAYKIT_METADATA_KEY: JSON.stringify({ source: "medusa" }) }
+        })
+      );
+    } else {
+      customer = customer;
+    }
+    intent.customer = customer;
+    const [paymentIntentResult, paymentIntentError] = await tryCatchAsync(
+      this.paykit.payments.create(intent)
+    );
+    if (paymentIntentError)
+      throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { id: paymentIntentResult.id, status: medusaStatus$InboundSchema(paymentIntentResult.status) };
+  };
+  capturePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Capturing payment", input);
+    }
+    const { id, amount } = validateRequiredKeys(
+      ["id", "amount"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    if (!amount) throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required payment amount");
+    const [paymentIntentResult, paymentIntentError] = await tryCatchAsync(
+      this.paykit.payments.capture(id, { amount: Number(amount) })
+    );
+    if (paymentIntentError)
+      throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  authorizePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Authorizing payment", input);
+    }
+    return this.getPaymentStatus(input);
+  };
+  cancelPayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Canceling payment", input);
+    }
+    const { id } = validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await tryCatchAsync(this.paykit.payments.cancel(id));
+    if (paymentIntentError)
+      throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  deletePayment = async (input) => {
+    return this.cancelPayment(input);
+  };
+  getPaymentStatus = async (input) => {
+    const { id } = validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await tryCatchAsync(this.paykit.payments.retrieve(id));
+    if (paymentIntentError)
+      throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    if (!paymentIntentResult) throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, "Payment not found");
+    return {
+      status: medusaStatus$InboundSchema(paymentIntentResult.status),
+      data: paymentIntentResult
+    };
+  };
+  refundPayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Refunding payment", input);
+    }
+    const { id: paymentId } = validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!paymentId) throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [refundResult, refundError] = await tryCatchAsync(
+      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
+      })
+    );
+    if (refundError) throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, refundError.message);
+    return { data: refundResult };
+  };
+  retrievePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Retrieving payment", input);
+    }
+    const { id } = validateRequiredKeys(
+      ["id"],
+      input?.data ?? {},
+      "Missing required payment ID"
+    );
+    if (!id) throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await tryCatchAsync(this.paykit.payments.retrieve(id));
+    if (paymentIntentError)
+      throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  updatePayment = async (input) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Updating payment", input);
+    }
+    const { amount, currency_code } = validateRequiredKeys(
+      ["amount", "currency_code"],
+      input,
+      "Missing required payment ID"
+    );
+    if (!amount || !currency_code)
+      throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required amount or currency code");
+    const { id: paymentId } = validateRequiredKeys(
+      ["id"],
+      input.data,
+      "Missing required payment ID"
+    );
+    if (!paymentId) throw new MedusaError(MedusaError.Types.INVALID_DATA, "Missing required payment ID");
+    const [paymentIntentResult, paymentIntentError] = await tryCatchAsync(
+      this.paykit.payments.update(paymentId, {
+        amount: Number(amount),
+        currency: currency_code,
+        metadata: input.data?.metadata ? input.data.metadata : {},
+        provider_metadata: input.data?.provider_metadata ? input.data.provider_metadata : void 0
+      })
+    );
+    if (paymentIntentError)
+      throw new MedusaError(MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, paymentIntentError.message);
+    return { data: paymentIntentResult };
+  };
+  getWebhookActionAndData = async (payload) => {
+    if (this.options.debug) {
+      console.info("[PayKit] Getting webhook action and data", payload);
+    }
+    const { rawData, headers } = payload;
+    const fullUrl = (() => {
+      if (headers["origin"]) {
+        return headers["origin"];
+      }
+      if (headers["x-forwarded-host"]) {
+        const protocol = headers["x-forwarded-proto"] || "https";
+        const host = headers["x-forwarded-host"];
+        const path = headers["x-forwarded-path"] || "";
+        return `${protocol}://${host}${path}`;
+      }
+      if (headers["host"]) {
+        const protocol = headers["x-forwarded-proto"] || (String(headers["host"]).includes("localhost") ? "http" : "https");
+        const host = headers["host"];
+        const path = headers["x-original-url"] || headers["x-forwarded-path"] || "";
+        return `${protocol}://${host}${path}`;
+      }
+      return "";
+    })();
+    const webhook = this.paykit.webhooks.setup({ webhookSecret: this.options.webhookSecret }).on("payment.created", async (event) => {
+      return {
+        action: PaymentActions.PENDING,
+        data: { session_id: event.data?.metadata?.session_id, amount: event.data?.amount }
+      };
+    }).on("payment.updated", async (event) => {
+      const statusActionMap = {
+        pending: PaymentActions.PENDING,
+        processing: PaymentActions.PENDING,
+        requires_action: PaymentActions.REQUIRES_MORE,
+        requires_capture: PaymentActions.AUTHORIZED,
+        succeeded: PaymentActions.SUCCESSFUL,
+        failed: PaymentActions.FAILED,
+        canceled: PaymentActions.CANCELED
+      };
+      return {
+        action: event.data?.status ? statusActionMap[event.data.status] : PaymentActions.PENDING,
+        data: { session_id: event.data?.metadata?.session_id, amount: event.data?.amount }
+      };
+    }).on("payment.canceled", async (event) => {
+      return {
+        action: PaymentActions.CANCELED,
+        data: { session_id: event.data?.metadata?.session_id, amount: event.data?.amount }
+      };
+    });
+    const webhookEvents = await webhook.handle({
+      body: rawData,
+      headers,
+      fullUrl
+    });
+    return webhookEvents;
+  };
+};
+
+export { PaykitMedusaJSAdapter };

package/dist/utils/mapper.d.mts

@@ -0,0 +1,6 @@
+import { PaymentSessionStatus } from '@medusajs/framework/utils';
+import { PaymentStatus } from '@paykit-sdk/core';
+
+declare const medusaStatus$InboundSchema: (status: PaymentStatus) => PaymentSessionStatus;
+
+export { medusaStatus$InboundSchema };

package/dist/utils/mapper.d.ts

@@ -0,0 +1,6 @@
+import { PaymentSessionStatus } from '@medusajs/framework/utils';
+import { PaymentStatus } from '@paykit-sdk/core';
+
+declare const medusaStatus$InboundSchema: (status: PaymentStatus) => PaymentSessionStatus;
+
+export { medusaStatus$InboundSchema };

package/dist/utils/mapper.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var utils = require('@medusajs/framework/utils');
+
+// src/utils/mapper.ts
+var medusaStatus$InboundSchema = (status) => {
+  switch (status) {
+    case "pending":
+    case "processing":
+      return utils.PaymentSessionStatus.PENDING;
+    case "requires_action":
+      return utils.PaymentSessionStatus.REQUIRES_MORE;
+    case "requires_capture":
+      return utils.PaymentSessionStatus.AUTHORIZED;
+    case "succeeded":
+      return utils.PaymentSessionStatus.CAPTURED;
+    case "canceled":
+      return utils.PaymentSessionStatus.CANCELED;
+    case "failed":
+      return utils.PaymentSessionStatus.ERROR;
+    default:
+      return utils.PaymentSessionStatus.PENDING;
+  }
+};
+
+exports.medusaStatus$InboundSchema = medusaStatus$InboundSchema;

package/dist/utils/mapper.mjs

@@ -0,0 +1,24 @@
+import { PaymentSessionStatus } from '@medusajs/framework/utils';
+
+// src/utils/mapper.ts
+var medusaStatus$InboundSchema = (status) => {
+  switch (status) {
+    case "pending":
+    case "processing":
+      return PaymentSessionStatus.PENDING;
+    case "requires_action":
+      return PaymentSessionStatus.REQUIRES_MORE;
+    case "requires_capture":
+      return PaymentSessionStatus.AUTHORIZED;
+    case "succeeded":
+      return PaymentSessionStatus.CAPTURED;
+    case "canceled":
+      return PaymentSessionStatus.CANCELED;
+    case "failed":
+      return PaymentSessionStatus.ERROR;
+    default:
+      return PaymentSessionStatus.PENDING;
+  }
+};
+
+export { medusaStatus$InboundSchema };