@mathrunet/masamune_cloudflare_purchase_stripe 3.2.1 → 3.3.0

package/src/workers/stripe_webhook.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { jsonError } from "@mathrunet/masamune_cloudflare/dist/lib/src/http_error";
+import { jsonError } from "@mathrunet/masamune_cloudflare";
 import {
     resolveStripeClient,
     resolveStripePurchaseStore,
@@ -9,6 +9,10 @@ import {
 } from "../lib/options";
 import { constructStripeEvent } from "../lib/stripe_client";
 import { syncStripePayment } from "../lib/purchase/sync_payment";
+import {
+    resolvePaymentIntentReceipt,
+    resolveSubscriptionPurchaseFields,
+} from "../lib/purchase/stripe_mapping";
 
 /**
  * Receives and processes webhooks from Stripe (parity with the `stripeWebhook`
@@ -154,13 +158,16 @@ module.exports = (
                     update["errorMessage"] = null;
                     update["updatedTime"] = new Date();
 
-                    if (payment["charges"] && payment["charges"]["data"] && payment["charges"]["data"].length > 0 && payment["charges"]["data"][0]) {
-                        if (payment["charges"]["data"][0]["receipt_url"]) {
-                            update["receiptUrl"] = payment["charges"]["data"][0]["receipt_url"];
-                        }
-                        if (payment["charges"]["data"][0]["amount_captured"]) {
-                            update["capturedAmount"] = payment["charges"]["data"][0]["amount_captured"];
-                        }
+                    // `PaymentIntent.charges` no longer exists; resolve the receipt via `latest_charge`.
+                    const receipt = await resolvePaymentIntentReceipt({
+                        stripeClient,
+                        paymentIntent: payment,
+                    });
+                    if (receipt.receiptUrl) {
+                        update["receiptUrl"] = receipt.receiptUrl;
+                    }
+                    if (receipt.capturedAmount) {
+                        update["capturedAmount"] = receipt.capturedAmount;
                     }
                     await store.savePurchase(purchase.orderId, update);
                     return c.json({
@@ -333,17 +340,17 @@ module.exports = (
                             "success": "Subscription is not active.",
                         });
                     }
-                    const endDate = new Date(subscription["current_period_end"] as number * 1000);
+                    // Since basil the period and price live on the subscription items.
+                    const fields = resolveSubscriptionPurchaseFields(subscription);
                     const id = subscription["id"];
                     const userId = subscription["metadata"]?.["userId"] as string;
                     const orderId = (subscription["metadata"]?.["orderId"] as string) ?? id;
-                    const plan = subscription["plan"] as {
-                        [key: string]: any
-                    } ?? {};
 
                     const existing = await store.findPurchaseBySubscriptionId(id);
                     const targetOrderId = existing?.orderId ?? orderId;
-                    update["expired"] = now >= endDate;
+                    update["expired"] = fields.current_period_end !== null
+                        ? now.getTime() >= fields.current_period_end * 1000
+                        : false;
                     if (userId) {
                         update["user"] = userId;
                     }
@@ -357,20 +364,20 @@ module.exports = (
                     update["canceled_at"] = subscription["canceled_at"];
                     update["collection_method"] = subscription["collection_method"];
                     update["currency"] = subscription["currency"];
-                    update["current_period_start"] = subscription["current_period_start"];
-                    update["current_period_end"] = subscription["current_period_end"];
+                    update["current_period_start"] = fields.current_period_start;
+                    update["current_period_end"] = fields.current_period_end;
                     update["customer"] = subscription["customer"];
                     update["default_payment_method"] = subscription["default_payment_method"];
                     update["ended_at"] = subscription["ended_at"];
                     update["latest_invoice"] = subscription["latest_invoice"];
-                    update["price_id"] = plan["id"];
-                    update["active"] = plan["active"];
-                    update["amount"] = plan["amount"];
-                    update["billing_scheme"] = plan["billing_scheme"];
-                    update["interval"] = plan["interval"];
-                    update["interval_count"] = plan["interval_count"];
-                    update["usage_type"] = plan["usage_type"];
-                    update["quantity"] = subscription["quantity"];
+                    update["price_id"] = fields.price_id;
+                    update["active"] = fields.active;
+                    update["amount"] = fields.amount;
+                    update["billing_scheme"] = fields.billing_scheme;
+                    update["interval"] = fields.interval;
+                    update["interval_count"] = fields.interval_count;
+                    update["usage_type"] = fields.usage_type;
+                    update["quantity"] = fields.quantity;
                     update["start_date"] = subscription["start_date"];
                     console.log(`Subscription status is ${status}.`);
                     await store.savePurchase(targetOrderId, update, {

package/src/workers/stripe_webhook_connect.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { jsonError } from "@mathrunet/masamune_cloudflare/dist/lib/src/http_error";
+import { jsonError } from "@mathrunet/masamune_cloudflare";
 import {
     resolveStripeClient,
     resolveStripePurchaseStore,

package/src/workers/stripe_webhook_secure.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { jsonError } from "@mathrunet/masamune_cloudflare/dist/lib/src/http_error";
+import { jsonError } from "@mathrunet/masamune_cloudflare";
 import "@mathrunet/masamune";
 import {
     resolveStripeClient,

package/test/meter.test.ts

@@ -39,7 +39,14 @@ function fakeKv(store: Map<string, string>): KVNamespaceLike {
 function fakeFetch(status: number, onRequest?: (init?: RequestInit) => void): typeof fetch {
     return (async (_url: unknown, init?: RequestInit) => {
         onRequest?.(init);
-        return new Response(status >= 400 ? "error" : "{}", { status });
+        // Return a Stripe-shaped JSON error body; the SDK leaves its request
+        // timeout timer armed when an error body is not valid JSON.
+        return new Response(
+            status >= 400
+                ? JSON.stringify({ error: { type: "invalid_request_error", message: "error" } })
+                : "{}",
+            { status, headers: { "content-type": "application/json" } },
+        );
     }) as typeof fetch;
 }
 
@@ -68,7 +75,9 @@ describe("recordUsage", () => {
             pendingRows: [{ id: "u1", units: 10 }],
             executed,
             store,
-            fetch: fakeFetch(500),
+            // Use a non-retryable error: stripe-node 22.6.x leaves the request
+            // timeout timer of a retried (5xx) attempt armed, which keeps Jest alive.
+            fetch: fakeFetch(400),
         });
 
         await recordUsage({

package/test/stripe_mapping.test.ts

@@ -0,0 +1,184 @@
+import Stripe from "stripe";
+import {
+    resolvePaymentIntentReceipt,
+    resolveSubscriptionPeriod,
+    resolveSubscriptionPurchaseFields,
+} from "../src/lib/purchase/stripe_mapping";
+
+function stripeStub(retrieve: (id: string) => Promise<unknown>): Stripe {
+    return { charges: { retrieve } } as unknown as Stripe;
+}
+
+describe("resolveSubscriptionPeriod", () => {
+    it("アイテム間で最も早い開始と最も遅い終了を返す", () => {
+        const period = resolveSubscriptionPeriod({
+            items: {
+                data: [
+                    { current_period_start: 200, current_period_end: 900 },
+                    { current_period_start: 100, current_period_end: 1200 },
+                ],
+            },
+        });
+        expect(period).toEqual({ start: 100, end: 1200 });
+    });
+
+    it("アイテムに期間が無ければトップレベルの旧フィールドにフォールバックする", () => {
+        const period = resolveSubscriptionPeriod({
+            current_period_start: 10,
+            current_period_end: 20,
+            items: { data: [{ id: "si_1" }] },
+        });
+        expect(period).toEqual({ start: 10, end: 20 });
+    });
+
+    it("期間が取得できなければInvalid Dateではなくnullを返す", () => {
+        expect(resolveSubscriptionPeriod({ items: { data: [] } })).toEqual({ start: null, end: null });
+        expect(resolveSubscriptionPeriod({ current_period_end: "x" })).toEqual({ start: null, end: null });
+    });
+});
+
+describe("resolveSubscriptionPurchaseFields", () => {
+    it("items.data[0].priceから従来と同じフィールド名で値を構築する", () => {
+        const fields = resolveSubscriptionPurchaseFields({
+            items: {
+                data: [
+                    {
+                        current_period_start: 100,
+                        current_period_end: 200,
+                        quantity: 3,
+                        price: {
+                            id: "price_1",
+                            active: true,
+                            unit_amount: 1500,
+                            billing_scheme: "tiered",
+                            recurring: {
+                                interval: "week",
+                                interval_count: 2,
+                                usage_type: "metered",
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        expect(fields).toEqual({
+            current_period_start: 100,
+            current_period_end: 200,
+            price_id: "price_1",
+            active: true,
+            amount: 1500,
+            billing_scheme: "tiered",
+            interval: "week",
+            interval_count: 2,
+            usage_type: "metered",
+            quantity: 3,
+        });
+    });
+
+    it("priceが無ければitems.data[0].plan、次にsubscription.planへフォールバックする", () => {
+        const fromItemPlan = resolveSubscriptionPurchaseFields({
+            items: {
+                data: [{
+                    plan: {
+                        id: "plan_item",
+                        active: false,
+                        amount: 300,
+                        billing_scheme: "per_unit",
+                        interval: "day",
+                        interval_count: 7,
+                        usage_type: "licensed",
+                    },
+                }],
+            },
+        });
+        expect(fromItemPlan).toMatchObject({
+            price_id: "plan_item",
+            active: false,
+            amount: 300,
+            interval: "day",
+            interval_count: 7,
+        });
+
+        const fromLegacy = resolveSubscriptionPurchaseFields({
+            quantity: 4,
+            plan: { id: "plan_legacy", amount: 700, interval: "month" },
+        });
+        expect(fromLegacy).toMatchObject({
+            price_id: "plan_legacy",
+            amount: 700,
+            interval: "month",
+            quantity: 4,
+        });
+    });
+
+    it("何も無ければ全フィールドnullを返す", () => {
+        expect(resolveSubscriptionPurchaseFields({})).toEqual({
+            current_period_start: null,
+            current_period_end: null,
+            price_id: null,
+            active: null,
+            amount: null,
+            billing_scheme: null,
+            interval: null,
+            interval_count: null,
+            usage_type: null,
+            quantity: null,
+        });
+    });
+});
+
+describe("resolvePaymentIntentReceipt", () => {
+    it("latest_chargeがIDならチャージを取得する", async () => {
+        const retrieve = jest.fn(async () => ({
+            receipt_url: "https://pay.stripe.com/receipts/1",
+            amount_captured: 1000,
+        }));
+        const receipt = await resolvePaymentIntentReceipt({
+            stripeClient: stripeStub(retrieve),
+            paymentIntent: { id: "pi_1", latest_charge: "ch_1" },
+        });
+        expect(retrieve).toHaveBeenCalledWith("ch_1");
+        expect(receipt).toEqual({
+            receiptUrl: "https://pay.stripe.com/receipts/1",
+            capturedAmount: 1000,
+        });
+    });
+
+    it("展開済みのlatest_chargeはAPIを呼ばずにそのまま使う", async () => {
+        const retrieve = jest.fn();
+        const receipt = await resolvePaymentIntentReceipt({
+            stripeClient: stripeStub(retrieve),
+            paymentIntent: {
+                latest_charge: { id: "ch_2", receipt_url: "https://r/2", amount_captured: 50 },
+            },
+        });
+        expect(retrieve).not.toHaveBeenCalled();
+        expect(receipt).toEqual({ receiptUrl: "https://r/2", capturedAmount: 50 });
+    });
+
+    it("latest_chargeが無ければ旧charges.data[0]にフォールバックする", async () => {
+        const retrieve = jest.fn();
+        const receipt = await resolvePaymentIntentReceipt({
+            stripeClient: stripeStub(retrieve),
+            paymentIntent: {
+                latest_charge: null,
+                charges: { data: [{ receipt_url: "https://r/legacy", amount_captured: 70 }] },
+            },
+        });
+        expect(retrieve).not.toHaveBeenCalled();
+        expect(receipt).toEqual({ receiptUrl: "https://r/legacy", capturedAmount: 70 });
+    });
+
+    it("取得に失敗したらnullを返し例外を投げない", async () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+        const receipt = await resolvePaymentIntentReceipt({
+            stripeClient: stripeStub(async () => {
+                throw new Error("boom");
+            }),
+            paymentIntent: { latest_charge: "ch_x" },
+        });
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+        expect(receipt).toEqual({ receiptUrl: null, capturedAmount: null });
+    });
+});

package/test/stripe_webhook.test.ts

@@ -1,6 +1,7 @@
 import Stripe from "stripe";
 import { Hono } from "hono";
 import { StripePurchaseWorkersOptions } from "../src/lib/options";
+import { STRIPE_API_VERSION } from "../src/lib/stripe_client";
 import { MemoryPurchaseStore } from "./helpers/mem_store";
 
 const buildWebhook = require("../src/workers/stripe_webhook") as (
@@ -11,60 +12,91 @@ const buildWebhook = require("../src/workers/stripe_webhook") as (
 
 const WEBHOOK_SECRET = "whsec_test_secret";
 const stripeForSigning = new Stripe("sk_test_dummy", {
-    apiVersion: "2025-02-24.acacia",
+    apiVersion: STRIPE_API_VERSION,
 });
 
-function subscriptionEvent(type: string, overrides: { [key: string]: any } = {}): string {
+const NOW = Math.floor(Date.now() / 1000);
+const PERIOD_START = NOW - 60;
+const PERIOD_END = NOW + 86400 * 30;
+
+function subscriptionObject(overrides: { [key: string]: any } = {}): { [key: string]: any } {
+    return {
+        id: "sub_test_1",
+        object: "subscription",
+        status: "active",
+        customer: "cus_test_1",
+        cancel_at: null,
+        cancel_at_period_end: false,
+        canceled_at: null,
+        collection_method: "charge_automatically",
+        currency: "jpy",
+        default_payment_method: "pm_test_1",
+        ended_at: null,
+        latest_invoice: "in_test_1",
+        start_date: PERIOD_START,
+        application: null,
+        application_fee_percent: null,
+        metadata: {
+            userId: "user_1",
+            orderId: "order_1",
+        },
+        items: {
+            object: "list",
+            data: [
+                {
+                    id: "si_test_1",
+                    object: "subscription_item",
+                    current_period_start: PERIOD_START,
+                    current_period_end: PERIOD_END,
+                    quantity: 1,
+                    price: {
+                        id: "price_test_1",
+                        object: "price",
+                        active: true,
+                        unit_amount: 500,
+                        billing_scheme: "per_unit",
+                        recurring: {
+                            interval: "month",
+                            interval_count: 1,
+                            usage_type: "licensed",
+                        },
+                    },
+                },
+            ],
+        },
+        ...overrides,
+    };
+}
+
+function eventPayload(type: string, object: { [key: string]: any }, apiVersion: string = STRIPE_API_VERSION): string {
     return JSON.stringify({
         id: "evt_test_1",
         object: "event",
-        api_version: "2025-02-24.acacia",
+        api_version: apiVersion,
         type,
         data: {
-            object: {
-                id: "sub_test_1",
-                object: "subscription",
-                status: "active",
-                customer: "cus_test_1",
-                current_period_start: Math.floor(Date.now() / 1000) - 60,
-                current_period_end: Math.floor(Date.now() / 1000) + 86400 * 30,
-                cancel_at: null,
-                cancel_at_period_end: false,
-                canceled_at: null,
-                collection_method: "charge_automatically",
-                currency: "jpy",
-                default_payment_method: "pm_test_1",
-                ended_at: null,
-                latest_invoice: "in_test_1",
-                quantity: 1,
-                start_date: Math.floor(Date.now() / 1000) - 60,
-                application: null,
-                application_fee_percent: null,
-                metadata: {
-                    userId: "user_1",
-                    orderId: "order_1",
-                },
-                plan: {
-                    id: "price_test_1",
-                    active: true,
-                    amount: 500,
-                    billing_scheme: "per_unit",
-                    interval: "month",
-                    interval_count: 1,
-                    usage_type: "licensed",
-                },
-                ...overrides,
-            },
+            object,
         },
     });
 }
 
-function buildApp(store: MemoryPurchaseStore): Hono {
+function subscriptionEvent(type: string, overrides: { [key: string]: any } = {}): string {
+    return eventPayload(type, subscriptionObject(overrides));
+}
+
+function sign(payload: string, secret: string = WEBHOOK_SECRET): string {
+    return stripeForSigning.webhooks.generateTestHeaderString({
+        payload,
+        secret,
+    });
+}
+
+function buildApp(store: MemoryPurchaseStore, stripeClient: unknown = stripeForSigning): Hono {
     return buildWebhook(new Hono(), {
         secretKey: "sk_test_dummy",
         webhookSecret: WEBHOOK_SECRET,
         store: () => store,
-        stripeClient: () => stripeForSigning,
+        stripeClient: () => stripeClient as Stripe,
     }, {});
 }
 
@@ -87,12 +119,8 @@ describe("stripeWebhook", () => {
         const store = new MemoryPurchaseStore();
         const app = buildApp(store);
         const payload = subscriptionEvent("customer.subscription.created");
-        const signature = stripeForSigning.webhooks.generateTestHeaderString({
-            payload,
-            secret: WEBHOOK_SECRET,
-        });
 
-        const res = await post(app, payload, signature);
+        const res = await post(app, payload, sign(payload));
 
         expect(res.status).toBe(200);
         const purchase = await store.getPurchase("order_1");
@@ -101,24 +129,154 @@ describe("stripeWebhook", () => {
         expect(purchase?.data).toMatchObject({
             subscription: "sub_test_1",
             price_id: "price_test_1",
+            active: true,
             amount: 500,
+            billing_scheme: "per_unit",
             interval: "month",
+            interval_count: 1,
+            usage_type: "licensed",
+            quantity: 1,
+            current_period_start: PERIOD_START,
+            current_period_end: PERIOD_END,
             expired: false,
             customer: "cus_test_1",
         });
         expect((await store.findPurchaseBySubscriptionId("sub_test_1"))?.orderId).toBe("order_1");
     });
 
-    it("activeでないサブスクリプションは保存せず200を返す", async () => {
+    it("サブスクリプションアイテムの期間が終了していればexpiredをtrueにする", async () => {
         const store = new MemoryPurchaseStore();
         const app = buildApp(store);
-        const payload = subscriptionEvent("customer.subscription.updated", { status: "incomplete" });
-        const signature = stripeForSigning.webhooks.generateTestHeaderString({
-            payload,
-            secret: WEBHOOK_SECRET,
+        const base = subscriptionObject();
+        base["items"]["data"][0]["current_period_start"] = NOW - 86400 * 31;
+        base["items"]["data"][0]["current_period_end"] = NOW - 60;
+        const payload = eventPayload("customer.subscription.updated", base);
+
+        const res = await post(app, payload, sign(payload));
+
+        expect(res.status).toBe(200);
+        const purchase = await store.getPurchase("order_1");
+        expect(purchase?.data["expired"]).toBe(true);
+        expect(purchase?.data["current_period_end"]).toBe(NOW - 60);
+    });
+
+    it("旧APIバージョン（acacia）のペイロードではトップレベルのperiodとplanにフォールバックする", async () => {
+        const store = new MemoryPurchaseStore();
+        const app = buildApp(store);
+        const legacy = subscriptionObject({
+            current_period_start: PERIOD_START,
+            current_period_end: PERIOD_END,
+            quantity: 2,
+            plan: {
+                id: "price_legacy_1",
+                active: true,
+                amount: 800,
+                billing_scheme: "per_unit",
+                interval: "year",
+                interval_count: 1,
+                usage_type: "licensed",
+            },
+            items: {
+                object: "list",
+                data: [],
+            },
+        });
+        const payload = eventPayload("customer.subscription.created", legacy, "2025-02-24.acacia");
+
+        const res = await post(app, payload, sign(payload));
+
+        expect(res.status).toBe(200);
+        expect((await store.getPurchase("order_1"))?.data).toMatchObject({
+            price_id: "price_legacy_1",
+            amount: 800,
+            interval: "year",
+            quantity: 2,
+            current_period_start: PERIOD_START,
+            current_period_end: PERIOD_END,
+            expired: false,
+        });
+    });
+
+    it("payment_intent.succeededでlatest_chargeを取得してreceiptUrlとcapturedAmountを保存する", async () => {
+        const store = new MemoryPurchaseStore();
+        await store.saveUser("user_1", { customer: "cus_test_1" });
+        await store.savePurchase("order_pi_1", {
+            purchaseId: "pi_test_1",
+            user: "user_1",
+            success: false,
+        });
+        const retrieve = jest.fn(async (id: string) => ({
+            id,
+            object: "charge",
+            receipt_url: "https://pay.stripe.com/receipts/test",
+            amount_captured: 1200,
+        }));
+        const stripeStub = {
+            webhooks: stripeForSigning.webhooks,
+            charges: { retrieve },
+        };
+        const app = buildApp(store, stripeStub);
+        const payload = eventPayload("payment_intent.succeeded", {
+            id: "pi_test_1",
+            object: "payment_intent",
+            customer: "cus_test_1",
+            status: "succeeded",
+            latest_charge: "ch_test_1",
         });
 
-        const res = await post(app, payload, signature);
+        const res = await post(app, payload, sign(payload));
+
+        expect(res.status).toBe(200);
+        expect(retrieve).toHaveBeenCalledWith("ch_test_1");
+        expect((await store.getPurchase("order_pi_1"))?.data).toMatchObject({
+            success: true,
+            capture: true,
+            receiptUrl: "https://pay.stripe.com/receipts/test",
+            capturedAmount: 1200,
+        });
+    });
+
+    it("latest_chargeの取得に失敗しても購入の成功は保存する", async () => {
+        const store = new MemoryPurchaseStore();
+        await store.saveUser("user_1", { customer: "cus_test_1" });
+        await store.savePurchase("order_pi_1", {
+            purchaseId: "pi_test_1",
+            user: "user_1",
+            success: false,
+        });
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+        const stripeStub = {
+            webhooks: stripeForSigning.webhooks,
+            charges: {
+                retrieve: jest.fn(async () => {
+                    throw new Error("No such charge");
+                }),
+            },
+        };
+        const app = buildApp(store, stripeStub);
+        const payload = eventPayload("payment_intent.succeeded", {
+            id: "pi_test_1",
+            object: "payment_intent",
+            customer: "cus_test_1",
+            status: "succeeded",
+            latest_charge: "ch_missing",
+        });
+
+        const res = await post(app, payload, sign(payload));
+        warn.mockRestore();
+
+        expect(res.status).toBe(200);
+        const data = (await store.getPurchase("order_pi_1"))?.data;
+        expect(data?.["success"]).toBe(true);
+        expect(data?.["receiptUrl"]).toBeUndefined();
+        expect(data?.["capturedAmount"]).toBeUndefined();
+    });
+
+    it("activeでないサブスクリプションは保存せず200を返す", async () => {
+        const store = new MemoryPurchaseStore();
+        const app = buildApp(store);
+        const payload = subscriptionEvent("customer.subscription.updated", { status: "incomplete" });
+        const res = await post(app, payload, sign(payload));
 
         expect(res.status).toBe(200);
         expect(await store.getPurchase("order_1")).toBeNull();
@@ -137,12 +295,7 @@ describe("stripeWebhook", () => {
             ended_at: Math.floor(Date.now() / 1000),
             canceled_at: Math.floor(Date.now() / 1000),
         });
-        const signature = stripeForSigning.webhooks.generateTestHeaderString({
-            payload,
-            secret: WEBHOOK_SECRET,
-        });
-
-        const res = await post(app, payload, signature);
+        const res = await post(app, payload, sign(payload));
 
         expect(res.status).toBe(200);
         expect((await store.getPurchase("order_1"))?.data["expired"]).toBe(true);
@@ -152,12 +305,7 @@ describe("stripeWebhook", () => {
         const store = new MemoryPurchaseStore();
         const app = buildApp(store);
         const payload = subscriptionEvent("customer.subscription.created");
-        const signature = stripeForSigning.webhooks.generateTestHeaderString({
-            payload,
-            secret: "whsec_wrong_secret",
-        });
-
-        const res = await post(app, payload, signature);
+        const res = await post(app, payload, sign(payload, "whsec_wrong_secret"));
 
         expect(res.status).toBe(403);
         expect(store.purchases.size).toBe(0);