lokicms-plugin-stripe 1.0.0

package/src/stripe-service.ts

@@ -0,0 +1,552 @@
+/**
+ * Stripe Service
+ * Handles all Stripe API interactions
+ */
+
+import Stripe from 'stripe';
+import type {
+  StripeConfig,
+  StripeProduct,
+  StripePrice,
+  StripeCustomer,
+  StripeSubscription,
+  StripeInvoice,
+  CheckoutSessionParams,
+  PortalSessionParams,
+  WebhookEvent,
+} from './types';
+
+export class StripeService {
+  private stripe: Stripe;
+  private config: StripeConfig;
+
+  constructor(config: StripeConfig) {
+    this.config = config;
+    this.stripe = new Stripe(config.secretKey, {
+      apiVersion: '2025-02-24.acacia',
+    });
+  }
+
+  // ============================================================================
+  // Products
+  // ============================================================================
+
+  async createProduct(params: {
+    name: string;
+    description?: string;
+    metadata?: Record<string, string>;
+  }): Promise<StripeProduct> {
+    const product = await this.stripe.products.create({
+      name: params.name,
+      description: params.description,
+      metadata: params.metadata,
+    });
+
+    return this.mapProduct(product);
+  }
+
+  async getProduct(id: string): Promise<StripeProduct | null> {
+    try {
+      const product = await this.stripe.products.retrieve(id);
+      return this.mapProduct(product);
+    } catch {
+      return null;
+    }
+  }
+
+  async listProducts(params?: {
+    active?: boolean;
+    limit?: number;
+  }): Promise<StripeProduct[]> {
+    const products = await this.stripe.products.list({
+      active: params?.active,
+      limit: params?.limit || 100,
+    });
+
+    return products.data.map((p) => this.mapProduct(p));
+  }
+
+  async updateProduct(
+    id: string,
+    params: {
+      name?: string;
+      description?: string;
+      active?: boolean;
+      metadata?: Record<string, string>;
+    }
+  ): Promise<StripeProduct> {
+    const product = await this.stripe.products.update(id, params);
+    return this.mapProduct(product);
+  }
+
+  async archiveProduct(id: string): Promise<StripeProduct> {
+    const product = await this.stripe.products.update(id, { active: false });
+    return this.mapProduct(product);
+  }
+
+  private mapProduct(product: Stripe.Product): StripeProduct {
+    return {
+      id: product.id,
+      name: product.name,
+      description: product.description || undefined,
+      active: product.active,
+      metadata: product.metadata,
+    };
+  }
+
+  // ============================================================================
+  // Prices
+  // ============================================================================
+
+  async createPrice(params: {
+    productId: string;
+    unitAmount: number;
+    currency?: string;
+    recurring?: {
+      interval: 'day' | 'week' | 'month' | 'year';
+      intervalCount?: number;
+    };
+    trialPeriodDays?: number;
+    metadata?: Record<string, string>;
+  }): Promise<StripePrice> {
+    const priceParams: Stripe.PriceCreateParams = {
+      product: params.productId,
+      unit_amount: params.unitAmount,
+      currency: params.currency || this.config.currency,
+    };
+
+    if (params.recurring) {
+      priceParams.recurring = {
+        interval: params.recurring.interval,
+        interval_count: params.recurring.intervalCount,
+        trial_period_days: params.trialPeriodDays,
+      };
+    }
+
+    if (params.metadata) {
+      priceParams.metadata = params.metadata;
+    }
+
+    const price = await this.stripe.prices.create(priceParams);
+    return this.mapPrice(price);
+  }
+
+  async getPrice(id: string): Promise<StripePrice | null> {
+    try {
+      const price = await this.stripe.prices.retrieve(id);
+      return this.mapPrice(price);
+    } catch {
+      return null;
+    }
+  }
+
+  async listPrices(params?: {
+    productId?: string;
+    active?: boolean;
+    type?: 'one_time' | 'recurring';
+    limit?: number;
+  }): Promise<StripePrice[]> {
+    const prices = await this.stripe.prices.list({
+      product: params?.productId,
+      active: params?.active,
+      type: params?.type,
+      limit: params?.limit || 100,
+    });
+
+    return prices.data.map((p) => this.mapPrice(p));
+  }
+
+  async updatePrice(
+    id: string,
+    params: {
+      active?: boolean;
+      metadata?: Record<string, string>;
+    }
+  ): Promise<StripePrice> {
+    const price = await this.stripe.prices.update(id, params);
+    return this.mapPrice(price);
+  }
+
+  private mapPrice(price: Stripe.Price): StripePrice {
+    return {
+      id: price.id,
+      productId: typeof price.product === 'string' ? price.product : price.product.id,
+      active: price.active,
+      currency: price.currency,
+      unitAmount: price.unit_amount || 0,
+      type: price.type,
+      interval: price.recurring?.interval,
+      intervalCount: price.recurring?.interval_count,
+      trialPeriodDays: price.recurring?.trial_period_days || undefined,
+    };
+  }
+
+  // ============================================================================
+  // Customers
+  // ============================================================================
+
+  async createCustomer(params: {
+    email: string;
+    name?: string;
+    metadata?: Record<string, string>;
+  }): Promise<StripeCustomer> {
+    const customer = await this.stripe.customers.create(params);
+    return this.mapCustomer(customer);
+  }
+
+  async getCustomer(id: string): Promise<StripeCustomer | null> {
+    try {
+      const customer = await this.stripe.customers.retrieve(id);
+      if (customer.deleted) return null;
+      return this.mapCustomer(customer as Stripe.Customer);
+    } catch {
+      return null;
+    }
+  }
+
+  async getCustomerByEmail(email: string): Promise<StripeCustomer | null> {
+    const customers = await this.stripe.customers.list({ email, limit: 1 });
+    if (customers.data.length === 0) return null;
+    return this.mapCustomer(customers.data[0]);
+  }
+
+  async updateCustomer(
+    id: string,
+    params: {
+      email?: string;
+      name?: string;
+      metadata?: Record<string, string>;
+    }
+  ): Promise<StripeCustomer> {
+    const customer = await this.stripe.customers.update(id, params);
+    return this.mapCustomer(customer);
+  }
+
+  async deleteCustomer(id: string): Promise<void> {
+    await this.stripe.customers.del(id);
+  }
+
+  private mapCustomer(customer: Stripe.Customer): StripeCustomer {
+    return {
+      id: customer.id,
+      email: customer.email || '',
+      name: customer.name || undefined,
+      metadata: customer.metadata,
+    };
+  }
+
+  // ============================================================================
+  // Subscriptions
+  // ============================================================================
+
+  async createSubscription(params: {
+    customerId: string;
+    priceId: string;
+    trialPeriodDays?: number;
+    metadata?: Record<string, string>;
+  }): Promise<StripeSubscription> {
+    const subscriptionParams: Stripe.SubscriptionCreateParams = {
+      customer: params.customerId,
+      items: [{ price: params.priceId }],
+    };
+
+    if (params.trialPeriodDays) {
+      subscriptionParams.trial_period_days = params.trialPeriodDays;
+    }
+
+    if (params.metadata) {
+      subscriptionParams.metadata = params.metadata;
+    }
+
+    const subscription = await this.stripe.subscriptions.create(subscriptionParams);
+    return this.mapSubscription(subscription);
+  }
+
+  async getSubscription(id: string): Promise<StripeSubscription | null> {
+    try {
+      const subscription = await this.stripe.subscriptions.retrieve(id);
+      return this.mapSubscription(subscription);
+    } catch {
+      return null;
+    }
+  }
+
+  async listSubscriptions(params?: {
+    customerId?: string;
+    priceId?: string;
+    status?: string;
+    limit?: number;
+  }): Promise<StripeSubscription[]> {
+    const subscriptions = await this.stripe.subscriptions.list({
+      customer: params?.customerId,
+      price: params?.priceId,
+      status: params?.status as Stripe.SubscriptionListParams.Status,
+      limit: params?.limit || 100,
+    });
+
+    return subscriptions.data.map((s) => this.mapSubscription(s));
+  }
+
+  async cancelSubscription(
+    id: string,
+    params?: { atPeriodEnd?: boolean }
+  ): Promise<StripeSubscription> {
+    let subscription: Stripe.Subscription;
+
+    if (params?.atPeriodEnd) {
+      subscription = await this.stripe.subscriptions.update(id, {
+        cancel_at_period_end: true,
+      });
+    } else {
+      subscription = await this.stripe.subscriptions.cancel(id);
+    }
+
+    return this.mapSubscription(subscription);
+  }
+
+  async resumeSubscription(id: string): Promise<StripeSubscription> {
+    const subscription = await this.stripe.subscriptions.update(id, {
+      cancel_at_period_end: false,
+    });
+    return this.mapSubscription(subscription);
+  }
+
+  async updateSubscription(
+    id: string,
+    params: {
+      priceId?: string;
+      metadata?: Record<string, string>;
+    }
+  ): Promise<StripeSubscription> {
+    const updateParams: Stripe.SubscriptionUpdateParams = {};
+
+    if (params.priceId) {
+      const subscription = await this.stripe.subscriptions.retrieve(id);
+      updateParams.items = [
+        {
+          id: subscription.items.data[0].id,
+          price: params.priceId,
+        },
+      ];
+    }
+
+    if (params.metadata) {
+      updateParams.metadata = params.metadata;
+    }
+
+    const subscription = await this.stripe.subscriptions.update(id, updateParams);
+    return this.mapSubscription(subscription);
+  }
+
+  private mapSubscription(subscription: Stripe.Subscription): StripeSubscription {
+    const item = subscription.items.data[0];
+    return {
+      id: subscription.id,
+      customerId:
+        typeof subscription.customer === 'string'
+          ? subscription.customer
+          : subscription.customer.id,
+      priceId: item.price.id,
+      status: subscription.status,
+      currentPeriodStart: subscription.current_period_start,
+      currentPeriodEnd: subscription.current_period_end,
+      cancelAtPeriodEnd: subscription.cancel_at_period_end,
+      canceledAt: subscription.canceled_at || undefined,
+      trialStart: subscription.trial_start || undefined,
+      trialEnd: subscription.trial_end || undefined,
+    };
+  }
+
+  // ============================================================================
+  // Invoices
+  // ============================================================================
+
+  async getInvoice(id: string): Promise<StripeInvoice | null> {
+    try {
+      const invoice = await this.stripe.invoices.retrieve(id);
+      return this.mapInvoice(invoice);
+    } catch {
+      return null;
+    }
+  }
+
+  async listInvoices(params?: {
+    customerId?: string;
+    subscriptionId?: string;
+    status?: string;
+    limit?: number;
+  }): Promise<StripeInvoice[]> {
+    const invoices = await this.stripe.invoices.list({
+      customer: params?.customerId,
+      subscription: params?.subscriptionId,
+      status: params?.status as Stripe.InvoiceListParams.Status,
+      limit: params?.limit || 100,
+    });
+
+    return invoices.data.map((i) => this.mapInvoice(i));
+  }
+
+  async payInvoice(id: string): Promise<StripeInvoice> {
+    const invoice = await this.stripe.invoices.pay(id);
+    return this.mapInvoice(invoice);
+  }
+
+  async voidInvoice(id: string): Promise<StripeInvoice> {
+    const invoice = await this.stripe.invoices.voidInvoice(id);
+    return this.mapInvoice(invoice);
+  }
+
+  private mapInvoice(invoice: Stripe.Invoice): StripeInvoice {
+    return {
+      id: invoice.id,
+      customerId:
+        typeof invoice.customer === 'string'
+          ? invoice.customer
+          : invoice.customer?.id || '',
+      subscriptionId:
+        typeof invoice.subscription === 'string'
+          ? invoice.subscription
+          : invoice.subscription?.id,
+      status: invoice.status || 'draft',
+      amountDue: invoice.amount_due,
+      amountPaid: invoice.amount_paid,
+      currency: invoice.currency,
+      hostedInvoiceUrl: invoice.hosted_invoice_url || undefined,
+      invoicePdf: invoice.invoice_pdf || undefined,
+      paidAt: invoice.status_transitions?.paid_at || undefined,
+    };
+  }
+
+  // ============================================================================
+  // Checkout Sessions
+  // ============================================================================
+
+  async createCheckoutSession(params: CheckoutSessionParams): Promise<{
+    id: string;
+    url: string;
+  }> {
+    const sessionParams: Stripe.Checkout.SessionCreateParams = {
+      mode: params.mode,
+      line_items: [
+        {
+          price: params.priceId,
+          quantity: params.quantity || 1,
+        },
+      ],
+      success_url: this.config.successUrl,
+      cancel_url: this.config.cancelUrl,
+    };
+
+    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,
+      };
+    }
+
+    if (params.metadata) {
+      sessionParams.metadata = params.metadata;
+    }
+
+    if (params.userId) {
+      sessionParams.client_reference_id = params.userId;
+    }
+
+    const session = await this.stripe.checkout.sessions.create(sessionParams);
+
+    return {
+      id: session.id,
+      url: session.url || '',
+    };
+  }
+
+  async getCheckoutSession(id: string): Promise<Stripe.Checkout.Session | null> {
+    try {
+      return await this.stripe.checkout.sessions.retrieve(id, {
+        expand: ['customer', 'subscription', 'payment_intent'],
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  // ============================================================================
+  // Customer Portal
+  // ============================================================================
+
+  async createPortalSession(params: PortalSessionParams): Promise<{
+    id: string;
+    url: string;
+  }> {
+    const session = await this.stripe.billingPortal.sessions.create({
+      customer: params.customerId,
+      return_url: params.returnUrl || this.config.portalReturnUrl,
+    });
+
+    return {
+      id: session.id,
+      url: session.url,
+    };
+  }
+
+  // ============================================================================
+  // Webhooks
+  // ============================================================================
+
+  verifyWebhookSignature(
+    payload: string | Buffer,
+    signature: string
+  ): WebhookEvent {
+    const event = this.stripe.webhooks.constructEvent(
+      payload,
+      signature,
+      this.config.webhookSecret
+    );
+
+    return {
+      id: event.id,
+      type: event.type,
+      data: event.data,
+    };
+  }
+
+  // ============================================================================
+  // Payment Methods
+  // ============================================================================
+
+  async listPaymentMethods(customerId: string): Promise<Stripe.PaymentMethod[]> {
+    const methods = await this.stripe.paymentMethods.list({
+      customer: customerId,
+      type: 'card',
+    });
+    return methods.data;
+  }
+
+  async detachPaymentMethod(paymentMethodId: string): Promise<void> {
+    await this.stripe.paymentMethods.detach(paymentMethodId);
+  }
+
+  // ============================================================================
+  // Usage Records (for metered billing)
+  // ============================================================================
+
+  async createUsageRecord(
+    subscriptionItemId: string,
+    quantity: number,
+    timestamp?: number
+  ): Promise<Stripe.UsageRecord> {
+    return await this.stripe.subscriptionItems.createUsageRecord(
+      subscriptionItemId,
+      {
+        quantity,
+        timestamp: timestamp || Math.floor(Date.now() / 1000),
+        action: 'increment',
+      }
+    );
+  }
+}