@paykit-sdk/medusajs 1.0.0

package/dist/index.mjs

@@ -0,0 +1,306 @@
+import { ModuleProvider, Modules, AbstractPaymentProvider, MedusaError, PaymentActions, PaymentSessionStatus } from '@medusajs/framework/utils';
+import { providerSchema, PayKit, tryCatchAsync, validateRequiredKeys } from '@paykit-sdk/core';
+import { z } from 'zod';
+
+// src/index.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;
+  };
+};
+
+// src/index.ts
+var index_default = ModuleProvider(Modules.PAYMENT, {
+  services: [PaykitMedusaJSAdapter]
+});
+
+export { PaykitMedusaJSAdapter, index_default as default };

package/dist/providers/paykit-provider.d.mts

@@ -0,0 +1,61 @@
+import { InitiatePaymentInput, InitiatePaymentOutput, CapturePaymentInput, CapturePaymentOutput, AuthorizePaymentInput, AuthorizePaymentOutput, CancelPaymentInput, CancelPaymentOutput, DeletePaymentInput, DeletePaymentOutput, GetPaymentStatusInput, GetPaymentStatusOutput, RefundPaymentInput, RefundPaymentOutput, RetrievePaymentInput, RetrievePaymentOutput, UpdatePaymentInput, UpdatePaymentOutput, ProviderWebhookPayload, WebhookActionResult } from '@medusajs/framework/types';
+import { AbstractPaymentProvider } from '@medusajs/framework/utils';
+import { PayKitProvider, PayKit } from '@paykit-sdk/core';
+import { z } from 'zod';
+
+declare const optionsSchema: z.ZodObject<{
+    /**
+     * The underlying PayKit provider instance (Stripe, PayPal, etc.)
+     * This is required and must be a valid PayKit provider instance
+     */
+    provider: z.ZodType<PayKitProvider, z.ZodTypeDef, PayKitProvider>;
+    /**
+     * The webhook secret for the provider
+     * This is required and must be a valid webhook secret
+     */
+    webhookSecret: z.ZodString;
+    /**
+     * Whether to enable debug mode
+     * If enabled, the adapter will log debug information to the console
+     */
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    provider: PayKitProvider;
+    webhookSecret: string;
+    debug?: boolean | undefined;
+}, {
+    provider: PayKitProvider;
+    webhookSecret: string;
+    debug?: boolean | undefined;
+}>;
+type PaykitMedusaJSAdapterOptions = z.infer<typeof optionsSchema>;
+declare class PaykitMedusaJSAdapter extends AbstractPaymentProvider<PaykitMedusaJSAdapterOptions> {
+    /**
+     * The unique identifier for this payment provider
+     * Will be stored as `pp_paykit_{id}` in Medusa
+     */
+    static identifier: string;
+    protected readonly paykit: PayKit;
+    protected readonly provider: PayKitProvider;
+    protected readonly options: PaykitMedusaJSAdapterOptions;
+    static validateOptions(options: Record<string, any>): void | never;
+    /**
+     * Constructor receives Medusa's container and provider options
+     *
+     * @param cradle - Medusa's dependency injection container
+     * @param options - PayKit provider configuration
+     */
+    constructor(cradle: Record<string, unknown>, options: PaykitMedusaJSAdapterOptions);
+    initiatePayment: ({ context, amount, currency_code, data, }: InitiatePaymentInput) => Promise<InitiatePaymentOutput>;
+    capturePayment: (input: CapturePaymentInput) => Promise<CapturePaymentOutput>;
+    authorizePayment: (input: AuthorizePaymentInput) => Promise<AuthorizePaymentOutput>;
+    cancelPayment: (input: CancelPaymentInput) => Promise<CancelPaymentOutput>;
+    deletePayment: (input: DeletePaymentInput) => Promise<DeletePaymentOutput>;
+    getPaymentStatus: (input: GetPaymentStatusInput) => Promise<GetPaymentStatusOutput>;
+    refundPayment: (input: RefundPaymentInput) => Promise<RefundPaymentOutput>;
+    retrievePayment: (input: RetrievePaymentInput) => Promise<RetrievePaymentOutput>;
+    updatePayment: (input: UpdatePaymentInput) => Promise<UpdatePaymentOutput>;
+    getWebhookActionAndData: (payload: ProviderWebhookPayload["payload"]) => Promise<WebhookActionResult>;
+}
+
+export { PaykitMedusaJSAdapter, type PaykitMedusaJSAdapterOptions };

package/dist/providers/paykit-provider.d.ts

@@ -0,0 +1,61 @@
+import { InitiatePaymentInput, InitiatePaymentOutput, CapturePaymentInput, CapturePaymentOutput, AuthorizePaymentInput, AuthorizePaymentOutput, CancelPaymentInput, CancelPaymentOutput, DeletePaymentInput, DeletePaymentOutput, GetPaymentStatusInput, GetPaymentStatusOutput, RefundPaymentInput, RefundPaymentOutput, RetrievePaymentInput, RetrievePaymentOutput, UpdatePaymentInput, UpdatePaymentOutput, ProviderWebhookPayload, WebhookActionResult } from '@medusajs/framework/types';
+import { AbstractPaymentProvider } from '@medusajs/framework/utils';
+import { PayKitProvider, PayKit } from '@paykit-sdk/core';
+import { z } from 'zod';
+
+declare const optionsSchema: z.ZodObject<{
+    /**
+     * The underlying PayKit provider instance (Stripe, PayPal, etc.)
+     * This is required and must be a valid PayKit provider instance
+     */
+    provider: z.ZodType<PayKitProvider, z.ZodTypeDef, PayKitProvider>;
+    /**
+     * The webhook secret for the provider
+     * This is required and must be a valid webhook secret
+     */
+    webhookSecret: z.ZodString;
+    /**
+     * Whether to enable debug mode
+     * If enabled, the adapter will log debug information to the console
+     */
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    provider: PayKitProvider;
+    webhookSecret: string;
+    debug?: boolean | undefined;
+}, {
+    provider: PayKitProvider;
+    webhookSecret: string;
+    debug?: boolean | undefined;
+}>;
+type PaykitMedusaJSAdapterOptions = z.infer<typeof optionsSchema>;
+declare class PaykitMedusaJSAdapter extends AbstractPaymentProvider<PaykitMedusaJSAdapterOptions> {
+    /**
+     * The unique identifier for this payment provider
+     * Will be stored as `pp_paykit_{id}` in Medusa
+     */
+    static identifier: string;
+    protected readonly paykit: PayKit;
+    protected readonly provider: PayKitProvider;
+    protected readonly options: PaykitMedusaJSAdapterOptions;
+    static validateOptions(options: Record<string, any>): void | never;
+    /**
+     * Constructor receives Medusa's container and provider options
+     *
+     * @param cradle - Medusa's dependency injection container
+     * @param options - PayKit provider configuration
+     */
+    constructor(cradle: Record<string, unknown>, options: PaykitMedusaJSAdapterOptions);
+    initiatePayment: ({ context, amount, currency_code, data, }: InitiatePaymentInput) => Promise<InitiatePaymentOutput>;
+    capturePayment: (input: CapturePaymentInput) => Promise<CapturePaymentOutput>;
+    authorizePayment: (input: AuthorizePaymentInput) => Promise<AuthorizePaymentOutput>;
+    cancelPayment: (input: CancelPaymentInput) => Promise<CancelPaymentOutput>;
+    deletePayment: (input: DeletePaymentInput) => Promise<DeletePaymentOutput>;
+    getPaymentStatus: (input: GetPaymentStatusInput) => Promise<GetPaymentStatusOutput>;
+    refundPayment: (input: RefundPaymentInput) => Promise<RefundPaymentOutput>;
+    retrievePayment: (input: RetrievePaymentInput) => Promise<RetrievePaymentOutput>;
+    updatePayment: (input: UpdatePaymentInput) => Promise<UpdatePaymentOutput>;
+    getWebhookActionAndData: (payload: ProviderWebhookPayload["payload"]) => Promise<WebhookActionResult>;
+}
+
+export { PaykitMedusaJSAdapter, type PaykitMedusaJSAdapterOptions };