@efaj/pulumi-dynamic-stripe 0.0.1 → 0.0.2-0dc4080

package/Makefile

@@ -0,0 +1,15 @@
+.PHONY: all install build test clean
+
+all: install build test
+
+install:
+	npm install
+
+build:
+	npm run build
+
+test:
+	npm test
+
+clean:
+	rm -rf dist node_modules package-lock.json

package/README.md

@@ -1,7 +1,7 @@
 # pulumi-dynamic-stripe
 
-![NPM Version](https://img.shields.io/npm/v/pulumi-dynamic-stripe)
-![License](https://img.shields.io/npm/l/pulumi-dynamic-stripe)
+![NPM Version](https://img.shields.io/npm/v/@efaj/pulumi-dynamic-stripe)
+![License](https://img.shields.io/npm/l/@efaj/pulumi-dynamic-stripe)
 [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fefaj%2Fpulumi-dynamic-stripe.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Fefaj%2Fpulumi-dynamic-stripe?ref=badge_shield)
 
 A native Pulumi Dynamic Provider for Stripe.
@@ -28,7 +28,7 @@ Contributions to add more dynamic providers for other Stripe resources are highl
 ## Installation
 
 ```bash
-npm install pulumi-dynamic-stripe
+npm install @efaj/pulumi-dynamic-stripe
 ```
 
 ## Usage
@@ -37,7 +37,7 @@ Here is a full example of provisioning a Product, attaching a Price to it, and g
 
 ```typescript
 import * as pulumi from "@pulumi/pulumi";
-import { Product, Price, PaymentLink } from "pulumi-dynamic-stripe";
+import { Product, Price, PaymentLink } from "@efaj/pulumi-dynamic-stripe";
 
 const config = new pulumi.Config();
 const stripeApiKey = config.requireSecret("stripeApiKey");
@@ -71,3 +71,26 @@ export const paymentUrl = premiumPaymentLink.url;
 ## How it works
 
 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`.
+
+```bash
+# Install dependencies
+make install
+
+# Build the TypeScript source
+make build
+
+# Run the Vitest test suite
+make test
+```

package/dist/StripePaymentLink.d.ts

@@ -0,0 +1,27 @@
+import * as pulumi from "@pulumi/pulumi";
+export interface StripePaymentLinkArgs {
+    apiKey: pulumi.Input<string>;
+    priceId: pulumi.Input<string>;
+    sparksAmount: pulumi.Input<string>;
+    redirectUrl: pulumi.Input<string>;
+    allowPromotionCodes?: pulumi.Input<boolean>;
+    managedPayments?: pulumi.Input<boolean>;
+}
+export interface StripePaymentLinkProviderArgs {
+    apiKey: string;
+    priceId: string;
+    sparksAmount: string;
+    redirectUrl: string;
+    allowPromotionCodes?: boolean;
+    managedPayments?: boolean;
+}
+export declare class StripePaymentLinkProvider implements pulumi.dynamic.ResourceProvider {
+    create(inputs: StripePaymentLinkProviderArgs): Promise<pulumi.dynamic.CreateResult>;
+    diff(id: string, olds: StripePaymentLinkProviderArgs, news: StripePaymentLinkProviderArgs): Promise<pulumi.dynamic.DiffResult>;
+    delete(id: string, props: StripePaymentLinkProviderArgs): Promise<void>;
+}
+export declare class PaymentLink extends pulumi.dynamic.Resource {
+    readonly url: pulumi.Output<string>;
+    readonly paymentLinkId: pulumi.Output<string>;
+    constructor(name: string, args: StripePaymentLinkArgs, opts?: pulumi.CustomResourceOptions);
+}

package/dist/StripePaymentLink.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentLink = exports.StripePaymentLinkProvider = void 0;
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const stripe_1 = __importDefault(require("stripe"));
+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,
+                    },
+                }],
+            after_completion: {
+                type: 'redirect',
+                redirect: {
+                    url: inputs.redirectUrl,
+                }
+            },
+            allow_promotion_codes: inputs.allowPromotionCodes,
+            ...(inputs.managedPayments ? { managed_payments: { enabled: true } } : {}),
+            metadata: {
+                sparks: inputs.sparksAmount
+            }
+        });
+        return {
+            id: paymentLink.id,
+            outs: {
+                ...inputs,
+                paymentLinkId: paymentLink.id,
+                url: paymentLink.url,
+            }
+        };
+    }
+    async diff(id, olds, news) {
+        const replaces = [];
+        if (olds.priceId !== news.priceId)
+            replaces.push("priceId");
+        if (olds.sparksAmount !== news.sparksAmount)
+            replaces.push("sparksAmount");
+        if (olds.redirectUrl !== news.redirectUrl)
+            replaces.push("redirectUrl");
+        if (olds.allowPromotionCodes !== news.allowPromotionCodes)
+            replaces.push("allowPromotionCodes");
+        if (olds.managedPayments !== news.managedPayments)
+            replaces.push("managedPayments");
+        if (olds.apiKey !== news.apiKey)
+            replaces.push("apiKey");
+        return {
+            changes: replaces.length > 0,
+            replaces,
+        };
+    }
+    async delete(id, props) {
+        const apiKey = props.apiKey || process.env.STRIPE_SECRET_KEY || process.env.STRIPE_API_KEY;
+        if (!apiKey) {
+            console.warn(`[StripePaymentLinkProvider] Skipping deletion of ${id} due to missing apiKey in state and environment variables.`);
+            return;
+        }
+        try {
+            const stripe = new stripe_1.default(apiKey);
+            await stripe.paymentLinks.update(id, { active: false });
+        }
+        catch (error) {
+            console.warn(`[StripePaymentLinkProvider] Failed to deactivate payment link ${id}:`, error);
+        }
+    }
+}
+exports.StripePaymentLinkProvider = StripePaymentLinkProvider;
+const stripePaymentLinkProvider = new StripePaymentLinkProvider();
+class PaymentLink extends pulumi.dynamic.Resource {
+    constructor(name, args, opts) {
+        super(stripePaymentLinkProvider, name, {
+            apiKey: args.apiKey,
+            priceId: args.priceId,
+            sparksAmount: args.sparksAmount,
+            redirectUrl: args.redirectUrl,
+            allowPromotionCodes: args.allowPromotionCodes,
+            managedPayments: args.managedPayments,
+            paymentLinkId: undefined,
+            url: undefined,
+        }, opts);
+    }
+}
+exports.PaymentLink = PaymentLink;

package/dist/StripePrice.d.ts

@@ -0,0 +1,22 @@
+import * as pulumi from "@pulumi/pulumi";
+export interface StripePriceArgs {
+    apiKey: pulumi.Input<string>;
+    productId: pulumi.Input<string>;
+    unitAmount: pulumi.Input<number>;
+    currency: pulumi.Input<string>;
+}
+export interface StripePriceProviderArgs {
+    apiKey: string;
+    productId: string;
+    unitAmount: number;
+    currency: string;
+}
+export declare class StripePriceProvider implements pulumi.dynamic.ResourceProvider {
+    create(inputs: StripePriceProviderArgs): Promise<pulumi.dynamic.CreateResult>;
+    diff(id: string, olds: StripePriceProviderArgs, news: StripePriceProviderArgs): Promise<pulumi.dynamic.DiffResult>;
+    delete(id: string, props: StripePriceProviderArgs): Promise<void>;
+}
+export declare class Price extends pulumi.dynamic.Resource {
+    readonly priceId: pulumi.Output<string>;
+    constructor(name: string, args: StripePriceArgs, opts?: pulumi.CustomResourceOptions);
+}

package/dist/StripePrice.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Price = exports.StripePriceProvider = void 0;
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const stripe_1 = __importDefault(require("stripe"));
+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,
+        });
+        return {
+            id: price.id,
+            outs: {
+                ...inputs,
+                priceId: price.id,
+            }
+        };
+    }
+    async diff(id, olds, news) {
+        const replaces = [];
+        if (olds.productId !== news.productId)
+            replaces.push("productId");
+        if (olds.unitAmount !== news.unitAmount)
+            replaces.push("unitAmount");
+        if (olds.currency !== news.currency)
+            replaces.push("currency");
+        if (olds.apiKey !== news.apiKey)
+            replaces.push("apiKey");
+        return {
+            changes: replaces.length > 0,
+            replaces,
+        };
+    }
+    async delete(id, props) {
+        const apiKey = props.apiKey || process.env.STRIPE_SECRET_KEY || process.env.STRIPE_API_KEY;
+        if (!apiKey) {
+            console.warn(`[StripePriceProvider] Skipping deletion of ${id} due to missing apiKey in state and environment variables.`);
+            return;
+        }
+        try {
+            const stripe = new stripe_1.default(apiKey);
+            await stripe.prices.update(id, { active: false });
+        }
+        catch (error) {
+            console.warn(`[StripePriceProvider] Failed to deactivate price ${id}:`, error);
+        }
+    }
+}
+exports.StripePriceProvider = StripePriceProvider;
+const stripePriceProvider = new StripePriceProvider();
+class Price extends pulumi.dynamic.Resource {
+    constructor(name, args, opts) {
+        super(stripePriceProvider, name, { ...args, priceId: undefined }, opts);
+    }
+}
+exports.Price = Price;

package/dist/StripeProduct.d.ts

@@ -0,0 +1,23 @@
+import * as pulumi from "@pulumi/pulumi";
+export interface StripeProductArgs {
+    apiKey: pulumi.Input<string>;
+    name: pulumi.Input<string>;
+    description?: pulumi.Input<string>;
+    taxCode?: pulumi.Input<string>;
+}
+export interface StripeProductProviderArgs {
+    apiKey: string;
+    name: string;
+    description?: string;
+    taxCode?: string;
+}
+export declare class StripeProductProvider implements pulumi.dynamic.ResourceProvider {
+    create(inputs: StripeProductProviderArgs): Promise<pulumi.dynamic.CreateResult>;
+    diff(id: string, olds: StripeProductProviderArgs, news: StripeProductProviderArgs): Promise<pulumi.dynamic.DiffResult>;
+    update(id: string, olds: StripeProductProviderArgs, news: StripeProductProviderArgs): Promise<pulumi.dynamic.UpdateResult>;
+    delete(id: string, props: StripeProductProviderArgs): Promise<void>;
+}
+export declare class Product extends pulumi.dynamic.Resource {
+    readonly productId: pulumi.Output<string>;
+    constructor(name: string, args: StripeProductArgs, opts?: pulumi.CustomResourceOptions);
+}

package/dist/StripeProduct.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Product = exports.StripeProductProvider = void 0;
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const stripe_1 = __importDefault(require("stripe"));
+class StripeProductProvider {
+    async create(inputs) {
+        const stripe = new stripe_1.default(inputs.apiKey);
+        const product = await stripe.products.create({
+            name: inputs.name,
+            description: inputs.description,
+            tax_code: inputs.taxCode,
+        });
+        return {
+            id: product.id,
+            outs: {
+                ...inputs,
+                productId: product.id,
+            }
+        };
+    }
+    async diff(id, olds, news) {
+        const changes = [];
+        if (olds.name !== news.name)
+            changes.push("name");
+        if (olds.description !== news.description)
+            changes.push("description");
+        if (olds.taxCode !== news.taxCode)
+            changes.push("taxCode");
+        if (olds.apiKey !== news.apiKey)
+            changes.push("apiKey");
+        return {
+            changes: changes.length > 0,
+            replaces: [], // None require replacement, all can be updated
+        };
+    }
+    async update(id, olds, news) {
+        const stripe = new stripe_1.default(news.apiKey);
+        await stripe.products.update(id, {
+            name: news.name,
+            description: news.description,
+            tax_code: news.taxCode,
+        });
+        return {
+            outs: {
+                ...news,
+                productId: id,
+            }
+        };
+    }
+    async delete(id, props) {
+        const apiKey = props.apiKey || process.env.STRIPE_SECRET_KEY || process.env.STRIPE_API_KEY;
+        if (!apiKey) {
+            console.warn(`[StripeProductProvider] Skipping deletion of ${id} due to missing apiKey in state and environment variables.`);
+            return;
+        }
+        try {
+            const stripe = new stripe_1.default(apiKey);
+            await stripe.products.update(id, { active: false });
+        }
+        catch (error) {
+            console.warn(`[StripeProductProvider] Failed to deactivate product ${id}:`, error);
+        }
+    }
+}
+exports.StripeProductProvider = StripeProductProvider;
+const stripeProductProvider = new StripeProductProvider();
+class Product extends pulumi.dynamic.Resource {
+    constructor(name, args, opts) {
+        super(stripeProductProvider, name, { ...args, productId: undefined }, opts);
+    }
+}
+exports.Product = Product;

package/dist/index.d.ts

@@ -1,33 +1,3 @@
-import * as pulumi from "@pulumi/pulumi";
-interface StripePaymentLinkArgs {
-    apiKey: pulumi.Input<string>;
-    priceId: pulumi.Input<string>;
-    sparksAmount: pulumi.Input<string>;
-    redirectUrl: pulumi.Input<string>;
-    allowPromotionCodes?: pulumi.Input<boolean>;
-}
-export declare class PaymentLink extends pulumi.dynamic.Resource {
-    readonly url: pulumi.Output<string>;
-    readonly paymentLinkId: pulumi.Output<string>;
-    constructor(name: string, args: StripePaymentLinkArgs, opts?: any);
-}
-interface StripeProductArgs {
-    apiKey: pulumi.Input<string>;
-    name: pulumi.Input<string>;
-    description?: pulumi.Input<string>;
-}
-export declare class Product extends pulumi.dynamic.Resource {
-    readonly productId: pulumi.Output<string>;
-    constructor(name: string, args: StripeProductArgs, opts?: any);
-}
-interface StripePriceArgs {
-    apiKey: pulumi.Input<string>;
-    productId: pulumi.Input<string>;
-    unitAmount: pulumi.Input<number>;
-    currency: pulumi.Input<string>;
-}
-export declare class Price extends pulumi.dynamic.Resource {
-    readonly priceId: pulumi.Output<string>;
-    constructor(name: string, args: StripePriceArgs, opts?: any);
-}
-export {};
+export * from "./StripePaymentLink";
+export * from "./StripeProduct";
+export * from "./StripePrice";

package/dist/index.js

@@ -10,153 +10,10 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Price = exports.Product = exports.PaymentLink = void 0;
-const pulumi = __importStar(require("@pulumi/pulumi"));
-// @ts-ignore
-const stripe_1 = __importDefault(require("stripe"));
-class StripePaymentLinkProvider {
-    async create(inputs) {
-        const stripe = new stripe_1.default(inputs.apiKey, { apiVersion: '2022-11-15' }); // Using older API version to avoid typings mismatch if any
-        const paymentLink = await stripe.paymentLinks.create({
-            line_items: [{
-                    price: inputs.priceId,
-                    quantity: 1,
-                    adjustable_quantity: {
-                        enabled: true,
-                        minimum: 1,
-                        maximum: 100,
-                    },
-                }],
-            after_completion: {
-                type: 'redirect',
-                redirect: {
-                    url: inputs.redirectUrl,
-                }
-            },
-            allow_promotion_codes: inputs.allowPromotionCodes,
-            metadata: {
-                sparks: inputs.sparksAmount
-            }
-        });
-        return {
-            id: paymentLink.id,
-            outs: {
-                ...inputs,
-                paymentLinkId: paymentLink.id,
-                url: paymentLink.url,
-            }
-        };
-    }
-    async delete(id, props) {
-        const stripe = new stripe_1.default(props.apiKey, { apiVersion: '2022-11-15' });
-        // Payment links cannot be deleted, but they can be deactivated
-        await stripe.paymentLinks.update(id, { active: false });
-    }
-}
-const stripePaymentLinkProvider = new StripePaymentLinkProvider();
-class PaymentLink extends pulumi.dynamic.Resource {
-    constructor(name, args, opts) {
-        super(stripePaymentLinkProvider, name, {
-            apiKey: args.apiKey,
-            priceId: args.priceId,
-            sparksAmount: args.sparksAmount,
-            redirectUrl: args.redirectUrl,
-            allowPromotionCodes: args.allowPromotionCodes,
-            paymentLinkId: undefined,
-            url: undefined,
-        }, opts);
-    }
-}
-exports.PaymentLink = PaymentLink;
-class StripeProductProvider {
-    async create(inputs) {
-        const stripe = new stripe_1.default(inputs.apiKey, { apiVersion: '2022-11-15' });
-        const product = await stripe.products.create({
-            name: inputs.name,
-            description: inputs.description,
-        });
-        return {
-            id: product.id,
-            outs: {
-                ...inputs,
-                productId: product.id,
-            }
-        };
-    }
-    async update(id, olds, news) {
-        const stripe = new stripe_1.default(news.apiKey, { apiVersion: '2022-11-15' });
-        await stripe.products.update(id, {
-            name: news.name,
-            description: news.description,
-        });
-        return {
-            outs: {
-                ...news,
-                productId: id,
-            }
-        };
-    }
-    async delete(id, props) {
-        const stripe = new stripe_1.default(props.apiKey, { apiVersion: '2022-11-15' });
-        await stripe.products.update(id, { active: false });
-    }
-}
-class Product extends pulumi.dynamic.Resource {
-    constructor(name, args, opts) {
-        super(new StripeProductProvider(), name, { ...args, productId: undefined }, opts);
-    }
-}
-exports.Product = Product;
-class StripePriceProvider {
-    async create(inputs) {
-        const stripe = new stripe_1.default(inputs.apiKey, { apiVersion: '2022-11-15' });
-        const price = await stripe.prices.create({
-            product: inputs.productId,
-            unit_amount: inputs.unitAmount,
-            currency: inputs.currency,
-        });
-        return {
-            id: price.id,
-            outs: {
-                ...inputs,
-                priceId: price.id,
-            }
-        };
-    }
-    async delete(id, props) {
-        const stripe = new stripe_1.default(props.apiKey, { apiVersion: '2022-11-15' });
-        await stripe.prices.update(id, { active: false });
-    }
-}
-class Price extends pulumi.dynamic.Resource {
-    constructor(name, args, opts) {
-        super(new StripePriceProvider(), name, { ...args, priceId: undefined }, opts);
-    }
-}
-exports.Price = Price;
+__exportStar(require("./StripePaymentLink"), exports);
+__exportStar(require("./StripeProduct"), exports);
+__exportStar(require("./StripePrice"), exports);

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.1",
+  "version": "0.0.2-0dc4080",
   "description": "A Pulumi Dynamic Provider for Stripe, supporting modern features like Payment Links.",
   "keywords": [
     "pulumi",
@@ -21,7 +21,8 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "prepare": "tsc"
+    "prepare": "tsc",
+    "test": "vitest run"
   },
   "dependencies": {
     "@pulumi/pulumi": "^3.259.0",
@@ -29,6 +30,7 @@
   },
   "devDependencies": {
     "@types/node": "^26.4.0",
+    "vitest": "^2.0.5",
     "typescript": "^6.0.3"
   }
 }

package/tests/index.test.ts

@@ -0,0 +1,551 @@
+import { StripePaymentLinkProvider, StripeProductProvider, StripePriceProvider } from "../src/index";
+import Stripe from "stripe";
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { Mock } from 'vitest';
+
+// Mock the Stripe SDK
+vi.mock("stripe");
+
+const MockedStripe = Stripe as any;
+
+describe("Stripe Providers", () => {
+    let mockPaymentLinksCreate: Mock<any>;
+    let mockPaymentLinksUpdate: Mock<any>;
+    let mockProductsCreate: Mock<any>;
+    let mockProductsUpdate: Mock<any>;
+    let mockPricesCreate: Mock<any>;
+    let mockPricesUpdate: Mock<any>;
+
+    beforeEach(() => {
+        // Reset mocks before each test
+        vi.clearAllMocks();
+
+        mockPaymentLinksCreate = vi.fn<any>().mockResolvedValue({ id: "plink_123", url: "https://stripe.com/plink_123" } as any);
+        mockPaymentLinksUpdate = vi.fn<any>().mockResolvedValue({ id: "plink_123" } as any);
+        
+        mockProductsCreate = vi.fn<any>().mockResolvedValue({ id: "prod_123" } as any);
+        mockProductsUpdate = vi.fn<any>().mockResolvedValue({ id: "prod_123" } as any);
+        
+        mockPricesCreate = vi.fn<any>().mockResolvedValue({ id: "price_123" } as any);
+        mockPricesUpdate = vi.fn<any>().mockResolvedValue({ id: "price_123" } as any);
+
+        // Setup the mocked Stripe instance's internal resource objects
+        MockedStripe.mockImplementation(() => {
+            return {
+                paymentLinks: {
+                    create: mockPaymentLinksCreate,
+                    update: mockPaymentLinksUpdate,
+                },
+                products: {
+                    create: mockProductsCreate,
+                    update: mockProductsUpdate,
+                },
+                prices: {
+                    create: mockPricesCreate,
+                    update: mockPricesUpdate,
+                },
+            } as any;
+        });
+    });
+
+    describe("StripePaymentLinkProvider", () => {
+        const provider = new StripePaymentLinkProvider();
+
+        describe("create", () => {
+            const createCases = [
+                {
+                    name: "all properties provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        priceId: "price_abc",
+                        sparksAmount: "100",
+                        redirectUrl: "https://example.com/success",
+                        allowPromotionCodes: true,
+                        managedPayments: true,
+                    },
+                    expectedPayload: {
+                        line_items: [{
+                            price: "price_abc",
+                            quantity: 1,
+                            adjustable_quantity: { enabled: true, minimum: 1, maximum: 100 },
+                        }],
+                        after_completion: { type: 'redirect', redirect: { url: "https://example.com/success" } },
+                        allow_promotion_codes: true,
+                        managed_payments: { enabled: true },
+                        metadata: { sparks: "100" }
+                    }
+                },
+                {
+                    name: "only required properties provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        priceId: "price_abc",
+                        sparksAmount: "50",
+                        redirectUrl: "https://example.com/success",
+                    },
+                    expectedPayload: {
+                        line_items: [{
+                            price: "price_abc",
+                            quantity: 1,
+                            adjustable_quantity: { enabled: true, minimum: 1, maximum: 100 },
+                        }],
+                        after_completion: { type: 'redirect', redirect: { url: "https://example.com/success" } },
+                        allow_promotion_codes: undefined,
+                        metadata: { sparks: "50" }
+                    }
+                }
+            ];
+
+            it.each(createCases)("should correctly map Pulumi inputs to Stripe API payload when $name", async ({ inputs, expectedPayload }) => {
+                const result = await provider.create(inputs as any);
+
+                expect(result.id).toBe("plink_123");
+                expect(result.outs?.paymentLinkId).toBe("plink_123");
+                expect(result.outs?.url).toBe("https://stripe.com/plink_123");
+                
+                expect(MockedStripe).toHaveBeenCalledWith(inputs.apiKey);
+                expect(mockPaymentLinksCreate).toHaveBeenCalledWith(expectedPayload);
+            });
+        });
+
+        describe("diff", () => {
+            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" },
+                    expectedChanges: true,
+                    expectedReplaces: ["priceId", "sparksAmount", "redirectUrl", "allowPromotionCodes", "managedPayments", "apiKey"]
+                },
+                {
+                    name: "some properties change",
+                    olds: { priceId: "old", sparksAmount: "10", redirectUrl: "url1" },
+                    news: { priceId: "old", sparksAmount: "20", redirectUrl: "url1" },
+                    expectedChanges: true,
+                    expectedReplaces: ["sparksAmount"]
+                },
+                {
+                    name: "no properties change",
+                    olds: { priceId: "same", sparksAmount: "10" },
+                    news: { priceId: "same", sparksAmount: "10" },
+                    expectedChanges: false,
+                    expectedReplaces: []
+                }
+            ];
+
+            it.each(diffCases)("should correctly detect diff when $name", async ({ olds, news, expectedChanges, expectedReplaces }) => {
+                const diffResult = await provider.diff("plink_123", olds as any, news as any);
+                expect(diffResult.changes).toBe(expectedChanges);
+                expect(diffResult.replaces).toEqual(expect.arrayContaining(expectedReplaces));
+                expect(diffResult.replaces?.length).toBe(expectedReplaces.length);
+            });
+        });
+
+        describe("delete", () => {
+            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;
+            });
+        });
+    });
+
+    describe("StripeProductProvider", () => {
+        const provider = new StripeProductProvider();
+
+        describe("create", () => {
+            const createCases = [
+                {
+                    name: "all properties provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        name: "Full Product",
+                        description: "A complete product",
+                        taxCode: "txcd_123",
+                    },
+                    expectedPayload: {
+                        name: "Full Product",
+                        description: "A complete product",
+                        tax_code: "txcd_123",
+                    }
+                },
+                {
+                    name: "only required properties provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        name: "Minimal Product",
+                    },
+                    expectedPayload: {
+                        name: "Minimal Product",
+                        description: undefined,
+                        tax_code: undefined,
+                    }
+                }
+            ];
+
+            it.each(createCases)("should correctly create a product when $name", async ({ inputs, expectedPayload }) => {
+                const result = await provider.create(inputs as any);
+
+                expect(result.id).toBe("prod_123");
+                expect(result.outs?.productId).toBe("prod_123");
+                
+                expect(MockedStripe).toHaveBeenCalledWith(inputs.apiKey);
+                expect(mockProductsCreate).toHaveBeenCalledWith(expectedPayload);
+            });
+        });
+
+        describe("diff", () => {
+            const diffCases = [
+                {
+                    name: "all properties change",
+                    olds: { name: "old name", description: "old desc", taxCode: "tx_1", apiKey: "old_key" },
+                    news: { name: "new name", description: "new desc", taxCode: "tx_2", apiKey: "new_key" },
+                    expectedChanges: true,
+                },
+                {
+                    name: "some properties change",
+                    olds: { name: "old name", description: "old desc" },
+                    news: { name: "old name", description: "new desc" },
+                    expectedChanges: true,
+                },
+                {
+                    name: "no properties change",
+                    olds: { name: "same name", description: "same desc" },
+                    news: { name: "same name", description: "same desc" },
+                    expectedChanges: false,
+                }
+            ];
+
+            it.each(diffCases)("should correctly detect diff when $name", async ({ olds, news, expectedChanges }) => {
+                const diffResult = await provider.diff("prod_123", olds as any, news as any);
+                expect(diffResult.changes).toBe(expectedChanges);
+                expect(diffResult.replaces).toHaveLength(0);
+            });
+        });
+
+        describe("update", () => {
+            it("should correctly update a product", async () => {
+                const result = await provider.update("prod_123", 
+                    { apiKey: "sk_test_123", name: "Old Name" } as any,
+                    { apiKey: "sk_test_123", name: "New Name", description: "New Desc", taxCode: "txcd_999" } as any
+                );
+
+                expect(result.outs?.productId).toBe("prod_123");
+                expect(result.outs?.name).toBe("New Name");
+                
+                expect(mockProductsUpdate).toHaveBeenCalledWith("prod_123", {
+                    name: "New Name",
+                    description: "New Desc",
+                    tax_code: "txcd_999",
+                });
+            });
+        });
+
+        describe("delete", () => {
+            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;
+            });
+        });
+    });
+
+    describe("StripePriceProvider", () => {
+        const provider = new StripePriceProvider();
+
+        describe("create", () => {
+            const createCases = [
+                {
+                    name: "required properties provided",
+                    inputs: {
+                        apiKey: "sk_test_123",
+                        productId: "prod_123",
+                        unitAmount: 1000,
+                        currency: "usd",
+                    },
+                    expectedPayload: {
+                        product: "prod_123",
+                        unit_amount: 1000,
+                        currency: "usd",
+                    }
+                }
+            ];
+
+            it.each(createCases)("should correctly create a price when $name", async ({ inputs, expectedPayload }) => {
+                const result = await provider.create(inputs as any);
+
+                expect(result.id).toBe("price_123");
+                expect(result.outs?.priceId).toBe("price_123");
+                
+                expect(MockedStripe).toHaveBeenCalledWith(inputs.apiKey);
+                expect(mockPricesCreate).toHaveBeenCalledWith(expectedPayload);
+            });
+        });
+
+        describe("diff", () => {
+            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" },
+                    expectedChanges: true,
+                    expectedReplaces: ["productId", "unitAmount", "currency", "apiKey"]
+                },
+                {
+                    name: "some properties change",
+                    olds: { productId: "prod_1", unitAmount: 100, currency: "usd" },
+                    news: { productId: "prod_1", unitAmount: 200, currency: "usd" },
+                    expectedChanges: true,
+                    expectedReplaces: ["unitAmount"]
+                },
+                {
+                    name: "no properties change",
+                    olds: { productId: "prod_1", unitAmount: 100, currency: "usd" },
+                    news: { productId: "prod_1", unitAmount: 100, currency: "usd" },
+                    expectedChanges: false,
+                    expectedReplaces: []
+                }
+            ];
+
+            it.each(diffCases)("should correctly detect diff when $name", async ({ olds, news, expectedChanges, expectedReplaces }) => {
+                const diffResult = await provider.diff("price_123", olds as any, news as any);
+                expect(diffResult.changes).toBe(expectedChanges);
+                expect(diffResult.replaces).toEqual(expect.arrayContaining(expectedReplaces));
+                expect(diffResult.replaces?.length).toBe(expectedReplaces.length);
+            });
+        });
+
+        describe("delete", () => {
+            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;
+            });
+        });
+    });
+});

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+});