@contextplusplus/core 1.1.0

package/dist/infrastructure/usage/supabase-usage-live.js

@@ -0,0 +1,639 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b2b30f7a-e056-5c51-bbb6-d8e27554307c")}catch(e){}}();
+import { createClient } from "@supabase/supabase-js";
+import { Effect, Layer, Option, Redacted } from "effect";
+import { ProductConfigService } from "../../application/ports/config-service.js";
+import { UsageService } from "../../application/ports/usage-service.js";
+import { AccountSuspendedError, BillingStateError, QuotaExceededError, sanitizeErrorCause, SubscriptionRequiredError } from "../../domain/errors.js";
+/**
+ * Statuses that MAY grant entitlement — but only while the current billing
+ * period is still open (see {@link isEntitled}).
+ *
+ * Policy (documented grace):
+ *   * `active` / `trialing` — fully paid / in trial; entitled within period.
+ *   * `past_due` — a renewal payment failed but Stripe still considers the sub
+ *     recoverable (it has not yet transitioned to `canceled` / `unpaid`).
+ *     Granting `past_due` access WITHIN its current period is the standard SaaS
+ *     grace window: the customer keeps working while Stripe retries the charge,
+ *     and is blocked automatically once the period elapses (no manual cutoff).
+ * Any other status (`canceled`, `unpaid`, `incomplete`, `incomplete_expired`,
+ * `paused`, `inactive`, ...) is never entitled.
+ */
+const ENTITLED_STATUSES = new Set(["active", "trialing", "past_due"]);
+/**
+ * Entitlement gate: a billing-state row grants access only when its status is
+ * one of {@link ENTITLED_STATUSES} AND its current period has not yet elapsed.
+ * A missing `current_period_end` is treated as NOT entitled (fail-closed: we
+ * cannot confirm the paid window is open). `now` is injected so the predicate is
+ * deterministic under test.
+ */
+function isEntitled(status, currentPeriodEnd, now) {
+    if (!ENTITLED_STATUSES.has(status)) {
+        return false;
+    }
+    if (currentPeriodEnd === null) {
+        return false;
+    }
+    const periodEnd = Date.parse(currentPeriodEnd);
+    return Number.isFinite(periodEnd) && periodEnd > now;
+}
+/**
+ * Seconds from `now` until an ISO instant, clamped to a non-negative integer.
+ * `undefined` when the instant is absent or unparseable. Used to derive the
+ * quota 429 `Retry-After` from the subscription's `current_period_end` (which
+ * the {@link isEntitled} gate guarantees is in the future at the raise site).
+ */
+function secondsUntil(iso, now) {
+    if (iso === null) {
+        return undefined;
+    }
+    const at = Date.parse(iso);
+    if (!Number.isFinite(at)) {
+        return undefined;
+    }
+    return Math.max(0, Math.ceil((at - now) / 1000));
+}
+function periodStartFrom(value) {
+    if (value !== null) {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) {
+            return new Date(parsed).toISOString().slice(0, 10);
+        }
+    }
+    const now = new Date();
+    const month = `${now.getUTCMonth() + 1}`.padStart(2, "0");
+    return `${now.getUTCFullYear()}-${month}-01`;
+}
+function billingError(operation) {
+    return (cause) => new BillingStateError({ operation, cause: sanitizeErrorCause(cause) });
+}
+export function makeSupabaseUsageService(deps, adminUserIds = new Set(), spendCeilingCredits = 0) {
+    // In-process cache of the daily provider-spend trip state. Updated by
+    // recordProviderSpend from the durable RPC's return; read (in-memory, no DB
+    // round-trip) by spendCeilingTripped on the hot path. Resets implicitly when
+    // the UTC day rolls over (a different `day` string). A restart clears it, so
+    // the first post-restart recordProviderSpend re-derives the true state from
+    // the DB (bounded over-shoot of at most one run).
+    const spendState = { day: "", tripped: false };
+    const utcDay = () => new Date().toISOString().slice(0, 10);
+    return UsageService.make({
+        getUsageSnapshot: (userId) => Effect.gen(function* () {
+            const subscription = yield* Effect.tryPromise({
+                try: () => deps.getUsageSubscription(String(userId)),
+                catch: billingError("get-usage-subscription")
+            });
+            if (subscription?.plan === undefined || subscription.plan === null) {
+                return emptyUsageSnapshot();
+            }
+            const [planTier, usage] = yield* Effect.all([
+                Effect.tryPromise({
+                    try: () => deps.getPlanTier(subscription.plan ?? ""),
+                    catch: billingError("get-plan-tier")
+                }),
+                Effect.tryPromise({
+                    try: () => deps.getMonthlyUsage(String(userId), periodStartFrom(subscription.current_period_start)),
+                    catch: billingError("get-monthly-usage")
+                })
+            ], { concurrency: 2 });
+            const monthlyLimit = planTier?.monthly_limit_units ?? 0;
+            const used = usage?.usage_count ?? 0;
+            return {
+                planTier: subscription.plan,
+                monthlyLimit,
+                used,
+                remaining: Math.max(0, monthlyLimit - used),
+                periodEnd: isoFrom(subscription.current_period_end),
+                subscriptionStatus: subscription.status,
+                entitled: isEntitled(subscription.status, subscription.current_period_end, Date.now())
+            };
+        }).pipe(Effect.withSpan("SupabaseUsageService.getUsageSnapshot")),
+        listPlans: (userId) => Effect.gen(function* () {
+            const [tiers, subscription] = yield* Effect.all([
+                Effect.tryPromise({
+                    try: () => deps.listPlanTiers(),
+                    catch: billingError("list-plan-tiers")
+                }),
+                Effect.tryPromise({
+                    try: () => deps.getUsageSubscription(String(userId)),
+                    catch: billingError("get-usage-subscription")
+                })
+            ], { concurrency: 2 });
+            const currentPlan = subscription?.plan === undefined ? null : subscription.plan;
+            const plans = [...tiers]
+                .map((tier) => ({
+                plan: tier.plan,
+                monthlyLimit: tier.monthly_limit_units,
+                priceCents: tier.price_cents,
+                current: currentPlan !== null && tier.plan === currentPlan
+            }))
+                .sort((left, right) => left.priceCents - right.priceCents);
+            return { plans, currentPlan };
+        }).pipe(Effect.withSpan("SupabaseUsageService.listPlans")),
+        listUsageEvents: (userId, query) => Effect.gen(function* () {
+            const page = yield* Effect.tryPromise({
+                try: () => deps.listUsageEventsPage(String(userId), query),
+                catch: billingError("usage-history")
+            });
+            const events = page.rows.map((row) => ({
+                id: row.id,
+                endpoint: row.endpoint,
+                units: typeof row.units === "string" ? Number(row.units) : row.units,
+                provider: row.provider,
+                outcome: row.outcome,
+                runId: usageEventRunId(row.metadata),
+                createdAt: row.created_at
+            }));
+            return {
+                events,
+                total: page.total,
+                limit: query.limit,
+                offset: query.offset
+            };
+        }).pipe(Effect.withSpan("SupabaseUsageService.listUsageEvents")),
+        checkAndReserveQuota: (userId) => Effect.gen(function* () {
+            const subscription = yield* Effect.tryPromise({
+                try: () => deps.getActiveSubscription(String(userId)),
+                catch: billingError("get-active-subscription")
+            });
+            if (subscription === null ||
+                subscription.plan === null ||
+                !isEntitled(subscription.status, subscription.current_period_end, Date.now())) {
+                return yield* new SubscriptionRequiredError({
+                    userId: String(userId),
+                    status: subscription?.status ?? "none"
+                });
+            }
+            // Fail closed on a missing period start. `isEntitled` (above) only
+            // checks current_period_END, so an entitled subscription can still reach
+            // here with a NULL current_period_START. Reserving via
+            // `periodStartFrom(null)` would fall back to the first-of-month -- a
+            // DIFFERENT `user_monthly_usage` row than the real period -- handing the
+            // user a second full quota allocation. Refuse instead (a data-integrity
+            // state Stripe should never produce; surfaces as a 500 BillingStateError).
+            if (subscription.current_period_start === null) {
+                return yield* new BillingStateError({
+                    operation: "reserve.missing_period_start"
+                });
+            }
+            const plan = subscription.plan;
+            const periodStart = periodStartFrom(subscription.current_period_start);
+            const row = yield* Effect.tryPromise({
+                try: () => deps.reserveQuota(String(userId), periodStart, plan),
+                catch: billingError("reserve-quota")
+            });
+            if (row.usage_count === -1 && row.limit_units === -1 && !row.allowed) {
+                return yield* new AccountSuspendedError({
+                    userId: String(userId),
+                    reason: "Account is suspended"
+                });
+            }
+            if (!row.allowed) {
+                // `current_period_end` is the quota-window reset and is in scope here
+                // (the isEntitled gate above already required it to be a future
+                // instant), so no extra query is needed.
+                const retryAfterSeconds = secondsUntil(subscription.current_period_end, Date.now());
+                return yield* new QuotaExceededError({
+                    userId: String(userId),
+                    plan,
+                    usageCount: row.usage_count,
+                    limit: row.limit_units,
+                    ...(retryAfterSeconds !== undefined ? { retryAfterSeconds } : {})
+                });
+            }
+            return {
+                allowed: true,
+                plan,
+                usageCount: row.usage_count,
+                limit: row.limit_units,
+                periodStart
+            };
+        }).pipe(Effect.withSpan("SupabaseUsageService.checkAndReserveQuota")),
+        releaseQuota: (userId, periodStart, units) => 
+        // Release against the EXACT period the reservation incremented (passed
+        // back by the caller from the QuotaDecision). Re-deriving the period here
+        // could resolve to a different counter row than `reserveQuota` touched —
+        // the decrement would then silently no-op and the unit would be lost.
+        Effect.tryPromise({
+            try: () => deps.releaseQuota(String(userId), periodStart, units),
+            catch: billingError("release-quota")
+        }).pipe(Effect.withSpan("SupabaseUsageService.releaseQuota")),
+        setSuspended: (userId, suspended) => Effect.tryPromise({
+            try: () => deps.setSuspended(String(userId), suspended),
+            catch: billingError("admin-set-suspended")
+        }).pipe(Effect.withSpan("SupabaseUsageService.setSuspended")),
+        resetCurrentUsage: (userId) => Effect.gen(function* () {
+            const subscription = yield* Effect.tryPromise({
+                try: () => deps.getUsageSubscription(String(userId)),
+                catch: billingError("admin-reset-current-usage")
+            }).pipe(Effect.orElseSucceed(() => null));
+            const periodStart = periodStartFrom(subscription?.current_period_start ?? null);
+            yield* Effect.tryPromise({
+                try: () => deps.resetCurrentUsage(String(userId), periodStart),
+                catch: billingError("admin-reset-current-usage")
+            });
+        }).pipe(Effect.withSpan("SupabaseUsageService.resetCurrentUsage")),
+        recordUsage: (record) => Effect.tryPromise({
+            try: () => deps.insertUsageEvent({
+                user_id: String(record.userId),
+                endpoint: record.endpoint,
+                units: record.units,
+                provider: record.provider ?? null,
+                outcome: record.outcome,
+                metadata: record.runId === undefined ? null : { runId: record.runId }
+            }),
+            catch: billingError("record-usage")
+        }).pipe(Effect.withSpan("SupabaseUsageService.recordUsage")),
+        isAdmin: (userId) => Effect.sync(() => adminUserIds.has(String(userId))).pipe(Effect.withSpan("SupabaseUsageService.isAdmin")),
+        recordProviderSpend: (credits) => spendCeilingCredits <= 0 || credits <= 0
+            ? Effect.succeed({ tripped: false })
+            : Effect.gen(function* () {
+                const day = utcDay();
+                const result = yield* Effect.tryPromise({
+                    try: () => deps.recordProviderSpend(day, credits, spendCeilingCredits),
+                    catch: (cause) => cause
+                }).pipe(
+                // Best-effort: spend accounting must never break a served request.
+                Effect.catchAll((cause) => Effect.logWarning("provider spend not recorded", {
+                    errorTag: cause._tag
+                }).pipe(Effect.as({ day_credits: 0, over_ceiling: false }))));
+                const wasTripped = spendState.day === day && spendState.tripped;
+                spendState.day = day;
+                spendState.tripped = result.over_ceiling;
+                // Alert exactly on the crossing (not on every subsequent blocked run).
+                // Effect.logError routes to Sentry Logs when configured; the operator
+                // attaches an alert rule to the `spend_ceiling_tripped` event.
+                if (result.over_ceiling && !wasTripped) {
+                    yield* Effect.logError("provider spend daily ceiling tripped — outbound provider calls halted for the UTC day", {
+                        event: "spend_ceiling_tripped",
+                        dayCredits: result.day_credits,
+                        ceilingCredits: spendCeilingCredits
+                    });
+                }
+                return { tripped: result.over_ceiling };
+            }).pipe(Effect.withSpan("SupabaseUsageService.recordProviderSpend")),
+        spendCeilingTripped: () => Effect.sync(() => spendCeilingCredits <= 0
+            ? false
+            : spendState.day === utcDay() && spendState.tripped).pipe(Effect.withSpan("SupabaseUsageService.spendCeilingTripped")),
+        getAdminUsageOverview: () => Effect.gen(function* () {
+            // Each subscriber's "current period" is keyed by their own Stripe
+            // billing anchor (periodStartFrom(current_period_start)), exactly as the
+            // quota-reservation path keys `user_monthly_usage`. A single global
+            // first-of-month period only matches subscribers anchored to the 1st, so
+            // the overview must read the union of every subscriber's anchored period
+            // and match usage rows back to each user's own period.
+            const subscriptions = yield* Effect.tryPromise({
+                try: () => deps.listAllSubscriptions(),
+                catch: billingError("admin-list-subscriptions")
+            });
+            const periodStarts = [
+                ...new Set(subscriptions.map((row) => periodStartFrom(row.current_period_start)))
+            ];
+            const usageRows = periodStarts.length === 0
+                ? []
+                : yield* Effect.tryPromise({
+                    try: () => deps.listMonthlyUsage(periodStarts),
+                    catch: billingError("admin-list-monthly-usage")
+                });
+            return buildAdminUsageOverview(subscriptions, usageRows);
+        }).pipe(Effect.withSpan("SupabaseUsageService.getAdminUsageOverview")),
+        listAdminSubscriptions: (query) => Effect.gen(function* () {
+            const page = yield* Effect.tryPromise({
+                try: () => deps.listSubscriptionsPage(query.limit, query.offset),
+                catch: billingError("admin-subscriptions-page")
+            });
+            const subscriptions = page.rows.map((row) => ({
+                userId: row.user_id,
+                plan: row.plan,
+                status: row.status,
+                currentPeriodEnd: isoFrom(row.current_period_end)
+            }));
+            return {
+                subscriptions,
+                total: page.total
+            };
+        }).pipe(Effect.withSpan("SupabaseUsageService.listAdminSubscriptions"))
+    });
+}
+/** Limit on heaviest-consumer rows returned in the admin usage overview. */
+const ADMIN_TOP_USERS_LIMIT = 20;
+/**
+ * Derives the current-period overview from the raw subscription + usage rows.
+ * `subscriptions` attributes a plan to each user; `usageRows` carries the
+ * reserved unit count for the current period. Users without a subscription row
+ * are bucketed under the `none` tier so the totals stay exhaustive.
+ */
+function buildAdminUsageOverview(subscriptions, usageRows) {
+    const planByUser = new Map();
+    const periodByUser = new Map();
+    for (const row of subscriptions) {
+        planByUser.set(row.user_id, row.plan ?? "none");
+        periodByUser.set(row.user_id, periodStartFrom(row.current_period_start));
+    }
+    // The bulk `.in(period_start, …)` fetch can return another subscriber's row
+    // that happens to share a period start, so keep only each user's own
+    // current-period usage by matching (user_id, period_start).
+    const currentUsage = usageRows.filter((row) => periodByUser.get(row.user_id) === row.period_start);
+    const userIds = new Set([
+        ...planByUser.keys(),
+        ...currentUsage.map((row) => row.user_id)
+    ]);
+    const tierSubscribers = new Map();
+    for (const plan of planByUser.values()) {
+        tierSubscribers.set(plan, (tierSubscribers.get(plan) ?? 0) + 1);
+    }
+    const tierUnits = new Map();
+    const topUsers = [];
+    let totalUsageThisPeriod = 0;
+    for (const row of currentUsage) {
+        const plan = planByUser.get(row.user_id) ?? "none";
+        const used = row.usage_count;
+        totalUsageThisPeriod += used;
+        tierUnits.set(plan, (tierUnits.get(plan) ?? 0) + used);
+        topUsers.push({ userId: row.user_id, plan, used });
+    }
+    const perTier = [...tierSubscribers.keys()]
+        .map((plan) => ({
+        plan,
+        subscribers: tierSubscribers.get(plan) ?? 0,
+        usageUnits: tierUnits.get(plan) ?? 0
+    }))
+        .sort((left, right) => left.plan.localeCompare(right.plan));
+    topUsers.sort((left, right) => right.used - left.used);
+    return {
+        totalUsers: userIds.size,
+        totalUsageThisPeriod,
+        perTier,
+        topUsers: topUsers.slice(0, ADMIN_TOP_USERS_LIMIT)
+    };
+}
+function emptyUsageSnapshot() {
+    return {
+        planTier: "none",
+        monthlyLimit: 0,
+        used: 0,
+        remaining: 0,
+        periodEnd: null,
+        subscriptionStatus: "none",
+        entitled: false
+    };
+}
+function isoFrom(value) {
+    if (value === null) {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+/** Lifts the correlation `runId` out of a usage event's metadata, if present. */
+function usageEventRunId(metadata) {
+    if (metadata === null) {
+        return null;
+    }
+    const runId = metadata["runId"];
+    return typeof runId === "string" ? runId : null;
+}
+const rejectUnconfigured = (operation) => () => Promise.reject(new Error(`Supabase service role is not configured (${operation})`));
+function serviceRoleClient(config) {
+    return Option.flatMap(config.supabaseServiceRoleKey, (serviceRoleKey) => Option.map(config.supabaseUrl, (url) => createClient(url, Redacted.value(serviceRoleKey), {
+        auth: { persistSession: false, autoRefreshToken: false }
+    })));
+}
+function liveDeps(client) {
+    return {
+        getActiveSubscription: async (userId) => {
+            // Entitlement is gated in SQL as well as in code (defense in depth):
+            // only rows whose status grants access AND whose current period has not
+            // elapsed are returned. `past_due` is included as a documented grace
+            // window — it stays entitled WITHIN its period and falls away once
+            // `current_period_end <= now()`. See `isEntitled`.
+            const { data, error } = await client
+                .from("subscriptions")
+                .select("plan, status, current_period_start, current_period_end")
+                .eq("user_id", userId)
+                .in("status", ["active", "trialing", "past_due"])
+                .gt("current_period_end", new Date().toISOString())
+                .order("current_period_end", { ascending: false })
+                .limit(1)
+                .maybeSingle();
+            if (error !== null) {
+                throw error;
+            }
+            return data ?? null;
+        },
+        getUsageSubscription: async (userId) => {
+            const { data, error } = await client
+                .from("subscriptions")
+                .select("plan, status, current_period_start, current_period_end")
+                .eq("user_id", userId)
+                .in("status", ["active", "trialing", "past_due"])
+                .order("current_period_end", { ascending: false })
+                .limit(1)
+                .maybeSingle();
+            if (error !== null) {
+                throw error;
+            }
+            return data ?? null;
+        },
+        getPlanTier: async (plan) => {
+            const { data, error } = await client
+                .from("plan_tiers")
+                .select("monthly_limit_units")
+                .eq("plan", plan)
+                .maybeSingle();
+            if (error !== null) {
+                throw error;
+            }
+            return data ?? null;
+        },
+        listPlanTiers: async () => {
+            // RLS makes `plan_tiers` readable by any signed-in user; the service-role
+            // client used here reads them unconditionally. Only the public columns are
+            // selected — `stripe_price_id` is never exposed on the plans surface.
+            const { data, error } = await client
+                .from("plan_tiers")
+                .select("plan, monthly_limit_units, price_cents");
+            if (error !== null) {
+                throw error;
+            }
+            return data ?? [];
+        },
+        getMonthlyUsage: async (userId, periodStart) => {
+            const { data, error } = await client
+                .from("user_monthly_usage")
+                .select("usage_count")
+                .eq("user_id", userId)
+                .eq("period_start", periodStart)
+                .maybeSingle();
+            if (error !== null) {
+                throw error;
+            }
+            return data ?? null;
+        },
+        reserveQuota: async (userId, periodStart, plan) => {
+            const { data, error } = await client.rpc("check_and_increment_quota", {
+                p_user_id: userId,
+                p_period_start: periodStart,
+                p_plan: plan
+            });
+            if (error !== null) {
+                throw error;
+            }
+            const row = (Array.isArray(data) ? data[0] : data);
+            if (row === undefined) {
+                throw new BillingStateError({ operation: "reserve-quota", cause: { message: "check_and_increment_quota returned no row" } });
+            }
+            return row;
+        },
+        recordProviderSpend: async (day, credits, ceiling) => {
+            const { data, error } = await client.rpc("record_and_check_provider_spend", {
+                p_day: day,
+                p_credits: credits,
+                p_ceiling: ceiling
+            });
+            if (error !== null) {
+                throw error;
+            }
+            const row = (Array.isArray(data) ? data[0] : data);
+            return {
+                day_credits: Number(row?.day_credits ?? 0),
+                over_ceiling: row?.over_ceiling === true
+            };
+        },
+        releaseQuota: async (userId, periodStart, units) => {
+            const { error } = await client.rpc("release_quota_unit", {
+                p_user_id: userId,
+                p_period_start: periodStart,
+                p_units: units
+            });
+            if (error !== null) {
+                throw error;
+            }
+        },
+        setSuspended: async (userId, suspended) => {
+            const { error } = await client
+                .from("profiles")
+                .update({ suspended })
+                .eq("id", userId);
+            if (error !== null) {
+                throw error;
+            }
+        },
+        resetCurrentUsage: async (userId, periodStart) => {
+            const { error } = await client.rpc("reset_current_usage", {
+                p_user_id: userId,
+                p_period: periodStart
+            });
+            if (error !== null) {
+                throw error;
+            }
+        },
+        insertUsageEvent: async (event) => {
+            const { error } = await client
+                .from("usage_events")
+                // Local UsageEventInsert uses readonly metadata (Record|null); the
+                // generated Insert expects mutable Json. Same column set — cast the
+                // payload while the typed handle still checks the table + columns.
+                .insert(event);
+            if (error !== null) {
+                throw error;
+            }
+        },
+        listUsageEventsPage: async (userId, query) => {
+            // Owner-scoped read: filtered to the caller's own user_id, newest first,
+            // bounded page. `count: "exact"` returns the total alongside the page.
+            let builder = client
+                .from("usage_events")
+                .select("id, endpoint, units, provider, outcome, metadata, created_at", {
+                count: "exact"
+            })
+                .eq("user_id", userId);
+            if (query.start !== undefined) {
+                builder = builder.gte("created_at", query.start);
+            }
+            if (query.end !== undefined) {
+                builder = builder.lte("created_at", query.end);
+            }
+            const { data, error, count } = await builder
+                .order("created_at", { ascending: false })
+                .range(query.offset, query.offset + query.limit - 1);
+            if (error !== null) {
+                throw error;
+            }
+            return {
+                rows: data ?? [],
+                total: count ?? 0
+            };
+        },
+        listAllSubscriptions: async () => {
+            // Service-role aggregate read (bypasses RLS). Only the operator-visible
+            // columns are selected — Stripe ids, customer ids, and emails are never
+            // read here.
+            const { data, error } = await client
+                .from("subscriptions")
+                .select("user_id, plan, status, current_period_start, current_period_end");
+            if (error !== null) {
+                throw error;
+            }
+            return data ?? [];
+        },
+        listMonthlyUsage: async (periodStarts) => {
+            if (periodStarts.length === 0) {
+                return [];
+            }
+            const { data, error } = await client
+                .from("user_monthly_usage")
+                .select("user_id, usage_count, period_start")
+                .in("period_start", periodStarts);
+            if (error !== null) {
+                throw error;
+            }
+            return data ?? [];
+        },
+        listSubscriptionsPage: async (limit, offset) => {
+            // Bounded page ordered by most-recent period end first. `count: "exact"`
+            // returns the total matched rows alongside the page for pagination.
+            const { data, error, count } = await client
+                .from("subscriptions")
+                .select("user_id, plan, status, current_period_start, current_period_end", {
+                count: "exact"
+            })
+                .order("current_period_end", { ascending: false, nullsFirst: false })
+                .range(offset, offset + limit - 1);
+            if (error !== null) {
+                throw error;
+            }
+            return {
+                rows: data ?? [],
+                total: count ?? 0
+            };
+        }
+    };
+}
+export function supabaseUsageDeps(config) {
+    return Option.match(serviceRoleClient(config), {
+        onNone: () => ({
+            getActiveSubscription: rejectUnconfigured("get-active-subscription"),
+            getUsageSubscription: rejectUnconfigured("get-usage-subscription"),
+            getPlanTier: rejectUnconfigured("get-plan-tier"),
+            listPlanTiers: rejectUnconfigured("list-plan-tiers"),
+            getMonthlyUsage: rejectUnconfigured("get-monthly-usage"),
+            reserveQuota: rejectUnconfigured("reserve-quota"),
+            recordProviderSpend: rejectUnconfigured("record-provider-spend"),
+            releaseQuota: rejectUnconfigured("release-quota"),
+            setSuspended: rejectUnconfigured("admin-set-suspended"),
+            resetCurrentUsage: rejectUnconfigured("admin-reset-current-usage"),
+            insertUsageEvent: rejectUnconfigured("record-usage"),
+            listUsageEventsPage: rejectUnconfigured("usage-history"),
+            listAllSubscriptions: rejectUnconfigured("admin-list-subscriptions"),
+            listMonthlyUsage: rejectUnconfigured("admin-list-monthly-usage"),
+            listSubscriptionsPage: rejectUnconfigured("admin-subscriptions-page")
+        }),
+        onSome: (client) => liveDeps(client)
+    });
+}
+export const SupabaseUsageLive = Layer.effect(UsageService, Effect.gen(function* () {
+    const { config } = yield* ProductConfigService;
+    return makeSupabaseUsageService(supabaseUsageDeps(config), config.adminUserIds, config.dailyProviderSpendCeilingCredits);
+}));
+//# sourceMappingURL=supabase-usage-live.js.map
+//# debugId=b2b30f7a-e056-5c51-bbb6-d8e27554307c