@fantastic.dev/better-stripe 0.23.1 → 0.23.2

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

@@ -432,6 +432,28 @@ export declare const mutation: import("convex-helpers/server/customFunctions").C
         searchIndexes: {};
         vectorIndexes: {};
     };
+    payoutSyncClaims: {
+        document: {
+            _creationTime: number;
+            _id: import("convex/values").GenericId<"payoutSyncClaims">;
+            acceptedAt?: number | undefined;
+            acceptedFingerprint?: string | undefined;
+            acceptedGeneration?: number | undefined;
+            accountId: string;
+            generation: number;
+            startedAt: number;
+            status: "accepted" | "pending" | "unknown";
+            stripePayoutId: string;
+        };
+        fieldPaths: "_id" | ("_creationTime" | "acceptedAt" | "acceptedFingerprint" | "acceptedGeneration" | "accountId" | "generation" | "startedAt" | "status" | "stripePayoutId");
+        indexes: {
+            by_id: ["_id"];
+            by_creation_time: ["_creationTime"];
+            by_stripe_payout_id: ["stripePayoutId", "_creationTime"];
+        };
+        searchIndexes: {};
+        vectorIndexes: {};
+    };
     payouts: {
         document: {
             _creationTime: number;
@@ -1262,6 +1284,28 @@ export declare const mutation: import("convex-helpers/server/customFunctions").C
         searchIndexes: {};
         vectorIndexes: {};
     };
+    payoutSyncClaims: {
+        document: {
+            _creationTime: number;
+            _id: import("convex/values").GenericId<"payoutSyncClaims">;
+            acceptedAt?: number | undefined;
+            acceptedFingerprint?: string | undefined;
+            acceptedGeneration?: number | undefined;
+            accountId: string;
+            generation: number;
+            startedAt: number;
+            status: "accepted" | "pending" | "unknown";
+            stripePayoutId: string;
+        };
+        fieldPaths: "_id" | ("_creationTime" | "acceptedAt" | "acceptedFingerprint" | "acceptedGeneration" | "accountId" | "generation" | "startedAt" | "status" | "stripePayoutId");
+        indexes: {
+            by_id: ["_id"];
+            by_creation_time: ["_creationTime"];
+            by_stripe_payout_id: ["stripePayoutId", "_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/payoutSync/helpers.d.ts

@@ -0,0 +1,44 @@
+import type { Infer } from "convex/values";
+import type { MutationCtx, QueryCtx } from "../_generated/server.js";
+import type { Doc } from "../_generated/dataModel.js";
+import type { snapshot } from "./validators.js";
+export declare function validateIdentity(args: {
+    stripePayoutId: string;
+    accountId: string;
+}): void;
+export declare function claimByPayout(ctx: QueryCtx | MutationCtx, args: {
+    stripePayoutId: string;
+    accountId: string;
+}): Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutSyncClaims">;
+    acceptedAt?: number | undefined;
+    acceptedFingerprint?: string | undefined;
+    acceptedGeneration?: number | undefined;
+    accountId: string;
+    generation: number;
+    startedAt: number;
+    status: "accepted" | "pending" | "unknown";
+    stripePayoutId: string;
+} | null>;
+export declare function payoutById(ctx: QueryCtx | MutationCtx, args: {
+    stripePayoutId: string;
+    accountId: string;
+}): Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payouts">;
+    accountId: string;
+    amount: number;
+    arrivalDate?: string | undefined;
+    currency: string;
+    failureCode?: string | undefined;
+    failureMessage?: string | undefined;
+    metadata?: any;
+    method?: string | undefined;
+    status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+    stripePayoutId: string;
+    totalsRecorded?: true | undefined;
+} | null>;
+export declare function validateSnapshot(p: Infer<typeof snapshot>): void;
+export declare function fingerprint(p: Infer<typeof snapshot> | Doc<"payouts">): Promise<string>;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/component/payoutSync/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,4BAA4B,CAAC;AAEtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB,QASA;AACD,wBAAsB,aAAa,CACjC,GAAG,EAAE,QAAQ,GAAG,WAAW,EAC3B,IAAI,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;UAYpD;AACD,wBAAsB,UAAU,CAC9B,GAAG,EAAE,QAAQ,GAAG,WAAW,EAC3B,IAAI,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;UAWpD;AACD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,QAAQ,CAAC,QAoBzD;AACD,wBAAsB,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,QAAQ,CAAC,GAAG,GAAG,CAAC,SAAS,CAAC,mBAiB3E"}

package/dist/component/payoutSync/helpers.js

@@ -0,0 +1,60 @@
+import { generateIdempotencyKey } from "../lib/idempotency.js";
+export function validateIdentity(args) {
+    if (!/^po_[A-Za-z0-9_]+$/.test(args.stripePayoutId) ||
+        args.stripePayoutId.length > 255 ||
+        (args.accountId !== "platform" &&
+            !/^acct_[A-Za-z0-9_]+$/.test(args.accountId)) ||
+        args.accountId.length > 255)
+        throw new Error("Invalid payout synchronization identity.");
+}
+export async function claimByPayout(ctx, args) {
+    validateIdentity(args);
+    const claim = await ctx.db
+        .query("payoutSyncClaims")
+        .withIndex("by_stripe_payout_id", (q) => q.eq("stripePayoutId", args.stripePayoutId))
+        .unique();
+    if (claim && claim.accountId !== args.accountId)
+        throw new Error("Payout synchronization account does not match.");
+    return claim;
+}
+export async function payoutById(ctx, args) {
+    const payout = await ctx.db
+        .query("payouts")
+        .withIndex("by_stripe_payout_id", (q) => q.eq("stripePayoutId", args.stripePayoutId))
+        .unique();
+    if (payout && payout.accountId !== args.accountId)
+        throw new Error("Existing payout account does not match.");
+    return payout;
+}
+export function validateSnapshot(p) {
+    validateIdentity(p);
+    if (!Number.isSafeInteger(p.amount) ||
+        p.amount <= 0 ||
+        !/^[a-z]{3}$/.test(p.currency) ||
+        (p.method !== undefined && !["standard", "instant"].includes(p.method)))
+        throw new Error("Invalid payout synchronization money or method.");
+    if (p.arrivalDate !== undefined &&
+        (!Number.isFinite(Date.parse(p.arrivalDate)) ||
+            new Date(p.arrivalDate).toISOString() !== p.arrivalDate))
+        throw new Error("Invalid payout arrival date.");
+    if ((p.failureCode !== undefined && p.failureCode.length > 255) ||
+        (p.failureMessage !== undefined && p.failureMessage.length > 4096))
+        throw new Error("Invalid payout failure detail.");
+}
+export async function fingerprint(p) {
+    return generateIdempotencyKey("payout-sync", {
+        snapshot: [
+            p.stripePayoutId,
+            p.accountId,
+            p.amount,
+            p.currency,
+            p.status,
+            p.arrivalDate,
+            p.method,
+            p.failureCode,
+            p.failureMessage,
+            Object.entries(p.metadata ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0),
+        ],
+    });
+}
+//# sourceMappingURL=helpers.js.map

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

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

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

@@ -0,0 +1,51 @@
+export declare const begin: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    stripePayoutId: string;
+}, Promise<number>>;
+export declare const finish: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    generation: number;
+    payout: {
+        accountId: string;
+        amount: number;
+        arrivalDate?: string | undefined;
+        currency: string;
+        failureCode?: string | undefined;
+        failureMessage?: string | undefined;
+        metadata?: Record<string, string> | undefined;
+        method?: string | undefined;
+        status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+        stripePayoutId: string;
+    };
+    stripePayoutId: string;
+}, Promise<{
+    status: "superseded";
+    generation: number;
+    changed?: undefined;
+    payout?: undefined;
+} | {
+    status: "accepted";
+    generation: number;
+    changed: boolean;
+    payout: {
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"payouts">;
+        accountId: string;
+        amount: number;
+        arrivalDate?: string | undefined;
+        currency: string;
+        failureCode?: string | undefined;
+        failureMessage?: string | undefined;
+        metadata?: any;
+        method?: string | undefined;
+        status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+        stripePayoutId: string;
+        totalsRecorded?: true | undefined;
+    };
+}>>;
+export declare const markUnknown: import("convex/server").RegisteredMutation<"public", {
+    accountId: string;
+    generation: number;
+    stripePayoutId: string;
+}, Promise<null>>;
+//# sourceMappingURL=mutations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../../src/component/payoutSync/mutations.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,KAAK;;;mBAwBhB,CAAC;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;YAOI,YAAY;;;;;YA8BnB,UAAU;;;;;;;;;;;;;;;;;;GAmBxB,CAAC;AACH,eAAO,MAAM,WAAW;;;;iBAStB,CAAC"}

package/dist/component/payoutSync/mutations.js

@@ -0,0 +1,88 @@
+import { v } from "convex/values";
+import { mutation } from "../earnings/triggers.js";
+import { writePayout } from "../connect/payoutWrites.js";
+import { claimByPayout, payoutById, validateSnapshot, fingerprint, } from "./helpers.js";
+import { identity, prepared, result } from "./validators.js";
+export const begin = mutation({
+    args: identity,
+    returns: v.number(),
+    handler: async (ctx, args) => {
+        const claim = await claimByPayout(ctx, args);
+        await payoutById(ctx, args);
+        const generation = (claim?.generation ?? 0) + 1;
+        if (!Number.isSafeInteger(generation))
+            throw new Error("Payout synchronization generation exhausted.");
+        if (claim)
+            await ctx.db.patch("payoutSyncClaims", claim._id, {
+                generation,
+                status: "pending",
+                startedAt: Date.now(),
+            });
+        else
+            await ctx.db.insert("payoutSyncClaims", {
+                ...args,
+                generation,
+                status: "pending",
+                startedAt: Date.now(),
+            });
+        return generation;
+    },
+});
+export const finish = mutation({
+    args: prepared,
+    returns: result,
+    handler: async (ctx, args) => {
+        const claim = await claimByPayout(ctx, args);
+        if (!claim)
+            throw new Error("Payout synchronization claim is missing.");
+        if (claim.generation !== args.generation)
+            return { status: "superseded", generation: args.generation };
+        validateSnapshot(args.payout);
+        if (args.payout.accountId !== args.accountId ||
+            args.payout.stripePayoutId !== args.stripePayoutId)
+            throw new Error("Payout synchronization snapshot identity does not match.");
+        const existing = await payoutById(ctx, args);
+        if (existing &&
+            (existing.amount !== args.payout.amount ||
+                existing.currency !== args.payout.currency))
+            throw new Error("Existing payout original money does not match.");
+        const nextFingerprint = await fingerprint(args.payout);
+        if (claim.status === "accepted" &&
+            claim.acceptedFingerprint !== nextFingerprint)
+            throw new Error("An accepted payout observation cannot be replaced.");
+        const changed = !existing || (await fingerprint(existing)) !== nextFingerprint;
+        if (claim.status === "accepted" && changed)
+            throw new Error("Accepted payout state changed outside its synchronization.");
+        if (claim.status === "accepted")
+            return {
+                status: "accepted",
+                generation: args.generation,
+                changed: false,
+                payout: existing,
+            };
+        const payout = changed ? await writePayout(ctx, args.payout) : existing;
+        await ctx.db.patch("payoutSyncClaims", claim._id, {
+            status: "accepted",
+            acceptedGeneration: args.generation,
+            acceptedAt: Date.now(),
+            acceptedFingerprint: nextFingerprint,
+        });
+        return {
+            status: "accepted",
+            generation: args.generation,
+            changed,
+            payout,
+        };
+    },
+});
+export const markUnknown = mutation({
+    args: { ...identity, generation: v.number() },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const claim = await claimByPayout(ctx, args);
+        if (claim?.generation === args.generation && claim.status === "pending")
+            await ctx.db.patch("payoutSyncClaims", claim._id, { status: "unknown" });
+        return null;
+    },
+});
+//# sourceMappingURL=mutations.js.map

package/dist/component/payoutSync/mutations.js.map

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

package/dist/component/payoutSync/queries.d.ts

@@ -0,0 +1,16 @@
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    stripePayoutId: string;
+    accountId: string;
+}, Promise<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutSyncClaims">;
+    acceptedAt?: number | undefined;
+    acceptedFingerprint?: string | undefined;
+    acceptedGeneration?: number | undefined;
+    accountId: string;
+    generation: number;
+    startedAt: number;
+    status: "accepted" | "pending" | "unknown";
+    stripePayoutId: string;
+} | null>>;
+//# sourceMappingURL=queries.d.ts.map

package/dist/component/payoutSync/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/component/payoutSync/queries.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;UAId,CAAC"}

package/dist/component/payoutSync/queries.js

@@ -0,0 +1,11 @@
+import { v } from "convex/values";
+import { query } from "../_generated/server.js";
+import { claimByPayout } from "./helpers.js";
+import { claimDoc } from "./schema.js";
+import { identity } from "./validators.js";
+export const get = query({
+    args: identity,
+    returns: v.union(claimDoc, v.null()),
+    handler: claimByPayout,
+});
+//# sourceMappingURL=queries.js.map

package/dist/component/payoutSync/queries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../src/component/payoutSync/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,MAAM,CAAC,MAAM,GAAG,GAAG,KAAK,CAAC;IACvB,IAAI,EAAE,QAAQ;IACd,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IACpC,OAAO,EAAE,aAAa;CACvB,CAAC,CAAC"}

package/dist/component/payoutSync/schema.d.ts

@@ -0,0 +1,46 @@
+export declare const claimDoc: import("convex/values").VObject<{
+    _creationTime: number;
+    _id: import("convex/values").GenericId<"payoutSyncClaims">;
+    acceptedAt?: number | undefined;
+    acceptedFingerprint?: string | undefined;
+    acceptedGeneration?: number | undefined;
+    accountId: string;
+    generation: number;
+    startedAt: number;
+    status: "accepted" | "pending" | "unknown";
+    stripePayoutId: string;
+}, {
+    stripePayoutId: import("convex/values").VString<string, "required">;
+    accountId: import("convex/values").VString<string, "required">;
+    generation: import("convex/values").VFloat64<number, "required">;
+    status: import("convex/values").VUnion<"accepted" | "pending" | "unknown", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"accepted", "required">, import("convex/values").VLiteral<"unknown", "required">], "required", never>;
+    startedAt: import("convex/values").VFloat64<number, "required">;
+    acceptedGeneration: import("convex/values").VFloat64<number | undefined, "optional">;
+    acceptedAt: import("convex/values").VFloat64<number | undefined, "optional">;
+    acceptedFingerprint: import("convex/values").VString<string | undefined, "optional">;
+    _id: import("convex/values").VId<import("convex/values").GenericId<"payoutSyncClaims">, "required">;
+    _creationTime: import("convex/values").VFloat64<number, "required">;
+}, "required", "_creationTime" | "_id" | "acceptedAt" | "acceptedFingerprint" | "acceptedGeneration" | "accountId" | "generation" | "startedAt" | "status" | "stripePayoutId">;
+/** Operational generations only. Financial facts remain in the existing payouts table. */
+export declare const claimsTable: import("convex/server").TableDefinition<import("convex/values").VObject<{
+    acceptedAt?: number | undefined;
+    acceptedFingerprint?: string | undefined;
+    acceptedGeneration?: number | undefined;
+    accountId: string;
+    generation: number;
+    startedAt: number;
+    status: "accepted" | "pending" | "unknown";
+    stripePayoutId: string;
+}, {
+    stripePayoutId: import("convex/values").VString<string, "required">;
+    accountId: import("convex/values").VString<string, "required">;
+    generation: import("convex/values").VFloat64<number, "required">;
+    status: import("convex/values").VUnion<"accepted" | "pending" | "unknown", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"accepted", "required">, import("convex/values").VLiteral<"unknown", "required">], "required", never>;
+    startedAt: import("convex/values").VFloat64<number, "required">;
+    acceptedGeneration: import("convex/values").VFloat64<number | undefined, "optional">;
+    acceptedAt: import("convex/values").VFloat64<number | undefined, "optional">;
+    acceptedFingerprint: import("convex/values").VString<string | undefined, "optional">;
+}, "required", "acceptedAt" | "acceptedFingerprint" | "acceptedGeneration" | "accountId" | "generation" | "startedAt" | "status" | "stripePayoutId">, {
+    by_stripe_payout_id: ["stripePayoutId", "_creationTime"];
+}, {}, {}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/component/payoutSync/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/component/payoutSync/schema.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;8KAInB,CAAC;AACH,0FAA0F;AAC1F,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;UAEtB,CAAC"}

package/dist/component/payoutSync/schema.js

@@ -0,0 +1,22 @@
+import { defineTable } from "convex/server";
+import { v } from "convex/values";
+import { identity } from "./validators.js";
+const fields = {
+    ...identity,
+    generation: v.number(),
+    status: v.union(v.literal("pending"), v.literal("accepted"), v.literal("unknown")),
+    startedAt: v.number(),
+    acceptedGeneration: v.optional(v.number()),
+    acceptedAt: v.optional(v.number()),
+    acceptedFingerprint: v.optional(v.string()),
+};
+export const claimDoc = v.object({
+    ...fields,
+    _id: v.id("payoutSyncClaims"),
+    _creationTime: v.number(),
+});
+/** Operational generations only. Financial facts remain in the existing payouts table. */
+export const claimsTable = defineTable(fields).index("by_stripe_payout_id", [
+    "stripePayoutId",
+]);
+//# sourceMappingURL=schema.js.map

package/dist/component/payoutSync/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/component/payoutSync/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,MAAM,MAAM,GAAG;IACb,GAAG,QAAQ;IACX,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,MAAM,EAAE,CAAC,CAAC,KAAK,CACb,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,EACpB,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EACrB,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CACrB;IACD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,kBAAkB,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1C,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAClC,mBAAmB,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CAC5C,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B,GAAG,MAAM;IACT,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC;IAC7B,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;CAC1B,CAAC,CAAC;AACH,0FAA0F;AAC1F,MAAM,CAAC,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,qBAAqB,EAAE;IAC1E,gBAAgB;CACjB,CAAC,CAAC"}

package/dist/component/payoutSync/validators.d.ts

@@ -0,0 +1,137 @@
+export declare const identity: {
+    stripePayoutId: import("convex/values").VString<string, "required">;
+    accountId: import("convex/values").VString<string, "required">;
+};
+export declare const snapshot: import("convex/values").VObject<{
+    accountId: string;
+    amount: number;
+    arrivalDate?: string | undefined;
+    currency: string;
+    failureCode?: string | undefined;
+    failureMessage?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    method?: string | undefined;
+    status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+    stripePayoutId: string;
+}, {
+    stripePayoutId: import("convex/values").VString<string, "required">;
+    accountId: import("convex/values").VString<string, "required">;
+    amount: import("convex/values").VFloat64<number, "required">;
+    currency: import("convex/values").VString<string, "required">;
+    status: import("convex/values").VUnion<"canceled" | "failed" | "in_transit" | "paid" | "pending", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"paid", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">, import("convex/values").VLiteral<"in_transit", "required">], "required", never>;
+    arrivalDate: import("convex/values").VString<string | undefined, "optional">;
+    method: import("convex/values").VString<string | undefined, "optional">;
+    failureCode: import("convex/values").VString<string | undefined, "optional">;
+    failureMessage: import("convex/values").VString<string | undefined, "optional">;
+    metadata: import("convex/values").VRecord<Record<string, string> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VString<string, "required">, "optional", string>;
+}, "required", "accountId" | "amount" | "arrivalDate" | "currency" | "failureCode" | "failureMessage" | "metadata" | "method" | "status" | "stripePayoutId" | `metadata.${string}`>;
+export declare const prepared: {
+    stripePayoutId: import("convex/values").VString<string, "required">;
+    accountId: import("convex/values").VString<string, "required">;
+    generation: import("convex/values").VFloat64<number, "required">;
+    payout: import("convex/values").VObject<{
+        accountId: string;
+        amount: number;
+        arrivalDate?: string | undefined;
+        currency: string;
+        failureCode?: string | undefined;
+        failureMessage?: string | undefined;
+        metadata?: Record<string, string> | undefined;
+        method?: string | undefined;
+        status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+        stripePayoutId: string;
+    }, {
+        stripePayoutId: import("convex/values").VString<string, "required">;
+        accountId: import("convex/values").VString<string, "required">;
+        amount: import("convex/values").VFloat64<number, "required">;
+        currency: import("convex/values").VString<string, "required">;
+        status: import("convex/values").VUnion<"canceled" | "failed" | "in_transit" | "paid" | "pending", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"paid", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">, import("convex/values").VLiteral<"in_transit", "required">], "required", never>;
+        arrivalDate: import("convex/values").VString<string | undefined, "optional">;
+        method: import("convex/values").VString<string | undefined, "optional">;
+        failureCode: import("convex/values").VString<string | undefined, "optional">;
+        failureMessage: import("convex/values").VString<string | undefined, "optional">;
+        metadata: import("convex/values").VRecord<Record<string, string> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VString<string, "required">, "optional", string>;
+    }, "required", "accountId" | "amount" | "arrivalDate" | "currency" | "failureCode" | "failureMessage" | "metadata" | "method" | "status" | "stripePayoutId" | `metadata.${string}`>;
+};
+export declare const result: import("convex/values").VUnion<{
+    changed: boolean;
+    generation: number;
+    payout: {
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"payouts">;
+        accountId: string;
+        amount: number;
+        arrivalDate?: string | undefined;
+        currency: string;
+        failureCode?: string | undefined;
+        failureMessage?: string | undefined;
+        metadata?: any;
+        method?: string | undefined;
+        status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+        stripePayoutId: string;
+        totalsRecorded?: true | undefined;
+    };
+    status: "accepted";
+} | {
+    generation: number;
+    status: "superseded";
+}, [import("convex/values").VObject<{
+    changed: boolean;
+    generation: number;
+    payout: {
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"payouts">;
+        accountId: string;
+        amount: number;
+        arrivalDate?: string | undefined;
+        currency: string;
+        failureCode?: string | undefined;
+        failureMessage?: string | undefined;
+        metadata?: any;
+        method?: string | undefined;
+        status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+        stripePayoutId: string;
+        totalsRecorded?: true | undefined;
+    };
+    status: "accepted";
+}, {
+    status: import("convex/values").VLiteral<"accepted", "required">;
+    generation: import("convex/values").VFloat64<number, "required">;
+    changed: import("convex/values").VBoolean<boolean, "required">;
+    payout: import("convex/values").VObject<{
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"payouts">;
+        accountId: string;
+        amount: number;
+        arrivalDate?: string | undefined;
+        currency: string;
+        failureCode?: string | undefined;
+        failureMessage?: string | undefined;
+        metadata?: any;
+        method?: string | undefined;
+        status: "canceled" | "failed" | "in_transit" | "paid" | "pending";
+        stripePayoutId: string;
+        totalsRecorded?: true | undefined;
+    }, {
+        stripePayoutId: import("convex/values").VString<string, "required">;
+        accountId: import("convex/values").VString<string, "required">;
+        amount: import("convex/values").VFloat64<number, "required">;
+        currency: import("convex/values").VString<string, "required">;
+        status: import("convex/values").VUnion<"canceled" | "failed" | "in_transit" | "paid" | "pending", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"paid", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">, import("convex/values").VLiteral<"in_transit", "required">], "required", never>;
+        arrivalDate: import("convex/values").VString<string | undefined, "optional">;
+        method: import("convex/values").VString<string | undefined, "optional">;
+        failureCode: import("convex/values").VString<string | undefined, "optional">;
+        failureMessage: import("convex/values").VString<string | undefined, "optional">;
+        metadata: import("convex/values").VAny<any, "optional", string>;
+        _id: import("convex/values").VId<import("convex/values").GenericId<"payouts">, "required">;
+        _creationTime: import("convex/values").VFloat64<number, "required">;
+        totalsRecorded: import("convex/values").VLiteral<true | undefined, "optional">;
+    }, "required", "_creationTime" | "_id" | "accountId" | "amount" | "arrivalDate" | "currency" | "failureCode" | "failureMessage" | "metadata" | "method" | "status" | "stripePayoutId" | "totalsRecorded" | `metadata.${string}`>;
+}, "required", "changed" | "generation" | "payout" | "payout._creationTime" | "payout._id" | "payout.accountId" | "payout.amount" | "payout.arrivalDate" | "payout.currency" | "payout.failureCode" | "payout.failureMessage" | "payout.metadata" | "payout.method" | "payout.status" | "payout.stripePayoutId" | "payout.totalsRecorded" | "status" | `payout.metadata.${string}`>, import("convex/values").VObject<{
+    generation: number;
+    status: "superseded";
+}, {
+    status: import("convex/values").VLiteral<"superseded", "required">;
+    generation: import("convex/values").VFloat64<number, "required">;
+}, "required", "generation" | "status">], "required", "changed" | "generation" | "payout" | "payout._creationTime" | "payout._id" | "payout.accountId" | "payout.amount" | "payout.arrivalDate" | "payout.currency" | "payout.failureCode" | "payout.failureMessage" | "payout.metadata" | "payout.method" | "payout.status" | "payout.stripePayoutId" | "payout.totalsRecorded" | "status" | `payout.metadata.${string}`>;
+//# sourceMappingURL=validators.d.ts.map

package/dist/component/payoutSync/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../src/component/payoutSync/validators.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;IAAK,cAAc;IAAc,SAAS;CAAc,CAAC;AAC9E,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;mLAGnB,CAAC;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AACF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0ZAQlB,CAAC"}

package/dist/component/payoutSync/validators.js

@@ -0,0 +1,19 @@
+import { v } from "convex/values";
+import { payoutFields, payoutDocValidator } from "../connect/validators.js";
+export const identity = { stripePayoutId: v.string(), accountId: v.string() };
+export const snapshot = v.object({
+    ...payoutFields,
+    metadata: v.optional(v.record(v.string(), v.string())),
+});
+export const prepared = {
+    ...identity,
+    generation: v.number(),
+    payout: snapshot,
+};
+export const result = v.union(v.object({
+    status: v.literal("accepted"),
+    generation: v.number(),
+    changed: v.boolean(),
+    payout: payoutDocValidator,
+}), v.object({ status: v.literal("superseded"), generation: v.number() }));
+//# sourceMappingURL=validators.js.map

package/dist/component/payoutSync/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../../src/component/payoutSync/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC5E,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;AAC9E,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B,GAAG,YAAY;IACf,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;CACvD,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,GAAG,QAAQ;IACX,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,MAAM,EAAE,QAAQ;CACjB,CAAC;AACF,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAC3B,CAAC,CAAC,MAAM,CAAC;IACP,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;IAC7B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,MAAM,EAAE,kBAAkB;CAC3B,CAAC,EACF,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CACtE,CAAC"}