@baasix/plugin-stripe 0.1.0

package/dist/schemas/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Stripe Plugin Database Schemas
+ *
+ * Defines the database tables created by the Stripe plugin:
+ * - baasix_StripeCustomer: Maps users to Stripe customers
+ * - baasix_StripePayment: Records one-time payments
+ * - baasix_StripeSubscription: Tracks subscriptions
+ * - baasix_StripeProduct: Caches products/prices from Stripe
+ */
+import type { PluginSchemaDefinition } from "../types.js";
+/**
+ * Stripe Customer schema - maps Baasix users to Stripe customers
+ */
+export declare const stripeCustomerSchema: PluginSchemaDefinition;
+/**
+ * Stripe Payment schema - records one-time payments
+ */
+export declare const stripePaymentSchema: PluginSchemaDefinition;
+/**
+ * Stripe Subscription schema - tracks active and past subscriptions
+ */
+export declare const stripeSubscriptionSchema: PluginSchemaDefinition;
+/**
+ * Stripe Product schema - caches products and prices from Stripe
+ */
+export declare const stripeProductSchema: PluginSchemaDefinition;
+/**
+ * All Stripe plugin schemas
+ */
+export declare const stripeSchemas: PluginSchemaDefinition[];
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,sBAuBlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,sBA2BjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,sBA4BtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,sBA2BjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,sBAAsB,EAKjD,CAAC"}

package/dist/schemas/index.js

@@ -0,0 +1,140 @@
+/**
+ * Stripe Plugin Database Schemas
+ *
+ * Defines the database tables created by the Stripe plugin:
+ * - baasix_StripeCustomer: Maps users to Stripe customers
+ * - baasix_StripePayment: Records one-time payments
+ * - baasix_StripeSubscription: Tracks subscriptions
+ * - baasix_StripeProduct: Caches products/prices from Stripe
+ */
+/**
+ * Stripe Customer schema - maps Baasix users to Stripe customers
+ */
+export const stripeCustomerSchema = {
+    collectionName: "baasix_StripeCustomer",
+    schema: {
+        name: "StripeCustomer",
+        timestamps: true,
+        fields: {
+            id: { type: "UUID", primaryKey: true, defaultValue: { type: "UUIDV4" } },
+            user_Id: { type: "UUID", allowNull: false },
+            stripeCustomerId: { type: "String", allowNull: false },
+            email: { type: "String", allowNull: true },
+            metadata: { type: "JSON", allowNull: true },
+            user: {
+                relType: "BelongsTo",
+                target: "baasix_User",
+                foreignKey: "user_Id",
+                as: "user",
+            },
+        },
+        indexes: [
+            { fields: ["stripeCustomerId"], unique: true },
+            { fields: ["user_Id"], unique: true },
+        ],
+    },
+};
+/**
+ * Stripe Payment schema - records one-time payments
+ */
+export const stripePaymentSchema = {
+    collectionName: "baasix_StripePayment",
+    schema: {
+        name: "StripePayment",
+        timestamps: true,
+        fields: {
+            id: { type: "UUID", primaryKey: true, defaultValue: { type: "UUIDV4" } },
+            customer_Id: { type: "UUID", allowNull: false },
+            stripePaymentIntentId: { type: "String", allowNull: false },
+            stripeCheckoutSessionId: { type: "String", allowNull: true },
+            amount: { type: "Integer", allowNull: false },
+            currency: { type: "String", defaultValue: "usd" },
+            status: {
+                type: "ENUM",
+                values: ["pending", "processing", "succeeded", "failed", "canceled", "refunded"],
+                defaultValue: "pending",
+            },
+            metadata: { type: "JSON", allowNull: true },
+            customer: {
+                relType: "BelongsTo",
+                target: "baasix_StripeCustomer",
+                foreignKey: "customer_Id",
+                as: "customer",
+            },
+        },
+        indexes: [{ fields: ["stripePaymentIntentId"], unique: true }],
+    },
+};
+/**
+ * Stripe Subscription schema - tracks active and past subscriptions
+ */
+export const stripeSubscriptionSchema = {
+    collectionName: "baasix_StripeSubscription",
+    schema: {
+        name: "StripeSubscription",
+        timestamps: true,
+        fields: {
+            id: { type: "UUID", primaryKey: true, defaultValue: { type: "UUIDV4" } },
+            customer_Id: { type: "UUID", allowNull: false },
+            stripeSubscriptionId: { type: "String", allowNull: false },
+            stripePriceId: { type: "String", allowNull: false },
+            status: {
+                type: "ENUM",
+                values: ["active", "canceled", "incomplete", "past_due", "trialing", "unpaid", "incomplete_expired", "paused"],
+                defaultValue: "incomplete",
+            },
+            currentPeriodStart: { type: "DateTime", allowNull: true },
+            currentPeriodEnd: { type: "DateTime", allowNull: true },
+            cancelAtPeriodEnd: { type: "Boolean", defaultValue: false },
+            metadata: { type: "JSON", allowNull: true },
+            customer: {
+                relType: "BelongsTo",
+                target: "baasix_StripeCustomer",
+                foreignKey: "customer_Id",
+                as: "customer",
+            },
+        },
+        indexes: [{ fields: ["stripeSubscriptionId"], unique: true }],
+    },
+};
+/**
+ * Stripe Product schema - caches products and prices from Stripe
+ */
+export const stripeProductSchema = {
+    collectionName: "baasix_StripeProduct",
+    schema: {
+        name: "StripeProduct",
+        timestamps: true,
+        fields: {
+            id: { type: "UUID", primaryKey: true, defaultValue: { type: "UUIDV4" } },
+            stripeProductId: { type: "String", allowNull: false },
+            stripePriceId: { type: "String", allowNull: false },
+            name: { type: "String", allowNull: false },
+            description: { type: "Text", allowNull: true },
+            amount: { type: "Integer", allowNull: true },
+            currency: { type: "String", defaultValue: "usd" },
+            interval: {
+                type: "ENUM",
+                values: ["one_time", "day", "week", "month", "year"],
+                defaultValue: "one_time",
+            },
+            intervalCount: { type: "Integer", defaultValue: 1 },
+            active: { type: "Boolean", defaultValue: true },
+            metadata: { type: "JSON", allowNull: true },
+        },
+        indexes: [
+            { fields: ["stripeProductId"] },
+            { fields: ["stripePriceId"], unique: true },
+        ],
+    },
+};
+/**
+ * All Stripe plugin schemas
+ */
+export const stripeSchemas = [
+    stripeCustomerSchema,
+    stripePaymentSchema,
+    stripeSubscriptionSchema,
+    stripeProductSchema,
+];
+//# sourceMappingURL=index.js.map

package/dist/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"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"}

package/dist/services/stripeService.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Stripe Service Implementation
+ *
+ * Provides all Stripe-related business logic including:
+ * - Customer management
+ * - Payment processing
+ * - Subscription management
+ * - Webhook handling
+ * - Product synchronization
+ *
+ * This service is available as a singleton after plugin initialization.
+ * You can access it via:
+ * - `getStripeService()` - from anywhere in your code
+ * - `context.services.stripeService` - in plugin routes/hooks
+ */
+import type { PluginContext, StripePluginConfig, StripeServiceInterface } from "../types.js";
+declare global {
+    var __baasix_stripeService: StripeServiceInterface | undefined;
+    var __baasix_stripeServiceInitialized: boolean | undefined;
+}
+/**
+ * Get the Stripe service singleton instance
+ *
+ * @throws Error if the service hasn't been initialized yet
+ *
+ * @example
+ * ```typescript
+ * import { getStripeService } from '@baasix/plugin-stripe';
+ *
+ * // In an endpoint or hook
+ * const stripeService = getStripeService();
+ * const customer = await stripeService.getOrCreateCustomer(userId);
+ * ```
+ */
+export declare function getStripeService(): StripeServiceInterface;
+/**
+ * Check if the Stripe service has been initialized
+ */
+export declare function isStripeServiceInitialized(): boolean;
+/**
+ * Initialize the Stripe service singleton (called internally by the plugin)
+ * @internal
+ */
+export declare function initializeStripeService(service: StripeServiceInterface): void;
+/**
+ * Reset the Stripe service singleton (for testing)
+ * @internal
+ */
+export declare function resetStripeService(): void;
+/**
+ * Creates the Stripe service instance
+ *
+ * @param getStripe - Function to get the Stripe SDK instance
+ * @param config - Plugin configuration
+ * @param context - Plugin context with database access
+ */
+export declare function createStripeService(getStripe: () => Promise<any>, config: StripePluginConfig, context: PluginContext): StripeServiceInterface;
+//# sourceMappingURL=stripeService.d.ts.map

package/dist/services/stripeService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripeService.d.ts","sourceRoot":"","sources":["../../src/services/stripeService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,kBAAkB,EAClB,sBAAsB,EAKvB,MAAM,aAAa,CAAC;AAOrB,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,sBAAsB,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAE/D,IAAI,iCAAiC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,IAAI,sBAAsB,CAOzD;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAG7E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC;AAMD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EAC7B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,aAAa,GACrB,sBAAsB,CA8bxB"}

package/dist/services/stripeService.js

@@ -0,0 +1,431 @@
+/**
+ * Stripe Service Implementation
+ *
+ * Provides all Stripe-related business logic including:
+ * - Customer management
+ * - Payment processing
+ * - Subscription management
+ * - Webhook handling
+ * - Product synchronization
+ *
+ * This service is available as a singleton after plugin initialization.
+ * You can access it via:
+ * - `getStripeService()` - from anywhere in your code
+ * - `context.services.stripeService` - in plugin routes/hooks
+ */
+/**
+ * Get the Stripe service singleton instance
+ *
+ * @throws Error if the service hasn't been initialized yet
+ *
+ * @example
+ * ```typescript
+ * import { getStripeService } from '@baasix/plugin-stripe';
+ *
+ * // In an endpoint or hook
+ * const stripeService = getStripeService();
+ * const customer = await stripeService.getOrCreateCustomer(userId);
+ * ```
+ */
+export function getStripeService() {
+    if (!globalThis.__baasix_stripeService) {
+        throw new Error("Stripe service not initialized. Make sure the Stripe plugin is loaded in startServer().");
+    }
+    return globalThis.__baasix_stripeService;
+}
+/**
+ * Check if the Stripe service has been initialized
+ */
+export function isStripeServiceInitialized() {
+    return globalThis.__baasix_stripeServiceInitialized === true;
+}
+/**
+ * Initialize the Stripe service singleton (called internally by the plugin)
+ * @internal
+ */
+export function initializeStripeService(service) {
+    globalThis.__baasix_stripeService = service;
+    globalThis.__baasix_stripeServiceInitialized = true;
+}
+/**
+ * Reset the Stripe service singleton (for testing)
+ * @internal
+ */
+export function resetStripeService() {
+    globalThis.__baasix_stripeService = undefined;
+    globalThis.__baasix_stripeServiceInitialized = false;
+}
+// ============================================================================
+// Service Factory
+// ============================================================================
+/**
+ * Creates the Stripe service instance
+ *
+ * @param getStripe - Function to get the Stripe SDK instance
+ * @param config - Plugin configuration
+ * @param context - Plugin context with database access
+ */
+export function createStripeService(getStripe, config, context) {
+    // Cache the stripe instance after first call
+    let cachedStripe = null;
+    const stripe = async () => {
+        if (!cachedStripe) {
+            cachedStripe = await getStripe();
+        }
+        return cachedStripe;
+    };
+    const service = {
+        /**
+         * Get the Stripe SDK instance (synchronous, returns cached value)
+         */
+        get stripe() {
+            return cachedStripe;
+        },
+        /**
+         * Get or create a Stripe customer for a user
+         */
+        async getOrCreateCustomer(userId) {
+            const stripeClient = await stripe();
+            const ItemsService = context.ItemsService;
+            const customerService = new ItemsService("baasix_StripeCustomer");
+            // Check for existing customer
+            const existing = await customerService.readByQuery({
+                filter: { user_Id: { _eq: userId } },
+            });
+            if (existing.length > 0) {
+                return existing[0];
+            }
+            // Get user details
+            const userService = new ItemsService("baasix_User");
+            const user = await userService.readOne(userId);
+            if (!user) {
+                throw new Error("User not found");
+            }
+            // Create Stripe customer
+            const stripeCustomer = await stripeClient.customers.create({
+                email: user.email,
+                name: [user.firstName, user.lastName].filter(Boolean).join(" ") || undefined,
+                metadata: { userId },
+            });
+            // Save mapping to database
+            return customerService.createOne({
+                user_Id: userId,
+                stripeCustomerId: stripeCustomer.id,
+                email: user.email,
+            });
+        },
+        /**
+         * Get a Stripe customer by user ID
+         */
+        async getCustomer(userId) {
+            const ItemsService = context.ItemsService;
+            const customerService = new ItemsService("baasix_StripeCustomer");
+            const results = await customerService.readByQuery({
+                filter: { user_Id: { _eq: userId } },
+            });
+            return results[0] || null;
+        },
+        /**
+         * Handle incoming Stripe webhook events
+         */
+        async handleWebhook(event) {
+            const stripeClient = await stripe();
+            const ItemsService = context.ItemsService;
+            switch (event.type) {
+                case "checkout.session.completed": {
+                    const session = event.data.object;
+                    if (session.mode === "payment" && session.payment_intent) {
+                        // Record the completed payment
+                        const paymentService = new ItemsService("baasix_StripePayment");
+                        const customerService = new ItemsService("baasix_StripeCustomer");
+                        const customers = await customerService.readByQuery({
+                            filter: { stripeCustomerId: { _eq: session.customer } },
+                        });
+                        if (customers.length > 0) {
+                            await paymentService.createOne({
+                                customer_Id: customers[0].id,
+                                stripePaymentIntentId: session.payment_intent,
+                                stripeCheckoutSessionId: session.id,
+                                amount: session.amount_total || 0,
+                                currency: session.currency || config.currency || "usd",
+                                status: "succeeded",
+                                metadata: session.metadata,
+                            });
+                        }
+                    }
+                    break;
+                }
+                case "payment_intent.succeeded": {
+                    const paymentIntent = event.data.object;
+                    const paymentService = new ItemsService("baasix_StripePayment");
+                    // Update existing payment record if it exists
+                    const existing = await paymentService.readByQuery({
+                        filter: { stripePaymentIntentId: { _eq: paymentIntent.id } },
+                    });
+                    if (existing.length > 0) {
+                        await paymentService.updateOne(existing[0].id, { status: "succeeded" });
+                    }
+                    break;
+                }
+                case "payment_intent.payment_failed": {
+                    const paymentIntent = event.data.object;
+                    const paymentService = new ItemsService("baasix_StripePayment");
+                    const existing = await paymentService.readByQuery({
+                        filter: { stripePaymentIntentId: { _eq: paymentIntent.id } },
+                    });
+                    if (existing.length > 0) {
+                        await paymentService.updateOne(existing[0].id, { status: "failed" });
+                    }
+                    break;
+                }
+                case "customer.subscription.created":
+                case "customer.subscription.updated": {
+                    const subscription = event.data.object;
+                    await this.syncSubscription(subscription);
+                    break;
+                }
+                case "customer.subscription.deleted": {
+                    const subscription = event.data.object;
+                    const subService = new ItemsService("baasix_StripeSubscription");
+                    const existing = await subService.readByQuery({
+                        filter: { stripeSubscriptionId: { _eq: subscription.id } },
+                    });
+                    if (existing.length > 0) {
+                        await subService.updateOne(existing[0].id, { status: "canceled" });
+                    }
+                    break;
+                }
+                case "invoice.payment_succeeded": {
+                    // Handle subscription renewal
+                    const invoice = event.data.object;
+                    if (invoice.subscription) {
+                        const subscription = await stripeClient.subscriptions.retrieve(invoice.subscription);
+                        await this.syncSubscription(subscription);
+                    }
+                    break;
+                }
+                case "invoice.payment_failed": {
+                    // Handle failed subscription payment
+                    const invoice = event.data.object;
+                    if (invoice.subscription) {
+                        const subService = new ItemsService("baasix_StripeSubscription");
+                        const existing = await subService.readByQuery({
+                            filter: { stripeSubscriptionId: { _eq: invoice.subscription } },
+                        });
+                        if (existing.length > 0) {
+                            await subService.updateOne(existing[0].id, { status: "past_due" });
+                        }
+                    }
+                    break;
+                }
+                default:
+                    console.log(`[Stripe Plugin] Unhandled webhook event: ${event.type}`);
+            }
+        },
+        /**
+         * Sync a subscription from Stripe to the database
+         */
+        async syncSubscription(subscription) {
+            const ItemsService = context.ItemsService;
+            const subService = new ItemsService("baasix_StripeSubscription");
+            const customerService = new ItemsService("baasix_StripeCustomer");
+            // Find the customer
+            const customers = await customerService.readByQuery({
+                filter: { stripeCustomerId: { _eq: subscription.customer } },
+            });
+            if (customers.length === 0) {
+                console.warn(`[Stripe Plugin] Customer not found for subscription: ${subscription.id}`);
+                return;
+            }
+            const priceId = subscription.items.data[0]?.price?.id;
+            if (!priceId) {
+                console.warn(`[Stripe Plugin] No price ID found for subscription: ${subscription.id}`);
+                return;
+            }
+            const data = {
+                customer_Id: customers[0].id,
+                stripeSubscriptionId: subscription.id,
+                stripePriceId: priceId,
+                status: subscription.status,
+                currentPeriodStart: new Date(subscription.current_period_start * 1000),
+                currentPeriodEnd: new Date(subscription.current_period_end * 1000),
+                cancelAtPeriodEnd: subscription.cancel_at_period_end,
+                metadata: subscription.metadata,
+            };
+            // Upsert the subscription
+            const existing = await subService.readByQuery({
+                filter: { stripeSubscriptionId: { _eq: subscription.id } },
+            });
+            if (existing.length > 0) {
+                await subService.updateOne(existing[0].id, data);
+            }
+            else {
+                await subService.createOne(data);
+            }
+        },
+        /**
+         * Manage a subscription (cancel or resume)
+         */
+        async manageSubscription(userId, subscriptionId, action) {
+            const stripeClient = await stripe();
+            const ItemsService = context.ItemsService;
+            const subService = new ItemsService("baasix_StripeSubscription");
+            // Get customer to verify ownership
+            const customer = await this.getCustomer(userId);
+            if (!customer) {
+                throw new Error("Customer not found");
+            }
+            // Verify subscription belongs to user
+            const subs = await subService.readByQuery({
+                filter: {
+                    id: { _eq: subscriptionId },
+                    customer_Id: { _eq: customer.id },
+                },
+            });
+            if (subs.length === 0) {
+                throw new Error("Subscription not found");
+            }
+            const stripeSubId = subs[0].stripeSubscriptionId;
+            if (action === "cancel") {
+                await stripeClient.subscriptions.update(stripeSubId, { cancel_at_period_end: true });
+                await subService.updateOne(subscriptionId, { cancelAtPeriodEnd: true });
+            }
+            else if (action === "resume") {
+                await stripeClient.subscriptions.update(stripeSubId, { cancel_at_period_end: false });
+                await subService.updateOne(subscriptionId, { cancelAtPeriodEnd: false });
+            }
+            return { success: true };
+        },
+        /**
+         * Get a user's payment history
+         */
+        async getUserPayments(userId) {
+            const customer = await this.getCustomer(userId);
+            if (!customer)
+                return [];
+            const ItemsService = context.ItemsService;
+            const paymentService = new ItemsService("baasix_StripePayment");
+            return paymentService.readByQuery({
+                filter: { customer_Id: { _eq: customer.id } },
+                sort: ["-createdAt"],
+            });
+        },
+        /**
+         * Get a user's subscriptions
+         */
+        async getUserSubscriptions(userId) {
+            const customer = await this.getCustomer(userId);
+            if (!customer)
+                return [];
+            const ItemsService = context.ItemsService;
+            const subService = new ItemsService("baasix_StripeSubscription");
+            return subService.readByQuery({
+                filter: { customer_Id: { _eq: customer.id } },
+                sort: ["-createdAt"],
+            });
+        },
+        /**
+         * Get all active products
+         */
+        async getProducts() {
+            const ItemsService = context.ItemsService;
+            const productService = new ItemsService("baasix_StripeProduct");
+            return productService.readByQuery({
+                filter: { active: { _eq: true } },
+                sort: ["name"],
+            });
+        },
+        /**
+         * Sync products and prices from Stripe
+         */
+        async syncProducts() {
+            const stripeClient = await stripe();
+            const products = await stripeClient.products.list({ active: true, limit: 100 });
+            const prices = await stripeClient.prices.list({ active: true, limit: 100 });
+            const ItemsService = context.ItemsService;
+            const productService = new ItemsService("baasix_StripeProduct");
+            for (const price of prices.data) {
+                const product = products.data.find((p) => p.id === price.product);
+                if (!product)
+                    continue;
+                const data = {
+                    stripeProductId: product.id,
+                    stripePriceId: price.id,
+                    name: product.name,
+                    description: product.description || null,
+                    amount: price.unit_amount,
+                    currency: price.currency,
+                    interval: price.recurring?.interval || "one_time",
+                    intervalCount: price.recurring?.interval_count || 1,
+                    active: price.active && product.active,
+                    metadata: product.metadata,
+                };
+                // Upsert by price ID
+                const existing = await productService.readByQuery({
+                    filter: { stripePriceId: { _eq: price.id } },
+                });
+                if (existing.length > 0) {
+                    await productService.updateOne(existing[0].id, data);
+                }
+                else {
+                    await productService.createOne(data);
+                }
+            }
+            console.log(`[Stripe Plugin] Synced ${prices.data.length} products/prices`);
+        },
+        /**
+         * Create a checkout session for one-time payment
+         */
+        async createCheckoutSession(options) {
+            const stripeClient = await stripe();
+            const customer = await this.getOrCreateCustomer(options.userId);
+            const session = await stripeClient.checkout.sessions.create({
+                customer: customer.stripeCustomerId,
+                mode: "payment",
+                line_items: [{ price: options.priceId, quantity: options.quantity || 1 }],
+                success_url: options.successUrl,
+                cancel_url: options.cancelUrl,
+                metadata: { userId: options.userId, ...options.metadata },
+            });
+            return { sessionId: session.id, url: session.url };
+        },
+        /**
+         * Create a checkout session for subscription
+         */
+        async createSubscriptionCheckout(options) {
+            const stripeClient = await stripe();
+            const customer = await this.getOrCreateCustomer(options.userId);
+            const session = await stripeClient.checkout.sessions.create({
+                customer: customer.stripeCustomerId,
+                mode: "subscription",
+                line_items: [{ price: options.priceId, quantity: 1 }],
+                success_url: options.successUrl,
+                cancel_url: options.cancelUrl,
+                subscription_data: options.trialDays
+                    ? { trial_period_days: options.trialDays }
+                    : undefined,
+                metadata: { userId: options.userId, ...options.metadata },
+            });
+            return { sessionId: session.id, url: session.url };
+        },
+        /**
+         * Create a billing portal session for customer self-service
+         */
+        async createPortalSession(userId, returnUrl) {
+            const stripeClient = await stripe();
+            const customer = await this.getCustomer(userId);
+            if (!customer) {
+                throw new Error("Customer not found");
+            }
+            const session = await stripeClient.billingPortal.sessions.create({
+                customer: customer.stripeCustomerId,
+                return_url: returnUrl,
+            });
+            return { url: session.url };
+        },
+    };
+    // Initialize the singleton
+    initializeStripeService(service);
+    return service;
+}
+//# sourceMappingURL=stripeService.js.map