@hazeljs/payment 0.2.0-alpha.4

package/dist/payment.controller.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const payment_controller_1 = require("./payment.controller");
+const mockCreateCheckoutSession = jest.fn();
+const mockParseWebhookEvent = jest.fn();
+describe('PaymentController', () => {
+    let controller;
+    let res;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        res = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn().mockReturnThis(),
+            send: jest.fn().mockReturnThis(),
+        };
+        const paymentService = {
+            createCheckoutSession: mockCreateCheckoutSession,
+            parseWebhookEvent: mockParseWebhookEvent,
+        };
+        controller = new payment_controller_1.PaymentController(paymentService);
+    });
+    describe('createCheckoutSession', () => {
+        it('returns 200 and session result on success', async () => {
+            mockCreateCheckoutSession.mockResolvedValue({
+                sessionId: 'cs_123',
+                url: 'https://checkout.stripe.com',
+            });
+            await controller.createCheckoutSession({
+                successUrl: 'https://a.com/s',
+                cancelUrl: 'https://a.com/c',
+            }, res);
+            expect(mockCreateCheckoutSession).toHaveBeenCalledWith({ successUrl: 'https://a.com/s', cancelUrl: 'https://a.com/c' }, undefined);
+            expect(res.status).toHaveBeenCalledWith(200);
+            expect(res.json).toHaveBeenCalledWith({
+                sessionId: 'cs_123',
+                url: 'https://checkout.stripe.com',
+            });
+        });
+        it('passes provider from body when present', async () => {
+            mockCreateCheckoutSession.mockResolvedValue({ sessionId: 'cs_456', url: null });
+            await controller.createCheckoutSession({
+                successUrl: 'https://a.com/s',
+                cancelUrl: 'https://a.com/c',
+                provider: 'stripe',
+            }, res);
+            expect(mockCreateCheckoutSession).toHaveBeenCalledWith({ successUrl: 'https://a.com/s', cancelUrl: 'https://a.com/c' }, 'stripe');
+        });
+        it('returns 400 and error message on failure', async () => {
+            mockCreateCheckoutSession.mockRejectedValue(new Error('Invalid price ID'));
+            await controller.createCheckoutSession({ successUrl: 'https://a.com/s', cancelUrl: 'https://a.com/c' }, res);
+            expect(res.status).toHaveBeenCalledWith(400);
+            expect(res.json).toHaveBeenCalledWith({ error: 'Invalid price ID' });
+        });
+        it('returns 400 with generic message when error is not Error instance', async () => {
+            mockCreateCheckoutSession.mockRejectedValue('string error');
+            await controller.createCheckoutSession({ successUrl: 'https://a.com/s', cancelUrl: 'https://a.com/c' }, res);
+            expect(res.status).toHaveBeenCalledWith(400);
+            expect(res.json).toHaveBeenCalledWith({ error: 'Failed to create checkout session' });
+        });
+    });
+    describe('webhook', () => {
+        it('returns 400 when raw body is missing', async () => {
+            const req = { headers: { 'stripe-signature': 'sig' } };
+            await controller.webhook('stripe', req, res);
+            expect(res.status).toHaveBeenCalledWith(400);
+            expect(res.send).toHaveBeenCalledWith('Webhook requires raw body');
+            expect(mockParseWebhookEvent).not.toHaveBeenCalled();
+        });
+        it('uses rawBody when present', async () => {
+            mockParseWebhookEvent.mockReturnValue({ type: 'checkout.session.completed' });
+            const req = {
+                headers: { 'stripe-signature': 'v1,sig' },
+                rawBody: Buffer.from('{"id":"evt_1"}'),
+            };
+            await controller.webhook('stripe', req, res);
+            expect(mockParseWebhookEvent).toHaveBeenCalledWith('stripe', req.rawBody, 'v1,sig');
+            expect(res.status).toHaveBeenCalledWith(200);
+            expect(res.json).toHaveBeenCalledWith({
+                received: true,
+                provider: 'stripe',
+                type: 'checkout.session.completed',
+            });
+        });
+        it('uses body as string when rawBody absent and body is string', async () => {
+            mockParseWebhookEvent.mockReturnValue({ type: 'invoice.paid' });
+            const req = {
+                headers: { 'stripe-signature': 'sig' },
+                body: '{"id":"evt_2"}',
+            };
+            await controller.webhook('stripe', req, res);
+            expect(mockParseWebhookEvent).toHaveBeenCalledWith('stripe', '{"id":"evt_2"}', 'sig');
+            expect(res.status).toHaveBeenCalledWith(200);
+            expect(res.json).toHaveBeenCalledWith({
+                received: true,
+                provider: 'stripe',
+                type: 'invoice.paid',
+            });
+        });
+        it('uses body as Buffer when rawBody absent and body is Buffer', async () => {
+            const buf = Buffer.from('{}');
+            mockParseWebhookEvent.mockReturnValue({});
+            const req = { headers: {}, body: buf };
+            await controller.webhook('paypal', req, res);
+            expect(mockParseWebhookEvent).toHaveBeenCalledWith('paypal', buf, '');
+            expect(res.status).toHaveBeenCalledWith(200);
+            expect(res.json).toHaveBeenCalledWith({
+                received: true,
+                provider: 'paypal',
+                type: undefined,
+            });
+        });
+        it('returns 400 when parseWebhookEvent throws', async () => {
+            mockParseWebhookEvent.mockImplementation(() => {
+                throw new Error('Invalid signature');
+            });
+            const req = { headers: { 'stripe-signature': 'bad' }, rawBody: 'payload' };
+            await controller.webhook('stripe', req, res);
+            expect(res.status).toHaveBeenCalledWith(400);
+            expect(res.send).toHaveBeenCalledWith('Invalid signature');
+        });
+        it('uses paypal-transmission-sig header when stripe-signature absent', async () => {
+            mockParseWebhookEvent.mockReturnValue({ type: 'payment.capture.completed' });
+            const req = {
+                headers: { 'paypal-transmission-sig': 'paypal_sig' },
+                rawBody: 'payload',
+            };
+            await controller.webhook('paypal', req, res);
+            expect(mockParseWebhookEvent).toHaveBeenCalledWith('paypal', 'payload', 'paypal_sig');
+        });
+    });
+});

package/dist/payment.module.d.ts

@@ -0,0 +1,21 @@
+import type { PaymentProvider } from './providers/provider.interface';
+import type { StripeProviderOptions } from './providers/stripe/stripe.types';
+/**
+ * Options for PaymentModule.forRoot().
+ * Register providers via convenience keys (e.g. stripe) and/or pass pre-built provider instances.
+ */
+export interface PaymentModuleOptions {
+    /** Provider to use when none is specified (default: first registered). */
+    defaultProvider?: string;
+    /** Convenience: Stripe config; we create StripePaymentProvider. */
+    stripe?: StripeProviderOptions;
+    /** Additional or custom provider instances (merged with convenience providers). */
+    providers?: Record<string, PaymentProvider>;
+}
+/**
+ * Payment module for Stripe, and other providers. Register with forRoot().
+ */
+export declare class PaymentModule {
+    static forRoot(options: PaymentModuleOptions): typeof PaymentModule;
+}
+//# sourceMappingURL=payment.module.d.ts.map

package/dist/payment.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment.module.d.ts","sourceRoot":"","sources":["../src/payment.module.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,qBAKa,aAAa;IACxB,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,aAAa;CAapE"}

package/dist/payment.module.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var PaymentModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentModule = void 0;
+const core_1 = require("@hazeljs/core");
+const payment_controller_1 = require("./payment.controller");
+const payment_service_1 = require("./payment.service");
+const stripe_provider_1 = require("./providers/stripe/stripe.provider");
+/**
+ * Payment module for Stripe, and other providers. Register with forRoot().
+ */
+let PaymentModule = PaymentModule_1 = class PaymentModule {
+    static forRoot(options) {
+        const providers = {
+            ...(options.providers ?? {}),
+        };
+        if (options.stripe) {
+            providers[stripe_provider_1.STRIPE_PROVIDER_NAME] = new stripe_provider_1.StripePaymentProvider(options.stripe);
+        }
+        payment_service_1.PaymentService.configure({
+            defaultProvider: options.defaultProvider,
+            providers,
+        });
+        return PaymentModule_1;
+    }
+};
+exports.PaymentModule = PaymentModule;
+exports.PaymentModule = PaymentModule = PaymentModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        controllers: [payment_controller_1.PaymentController],
+        providers: [payment_service_1.PaymentService],
+        exports: [payment_service_1.PaymentService],
+    })
+], PaymentModule);

package/dist/payment.module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=payment.module.test.d.ts.map

package/dist/payment.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment.module.test.d.ts","sourceRoot":"","sources":["../src/payment.module.test.ts"],"names":[],"mappings":""}

package/dist/payment.module.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('stripe', () => jest.fn().mockImplementation(() => ({})));
+const payment_module_1 = require("./payment.module");
+const payment_service_1 = require("./payment.service");
+const stripe_provider_1 = require("./providers/stripe/stripe.provider");
+const mockProvider = {
+    name: 'mock',
+    createCheckoutSession: jest
+        .fn()
+        .mockResolvedValue({ sessionId: 'sess_1', url: 'https://pay.com' }),
+    createCustomer: jest
+        .fn()
+        .mockResolvedValue({ id: 'cus_1', email: 'a@b.com', name: null, metadata: {} }),
+    getCustomer: jest
+        .fn()
+        .mockResolvedValue({ id: 'cus_1', email: 'a@b.com', name: null, metadata: {} }),
+    listSubscriptions: jest.fn().mockResolvedValue({ data: [] }),
+    getCheckoutSession: jest.fn().mockResolvedValue({ id: 'sess_1', url: null }),
+    isWebhookConfigured: jest.fn().mockReturnValue(false),
+    parseWebhookEvent: jest.fn().mockReturnValue({}),
+};
+describe('PaymentModule', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        payment_service_1.PaymentService.config = null;
+    });
+    it('forRoot with stripe option registers StripePaymentProvider', () => {
+        const result = payment_module_1.PaymentModule.forRoot({
+            stripe: { secretKey: 'sk_test_xxx' },
+        });
+        expect(result).toBe(payment_module_1.PaymentModule);
+        const service = new payment_service_1.PaymentService();
+        expect(service.getProviderNames()).toContain(stripe_provider_1.STRIPE_PROVIDER_NAME);
+    });
+    it('forRoot with providers option registers custom providers', () => {
+        payment_module_1.PaymentModule.forRoot({
+            providers: { mock: mockProvider },
+        });
+        const service = new payment_service_1.PaymentService();
+        expect(service.getProviderNames()).toContain('mock');
+        expect(service.getProvider('mock').name).toBe('mock');
+    });
+    it('forRoot merges stripe and providers', () => {
+        payment_module_1.PaymentModule.forRoot({
+            stripe: { secretKey: 'sk_test_xxx' },
+            providers: { custom: mockProvider },
+        });
+        const service = new payment_service_1.PaymentService();
+        expect(service.getProviderNames()).toContain(stripe_provider_1.STRIPE_PROVIDER_NAME);
+        expect(service.getProviderNames()).toContain('custom');
+    });
+    it('forRoot with defaultProvider sets it', async () => {
+        payment_module_1.PaymentModule.forRoot({
+            defaultProvider: 'mock',
+            providers: { stripe: mockProvider, mock: mockProvider },
+        });
+        const service = new payment_service_1.PaymentService();
+        const result = await service.createCheckoutSession({
+            successUrl: 'https://a.com/s',
+            cancelUrl: 'https://a.com/c',
+        });
+        expect(result.sessionId).toBe('sess_1');
+        expect(mockProvider.createCheckoutSession).toHaveBeenCalled();
+    });
+    it('forRoot with only providers (no stripe) works', () => {
+        payment_module_1.PaymentModule.forRoot({ providers: { mock: mockProvider } });
+        const service = new payment_service_1.PaymentService();
+        expect(service.getProviderNames()).toEqual(['mock']);
+    });
+});

package/dist/payment.service.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Payment service that delegates to registered providers (Stripe, PayPal, etc.).
+ */
+import type { PaymentProvider } from './providers/provider.interface';
+import type { ListSubscriptionsResult } from './providers/provider.interface';
+import type { CreateCheckoutSessionOptions, CreateCheckoutSessionResult, CreateCustomerOptions, Customer, CheckoutSessionInfo, SubscriptionStatusFilter } from './types/payment.types';
+export interface PaymentServiceConfig {
+    defaultProvider?: string;
+    providers: Record<string, PaymentProvider>;
+}
+export declare class PaymentService {
+    private config;
+    constructor();
+    private static config;
+    static configure(config: PaymentServiceConfig): void;
+    private static getConfig;
+    private resolveProvider;
+    /** Get a provider by name for provider-specific APIs (e.g. Stripe client). */
+    getProvider<T extends PaymentProvider = PaymentProvider>(name: string): T;
+    /** List registered provider names. */
+    getProviderNames(): string[];
+    createCheckoutSession(options: CreateCheckoutSessionOptions, providerName?: string): Promise<CreateCheckoutSessionResult>;
+    createCustomer(options: CreateCustomerOptions, providerName?: string): Promise<Customer>;
+    getCustomer(customerId: string, providerName?: string): Promise<Customer | null>;
+    listSubscriptions(customerId: string, status?: SubscriptionStatusFilter, providerName?: string): Promise<ListSubscriptionsResult>;
+    getCheckoutSession(sessionId: string, providerName?: string): Promise<CheckoutSessionInfo>;
+    /**
+     * Verify and parse a webhook event. Use the provider name that received the webhook (e.g. 'stripe').
+     */
+    parseWebhookEvent(providerName: string, payload: string | Buffer, signature: string): unknown;
+    isWebhookConfigured(providerName?: string): boolean;
+}
+//# sourceMappingURL=payment.service.d.ts.map

package/dist/payment.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment.service.d.ts","sourceRoot":"","sources":["../src/payment.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,KAAK,EACV,4BAA4B,EAC5B,2BAA2B,EAC3B,qBAAqB,EACrB,QAAQ,EACR,mBAAmB,EACnB,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC5C;AAED,qBACa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAuB;;IAYrC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAqC;IAE1D,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI;IAIpD,OAAO,CAAC,MAAM,CAAC,SAAS;IASxB,OAAO,CAAC,eAAe;IAYvB,8EAA8E;IAC9E,WAAW,CAAC,CAAC,SAAS,eAAe,GAAG,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC;IAUzE,sCAAsC;IACtC,gBAAgB,IAAI,MAAM,EAAE;IAItB,qBAAqB,CACzB,OAAO,EAAE,4BAA4B,EACrC,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,2BAA2B,CAAC;IAIjC,cAAc,CAAC,OAAO,EAAE,qBAAqB,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAIxF,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAIhF,iBAAiB,CACrB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,wBAAwB,EACjC,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,uBAAuB,CAAC;IAI7B,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAIhG;;OAEG;IACH,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAI7F,mBAAmB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO;CAMpD"}

package/dist/payment.service.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Payment service that delegates to registered providers (Stripe, PayPal, etc.).
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var PaymentService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentService = void 0;
+const core_1 = require("@hazeljs/core");
+let PaymentService = PaymentService_1 = class PaymentService {
+    constructor() {
+        this.config = PaymentService_1.getConfig();
+        const names = Object.keys(this.config.providers);
+        if (names.length === 0) {
+            throw new Error('No payment providers registered. Call PaymentModule.forRoot({ providers: { stripe: new StripePaymentProvider(...) } }).');
+        }
+    }
+    static configure(config) {
+        PaymentService_1.config = config;
+    }
+    static getConfig() {
+        if (!PaymentService_1.config) {
+            throw new Error('PaymentModule not configured. Call PaymentModule.forRoot({ providers: { ... } }) in your app module.');
+        }
+        return PaymentService_1.config;
+    }
+    resolveProvider(providerName) {
+        const name = providerName ?? this.config.defaultProvider ?? Object.keys(this.config.providers)[0];
+        const provider = this.config.providers[name];
+        if (!provider) {
+            throw new Error(`Payment provider "${name}" not found. Registered: ${Object.keys(this.config.providers).join(', ')}.`);
+        }
+        return provider;
+    }
+    /** Get a provider by name for provider-specific APIs (e.g. Stripe client). */
+    getProvider(name) {
+        const provider = this.config.providers[name];
+        if (!provider) {
+            throw new Error(`Payment provider "${name}" not found. Registered: ${Object.keys(this.config.providers).join(', ')}.`);
+        }
+        return provider;
+    }
+    /** List registered provider names. */
+    getProviderNames() {
+        return Object.keys(this.config.providers);
+    }
+    async createCheckoutSession(options, providerName) {
+        return this.resolveProvider(providerName).createCheckoutSession(options);
+    }
+    async createCustomer(options, providerName) {
+        return this.resolveProvider(providerName).createCustomer(options);
+    }
+    async getCustomer(customerId, providerName) {
+        return this.resolveProvider(providerName).getCustomer(customerId);
+    }
+    async listSubscriptions(customerId, status, providerName) {
+        return this.resolveProvider(providerName).listSubscriptions(customerId, status);
+    }
+    async getCheckoutSession(sessionId, providerName) {
+        return this.resolveProvider(providerName).getCheckoutSession(sessionId);
+    }
+    /**
+     * Verify and parse a webhook event. Use the provider name that received the webhook (e.g. 'stripe').
+     */
+    parseWebhookEvent(providerName, payload, signature) {
+        return this.getProvider(providerName).parseWebhookEvent(payload, signature);
+    }
+    isWebhookConfigured(providerName) {
+        if (providerName) {
+            return this.getProvider(providerName).isWebhookConfigured();
+        }
+        return Object.values(this.config.providers).some((p) => p.isWebhookConfigured());
+    }
+};
+exports.PaymentService = PaymentService;
+PaymentService.config = null;
+exports.PaymentService = PaymentService = PaymentService_1 = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [])
+], PaymentService);

package/dist/payment.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=payment.service.test.d.ts.map

package/dist/payment.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment.service.test.d.ts","sourceRoot":"","sources":["../src/payment.service.test.ts"],"names":[],"mappings":""}

package/dist/payment.service.test.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const payment_service_1 = require("./payment.service");
+function createMockProvider(name) {
+    return {
+        name,
+        createCheckoutSession: jest
+            .fn()
+            .mockResolvedValue({ sessionId: `sess_${name}`, url: `https://pay.${name}.com/checkout` }),
+        createCustomer: jest.fn().mockResolvedValue({
+            id: `cus_${name}`,
+            email: 'test@example.com',
+            name: null,
+            metadata: {},
+        }),
+        getCustomer: jest.fn().mockResolvedValue({
+            id: `cus_${name}`,
+            email: 'test@example.com',
+            name: null,
+            metadata: {},
+        }),
+        listSubscriptions: jest
+            .fn()
+            .mockResolvedValue({ data: [{ id: 'sub_1', status: 'active', customerId: `cus_${name}` }] }),
+        getCheckoutSession: jest.fn().mockResolvedValue({
+            id: `sess_${name}`,
+            url: null,
+            customerId: `cus_${name}`,
+            status: 'complete',
+        }),
+        isWebhookConfigured: jest.fn().mockReturnValue(true),
+        parseWebhookEvent: jest.fn().mockReturnValue({ type: 'checkout.session.completed' }),
+    };
+}
+describe('PaymentService', () => {
+    const mockStripe = createMockProvider('stripe');
+    const mockPaypal = createMockProvider('paypal');
+    beforeEach(() => {
+        jest.clearAllMocks();
+        payment_service_1.PaymentService.configure({
+            providers: { stripe: mockStripe, paypal: mockPaypal },
+        });
+    });
+    afterEach(() => {
+        payment_service_1.PaymentService.configure({ providers: {} });
+    });
+    describe('constructor', () => {
+        it('uses first provider as default when no defaultProvider set', async () => {
+            const service = new payment_service_1.PaymentService();
+            const result = await service.createCheckoutSession({
+                successUrl: 'https://a.com/s',
+                cancelUrl: 'https://a.com/c',
+            });
+            expect(result.sessionId).toBe('sess_stripe');
+            expect(mockStripe.createCheckoutSession).toHaveBeenCalled();
+            expect(mockPaypal.createCheckoutSession).not.toHaveBeenCalled();
+        });
+        it('throws when no providers registered', () => {
+            payment_service_1.PaymentService.configure({ providers: {} });
+            expect(() => new payment_service_1.PaymentService()).toThrow('No payment providers registered');
+        });
+        it('throws when module not configured', () => {
+            payment_service_1.PaymentService.configure({ providers: {} });
+            payment_service_1.PaymentService.config = null;
+            expect(() => new payment_service_1.PaymentService()).toThrow('PaymentModule not configured');
+            payment_service_1.PaymentService.configure({ providers: { stripe: mockStripe } });
+        });
+    });
+    describe('defaultProvider', () => {
+        it('uses defaultProvider when set', async () => {
+            payment_service_1.PaymentService.configure({
+                defaultProvider: 'paypal',
+                providers: { stripe: mockStripe, paypal: mockPaypal },
+            });
+            const service = new payment_service_1.PaymentService();
+            const result = await service.createCheckoutSession({
+                successUrl: 'https://a.com/s',
+                cancelUrl: 'https://a.com/c',
+            });
+            expect(result.sessionId).toBe('sess_paypal');
+            expect(mockPaypal.createCheckoutSession).toHaveBeenCalled();
+        });
+        it('throws when defaultProvider is not in providers', async () => {
+            payment_service_1.PaymentService.configure({
+                defaultProvider: 'nonexistent',
+                providers: { stripe: mockStripe },
+            });
+            const service = new payment_service_1.PaymentService();
+            await expect(service.createCheckoutSession({
+                successUrl: 'https://a.com/s',
+                cancelUrl: 'https://a.com/c',
+            })).rejects.toThrow('Payment provider "nonexistent" not found');
+        });
+    });
+    describe('getProviderNames', () => {
+        it('returns registered provider names', () => {
+            const service = new payment_service_1.PaymentService();
+            expect(service.getProviderNames()).toEqual(['stripe', 'paypal']);
+        });
+    });
+    describe('getProvider', () => {
+        it('returns provider by name', () => {
+            const service = new payment_service_1.PaymentService();
+            const p = service.getProvider('paypal');
+            expect(p.name).toBe('paypal');
+        });
+        it('throws when provider not found', () => {
+            const service = new payment_service_1.PaymentService();
+            expect(() => service.getProvider('unknown')).toThrow('Payment provider "unknown" not found');
+        });
+    });
+    describe('createCheckoutSession', () => {
+        it('delegates to default provider without providerName', async () => {
+            const service = new payment_service_1.PaymentService();
+            const options = {
+                successUrl: 'https://a.com/s',
+                cancelUrl: 'https://a.com/c',
+                customerEmail: 'u@example.com',
+            };
+            await service.createCheckoutSession(options);
+            expect(mockStripe.createCheckoutSession).toHaveBeenCalledWith(options);
+        });
+        it('delegates to named provider when providerName given', async () => {
+            const service = new payment_service_1.PaymentService();
+            const options = {
+                successUrl: 'https://a.com/s',
+                cancelUrl: 'https://a.com/c',
+            };
+            await service.createCheckoutSession(options, 'paypal');
+            expect(mockPaypal.createCheckoutSession).toHaveBeenCalledWith(options);
+        });
+        it('throws when named provider does not exist', async () => {
+            const service = new payment_service_1.PaymentService();
+            await expect(service.createCheckoutSession({ successUrl: 'https://a.com/s', cancelUrl: 'https://a.com/c' }, 'nonexistent')).rejects.toThrow('Payment provider "nonexistent" not found');
+        });
+    });
+    describe('createCustomer', () => {
+        it('delegates to default provider', async () => {
+            const service = new payment_service_1.PaymentService();
+            const options = { email: 'new@example.com', name: 'Alice' };
+            const customer = await service.createCustomer(options);
+            expect(customer.id).toBe('cus_stripe');
+            expect(mockStripe.createCustomer).toHaveBeenCalledWith(options);
+        });
+        it('delegates to named provider', async () => {
+            const service = new payment_service_1.PaymentService();
+            await service.createCustomer({ email: 'b@example.com' }, 'paypal');
+            expect(mockPaypal.createCustomer).toHaveBeenCalledWith({ email: 'b@example.com' });
+        });
+    });
+    describe('getCustomer', () => {
+        it('delegates to default provider', async () => {
+            const service = new payment_service_1.PaymentService();
+            const customer = await service.getCustomer('cus_123');
+            expect(customer).not.toBeNull();
+            expect(mockStripe.getCustomer).toHaveBeenCalledWith('cus_123');
+        });
+        it('delegates to named provider', async () => {
+            const service = new payment_service_1.PaymentService();
+            await service.getCustomer('cus_456', 'paypal');
+            expect(mockPaypal.getCustomer).toHaveBeenCalledWith('cus_456');
+        });
+    });
+    describe('listSubscriptions', () => {
+        it('delegates to default provider', async () => {
+            const service = new payment_service_1.PaymentService();
+            const result = await service.listSubscriptions('cus_1');
+            expect(result.data).toHaveLength(1);
+            expect(mockStripe.listSubscriptions).toHaveBeenCalledWith('cus_1', undefined);
+        });
+        it('passes status when provided', async () => {
+            const service = new payment_service_1.PaymentService();
+            await service.listSubscriptions('cus_1', 'active', 'stripe');
+            expect(mockStripe.listSubscriptions).toHaveBeenCalledWith('cus_1', 'active');
+        });
+    });
+    describe('getCheckoutSession', () => {
+        it('delegates to default provider', async () => {
+            const service = new payment_service_1.PaymentService();
+            const session = await service.getCheckoutSession('sess_abc');
+            expect(session.id).toBe('sess_stripe');
+            expect(mockStripe.getCheckoutSession).toHaveBeenCalledWith('sess_abc');
+        });
+        it('delegates to named provider', async () => {
+            const service = new payment_service_1.PaymentService();
+            await service.getCheckoutSession('sess_xyz', 'paypal');
+            expect(mockPaypal.getCheckoutSession).toHaveBeenCalledWith('sess_xyz');
+        });
+    });
+    describe('parseWebhookEvent', () => {
+        it('delegates to named provider', () => {
+            const service = new payment_service_1.PaymentService();
+            const event = service.parseWebhookEvent('stripe', 'payload', 'sig');
+            expect(event).toEqual({ type: 'checkout.session.completed' });
+            expect(mockStripe.parseWebhookEvent).toHaveBeenCalledWith('payload', 'sig');
+        });
+        it('throws when provider not found', () => {
+            const service = new payment_service_1.PaymentService();
+            expect(() => service.parseWebhookEvent('unknown', 'p', 's')).toThrow('Payment provider "unknown" not found');
+        });
+    });
+    describe('isWebhookConfigured', () => {
+        it('returns true for named provider when configured', () => {
+            const service = new payment_service_1.PaymentService();
+            expect(service.isWebhookConfigured('stripe')).toBe(true);
+            expect(mockStripe.isWebhookConfigured).toHaveBeenCalled();
+        });
+        it('returns true when any provider has webhook configured', () => {
+            const service = new payment_service_1.PaymentService();
+            expect(service.isWebhookConfigured()).toBe(true);
+        });
+        it('returns false when no provider has webhook configured', () => {
+            mockStripe.isWebhookConfigured.mockReturnValue(false);
+            mockPaypal.isWebhookConfigured.mockReturnValue(false);
+            const service = new payment_service_1.PaymentService();
+            expect(service.isWebhookConfigured()).toBe(false);
+        });
+    });
+});

package/dist/providers/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Payment providers. Add new providers here and register in PaymentModule.
+ */
+export type { PaymentProvider } from './provider.interface';
+export type { ListSubscriptionsResult } from './provider.interface';
+export { StripePaymentProvider, STRIPE_PROVIDER_NAME } from './stripe/stripe.provider';
+export type { StripeProviderOptions, StripeWebhookEvent } from './stripe/stripe.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/providers/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACvF,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/providers/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Payment providers. Add new providers here and register in PaymentModule.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRIPE_PROVIDER_NAME = exports.StripePaymentProvider = void 0;
+var stripe_provider_1 = require("./stripe/stripe.provider");
+Object.defineProperty(exports, "StripePaymentProvider", { enumerable: true, get: function () { return stripe_provider_1.StripePaymentProvider; } });
+Object.defineProperty(exports, "STRIPE_PROVIDER_NAME", { enumerable: true, get: function () { return stripe_provider_1.STRIPE_PROVIDER_NAME; } });