@voltro/plugin-billing 0.84.0 → 0.86.0

package/dist/entitlement.js

@@ -0,0 +1,41 @@
+import { BillingService as e, EntitlementExceeded as t, SubscriptionLocked as n } from "./types.js";
+import { Effect as r } from "effect";
+//#region src/entitlement.ts
+var i = (e, t, n, r) => ({
+	allowed: !Number.isFinite(t) || r <= 0 || n + r <= t,
+	entitlement: e,
+	limit: t,
+	used: n,
+	cost: r
+}), a = (e) => e.tenantId, o = (n, i, o) => r.gen(function* () {
+	let s = a(n.request.subject);
+	if (s === null) return o <= 0 ? void 0 : yield* r.fail(new t({
+		entitlement: i,
+		limit: 0,
+		used: 0,
+		cost: o
+	}));
+	yield* (yield* e).consumeEntitlement(s, i, o);
+}), s = (t) => r.gen(function* () {
+	let i = a(t.request.subject);
+	if (i === null) return;
+	let o = yield* (yield* e).entitlementStatus(i);
+	if (!o.entitled) return yield* r.fail(new n({
+		tenantId: i,
+		status: o.status,
+		lockedSince: (o.lockedSince ?? /* @__PURE__ */ new Date()).toISOString(),
+		lockout: o.lockout
+	}));
+}), c = (e, n) => (i, a) => {
+	let o = e[a.tag];
+	if (o === void 0) return i;
+	let s = o.cost ?? 1, c = a.subject.tenantId;
+	return c === null ? s <= 0 ? i : r.fail(new t({
+		entitlement: o.entitlement,
+		limit: 0,
+		used: 0,
+		cost: s
+	})) : r.flatMap(n.consumeEntitlement(c, o.entitlement, s), () => i);
+};
+//#endregion
+export { c as buildEnforceInterceptor, i as evaluateEntitlement, s as requireEntitled, o as requireEntitlement };

package/dist/flushClaim.js

@@ -0,0 +1,20 @@
+import { id as e, table as t, text as n, timestamp as r } from "@voltro/database";
+//#region src/flushClaim.ts
+var i = "_voltro_billing_flush_claims", a = t(i, {
+	id: e({ scheme: "numeric" }),
+	windowKey: n(),
+	claimedBy: n(),
+	claimedAt: r().default("now")
+}).unique("billingFlushClaimWindow", ["windowKey"]), o = (e, t) => `billing-flush:${Math.floor(e / Math.max(1, t))}`, s = async (e, t, n, r) => {
+	try {
+		return (await e.insertIgnore(i, {
+			windowKey: t,
+			claimedBy: n,
+			claimedAt: new Date(r)
+		}, { conflictColumns: ["windowKey"] })).claimedBy === n;
+	} catch {
+		return !0;
+	}
+};
+//#endregion
+export { i as BILLING_FLUSH_CLAIMS_TABLE, a as billingFlushClaimsTable, s as claimFlushWindow, o as flushWindowKey };

package/dist/index.d.ts

@@ -16,6 +16,7 @@ import { Subject } from '@voltro/protocol';
 import { TableIndex } from '@voltro/database';
 import { TableLike } from '@voltro/database';
 import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
 
 export declare const assertBillingProductionReady: (input: {
     readonly env: NodeJS.ProcessEnv;
@@ -93,15 +94,13 @@ export declare const billingEgressOf: (provider: Pick<BillingProvider, "name">)
 export declare class BillingError extends BillingError_base {
 }
 
-declare const BillingError_base: Schema.TaggedErrorClass<BillingError, "BillingError", {
-    readonly _tag: Schema.tag<"BillingError">;
-} & {
+declare const BillingError_base: Schema.Class<BillingError, Schema.TaggedStruct<"BillingError", {
     /** Where the failure originated — provider name or an internal stage. */
-    source: typeof Schema.String;
-    message: typeof Schema.String;
+    readonly source: Schema.String;
+    readonly message: Schema.String;
     /** Retryable? The service retries `transient` failures on a Schedule. */
-    transient: typeof Schema.Boolean;
-}>;
+    readonly transient: Schema.Boolean;
+}>, YieldableError>;
 
 /**
  * The normalized event union a `BillingProvider.normalizeEvent` produces
@@ -420,7 +419,7 @@ export declare type BillingProviderName = 'stripe' | 'mock';
 export declare class BillingService extends BillingService_base {
 }
 
-declare const BillingService_base: Context.TagClass<BillingService, "@voltro/plugin-billing/BillingService", BillingServiceShape>;
+declare const BillingService_base: Context.ServiceClass<BillingService, "@voltro/plugin-billing/BillingService", BillingServiceShape>;
 
 /** Wrap a built service in a `Layer` for the plugin's `services` field. */
 export declare const billingServiceLayer: (service: BillingServiceShape) => Layer.Layer<BillingService, never, never>;
@@ -1012,18 +1011,16 @@ export declare interface EntitlementDecision {
 export declare class EntitlementExceeded extends EntitlementExceeded_base {
 }
 
-declare const EntitlementExceeded_base: Schema.TaggedErrorClass<EntitlementExceeded, "EntitlementExceeded", {
-    readonly _tag: Schema.tag<"EntitlementExceeded">;
-} & {
+declare const EntitlementExceeded_base: Schema.Class<EntitlementExceeded, Schema.TaggedStruct<"EntitlementExceeded", {
     /** The entitlement key that was exhausted (`'aiCalls'`). */
-    entitlement: typeof Schema.String;
+    readonly entitlement: Schema.String;
     /** The static limit for the caller's plan. */
-    limit: typeof Schema.Number;
+    readonly limit: Schema.Number;
     /** How much was already used in the current window. */
-    used: typeof Schema.Number;
+    readonly used: Schema.Number;
     /** The cost the rejected call would have charged. */
-    cost: typeof Schema.Number;
-}>;
+    readonly cost: Schema.Number;
+}>, YieldableError>;
 
 /** An entitlement limit: a finite quota or the unbounded `'unlimited'`. */
 export declare type EntitlementLimit = number | 'unlimited';
@@ -1839,17 +1836,15 @@ declare interface SubscriptionChangeResult {
 export declare class SubscriptionLocked extends SubscriptionLocked_base {
 }
 
-declare const SubscriptionLocked_base: Schema.TaggedErrorClass<SubscriptionLocked, "SubscriptionLocked", {
-    readonly _tag: Schema.tag<"SubscriptionLocked">;
-} & {
-    tenantId: typeof Schema.String;
+declare const SubscriptionLocked_base: Schema.Class<SubscriptionLocked, Schema.TaggedStruct<"SubscriptionLocked", {
+    readonly tenantId: Schema.String;
     /** The subscription status at the time of the refusal (`'pastDue'`). */
-    status: typeof Schema.String;
+    readonly status: Schema.String;
     /** ISO timestamp at which the grace period expired. */
-    lockedSince: typeof Schema.String;
+    readonly lockedSince: Schema.String;
     /** `'hard'` (limits fell to the free plan) or `'soft'` (report only). */
-    lockout: typeof Schema.String;
-}>;
+    readonly lockout: Schema.String;
+}>, YieldableError>;
 
 /** Fields a mid-cycle / reconcile patch may set on the tenant's row. */
 export declare interface SubscriptionPatch {