@voltro/testing 0.85.0 → 0.86.0

package/dist/testEventBus.js

@@ -0,0 +1,73 @@
+import { Effect as e, Result as t } from "effect";
+import { eventRoute as n } from "@voltro/protocol";
+import { EventBus as r, publishEvent as i } from "@voltro/runtime";
+//#region src/testEventBus.ts
+var a = (a = {}) => {
+	let o = a.tenantId ?? null, s = new r({
+		origin: a.origin ?? "test",
+		...a.ringSize === void 0 ? {} : { ringSize: a.ringSize }
+	});
+	return {
+		publish: async (n, r, a) => {
+			let c = await e.runPromise(e.result(i({
+				bus: s,
+				tenantId: o
+			}, n, r, a)));
+			if (t.isFailure(c)) {
+				let e = c.failure;
+				throw Error(`testEventBus.publish(${n.name}) was rejected: ${e._tag}`, { cause: e });
+			}
+			return { n: c.success.n };
+		},
+		subscribe: (e, t, n) => {
+			let r = [], i = [];
+			return {
+				get received() {
+					return r.map((e) => e.payload);
+				},
+				get deliveries() {
+					return r;
+				},
+				get missed() {
+					return i;
+				},
+				get missedCount() {
+					return i.reduce((e, t) => e + t.count, 0);
+				},
+				stop: s.subscribe({
+					tenantId: n?.tenantId ?? o,
+					event: e.name,
+					key: t,
+					listener: (e) => {
+						e.kind === "gap" ? i.push({
+							count: e.missed,
+							reason: e.reason
+						}) : r.push({
+							payload: e.envelope.payload,
+							origin: e.envelope.origin,
+							n: e.envelope.n
+						});
+					},
+					...n?.resume === void 0 ? {} : { options: { resume: n.resume } }
+				})
+			};
+		},
+		skipSerials: (e, t, r, i) => {
+			let a = i?.tenantId ?? o, c = {
+				route: n(a, e.name, t),
+				event: e.name,
+				origin: "test-gap",
+				n: r + 1,
+				emittedAt: Date.now(),
+				payload: void 0
+			};
+			s.injectRemote(c);
+		},
+		bus: s,
+		reset: () => {
+			s.clear();
+		}
+	};
+};
+//#endregion
+export { a as testEventBus };

package/dist/testRequest.js

@@ -0,0 +1,119 @@
+import { markRestInvocation as e, pluginsOf as t } from "./testContext.js";
+import { invoke as n } from "./invoke.js";
+import { Effect as r } from "effect";
+import { composeAuthStrategies as i } from "@voltro/protocol";
+import { resolveRequestClientAddress as a, resolveTrustedProxies as o } from "@voltro/runtime";
+import { collectPublicApiRoutes as s, dispatchSharedPath as c, restRoutesToHttpRoutes as l } from "@voltro/protocol/rest";
+//#region src/testRequest.ts
+var u = "127.0.0.1", d = (e) => {
+	let t = e.indexOf("?");
+	return t === -1 ? {
+		path: e,
+		query: ""
+	} : {
+		path: e.slice(0, t),
+		query: e.slice(t + 1)
+	};
+}, f = (e, t) => {
+	let n = e.split("/").filter((e) => e.length > 0), r = t.split("/").filter((e) => e.length > 0);
+	return n.length === r.length && n.every((e, t) => e.startsWith(":") || e === r[t]);
+}, p = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e)) t[n.toLowerCase()] = r;
+	return t;
+}, m = (e) => e === void 0 ? /* @__PURE__ */ new Uint8Array() : new TextEncoder().encode(JSON.stringify(e)), h = (e) => e === void 0 ? "" : typeof e == "string" ? e : new TextDecoder().decode(e), g = (g) => {
+	let _ = o(g.security?.trustedProxies, process.env, g.security?.clientAddressHeader), { ctx: v } = g, y = s((g.publicApi ?? []).map((t) => ({
+		descriptor: t.descriptor,
+		invoke: (r, i) => v.withSubject(i.subject, (a) => (t.descriptor.publicApi !== void 0 && e(a, t.descriptor.publicApi, i.remoteAddr), n(t.descriptor, t.handler, r, a)))
+	})), {
+		pluginErrors: t(v).flatMap((e) => e.errorSchemas ?? []),
+		...g.publicApiProfile === void 0 ? {} : { profile: g.publicApiProfile }
+	}), b = [...g.restRoutes ?? [], ...y], x = i(g.strategies ?? [], {
+		anonymous: g.anonymous ?? { headerOrTenant: "acme" },
+		getStore: () => v.store
+	}), S = (e, n) => {
+		let i = {
+			store: v.store,
+			...t(v).some((e) => e.restRateLimit !== void 0) ? { rateLimit: (e, n, i) => r.forEach(t(v), (t) => t.restRateLimit?.(e, n, i) ?? r.void, { discard: !0 }) } : {},
+			buildContext: () => v,
+			resolveSubject: e === void 0 ? async (e) => (await x({
+				headers: e,
+				clientId: -1
+			})).subject : () => e,
+			...g.idempotency === void 0 ? {} : { idempotency: g.idempotency }
+		}, o = l(b, i).map((e, t) => ({
+			pattern: b[t].path,
+			route: e
+		})), s = async (e, t, r = {}) => {
+			let { path: i, query: s } = d(t), l = o.filter((e) => f(e.pattern, i)).map((e) => e.route);
+			if (l.length === 0) return {
+				status: 404,
+				headers: {},
+				text: "",
+				body: {
+					error: "No route mounted for this path",
+					mounted: b.map((e) => e.path)
+				},
+				stream: !1
+			};
+			let g = {
+				...p(n),
+				...p(r.headers ?? {})
+			}, y = a({
+				socketAddress: r.remoteAddr ?? u,
+				headers: g,
+				config: _
+			}), x = {
+				method: e.toUpperCase(),
+				path: i,
+				query: s,
+				headers: g,
+				rawBody: m(r.body),
+				store: v.store,
+				...y === void 0 ? {} : { remoteAddr: y }
+			}, S = await c(l, x), C = {};
+			for (let [e, t] of Object.entries(S.headers ?? {})) C[e.toLowerCase()] = t;
+			S.contentType !== void 0 && (C["content-type"] = S.contentType);
+			let w = typeof S.body == "string" ? new TextEncoder().encode(S.body) : S.body ?? /* @__PURE__ */ new Uint8Array();
+			if (S.byteStream !== void 0) {
+				let e = S.byteStream.stream, t = typeof e == "function" ? e() : e;
+				w = new Uint8Array(await new Response(t).arrayBuffer());
+			}
+			let T = h(w), E = (S.contentType ?? "").includes("json");
+			return {
+				status: S.status,
+				headers: C,
+				text: T,
+				body: E && T !== "" ? JSON.parse(T) : void 0,
+				bytes: w,
+				stream: S.stream !== void 0 || S.byteStream !== void 0
+			};
+		};
+		return {
+			actingAs: (e) => S(e, n),
+			withHeaders: (t) => S(e, {
+				...n,
+				...t
+			}),
+			get: (e, t) => s("GET", e, t ?? {}),
+			delete: (e, t) => s("DELETE", e, t ?? {}),
+			post: (e, t, n) => s("POST", e, {
+				...n ?? {},
+				body: t
+			}),
+			put: (e, t, n) => s("PUT", e, {
+				...n ?? {},
+				body: t
+			}),
+			patch: (e, t, n) => s("PATCH", e, {
+				...n ?? {},
+				body: t
+			}),
+			request: (e, t, n) => s(e, t, n ?? {}),
+			paths: b.map((e) => e.path)
+		};
+	};
+	return S(void 0, {});
+};
+//#endregion
+export { g as makeTestApp };

package/dist/workflowRunner.js

@@ -0,0 +1,85 @@
+import { Effect as e, Layer as t, Result as n } from "effect";
+import { getFieldCipher as r, makeEffectStoreLayer as i, makeFieldCipher as a } from "@voltro/runtime";
+import { randomBytes as o } from "node:crypto";
+import { CurrentWorkflowRunId as s, failureMessage as c, getWorkflowJournalCipher as l, inMemoryWorkflowEngineLayer as u, makeInMemoryRecorder as d, setWorkflowJournalCipher as f } from "@voltro/workflow";
+//#region src/workflowRunner.ts
+var p = (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);
+}, m = () => {
+	if (l() !== void 0) return;
+	let e = a(o(32).toString("hex"));
+	f(() => r() ?? e);
+}, h = (r) => {
+	m();
+	let a = r.workflows ?? [], o = /* @__PURE__ */ new Map(), l = 0;
+	return {
+		start: async (f, m) => {
+			let h = a.find((e) => e.workflow.name === f);
+			if (h === void 0) throw Error(`makeWorkflowRunner: no workflow named '${f}' — pass it in makeWorkflowRunner({ ctx, workflows: [{ workflow, execute }] }).`);
+			let g = `wfrun_test_${++l}`, _ = d(), v = h.workflow.toLayer(h.execute).pipe(t.provideMerge(u)), y = /* @__PURE__ */ new Date(), b = h.workflow.execute(m).pipe(e.provideService(s, g), e.provide(_.layer), e.provide(v)), x = (r.ctx.store === void 0 ? b : e.provide(b, i(r.ctx.store))).pipe(e.result), S = await e.runPromise(x), C = p(_.readSteps()), w = /* @__PURE__ */ new Date(), T;
+			if (n.isSuccess(S)) T = {
+				status: "succeeded",
+				output: S.success,
+				error: null,
+				steps: C,
+				runId: g
+			};
+			else {
+				let e = S.failure;
+				T = {
+					status: "failed",
+					output: null,
+					error: {
+						tag: e && typeof e == "object" && "_tag" in e ? String(e._tag) : null,
+						message: c(S.failure)
+					},
+					steps: C,
+					runId: g
+				};
+			}
+			return o.set(g, {
+				id: g,
+				executionId: g,
+				name: f,
+				status: T.status,
+				input: m,
+				output: T.output,
+				subject: r.ctx.request.subject,
+				source: "test-runner",
+				steps: C,
+				startedAt: y,
+				finishedAt: w,
+				traceId: null,
+				parentExecutionId: null,
+				parentClosePolicy: null
+			}), T;
+		},
+		inspect: async (e) => o.get(e) ?? null
+	};
+};
+//#endregion
+export { h as makeWorkflowRunner };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/testing",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "description": "Test utilities for Voltro apps — deterministic clock, subject and row factories, a handler-level invoke and a request-level app harness, queued LLM responses, scoped subject/tenant runners, and a cross-dialect parity harness.",
   "keywords": [
     "voltro",
@@ -53,16 +53,16 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.85.0",
-    "@voltro/env": "0.85.0",
-    "@voltro/local-first": "0.85.0",
-    "@voltro/logger": "0.85.0",
-    "@voltro/protocol": "0.85.0",
-    "@voltro/runtime": "0.85.0",
-    "@voltro/workflow": "0.85.0"
+    "@voltro/database": "0.86.0",
+    "@voltro/env": "0.86.0",
+    "@voltro/local-first": "0.86.0",
+    "@voltro/logger": "0.86.0",
+    "@voltro/protocol": "0.86.0",
+    "@voltro/runtime": "0.86.0",
+    "@voltro/workflow": "0.86.0"
   },
   "peerDependencies": {
-    "@voltro/client": "0.85.0",
+    "@voltro/client": "0.86.0",
     "effect": "4.0.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",