@efaj/pulumi-dynamic-stripe 0.0.2-bfb0df3 → 0.1.0-5ac2a7e

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [0.1.0](https://github.com/efaj/pulumi-dynamic-stripe/compare/v0.0.2...v0.1.0) (2026-08-28)
+
+
+### Features
+
+* Handle delete case w/o apiKey gracefully ([0639e18](https://github.com/efaj/pulumi-dynamic-stripe/commit/0639e18beff72d6d4fe251be171e2e2e4bc47bda))

package/README.md

@@ -72,6 +72,14 @@ export const paymentUrl = premiumPaymentLink.url;
 
 Behind the scenes, this library defines custom Pulumi Dynamic Resource Providers that implement the CRUD operations for Stripe entities via the `@pulumi/pulumi` and `stripe` Node packages.
 
+## Resource Deletion & State Fallbacks
+
+Stripe entities generally cannot be hard-deleted via the API; instead, this provider safely **deactivates** them (e.g., setting `active: false` on Payment Links, Products, and Prices) when Pulumi destroys the resource.
+
+Due to the way Pulumi manages dynamic provider state, if an input property like `apiKey` is not explicitly declared as a public output on the resource class, it may be scrubbed from the state file. When Pulumi attempts to delete a replaced or destroyed resource, it reads from the old state. If the `apiKey` is missing from the state during deletion, the provider will gracefully attempt to fall back to the `STRIPE_SECRET_KEY` or `STRIPE_API_KEY` environment variables. 
+
+If no API key is found in the state or environment variables, the provider will log a warning and **skip the Stripe deactivation (NoOp)** to allow Pulumi to successfully finish deleting the resource from its internal state without crashing.
+
 ## Development
 
 If you wish to contribute or build the project locally, please use the provided `Makefile`.
@@ -86,3 +94,11 @@ make build
 # Run the Vitest test suite
 make test
 ```
+
+### Contributing & Releases
+
+This project uses [Release Please](https://github.com/googleapis/release-please) to automate versioning, changelog generation, and NPM publishing. 
+
+When contributing, you **must** format your commit messages using [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) (e.g., `feat: add new resource`, `fix: handle edge case`). 
+
+When your PR is merged into `main`, Release Please will automatically open a "Release PR" bumping the semantic version and updating the `CHANGELOG.md`. Merging that Release PR will trigger the GitHub Action to cut a GitHub Release and publish the new version to NPM.

package/dist/StripePaymentLink.d.ts

@@ -6,6 +6,13 @@ export interface StripePaymentLinkArgs {
     redirectUrl: pulumi.Input<string>;
     allowPromotionCodes?: pulumi.Input<boolean>;
     managedPayments?: pulumi.Input<boolean>;
+    automaticTax?: pulumi.Input<boolean>;
+    quantity?: pulumi.Input<number>;
+    adjustableQuantity?: pulumi.Input<{
+        enabled: boolean;
+        minimum?: number;
+        maximum?: number;
+    }>;
 }
 export interface StripePaymentLinkProviderArgs {
     apiKey: string;
@@ -14,6 +21,13 @@ export interface StripePaymentLinkProviderArgs {
     redirectUrl: string;
     allowPromotionCodes?: boolean;
     managedPayments?: boolean;
+    automaticTax?: boolean;
+    quantity?: number;
+    adjustableQuantity?: {
+        enabled: boolean;
+        minimum?: number;
+        maximum?: number;
+    };
 }
 export declare class StripePaymentLinkProvider implements pulumi.dynamic.ResourceProvider {
     create(inputs: StripePaymentLinkProviderArgs): Promise<pulumi.dynamic.CreateResult>;

package/dist/StripePaymentLink.js

@@ -39,18 +39,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaymentLink = exports.StripePaymentLinkProvider = void 0;
 const pulumi = __importStar(require("@pulumi/pulumi"));
 const stripe_1 = __importDefault(require("stripe"));
+const utils_1 = require("./utils");
 class StripePaymentLinkProvider {
     async create(inputs) {
         const stripe = new stripe_1.default(inputs.apiKey);
         const paymentLink = await stripe.paymentLinks.create({
             line_items: [{
                     price: inputs.priceId,
-                    quantity: 1,
-                    adjustable_quantity: {
-                        enabled: true,
-                        minimum: 1,
-                        maximum: 100,
-                    },
+                    quantity: inputs.quantity ?? 1,
+                    ...(inputs.adjustableQuantity !== undefined
+                        ? (inputs.adjustableQuantity.enabled
+                            ? { adjustable_quantity: inputs.adjustableQuantity }
+                            : {})
+                        : {
+                            adjustable_quantity: {
+                                enabled: true,
+                                minimum: 1,
+                                maximum: 100,
+                            },
+                        }),
                 }],
             after_completion: {
                 type: 'redirect',
@@ -60,6 +67,7 @@ class StripePaymentLinkProvider {
             },
             allow_promotion_codes: inputs.allowPromotionCodes,
             ...(inputs.managedPayments ? { managed_payments: { enabled: true } } : {}),
+            ...(inputs.automaticTax ? { automatic_tax: { enabled: true } } : {}),
             metadata: {
                 sparks: inputs.sparksAmount
             }
@@ -85,16 +93,21 @@ class StripePaymentLinkProvider {
             replaces.push("allowPromotionCodes");
         if (olds.managedPayments !== news.managedPayments)
             replaces.push("managedPayments");
+        if (olds.automaticTax !== news.automaticTax)
+            replaces.push("automaticTax");
         if (olds.apiKey !== news.apiKey)
             replaces.push("apiKey");
+        if (olds.quantity !== news.quantity)
+            replaces.push("quantity");
+        if (JSON.stringify(olds.adjustableQuantity) !== JSON.stringify(news.adjustableQuantity))
+            replaces.push("adjustableQuantity");
         return {
             changes: replaces.length > 0,
             replaces,
         };
     }
     async delete(id, props) {
-        const stripe = new stripe_1.default(props.apiKey);
-        await stripe.paymentLinks.update(id, { active: false });
+        await (0, utils_1.safeDeactivateStripeResource)("StripePaymentLinkProvider", id, props.apiKey, async (stripe) => { await stripe.paymentLinks.update(id, { active: false }); });
     }
 }
 exports.StripePaymentLinkProvider = StripePaymentLinkProvider;
@@ -108,6 +121,9 @@ class PaymentLink extends pulumi.dynamic.Resource {
             redirectUrl: args.redirectUrl,
             allowPromotionCodes: args.allowPromotionCodes,
             managedPayments: args.managedPayments,
+            automaticTax: args.automaticTax,
+            quantity: args.quantity,
+            adjustableQuantity: args.adjustableQuantity,
             paymentLinkId: undefined,
             url: undefined,
         }, opts);

package/dist/StripePrice.d.ts

@@ -1,15 +1,56 @@
 import * as pulumi from "@pulumi/pulumi";
+import { TaxBehavior, BillingScheme, TiersMode, RecurringInterval, UsageType } from "./enums";
+export interface RecurringArgs {
+    interval: pulumi.Input<RecurringInterval>;
+    intervalCount?: pulumi.Input<number>;
+    usageType?: pulumi.Input<UsageType>;
+}
+export interface TierArgs {
+    upTo: pulumi.Input<number | "inf">;
+    unitAmount?: pulumi.Input<number>;
+    flatAmount?: pulumi.Input<number>;
+}
+export interface TransformQuantityArgs {
+    divideBy: pulumi.Input<number>;
+    round: pulumi.Input<"up" | "down">;
+}
 export interface StripePriceArgs {
     apiKey: pulumi.Input<string>;
     productId: pulumi.Input<string>;
-    unitAmount: pulumi.Input<number>;
     currency: pulumi.Input<string>;
+    unitAmount?: pulumi.Input<number>;
+    taxBehavior?: pulumi.Input<TaxBehavior>;
+    recurring?: pulumi.Input<RecurringArgs>;
+    billingScheme?: pulumi.Input<BillingScheme>;
+    tiersMode?: pulumi.Input<TiersMode>;
+    tiers?: pulumi.Input<pulumi.Input<TierArgs>[]>;
+    transformQuantity?: pulumi.Input<TransformQuantityArgs>;
+}
+export interface RecurringProviderArgs {
+    interval: RecurringInterval;
+    intervalCount?: number;
+    usageType?: UsageType;
+}
+export interface TierProviderArgs {
+    upTo: number | "inf";
+    unitAmount?: number;
+    flatAmount?: number;
+}
+export interface TransformQuantityProviderArgs {
+    divideBy: number;
+    round: "up" | "down";
 }
 export interface StripePriceProviderArgs {
     apiKey: string;
     productId: string;
-    unitAmount: number;
     currency: string;
+    unitAmount?: number;
+    taxBehavior?: TaxBehavior;
+    recurring?: RecurringProviderArgs;
+    billingScheme?: BillingScheme;
+    tiersMode?: TiersMode;
+    tiers?: TierProviderArgs[];
+    transformQuantity?: TransformQuantityProviderArgs;
 }
 export declare class StripePriceProvider implements pulumi.dynamic.ResourceProvider {
     create(inputs: StripePriceProviderArgs): Promise<pulumi.dynamic.CreateResult>;

package/dist/StripePrice.js

@@ -39,13 +39,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Price = exports.StripePriceProvider = void 0;
 const pulumi = __importStar(require("@pulumi/pulumi"));
 const stripe_1 = __importDefault(require("stripe"));
+const utils_1 = require("./utils");
 class StripePriceProvider {
     async create(inputs) {
         const stripe = new stripe_1.default(inputs.apiKey);
         const price = await stripe.prices.create({
             product: inputs.productId,
-            unit_amount: inputs.unitAmount,
             currency: inputs.currency,
+            ...(inputs.unitAmount !== undefined ? { unit_amount: inputs.unitAmount } : {}),
+            tax_behavior: inputs.taxBehavior,
+            ...(inputs.recurring ? {
+                recurring: {
+                    interval: inputs.recurring.interval,
+                    interval_count: inputs.recurring.intervalCount,
+                    usage_type: inputs.recurring.usageType,
+                }
+            } : {}),
+            billing_scheme: inputs.billingScheme,
+            tiers_mode: inputs.tiersMode,
+            ...(inputs.tiers ? {
+                tiers: inputs.tiers.map(t => ({
+                    up_to: t.upTo,
+                    unit_amount: t.unitAmount,
+                    flat_amount: t.flatAmount,
+                }))
+            } : {}),
+            ...(inputs.transformQuantity ? {
+                transform_quantity: {
+                    divide_by: inputs.transformQuantity.divideBy,
+                    round: inputs.transformQuantity.round,
+                }
+            } : {}),
         });
         return {
             id: price.id,
@@ -63,6 +87,18 @@ class StripePriceProvider {
             replaces.push("unitAmount");
         if (olds.currency !== news.currency)
             replaces.push("currency");
+        if (olds.taxBehavior !== news.taxBehavior)
+            replaces.push("taxBehavior");
+        if (JSON.stringify(olds.recurring) !== JSON.stringify(news.recurring))
+            replaces.push("recurring");
+        if (olds.billingScheme !== news.billingScheme)
+            replaces.push("billingScheme");
+        if (olds.tiersMode !== news.tiersMode)
+            replaces.push("tiersMode");
+        if (JSON.stringify(olds.tiers) !== JSON.stringify(news.tiers))
+            replaces.push("tiers");
+        if (JSON.stringify(olds.transformQuantity) !== JSON.stringify(news.transformQuantity))
+            replaces.push("transformQuantity");
         if (olds.apiKey !== news.apiKey)
             replaces.push("apiKey");
         return {
@@ -71,8 +107,7 @@ class StripePriceProvider {
         };
     }
     async delete(id, props) {
-        const stripe = new stripe_1.default(props.apiKey);
-        await stripe.prices.update(id, { active: false });
+        await (0, utils_1.safeDeactivateStripeResource)("StripePriceProvider", id, props.apiKey, async (stripe) => { await stripe.prices.update(id, { active: false }); });
     }
 }
 exports.StripePriceProvider = StripePriceProvider;

package/dist/StripeProduct.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Product = exports.StripeProductProvider = void 0;
 const pulumi = __importStar(require("@pulumi/pulumi"));
 const stripe_1 = __importDefault(require("stripe"));
+const utils_1 = require("./utils");
 class StripeProductProvider {
     async create(inputs) {
         const stripe = new stripe_1.default(inputs.apiKey);
@@ -85,8 +86,7 @@ class StripeProductProvider {
         };
     }
     async delete(id, props) {
-        const stripe = new stripe_1.default(props.apiKey);
-        await stripe.products.update(id, { active: false });
+        await (0, utils_1.safeDeactivateStripeResource)("StripeProductProvider", id, props.apiKey, async (stripe) => { await stripe.products.update(id, { active: false }); });
     }
 }
 exports.StripeProductProvider = StripeProductProvider;

package/dist/enums.d.ts

@@ -0,0 +1,23 @@
+export declare enum TaxBehavior {
+    Inclusive = "inclusive",
+    Exclusive = "exclusive",
+    Unspecified = "unspecified"
+}
+export declare enum BillingScheme {
+    PerUnit = "per_unit",
+    Tiered = "tiered"
+}
+export declare enum TiersMode {
+    Graduated = "graduated",
+    Volume = "volume"
+}
+export declare enum RecurringInterval {
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Year = "year"
+}
+export declare enum UsageType {
+    Metered = "metered",
+    Licensed = "licensed"
+}

package/dist/enums.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageType = exports.RecurringInterval = exports.TiersMode = exports.BillingScheme = exports.TaxBehavior = void 0;
+var TaxBehavior;
+(function (TaxBehavior) {
+    TaxBehavior["Inclusive"] = "inclusive";
+    TaxBehavior["Exclusive"] = "exclusive";
+    TaxBehavior["Unspecified"] = "unspecified";
+})(TaxBehavior || (exports.TaxBehavior = TaxBehavior = {}));
+var BillingScheme;
+(function (BillingScheme) {
+    BillingScheme["PerUnit"] = "per_unit";
+    BillingScheme["Tiered"] = "tiered";
+})(BillingScheme || (exports.BillingScheme = BillingScheme = {}));
+var TiersMode;
+(function (TiersMode) {
+    TiersMode["Graduated"] = "graduated";
+    TiersMode["Volume"] = "volume";
+})(TiersMode || (exports.TiersMode = TiersMode = {}));
+var RecurringInterval;
+(function (RecurringInterval) {
+    RecurringInterval["Day"] = "day";
+    RecurringInterval["Week"] = "week";
+    RecurringInterval["Month"] = "month";
+    RecurringInterval["Year"] = "year";
+})(RecurringInterval || (exports.RecurringInterval = RecurringInterval = {}));
+var UsageType;
+(function (UsageType) {
+    UsageType["Metered"] = "metered";
+    UsageType["Licensed"] = "licensed";
+})(UsageType || (exports.UsageType = UsageType = {}));

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./StripePaymentLink";
 export * from "./StripeProduct";
 export * from "./StripePrice";
+export * from "./enums";

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./StripePaymentLink"), exports);
 __exportStar(require("./StripeProduct"), exports);
 __exportStar(require("./StripePrice"), exports);
+__exportStar(require("./enums"), exports);

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import Stripe from "stripe";
+/**
+ * Safely deactivates a Stripe resource during Pulumi deletion.
+ * Falls back to environment variables if the apiKey is missing from state.
+ * Prevents Pulumi state engine crashes when a resource cannot be deactivated.
+ */
+export declare function safeDeactivateStripeResource(providerName: string, resourceId: string, apiKeyFromState: string | undefined, deactivateFn: (stripe: Stripe) => Promise<void>): Promise<void>;

package/dist/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeDeactivateStripeResource = safeDeactivateStripeResource;
+const stripe_1 = __importDefault(require("stripe"));
+/**
+ * Safely deactivates a Stripe resource during Pulumi deletion.
+ * Falls back to environment variables if the apiKey is missing from state.
+ * Prevents Pulumi state engine crashes when a resource cannot be deactivated.
+ */
+async function safeDeactivateStripeResource(providerName, resourceId, apiKeyFromState, deactivateFn) {
+    const apiKey = apiKeyFromState || process.env.STRIPE_SECRET_KEY || process.env.STRIPE_API_KEY;
+    if (!apiKey) {
+        console.warn(`[${providerName}] Skipping deletion of ${resourceId} due to missing apiKey in state and environment variables.`);
+        return;
+    }
+    try {
+        const stripe = new stripe_1.default(apiKey);
+        await deactivateFn(stripe);
+    }
+    catch (error) {
+        console.warn(`[${providerName}] Failed to deactivate ${resourceId}:`, error);
+    }
+}

package/docs/troubleshooting-stuck-state.md

@@ -0,0 +1,63 @@
+# Troubleshooting Stuck State in Pulumi Dynamic Providers
+
+## The Problem
+
+When using `pulumi-dynamic-stripe` versions **0.0.1** and **0.0.2**, you might encounter an issue where Pulumi fails to delete a Stripe resource (e.g., a Payment Link) during a `pulumi up`, `pulumi destroy`, or replacement operation.
+
+The stack will show the resource as `deleting failed` with an error similar to this:
+
+```
+Error: Neither apiKey nor config.authenticator provided
+    at Stripe._setAuthenticator (node_modules/stripe/src/stripe.core.ts:1319:13)
+```
+
+## Why This Happens
+
+This is fundamentally caused by how Pulumi Dynamic Providers function under the hood. 
+
+When you deploy a resource using a Dynamic Provider, Pulumi takes the **JavaScript source code of your provider methods** (like `create`, `update`, `diff`, and importantly `delete`) and **serializes the compiled code directly into the Pulumi state file in the cloud**.
+
+In versions `0.0.1` and `0.0.2` of this library, the `delete` method had a bug where it crashed if it couldn't find an API key in the Pulumi state (due to how state diffs and replacement work). Although we patched this bug in the library's source code by adding environment variable fallbacks and `try/catch` handlers, **Pulumi does not use your newly updated local code to delete older resources.**
+
+Instead, Pulumi downloads the *old, buggy, serialized `delete` function* that was saved in the cloud during the resource's initial creation, and attempts to run it. When that old code inevitably crashes, the resource gets stuck in a perpetual `deleting failed` state.
+
+## The Solution
+
+Since you cannot fix an old resource's deletion behavior by updating your local provider package, you must manually excise the corrupted resource from the Pulumi state.
+
+### Step 1: Export the Pulumi State
+First, export your stack's state to a local JSON file:
+```bash
+pulumi stack export > state.json
+```
+
+### Step 2: Identify and Remove the Corrupted Resource
+Open `state.json` in a text editor and search for the resource that is stuck. You are looking for a JSON object in the `deployment.resources` array that matches your resource's URN and has `"delete": true` set.
+
+For example, look for something like this and **delete the entire JSON object from the array**:
+```json
+{
+    "urn": "urn:pulumi:prod.quiz.crenet-games::quizai-infrastructure::pulumi-nodejs:dynamic:Resource::sparks-link",
+    "custom": true,
+    "delete": true,
+    "id": "plink_1U8pkf1i5elBtkZIXxmnduNm",
+    "type": "pulumi-nodejs:dynamic:Resource",
+    "inputs": { ... }
+}
+```
+
+*Alternatively, you can script this step using Node or `jq`.*
+
+### Step 3: Import the Fixed State
+Once the offending resource object is removed from the JSON array, save the file and import it back to Pulumi:
+```bash
+pulumi stack import --file state.json
+```
+
+### Step 4: Re-run Pulumi Up
+Now that the stuck state is gone, Pulumi will no longer attempt to run the broken deletion hook. Run your update command:
+```bash
+pulumi up -y
+```
+
+Moving forward, any new resources created by the updated provider will have the new, robust, crash-free `delete` function serialized into the state, permanently solving this issue.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efaj/pulumi-dynamic-stripe",
-  "version": "0.0.2-bfb0df3",
+  "version": "0.1.0-5ac2a7e",
   "description": "A Pulumi Dynamic Provider for Stripe, supporting modern features like Payment Links.",
   "keywords": [
     "pulumi",

package/tests/index.test.ts

@@ -62,6 +62,7 @@ describe("Stripe Providers", () => {
                         redirectUrl: "https://example.com/success",
                         allowPromotionCodes: true,
                         managedPayments: true,
+                        automaticTax: true,
                     },
                     expectedPayload: {
                         line_items: [{
@@ -72,6 +73,7 @@ describe("Stripe Providers", () => {
                         after_completion: { type: 'redirect', redirect: { url: "https://example.com/success" } },
                         allow_promotion_codes: true,
                         managed_payments: { enabled: true },
+                        automatic_tax: { enabled: true },
                         metadata: { sparks: "100" }
                     }
                 },
@@ -93,6 +95,27 @@ describe("Stripe Providers", () => {
                         allow_promotion_codes: undefined,
                         metadata: { sparks: "50" }
                     }
+                },
+                {
+                    name: "custom quantity and adjustableQuantity provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        priceId: "price_abc",
+                        sparksAmount: "100",
+                        redirectUrl: "https://example.com/success",
+                        quantity: 5,
+                        adjustableQuantity: { enabled: true, maximum: 5 }
+                    },
+                    expectedPayload: {
+                        line_items: [{
+                            price: "price_abc",
+                            quantity: 5,
+                            adjustable_quantity: { enabled: true, maximum: 5 },
+                        }],
+                        after_completion: { type: 'redirect', redirect: { url: "https://example.com/success" } },
+                        allow_promotion_codes: undefined,
+                        metadata: { sparks: "100" }
+                    }
                 }
             ];
 
@@ -112,10 +135,10 @@ describe("Stripe Providers", () => {
             const diffCases = [
                 {
                     name: "all properties change",
-                    olds: { priceId: "old", sparksAmount: "10", redirectUrl: "url1", allowPromotionCodes: false, managedPayments: false, apiKey: "old_key" },
-                    news: { priceId: "new", sparksAmount: "20", redirectUrl: "url2", allowPromotionCodes: true, managedPayments: true, apiKey: "new_key" },
+                    olds: { priceId: "old", sparksAmount: "10", redirectUrl: "url1", allowPromotionCodes: false, managedPayments: false, automaticTax: false, quantity: 1, adjustableQuantity: { enabled: true }, apiKey: "old_key" },
+                    news: { priceId: "new", sparksAmount: "20", redirectUrl: "url2", allowPromotionCodes: true, managedPayments: true, automaticTax: true, quantity: 2, adjustableQuantity: { enabled: false }, apiKey: "new_key" },
                     expectedChanges: true,
-                    expectedReplaces: ["priceId", "sparksAmount", "redirectUrl", "allowPromotionCodes", "managedPayments", "apiKey"]
+                    expectedReplaces: ["priceId", "sparksAmount", "redirectUrl", "allowPromotionCodes", "managedPayments", "automaticTax", "apiKey", "quantity", "adjustableQuantity"]
                 },
                 {
                     name: "some properties change",
@@ -124,6 +147,20 @@ describe("Stripe Providers", () => {
                     expectedChanges: true,
                     expectedReplaces: ["sparksAmount"]
                 },
+                {
+                    name: "quantity changes",
+                    olds: { priceId: "same", sparksAmount: "10", quantity: 1 },
+                    news: { priceId: "same", sparksAmount: "10", quantity: 2 },
+                    expectedChanges: true,
+                    expectedReplaces: ["quantity"]
+                },
+                {
+                    name: "adjustableQuantity changes",
+                    olds: { priceId: "same", sparksAmount: "10", adjustableQuantity: { enabled: true, minimum: 1, maximum: 10 } },
+                    news: { priceId: "same", sparksAmount: "10", adjustableQuantity: { enabled: true, minimum: 2, maximum: 10 } },
+                    expectedChanges: true,
+                    expectedReplaces: ["adjustableQuantity"]
+                },
                 {
                     name: "no properties change",
                     olds: { priceId: "same", sparksAmount: "10" },
@@ -142,9 +179,85 @@ describe("Stripe Providers", () => {
         });
 
         describe("delete", () => {
-            it("should deactivate the payment link", async () => {
-                await provider.delete("plink_123", { apiKey: "sk_test_123" } as any);
-                expect(mockPaymentLinksUpdate).toHaveBeenCalledWith("plink_123", { active: false });
+            const deleteCases = [
+                {
+                    name: "apiKey is in state",
+                    state: { apiKey: "sk_test_state" },
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: "sk_test_state",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing, falls back to STRIPE_SECRET_KEY",
+                    state: {},
+                    envSecret: "sk_test_secret",
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: "sk_test_secret",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing, falls back to STRIPE_API_KEY",
+                    state: {},
+                    envSecret: undefined,
+                    envApi: "sk_test_api",
+                    mockError: false,
+                    expectStripeInit: "sk_test_api",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing everywhere (NoOp)",
+                    state: {},
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: null,
+                    expectUpdate: false,
+                },
+                {
+                    name: "Stripe SDK throws an error (caught safely)",
+                    state: { apiKey: "sk_test_error" },
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: true,
+                    expectStripeInit: "sk_test_error",
+                    expectUpdate: true,
+                }
+            ];
+
+            it.each(deleteCases)("should handle deletion when $name", async ({ state, envSecret, envApi, mockError, expectStripeInit, expectUpdate }) => {
+                const originalSecret = process.env.STRIPE_SECRET_KEY;
+                const originalApi = process.env.STRIPE_API_KEY;
+                
+                if (envSecret !== undefined) process.env.STRIPE_SECRET_KEY = envSecret;
+                else delete process.env.STRIPE_SECRET_KEY;
+
+                if (envApi !== undefined) process.env.STRIPE_API_KEY = envApi;
+                else delete process.env.STRIPE_API_KEY;
+
+                if (mockError) {
+                    mockPaymentLinksUpdate.mockRejectedValueOnce(new Error("Stripe error"));
+                }
+
+                await provider.delete("plink_123", state as any);
+
+                if (expectStripeInit) {
+                    expect(MockedStripe).toHaveBeenCalledWith(expectStripeInit);
+                }
+                
+                if (expectUpdate) {
+                    expect(mockPaymentLinksUpdate).toHaveBeenCalledWith("plink_123", { active: false });
+                } else {
+                    expect(mockPaymentLinksUpdate).not.toHaveBeenCalled();
+                }
+
+                if (originalSecret !== undefined) process.env.STRIPE_SECRET_KEY = originalSecret;
+                else delete process.env.STRIPE_SECRET_KEY;
+                
+                if (originalApi !== undefined) process.env.STRIPE_API_KEY = originalApi;
+                else delete process.env.STRIPE_API_KEY;
             });
         });
     });
@@ -241,9 +354,85 @@ describe("Stripe Providers", () => {
         });
 
         describe("delete", () => {
-            it("should deactivate the product on delete", async () => {
-                await provider.delete("prod_123", { apiKey: "sk_test_123" } as any);
-                expect(mockProductsUpdate).toHaveBeenCalledWith("prod_123", { active: false });
+            const deleteCases = [
+                {
+                    name: "apiKey is in state",
+                    state: { apiKey: "sk_test_state" },
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: "sk_test_state",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing, falls back to STRIPE_SECRET_KEY",
+                    state: {},
+                    envSecret: "sk_test_secret",
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: "sk_test_secret",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing, falls back to STRIPE_API_KEY",
+                    state: {},
+                    envSecret: undefined,
+                    envApi: "sk_test_api",
+                    mockError: false,
+                    expectStripeInit: "sk_test_api",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing everywhere (NoOp)",
+                    state: {},
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: null,
+                    expectUpdate: false,
+                },
+                {
+                    name: "Stripe SDK throws an error (caught safely)",
+                    state: { apiKey: "sk_test_error" },
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: true,
+                    expectStripeInit: "sk_test_error",
+                    expectUpdate: true,
+                }
+            ];
+
+            it.each(deleteCases)("should handle deletion when $name", async ({ state, envSecret, envApi, mockError, expectStripeInit, expectUpdate }) => {
+                const originalSecret = process.env.STRIPE_SECRET_KEY;
+                const originalApi = process.env.STRIPE_API_KEY;
+                
+                if (envSecret !== undefined) process.env.STRIPE_SECRET_KEY = envSecret;
+                else delete process.env.STRIPE_SECRET_KEY;
+
+                if (envApi !== undefined) process.env.STRIPE_API_KEY = envApi;
+                else delete process.env.STRIPE_API_KEY;
+
+                if (mockError) {
+                    mockProductsUpdate.mockRejectedValueOnce(new Error("Stripe error"));
+                }
+
+                await provider.delete("prod_123", state as any);
+
+                if (expectStripeInit) {
+                    expect(MockedStripe).toHaveBeenCalledWith(expectStripeInit);
+                }
+                
+                if (expectUpdate) {
+                    expect(mockProductsUpdate).toHaveBeenCalledWith("prod_123", { active: false });
+                } else {
+                    expect(mockProductsUpdate).not.toHaveBeenCalled();
+                }
+
+                if (originalSecret !== undefined) process.env.STRIPE_SECRET_KEY = originalSecret;
+                else delete process.env.STRIPE_SECRET_KEY;
+                
+                if (originalApi !== undefined) process.env.STRIPE_API_KEY = originalApi;
+                else delete process.env.STRIPE_API_KEY;
             });
         });
     });
@@ -253,6 +442,22 @@ describe("Stripe Providers", () => {
 
         describe("create", () => {
             const createCases = [
+                {
+                    name: "all properties provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        productId: "prod_123",
+                        unitAmount: 1000,
+                        currency: "usd",
+                        taxBehavior: "inclusive",
+                    },
+                    expectedPayload: {
+                        product: "prod_123",
+                        unit_amount: 1000,
+                        currency: "usd",
+                        tax_behavior: "inclusive",
+                    }
+                },
                 {
                     name: "required properties provided",
                     inputs: {
@@ -265,6 +470,63 @@ describe("Stripe Providers", () => {
                         product: "prod_123",
                         unit_amount: 1000,
                         currency: "usd",
+                        tax_behavior: undefined,
+                    }
+                },
+                {
+                    name: "recurring pricing provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        productId: "prod_123",
+                        unitAmount: 1000,
+                        currency: "usd",
+                        recurring: { interval: "month", intervalCount: 1, usageType: "licensed" }
+                    },
+                    expectedPayload: {
+                        product: "prod_123",
+                        unit_amount: 1000,
+                        currency: "usd",
+                        recurring: { interval: "month", interval_count: 1, usage_type: "licensed" }
+                    }
+                },
+                {
+                    name: "tiered pricing provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        productId: "prod_123",
+                        currency: "usd",
+                        billingScheme: "tiered",
+                        tiersMode: "volume",
+                        tiers: [
+                            { upTo: 10, unitAmount: 1000 },
+                            { upTo: "inf", unitAmount: 800 }
+                        ]
+                    },
+                    expectedPayload: {
+                        product: "prod_123",
+                        currency: "usd",
+                        billing_scheme: "tiered",
+                        tiers_mode: "volume",
+                        tiers: [
+                            { up_to: 10, unit_amount: 1000, flat_amount: undefined },
+                            { up_to: "inf", unit_amount: 800, flat_amount: undefined }
+                        ]
+                    }
+                },
+                {
+                    name: "package pricing provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        productId: "prod_123",
+                        unitAmount: 5000,
+                        currency: "usd",
+                        transformQuantity: { divideBy: 5, round: "up" }
+                    },
+                    expectedPayload: {
+                        product: "prod_123",
+                        unit_amount: 5000,
+                        currency: "usd",
+                        transform_quantity: { divide_by: 5, round: "up" }
                     }
                 }
             ];
@@ -284,10 +546,17 @@ describe("Stripe Providers", () => {
             const diffCases = [
                 {
                     name: "all properties change",
-                    olds: { productId: "prod_1", unitAmount: 100, currency: "usd", apiKey: "old_key" },
-                    news: { productId: "prod_2", unitAmount: 200, currency: "eur", apiKey: "new_key" },
+                    olds: { productId: "prod_1", unitAmount: 100, currency: "usd", taxBehavior: "inclusive", apiKey: "old_key" },
+                    news: { productId: "prod_2", unitAmount: 200, currency: "eur", taxBehavior: "exclusive", apiKey: "new_key" },
                     expectedChanges: true,
-                    expectedReplaces: ["productId", "unitAmount", "currency", "apiKey"]
+                    expectedReplaces: ["productId", "unitAmount", "currency", "taxBehavior", "apiKey"]
+                },
+                {
+                    name: "pricing models properties change",
+                    olds: { productId: "prod_1", currency: "usd", recurring: { interval: "month" }, billingScheme: "per_unit", tiersMode: "volume", tiers: [{ upTo: 10 }], transformQuantity: { divideBy: 5 } },
+                    news: { productId: "prod_1", currency: "usd", recurring: { interval: "year" }, billingScheme: "tiered", tiersMode: "graduated", tiers: [{ upTo: 20 }], transformQuantity: { divideBy: 10 } },
+                    expectedChanges: true,
+                    expectedReplaces: ["recurring", "billingScheme", "tiersMode", "tiers", "transformQuantity"]
                 },
                 {
                     name: "some properties change",
@@ -314,9 +583,85 @@ describe("Stripe Providers", () => {
         });
 
         describe("delete", () => {
-            it("should deactivate the price on delete", async () => {
-                await provider.delete("price_123", { apiKey: "sk_test_123" } as any);
-                expect(mockPricesUpdate).toHaveBeenCalledWith("price_123", { active: false });
+            const deleteCases = [
+                {
+                    name: "apiKey is in state",
+                    state: { apiKey: "sk_test_state" },
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: "sk_test_state",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing, falls back to STRIPE_SECRET_KEY",
+                    state: {},
+                    envSecret: "sk_test_secret",
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: "sk_test_secret",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing, falls back to STRIPE_API_KEY",
+                    state: {},
+                    envSecret: undefined,
+                    envApi: "sk_test_api",
+                    mockError: false,
+                    expectStripeInit: "sk_test_api",
+                    expectUpdate: true,
+                },
+                {
+                    name: "apiKey is missing everywhere (NoOp)",
+                    state: {},
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: false,
+                    expectStripeInit: null,
+                    expectUpdate: false,
+                },
+                {
+                    name: "Stripe SDK throws an error (caught safely)",
+                    state: { apiKey: "sk_test_error" },
+                    envSecret: undefined,
+                    envApi: undefined,
+                    mockError: true,
+                    expectStripeInit: "sk_test_error",
+                    expectUpdate: true,
+                }
+            ];
+
+            it.each(deleteCases)("should handle deletion when $name", async ({ state, envSecret, envApi, mockError, expectStripeInit, expectUpdate }) => {
+                const originalSecret = process.env.STRIPE_SECRET_KEY;
+                const originalApi = process.env.STRIPE_API_KEY;
+                
+                if (envSecret !== undefined) process.env.STRIPE_SECRET_KEY = envSecret;
+                else delete process.env.STRIPE_SECRET_KEY;
+
+                if (envApi !== undefined) process.env.STRIPE_API_KEY = envApi;
+                else delete process.env.STRIPE_API_KEY;
+
+                if (mockError) {
+                    mockPricesUpdate.mockRejectedValueOnce(new Error("Stripe error"));
+                }
+
+                await provider.delete("price_123", state as any);
+
+                if (expectStripeInit) {
+                    expect(MockedStripe).toHaveBeenCalledWith(expectStripeInit);
+                }
+                
+                if (expectUpdate) {
+                    expect(mockPricesUpdate).toHaveBeenCalledWith("price_123", { active: false });
+                } else {
+                    expect(mockPricesUpdate).not.toHaveBeenCalled();
+                }
+
+                if (originalSecret !== undefined) process.env.STRIPE_SECRET_KEY = originalSecret;
+                else delete process.env.STRIPE_SECRET_KEY;
+                
+                if (originalApi !== undefined) process.env.STRIPE_API_KEY = originalApi;
+                else delete process.env.STRIPE_API_KEY;
             });
         });
     });