@codelitdev/billing 0.1.0-alpha.1

package/dist/adapters/drizzle/store.js

@@ -0,0 +1,889 @@
+import { and, eq, inArray, isNotNull, isNull, lte, or } from "drizzle-orm";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { nanoid } from "nanoid";
+import { BillingCompositionError } from "../../core/errors.js";
+export function createDrizzleBillingStore(db, options) {
+    const schema = options.schema;
+    const transactionContext = new AsyncLocalStorage();
+    function activeDb() {
+        return (transactionContext.getStore() ?? db);
+    }
+    function t(key) {
+        return schema[key];
+    }
+    async function one(table, where) {
+        let query = activeDb().select().from(table).where(where);
+        if (transactionContext.getStore())
+            query = query.for("update");
+        const rows = (await query.limit(1));
+        return rows[0];
+    }
+    async function many(table, where, limit) {
+        let q = activeDb().select().from(table);
+        if (transactionContext.getStore())
+            q = q.for("update");
+        if (where)
+            q = q.where(where);
+        if (limit !== undefined)
+            q = q.limit(limit);
+        return (await q);
+    }
+    function mapPrice(row) {
+        return {
+            id: String(row.id),
+            offerKey: String(row.offerKey),
+            plan: String(row.plan),
+            interval: row.billingInterval,
+            currency: String(row.currency),
+            amountMinor: Number(row.amountMinor),
+            providerTrialDays: Number(row.providerTrialDays ?? 0),
+            provider: String(row.provider),
+            providerProductId: String(row.providerProductId),
+            verifiedAt: row.verifiedAt ?? null,
+        };
+    }
+    function mapRevision(row) {
+        return {
+            id: String(row.id),
+            revision: Number(row.revision),
+            checkoutProvider: String(row.checkoutProvider),
+            status: row.status,
+            verifiedAt: row.verifiedAt ?? null,
+            activatedAt: row.activatedAt ?? null,
+            retiredAt: row.retiredAt ?? null,
+        };
+    }
+    function mapCustomer(row) {
+        return {
+            id: String(row.id),
+            provider: String(row.provider),
+            payerId: String(row.payerId),
+            payerEmail: String(row.payerEmail ?? ""),
+            providerCustomerId: row.providerCustomerId ?? null,
+            idempotencyKey: String(row.idempotencyKey),
+            status: row.status,
+            lastError: row.lastError ?? null,
+        };
+    }
+    function mapCheckout(row) {
+        return {
+            id: String(row.id),
+            attemptId: String(row.attemptId),
+            billableEntityId: String(row.billableEntityId),
+            payerId: String(row.payerId),
+            payerEmail: String(row.payerEmail ?? ""),
+            returnUrl: String(row.returnUrl ?? ""),
+            provider: String(row.provider),
+            catalogRevision: Number(row.catalogRevision),
+            offerKey: String(row.offerKey),
+            plan: String(row.requestedPlan ?? row.plan),
+            interval: (row.requestedInterval ?? row.interval),
+            priceEntryId: String(row.billingPriceEntryId ?? row.priceEntryId),
+            quotedAmountMinor: Number(row.quotedAmountMinor),
+            quotedCurrency: String(row.quotedCurrency),
+            providerCustomerRowId: row.billingCustomerId ?? null,
+            providerCheckoutSessionId: row.providerCheckoutSessionId ?? null,
+            checkoutUrlEncrypted: row.checkoutUrlEncrypted ?? null,
+            idempotencyKey: String(row.idempotencyKey),
+            status: row.status,
+            expiresAt: row.expiresAt,
+            lastError: row.lastError ?? null,
+            completedAt: row.completedAt ?? null,
+            applicationFields: options.checkoutApplicationFields?.fromRow(row) ?? undefined,
+        };
+    }
+    function checkoutApplicationColumns(fields) {
+        if (!fields || Object.keys(fields).length === 0)
+            return {};
+        if (!options.checkoutApplicationFields) {
+            throw new BillingCompositionError("checkout_application_fields_codec_required");
+        }
+        const encoded = options.checkoutApplicationFields.toColumns(fields);
+        if (!encoded || typeof encoded !== "object" || Array.isArray(encoded)) {
+            throw new BillingCompositionError("checkout_application_fields_codec_invalid");
+        }
+        return encoded;
+    }
+    function mapSubscription(row) {
+        return {
+            id: String(row.id),
+            billableEntityId: String(row.billableEntityId),
+            payerId: String(row.payerId),
+            provider: String(row.provider),
+            providerCustomerId: String(row.billingCustomerId),
+            providerSubscriptionId: String(row.providerSubscriptionId),
+            providerProductId: String(row.providerProductId),
+            catalogRevision: Number(row.catalogRevision),
+            offerKey: String(row.offerKey),
+            plan: String(row.plan),
+            interval: row.billingInterval,
+            priceEntryId: String(row.billingPriceEntryId),
+            status: row.status,
+            currentPeriodStartsAt: row.currentPeriodStartsAt ?? null,
+            currentPeriodEndsAt: row.currentPeriodEndsAt ?? null,
+            paidThroughAt: row.paidThroughAt ?? null,
+            trialEndsAt: row.trialEndsAt ?? null,
+            cancelAtPeriodEnd: Boolean(row.cancelAtPeriodEnd),
+            isEntitlementSource: Boolean(row.isEntitlementSource),
+            originCheckoutAttemptId: row.originCheckoutAttemptId ?? null,
+            providerOccurredAt: row.providerOccurredAt ?? null,
+            providerVersion: row.providerVersion ?? null,
+            lastObservedAt: row.lastObservedAt ?? null,
+            lastReconciledAt: row.lastReconciledAt ?? null,
+        };
+    }
+    function mapPlanChange(row) {
+        return {
+            id: String(row.id),
+            changeId: String(row.changeId),
+            billableEntityId: String(row.billableEntityId),
+            subscriptionId: String(row.subscriptionId),
+            actorId: String(row.actorId),
+            payerId: String(row.payerId),
+            provider: String(row.provider),
+            idempotencyKey: String(row.idempotencyKey),
+            currentCatalogRevision: Number(row.currentCatalogRevision),
+            currentPriceEntryId: String(row.currentBillingPriceEntryId),
+            currentPlan: String(row.currentPlan),
+            currentInterval: row.currentInterval,
+            targetCatalogRevision: Number(row.targetCatalogRevision),
+            targetPriceEntryId: String(row.targetBillingPriceEntryId),
+            targetPlan: String(row.targetPlan),
+            targetInterval: row.targetInterval,
+            targetOfferKey: String(row.targetOfferKey),
+            effectiveAt: row.effectiveAt,
+            prorationMode: row.prorationMode,
+            status: row.status,
+            lastError: row.lastError ?? null,
+            providerPaymentId: row.providerPaymentId ?? null,
+            paymentUrlEncrypted: row.paymentUrlEncrypted ?? null,
+            completedAt: row.completedAt ?? null,
+        };
+    }
+    function mapWebhook(row) {
+        const subscriptionId = row.subscriptionId ?? null;
+        const checkoutAttemptId = row.checkoutAttemptId ?? null;
+        return {
+            id: String(row.id),
+            provider: String(row.provider),
+            providerEventId: String(row.providerEventId),
+            eventType: String(row.eventType),
+            occurredAt: row.occurredAt,
+            subscriptionId,
+            checkoutAttemptId,
+            payloadEncrypted: row.payloadEncrypted ?? null,
+            payloadKeyVersion: row.payloadKeyVersion ?? null,
+            verifiedKeyVersion: row.verifiedKeyVersion ?? null,
+            status: row.status,
+            processingAttempts: Number(row.processingAttempts ?? 0),
+            lastError: row.lastError ?? null,
+            availableAt: row.availableAt,
+            lockedAt: row.lockedAt ?? null,
+            leaseExpiresAt: row.leaseExpiresAt ?? null,
+            workerId: row.workerId ?? null,
+            processedAt: row.processedAt ?? null,
+        };
+    }
+    function mapJob(row) {
+        return {
+            id: String(row.id),
+            provider: String(row.provider),
+            checkoutAttemptId: row.checkoutAttemptId ?? null,
+            planChangeAttemptId: row.planChangeAttemptId ?? null,
+            subscriptionId: row.subscriptionId ?? null,
+            providerCustomerId: row.providerCustomerId ?? null,
+            operation: row.operation,
+            status: row.status,
+            attemptCount: Number(row.attemptCount ?? 0),
+            availableAt: row.availableAt,
+            lockedAt: row.lockedAt ?? null,
+            leaseExpiresAt: row.leaseExpiresAt ?? null,
+            workerId: row.workerId ?? null,
+            lastError: row.lastError ?? null,
+        };
+    }
+    const store = {
+        transactionDepth: 0,
+        isInTransaction() {
+            return transactionContext.getStore() !== undefined;
+        },
+        getTransaction() {
+            return transactionContext.getStore();
+        },
+        async withTransaction(fn) {
+            store.transactionDepth += 1;
+            try {
+                return await db.transaction((tx) => transactionContext.run(tx, () => fn.length > 0
+                    ? fn(tx)
+                    : fn()));
+            }
+            finally {
+                store.transactionDepth -= 1;
+            }
+        },
+        noteProviderCall() {
+            if (transactionContext.getStore()) {
+                throw new Error("transaction_open_across_provider_call");
+            }
+        },
+        async getActiveCatalog(providerName) {
+            const revision = await one(t("billingCatalogRevisions"), and(eq(t("billingCatalogRevisions").checkoutProvider, providerName), eq(t("billingCatalogRevisions").status, "active")));
+            if (!revision)
+                return null;
+            const items = await many(t("billingCatalogRevisionItems"), eq(t("billingCatalogRevisionItems").catalogRevisionId, revision.id));
+            const prices = await many(t("billingPriceEntries"));
+            return {
+                revision: mapRevision(revision),
+                items: items.map((item) => ({
+                    offerKey: String(item.offerKey),
+                    price: mapPrice(prices.find((price) => price.id === item.billingPriceEntryId)),
+                })),
+            };
+        },
+        async getCatalogRevision(providerName, revisionNumber) {
+            const revision = await one(t("billingCatalogRevisions"), and(eq(t("billingCatalogRevisions").checkoutProvider, providerName), eq(t("billingCatalogRevisions").revision, revisionNumber)));
+            if (!revision)
+                return null;
+            const items = await many(t("billingCatalogRevisionItems"), eq(t("billingCatalogRevisionItems").catalogRevisionId, revision.id));
+            const prices = await many(t("billingPriceEntries"));
+            return {
+                revision: mapRevision(revision),
+                items: items.map((item) => {
+                    const price = prices.find((candidate) => candidate.id === item.billingPriceEntryId);
+                    if (!price)
+                        throw new Error("catalog_price_missing");
+                    return {
+                        offerKey: String(item.offerKey),
+                        price: mapPrice(price),
+                    };
+                }),
+            };
+        },
+        async insertCatalogRevision(revision) {
+            await activeDb().insert(t("billingCatalogRevisions")).values({
+                id: revision.id,
+                revision: revision.revision,
+                checkoutProvider: revision.checkoutProvider,
+                status: revision.status,
+                verifiedAt: revision.verifiedAt,
+                activatedAt: revision.activatedAt,
+                retiredAt: revision.retiredAt,
+            });
+        },
+        async saveCatalogRevision(revision) {
+            await activeDb()
+                .update(t("billingCatalogRevisions"))
+                .set({
+                status: revision.status,
+                verifiedAt: revision.verifiedAt,
+                activatedAt: revision.activatedAt,
+                retiredAt: revision.retiredAt,
+                updatedAt: options.clock.now(),
+            })
+                .where(eq(t("billingCatalogRevisions").id, revision.id));
+        },
+        async insertPriceEntry(price) {
+            await activeDb().insert(t("billingPriceEntries")).values({
+                id: price.id,
+                offerKey: price.offerKey,
+                plan: price.plan,
+                billingInterval: price.interval,
+                currency: price.currency,
+                amountMinor: price.amountMinor,
+                providerTrialDays: price.providerTrialDays,
+                provider: price.provider,
+                providerProductId: price.providerProductId,
+                verifiedAt: price.verifiedAt,
+            });
+        },
+        async insertCatalogRevisionItem(item) {
+            await activeDb().insert(t("billingCatalogRevisionItems")).values({
+                id: item.id,
+                catalogRevisionId: item.revisionId,
+                offerKey: item.offerKey,
+                billingPriceEntryId: item.priceEntryId,
+            });
+        },
+        async findPriceById(id) {
+            const row = await one(t("billingPriceEntries"), eq(t("billingPriceEntries").id, id));
+            return row ? mapPrice(row) : undefined;
+        },
+        async findPriceByProviderProduct(providerName, productId) {
+            const row = await one(t("billingPriceEntries"), and(eq(t("billingPriceEntries").provider, providerName), eq(t("billingPriceEntries").providerProductId, productId)));
+            return row ? mapPrice(row) : undefined;
+        },
+        async listRevisions() {
+            const rows = await many(t("billingCatalogRevisions"));
+            return rows.map(mapRevision);
+        },
+        newAttemptId() {
+            return `bca_${nanoid(12)}`;
+        },
+        newChangeId() {
+            return `bpc_${nanoid(12)}`;
+        },
+        async ensurePlanState(billableEntityId) {
+            const existing = await one(t("billingPlanStates"), eq(t("billingPlanStates").billableEntityId, billableEntityId));
+            if (existing) {
+                return {
+                    billableEntityId,
+                    activeSubscriptionId: existing.activeSubscriptionId ??
+                        null,
+                    projectionVersion: Number(existing.projectionVersion ?? 0),
+                };
+            }
+            await activeDb()
+                .insert(t("billingPlanStates"))
+                .values({
+                billableEntityId,
+                activeSubscriptionId: null,
+                projectionVersion: 0,
+                ...(options.planStateDefaults ?? {}),
+            });
+            return {
+                billableEntityId,
+                activeSubscriptionId: null,
+                projectionVersion: 0,
+            };
+        },
+        async findPlanState(billableEntityId) {
+            const existing = await one(t("billingPlanStates"), eq(t("billingPlanStates").billableEntityId, billableEntityId));
+            return existing
+                ? {
+                    billableEntityId,
+                    activeSubscriptionId: existing.activeSubscriptionId ??
+                        null,
+                    projectionVersion: Number(existing.projectionVersion ?? 0),
+                }
+                : undefined;
+        },
+        async savePlanState(state) {
+            await activeDb()
+                .update(t("billingPlanStates"))
+                .set({
+                activeSubscriptionId: state.activeSubscriptionId,
+                projectionVersion: state.projectionVersion,
+                updatedAt: options.clock.now(),
+            })
+                .where(eq(t("billingPlanStates").billableEntityId, state.billableEntityId));
+        },
+        async findCustomerByPayer(providerName, payerId) {
+            const row = await one(t("billingProviderCustomers"), and(eq(t("billingProviderCustomers").provider, providerName), eq(t("billingProviderCustomers").payerId, payerId)));
+            return row ? mapCustomer(row) : undefined;
+        },
+        async findCustomerById(id) {
+            const row = await one(t("billingProviderCustomers"), eq(t("billingProviderCustomers").id, id));
+            return row ? mapCustomer(row) : undefined;
+        },
+        async findCustomerByProviderCustomerId(providerName, providerCustomerId) {
+            const row = await one(t("billingProviderCustomers"), and(eq(t("billingProviderCustomers").provider, providerName), eq(t("billingProviderCustomers")
+                .providerCustomerId, providerCustomerId)));
+            return row ? mapCustomer(row) : undefined;
+        },
+        async listCustomersByPayer(payerId) {
+            const rows = await many(t("billingProviderCustomers"), eq(t("billingProviderCustomers").payerId, payerId));
+            return rows.map(mapCustomer);
+        },
+        async insertCustomer(customer) {
+            await activeDb().insert(t("billingProviderCustomers")).values({
+                id: customer.id,
+                provider: customer.provider,
+                payerId: customer.payerId,
+                payerEmail: customer.payerEmail,
+                providerCustomerId: customer.providerCustomerId,
+                idempotencyKey: customer.idempotencyKey,
+                status: customer.status,
+                lastError: customer.lastError,
+            });
+        },
+        async saveCustomer(customer) {
+            await activeDb()
+                .update(t("billingProviderCustomers"))
+                .set({
+                providerCustomerId: customer.providerCustomerId,
+                payerEmail: customer.payerEmail,
+                status: customer.status,
+                lastError: customer.lastError,
+                updatedAt: options.clock.now(),
+            })
+                .where(eq(t("billingProviderCustomers").id, customer.id));
+        },
+        async findLiveCheckout(billableEntityId) {
+            const row = await one(t("billingCheckoutAttempts"), and(eq(t("billingCheckoutAttempts").billableEntityId, billableEntityId), inArray(t("billingCheckoutAttempts").status, [
+                "creating",
+                "open",
+            ])));
+            return row ? mapCheckout(row) : undefined;
+        },
+        async findCheckoutById(id) {
+            const row = await one(t("billingCheckoutAttempts"), eq(t("billingCheckoutAttempts").id, id));
+            return row ? mapCheckout(row) : undefined;
+        },
+        async findCheckoutByAttemptId(attemptId) {
+            const row = await one(t("billingCheckoutAttempts"), eq(t("billingCheckoutAttempts").attemptId, attemptId));
+            return row ? mapCheckout(row) : undefined;
+        },
+        async insertCheckout(attempt) {
+            await activeDb()
+                .insert(t("billingCheckoutAttempts"))
+                .values({
+                ...checkoutApplicationColumns(attempt.applicationFields),
+                id: attempt.id,
+                attemptId: attempt.attemptId,
+                billableEntityId: attempt.billableEntityId,
+                payerId: attempt.payerId,
+                payerEmail: attempt.payerEmail,
+                returnUrl: attempt.returnUrl,
+                provider: attempt.provider,
+                catalogRevision: attempt.catalogRevision,
+                offerKey: attempt.offerKey,
+                requestedPlan: attempt.plan,
+                requestedInterval: attempt.interval,
+                billingPriceEntryId: attempt.priceEntryId,
+                quotedAmountMinor: attempt.quotedAmountMinor,
+                quotedCurrency: attempt.quotedCurrency,
+                billingCustomerId: attempt.providerCustomerRowId,
+                providerCheckoutSessionId: attempt.providerCheckoutSessionId,
+                checkoutUrlEncrypted: attempt.checkoutUrlEncrypted,
+                idempotencyKey: attempt.idempotencyKey,
+                status: attempt.status,
+                expiresAt: attempt.expiresAt,
+                lastError: attempt.lastError,
+                completedAt: attempt.completedAt,
+            });
+        },
+        async saveCheckout(attempt) {
+            await activeDb()
+                .update(t("billingCheckoutAttempts"))
+                .set({
+                ...checkoutApplicationColumns(attempt.applicationFields),
+                billingCustomerId: attempt.providerCustomerRowId,
+                payerEmail: attempt.payerEmail,
+                returnUrl: attempt.returnUrl,
+                providerCheckoutSessionId: attempt.providerCheckoutSessionId,
+                checkoutUrlEncrypted: attempt.checkoutUrlEncrypted,
+                status: attempt.status,
+                lastError: attempt.lastError,
+                expiresAt: attempt.expiresAt,
+                completedAt: attempt.completedAt,
+                updatedAt: options.clock.now(),
+            })
+                .where(eq(t("billingCheckoutAttempts").id, attempt.id));
+        },
+        async countCreatingCheckouts() {
+            const rows = await many(t("billingCheckoutAttempts"), eq(t("billingCheckoutAttempts").status, "creating"));
+            return rows.length;
+        },
+        async listExpiredCheckouts(now, limit) {
+            const rows = await many(t("billingCheckoutAttempts"), and(inArray(t("billingCheckoutAttempts").status, [
+                "creating",
+                "open",
+            ]), lte(t("billingCheckoutAttempts").expiresAt, now)), limit);
+            return rows.map(mapCheckout);
+        },
+        async listPurgeableCheckouts(before, limit) {
+            const rows = await many(t("billingCheckoutAttempts"), and(inArray(t("billingCheckoutAttempts").status, [
+                "completed",
+                "expired",
+                "abandoned",
+                "conflicted",
+            ]), isNotNull(t("billingCheckoutAttempts")
+                .checkoutUrlEncrypted), lte(t("billingCheckoutAttempts").completedAt, before)), limit);
+            return rows.map(mapCheckout);
+        },
+        async findEntitlementSubscription(billableEntityId) {
+            const row = await one(t("billingSubscriptions"), and(eq(t("billingSubscriptions").billableEntityId, billableEntityId), eq(t("billingSubscriptions").isEntitlementSource, true)));
+            return row ? mapSubscription(row) : undefined;
+        },
+        async listSubscriptionsByEntity(billableEntityId) {
+            const rows = await many(t("billingSubscriptions"), eq(t("billingSubscriptions").billableEntityId, billableEntityId));
+            return rows.map(mapSubscription);
+        },
+        async findSubscriptionById(id) {
+            const row = await one(t("billingSubscriptions"), eq(t("billingSubscriptions").id, id));
+            return row ? mapSubscription(row) : undefined;
+        },
+        async findSubscriptionByProviderIds(providerName, providerSubscriptionId) {
+            const row = await one(t("billingSubscriptions"), and(eq(t("billingSubscriptions").provider, providerName), eq(t("billingSubscriptions")
+                .providerSubscriptionId, providerSubscriptionId)));
+            return row ? mapSubscription(row) : undefined;
+        },
+        async listSubscriptionsByPayer(payerId) {
+            const rows = await many(t("billingSubscriptions"), eq(t("billingSubscriptions").payerId, payerId));
+            return rows.map(mapSubscription);
+        },
+        async upsertSubscription(subscription) {
+            const existing = await store.findSubscriptionById(subscription.id);
+            const values = {
+                id: subscription.id,
+                billableEntityId: subscription.billableEntityId,
+                billingCustomerId: subscription.providerCustomerId,
+                payerId: subscription.payerId,
+                originCheckoutAttemptId: subscription.originCheckoutAttemptId,
+                provider: subscription.provider,
+                providerSubscriptionId: subscription.providerSubscriptionId,
+                providerProductId: subscription.providerProductId,
+                billingPriceEntryId: subscription.priceEntryId,
+                catalogRevision: subscription.catalogRevision,
+                offerKey: subscription.offerKey,
+                plan: subscription.plan,
+                billingInterval: subscription.interval,
+                status: subscription.status,
+                currentPeriodStartsAt: subscription.currentPeriodStartsAt,
+                currentPeriodEndsAt: subscription.currentPeriodEndsAt,
+                paidThroughAt: subscription.paidThroughAt,
+                trialEndsAt: subscription.trialEndsAt,
+                cancelAtPeriodEnd: subscription.cancelAtPeriodEnd,
+                isEntitlementSource: subscription.isEntitlementSource,
+                providerOccurredAt: subscription.providerOccurredAt,
+                providerVersion: subscription.providerVersion,
+                lastObservedAt: subscription.lastObservedAt,
+                lastReconciledAt: subscription.lastReconciledAt,
+                updatedAt: options.clock.now(),
+            };
+            if (existing) {
+                await activeDb()
+                    .update(t("billingSubscriptions"))
+                    .set(values)
+                    .where(eq(t("billingSubscriptions").id, subscription.id));
+            }
+            else {
+                await activeDb()
+                    .insert(t("billingSubscriptions"))
+                    .values(values);
+            }
+        },
+        async listDueSubscriptionDeadlines(now, limit) {
+            const rows = await many(t("billingSubscriptions"), and(eq(t("billingSubscriptions").isEntitlementSource, true), eq(t("billingSubscriptions").status, "cancelled"), eq(t("billingSubscriptions").cancelAtPeriodEnd, true), lte(t("billingSubscriptions").paidThroughAt, now)), limit);
+            return rows.map(mapSubscription);
+        },
+        async findLivePlanChange(billableEntityId) {
+            const row = await one(t("billingPlanChangeAttempts"), and(eq(t("billingPlanChangeAttempts")
+                .billableEntityId, billableEntityId), inArray(t("billingPlanChangeAttempts").status, [
+                "creating",
+                "pending",
+            ])));
+            return row ? mapPlanChange(row) : undefined;
+        },
+        async findPlanChangeBySubscriptionOffer(subscriptionId, offerKey) {
+            const row = await one(t("billingPlanChangeAttempts"), and(eq(t("billingPlanChangeAttempts").subscriptionId, subscriptionId), eq(t("billingPlanChangeAttempts").targetOfferKey, offerKey), inArray(t("billingPlanChangeAttempts").status, [
+                "creating",
+                "pending",
+            ])));
+            return row ? mapPlanChange(row) : undefined;
+        },
+        async findPlanChangeById(id) {
+            const row = await one(t("billingPlanChangeAttempts"), eq(t("billingPlanChangeAttempts").id, id));
+            return row ? mapPlanChange(row) : undefined;
+        },
+        async insertPlanChange(attempt) {
+            await activeDb()
+                .insert(t("billingPlanChangeAttempts"))
+                .values({
+                id: attempt.id,
+                changeId: attempt.changeId,
+                billableEntityId: attempt.billableEntityId,
+                subscriptionId: attempt.subscriptionId,
+                actorId: attempt.actorId,
+                payerId: attempt.payerId,
+                provider: attempt.provider,
+                idempotencyKey: attempt.idempotencyKey,
+                currentCatalogRevision: attempt.currentCatalogRevision,
+                currentBillingPriceEntryId: attempt.currentPriceEntryId,
+                currentPlan: attempt.currentPlan,
+                currentInterval: attempt.currentInterval,
+                targetCatalogRevision: attempt.targetCatalogRevision,
+                targetBillingPriceEntryId: attempt.targetPriceEntryId,
+                targetPlan: attempt.targetPlan,
+                targetInterval: attempt.targetInterval,
+                targetOfferKey: attempt.targetOfferKey,
+                effectiveAt: attempt.effectiveAt,
+                prorationMode: attempt.prorationMode,
+                providerPaymentId: attempt.providerPaymentId ?? null,
+                paymentUrlEncrypted: attempt.paymentUrlEncrypted ?? null,
+                status: attempt.status,
+                lastError: attempt.lastError,
+                completedAt: attempt.completedAt ?? null,
+            });
+        },
+        async savePlanChange(attempt) {
+            await activeDb()
+                .update(t("billingPlanChangeAttempts"))
+                .set({
+                status: attempt.status,
+                lastError: attempt.lastError,
+                providerPaymentId: attempt.providerPaymentId ?? null,
+                paymentUrlEncrypted: attempt.paymentUrlEncrypted ?? null,
+                completedAt: attempt.completedAt ?? null,
+                updatedAt: options.clock.now(),
+            })
+                .where(eq(t("billingPlanChangeAttempts").id, attempt.id));
+        },
+        async listPurgeablePlanChanges(before, limit) {
+            const rows = await many(t("billingPlanChangeAttempts"), and(inArray(t("billingPlanChangeAttempts").status, [
+                "succeeded",
+                "failed",
+                "conflicted",
+            ]), isNotNull(t("billingPlanChangeAttempts")
+                .paymentUrlEncrypted), lte(t("billingPlanChangeAttempts").completedAt, before)), limit);
+            return rows.map(mapPlanChange);
+        },
+        async findWebhook(providerName, providerEventId) {
+            const row = await one(t("billingWebhookEvents"), and(eq(t("billingWebhookEvents").provider, providerName), eq(t("billingWebhookEvents").providerEventId, providerEventId)));
+            return row ? mapWebhook(row) : undefined;
+        },
+        async findWebhookByEventId(providerEventId) {
+            const row = await one(t("billingWebhookEvents"), eq(t("billingWebhookEvents").providerEventId, providerEventId));
+            return row ? mapWebhook(row) : undefined;
+        },
+        async insertWebhook(record) {
+            await activeDb()
+                .insert(t("billingWebhookEvents"))
+                .values({
+                id: record.id,
+                provider: record.provider,
+                providerEventId: record.providerEventId,
+                eventType: record.eventType,
+                occurredAt: record.occurredAt,
+                subscriptionId: record.subscriptionId,
+                checkoutAttemptId: record.checkoutAttemptId,
+                payloadEncrypted: record.payloadEncrypted ?? null,
+                payloadKeyVersion: record.payloadKeyVersion ?? null,
+                verifiedKeyVersion: record.verifiedKeyVersion,
+                status: record.status,
+                processingAttempts: record.processingAttempts,
+                lastError: record.lastError,
+                availableAt: record.availableAt,
+                lockedAt: record.lockedAt,
+                leaseExpiresAt: record.leaseExpiresAt,
+                workerId: record.workerId,
+                processedAt: record.processedAt ?? null,
+            });
+        },
+        async saveWebhook(record) {
+            await activeDb()
+                .update(t("billingWebhookEvents"))
+                .set({
+                status: record.status,
+                processingAttempts: record.processingAttempts,
+                lastError: record.lastError,
+                availableAt: record.availableAt,
+                lockedAt: record.lockedAt,
+                leaseExpiresAt: record.leaseExpiresAt,
+                workerId: record.workerId,
+                processedAt: record.processedAt ?? null,
+                subscriptionId: record.subscriptionId,
+                checkoutAttemptId: record.checkoutAttemptId,
+                payloadEncrypted: record.payloadEncrypted ?? null,
+                payloadKeyVersion: record.payloadKeyVersion ?? null,
+            })
+                .where(eq(t("billingWebhookEvents").id, record.id));
+        },
+        async saveWebhookIfOwned(record, workerId) {
+            const rows = (await activeDb()
+                .update(t("billingWebhookEvents"))
+                .set({
+                status: record.status,
+                processingAttempts: record.processingAttempts,
+                lastError: record.lastError,
+                availableAt: record.availableAt,
+                lockedAt: record.lockedAt,
+                leaseExpiresAt: record.leaseExpiresAt,
+                workerId: record.workerId,
+                processedAt: record.processedAt ?? null,
+                subscriptionId: record.subscriptionId,
+                checkoutAttemptId: record.checkoutAttemptId,
+                payloadEncrypted: record.payloadEncrypted ?? null,
+                payloadKeyVersion: record.payloadKeyVersion ?? null,
+            })
+                .where(and(eq(t("billingWebhookEvents").id, record.id), eq(t("billingWebhookEvents").workerId, workerId), eq(t("billingWebhookEvents").status, "processing"), eq(t("billingWebhookEvents").lockedAt, record.lockedAt)))
+                .returning());
+            return rows.length > 0;
+        },
+        async listPurgeableWebhooks(before, limit) {
+            const rows = await many(t("billingWebhookEvents"), and(inArray(t("billingWebhookEvents").status, [
+                "processed",
+                "ignored",
+            ]), isNotNull(t("billingWebhookEvents").payloadEncrypted), lte(t("billingWebhookEvents").processedAt, before)), limit);
+            return rows.map(mapWebhook);
+        },
+        async listDueWebhooks(now, limit) {
+            const rows = await many(t("billingWebhookEvents"));
+            return rows
+                .map(mapWebhook)
+                .filter((row) => {
+                if (row.status === "processed" ||
+                    row.status === "ignored" ||
+                    row.status === "quarantined") {
+                    return false;
+                }
+                if (row.status === "processing" &&
+                    row.leaseExpiresAt &&
+                    row.leaseExpiresAt > now) {
+                    return false;
+                }
+                return row.availableAt <= now;
+            })
+                .slice(0, limit);
+        },
+        async claimDueWebhooks(now, limit, workerId) {
+            const candidates = await store.listDueWebhooks(now, limit);
+            if (candidates.length === 0)
+                return [];
+            return db.transaction(async (tx) => {
+                const claimed = [];
+                const table = t("billingWebhookEvents");
+                for (const candidate of candidates) {
+                    const rows = (await tx
+                        .update(table)
+                        .set({
+                        status: "processing",
+                        workerId,
+                        lockedAt: now,
+                        leaseExpiresAt: new Date(now.getTime() + 5 * 60 * 1000),
+                        processingAttempts: candidate.processingAttempts + 1,
+                    })
+                        .where(and(eq(table.id, candidate.id), lte(table.availableAt, now), or(inArray(table.status, [
+                        "pending",
+                        "failed",
+                    ]), and(eq(table.status, "processing"), or(isNull(table.leaseExpiresAt), lte(table.leaseExpiresAt, now))))))
+                        .returning());
+                    if (rows[0])
+                        claimed.push(mapWebhook(rows[0]));
+                }
+                return claimed;
+            });
+        },
+        async findLiveJob(subject) {
+            if (!subject.checkoutAttemptId &&
+                !subject.planChangeAttemptId &&
+                !subject.subscriptionId &&
+                !subject.providerCustomerId) {
+                return undefined;
+            }
+            const rows = await many(t("billingReconciliationJobs"));
+            return rows.map(mapJob).find((job) => {
+                if (job.status === "completed" || job.status === "quarantined")
+                    return false;
+                if (job.provider !== subject.provider)
+                    return false;
+                if (subject.checkoutAttemptId)
+                    return job.checkoutAttemptId === subject.checkoutAttemptId;
+                if (subject.planChangeAttemptId)
+                    return (job.planChangeAttemptId === subject.planChangeAttemptId);
+                if (subject.subscriptionId)
+                    return job.subscriptionId === subject.subscriptionId;
+                return job.providerCustomerId === subject.providerCustomerId;
+            });
+        },
+        async insertJob(job) {
+            await activeDb().insert(t("billingReconciliationJobs")).values(job);
+        },
+        async saveJob(job) {
+            await activeDb()
+                .update(t("billingReconciliationJobs"))
+                .set({
+                status: job.status,
+                attemptCount: job.attemptCount,
+                availableAt: job.availableAt,
+                lockedAt: job.lockedAt,
+                leaseExpiresAt: job.leaseExpiresAt,
+                workerId: job.workerId,
+                lastError: job.lastError,
+                operation: job.operation ?? "reconcile",
+                updatedAt: options.clock.now(),
+            })
+                .where(eq(t("billingReconciliationJobs").id, job.id));
+        },
+        async saveJobIfOwned(job, workerId) {
+            const rows = (await activeDb()
+                .update(t("billingReconciliationJobs"))
+                .set({
+                status: job.status,
+                attemptCount: job.attemptCount,
+                availableAt: job.availableAt,
+                lockedAt: job.lockedAt,
+                leaseExpiresAt: job.leaseExpiresAt,
+                workerId: job.workerId,
+                lastError: job.lastError,
+                operation: job.operation ?? "reconcile",
+                updatedAt: options.clock.now(),
+            })
+                .where(and(eq(t("billingReconciliationJobs").id, job.id), eq(t("billingReconciliationJobs").workerId, workerId), eq(t("billingReconciliationJobs").status, "processing"), eq(t("billingReconciliationJobs").lockedAt, job.lockedAt)))
+                .returning());
+            return rows.length > 0;
+        },
+        async listClaimableJobs(now, limit) {
+            const rows = await many(t("billingReconciliationJobs"));
+            const claimed = [];
+            for (const job of rows.map(mapJob)) {
+                if (claimed.length >= limit)
+                    break;
+                const leaseExpired = job.status === "processing" &&
+                    (!job.leaseExpiresAt ||
+                        job.leaseExpiresAt.getTime() <= now.getTime());
+                const claimable = (job.status === "pending" ||
+                    job.status === "failed" ||
+                    leaseExpired) &&
+                    job.availableAt.getTime() <= now.getTime();
+                if (claimable)
+                    claimed.push(job);
+            }
+            return claimed;
+        },
+        async claimClaimableJobs(now, limit, workerId) {
+            const candidates = await store.listClaimableJobs(now, limit);
+            if (candidates.length === 0)
+                return [];
+            return db.transaction(async (tx) => {
+                const claimed = [];
+                const table = t("billingReconciliationJobs");
+                for (const candidate of candidates) {
+                    const rows = (await tx
+                        .update(table)
+                        .set({
+                        status: "processing",
+                        workerId,
+                        lockedAt: now,
+                        leaseExpiresAt: new Date(now.getTime() + 5 * 60 * 1000),
+                        attemptCount: candidate.attemptCount + 1,
+                    })
+                        .where(and(eq(table.id, candidate.id), lte(table.availableAt, now), or(inArray(table.status, [
+                        "pending",
+                        "failed",
+                    ]), and(eq(table.status, "processing"), or(isNull(table.leaseExpiresAt), lte(table.leaseExpiresAt, now))))))
+                        .returning());
+                    if (rows[0])
+                        claimed.push(mapJob(rows[0]));
+                }
+                return claimed;
+            });
+        },
+        async health(_now, providerName) {
+            const webhooks = (await many(t("billingWebhookEvents"))).map(mapWebhook);
+            const jobs = (await many(t("billingReconciliationJobs"))).map(mapJob);
+            const checkouts = await many(t("billingCheckoutAttempts"));
+            const customers = await many(t("billingProviderCustomers"));
+            const subscriptions = (await many(t("billingSubscriptions"))).map(mapSubscription);
+            const pendingInbox = webhooks.filter((row) => row.status === "pending" || row.status === "failed");
+            const oldest = pendingInbox
+                .map((row) => row.occurredAt)
+                .sort((a, b) => a.getTime() - b.getTime())[0];
+            const revisions = await store.listRevisions();
+            const activeRevision = revisions.find((row) => row.status === "active" &&
+                (providerName === undefined ||
+                    row.checkoutProvider === providerName));
+            return {
+                oldestPendingInboxOccurredAt: oldest ?? null,
+                quarantinedWebhooks: webhooks.filter((row) => row.status === "quarantined").length,
+                quarantinedJobs: jobs.filter((row) => row.status === "quarantined").length,
+                stuckCreatingCheckouts: checkouts.filter((row) => row.status === "creating").length,
+                stuckCreatingCustomers: customers.filter((row) => row.status === "creating").length,
+                unreconciledSubscriptions: subscriptions.filter((row) => !row.lastReconciledAt).length,
+                activeRevision: activeRevision?.revision ?? null,
+            };
+        },
+    };
+    return store;
+}
+//# sourceMappingURL=store.js.map