@opengeni/db 1.3.0 → 1.4.2

package/src/credit-balances.ts

@@ -38,7 +38,8 @@ export async function getBillingBalance(
                 else policy->'offers'->(g.metadata->>'creditOfferId')->'eligibleModelIds' end,
               policy->'defaultModelIds'
             ) from current_policy), to_jsonb(g.eligible_model_ids)),
-          'remainingMicros', g.amount_micros - coalesce(used.amount, 0)
+          'remainingMicros', g.amount_micros - coalesce(used.amount, 0),
+          'coversVoice', g.source_type = 'verified_signup_trial'
         ) order by g.created_at, g.id)
           from ${schema.creditLedgerEntries} g
           left join (
@@ -66,13 +67,28 @@ export async function getBillingBalance(
   });
 }
 
-/** Missing model means a non-model resource, which can only use general credits. */
-export function spendableCreditMicros(balance: BillingBalance, modelId?: string): number {
+/**
+ * What a charge pays for. A canonical model ID uses grants scoped to that
+ * model; {@link VOICE_CREDIT_USAGE} (dictation and live voice) uses grants
+ * that cover voice, which are the verified-signup trial credits. Omitted means
+ * a non-model resource, which can only use general credits.
+ */
+export type CreditUsage = string | { readonly kind: "voice" } | undefined;
+
+/** Deployment-funded dictation and live voice. */
+export const VOICE_CREDIT_USAGE: { readonly kind: "voice" } = Object.freeze({ kind: "voice" });
+
+function grantCovers(grant: PromotionalCreditBalance, usage: CreditUsage): boolean {
+  if (!usage) return false;
+  if (typeof usage === "string") return grant.eligibleModelIds.includes(usage);
+  return grant.coversVoice === true;
+}
+
+export function spendableCreditMicros(balance: BillingBalance, usage?: CreditUsage): number {
   return (
     Math.max(0, balance.generalBalanceMicros ?? balance.balanceMicros) +
     (balance.promotionalCredits ?? []).reduce(
-      (sum, grant) =>
-        sum + (modelId && grant.eligibleModelIds.includes(modelId) ? grant.remainingMicros : 0),
+      (sum, grant) => sum + (grantCovers(grant, usage) ? grant.remainingMicros : 0),
       0,
     )
   );
@@ -81,29 +97,54 @@ export function spendableCreditMicros(balance: BillingBalance, modelId?: string)
 export async function getSpendableCreditBalance(
   db: Database,
   accountId: string,
-  modelId?: string,
+  usage?: CreditUsage,
   policyRevision?: number,
 ): Promise<CreditBalanceSnapshot> {
   const balance = await getBillingBalance(db, accountId, policyRevision);
-  return { ...balance, balanceMicros: spendableCreditMicros(balance, modelId) };
+  return { ...balance, balanceMicros: spendableCreditMicros(balance, usage) };
+}
+
+/** Covering grants pay first, oldest first; the rest is general credit. */
+function allocateToCoveringGrants(
+  balance: BillingBalance,
+  amountMicros: number,
+  usage: CreditUsage,
+) {
+  let remaining = amountMicros;
+  const allocations: { grantEntryId: string; amountMicros: number }[] = [];
+  for (const grant of balance.promotionalCredits ?? []) {
+    if (!remaining || !grantCovers(grant, usage) || grant.remainingMicros <= 0) continue;
+    const allocated = Math.min(remaining, grant.remainingMicros);
+    allocations.push({ grantEntryId: grant.grantId, amountMicros: allocated });
+    remaining -= allocated;
+  }
+  return allocations;
 }
 
 export function planCreditDebit(
   balance: BillingBalance,
   requestedMicros: number,
-  modelId?: string,
+  usage?: CreditUsage,
 ) {
   if (!Number.isSafeInteger(requestedMicros) || requestedMicros <= 0) {
     throw new Error("credit debit requires a positive, safe integer micro amount");
   }
-  const debitedMicros = Math.min(requestedMicros, spendableCreditMicros(balance, modelId));
-  let remaining = debitedMicros;
-  const allocations: { grantEntryId: string; amountMicros: number }[] = [];
-  for (const grant of balance.promotionalCredits ?? []) {
-    if (!remaining || !modelId || !grant.eligibleModelIds.includes(modelId)) continue;
-    const amountMicros = Math.min(remaining, grant.remainingMicros);
-    allocations.push({ grantEntryId: grant.grantId, amountMicros });
-    remaining -= amountMicros;
+  const debitedMicros = Math.min(requestedMicros, spendableCreditMicros(balance, usage));
+  return { debitedMicros, allocations: allocateToCoveringGrants(balance, debitedMicros, usage) };
+}
+
+/**
+ * Allocations for an already-consumed charge of the full amount: covering
+ * grants pay what they can and general credit takes the rest, possibly going
+ * negative.
+ */
+export function planPostUseCreditAllocations(
+  balance: BillingBalance,
+  amountMicros: number,
+  usage: CreditUsage,
+) {
+  if (!Number.isSafeInteger(amountMicros) || amountMicros <= 0) {
+    throw new Error("credit debit requires a positive, safe integer micro amount");
   }
-  return { debitedMicros, allocations };
+  return allocateToCoveringGrants(balance, amountMicros, usage);
 }

package/src/database.ts

@@ -898,17 +898,26 @@ export async function withSessionActivityRlsContext<T>(
   );
 }
 
+/**
+ * `organizationMembershipFence` is required when the callback takes the
+ * organization-membership lifecycle lock (for example external-actor
+ * reauthorization): that lock precedes the session-tenancy fence and the
+ * canonical control/workspace/session prefix, never follows it.
+ */
 export async function withWorkspaceSessionActivityRls<T>(
   db: Database,
   workspaceId: string,
   fn: (db: SessionActivityDatabase) => Promise<T>,
   transactionConfig?: PgTransactionConfig,
+  organizationMembershipFence = false,
 ): Promise<T> {
   return await withSessionActivityRlsContext(
     db,
     { ...(await rlsContextForWorkspace(db, workspaceId)), workspaceId },
     fn,
     transactionConfig,
+    "shared",
+    organizationMembershipFence,
   );
 }