@efaj/pulumi-dynamic-stripe 0.0.2-bfb0df3 → 0.1.0-06c6e41

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/Makefile

@@ -1,6 +1,6 @@
-.PHONY: all install build test clean
+.PHONY: all install build lint test clean
 
-all: install build test
+all: install build lint test
 
 install:
 	npm install
@@ -8,6 +8,9 @@ install:
 build:
 	npm run build
 
+lint:
+	npm run lint
+
 test:
 	npm test
 

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`.
@@ -83,6 +91,17 @@ make install
 # Build the TypeScript source
 make build
 
+# Lint the codebase
+make lint
+
 # 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/biome.json

@@ -0,0 +1,37 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.5.11/schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
+	},
+	"files": {
+		"includes": ["**", "!!**/dist"]
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"preset": "recommended",
+			"suspicious": {
+				"noExplicitAny": "off"
+			}
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

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,10 +21,17 @@ 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>;
-    diff(id: string, olds: StripePaymentLinkProviderArgs, news: StripePaymentLinkProviderArgs): Promise<pulumi.dynamic.DiffResult>;
+    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 {

package/dist/StripePaymentLink.js

@@ -39,30 +39,42 @@ 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: [{
+            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',
+                type: "redirect",
                 redirect: {
                     url: inputs.redirectUrl,
-                }
+                },
             },
             allow_promotion_codes: inputs.allowPromotionCodes,
-            ...(inputs.managedPayments ? { managed_payments: { enabled: true } } : {}),
+            ...(inputs.managedPayments
+                ? { managed_payments: { enabled: true } }
+                : {}),
+            ...(inputs.automaticTax ? { automatic_tax: { enabled: true } } : {}),
             metadata: {
-                sparks: inputs.sparksAmount
-            }
+                sparks: inputs.sparksAmount,
+            },
         });
         return {
             id: paymentLink.id,
@@ -70,10 +82,10 @@ class StripePaymentLinkProvider {
                 ...inputs,
                 paymentLinkId: paymentLink.id,
                 url: paymentLink.url,
-            }
+            },
         };
     }
-    async diff(id, olds, news) {
+    async diff(_id, olds, news) {
         const replaces = [];
         if (olds.priceId !== news.priceId)
             replaces.push("priceId");
@@ -85,16 +97,24 @@ 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 +128,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,19 +1,60 @@
 import * as pulumi from "@pulumi/pulumi";
+import type { BillingScheme, RecurringInterval, TaxBehavior, TiersMode, 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>;
-    diff(id: string, olds: StripePriceProviderArgs, news: StripePriceProviderArgs): Promise<pulumi.dynamic.DiffResult>;
+    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 {

package/dist/StripePrice.js

@@ -39,23 +39,55 @@ 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,
             outs: {
                 ...inputs,
                 priceId: price.id,
-            }
+            },
         };
     }
-    async diff(id, olds, news) {
+    async diff(_id, olds, news) {
         const replaces = [];
         if (olds.productId !== news.productId)
             replaces.push("productId");
@@ -63,6 +95,19 @@ 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 +116,9 @@ 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.d.ts

@@ -13,8 +13,8 @@ export interface StripeProductProviderArgs {
 }
 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>;
+    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 {

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);
@@ -52,10 +53,10 @@ class StripeProductProvider {
             outs: {
                 ...inputs,
                 productId: product.id,
-            }
+            },
         };
     }
-    async diff(id, olds, news) {
+    async diff(_id, olds, news) {
         const changes = [];
         if (olds.name !== news.name)
             changes.push("name");
@@ -70,7 +71,7 @@ class StripeProductProvider {
             replaces: [], // None require replacement, all can be updated
         };
     }
-    async update(id, olds, news) {
+    async update(id, _olds, news) {
         const stripe = new stripe_1.default(news.apiKey);
         await stripe.products.update(id, {
             name: news.name,
@@ -81,12 +82,13 @@ class StripeProductProvider {
             outs: {
                 ...news,
                 productId: id,
-            }
+            },
         };
     }
     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,24 @@
+export declare const INF: "inf";
+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,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageType = exports.RecurringInterval = exports.TiersMode = exports.BillingScheme = exports.TaxBehavior = exports.INF = void 0;
+exports.INF = "inf";
+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 "./enums";
 export * from "./StripePaymentLink";
-export * from "./StripeProduct";
 export * from "./StripePrice";
+export * from "./StripeProduct";

package/dist/index.js

@@ -14,6 +14,7 @@ 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 });
+__exportStar(require("./enums"), exports);
 __exportStar(require("./StripePaymentLink"), exports);
-__exportStar(require("./StripeProduct"), exports);
 __exportStar(require("./StripePrice"), exports);
+__exportStar(require("./StripeProduct"), 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,28 @@
+"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.