fix(provider): accept payment behavior from param

accept payment behavior from param

GH-21

Author: Piyush Singh Gaur

src/__tests__/unit/stripe-subscription.service.unit.ts

@@ -2,6 +2,7 @@ import {expect, sinon} from '@loopback/testlab';
 import {StripeService} from '../../providers/sdk/stripe/stripe.service';
 import {
   CollectionMethod,
+  PaymentBehavior,
   ProrationBehavior,
   RecurringInterval,
   TPrice,
@@ -253,19 +254,52 @@ describe('StripeService - Subscription Management', () => {
       expect(callArg.collection_method).to.equal(CollectionMethod.SEND_INVOICE);
     });
 
-    it('uses defaultPaymentBehavior from StripeConfig when provided', async () => {
-      // Create a separate service instance with a custom payment behavior so
-      // callers are not forced to use the SCA-default 'default_incomplete'.
+    it('uses per-call paymentBehavior when provided on TSubscriptionCreate', async () => {
+      stripeStub.subscriptions.create.resolves({id: 'sub_custom_003'});
+
+      await service.createSubscription({
+        customerId: 'cus_custom',
+        priceRefId: 'price_abc',
+        collectionMethod: CollectionMethod.CHARGE_AUTOMATICALLY,
+        paymentBehavior: PaymentBehavior.ALLOW_INCOMPLETE,
+      });
+
+      const callArg = stripeStub.subscriptions.create.firstCall.args[0];
+      expect(callArg.payment_behavior).to.equal('allow_incomplete');
+    });
+
+    it('per-call paymentBehavior takes priority over StripeConfig.defaultPaymentBehavior', async () => {
+      // Config says 'error_if_incomplete', but the per-call param overrides it.
+      const customService = new StripeService({
+        secretKey: 'sk_test_dummy',
+        defaultPaymentBehavior: 'error_if_incomplete',
+      });
+      (customService as unknown as {stripe: StubbedStripe}).stripe = stripeStub;
+
+      stripeStub.subscriptions.create.resolves({id: 'sub_override_004'});
+
+      await customService.createSubscription({
+        customerId: 'cus_override',
+        priceRefId: 'price_abc',
+        collectionMethod: CollectionMethod.CHARGE_AUTOMATICALLY,
+        paymentBehavior: PaymentBehavior.ALLOW_INCOMPLETE,
+      });
+
+      const callArg = stripeStub.subscriptions.create.firstCall.args[0];
+      expect(callArg.payment_behavior).to.equal('allow_incomplete');
+    });
+
+    it('falls back to StripeConfig.defaultPaymentBehavior when no per-call value given', async () => {
       const customService = new StripeService({
         secretKey: 'sk_test_dummy',
         defaultPaymentBehavior: 'allow_incomplete',
       });
       (customService as unknown as {stripe: StubbedStripe}).stripe = stripeStub;
 
-      stripeStub.subscriptions.create.resolves({id: 'sub_custom_003'});
+      stripeStub.subscriptions.create.resolves({id: 'sub_config_005'});
 
       await customService.createSubscription({
-        customerId: 'cus_custom',
+        customerId: 'cus_config',
         priceRefId: 'price_abc',
         collectionMethod: CollectionMethod.CHARGE_AUTOMATICALLY,
       });
@@ -274,8 +308,8 @@ describe('StripeService - Subscription Management', () => {
       expect(callArg.payment_behavior).to.equal('allow_incomplete');
     });
 
-    it('falls back to default_incomplete when defaultPaymentBehavior is not configured', async () => {
-      stripeStub.subscriptions.create.resolves({id: 'sub_default_004'});
+    it('falls back to default_incomplete when neither per-call nor config is provided', async () => {
+      stripeStub.subscriptions.create.resolves({id: 'sub_default_006'});
 
       await service.createSubscription({
         customerId: 'cus_fallback',

src/keys.ts

@@ -1,6 +1,6 @@
 import {BindingKey, CoreBindings} from '@loopback/core';
 import {BillingComponent} from './component';
-import {IService, ISubscriptionService} from './types';
+import {IService} from './types';
 
 /**
  * Binding keys used by this component.
@@ -12,13 +12,4 @@ export namespace BillingComponentBindings {
   export const BillingProvider = BindingKey.create<IService>('sf.billing');
   export const SDKProvider = BindingKey.create<IService>('sf.billing.sdk');
   export const RestProvider = BindingKey.create<IService>('sf.billing.rest');
-  /**
-   * Binding key for a provider that implements the full subscription lifecycle
-   * ({@link ISubscriptionService}). Bind your extended StripeService (or any
-   * other gateway implementation) here so controllers and services can inject
-   * subscription capabilities independently of one-time billing.
-   */
-  export const SubscriptionProvider = BindingKey.create<ISubscriptionService>(
-    'sf.billing.subscription',
-  );
 }

src/providers/sdk/stripe/stripe.service.ts

@@ -332,7 +332,8 @@ export class StripeService implements IStripeService {
     const params = this.stripeSubscriptionAdapter.adaptFromModel(subscription);
     const created = await this.stripe.subscriptions.create({
       ...params,
-      payment_behavior: (this.stripeConfig.defaultPaymentBehavior ??
+      payment_behavior: (subscription.paymentBehavior ??
+        this.stripeConfig.defaultPaymentBehavior ??
         'default_incomplete') as Stripe.SubscriptionCreateParams.PaymentBehavior,
     });
     return created.id;

src/providers/sdk/stripe/type/index.ts

@@ -5,7 +5,7 @@ import {IService, ISubscriptionService} from '../../../../types';
  * and recurring-subscription management ({@link ISubscriptionService}).
  *
  * Implementors can bind to {@link BillingComponentBindings.SDKProvider} for
- * one-time billing OR to {@link BillingComponentBindings.SubscriptionProvider}
+ * one-time billing OR to {@link BillingComponentBindings.SDKProvider}
  * for subscription operations, depending on their needs (ISP).
  */
 export interface IStripeService extends IService, ISubscriptionService {}

src/providers/sdk/stripe/type/stripe-config.type.ts

@@ -2,12 +2,13 @@ import Stripe from 'stripe';
 export interface StripeConfig {
   secretKey: string;
   /**
-   * Controls how Stripe handles payment during subscription creation.
-   * Defaults to `'default_incomplete'` (SCA-compliant: subscription starts
-   * incomplete until the first payment is confirmed).
+   * Global fallback for Stripe payment behaviour during subscription creation.
+   * Defaults to `'default_incomplete'` when neither this nor a per-call
+   * `TSubscriptionCreate.paymentBehavior` is provided.
    *
-   * Set to `'allow_incomplete'` or `'error_if_incomplete'` to change the
-   * behaviour for your integration.
+   * Per-call `paymentBehavior` on `TSubscriptionCreate` takes highest priority,
+   * so different subscriptions can use different behaviours without changing
+   * this global setting.
    *
    * @see https://stripe.com/docs/api/subscriptions/create#create_subscription-payment_behavior
    */

src/types.ts

@@ -141,6 +141,20 @@ export enum RecurringInterval {
   YEAR = 'year',
 }
 
+/**
+ * Controls how Stripe handles payment collection during subscription creation.
+ * Pass this per-call on {@link TSubscriptionCreate.paymentBehavior}; falls back
+ * to `StripeConfig.defaultPaymentBehavior`, then `'default_incomplete'`.
+ *
+ * @see https://stripe.com/docs/api/subscriptions/create#create_subscription-payment_behavior
+ */
+export enum PaymentBehavior {
+  DEFAULT_INCOMPLETE = 'default_incomplete',
+  ALLOW_INCOMPLETE = 'allow_incomplete',
+  ERROR_IF_INCOMPLETE = 'error_if_incomplete',
+  PENDING_IF_INCOMPLETE = 'pending_if_incomplete',
+}
+
 /**
  * Controls how prorations are calculated when a subscription is updated.
  */
@@ -186,6 +200,12 @@ export interface TSubscriptionCreate {
   collectionMethod: CollectionMethod;
   /** Number of days after which the invoice is due (applicable for send_invoice). */
   daysUntilDue?: number;
+  /**
+   * Stripe-specific: controls payment behaviour during subscription creation.
+   * Takes highest priority over `StripeConfig.defaultPaymentBehavior`.
+   * Ignored by non-Stripe providers.
+   */
+  paymentBehavior?: PaymentBehavior;
 }
 
 /**