@mathrunet/masamune_cloudflare_purchase_stripe 3.2.0

package/test/helpers/mem_store.ts

@@ -0,0 +1,97 @@
+import {
+    mergeDocumentData,
+    StripeDocumentData,
+    StripePaymentDocument,
+    StripePurchaseDocument,
+    StripePurchaseStore,
+    StripeUserDocument,
+} from "../../src/lib/purchase/interface";
+
+/**
+ * In-memory [StripePurchaseStore] for tests.
+ *
+ * テスト用のインメモリ[StripePurchaseStore]。
+ */
+export class MemoryPurchaseStore implements StripePurchaseStore {
+    users = new Map<string, StripeDocumentData>();
+    payments = new Map<string, StripeDocumentData>();
+    purchases = new Map<string, { userId: string | null, data: StripeDocumentData }>();
+
+    async getUser(userId: string): Promise<StripeUserDocument | null> {
+        const data = this.users.get(userId);
+        return data ? { userId, data } : null;
+    }
+    async findUserByCustomerId(customerId: string): Promise<StripeUserDocument | null> {
+        for (const [userId, data] of this.users) {
+            if (data["customer"] === customerId) {
+                return { userId, data };
+            }
+        }
+        return null;
+    }
+    async findUserByAccountId(accountId: string): Promise<StripeUserDocument | null> {
+        for (const [userId, data] of this.users) {
+            if (data["account"] === accountId) {
+                return { userId, data };
+            }
+        }
+        return null;
+    }
+    async saveUser(userId: string, update: StripeDocumentData): Promise<void> {
+        this.users.set(userId, mergeDocumentData(this.users.get(userId) ?? {}, update));
+    }
+    async listPayments(userId: string): Promise<StripePaymentDocument[]> {
+        const list: StripePaymentDocument[] = [];
+        for (const [key, data] of this.payments) {
+            const [owner, paymentId] = key.split("/");
+            if (owner === userId && paymentId) {
+                list.push({ userId, paymentId, data });
+            }
+        }
+        return list;
+    }
+    async savePayment(userId: string, paymentId: string, update: StripeDocumentData): Promise<void> {
+        const key = `${userId}/${paymentId}`;
+        this.payments.set(key, mergeDocumentData(this.payments.get(key) ?? {}, update));
+    }
+    async deletePayment(userId: string, paymentId: string): Promise<void> {
+        this.payments.delete(`${userId}/${paymentId}`);
+    }
+    async getPurchase(orderId: string, userId?: string | undefined): Promise<StripePurchaseDocument | null> {
+        const entry = this.purchases.get(orderId);
+        if (!entry) {
+            return null;
+        }
+        if (userId && entry.userId !== userId) {
+            return null;
+        }
+        return { orderId, userId: entry.userId, data: entry.data };
+    }
+    async findPurchaseByPurchaseId(purchaseId: string): Promise<StripePurchaseDocument | null> {
+        for (const [orderId, entry] of this.purchases) {
+            if (entry.data["purchaseId"] === purchaseId) {
+                return { orderId, userId: entry.userId, data: entry.data };
+            }
+        }
+        return null;
+    }
+    async findPurchaseBySubscriptionId(subscriptionId: string): Promise<StripePurchaseDocument | null> {
+        for (const [orderId, entry] of this.purchases) {
+            if (entry.data["subscription"] === subscriptionId) {
+                return { orderId, userId: entry.userId, data: entry.data };
+            }
+        }
+        return null;
+    }
+    async savePurchase(
+        orderId: string,
+        update: StripeDocumentData,
+        options: { userId?: string | undefined } = {},
+    ): Promise<void> {
+        const existing = this.purchases.get(orderId);
+        const data = mergeDocumentData(existing?.data ?? {}, update);
+        const userId = options.userId
+            ?? (typeof data["user"] === "string" ? data["user"] : existing?.userId ?? null);
+        this.purchases.set(orderId, { userId, data });
+    }
+}

package/test/meter.test.ts

@@ -0,0 +1,217 @@
+import { D1UsageEventStore, SqlDatabaseLike } from "../src/lib/meter/d1_usage_event_store";
+import { flushStripeMeter } from "../src/lib/meter/flush_meter";
+import { KVNamespaceLike, KVUsageBuffer } from "../src/lib/meter/kv_usage_buffer";
+import { recordUsage } from "../src/lib/meter/record_usage";
+import { StripeMeterClient } from "../src/lib/meter/stripe_meter_client";
+
+function fakeDb(pendingRows: { id: string, units: number }[], executed: string[]): SqlDatabaseLike {
+    return {
+        prepare(sql: string) {
+            return {
+                bind(..._args: unknown[]) {
+                    return {
+                        async run() {
+                            executed.push(sql.replace(/\s+/g, " ").trim());
+                            return {};
+                        },
+                        async all<T>() {
+                            return { results: pendingRows as unknown as T[] };
+                        },
+                    };
+                },
+            };
+        },
+    };
+}
+
+function fakeKv(store: Map<string, string>): KVNamespaceLike {
+    return {
+        async get(key: string) {
+            const value = store.get(key);
+            return value === undefined ? null : JSON.parse(value);
+        },
+        async put(key: string, value: string) {
+            store.set(key, value);
+        },
+    };
+}
+
+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 });
+    }) as typeof fetch;
+}
+
+function makeParts(options: {
+    pendingRows: { id: string, units: number }[],
+    executed: string[],
+    store: Map<string, string>,
+    fetch: typeof fetch,
+}) {
+    return {
+        store: new D1UsageEventStore(fakeDb(options.pendingRows, options.executed)),
+        buffer: new KVUsageBuffer(fakeKv(options.store)),
+        client: new StripeMeterClient({
+            secretKey: "sk_test_dummy",
+            eventName: "test_decisions",
+            fetch: options.fetch,
+        }),
+    };
+}
+
+describe("recordUsage", () => {
+    it("Stripe flush が失敗したらバッファを保持して次回再送に回す", async () => {
+        const executed: string[] = [];
+        const store = new Map<string, string>();
+        const parts = makeParts({
+            pendingRows: [{ id: "u1", units: 10 }],
+            executed,
+            store,
+            fetch: fakeFetch(500),
+        });
+
+        await recordUsage({
+            ...parts,
+            customerKey: "key_1",
+            stripeCustomerId: "cus_123",
+            endpoint: "decide",
+            units: 10,
+        });
+
+        const buffer = JSON.parse(store.get("usage:key_1") ?? "{}");
+        expect(buffer.units).toBe(10);
+        expect(executed.some((sql) => sql.includes("SET flushed_to_stripe = 1"))).toBe(false);
+    });
+
+    it("Stripe flush が成功したらバッファをリセットし送信済みを記録する", async () => {
+        const executed: string[] = [];
+        const store = new Map<string, string>();
+        const parts = makeParts({
+            pendingRows: [{ id: "u1", units: 10 }],
+            executed,
+            store,
+            fetch: fakeFetch(200),
+        });
+
+        await recordUsage({
+            ...parts,
+            customerKey: "key_1",
+            stripeCustomerId: "cus_123",
+            endpoint: "decide",
+            units: 10,
+        });
+
+        const buffer = JSON.parse(store.get("usage:key_1") ?? "{}");
+        expect(buffer.units).toBe(0);
+        expect(executed.some((sql) => sql.includes("SET flushed_to_stripe = 1"))).toBe(true);
+    });
+
+    it("閾値未満なら flush せずバッファへ積むだけ", async () => {
+        const executed: string[] = [];
+        const store = new Map<string, string>();
+        let fetchCalled = false;
+        const parts = makeParts({
+            pendingRows: [{ id: "u1", units: 1 }],
+            executed,
+            store,
+            fetch: fakeFetch(200, () => {
+                fetchCalled = true;
+            }),
+        });
+
+        await recordUsage({
+            ...parts,
+            customerKey: "key_1",
+            stripeCustomerId: "cus_123",
+            endpoint: "decide",
+            units: 1,
+        });
+
+        const buffer = JSON.parse(store.get("usage:key_1") ?? "{}");
+        expect(buffer.units).toBe(1);
+        expect(fetchCalled).toBe(false);
+    });
+});
+
+describe("flushStripeMeter", () => {
+    it("バッチごとに一意な identifier を送る", async () => {
+        const identifiers: string[] = [];
+        const parts = makeParts({
+            pendingRows: [{ id: "u1", units: 3 }],
+            executed: [],
+            store: new Map(),
+            fetch: fakeFetch(200, (init) => {
+                identifiers.push(new URLSearchParams(String(init?.body ?? "")).get("identifier") ?? "");
+            }),
+        });
+        const options = {
+            store: parts.store,
+            client: parts.client,
+            customerKey: "key_1",
+            stripeCustomerId: "cus_123",
+        };
+
+        expect(await flushStripeMeter(options)).toBe(true);
+        expect(await flushStripeMeter(options)).toBe(true);
+        expect(identifiers).toHaveLength(2);
+        expect(identifiers[0]).not.toBe(identifiers[1]);
+        expect(identifiers[0]?.startsWith("key_1:")).toBe(true);
+    });
+
+    it("Stripe がエラーを返したら false を返し flushed を更新しない", async () => {
+        const executed: string[] = [];
+        const parts = makeParts({
+            pendingRows: [{ id: "u1", units: 3 }],
+            executed,
+            store: new Map(),
+            fetch: fakeFetch(400),
+        });
+
+        expect(
+            await flushStripeMeter({
+                store: parts.store,
+                client: parts.client,
+                customerKey: "key_1",
+                stripeCustomerId: "cus_123",
+            }),
+        ).toBe(false);
+        expect(executed.some((sql) => sql.includes("SET flushed_to_stripe = 1"))).toBe(false);
+    });
+
+    it("secret や顧客IDが未設定なら送信せず成功扱いにする", async () => {
+        let fetchCalled = false;
+        const store = new D1UsageEventStore(fakeDb([{ id: "u1", units: 3 }], []));
+        const disabledClient = new StripeMeterClient({
+            secretKey: "",
+            eventName: "test_decisions",
+            fetch: fakeFetch(200, () => {
+                fetchCalled = true;
+            }),
+        });
+
+        expect(
+            await flushStripeMeter({
+                store,
+                client: disabledClient,
+                customerKey: "key_1",
+                stripeCustomerId: "cus_123",
+            }),
+        ).toBe(true);
+        expect(
+            await flushStripeMeter({
+                store,
+                client: new StripeMeterClient({
+                    secretKey: "sk_test_dummy",
+                    eventName: "test_decisions",
+                    fetch: fakeFetch(200, () => {
+                        fetchCalled = true;
+                    }),
+                }),
+                customerKey: "key_1",
+                stripeCustomerId: null,
+            }),
+        ).toBe(true);
+        expect(fetchCalled).toBe(false);
+    });
+});

package/test/purchase_store.test.ts

@@ -0,0 +1,154 @@
+import { D1StripePurchaseStore } from "../src/lib/purchase/d1_purchase_store";
+import { mergeDocumentData } from "../src/lib/purchase/interface";
+import { SqlDatabaseLike } from "../src/lib/meter/d1_usage_event_store";
+
+interface Row {
+    [key: string]: unknown;
+}
+
+// D1StripePurchaseStore が発行する SELECT / INSERT / UPDATE / DELETE を
+// メモリ上のテーブルで解釈する最小のフェイクD1。
+function fakeDb(tables: { [table: string]: Row[] }): SqlDatabaseLike {
+    return {
+        prepare(sql: string) {
+            const normalized = sql.replace(/\s+/g, " ").trim();
+            return {
+                bind(...args: unknown[]) {
+                    const run = async () => {
+                        const insert = normalized.match(/^INSERT INTO (\w+) \(([^)]+)\) VALUES/);
+                        if (insert) {
+                            const table = insert[1] as string;
+                            const columns = (insert[2] as string).split(",").map((s) => s.trim());
+                            const row: Row = {};
+                            columns.forEach((column, i) => {
+                                row[column] = args[i];
+                            });
+                            (tables[table] ??= []).push(row);
+                            return {};
+                        }
+                        const update = normalized.match(/^UPDATE (\w+) SET (.+) WHERE (.+)$/);
+                        if (update) {
+                            const table = update[1] as string;
+                            const setColumns = (update[2] as string).split(",").map((s) => (s.split("=")[0] as string).trim());
+                            const whereColumns = (update[3] as string).split("AND").map((s) => (s.split("=")[0] as string).trim());
+                            const setValues = args.slice(0, setColumns.length);
+                            const whereValues = args.slice(setColumns.length);
+                            for (const row of tables[table] ?? []) {
+                                if (whereColumns.every((column, i) => row[column] === whereValues[i])) {
+                                    setColumns.forEach((column, i) => {
+                                        row[column] = setValues[i];
+                                    });
+                                }
+                            }
+                            return {};
+                        }
+                        const del = normalized.match(/^DELETE FROM (\w+) WHERE (.+)$/);
+                        if (del) {
+                            const table = del[1] as string;
+                            const whereColumns = (del[2] as string).split("AND").map((s) => (s.split("=")[0] as string).trim());
+                            tables[table] = (tables[table] ?? []).filter(
+                                (row) => !whereColumns.every((column, i) => row[column] === args[i]),
+                            );
+                            return {};
+                        }
+                        throw new Error(`Unsupported SQL: ${normalized}`);
+                    };
+                    const all = async <T>() => {
+                        const select = normalized.match(/^SELECT (.+) FROM (\w+)(?: WHERE (.+?))?( LIMIT \d+)?$/);
+                        if (!select) {
+                            throw new Error(`Unsupported SQL: ${normalized}`);
+                        }
+                        const table = select[2] as string;
+                        const where = select[3];
+                        let rows = tables[table] ?? [];
+                        if (where) {
+                            const whereColumns = where.split("AND").map((s) => (s.split("=")[0] as string).trim());
+                            rows = rows.filter((row) => whereColumns.every((column, i) => row[column] === args[i]));
+                        }
+                        return { results: rows as unknown as T[] };
+                    };
+                    return { run, all };
+                },
+            };
+        },
+    };
+}
+
+describe("mergeDocumentData", () => {
+    it("nullのキーは削除しundefinedは無視する", () => {
+        const merged = mergeDocumentData(
+            { a: 1, b: 2, c: 3 },
+            { a: null, b: undefined, d: 4 },
+        );
+        expect(merged).toEqual({ b: 2, c: 3, d: 4 });
+    });
+});
+
+describe("D1StripePurchaseStore", () => {
+    it("saveUserがマージ保存し検索キーカラムを同期する", async () => {
+        const tables: { [table: string]: Row[] } = {};
+        const store = new D1StripePurchaseStore(fakeDb(tables));
+
+        await store.saveUser("user_1", { user: "user_1", customer: "cus_1" });
+        await store.saveUser("user_1", { account: "acct_1", email: "a@b.c" });
+
+        const user = await store.getUser("user_1");
+        expect(user?.data).toMatchObject({
+            user: "user_1",
+            customer: "cus_1",
+            account: "acct_1",
+            email: "a@b.c",
+        });
+        expect(await store.findUserByCustomerId("cus_1")).not.toBeNull();
+        expect(await store.findUserByAccountId("acct_1")).not.toBeNull();
+
+        await store.saveUser("user_1", { customer: null });
+        expect(await store.findUserByCustomerId("cus_1")).toBeNull();
+        const after = await store.getUser("user_1");
+        expect(after?.data["customer"]).toBeUndefined();
+    });
+
+    it("savePurchaseがpurchaseId/subscriptionを検索キーへ同期する", async () => {
+        const tables: { [table: string]: Row[] } = {};
+        const store = new D1StripePurchaseStore(fakeDb(tables));
+
+        await store.savePurchase("order_1", {
+            orderId: "order_1",
+            purchaseId: "pi_1",
+            user: "user_1",
+        }, { userId: "user_1" });
+        await store.savePurchase("order_2", {
+            subscription: "sub_1",
+            user: "user_1",
+        });
+
+        expect((await store.findPurchaseByPurchaseId("pi_1"))?.orderId).toBe("order_1");
+        expect((await store.findPurchaseBySubscriptionId("sub_1"))?.orderId).toBe("order_2");
+        expect((await store.getPurchase("order_1", "user_1"))?.data["purchaseId"]).toBe("pi_1");
+        expect(await store.getPurchase("order_1", "other_user")).toBeNull();
+
+        await store.savePurchase("order_1", { confirm: true, error: null });
+        const purchase = await store.getPurchase("order_1");
+        expect(purchase?.data["confirm"]).toBe(true);
+        expect(purchase?.data["purchaseId"]).toBe("pi_1");
+    });
+
+    it("支払い方法の保存・一覧・削除ができる", async () => {
+        const tables: { [table: string]: Row[] } = {};
+        const store = new D1StripePurchaseStore(fakeDb(tables));
+
+        await store.savePayment("user_1", "pm_1", { id: "pm_1", brand: "visa", default: true });
+        await store.savePayment("user_1", "pm_2", { id: "pm_2", brand: "mc", default: false });
+        await store.savePayment("user_1", "pm_1", { expMonth: 12 });
+
+        const payments = await store.listPayments("user_1");
+        expect(payments).toHaveLength(2);
+        expect(payments.find((p) => p.paymentId === "pm_1")?.data).toMatchObject({
+            brand: "visa",
+            expMonth: 12,
+        });
+
+        await store.deletePayment("user_1", "pm_1");
+        expect(await store.listPayments("user_1")).toHaveLength(1);
+    });
+});

package/test/stripe.test.ts

@@ -0,0 +1,146 @@
+import Stripe from "stripe";
+import { Hono } from "hono";
+import { StripePurchaseWorkersOptions } from "../src/lib/options";
+import { MemoryPurchaseStore } from "./helpers/mem_store";
+
+const buildStripe = require("../src/workers/stripe") as (
+    hono: Hono,
+    options: StripePurchaseWorkersOptions,
+    data: { [key: string]: any },
+) => Hono;
+
+function buildApp(store: MemoryPurchaseStore, stripeStub: unknown): Hono {
+    return buildStripe(new Hono(), {
+        secretKey: "sk_test_dummy_secret_key_0123456789abcdef0123456789abcdef",
+        store: () => store,
+        stripeClient: () => stripeStub as Stripe,
+    }, {});
+}
+
+async function post(app: Hono, body: { [key: string]: any }): Promise<Response> {
+    return app.request("/", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}
+
+describe("stripe (mode actions)", () => {
+    it("create_subscriptionがCheckout SessionのURLを返す", async () => {
+        const created: any[] = [];
+        const stripeStub = {
+            checkout: {
+                sessions: {
+                    create: async (params: any) => {
+                        created.push(params);
+                        return { url: "https://checkout.stripe.com/test" };
+                    },
+                },
+            },
+        };
+        const app = buildApp(new MemoryPurchaseStore(), stripeStub);
+
+        const res = await post(app, {
+            mode: "create_subscription",
+            userId: "user_1",
+            orderId: "order_1",
+            productId: "price_test_1",
+            successUrl: "https://example.com/ok",
+            cancelUrl: "https://example.com/ng",
+        });
+
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ endpoint: "https://checkout.stripe.com/test" });
+        expect(created[0]).toMatchObject({
+            mode: "subscription",
+            subscription_data: {
+                metadata: { userId: "user_1", orderId: "order_1" },
+            },
+            line_items: [{ price: "price_test_1", quantity: 1 }],
+        });
+    });
+
+    it("create_subscriptionは必須パラメータ欠如で400を返す", async () => {
+        const app = buildApp(new MemoryPurchaseStore(), {});
+
+        const res = await post(app, {
+            mode: "create_subscription",
+            userId: "user_1",
+            orderId: "order_1",
+        });
+
+        expect(res.status).toBe(400);
+    });
+
+    it("delete_subscriptionがcancel_at_period_endを設定する", async () => {
+        const updated: any[] = [];
+        const stripeStub = {
+            subscriptions: {
+                update: async (id: string, params: any) => {
+                    updated.push([id, params]);
+                    return { cancel_at_period_end: true };
+                },
+            },
+        };
+        const store = new MemoryPurchaseStore();
+        await store.savePurchase("order_1", { subscription: "sub_test_1", user: "user_1" });
+        const app = buildApp(store, stripeStub);
+
+        const res = await post(app, {
+            mode: "delete_subscription",
+            orderId: "order_1",
+        });
+
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ success: true });
+        expect(updated[0]).toEqual(["sub_test_1", { cancel_at_period_end: true }]);
+    });
+
+    it("delete_subscriptionは購読が見つからなければ404を返す", async () => {
+        const app = buildApp(new MemoryPurchaseStore(), {});
+
+        const res = await post(app, {
+            mode: "delete_subscription",
+            orderId: "missing_order",
+        });
+
+        expect(res.status).toBe(404);
+    });
+
+    it("create_customer_and_paymentが新規カスタマーとsetupセッションを作る", async () => {
+        const stripeStub = {
+            customers: {
+                create: async (params: any) => ({ id: "cus_new_1", ...params }),
+            },
+            checkout: {
+                sessions: {
+                    create: async (_params: any) => ({ url: "https://checkout.stripe.com/setup" }),
+                },
+            },
+        };
+        const store = new MemoryPurchaseStore();
+        const app = buildApp(store, stripeStub);
+
+        const res = await post(app, {
+            mode: "create_customer_and_payment",
+            userId: "user_1",
+            successUrl: "https://example.com/ok",
+            cancelUrl: "https://example.com/ng",
+        });
+
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({
+            endpoint: "https://checkout.stripe.com/setup",
+            customerId: "cus_new_1",
+        });
+        expect((await store.getUser("user_1"))?.data["customer"]).toBe("cus_new_1");
+    });
+
+    it("未知のmodeは404を返す", async () => {
+        const app = buildApp(new MemoryPurchaseStore(), {});
+
+        const res = await post(app, { mode: "unknown_mode" });
+
+        expect(res.status).toBe(404);
+    });
+});