@nlabs/reaktor 1.16.0 → 1.18.0

package/lib/organizations/reconciliation.js

@@ -0,0 +1,400 @@
+/* Stream-transaction operations and per-organization jobs must be ordered. */ /* eslint-disable no-await-in-loop */ import { randomUUID } from 'node:crypto';
+import { getOrganizationSubscription, requireBillingAdmin } from './billing.js';
+import { getOrganizationBillingProvider, organizationBillingMode } from './billingProvider.js';
+import { sendOrganizationMail } from './mail.js';
+import { getOrganizationPlan } from './plans.js';
+import { organizationKey, organizationStoreFor, requireIdentifier } from './store.js';
+const enqueue = async (tx, org, kind, desired)=>{
+    const previous = await tx.get('organizations', org.organizationId);
+    if (!previous || previous.revision !== org.revision) {
+        throw new Error('revision_conflict');
+    }
+    const sequence = org.revision + 1;
+    const jobId = organizationKey(org.organizationId, String(sequence));
+    const job = {
+        attempts: 0,
+        desired,
+        effectiveAt: Date.now(),
+        jobId,
+        kind,
+        leaseExpires: 0,
+        organizationId: org.organizationId,
+        owner: '',
+        priceVersion: '2026-10-v1',
+        sequence,
+        status: 'pending'
+    };
+    await tx.put('organizations', org.organizationId, {
+        ...previous,
+        revision: sequence,
+        updatedAt: job.effectiveAt
+    }, previous);
+    await tx.put('organizationBillingJobs', jobId, job);
+};
+export const reconcileOrganizationBillingEvent = (context, event)=>organizationStoreFor(context).transaction(async (tx)=>{
+        requireIdentifier(event.eventId);
+        requireIdentifier(event.customerId);
+        const key = organizationKey('event', event.eventId);
+        if (await tx.get('organizationBillingEvents', key)) {
+            return;
+        }
+        const records = await tx.find('organizationBilling', {
+            customerId: event.customerId
+        });
+        if (records.length > 1) {
+            throw new Error('billing_customer_conflict');
+        }
+        const billing = records[0];
+        await tx.put('organizationBillingEvents', key, {
+            customerId: event.customerId,
+            eventId: event.eventId,
+            organizationId: billing?.organizationId || '',
+            receivedAt: Date.now(),
+            status: billing ? 'pending' : 'ignored',
+            type: event.type
+        });
+        if (billing) {
+            const org = await tx.get('organizations', billing.organizationId);
+            if (!org) {
+                throw new Error('organization_state_invalid');
+            }
+            await enqueue(tx, org, 'reconcile', {
+                eventId: event.eventId
+            });
+        }
+    });
+export const processOrganizationBillingJobs = async (context, limit)=>{
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 20) {
+        throw new Error('invalid_billing_batch');
+    }
+    const store = organizationStoreFor(context);
+    const failed = new Set();
+    let completed = 0;
+    for(let i = 0; i < limit; i++){
+        const owner = randomUUID();
+        const job = await store.transaction(async (tx)=>{
+            const pending = (await tx.find('organizationBillingJobs', {
+                status: 'pending'
+            })).sort((a, b)=>Number(b.kind === 'cancel') - Number(a.kind === 'cancel') || a.sequence - b.sequence);
+            const firstByOrg = new Map();
+            for (const candidate of pending){
+                if (candidate.kind !== 'mail' && !firstByOrg.has(candidate.organizationId)) {
+                    firstByOrg.set(candidate.organizationId, candidate);
+                }
+            }
+            const candidate = pending.find((item)=>!failed.has(item.kind === 'mail' ? item.jobId : item.organizationId) && item.leaseExpires <= Date.now() && (item.kind === 'mail' || organizationBillingMode() === 'test' && firstByOrg.get(item.organizationId)?.jobId === item.jobId));
+            if (!candidate) {
+                return null;
+            }
+            const claimed = {
+                ...candidate,
+                attempts: candidate.attempts + 1,
+                leaseExpires: Date.now() + 120000,
+                owner
+            };
+            await tx.put('organizationBillingJobs', candidate.jobId, claimed, candidate);
+            return claimed;
+        });
+        if (!job) {
+            break;
+        }
+        const fence = async ()=>store.transaction(async (tx)=>{
+                const current = await tx.get('organizationBillingJobs', job.jobId);
+                if (current?.owner !== owner || current.status !== 'pending' || current.leaseExpires <= Date.now()) {
+                    throw new Error('billing_lease_lost');
+                }
+            });
+        try {
+            let snapshot = null;
+            let updateResult;
+            let billing = null;
+            if (job.kind === 'mail') {
+                await fence();
+                await sendOrganizationMail(String(job.desired.ciphertext));
+            } else {
+                billing = await store.transaction((tx)=>tx.get('organizationBilling', job.organizationId));
+                if (billing?.customerId) {
+                    const provider = await getOrganizationBillingProvider();
+                    await fence();
+                    snapshot = await provider.retrieve(billing.customerId, job.kind === 'reconcile' ? undefined : billing.subscription?.id);
+                    if (!snapshot && job.kind !== 'reconcile') {
+                        throw new Error('billing_subscription_unavailable');
+                    }
+                    if (snapshot && job.kind !== 'reconcile') {
+                        let transition = job;
+                        let includedInCheckout = false;
+                        if (job.kind === 'seats' && snapshot.startedAt && job.effectiveAt < snapshot.startedAt) {
+                            const sequence = billing.checkout?.sequence;
+                            if (!Number.isSafeInteger(sequence)) {
+                                throw new Error('billing_checkout_baseline_required');
+                            }
+                            includedInCheckout = job.sequence <= sequence;
+                            transition = {
+                                ...job,
+                                desired: {
+                                    ...job.desired,
+                                    previousExtraSeats: snapshot.extraSeats
+                                },
+                                effectiveAt: snapshot.startedAt
+                            };
+                        }
+                        if (!includedInCheckout) {
+                            updateResult = await provider.update(snapshot, transition, fence);
+                        }
+                        await fence();
+                        snapshot = await provider.retrieve(billing.customerId, snapshot.id);
+                        if (!snapshot) {
+                            throw new Error('billing_subscription_unavailable');
+                        }
+                    }
+                }
+            }
+            await store.transaction(async (tx)=>{
+                const current = await tx.get('organizationBillingJobs', job.jobId);
+                if (current?.owner !== owner || current.status !== 'pending' || current.leaseExpires <= Date.now()) {
+                    throw new Error('billing_lease_lost');
+                }
+                if (job.kind !== 'mail' && billing?.customerId) {
+                    const record = await tx.get('organizationBilling', job.organizationId);
+                    if (!record || record.customerId !== billing.customerId) {
+                        throw new Error('billing_customer_conflict');
+                    }
+                    const canceled = !snapshot || [
+                        'canceled',
+                        'incomplete_expired'
+                    ].includes(snapshot.status);
+                    let pendingChange = null;
+                    if (!canceled) {
+                        if (snapshot?.cancelAtPeriodEnd || job.kind === 'cancel') {
+                            pendingChange = 'cancel';
+                        } else if (snapshot?.pendingPlan) {
+                            pendingChange = snapshot.pendingPlan;
+                        } else if (job.kind === 'plan' && job.desired.changeAt === 'period_end') {
+                            pendingChange = String(job.desired.plan);
+                        } else if (record.pendingChange !== snapshot?.plan) {
+                            pendingChange = record.pendingChange || null;
+                        }
+                    }
+                    await tx.put('organizationBilling', job.organizationId, {
+                        ...record,
+                        pendingChange,
+                        periodEnd: snapshot?.periodEnd || null,
+                        plan: canceled ? null : snapshot.plan,
+                        status: snapshot?.status || 'canceled',
+                        subscription: snapshot
+                    }, record);
+                    if (snapshot) {
+                        const periodKey = organizationKey(job.organizationId, snapshot.id, String(snapshot.periodStart), job.jobId);
+                        if (!await tx.get('organizationBillingPeriods', periodKey)) {
+                            await tx.put('organizationBillingPeriods', periodKey, {
+                                adjustments: updateResult?.adjustments || [],
+                                effectiveAt: job.effectiveAt,
+                                jobId: job.jobId,
+                                organizationId: job.organizationId,
+                                priceVersion: job.priceVersion,
+                                recordedAt: Date.now(),
+                                sequence: job.sequence,
+                                snapshot
+                            });
+                        }
+                    }
+                    if (job.kind === 'reconcile') {
+                        const receiptKey = organizationKey('event', String(job.desired.eventId));
+                        const receipt = await tx.get('organizationBillingEvents', receiptKey);
+                        if (!receipt) {
+                            throw new Error('billing_event_missing');
+                        }
+                        await tx.put('organizationBillingEvents', receiptKey, {
+                            ...receipt,
+                            processedAt: Date.now(),
+                            status: 'processed'
+                        }, receipt);
+                    }
+                }
+                await tx.put('organizationBillingJobs', job.jobId, {
+                    ...current,
+                    leaseExpires: 0,
+                    owner: '',
+                    status: 'complete'
+                }, current);
+            });
+            completed++;
+        } catch  {
+            failed.add(job.kind === 'mail' ? job.jobId : job.organizationId);
+            await store.transaction(async (tx)=>{
+                const current = await tx.get('organizationBillingJobs', job.jobId);
+                if (current?.owner === owner && current.status === 'pending') {
+                    await tx.put('organizationBillingJobs', job.jobId, {
+                        ...current,
+                        leaseExpires: 0,
+                        owner: ''
+                    }, current);
+                }
+            });
+        }
+    }
+    return {
+        completed,
+        pending: (await store.transaction((tx)=>tx.find('organizationBillingJobs', {
+                status: 'pending'
+            }))).length
+    };
+};
+const requireSubscription = (billing)=>{
+    if (organizationBillingMode() !== 'test') {
+        throw new Error('billing_disabled');
+    }
+    if (!billing?.customerId || !billing.plan || billing.status !== 'active') {
+        throw new Error('billing_not_ready');
+    }
+    return billing;
+};
+const originalBoundary = (billing)=>{
+    const subscriptionId = billing.subscription?.id;
+    const targetPeriodEnd = billing.periodEnd;
+    if (!subscriptionId || !Number.isSafeInteger(targetPeriodEnd) || targetPeriodEnd <= Date.now()) {
+        throw new Error('billing_period_refresh_required');
+    }
+    return {
+        subscriptionId,
+        targetPeriodEnd: targetPeriodEnd
+    };
+};
+export const quoteOrganizationPlanChange = async (context, organizationId, plan)=>{
+    getOrganizationPlan(plan);
+    const store = organizationStoreFor(context);
+    const intent = await store.transaction(async (tx)=>{
+        const access = await requireBillingAdmin(tx, context, organizationId);
+        const billing = requireSubscription(await tx.get('organizationBilling', organizationId));
+        return {
+            billing,
+            organization: access.organization
+        };
+    });
+    const provider = await getOrganizationBillingProvider();
+    const subscription = await provider.retrieve(intent.billing.customerId);
+    if (!subscription || subscription.status !== 'active') {
+        throw new Error('billing_not_ready');
+    }
+    const now = Date.now();
+    const prorationCents = await provider.preview(subscription, plan, subscription.extraSeats, now);
+    const quote = {
+        currency: 'usd',
+        expiresAt: now + 300000,
+        organizationRevision: intent.organization.revision,
+        prorationCents,
+        quantity: subscription.extraSeats,
+        quoteId: randomUUID()
+    };
+    await store.transaction(async (tx)=>{
+        const access = await requireBillingAdmin(tx, context, organizationId);
+        if (access.organization.revision !== quote.organizationRevision) {
+            throw new Error('revision_conflict');
+        }
+        await tx.put('organizationBillingQuotes', quote.quoteId, {
+            ...quote,
+            kind: 'plan',
+            organizationId,
+            plan,
+            used: false
+        });
+    });
+    return quote;
+};
+export const changeOrganizationPlan = async (context, organizationId, plan, confirmedQuoteId)=>{
+    getOrganizationPlan(plan);
+    await organizationStoreFor(context).transaction(async (tx)=>{
+        const access = await requireBillingAdmin(tx, context, organizationId);
+        const billing = requireSubscription(await tx.get('organizationBilling', organizationId));
+        if (plan === billing.plan) {
+            throw new Error('plan_unchanged');
+        }
+        if ((await tx.find('organizationBillingJobs', {
+            organizationId,
+            status: 'pending'
+        })).some((job)=>[
+                'plan',
+                'cancel'
+            ].includes(job.kind))) {
+            throw new Error('billing_change_pending');
+        }
+        const upgrade = getOrganizationPlan(plan).baseCents > getOrganizationPlan(billing.plan).baseCents;
+        if (upgrade) {
+            const quote = confirmedQuoteId ? await tx.get('organizationBillingQuotes', requireIdentifier(confirmedQuoteId)) : null;
+            if (!quote || quote.used || quote.kind !== 'plan' || quote.organizationId !== organizationId || quote.plan !== plan || quote.organizationRevision !== access.organization.revision || quote.expiresAt <= Date.now()) {
+                throw new Error('plan_quote_required');
+            }
+            await tx.put('organizationBillingQuotes', quote.quoteId, {
+                ...quote,
+                used: true
+            }, quote);
+        }
+        await enqueue(tx, access.organization, 'plan', {
+            ...upgrade ? {} : originalBoundary(billing),
+            changeAt: upgrade ? 'immediate' : 'period_end',
+            plan,
+            previousPlan: billing.plan
+        });
+        await tx.put('organizationBilling', organizationId, {
+            ...billing,
+            pendingChange: plan
+        }, billing);
+    });
+    return getOrganizationSubscription(context, organizationId);
+};
+export const cancelOrganizationSubscription = async (context, organizationId)=>{
+    await organizationStoreFor(context).transaction(async (tx)=>{
+        const access = await requireBillingAdmin(tx, context, organizationId);
+        if (organizationBillingMode() !== 'test') {
+            throw new Error('billing_disabled');
+        }
+        const billing = await tx.get('organizationBilling', organizationId);
+        if (!billing?.customerId || !billing.plan || ![
+            'active',
+            'past_due',
+            'unpaid',
+            'payment_pending'
+        ].includes(billing.status || '')) {
+            throw new Error('billing_not_ready');
+        }
+        if ((await tx.find('organizationBillingJobs', {
+            organizationId,
+            status: 'pending'
+        })).some((job)=>[
+                'plan',
+                'cancel'
+            ].includes(job.kind))) {
+            throw new Error('billing_change_pending');
+        }
+        await enqueue(tx, access.organization, 'cancel', originalBoundary(billing));
+        await tx.put('organizationBilling', organizationId, {
+            ...billing,
+            pendingChange: 'cancel'
+        }, billing);
+    });
+    return getOrganizationSubscription(context, organizationId);
+};
+export const setOrganizationOveragePreference = async (context, organizationId, preference)=>{
+    if (typeof preference.enabled !== 'boolean' || !Number.isSafeInteger(preference.monthlyCapCents) || preference.monthlyCapCents < 0 || preference.enabled && !preference.monthlyCapCents || !Number.isSafeInteger(preference.revision) || preference.revision < 0) {
+        throw new Error('invalid_overage_preference');
+    }
+    await organizationStoreFor(context).transaction(async (tx)=>{
+        await requireBillingAdmin(tx, context, organizationId);
+        const billing = await tx.get('organizationBilling', organizationId);
+        if ((billing?.overage?.revision || 0) !== preference.revision) {
+            throw new Error('revision_conflict');
+        }
+        await tx.put('organizationBilling', organizationId, {
+            ...billing,
+            customerId: billing?.customerId || '',
+            organizationId,
+            overage: {
+                ...preference,
+                revision: preference.revision + 1
+            }
+        }, billing);
+    });
+    return getOrganizationSubscription(context, organizationId);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/organizations/reconciliation.ts"],"sourcesContent":["/* Stream-transaction operations and per-organization jobs must be ordered. */\n/* eslint-disable no-await-in-loop */\nimport {randomUUID} from 'node:crypto';\n\nimport {getOrganizationSubscription, requireBillingAdmin, type OrganizationBilling} from './billing.js';\nimport {getOrganizationBillingProvider, organizationBillingMode} from './billingProvider.js';\nimport {sendOrganizationMail} from './mail.js';\nimport {getOrganizationPlan} from './plans.js';\nimport {\n  organizationKey,\n  organizationStoreFor,\n  requireIdentifier,\n  type OrganizationTransaction,\n  type Stored\n} from './store.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {\n  BillingJob,\n  BillingUpdateResult,\n  Organization,\n  OveragePreference,\n  PlanKey,\n  ProviderSubscription,\n  SeatChangeQuote,\n  SubscriptionSummary,\n  VerifiedBillingEvent\n} from './types.js';\n\nconst enqueue = async (\n  tx: OrganizationTransaction,\n  org: Organization,\n  kind: BillingJob['kind'],\n  desired: Record<string, unknown>\n): Promise<void> => {\n  const previous = await tx.get<Organization>('organizations', org.organizationId);\n  if(!previous || previous.revision !== org.revision) {\n    throw new Error('revision_conflict');\n  }\n  const sequence = org.revision + 1;\n  const jobId = organizationKey(org.organizationId, String(sequence));\n  const job: BillingJob = {\n    attempts: 0,\n    desired,\n    effectiveAt: Date.now(),\n    jobId,\n    kind,\n    leaseExpires: 0,\n    organizationId: org.organizationId,\n    owner: '',\n    priceVersion: '2026-10-v1',\n    sequence,\n    status: 'pending'\n  };\n  await tx.put(\n    'organizations',\n    org.organizationId,\n    {...previous, revision: sequence, updatedAt: job.effectiveAt},\n    previous\n  );\n  await tx.put('organizationBillingJobs', jobId, job);\n};\n\nexport const reconcileOrganizationBillingEvent = (\n  context: ApiContext,\n  event: VerifiedBillingEvent\n): Promise<void> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    requireIdentifier(event.eventId);\n    requireIdentifier(event.customerId);\n    const key = organizationKey('event', event.eventId);\n    if(await tx.get('organizationBillingEvents', key)) {\n      return;\n    }\n    const records = await tx.find<OrganizationBilling>('organizationBilling', {customerId: event.customerId});\n    if(records.length > 1) {\n      throw new Error('billing_customer_conflict');\n    }\n    const billing = records[0];\n    await tx.put('organizationBillingEvents', key, {\n      customerId: event.customerId,\n      eventId: event.eventId,\n      organizationId: billing?.organizationId || '',\n      receivedAt: Date.now(),\n      status: billing ? 'pending' : 'ignored',\n      type: event.type\n    });\n    if(billing) {\n      const org = await tx.get<Organization>('organizations', billing.organizationId);\n      if(!org) {\n        throw new Error('organization_state_invalid');\n      }\n      await enqueue(tx, org, 'reconcile', {eventId: event.eventId});\n    }\n  });\n\nexport const processOrganizationBillingJobs = async (\n  context: ApiContext,\n  limit: number\n): Promise<{completed: number; pending: number}> => {\n  if(!Number.isSafeInteger(limit) || limit < 1 || limit > 20) {\n    throw new Error('invalid_billing_batch');\n  }\n  const store = organizationStoreFor(context);\n  const failed = new Set<string>();\n  let completed = 0;\n  for(let i = 0; i < limit; i++) {\n    const owner = randomUUID();\n    const job = await store.transaction(async (tx) => {\n      const pending = (await tx.find<BillingJob>('organizationBillingJobs', {status: 'pending'})).sort(\n        (a, b) => Number(b.kind === 'cancel') - Number(a.kind === 'cancel') || a.sequence - b.sequence\n      );\n      const firstByOrg = new Map<string, Stored<BillingJob>>();\n      for(const candidate of pending) {\n        if(candidate.kind !== 'mail' && !firstByOrg.has(candidate.organizationId)) {\n          firstByOrg.set(candidate.organizationId, candidate);\n        }\n      }\n      const candidate = pending.find(\n        (item) =>\n          !failed.has(item.kind === 'mail' ? item.jobId : item.organizationId) &&\n          item.leaseExpires <= Date.now() &&\n          (item.kind === 'mail' ||\n            (organizationBillingMode() === 'test' &&\n              firstByOrg.get(item.organizationId)?.jobId === item.jobId))\n      );\n      if(!candidate) {\n        return null;\n      }\n      const claimed = {\n        ...candidate,\n        attempts: candidate.attempts + 1,\n        leaseExpires: Date.now() + 120000,\n        owner\n      };\n      await tx.put('organizationBillingJobs', candidate.jobId, claimed, candidate);\n      return claimed;\n    });\n    if(!job) {\n      break;\n    }\n    const fence = async (): Promise<void> =>\n      store.transaction(async (tx) => {\n        const current = await tx.get<BillingJob>('organizationBillingJobs', job.jobId);\n        if(current?.owner !== owner || current.status !== 'pending' || current.leaseExpires <= Date.now()) {\n          throw new Error('billing_lease_lost');\n        }\n      });\n    try {\n      let snapshot: ProviderSubscription | null = null;\n      let updateResult: BillingUpdateResult | undefined;\n      let billing: Stored<OrganizationBilling> | null = null;\n      if(job.kind === 'mail') {\n        await fence();\n        await sendOrganizationMail(String(job.desired.ciphertext));\n      } else {\n        billing = await store.transaction((tx) =>\n          tx.get<OrganizationBilling>('organizationBilling', job.organizationId)\n        );\n        if(billing?.customerId) {\n          const provider = await getOrganizationBillingProvider();\n          await fence();\n          snapshot = await provider.retrieve(billing.customerId, job.kind === 'reconcile' ? undefined : billing.subscription?.id);\n          if(!snapshot && job.kind !== 'reconcile') {\n            throw new Error('billing_subscription_unavailable');\n          }\n          if(snapshot && job.kind !== 'reconcile') {\n            let transition = job;\n            let includedInCheckout = false;\n            if(job.kind === 'seats' && snapshot.startedAt && job.effectiveAt < snapshot.startedAt) {\n              const sequence = billing.checkout?.sequence;\n              if(!Number.isSafeInteger(sequence)) {\n                throw new Error('billing_checkout_baseline_required');\n              }\n              includedInCheckout = job.sequence <= sequence!;\n              transition = {\n                ...job,\n                desired: {...job.desired, previousExtraSeats: snapshot.extraSeats},\n                effectiveAt: snapshot.startedAt\n              };\n            }\n            if(!includedInCheckout) {\n              updateResult = await provider.update(snapshot, transition, fence);\n            }\n            await fence();\n            snapshot = await provider.retrieve(billing.customerId, snapshot.id);\n            if(!snapshot) {\n              throw new Error('billing_subscription_unavailable');\n            }\n          }\n        }\n      }\n      await store.transaction(async (tx) => {\n        const current = await tx.get<BillingJob>('organizationBillingJobs', job.jobId);\n        if(current?.owner !== owner || current.status !== 'pending' || current.leaseExpires <= Date.now()) {\n          throw new Error('billing_lease_lost');\n        }\n        if(job.kind !== 'mail' && billing?.customerId) {\n          const record = await tx.get<OrganizationBilling>('organizationBilling', job.organizationId);\n          if(!record || record.customerId !== billing.customerId) {\n            throw new Error('billing_customer_conflict');\n          }\n          const canceled = !snapshot || ['canceled', 'incomplete_expired'].includes(snapshot.status);\n          let pendingChange: string | null = null;\n          if(!canceled) {\n            if(snapshot?.cancelAtPeriodEnd || job.kind === 'cancel') {\n              pendingChange = 'cancel';\n            } else if(snapshot?.pendingPlan) {\n              pendingChange = snapshot.pendingPlan;\n            } else if(job.kind === 'plan' && job.desired.changeAt === 'period_end') {\n              pendingChange = String(job.desired.plan);\n            } else if(record.pendingChange !== snapshot?.plan) {\n              pendingChange = record.pendingChange || null;\n            }\n          }\n          await tx.put(\n            'organizationBilling',\n            job.organizationId,\n            {\n              ...record,\n              pendingChange,\n              periodEnd: snapshot?.periodEnd || null,\n              plan: canceled ? null : snapshot!.plan,\n              status: snapshot?.status || 'canceled',\n              subscription: snapshot\n            },\n            record\n          );\n          if(snapshot) {\n            const periodKey = organizationKey(\n              job.organizationId,\n              snapshot.id,\n              String(snapshot.periodStart),\n              job.jobId\n            );\n            if(!(await tx.get('organizationBillingPeriods', periodKey))) {\n              await tx.put('organizationBillingPeriods', periodKey, {\n                adjustments: updateResult?.adjustments || [],\n                effectiveAt: job.effectiveAt,\n                jobId: job.jobId,\n                organizationId: job.organizationId,\n                priceVersion: job.priceVersion,\n                recordedAt: Date.now(),\n                sequence: job.sequence,\n                snapshot\n              });\n            }\n          }\n          if(job.kind === 'reconcile') {\n            const receiptKey = organizationKey('event', String(job.desired.eventId));\n            const receipt = await tx.get('organizationBillingEvents', receiptKey);\n            if(!receipt) {\n              throw new Error('billing_event_missing');\n            }\n            await tx.put(\n              'organizationBillingEvents',\n              receiptKey,\n              {...receipt, processedAt: Date.now(), status: 'processed'},\n              receipt\n            );\n          }\n        }\n        await tx.put(\n          'organizationBillingJobs',\n          job.jobId,\n          {...current, leaseExpires: 0, owner: '', status: 'complete'},\n          current\n        );\n      });\n      completed++;\n    } catch{\n      failed.add(job.kind === 'mail' ? job.jobId : job.organizationId);\n      await store.transaction(async (tx) => {\n        const current = await tx.get<BillingJob>('organizationBillingJobs', job.jobId);\n        if(current?.owner === owner && current.status === 'pending') {\n          await tx.put(\n            'organizationBillingJobs',\n            job.jobId,\n            {...current, leaseExpires: 0, owner: ''},\n            current\n          );\n        }\n      });\n    }\n  }\n  return {\n    completed,\n    pending: (await store.transaction((tx) => tx.find('organizationBillingJobs', {status: 'pending'}))).length\n  };\n};\n\nconst requireSubscription = (billing: Stored<OrganizationBilling> | null): Stored<OrganizationBilling> => {\n  if(organizationBillingMode() !== 'test') {\n    throw new Error('billing_disabled');\n  }\n  if(!billing?.customerId || !billing.plan || billing.status !== 'active') {\n    throw new Error('billing_not_ready');\n  }\n  return billing;\n};\nconst originalBoundary = (\n  billing: OrganizationBilling\n): Readonly<{subscriptionId: string; targetPeriodEnd: number}> => {\n  const subscriptionId = billing.subscription?.id;\n  const targetPeriodEnd = billing.periodEnd;\n  if(!subscriptionId || !Number.isSafeInteger(targetPeriodEnd) || targetPeriodEnd! <= Date.now()) {\n    throw new Error('billing_period_refresh_required');\n  }\n  return {subscriptionId, targetPeriodEnd: targetPeriodEnd!};\n};\ntype PlanQuote = SeatChangeQuote & {kind: 'plan'; organizationId: string; plan: PlanKey; used: boolean};\nexport const quoteOrganizationPlanChange = async (\n  context: ApiContext,\n  organizationId: string,\n  plan: PlanKey\n): Promise<SeatChangeQuote> => {\n  getOrganizationPlan(plan);\n  const store = organizationStoreFor(context);\n  const intent = await store.transaction(async (tx) => {\n    const access = await requireBillingAdmin(tx, context, organizationId);\n    const billing = requireSubscription(\n      await tx.get<OrganizationBilling>('organizationBilling', organizationId)\n    );\n    return {billing, organization: access.organization};\n  });\n  const provider = await getOrganizationBillingProvider();\n  const subscription = await provider.retrieve(intent.billing.customerId);\n  if(!subscription || subscription.status !== 'active') {\n    throw new Error('billing_not_ready');\n  }\n  const now = Date.now();\n  const prorationCents = await provider.preview(subscription, plan, subscription.extraSeats, now);\n  const quote: SeatChangeQuote = {\n    currency: 'usd',\n    expiresAt: now + 300000,\n    organizationRevision: intent.organization.revision,\n    prorationCents,\n    quantity: subscription.extraSeats,\n    quoteId: randomUUID()\n  };\n  await store.transaction(async (tx) => {\n    const access = await requireBillingAdmin(tx, context, organizationId);\n    if(access.organization.revision !== quote.organizationRevision) {\n      throw new Error('revision_conflict');\n    }\n    await tx.put('organizationBillingQuotes', quote.quoteId, {\n      ...quote,\n      kind: 'plan',\n      organizationId,\n      plan,\n      used: false\n    });\n  });\n  return quote;\n};\nexport const changeOrganizationPlan = async (\n  context: ApiContext,\n  organizationId: string,\n  plan: PlanKey,\n  confirmedQuoteId: string\n): Promise<SubscriptionSummary> => {\n  getOrganizationPlan(plan);\n  await organizationStoreFor(context).transaction(async (tx) => {\n    const access = await requireBillingAdmin(tx, context, organizationId);\n    const billing = requireSubscription(\n      await tx.get<OrganizationBilling>('organizationBilling', organizationId)\n    );\n    if(plan === billing.plan) {\n      throw new Error('plan_unchanged');\n    }\n    if(\n      (await tx.find<BillingJob>('organizationBillingJobs', {organizationId, status: 'pending'})).some(\n        (job) => ['plan', 'cancel'].includes(job.kind)\n      )\n    ) {\n      throw new Error('billing_change_pending');\n    }\n    const upgrade = getOrganizationPlan(plan).baseCents > getOrganizationPlan(billing.plan!).baseCents;\n    if(upgrade) {\n      const quote = confirmedQuoteId\n        ? await tx.get<PlanQuote>('organizationBillingQuotes', requireIdentifier(confirmedQuoteId))\n        : null;\n      if(\n        !quote ||\n        quote.used ||\n        quote.kind !== 'plan' ||\n        quote.organizationId !== organizationId ||\n        quote.plan !== plan ||\n        quote.organizationRevision !== access.organization.revision ||\n        quote.expiresAt <= Date.now()\n      ) {\n        throw new Error('plan_quote_required');\n      }\n      await tx.put('organizationBillingQuotes', quote.quoteId, {...quote, used: true}, quote);\n    }\n    await enqueue(tx, access.organization, 'plan', {\n      ...(upgrade ? {} : originalBoundary(billing)),\n      changeAt: upgrade ? 'immediate' : 'period_end',\n      plan,\n      previousPlan: billing.plan\n    });\n    await tx.put('organizationBilling', organizationId, {...billing, pendingChange: plan}, billing);\n  });\n  return getOrganizationSubscription(context, organizationId);\n};\nexport const cancelOrganizationSubscription = async (\n  context: ApiContext,\n  organizationId: string\n): Promise<SubscriptionSummary> => {\n  await organizationStoreFor(context).transaction(async (tx) => {\n    const access = await requireBillingAdmin(tx, context, organizationId);\n    if(organizationBillingMode() !== 'test') {\n      throw new Error('billing_disabled');\n    }\n    const billing = await tx.get<OrganizationBilling>('organizationBilling', organizationId);\n    if(!billing?.customerId || !billing.plan || !['active', 'past_due', 'unpaid', 'payment_pending'].includes(billing.status || '')) {\n      throw new Error('billing_not_ready');\n    }\n    if(\n      (await tx.find<BillingJob>('organizationBillingJobs', {organizationId, status: 'pending'})).some(\n        (job) => ['plan', 'cancel'].includes(job.kind)\n      )\n    ) {\n      throw new Error('billing_change_pending');\n    }\n    await enqueue(tx, access.organization, 'cancel', originalBoundary(billing));\n    await tx.put('organizationBilling', organizationId, {...billing, pendingChange: 'cancel'}, billing);\n  });\n  return getOrganizationSubscription(context, organizationId);\n};\nexport const setOrganizationOveragePreference = async (\n  context: ApiContext,\n  organizationId: string,\n  preference: OveragePreference\n): Promise<SubscriptionSummary> => {\n  if(\n    typeof preference.enabled !== 'boolean' ||\n    !Number.isSafeInteger(preference.monthlyCapCents) ||\n    preference.monthlyCapCents < 0 ||\n    (preference.enabled && !preference.monthlyCapCents) ||\n    !Number.isSafeInteger(preference.revision) ||\n    preference.revision < 0\n  ) {\n    throw new Error('invalid_overage_preference');\n  }\n  await organizationStoreFor(context).transaction(async (tx) => {\n    await requireBillingAdmin(tx, context, organizationId);\n    const billing = await tx.get<OrganizationBilling>('organizationBilling', organizationId);\n    if((billing?.overage?.revision || 0) !== preference.revision) {\n      throw new Error('revision_conflict');\n    }\n    await tx.put(\n      'organizationBilling',\n      organizationId,\n      {\n        ...billing,\n        customerId: billing?.customerId || '',\n        organizationId,\n        overage: {...preference, revision: preference.revision + 1}\n      },\n      billing\n    );\n  });\n  return getOrganizationSubscription(context, organizationId);\n};\n"],"names":["randomUUID","getOrganizationSubscription","requireBillingAdmin","getOrganizationBillingProvider","organizationBillingMode","sendOrganizationMail","getOrganizationPlan","organizationKey","organizationStoreFor","requireIdentifier","enqueue","tx","org","kind","desired","previous","get","organizationId","revision","Error","sequence","jobId","String","job","attempts","effectiveAt","Date","now","leaseExpires","owner","priceVersion","status","put","updatedAt","reconcileOrganizationBillingEvent","context","event","transaction","eventId","customerId","key","records","find","length","billing","receivedAt","type","processOrganizationBillingJobs","limit","Number","isSafeInteger","store","failed","Set","completed","i","pending","sort","a","b","firstByOrg","Map","candidate","has","set","item","claimed","fence","current","snapshot","updateResult","ciphertext","provider","retrieve","undefined","subscription","id","transition","includedInCheckout","startedAt","checkout","previousExtraSeats","extraSeats","update","record","canceled","includes","pendingChange","cancelAtPeriodEnd","pendingPlan","changeAt","plan","periodEnd","periodKey","periodStart","adjustments","recordedAt","receiptKey","receipt","processedAt","add","requireSubscription","originalBoundary","subscriptionId","targetPeriodEnd","quoteOrganizationPlanChange","intent","access","organization","prorationCents","preview","quote","currency","expiresAt","organizationRevision","quantity","quoteId","used","changeOrganizationPlan","confirmedQuoteId","some","upgrade","baseCents","previousPlan","cancelOrganizationSubscription","setOrganizationOveragePreference","preference","enabled","monthlyCapCents","overage"],"mappings":"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"}

package/lib/organizations/signup.d.ts

@@ -0,0 +1,25 @@
+import { type OrganizationTransaction } from './store.js';
+import type { ApiContext } from '../types/auth.types.js';
+import type { Organization, SignupInput, SignupResult } from './types.js';
+export type Registration = {
+    email: string;
+    fingerprint: string;
+    organizationId: string;
+    registrationId: string;
+    requestId: string;
+    userId: string;
+};
+export type Verification = {
+    attempts: number;
+    attemptWindow: number;
+    expiresAt: number;
+    lastSent: number;
+    resendCount: number;
+    resendWindow: number;
+    tokenHash: string;
+    used: boolean;
+    userId: string;
+};
+export declare const queueOrganizationVerification: (tx: OrganizationTransaction, registration: Registration, previous?: import('./store.js').Stored<Verification> | null) => Promise<void>;
+export declare const registerOrganization: (input: SignupInput, controlContext: ApiContext) => Promise<SignupResult>;
+export declare const createOrganization: (context: ApiContext, name: string, requestId: string) => Promise<Organization>;