@voltro/plugin-governance 0.84.0 → 0.86.0

package/dist/retention.js

@@ -0,0 +1,52 @@
+import { writeGovernanceRows as e } from "./store.js";
+import { assertAnonymizable as t } from "./gdpr.js";
+//#region src/retention.ts
+var n = (e, t, n) => {
+	let r = e[t], i = r instanceof Date ? r.getTime() : typeof r == "string" || typeof r == "number" ? new Date(r).getTime() : NaN;
+	return Number.isNaN(i) ? null : n - i;
+}, r = (e, t, r) => {
+	let i = t.dateField ?? "createdAt";
+	return e.filter((e) => {
+		let a = n(e, i, r);
+		return a !== null && a > t.ttlMs;
+	}).map((e) => String(e.id));
+}, i = 1e3, a = async (n, a, o = Date.now(), s = i) => {
+	if (!Number.isSafeInteger(s) || s < 1) throw Error("retention batchSize must be a positive safe integer");
+	let c = [];
+	for (let i of a) {
+		let a = i.action ?? "delete";
+		a === "anonymize" && t(`retention policy '${i.table}'`, i.anonymizeFields);
+		let l = 0, u = 0, d, f = !1;
+		for (; !f;) {
+			let t = i.dateField ?? "createdAt", c = new Date(Math.ceil(o - i.ttlMs)), p = n.scan ? await n.scan(i.table, {
+				limit: s,
+				...d === void 0 ? {} : { after: d },
+				projection: ["id", t],
+				...Number.isNaN(c.getTime()) ? {} : { expired: {
+					column: t,
+					before: c
+				} }
+			}) : await n.page(i.table, s, u), m = r(p, i, o);
+			if (a === "delete") l += await e(n, i.table, m), u += p.length - m.length;
+			else {
+				let t = {};
+				for (let e of i.anonymizeFields ?? []) t[e] = null;
+				l += await e(n, i.table, m, t), u += p.length;
+			}
+			if (p.length && n.scan) {
+				let e = p[p.length - 1].id;
+				if (e === void 0 || e === d) throw Error("retention scan must advance a stable id cursor");
+				d = e;
+			}
+			f = p.length < s;
+		}
+		c.push({
+			table: i.table,
+			action: a,
+			affected: l
+		});
+	}
+	return c;
+};
+//#endregion
+export { i as RETENTION_BATCH_SIZE, a as runRetention, r as selectExpired };

package/dist/rpc.d.ts

@@ -5,37 +5,37 @@ import { QueryProcedureDescriptor } from '@voltro/protocol';
 import { Schema } from 'effect';
 
 export declare const consentDescriptor: MutationProcedureDescriptor<"governance.consent", Schema.Struct<{
-    purpose: typeof Schema.String;
-    granted: typeof Schema.Boolean;
+    readonly purpose: Schema.String;
+    readonly granted: Schema.Boolean;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const eraseDescriptor: ActionProcedureDescriptor<"governance.erase", Schema.Struct<{
-    subjectId: typeof Schema.String;
-    mode: Schema.optional<Schema.Literal<["delete", "anonymize"]>>;
+    readonly subjectId: Schema.String;
+    readonly mode: Schema.optional<Schema.Literals<readonly ["delete", "anonymize"]>>;
 }>, Schema.Struct<{
-    subjectId: typeof Schema.String;
-    at: typeof Schema.String;
-    mode: typeof Schema.String;
-    affected: Schema.Array$<Schema.Struct<{
-        table: typeof Schema.String;
-        count: typeof Schema.Number;
+    readonly subjectId: Schema.String;
+    readonly at: Schema.String;
+    readonly mode: Schema.String;
+    readonly affected: Schema.$Array<Schema.Struct<{
+        readonly table: Schema.String;
+        readonly count: Schema.Number;
     }>>;
-}>, typeof Schema.Never>;
+}>, Schema.Never>;
 
 export declare const exportDescriptor: ActionProcedureDescriptor<"governance.export", Schema.Struct<{
-    subjectId: typeof Schema.String;
-}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, typeof Schema.Never>;
+    readonly subjectId: Schema.String;
+}>, Schema.$Record<Schema.String, Schema.Unknown>, Schema.Never>;
 
 /** Declared for the codegen (`VoltroPlugin.rpcClientDescriptors`) so each tag is
  *  emitted into the generated client group. Kept in lockstep with the exports. */
 export declare const governanceRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
 
 export declare const hasConsentDescriptor: QueryProcedureDescriptor<"governance.hasConsent", Schema.Struct<{
-    purpose: typeof Schema.String;
+    readonly purpose: Schema.String;
 }>, Schema.Struct<{
-    granted: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly granted: Schema.Boolean;
+}>, Schema.Never>;
 
 export { }

package/dist/rpc.js

@@ -4,16 +4,13 @@ import { ADMIN_SCOPE as t, defineAction as n, defineMutation as r, defineQuery a
 var a = n({
 	name: "governance.export",
 	input: e.Struct({ subjectId: e.String }),
-	output: e.Record({
-		key: e.String,
-		value: e.Unknown
-	}),
+	output: e.Record(e.String, e.Unknown),
 	guards: [{ scope: t }]
 }), o = n({
 	name: "governance.erase",
 	input: e.Struct({
 		subjectId: e.String,
-		mode: e.optional(e.Literal("delete", "anonymize"))
+		mode: e.optional(e.Literals(["delete", "anonymize"]))
 	}),
 	output: e.Struct({
 		subjectId: e.String,

package/dist/store.js

@@ -0,0 +1,120 @@
+import { and as e, getTable as t, gt as n, inSet as r, lt as i } from "@voltro/database";
+//#region src/store.ts
+var a = (a) => {
+	let o = a, s = (e, t) => ({
+		table: void 0,
+		predicate: void 0,
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: e,
+		skip: t,
+		projection: void 0
+	});
+	return {
+		all: (e) => o.query({
+			...s(void 0, void 0),
+			table: e
+		}),
+		where: async (e, t, n) => n.length === 0 ? [] : o.query({
+			...s(void 0, void 0),
+			table: e,
+			predicate: {
+				column: t,
+				op: "in",
+				value: [...n]
+			}
+		}),
+		page: (e, t, n) => o.query({
+			...s(t, n),
+			table: e
+		}),
+		scan: (a, c) => {
+			if (c.column !== void 0 && c.values?.length === 0) return Promise.resolve([]);
+			let l = [];
+			if (c.after !== void 0 && l.push(n("id", c.after)), c.column !== void 0) {
+				if (c.values === void 0) throw Error("governance scan needs values for its subject column");
+				l.push(r(c.column, c.values));
+			}
+			return c.expired && t(a)?.fields[c.expired.column]?.type === "timestamp" && l.push(i(c.expired.column, c.expired.before)), o.query({
+				...s(c.limit, void 0),
+				table: a,
+				predicate: l.length ? e(...l) : void 0,
+				projection: c.projection
+			});
+		},
+		...o.deleteMany && o.updateMany ? { writeMany: async (e, t, n) => {
+			if (t.length === 0) return 0;
+			let i = r("id", t);
+			return n === void 0 ? o.deleteMany(e, { where: i }) : o.updateMany(e, n, { where: i });
+		} } : {},
+		delete: async (e, t) => {
+			await (o.hardDelete ?? o.delete).call(o, e, t);
+		},
+		update: async (e, t, n) => {
+			await o.update(e, t, n);
+		}
+	};
+}, o = (e = {}) => {
+	let t = new Map(Object.entries(e).map(([e, t]) => [e, t.map((e) => ({ ...e }))])), n = (e) => {
+		let n = t.get(e);
+		return n || (n = [], t.set(e, n)), n;
+	};
+	return {
+		all: async (e) => [...n(e)],
+		where: async (e, t, r) => {
+			if (r.length === 0) return [];
+			let i = new Set(r.map((e) => String(e)));
+			return n(e).filter((e) => i.has(String(e[t]))).map((e) => ({ ...e }));
+		},
+		page: async (e, t, r) => n(e).slice(r, r + t).map((e) => ({ ...e })),
+		scan: async (e, t) => {
+			let r = t.values === void 0 ? void 0 : new Set(t.values.map(String));
+			return n(e).filter((e) => (t.after === void 0 || String(e.id) > String(t.after)) && (t.column === void 0 || r?.has(String(e[t.column])))).sort((e, t) => String(e.id) < String(t.id) ? -1 : +(String(e.id) > String(t.id))).slice(0, t.limit).map((e) => t.projection ? Object.fromEntries(t.projection.map((t) => [t, e[t]])) : { ...e });
+		},
+		writeMany: async (e, r, i) => {
+			let a = new Set(r), o = n(e), s = 0;
+			if (i === void 0) {
+				let n = o.filter((e) => !a.has(String(e.id)) || (s++, !1));
+				t.set(e, n);
+			} else for (let e = 0; e < o.length; e++) a.has(String(o[e].id)) && (o[e] = {
+				...o[e],
+				...i
+			}, s++);
+			return s;
+		},
+		delete: async (e, t) => {
+			let r = n(e), i = r.findIndex((e) => String(e.id) === t);
+			i !== -1 && r.splice(i, 1);
+		},
+		update: async (e, t, r) => {
+			let i = n(e), a = i.findIndex((e) => String(e.id) === t);
+			a !== -1 && (i[a] = {
+				...i[a],
+				...r
+			});
+		},
+		dump: () => Object.fromEntries([...t.entries()].map(([e, t]) => [e, t.map((e) => ({ ...e }))]))
+	};
+}, s = async (e, t, n, r) => {
+	let i = 0;
+	if (e.writeMany) {
+		for (let a = 0; a < n.length; a += 500) i += await e.writeMany(t, n.slice(a, a + 500), r);
+		return i;
+	}
+	let a = 0, o = !1, s = await Promise.allSettled(Array.from({ length: Math.min(8, n.length) }, async () => {
+		for (; !o && a < n.length;) {
+			let s = n[a++];
+			try {
+				r === void 0 ? await e.delete(t, s) : await e.update(t, s, r), i++;
+			} catch (e) {
+				throw o = !0, e;
+			}
+		}
+	}));
+	for (let e of s) if (e.status === "rejected") throw e.reason;
+	return i;
+};
+//#endregion
+export { a as dataStoreGovStore, o as memoryGovStore, s as writeGovernanceRows };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-governance",
-  "version": "0.84.0",
+  "version": "0.86.0",
   "description": "Data governance — retention policies (TTL sweep), GDPR subject export + erasure (right-to-be-forgotten), and consent recording. Builds on audit + soft-delete.",
   "keywords": [
     "voltro",
@@ -38,12 +38,12 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.84.0",
-    "@voltro/protocol": "0.84.0",
-    "@voltro/runtime": "0.84.0"
+    "@voltro/database": "0.86.0",
+    "@voltro/protocol": "0.86.0",
+    "@voltro/runtime": "0.86.0"
   },
   "peerDependencies": {
-    "effect": "^3.22.2"
+    "effect": "4.0.1"
   },
   "publishConfig": {
     "access": "public"