@fantastic.dev/better-stripe 0.17.1 → 0.19.0

package/dist/component/earnings/triggers.d.ts

@@ -248,6 +248,81 @@ export declare const mutation: import("convex-helpers/server/customFunctions").C
         searchIndexes: {};
         vectorIndexes: {};
     };
+    payoutPolicies: {
+        document: {
+            _creationTime: number;
+            _id: import("convex/values").GenericId<"payoutPolicies">;
+            accountId: string;
+            country: string;
+            holdDeadline?: number | undefined;
+            mode: "custom" | "stripe_managed";
+            operationKey: string;
+            ownerKey: string;
+            previousSchedule?: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            } | undefined;
+            revision: number;
+            status: "changing" | "ready";
+            thresholds: {
+                amount: number;
+                currency: string;
+            }[];
+        };
+        fieldPaths: "_id" | ("_creationTime" | "accountId" | "country" | "holdDeadline" | "mode" | "operationKey" | "ownerKey" | "previousSchedule" | "previousSchedule.interval" | "previousSchedule.monthlyDays" | "previousSchedule.weeklyDays" | "revision" | "status" | "thresholds");
+        indexes: {
+            by_id: ["_id"];
+            by_creation_time: ["_creationTime"];
+            by_account: ["accountId", "_creationTime"];
+            by_deadline: ["holdDeadline", "_creationTime"];
+        };
+        searchIndexes: {};
+        vectorIndexes: {};
+    };
+    payoutPolicyOperations: {
+        document: {
+            _creationTime: number;
+            _id: import("convex/values").GenericId<"payoutPolicyOperations">;
+            accountId: string;
+            attempted?: boolean | undefined;
+            country: string;
+            expectedRevision: number;
+            mode: "custom" | "stripe_managed";
+            observedAt?: number | undefined;
+            observedSchedule: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            };
+            operationKey: string;
+            ownerKey: string;
+            previousSchedule: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            };
+            revision: number;
+            status: "canceled" | "complete" | "pending";
+            targetSchedule: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            };
+            thresholds: {
+                amount: number;
+                currency: string;
+            }[];
+        };
+        fieldPaths: "_id" | ("_creationTime" | "accountId" | "attempted" | "country" | "expectedRevision" | "mode" | "observedAt" | "observedSchedule" | "observedSchedule.interval" | "observedSchedule.monthlyDays" | "observedSchedule.weeklyDays" | "operationKey" | "ownerKey" | "previousSchedule" | "previousSchedule.interval" | "previousSchedule.monthlyDays" | "previousSchedule.weeklyDays" | "revision" | "status" | "targetSchedule" | "targetSchedule.interval" | "targetSchedule.monthlyDays" | "targetSchedule.weeklyDays" | "thresholds");
+        indexes: {
+            by_id: ["_id"];
+            by_creation_time: ["_creationTime"];
+            by_operation: ["operationKey", "_creationTime"];
+        };
+        searchIndexes: {};
+        vectorIndexes: {};
+    };
     payouts: {
         document: {
             _creationTime: number;
@@ -894,6 +969,81 @@ export declare const mutation: import("convex-helpers/server/customFunctions").C
         searchIndexes: {};
         vectorIndexes: {};
     };
+    payoutPolicies: {
+        document: {
+            _creationTime: number;
+            _id: import("convex/values").GenericId<"payoutPolicies">;
+            accountId: string;
+            country: string;
+            holdDeadline?: number | undefined;
+            mode: "custom" | "stripe_managed";
+            operationKey: string;
+            ownerKey: string;
+            previousSchedule?: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            } | undefined;
+            revision: number;
+            status: "changing" | "ready";
+            thresholds: {
+                amount: number;
+                currency: string;
+            }[];
+        };
+        fieldPaths: "_id" | ("_creationTime" | "accountId" | "country" | "holdDeadline" | "mode" | "operationKey" | "ownerKey" | "previousSchedule" | "previousSchedule.interval" | "previousSchedule.monthlyDays" | "previousSchedule.weeklyDays" | "revision" | "status" | "thresholds");
+        indexes: {
+            by_id: ["_id"];
+            by_creation_time: ["_creationTime"];
+            by_account: ["accountId", "_creationTime"];
+            by_deadline: ["holdDeadline", "_creationTime"];
+        };
+        searchIndexes: {};
+        vectorIndexes: {};
+    };
+    payoutPolicyOperations: {
+        document: {
+            _creationTime: number;
+            _id: import("convex/values").GenericId<"payoutPolicyOperations">;
+            accountId: string;
+            attempted?: boolean | undefined;
+            country: string;
+            expectedRevision: number;
+            mode: "custom" | "stripe_managed";
+            observedAt?: number | undefined;
+            observedSchedule: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            };
+            operationKey: string;
+            ownerKey: string;
+            previousSchedule: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            };
+            revision: number;
+            status: "canceled" | "complete" | "pending";
+            targetSchedule: {
+                interval: "daily" | "manual" | "monthly" | "weekly";
+                monthlyDays?: number[] | undefined;
+                weeklyDays?: string[] | undefined;
+            };
+            thresholds: {
+                amount: number;
+                currency: string;
+            }[];
+        };
+        fieldPaths: "_id" | ("_creationTime" | "accountId" | "attempted" | "country" | "expectedRevision" | "mode" | "observedAt" | "observedSchedule" | "observedSchedule.interval" | "observedSchedule.monthlyDays" | "observedSchedule.weeklyDays" | "operationKey" | "ownerKey" | "previousSchedule" | "previousSchedule.interval" | "previousSchedule.monthlyDays" | "previousSchedule.weeklyDays" | "revision" | "status" | "targetSchedule" | "targetSchedule.interval" | "targetSchedule.monthlyDays" | "targetSchedule.weeklyDays" | "thresholds");
+        indexes: {
+            by_id: ["_id"];
+            by_creation_time: ["_creationTime"];
+            by_operation: ["operationKey", "_creationTime"];
+        };
+        searchIndexes: {};
+        vectorIndexes: {};
+    };
     payouts: {
         document: {
             _creationTime: number;

package/dist/component/earnings/triggers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triggers.d.ts","sourceRoot":"","sources":["../../../src/component/earnings/triggers.ts"],"names":[],"mappings":"AA+FA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAA0D,CAAC"}
+{"version":3,"file":"triggers.d.ts","sourceRoot":"","sources":["../../../src/component/earnings/triggers.ts"],"names":[],"mappings":"AA+FA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAA0D,CAAC"}

package/dist/component/payoutPolicy/helpers.d.ts

@@ -0,0 +1,51 @@
+import type { Infer } from "convex/values";
+import type { QueryCtx, MutationCtx } from "../_generated/server.js";
+import type { schedule, thresholds } from "./schema.js";
+export declare function canonicalSchedule(value: Infer<typeof schedule>): {
+    interval: "weekly";
+    weeklyDays: string[];
+    monthlyDays?: undefined;
+} | {
+    weeklyDays?: undefined;
+    interval: "monthly";
+    monthlyDays: number[];
+} | {
+    weeklyDays?: undefined;
+    monthlyDays?: undefined;
+    interval: "daily" | "manual";
+};
+export declare function canonicalThresholds(values: Infer<typeof thresholds>, custom: boolean): {
+    amount: number;
+    currency: string;
+}[];
+export declare function validateScope(scope: {
+    accountId: string;
+    ownerKey: string;
+}): void;
+export declare function readPolicy(ctx: QueryCtx | MutationCtx, scope: {
+    accountId: string;
+    ownerKey: string;
+}): Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutPolicies">;
+    accountId: string;
+    country: string;
+    holdDeadline?: number | undefined;
+    mode: "custom" | "stripe_managed";
+    operationKey: string;
+    ownerKey: string;
+    previousSchedule?: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    } | undefined;
+    revision: number;
+    status: "changing" | "ready";
+    thresholds: {
+        amount: number;
+        currency: string;
+    }[];
+} | null>;
+export declare const same: (a: unknown, b: unknown) => boolean;
+export declare function holdingDays(country: string): 10 | 90 | 730;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/component/payoutPolicy/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/component/payoutPolicy/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACxD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,QAAQ,CAAC;;;;;;;;;;;;EAoC9D;AACD,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,KAAK,CAAC,OAAO,UAAU,CAAC,EAChC,MAAM,EAAE,OAAO;;;IAgBhB;AACD,wBAAgB,aAAa,CAAC,KAAK,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,QAQ3E;AACD,wBAAsB,UAAU,CAC9B,GAAG,EAAE,QAAQ,GAAG,WAAW,EAC3B,KAAK,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;UAU/C;AACD,eAAO,MAAM,IAAI,MAAO,OAAO,KAAK,OAAO,YACF,CAAC;AAC1C,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,iBAI1C"}

package/dist/component/payoutPolicy/helpers.js

@@ -0,0 +1,68 @@
+export function canonicalSchedule(value) {
+    const weekdays = [
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday",
+    ];
+    if (value.interval === "weekly") {
+        const days = value.weeklyDays;
+        if (!days?.length ||
+            days.length > 7 ||
+            new Set(days).size !== days.length ||
+            days.some((day) => !weekdays.includes(day)))
+            throw new Error("Invalid weekly payout schedule.");
+        return { interval: value.interval, weeklyDays: [...days].sort() };
+    }
+    if (value.interval === "monthly") {
+        const days = value.monthlyDays;
+        if (!days?.length ||
+            days.length > 31 ||
+            new Set(days).size !== days.length ||
+            days.some((day) => !Number.isInteger(day) || day < 1 || day > 31))
+            throw new Error("Invalid monthly payout schedule.");
+        return {
+            interval: value.interval,
+            monthlyDays: [...days].sort((a, b) => a - b),
+        };
+    }
+    return { interval: value.interval };
+}
+export function canonicalThresholds(values, custom) {
+    if ((custom && !values.length) ||
+        values.length > 50 ||
+        (!custom && values.length) ||
+        new Set(values.map((v) => v.currency)).size !== values.length ||
+        values.some((v) => !Number.isSafeInteger(v.amount) ||
+            v.amount <= 0 ||
+            !/^[a-z]{3}$/.test(v.currency)))
+        throw new Error("Invalid custom payout thresholds.");
+    return [...values].sort((a, b) => a.currency.localeCompare(b.currency));
+}
+export function validateScope(scope) {
+    if (!/^acct_\w+$/.test(scope.accountId) ||
+        scope.accountId.length > 80 ||
+        !scope.ownerKey.trim() ||
+        scope.ownerKey.length > 200)
+        throw new Error("Invalid payout policy identity.");
+}
+export async function readPolicy(ctx, scope) {
+    validateScope(scope);
+    const value = await ctx.db
+        .query("payoutPolicies")
+        .withIndex("by_account", (q) => q.eq("accountId", scope.accountId))
+        .unique();
+    if (value && value.ownerKey !== scope.ownerKey)
+        throw new Error("Payout policy owner does not match.");
+    return value;
+}
+export const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export function holdingDays(country) {
+    if (!/^[A-Z]{2}$/.test(country))
+        throw new Error("A verified account country is required.");
+    return country === "TH" ? 10 : country === "US" ? 730 : 90;
+}
+//# sourceMappingURL=helpers.js.map

package/dist/component/payoutPolicy/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/component/payoutPolicy/helpers.ts"],"names":[],"mappings":"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"}

package/dist/component/payoutPolicy/mutations.d.ts

@@ -0,0 +1,172 @@
+export declare const prepare: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    country: string;
+    expectedRevision: number;
+    mode: "custom" | "stripe_managed";
+    observedAt?: number | undefined;
+    observedSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    operationKey: string;
+    ownerKey: string;
+    thresholds: {
+        amount: number;
+        currency: string;
+    }[];
+}, Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutPolicyOperations">;
+    accountId: string;
+    attempted?: boolean | undefined;
+    country: string;
+    expectedRevision: number;
+    mode: "custom" | "stripe_managed";
+    observedAt?: number | undefined;
+    observedSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    operationKey: string;
+    ownerKey: string;
+    previousSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    revision: number;
+    status: "canceled" | "complete" | "pending";
+    targetSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    thresholds: {
+        amount: number;
+        currency: string;
+    }[];
+}>>;
+export declare const confirm: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    observedSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    operationKey: string;
+    ownerKey: string;
+}, Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutPolicyOperations">;
+    accountId: string;
+    attempted?: boolean | undefined;
+    country: string;
+    expectedRevision: number;
+    mode: "custom" | "stripe_managed";
+    observedAt?: number | undefined;
+    observedSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    operationKey: string;
+    ownerKey: string;
+    previousSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    revision: number;
+    status: "canceled" | "complete" | "pending";
+    targetSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    thresholds: {
+        amount: number;
+        currency: string;
+    }[];
+}>>;
+export declare const beginAttempt: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    operationKey: string;
+    ownerKey: string;
+}, Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutPolicyOperations">;
+    accountId: string;
+    attempted?: boolean | undefined;
+    country: string;
+    expectedRevision: number;
+    mode: "custom" | "stripe_managed";
+    observedAt?: number | undefined;
+    observedSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    operationKey: string;
+    ownerKey: string;
+    previousSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    revision: number;
+    status: "canceled" | "complete" | "pending";
+    targetSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    thresholds: {
+        amount: number;
+        currency: string;
+    }[];
+}>>;
+export declare const cancelUnattempted: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    observedSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    operationKey: string;
+    ownerKey: string;
+}, Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutPolicyOperations">;
+    accountId: string;
+    attempted?: boolean | undefined;
+    country: string;
+    expectedRevision: number;
+    mode: "custom" | "stripe_managed";
+    observedAt?: number | undefined;
+    observedSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    operationKey: string;
+    ownerKey: string;
+    previousSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    revision: number;
+    status: "canceled" | "complete" | "pending";
+    targetSchedule: {
+        interval: "daily" | "manual" | "monthly" | "weekly";
+        monthlyDays?: number[] | undefined;
+        weeklyDays?: string[] | undefined;
+    };
+    thresholds: {
+        amount: number;
+        currency: string;
+    }[];
+}>>;
+//# sourceMappingURL=mutations.d.ts.map

package/dist/component/payoutPolicy/mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../../src/component/payoutPolicy/mutations.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GlB,CAAC;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuClB,CAAC;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBvB,CAAC;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsC5B,CAAC"}

package/dist/component/payoutPolicy/mutations.js

@@ -0,0 +1,191 @@
+import { v } from "convex/values";
+import { mutation } from "../_generated/server.js";
+import { prepareFields, operationDoc, scopeFields, schedule, } from "./schema.js";
+import { canonicalSchedule, canonicalThresholds, readPolicy, holdingDays, same, validateScope, } from "./helpers.js";
+export const prepare = mutation({
+    args: prepareFields,
+    returns: operationDoc,
+    handler: async (ctx, input) => {
+        validateScope(input);
+        if (!input.operationKey.trim() ||
+            input.operationKey.length > 180 ||
+            /[\r\n]/.test(input.operationKey) ||
+            !Number.isSafeInteger(input.expectedRevision) ||
+            input.expectedRevision < -1 ||
+            input.expectedRevision >= Number.MAX_SAFE_INTEGER)
+            throw new Error("Invalid payout policy operation identity or revision.");
+        const days = holdingDays(input.country);
+        const args = {
+            ...input,
+            observedSchedule: canonicalSchedule(input.observedSchedule),
+            thresholds: canonicalThresholds(input.thresholds, input.mode === "custom"),
+        };
+        const old = await ctx.db
+            .query("payoutPolicyOperations")
+            .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+            .unique();
+        if (old) {
+            if (old.accountId !== args.accountId ||
+                old.ownerKey !== args.ownerKey ||
+                old.expectedRevision !== args.expectedRevision ||
+                old.mode !== args.mode ||
+                old.country !== args.country ||
+                old.observedAt !== args.observedAt ||
+                !same(old.thresholds, args.thresholds) ||
+                !same(old.observedSchedule, args.observedSchedule))
+                throw new Error("Payout policy operation identity cannot be reused.");
+            return old;
+        }
+        if (input.observedAt !== undefined &&
+            (!Number.isSafeInteger(input.observedAt) ||
+                input.observedAt > Date.now() ||
+                input.observedAt < Date.now() - 600000))
+            throw new Error("Payout policy observation is stale or in the future.");
+        const policy = await readPolicy(ctx, args);
+        if (policy?.status === "changing")
+            throw new Error("A payout policy operation is pending.");
+        if ((policy?.revision ?? -1) !== args.expectedRevision)
+            throw new Error("Payout policy revision changed.");
+        if (policy?.mode === "custom" &&
+            args.observedSchedule.interval !== "manual")
+            throw new Error("Payout schedule drift requires reconciliation.");
+        if (policy?.mode === "custom" &&
+            policy.country !== args.country &&
+            args.mode === "custom")
+            throw new Error("Payout policy country changed.");
+        if (args.mode === "custom" &&
+            policy?.mode !== "custom" &&
+            args.observedSchedule.interval === "manual")
+            throw new Error("An existing manual schedule requires migration.");
+        const previousSchedule = policy?.mode === "custom"
+            ? policy.previousSchedule
+            : args.observedSchedule;
+        const targetSchedule = args.mode === "custom"
+            ? { interval: "manual" }
+            : previousSchedule;
+        const revision = args.expectedRevision + 1;
+        const operationId = await ctx.db.insert("payoutPolicyOperations", {
+            ...args,
+            revision,
+            previousSchedule,
+            targetSchedule,
+            status: "pending",
+        });
+        const next = {
+            accountId: args.accountId,
+            ownerKey: args.ownerKey,
+            revision,
+            mode: policy?.mode ?? "stripe_managed",
+            thresholds: policy?.thresholds ?? [],
+            status: "changing",
+            operationKey: args.operationKey,
+            country: args.country,
+            previousSchedule,
+            holdDeadline: policy?.holdDeadline ??
+                (args.mode === "custom"
+                    ? (args.observedAt ?? Date.now()) + days * 86400000
+                    : undefined),
+        };
+        if (policy)
+            await ctx.db.patch("payoutPolicies", policy._id, next);
+        else
+            await ctx.db.insert("payoutPolicies", next);
+        return (await ctx.db.get("payoutPolicyOperations", operationId));
+    },
+});
+export const confirm = mutation({
+    args: {
+        ...scopeFields,
+        operationKey: v.string(),
+        observedSchedule: schedule,
+    },
+    returns: operationDoc,
+    handler: async (ctx, args) => {
+        const policy = await readPolicy(ctx, args);
+        const op = await ctx.db
+            .query("payoutPolicyOperations")
+            .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+            .unique();
+        if (!op || op.accountId !== args.accountId || op.ownerKey !== args.ownerKey)
+            throw new Error("Payout policy operation identity does not match.");
+        if (!same(canonicalSchedule(args.observedSchedule), op.targetSchedule))
+            throw new Error("Provider payout schedule was not confirmed.");
+        if (op.status === "complete")
+            return op;
+        if (op.status === "canceled")
+            throw new Error("Payout policy operation was canceled.");
+        if (!policy ||
+            policy.operationKey !== op.operationKey ||
+            policy.revision !== op.revision)
+            throw new Error("Payout policy revision changed.");
+        await ctx.db.patch("payoutPolicyOperations", op._id, {
+            status: "complete",
+        });
+        await ctx.db.patch("payoutPolicies", policy._id, {
+            mode: op.mode,
+            thresholds: op.thresholds,
+            status: "ready",
+            ...(op.mode === "stripe_managed"
+                ? { previousSchedule: undefined, holdDeadline: undefined }
+                : {}),
+        });
+        return (await ctx.db.get("payoutPolicyOperations", op._id));
+    },
+});
+export const beginAttempt = mutation({
+    args: { ...scopeFields, operationKey: v.string() },
+    returns: operationDoc,
+    handler: async (ctx, args) => {
+        const policy = await readPolicy(ctx, args);
+        const op = await ctx.db
+            .query("payoutPolicyOperations")
+            .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+            .unique();
+        if (!op ||
+            op.accountId !== args.accountId ||
+            op.ownerKey !== args.ownerKey ||
+            op.status !== "pending" ||
+            policy?.operationKey !== op.operationKey ||
+            policy.status !== "changing")
+            throw new Error("Payout policy operation is not pending.");
+        if (!op.attempted)
+            await ctx.db.patch("payoutPolicyOperations", op._id, { attempted: true });
+        return (await ctx.db.get("payoutPolicyOperations", op._id));
+    },
+});
+export const cancelUnattempted = mutation({
+    args: {
+        ...scopeFields,
+        operationKey: v.string(),
+        observedSchedule: schedule,
+    },
+    returns: operationDoc,
+    handler: async (ctx, args) => {
+        const policy = await readPolicy(ctx, args);
+        const op = await ctx.db
+            .query("payoutPolicyOperations")
+            .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+            .unique();
+        if (!op ||
+            op.accountId !== args.accountId ||
+            op.ownerKey !== args.ownerKey ||
+            op.attempted ||
+            op.status !== "pending" ||
+            policy?.operationKey !== op.operationKey ||
+            policy.status !== "changing")
+            throw new Error("An attempted payout policy operation cannot be canceled.");
+        if (!same(canonicalSchedule(args.observedSchedule), op.observedSchedule))
+            throw new Error("Provider schedule changed before cancellation.");
+        await ctx.db.patch("payoutPolicyOperations", op._id, {
+            status: "canceled",
+        });
+        await ctx.db.patch("payoutPolicies", policy._id, {
+            status: "ready",
+            ...(policy.mode === "stripe_managed"
+                ? { previousSchedule: undefined, holdDeadline: undefined }
+                : {}),
+        });
+        return (await ctx.db.get("payoutPolicyOperations", op._id));
+    },
+});
+//# sourceMappingURL=mutations.js.map