@digilogiclabs/saas-factory-payments 0.1.0

package/dist/server/index.js

@@ -0,0 +1,484 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StripeServerAPI: () => StripeServerAPI,
+  StripeWebhookHandler: () => StripeWebhookHandler,
+  createNextJSWebhookHandler: () => createNextJSWebhookHandler,
+  createStripeWebhookHandler: () => createStripeWebhookHandler,
+  createStripeWebhookMiddleware: () => createStripeWebhookMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server/api/stripe-server.ts
+var import_stripe = __toESM(require("stripe"));
+
+// src/shared/constants.ts
+var STRIPE_API_VERSION = "2023-10-16";
+var WEBHOOK_EVENTS = {
+  CUSTOMER_SUBSCRIPTION_CREATED: "customer.subscription.created",
+  CUSTOMER_SUBSCRIPTION_UPDATED: "customer.subscription.updated",
+  CUSTOMER_SUBSCRIPTION_DELETED: "customer.subscription.deleted",
+  INVOICE_PAYMENT_SUCCEEDED: "invoice.payment_succeeded",
+  INVOICE_PAYMENT_FAILED: "invoice.payment_failed",
+  CHECKOUT_SESSION_COMPLETED: "checkout.session.completed",
+  PAYMENT_INTENT_SUCCEEDED: "payment_intent.succeeded",
+  PAYMENT_INTENT_PAYMENT_FAILED: "payment_intent.payment_failed"
+};
+
+// src/server/api/stripe-server.ts
+var StripeServerAPI = class {
+  constructor(secretKey, options) {
+    this.stripe = new import_stripe.default(secretKey, {
+      apiVersion: options?.apiVersion || STRIPE_API_VERSION,
+      typescript: true
+    });
+  }
+  // Customer methods
+  async createCustomer(params) {
+    return this.stripe.customers.create({
+      email: params.email,
+      name: params.name,
+      phone: params.phone,
+      metadata: params.metadata
+    });
+  }
+  async getCustomer(customerId) {
+    return this.stripe.customers.retrieve(customerId);
+  }
+  async updateCustomer(customerId, params) {
+    return this.stripe.customers.update(customerId, params);
+  }
+  async deleteCustomer(customerId) {
+    return this.stripe.customers.del(customerId);
+  }
+  // Subscription methods
+  async createSubscription(params) {
+    return this.stripe.subscriptions.create({
+      customer: params.customerId,
+      items: [
+        {
+          price: params.priceId,
+          quantity: params.quantity || 1
+        }
+      ],
+      trial_period_days: params.trialPeriodDays,
+      metadata: params.metadata,
+      payment_behavior: params.paymentBehavior || "default_incomplete",
+      payment_settings: {
+        save_default_payment_method: "on_subscription"
+      },
+      expand: ["latest_invoice.payment_intent"]
+    });
+  }
+  async getSubscription(subscriptionId) {
+    return this.stripe.subscriptions.retrieve(subscriptionId, {
+      expand: ["default_payment_method"]
+    });
+  }
+  async updateSubscription(subscriptionId, params) {
+    const updateData = {};
+    if (params.priceId) {
+      const subscription = await this.getSubscription(subscriptionId);
+      const currentItem = subscription.items.data[0];
+      updateData.items = [
+        {
+          id: currentItem.id,
+          price: params.priceId,
+          quantity: params.quantity || currentItem.quantity
+        }
+      ];
+    }
+    if (params.metadata) {
+      updateData.metadata = params.metadata;
+    }
+    if (typeof params.cancelAtPeriodEnd === "boolean") {
+      updateData.cancel_at_period_end = params.cancelAtPeriodEnd;
+    }
+    return this.stripe.subscriptions.update(subscriptionId, updateData);
+  }
+  async cancelSubscription(subscriptionId, immediately = false) {
+    if (immediately) {
+      return this.stripe.subscriptions.cancel(subscriptionId);
+    } else {
+      return this.stripe.subscriptions.update(subscriptionId, {
+        cancel_at_period_end: true
+      });
+    }
+  }
+  async reactivateSubscription(subscriptionId) {
+    return this.stripe.subscriptions.update(subscriptionId, {
+      cancel_at_period_end: false
+    });
+  }
+  async getCustomerSubscriptions(customerId) {
+    return this.stripe.subscriptions.list({
+      customer: customerId,
+      expand: ["data.default_payment_method"]
+    });
+  }
+  // Checkout methods
+  async createCheckoutSession(params) {
+    const sessionParams = {
+      payment_method_types: ["card"],
+      line_items: [
+        {
+          price: params.priceId,
+          quantity: 1
+        }
+      ],
+      mode: params.mode || "subscription",
+      success_url: params.successUrl,
+      cancel_url: params.cancelUrl,
+      allow_promotion_codes: params.allowPromotionCodes,
+      billing_address_collection: params.billingAddressCollection,
+      metadata: params.metadata
+    };
+    if (params.customerId) {
+      sessionParams.customer = params.customerId;
+    } else if (params.customerEmail) {
+      sessionParams.customer_email = params.customerEmail;
+    }
+    if (params.mode === "subscription" && params.trialPeriodDays) {
+      sessionParams.subscription_data = {
+        trial_period_days: params.trialPeriodDays
+      };
+    }
+    return this.stripe.checkout.sessions.create(sessionParams);
+  }
+  // Payment Intent methods
+  async createPaymentIntent(params) {
+    return this.stripe.paymentIntents.create({
+      amount: params.amount,
+      currency: params.currency,
+      customer: params.customerId,
+      payment_method_types: params.paymentMethodTypes || ["card"],
+      metadata: params.metadata,
+      description: params.description
+    });
+  }
+  async confirmPaymentIntent(paymentIntentId, params) {
+    return this.stripe.paymentIntents.confirm(paymentIntentId, {
+      payment_method: params?.paymentMethod
+    });
+  }
+  // Setup Intent methods (for subscriptions without immediate payment)
+  async createSetupIntent(params) {
+    return this.stripe.setupIntents.create({
+      customer: params.customerId,
+      payment_method_types: params.paymentMethodTypes || ["card"],
+      metadata: params.metadata,
+      usage: "off_session"
+    });
+  }
+  // Customer Portal methods
+  async createPortalSession(params) {
+    return this.stripe.billingPortal.sessions.create({
+      customer: params.customerId,
+      return_url: params.returnUrl
+    });
+  }
+  // Payment Method methods
+  async getCustomerPaymentMethods(customerId, type = "card") {
+    return this.stripe.paymentMethods.list({
+      customer: customerId,
+      type
+    });
+  }
+  async attachPaymentMethod(paymentMethodId, customerId) {
+    return this.stripe.paymentMethods.attach(paymentMethodId, {
+      customer: customerId
+    });
+  }
+  async detachPaymentMethod(paymentMethodId) {
+    return this.stripe.paymentMethods.detach(paymentMethodId);
+  }
+  async setDefaultPaymentMethod(customerId, paymentMethodId) {
+    return this.stripe.customers.update(customerId, {
+      invoice_settings: {
+        default_payment_method: paymentMethodId
+      }
+    });
+  }
+  // Invoice methods
+  async getCustomerInvoices(customerId, limit = 10) {
+    return this.stripe.invoices.list({
+      customer: customerId,
+      limit
+    });
+  }
+  async getInvoice(invoiceId) {
+    return this.stripe.invoices.retrieve(invoiceId);
+  }
+  // Webhook methods
+  constructWebhookEvent(payload, signature, webhookSecret) {
+    return this.stripe.webhooks.constructEvent(
+      payload,
+      signature,
+      webhookSecret
+    );
+  }
+  // Price and Product methods
+  async getPrice(priceId) {
+    return this.stripe.prices.retrieve(priceId, {
+      expand: ["product"]
+    });
+  }
+  async getPrices(params) {
+    return this.stripe.prices.list({
+      active: params?.active,
+      limit: params?.limit || 10,
+      product: params?.product,
+      expand: ["data.product"]
+    });
+  }
+  async getProduct(productId) {
+    return this.stripe.products.retrieve(productId);
+  }
+  // Ephemeral Key methods (for mobile)
+  async createEphemeralKey(customerId, apiVersion) {
+    return this.stripe.ephemeralKeys.create(
+      { customer: customerId },
+      { apiVersion }
+    );
+  }
+};
+
+// src/server/webhooks/stripe.ts
+var StripeWebhookHandler = class {
+  constructor(secretKey, handlers = {}) {
+    this.stripeAPI = new StripeServerAPI(secretKey);
+    this.handlers = handlers;
+  }
+  async handleWebhook(payload, signature, webhookSecret) {
+    try {
+      const event = this.stripeAPI.constructWebhookEvent(
+        payload,
+        signature,
+        webhookSecret
+      );
+      console.log(`Received webhook event: ${event.type}`);
+      await this.processEvent(event);
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown webhook error";
+      console.error("Webhook error:", errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  }
+  async processEvent(event) {
+    switch (event.type) {
+      case WEBHOOK_EVENTS.CUSTOMER_SUBSCRIPTION_CREATED:
+        await this.handleSubscriptionCreated(
+          event.data.object
+        );
+        break;
+      case WEBHOOK_EVENTS.CUSTOMER_SUBSCRIPTION_UPDATED:
+        await this.handleSubscriptionUpdated(
+          event.data.object
+        );
+        break;
+      case WEBHOOK_EVENTS.CUSTOMER_SUBSCRIPTION_DELETED:
+        await this.handleSubscriptionDeleted(
+          event.data.object
+        );
+        break;
+      case WEBHOOK_EVENTS.INVOICE_PAYMENT_SUCCEEDED:
+        await this.handleInvoicePaymentSucceeded(
+          event.data.object
+        );
+        break;
+      case WEBHOOK_EVENTS.INVOICE_PAYMENT_FAILED:
+        await this.handleInvoicePaymentFailed(
+          event.data.object
+        );
+        break;
+      case WEBHOOK_EVENTS.CHECKOUT_SESSION_COMPLETED:
+        await this.handleCheckoutSessionCompleted(
+          event.data.object
+        );
+        break;
+      case WEBHOOK_EVENTS.PAYMENT_INTENT_SUCCEEDED:
+        await this.handlePaymentIntentSucceeded(
+          event.data.object
+        );
+        break;
+      case WEBHOOK_EVENTS.PAYMENT_INTENT_PAYMENT_FAILED:
+        await this.handlePaymentIntentFailed(
+          event.data.object
+        );
+        break;
+      default:
+        console.log(`Unhandled event type: ${event.type}`);
+    }
+  }
+  async handleSubscriptionCreated(subscription) {
+    console.log(`Subscription created: ${subscription.id}`);
+    if (this.handlers.onCustomerSubscriptionCreated) {
+      await this.handlers.onCustomerSubscriptionCreated(subscription);
+    }
+    console.log(
+      `Customer ${subscription.customer} subscribed to ${subscription.items.data[0]?.price.id}`
+    );
+  }
+  async handleSubscriptionUpdated(subscription) {
+    console.log(`Subscription updated: ${subscription.id}`);
+    if (this.handlers.onCustomerSubscriptionUpdated) {
+      await this.handlers.onCustomerSubscriptionUpdated(subscription);
+    }
+    console.log(
+      `Subscription ${subscription.id} status: ${subscription.status}`
+    );
+  }
+  async handleSubscriptionDeleted(subscription) {
+    console.log(`Subscription deleted: ${subscription.id}`);
+    if (this.handlers.onCustomerSubscriptionDeleted) {
+      await this.handlers.onCustomerSubscriptionDeleted(subscription);
+    }
+    console.log(
+      `Customer ${subscription.customer} cancelled subscription ${subscription.id}`
+    );
+  }
+  async handleInvoicePaymentSucceeded(invoice) {
+    console.log(`Invoice payment succeeded: ${invoice.id}`);
+    if (this.handlers.onInvoicePaymentSucceeded) {
+      await this.handlers.onInvoicePaymentSucceeded(invoice);
+    }
+    if (invoice.subscription) {
+      console.log(`Payment succeeded for subscription ${invoice.subscription}`);
+    }
+  }
+  async handleInvoicePaymentFailed(invoice) {
+    console.log(`Invoice payment failed: ${invoice.id}`);
+    if (this.handlers.onInvoicePaymentFailed) {
+      await this.handlers.onInvoicePaymentFailed(invoice);
+    }
+    if (invoice.subscription) {
+      console.log(`Payment failed for subscription ${invoice.subscription}`);
+    }
+  }
+  async handleCheckoutSessionCompleted(session) {
+    console.log(`Checkout session completed: ${session.id}`);
+    if (this.handlers.onCheckoutSessionCompleted) {
+      await this.handlers.onCheckoutSessionCompleted(session);
+    }
+    if (session.mode === "subscription") {
+      console.log(
+        `Subscription checkout completed for customer ${session.customer}`
+      );
+    } else {
+      console.log(
+        `Payment checkout completed for customer ${session.customer}`
+      );
+    }
+  }
+  async handlePaymentIntentSucceeded(paymentIntent) {
+    console.log(`Payment intent succeeded: ${paymentIntent.id}`);
+    if (this.handlers.onPaymentIntentSucceeded) {
+      await this.handlers.onPaymentIntentSucceeded(paymentIntent);
+    }
+    console.log(
+      `Payment of ${paymentIntent.amount} ${paymentIntent.currency} succeeded`
+    );
+  }
+  async handlePaymentIntentFailed(paymentIntent) {
+    console.log(`Payment intent failed: ${paymentIntent.id}`);
+    if (this.handlers.onPaymentIntentPaymentFailed) {
+      await this.handlers.onPaymentIntentPaymentFailed(paymentIntent);
+    }
+    console.log(
+      `Payment of ${paymentIntent.amount} ${paymentIntent.currency} failed`
+    );
+  }
+};
+var createStripeWebhookHandler = (secretKey, handlers = {}) => {
+  return new StripeWebhookHandler(secretKey, handlers);
+};
+var createStripeWebhookMiddleware = (secretKey, webhookSecret, handlers = {}) => {
+  const webhookHandler = new StripeWebhookHandler(secretKey, handlers);
+  return async (req, res, next) => {
+    try {
+      const signature = req.headers["stripe-signature"];
+      if (!signature) {
+        return res.status(400).json({ error: "Missing stripe-signature header" });
+      }
+      const result = await webhookHandler.handleWebhook(
+        req.body,
+        signature,
+        webhookSecret
+      );
+      if (result.success) {
+        res.status(200).json({ received: true });
+      } else {
+        res.status(400).json({ error: result.error });
+      }
+    } catch (error) {
+      console.error("Webhook middleware error:", error);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  };
+};
+var createNextJSWebhookHandler = (secretKey, webhookSecret, handlers = {}) => {
+  const webhookHandler = new StripeWebhookHandler(secretKey, handlers);
+  return async (req, res) => {
+    if (req.method !== "POST") {
+      res.setHeader("Allow", "POST");
+      return res.status(405).json({ error: "Method not allowed" });
+    }
+    try {
+      const signature = req.headers["stripe-signature"];
+      if (!signature) {
+        return res.status(400).json({ error: "Missing stripe-signature header" });
+      }
+      const result = await webhookHandler.handleWebhook(
+        req.body,
+        signature,
+        webhookSecret
+      );
+      if (result.success) {
+        res.status(200).json({ received: true });
+      } else {
+        res.status(400).json({ error: result.error });
+      }
+    } catch (error) {
+      console.error("Webhook handler error:", error);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StripeServerAPI,
+  StripeWebhookHandler,
+  createNextJSWebhookHandler,
+  createStripeWebhookHandler,
+  createStripeWebhookMiddleware
+});