@voltro/testing 0.1.0

package/dist/index.js

@@ -0,0 +1,237 @@
+import { Effect as e, Layer as t, Schema as n } from "effect";
+import { allRegisteredTables as r } from "@voltro/database";
+import { installEnvSnapshot as i } from "@voltro/env";
+import { InMemoryDataStore as a, makeSchemaRegistry as o, wrapStoreWithMixinBehaviour as s } from "@voltro/runtime";
+import { anonymousSubject as c } from "@voltro/protocol";
+import { CurrentWorkflowRunId as l, inMemoryWorkflowEngineLayer as u, makeInMemoryRecorder as d } from "@voltro/workflow";
+//#region src/invoke.ts
+var f = async (e, t, r, i) => {
+	let a = e.input;
+	return t(await n.decodeUnknownPromise(a)(r), i);
+}, p = class {
+	currentMs;
+	constructor(e = /* @__PURE__ */ new Date("2026-01-01T00:00:00Z")) {
+		this.currentMs = typeof e == "number" ? e : e.getTime();
+	}
+	now() {
+		return this.currentMs;
+	}
+	date() {
+		return new Date(this.currentMs);
+	}
+	advance(e) {
+		this.currentMs += typeof e == "number" ? e : m(e);
+	}
+}, m = (e) => {
+	let t = /^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)\s*$/.exec(e);
+	if (!t) throw Error(`mockClock: cannot parse duration '${e}'`);
+	let n = Number(t[1]), r = t[2];
+	switch (r) {
+		case "ms": return n;
+		case "s": return n * 1e3;
+		case "m": return n * 6e4;
+		case "h": return n * 36e5;
+		case "d": return n * 864e5;
+		default: throw Error(`mockClock: unknown unit '${r}'`);
+	}
+}, h = class {
+	sent = [];
+	send(e) {
+		this.sent.push({
+			...e,
+			sentAt: /* @__PURE__ */ new Date()
+		});
+	}
+	lastTo(e) {
+		for (let t = this.sent.length - 1; t >= 0; t--) if (this.sent[t].to === e) return this.sent[t];
+	}
+	clear() {
+		this.sent.length = 0;
+	}
+}, g = class {
+	queue;
+	calls = [];
+	constructor(e) {
+		this.queue = [...e];
+	}
+	next(e) {
+		this.calls.push(e);
+		let t = this.queue.shift();
+		if (!t) throw Error("MockLLM: no more responses queued");
+		return t;
+	}
+	remaining() {
+		return this.queue.length;
+	}
+}, _ = (e) => e, v = "00000000000000000000000000000000", y = (e) => {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = (n) => {
+		let r = t.get(n);
+		return r === void 0 ? !1 : r.expiresAt !== null && r.expiresAt <= e() ? (t.delete(n), !1) : !0;
+	}, i = (r, i, a, o) => {
+		if (t.set(r, {
+			value: i,
+			expiresAt: a === void 0 ? null : e() + a
+		}), o) for (let e of o) {
+			let t = n.get(e) ?? /* @__PURE__ */ new Set();
+			t.add(r), n.set(e, t);
+		}
+	};
+	return {
+		get: async (e) => r(e) ? t.get(e).value : void 0,
+		set: async (e, t, n) => {
+			i(e, t, n?.ttlMs);
+		},
+		setWithTags: async (e, t, n) => {
+			i(e, t, n.ttlMs, n.tags);
+		},
+		remove: async (e) => t.delete(e),
+		has: async (e) => r(e),
+		clear: async () => {
+			t.clear(), n.clear();
+		},
+		invalidateTag: async (e) => {
+			let r = n.get(e);
+			if (r === void 0) return 0;
+			let i = 0;
+			for (let e of r) t.delete(e) && i++;
+			return n.delete(e), i;
+		},
+		wrap: async (e, n, a) => {
+			if (r(e)) return t.get(e).value;
+			let o = await a();
+			return i(e, o, n.ttlMs, n.tags), o;
+		}
+	};
+}, b = (e) => {
+	let t = /* @__PURE__ */ new Map(), n = (n) => {
+		let r = t.get(n);
+		return r === void 0 ? !1 : r.expiresAt !== null && r.expiresAt <= e() ? (t.delete(n), !1) : !0;
+	};
+	return {
+		get: async (e) => n(e) ? t.get(e).value : void 0,
+		getOrElse: async (e, r) => n(e) ? t.get(e).value : r(),
+		set: async (n, r, i) => {
+			t.set(n, {
+				value: r,
+				expiresAt: i?.ttlMs === void 0 ? null : e() + i.ttlMs
+			});
+		},
+		delete: async (e) => {
+			let r = n(e);
+			return t.delete(e), r;
+		},
+		has: async (e) => n(e),
+		list: async (e) => {
+			let r = [];
+			for (let i of t.keys()) n(i) && (e === "" || i.startsWith(e)) && r.push(i);
+			return r;
+		},
+		clear: async () => {
+			t.clear();
+		}
+	};
+}, x = (e = {}) => {
+	i({
+		...process.env,
+		...e.env ?? {}
+	});
+	let t = o(e.tables ?? r()), n = new a(e.store ?? {}), l = new p(e.clockStart), u = new h(), d = new g(e.llmResponses ?? []), f = y(() => l.now()), m = b(() => l.now()), _ = (r) => {
+		let i = {
+			subject: r,
+			traceId: v
+		};
+		return {
+			clock: l,
+			email: u,
+			llm: d,
+			...e.ai === void 0 ? {} : { ai: e.ai },
+			request: i,
+			cache: f,
+			kv: m,
+			store: s(n, {
+				subject: r,
+				schemaRegistry: t
+			}),
+			withSubject: (e, t) => Promise.resolve(t(_(e))),
+			withTenant: (e, t) => Promise.resolve(t(_({
+				...r,
+				tenantId: e
+			})))
+		};
+	};
+	return _(e.subject ?? c(null));
+}, S = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = t.get(n.stepName);
+		e === void 0 ? t.set(n.stepName, [n]) : e.push(n);
+	}
+	let n = [];
+	for (let [e, r] of t) {
+		r.sort((e, t) => e.attempt - t.attempt);
+		let t = r[r.length - 1], i = t.errorTag !== null || t.errorMessage !== null ? {
+			tag: t.errorTag,
+			message: t.errorMessage ?? ""
+		} : null;
+		n.push({
+			name: e,
+			attempt: t.attempt,
+			attempts: r.length,
+			status: t.status,
+			input: t.input,
+			output: t.output,
+			error: i,
+			durationMs: t.durationMs,
+			_startedAt: r[0].startedAt.getTime()
+		});
+	}
+	return n.sort((e, t) => e._startedAt - t._startedAt), n.map(({ _startedAt: e, ...t }) => t);
+}, C = (n) => {
+	let r = n.workflows ?? [], i = /* @__PURE__ */ new Map(), a = 0;
+	return {
+		start: async (o, s) => {
+			let c = r.find((e) => e.workflow.name === o);
+			if (c === void 0) throw Error(`makeWorkflowRunner: no workflow named '${o}' — pass it in makeWorkflowRunner({ ctx, workflows: [{ workflow, execute }] }).`);
+			let f = `wfrun_test_${++a}`, p = d(), m = c.workflow.toLayer(c.execute).pipe(t.provideMerge(u)), h = /* @__PURE__ */ new Date(), g = c.workflow.execute(s).pipe(e.locally(l, f), e.provide(p.layer), e.provide(m), e.either), _ = await e.runPromise(g), v = S(p.readSteps()), y = /* @__PURE__ */ new Date(), b;
+			if (_._tag === "Right") b = {
+				status: "succeeded",
+				output: _.right,
+				error: null,
+				steps: v,
+				runId: f
+			};
+			else {
+				let e = _.left;
+				b = {
+					status: "failed",
+					output: null,
+					error: {
+						tag: e && typeof e == "object" && "_tag" in e ? String(e._tag) : null,
+						message: e && typeof e == "object" && "message" in e && typeof e.message == "string" ? e.message : String(_.left)
+					},
+					steps: v,
+					runId: f
+				};
+			}
+			return i.set(f, {
+				id: f,
+				executionId: f,
+				name: o,
+				status: b.status,
+				input: s,
+				output: b.output,
+				subject: n.ctx.request.subject,
+				source: "test-runner",
+				steps: v,
+				startedAt: h,
+				finishedAt: y,
+				traceId: null,
+				parentExecutionId: null,
+				parentClosePolicy: null
+			}), b;
+		},
+		inspect: async (e) => i.get(e) ?? null
+	};
+}, w = 1;
+//#endregion
+export { p as MockClock, h as MockEmail, g as MockLLM, w as TESTING_PRESET_VERSION, f as invoke, x as makeTestContext, C as makeWorkflowRunner, _ as mockStore };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@voltro/testing",
+  "version": "0.1.0",
+  "description": "Test utilities for Voltro apps — deterministic clock, captured emails, queued LLM responses, scoped subject/tenant runners, and a cross-dialect parity harness.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./dialect": {
+      "types": "./dist/dialect.d.ts",
+      "import": "./dist/dialect.js",
+      "default": "./dist/dialect.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/database": "0.1.0",
+    "@voltro/env": "0.1.0",
+    "@voltro/protocol": "0.1.0",
+    "@voltro/runtime": "0.1.0",
+    "@voltro/workflow": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}