@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/codePort.fixture.js

@@ -0,0 +1,124 @@
+import { economyTables as e } from "./tables.entity.js";
+import { CodePort as t, defaultCodeEligibility as n, defineCode as r, resolveCodeEligibility as i } from "./codes.js";
+import { codeTables as a } from "./codeTables.entity.js";
+import { EconomyPort as o } from "./port.js";
+import { economyPlugin as s } from "./plugin.js";
+import { Effect as c, Layer as l } from "effect";
+import { systemSubject as u } from "@voltro/protocol";
+import { randomBytes as d } from "node:crypto";
+import { ensureTableRegistered as f } from "@voltro/database";
+import { InMemoryDataStore as p } from "@voltro/runtime";
+//#region src/codePort.fixture.ts
+var m = () => {
+	let e = [{
+		id: "test.gold",
+		kind: "soft",
+		cap: "1000"
+	}];
+	return Object.freeze({
+		currencies: e,
+		context: Object.freeze({
+			definition: r({
+				id: "fixture.gift",
+				campaign: "fixture.campaign",
+				currencies: [{
+					currency: "test.gold",
+					amount: "5"
+				}],
+				limits: {
+					global: 2,
+					perPlayer: 1
+				},
+				from: 0,
+				until: 864e5
+			}, e),
+			at: 1,
+			claims: 0,
+			playerClaims: 0
+		})
+	});
+}, h = m(), g = Object.freeze({
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => c.sync(() => i(h.context, h.currencies)),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => c.sync(() => i(h.context, h.currencies, (e) => n(e) && e.claims > 0)),
+		expected: !1
+	}
+}), _ = {
+	app: {
+		name: "codes-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, v = c.gen(function* () {
+	yield* c.sync(() => [...e, ...a].forEach(f));
+	let t = new p(), n = s({
+		currencies: h.currencies,
+		now: () => 1,
+		codes: {}
+	});
+	yield* c.promise(async () => {
+		await n.bindDataStore?.(t);
+	});
+	let r = d(32).toString("hex"), i = Object.freeze({
+		code: r,
+		requestId: "fixture.redeem"
+	});
+	return yield* n.economy.codes().create(u("codes.fixture"), {
+		tenantId: "fixture",
+		code: r,
+		definition: h.context.definition
+	}), Object.freeze({
+		plugin: n,
+		store: t,
+		input: i,
+		close: c.suspend(() => n.onDeactivate?.(_))
+	});
+}), y = l.effectContext(c.acquireRelease(v, (e) => e.close).pipe(c.flatMap((e) => l.build(e.plugin.services)))), b = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: y,
+	probe: {
+		run: () => c.scoped(c.gen(function* () {
+			let e = yield* t, n = yield* o, r = d(32).toString("hex"), i = {
+				code: r,
+				requestId: "fixture.probe"
+			}, a = {
+				type: "user",
+				id: "a",
+				tenantId: "fixture",
+				kind: "guest"
+			};
+			yield* e.create(u("codes.fixture"), {
+				tenantId: "fixture",
+				code: r,
+				definition: h.context.definition
+			});
+			let s = yield* e.redeem(a, i), c = yield* e.redeem(a, i), l = yield* e.receipt(a, i), f = yield* n.mine(a);
+			return {
+				same: s.operationId === c.operationId,
+				state: l.state,
+				balance: f[0]?.balance
+			};
+		}).pipe(c.provide(y))),
+		expected: {
+			same: !0,
+			state: "fulfilled",
+			balance: "5"
+		}
+	}
+});
+//#endregion
+export { m as codeEligibilityFixture, g as codeEligibilitySystemFixture, v as codePortFixture, b as codePortSystemFixture, y as codesFakeLayer };

package/dist/codeStore.server.js

@@ -0,0 +1,440 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataList as r, dataObject as i, identifier as a } from "./capture.js";
+import { positiveAmount as o } from "./amount.js";
+import { captureCurrencies as s } from "./currency.js";
+import { shopInteger as c } from "./shop.js";
+import { captureCodeIntent as l, captureCodeValue as u, defaultCodeEligibility as d, defineCode as f, resolveCodeEligibility as p } from "./codes.js";
+import { codeClaimsTable as m, codeSubjectsTable as h, codeTenantsTable as g, codesTable as _ } from "./codeTables.entity.js";
+import { Effect as v, Result as y } from "effect";
+import { systemSubject as b } from "@voltro/protocol";
+import { createHash as x } from "node:crypto";
+import { and as S, eq as C, queryFor as w } from "@voltro/database";
+import { executeSqlMutations as ee, prepareSqlMutation as te, prepareSqlMutationGroup as ne } from "@voltro/database/sql";
+import { InventoryError as T } from "@voltro/plugin-inventory/errors";
+//#region src/codeStore.server.ts
+var E = (e) => x("sha256").update(JSON.stringify(e)).digest("hex"), D = (e, ...t) => e + E(t).slice(0, 56), O = (n) => n instanceof e ? n : n instanceof T && [
+	"invalid_input",
+	"invalid_record",
+	"not_found",
+	"erased",
+	"forbidden",
+	"conflict",
+	"limit_exceeded"
+].includes(n.code) ? t(n.code) : t("unavailable"), k = (e) => v.tryPromise({
+	try: e,
+	catch: O
+}), A = (e) => {
+	try {
+		return e();
+	} catch (e) {
+		return v.fail(O(e));
+	}
+}, j = async (e) => {
+	let t = await v.runPromise(v.result(e));
+	if (y.isFailure(t)) throw t.failure;
+	return t.success;
+}, M = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return c(t, 0, 864e13);
+}, N = class extends Error {
+	constructor() {
+		super("Accepted code request replay"), this.name = "CodeReplay";
+	}
+}, P = (e) => {
+	let o = i(e, [
+		"currencies",
+		"economy",
+		"inventory",
+		"systemAccount",
+		"allowedServices",
+		"maxHistoryRows",
+		"now",
+		"eligibility",
+		"version"
+	]), l = s(o.currencies), u = n(o.economy, ["prepareTransfer"]), f = o.inventory === void 0 ? void 0 : n(o.inventory, ["prepareGrant"]), p = a(o.systemAccount ?? "codes"), m = r(o.allowedServices ?? [], 256).map((e) => a(e));
+	if (new Set(m).size !== m.length) throw t("invalid_input");
+	let h = c(o.maxHistoryRows ?? 1e4, 1, 1e5), g = o.now ?? Date.now, _ = o.eligibility ?? d;
+	if (typeof _ != "function") throw t("invalid_input");
+	let v = a(o.version ?? (_ === d ? "default.v1" : void 0));
+	if (_ !== d && v === "default.v1" || typeof g != "function") throw t("invalid_input");
+	return Object.freeze({
+		currencies: l,
+		economy: u,
+		inventory: f,
+		systemAccount: p,
+		allowedServices: Object.freeze(m),
+		maxHistoryRows: h,
+		now: g,
+		eligibility: _,
+		version: v
+	});
+}, F = (e, n) => {
+	let v = P(n), { currencies: y, economy: x, inventory: T, systemAccount: O, eligibility: F, version: I } = v, L = v.maxHistoryRows, re = v.now, ie = new Set(v.allowedServices), R = () => c(re(), 0, 864e13), z = b("economy.codes"), B = (e) => {
+		if (e.type !== "user") throw t("forbidden");
+		return {
+			tenant: a(e.tenantId),
+			owner: a(e.id)
+		};
+	}, V = (e, t) => D("ecs_", e, t), H = (e, t) => D("ecd_", e, t), U = (e, t, n) => D("ecr_", e, t, n), W = (e, t) => E([e, t]), G = (t) => e.insertIgnore(g.tableName, {
+		id: D("ect_", t),
+		tenantId: t,
+		admission: 0
+	}, { conflictColumns: ["id"] }), K = (t, n) => e.insertIgnore(h.tableName, {
+		id: V(t, n),
+		tenantId: t,
+		ownerId: n,
+		erased: !1,
+		admission: 0
+	}, { conflictColumns: ["id"] }), q = async (e, n) => {
+		let r = D("ect_", n);
+		if (await e.updateMany(g.tableName, { admission: 0 }, { where: C("id", r) }) !== 1) throw t("unavailable");
+		let i = (await e.query(w(g).where(C("id", r)).limit(1).descriptor))[0];
+		if (!i || i.tenantId !== n || i.admission !== 0) throw t("invalid_record");
+	}, J = async (e, n, r, i = !1) => {
+		let a = V(n, r);
+		if (await e.updateMany(h.tableName, { admission: 0 }, { where: C("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(w(h).where(C("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.admission !== 0 || o.erased !== !0 && o.erased !== !1 || o.erased === !1 && o.ownerId !== r || o.erased === !0 && o.ownerId !== null) throw t("invalid_record");
+		if (o.erased === !0 && !i) throw t("erased");
+	}, Y = async (e, n, r, i) => {
+		let a = (await e.query(w(m).where(C("id", i)).limit(1).descriptor))[0];
+		if (a && (a.tenantId !== n || a.ownerKey !== V(n, r))) throw t("invalid_record");
+		return a;
+	}, X = (e) => {
+		if (e.state !== "fulfilled" || e.accepted !== !0 || e.ownerId === null) throw t("invalid_record");
+		let n = i(e.intent, [
+			"definition",
+			"currencies",
+			"requestId",
+			"codeDigest",
+			"rulesVersion",
+			"at"
+		]), l = f(n.definition, s(n.currencies));
+		if (a(n.rulesVersion), typeof n.codeDigest != "string" || !/^[a-f0-9]{64}$/.test(n.codeDigest) || e.ownerKey !== V(a(e.tenantId), a(e.ownerId)) || e.digest !== E([
+			e.tenantId,
+			e.ownerId,
+			n.requestId,
+			n.codeDigest
+		]) || e.id !== U(String(e.tenantId), String(e.ownerId), a(n.requestId)) || e.codeKey !== "ecd_" + String(n.codeDigest).slice(0, 56)) throw t("invalid_record");
+		let u = i(e.receipt, [
+			"operationId",
+			"codeId",
+			"version",
+			"campaign",
+			"at",
+			"transfers",
+			"grants"
+		]), d = c(u.at, M(e.createdAt), 864e13);
+		if (u.operationId !== e.id || u.codeId !== l.id || u.version !== l.version || u.campaign !== l.campaign || d !== n.at || M(e.fulfilledAt) !== d || l.from !== null && d < l.from || l.until !== null && d >= l.until) throw t("invalid_record");
+		let p = Object.freeze(r(u.transfers, 16).map((n, r) => {
+			let s = i(n, [
+				"txId",
+				"currency",
+				"amount",
+				"at"
+			]), u = l.currencies[r];
+			if (!u || s.currency !== u.currency || s.amount !== u.amount || typeof s.amount != "string") throw t("invalid_record");
+			return Object.freeze({
+				txId: a(s.txId),
+				currency: u.currency,
+				amount: o(s.amount).toString(),
+				at: c(s.at, M(e.createdAt), d)
+			});
+		})), m = Object.freeze(r(u.grants, 16).map((n, o) => {
+			let s = i(n, [
+				"operationId",
+				"kind",
+				"changes",
+				"at"
+			]), u = l.items[o];
+			if (!u || s.kind !== "grant") throw t("invalid_record");
+			let f = Object.freeze(r(s.changes, 1e4).map((e) => {
+				let t = i(e, ["instanceId", "delta"]);
+				return Object.freeze({
+					instanceId: a(t.instanceId),
+					delta: c(t.delta, 1, 1e6)
+				});
+			}));
+			if (f.reduce((e, t) => e + t.delta, 0) !== u.qty || new Set(f.map((e) => e.instanceId)).size !== f.length) throw t("invalid_record");
+			return Object.freeze({
+				operationId: a(s.operationId),
+				kind: "grant",
+				changes: f,
+				at: c(s.at, M(e.createdAt), d)
+			});
+		}));
+		if (p.length !== l.currencies.length || m.length !== l.items.length || new Set(p.map((e) => e.txId)).size !== p.length || new Set(m.map((e) => e.operationId)).size !== m.length) throw t("invalid_record");
+		return Object.freeze({
+			operationId: a(e.id),
+			codeId: l.id,
+			version: l.version,
+			campaign: l.campaign,
+			at: d,
+			transfers: p,
+			grants: m
+		});
+	}, Z = async (e, n, r) => {
+		let i = await e.query(w(m).where(S(C("tenantId", n), r)).limit(L + 1).descriptor);
+		if (i.length > L) throw t("limit_exceeded");
+		for (let e of i) {
+			if (!/^ecr_[a-f0-9]{56}$/.test(String(e.id)) || !/^ecs_[a-f0-9]{56}$/.test(String(e.ownerKey)) || !/^ecd_[a-f0-9]{56}$/.test(String(e.codeKey)) || e.tenantId !== n || typeof e.accepted != "boolean" || ![
+				"pending",
+				"fulfilled",
+				"erased"
+			].includes(String(e.state))) throw t("invalid_record");
+			if (e.state === "fulfilled") X(e);
+			else if (e.state === "pending" && (e.accepted !== !1 || e.receipt !== null || e.fulfilledAt !== null)) throw t("invalid_record");
+			else if (e.state === "erased" && (e.ownerId !== null || e.digest !== null || e.intent !== null || e.receipt !== null || e.accepted && e.fulfilledAt === null || !e.accepted && e.fulfilledAt !== null)) throw t("invalid_record");
+		}
+		return i;
+	}, Q = (n, r, i, a) => e.transactional(async (e) => {
+		await q(e, n), await J(e, n, r);
+		let o = await Y(e, n, r, i);
+		if (o) {
+			if (o.digest !== a) throw t("conflict");
+			if (o.state === "fulfilled") return X(o);
+			if (o.state !== "pending" || o.accepted !== !1) throw t("invalid_record");
+		}
+	}), ae = (n, r) => A(() => {
+		if (n.type !== "system" && (n.type !== "service" || !ie.has(n.service))) throw t("forbidden");
+		let o = i(r, [
+			"tenantId",
+			"code",
+			"definition"
+		]), s = a(o.tenantId), c = u(o.code), l = f(o.definition, y);
+		if (l.items.length && !T) throw t("unavailable");
+		let d = H(s, c), p = W(s, c);
+		return k(async () => {
+			let n = R();
+			await G(s), await e.transactional(async (e) => {
+				await q(e, s);
+				let r = (await e.query(w(_).where(C("id", d)).limit(1).descriptor))[0];
+				if (r) {
+					if (r.tenantId !== s || r.codeDigest !== p || r.rulesVersion !== I || JSON.stringify(f(r.definition, y)) !== JSON.stringify(l)) throw t("conflict");
+				} else await e.insert(_.tableName, {
+					id: d,
+					tenantId: s,
+					codeDigest: p,
+					definition: l,
+					rulesVersion: I,
+					createdAt: new Date(n)
+				});
+			});
+		});
+	}), oe = (n, r) => A(() => {
+		let { tenant: i, owner: a } = B(n), o = l(r), s = U(i, a, o.requestId), c = H(i, o.code), u = W(i, o.code), h = E([
+			i,
+			a,
+			o.requestId,
+			u
+		]), g = o.requestId;
+		return k(async () => {
+			await G(i), await K(i, a);
+			let n = await Q(i, a, s, h);
+			if (n) return n;
+			let r = R(), o = await e.transactional(async (e) => {
+				await q(e, i), await J(e, i, a);
+				let n = (await e.query(w(_).where(C("id", c)).limit(1).descriptor))[0];
+				if (!n || n.tenantId !== i || n.codeDigest !== u) throw t("not_found");
+				if (n.rulesVersion !== I) throw t("conflict");
+				if (M(n.createdAt) > r) throw t("invalid_record");
+				let o = f(n.definition, y);
+				if (o.from !== null && r < o.from || o.until !== null && r >= o.until) throw t("forbidden");
+				let l = await Z(e, i, C("ownerKey", V(i, a))), d = await Y(e, i, a, s);
+				if (!d) {
+					if (l.length >= L) throw t("limit_exceeded");
+					await e.insert(m.tableName, {
+						id: s,
+						tenantId: i,
+						ownerId: a,
+						ownerKey: V(i, a),
+						codeKey: c,
+						state: "pending",
+						accepted: !1,
+						digest: h,
+						intent: null,
+						receipt: null,
+						createdAt: new Date(r),
+						fulfilledAt: null
+					});
+				} else if (d.digest !== h || d.codeKey !== c) throw t("conflict");
+				let p = (await Z(e, i, C("codeKey", c))).filter((e) => e.accepted);
+				return Object.freeze({
+					definition: o,
+					claims: p.length,
+					playerClaims: p.filter((e) => e.ownerKey === V(i, a)).length,
+					at: r
+				});
+			}), l = o.definition;
+			if (o.claims >= l.limits.global || o.playerClaims >= l.limits.perPlayer) throw t("limit_exceeded");
+			if (!p(o, y, F)) throw t("forbidden");
+			let v = [];
+			v.push(te(e, async (e) => {
+				await q(e, i), await J(e, i, a);
+				let n = await Y(e, i, a, s);
+				if (!n || n.digest !== h || n.codeKey !== c || n.ownerId !== a) throw t("invalid_record");
+				if (n.state === "fulfilled") throw X(n), new N();
+				if (n.state !== "pending" || n.accepted !== !1) throw t("invalid_record");
+				let r = (await Z(e, i, C("codeKey", c))).filter((e) => e.accepted);
+				if (F !== d && (r.length !== o.claims || r.filter((e) => e.ownerKey === V(i, a)).length !== o.playerClaims)) throw t("conflict");
+				if (r.length >= l.limits.global || r.filter((e) => e.ownerKey === V(i, a)).length >= l.limits.perPlayer) throw t("limit_exceeded");
+				return null;
+			}));
+			for (let [e, t] of l.currencies.entries()) v.push(await j(x.prepareTransfer(z, {
+				tenantId: i,
+				requestId: D("eck_", s, "transfer", String(e)),
+				currency: t.currency,
+				amount: t.amount,
+				from: {
+					kind: "system",
+					id: O
+				},
+				to: {
+					kind: "wallet",
+					ownerKind: "player",
+					ownerId: a
+				},
+				reason: "code.redeem",
+				ref: {
+					kind: "code-claim",
+					id: s
+				}
+			})));
+			if (l.items.length && !T) throw t("unavailable");
+			for (let [e, t] of l.items.entries()) v.push(await j(T.prepareGrant(z, {
+				tenantId: i,
+				owner: {
+					ownerKind: "player",
+					ownerId: a
+				},
+				itemId: t.itemId,
+				qty: t.qty,
+				requestId: D("eck_", s, "grant", String(e)),
+				reason: "code.redeem",
+				ref: {
+					kind: "code-claim",
+					id: s
+				}
+			})));
+			let b = R();
+			if (b < r || l.from !== null && b < l.from || l.until !== null && b >= l.until) throw t("forbidden");
+			let S = ne(e, v, async (e, n) => {
+				let r = {
+					operationId: s,
+					codeId: l.id,
+					version: l.version,
+					campaign: l.campaign,
+					at: b,
+					transfers: n.slice(1, 1 + l.currencies.length),
+					grants: n.slice(1 + l.currencies.length)
+				};
+				await e.update(m.tableName, s, {
+					state: "fulfilled",
+					accepted: !0,
+					intent: {
+						definition: l,
+						currencies: y,
+						requestId: g,
+						codeDigest: u,
+						rulesVersion: I,
+						at: b
+					},
+					receipt: r,
+					fulfilledAt: new Date(b)
+				});
+				let o = await Y(e, i, a, s);
+				if (!o) throw t("invalid_record");
+				return X(o);
+			});
+			try {
+				return (await ee(e, [S]))[0];
+			} catch (e) {
+				if (e instanceof N) {
+					let e = await Q(i, a, s, h);
+					if (e) return e;
+				}
+				throw e;
+			}
+		});
+	}), se = (n, r) => A(() => {
+		let { tenant: i, owner: a } = B(n), o = l(r), s = U(i, a, o.requestId), c = E([
+			i,
+			a,
+			o.requestId,
+			W(i, o.code)
+		]), u = o.requestId;
+		return k(async () => e.transactional(async (e) => {
+			let n = (await e.query(w(h).where(C("id", V(i, a))).limit(1).descriptor))[0];
+			if (n && n.tenantId !== i) throw t("invalid_record");
+			if (n?.erased === !0) throw n.ownerId === null ? t("erased") : t("invalid_record");
+			if (n && (n.tenantId !== i || n.ownerId !== a || n.erased !== !1)) throw t("invalid_record");
+			let r = await Y(e, i, a, s);
+			if (!r) return Object.freeze({
+				requestId: u,
+				state: "not-observed"
+			});
+			if (r.digest !== c) throw t("conflict");
+			if (r.state === "fulfilled") return Object.freeze({
+				requestId: u,
+				state: "fulfilled",
+				receipt: X(r)
+			});
+			if (r.state !== "pending" || r.accepted !== !1) throw t("invalid_record");
+			return Object.freeze({
+				requestId: u,
+				state: "pending"
+			});
+		}));
+	}), $ = (e) => {
+		let n = i(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "guest" && n.kind !== "user") throw t("invalid_input");
+		return {
+			tenant: a(n.tenantId),
+			owner: a(n.subjectId)
+		};
+	};
+	return Object.freeze({
+		create: ae,
+		redeem: oe,
+		receipt: se,
+		exportSubject: (n) => A(() => {
+			let { tenant: r, owner: i } = $(n);
+			return k(async () => e.transactional(async (e) => {
+				let n = (await e.query(w(h).where(C("id", V(r, i))).limit(1).descriptor))[0];
+				if (n && n.tenantId !== r) throw t("invalid_record");
+				if (n?.erased === !0) {
+					if (n.ownerId !== null) throw t("invalid_record");
+					return { claims: [] };
+				}
+				if (n && (n.tenantId !== r || n.ownerId !== i || n.erased !== !1)) throw t("invalid_record");
+				return { claims: await Z(e, r, C("ownerKey", V(r, i))) };
+			}));
+		}),
+		eraseSubject: (t) => A(() => {
+			let { tenant: n, owner: r } = $(t);
+			return k(async () => {
+				await G(n), await K(n, r), await e.transactional(async (e) => {
+					await q(e, n), await J(e, n, r, !0);
+					let t = await Z(e, n, C("ownerKey", V(n, r)));
+					for (let n of t) await e.update(m.tableName, String(n.id), {
+						ownerId: null,
+						state: "erased",
+						digest: null,
+						intent: null,
+						receipt: null
+					});
+					await e.update(h.tableName, V(n, r), {
+						ownerId: null,
+						erased: !0
+					});
+				});
+			});
+		})
+	});
+};
+//#endregion
+export { F as dataStoreCodes, P as resolveCodeStoreOptions };

package/dist/codeTables.entity.js

@@ -0,0 +1,44 @@
+import { boolean as e, id as t, integer as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+//#region src/codeTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = i("_voltro_eco_code_tenants", {
+	id: t({ prefix: "ect" }),
+	tenantId: s(),
+	admission: n().serverOnly()
+}).index(["tenantId"]), l = i("_voltro_eco_codes", {
+	id: t({ prefix: "ecd" }),
+	tenantId: s(),
+	codeDigest: a().maxLength(64).serverOnly(),
+	definition: r().serverOnly(),
+	rulesVersion: a().maxLength(120).serverOnly(),
+	createdAt: o().serverOnly()
+}).index(["tenantId"]), u = i("_voltro_eco_code_subjects", {
+	id: t({ prefix: "ecs" }),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: e().serverOnly(),
+	admission: n().serverOnly()
+}).index(["tenantId", "ownerId"]), d = i("_voltro_eco_code_claims", {
+	id: t({ prefix: "ecr" }),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	ownerKey: a().maxLength(64).serverOnly(),
+	codeKey: a().maxLength(64).serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"fulfilled",
+		"erased"
+	]).serverOnly(),
+	accepted: e().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	intent: r().nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	createdAt: o().serverOnly(),
+	fulfilledAt: o().nullable().serverOnly()
+}).index(["tenantId", "ownerKey"]).index(["tenantId", "codeKey"]), f = [
+	c,
+	l,
+	u,
+	d
+];
+//#endregion
+export { d as codeClaimsTable, u as codeSubjectsTable, f as codeTables, c as codeTenantsTable, l as codesTable };