@voltro/testing 0.84.0 → 0.86.0

package/dist/factory.js

@@ -0,0 +1,65 @@
+import { fixtureRow as e, nextSequence as t } from "./fixtureRow.js";
+import { missingRequiredColumns as n } from "@voltro/database";
+//#region src/factory.ts
+var r = (e) => {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) n[r] = typeof i == "function" ? i(t()) : i;
+	return n;
+}, i = (e) => {
+	for (let [t, n] of Object.entries(e.fields)) if (n.type === "id") return t;
+	return "id";
+}, a = async (e, t, r, a, s) => {
+	let c = {};
+	for (let l of n(t, r)) {
+		let n = t.fields[l];
+		if (n === void 0 || n.type !== "reference" || n.references === void 0) continue;
+		let r = n.references();
+		if (s.includes(r.tableName)) throw Error(`defineFactory: creating '${t.tableName}' requires '${r.tableName}' via '${l}', and that reference is cyclic (${[...s, r.tableName].join(" → ")}). Insert one side first and pass the id: create(store, { ${l}: existing.id }).`);
+		let u = a[l];
+		c[l] = (u === void 0 ? await o(e, r, {}, {}, [...s, r.tableName]) : await u.create(e, {}))[n.referenceColumn ?? i(r)];
+	}
+	return c;
+}, o = async (t, n, r, i, o) => {
+	let s = {
+		...await a(t, n, r, i, o),
+		...r
+	};
+	return t.insert(n.tableName, e(n, s));
+}, s = (e, t) => typeof e == "function" ? e(t) : e ?? {}, c = (t, n = {}) => {
+	let i = n.traits ?? {}, a = n.associations ?? {}, c = (n) => {
+		let l = (e = {}) => ({
+			...r(n),
+			...e
+		}), u = (n = {}) => e(t, l(n));
+		return {
+			table: t,
+			build: u,
+			buildList: (e, t) => Array.from({ length: e }, (e, n) => u(s(t, n))),
+			create: (e, n = {}) => o(e, t, l(n), a, [t.tableName]),
+			createList: async (e, n, r) => {
+				let i = [];
+				for (let c = 0; c < n; c++) i.push(await o(e, t, l(s(r, c)), a, [t.tableName]));
+				return i;
+			},
+			with: (...e) => {
+				let r = n;
+				for (let n of e) {
+					let e = i[n];
+					if (e === void 0) throw Error(`defineFactory: '${t.tableName}' has no trait '${n}'. Declared: ${Object.keys(i).join(", ") || "(none)"}.`);
+					r = {
+						...r,
+						...e
+					};
+				}
+				return c(r);
+			},
+			extend: (e) => c({
+				...n,
+				...e
+			})
+		};
+	};
+	return c(n.defaults ?? {});
+};
+//#endregion
+export { c as defineFactory };

package/dist/fixtureRow.js

@@ -0,0 +1,30 @@
+import { AUTO_FILLED_COLUMNS as e, missingRequiredColumns as t } from "@voltro/database";
+//#region src/fixtureRow.ts
+var n = new Set(e), r = 0, i = () => ++r, a = (e, t) => {
+	if (t.oneOf && t.oneOf.length > 0) return t.oneOf[0];
+	if (t.enumValues && t.enumValues.length > 0) return t.enumValues[0];
+	let n = t.unique === !0;
+	switch (t.type) {
+		case "text":
+		case "id":
+		case "enum": return n ? `${e}-${++r}` : e;
+		case "reference": return t.referenceStorage === "numeric" ? n ? ++r : 0 : n ? `${e}-${++r}` : e;
+		case "integer":
+		case "real": return n ? ++r : 0;
+		case "decimal":
+		case "bigint": return n ? String(++r) : "0";
+		case "boolean": return !1;
+		case "timestamp":
+		case "date": return /* @__PURE__ */ new Date(0);
+		default: throw Error(`fixtureRow: column '${e}' is a required '${t.type}' with no default, and fixtureRow can't synthesize a safe placeholder for that type. Pass it explicitly: fixtureRow(table, { ${e}: … }).`);
+	}
+}, o = (e, r = {}) => {
+	let i = {};
+	for (let o of t(e, r)) n.has(o) || (i[o] = a(o, e.fields[o]));
+	return {
+		...i,
+		...r
+	};
+};
+//#endregion
+export { o as fixtureRow, i as nextSequence };

package/dist/formBindingHarness.js

@@ -0,0 +1,46 @@
+import { makeVoltroTestClient as e } from "./client.js";
+import { act as t, createElement as n } from "react";
+import { useFormBinding as r } from "@voltro/client";
+//#region src/formBindingHarness.tsx
+var i = async (i, a = {}) => {
+	if (globalThis.document === void 0) throw Error("renderFormBinding needs a DOM to render hooks — add `// @vitest-environment jsdom` to the spec.");
+	let { createRoot: o } = await import("react-dom/client"), s = a.apiName ?? "app", c = e({
+		apiName: s,
+		...a.client ?? {},
+		mutations: {
+			[i]: a.mutation ?? (() => ({ ok: !0 })),
+			...a.client?.mutations ?? {}
+		}
+	}), l, u = () => (l = r(s, i, a.binding ?? {}), null), d = o(globalThis.document.createElement("div"));
+	return await t(async () => {
+		d.render(n(c.Provider, null, n(u)));
+	}), {
+		binding: () => l,
+		fill: (e, n) => {
+			t(() => {
+				l.field(e).setValue(n);
+			});
+		},
+		blur: (e) => {
+			t(() => {
+				l.field(e).onBlur();
+			});
+		},
+		submit: async () => {
+			let e;
+			return await t(async () => {
+				e = await l.submit();
+			}), e;
+		},
+		errors: () => l.errors,
+		state: () => l.state,
+		client: c,
+		unmount: () => {
+			t(() => {
+				d.unmount();
+			});
+		}
+	};
+};
+//#endregion
+export { i as renderFormBinding };

package/dist/hydrateFixtureRows.js

@@ -0,0 +1,22 @@
+import { Result as e, Schema as t } from "effect";
+//#region src/hydrateFixtureRows.ts
+var n = t.decodeUnknownResult(t.DateFromString), r = /^\d{4}-\d{2}-\d{2}$/, i = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/, a = (t, a) => {
+	if (typeof t != "string" || !i.test(t) && !(a === "date" && r.test(t))) return !1;
+	let o = t.slice(0, 10), s = n(o);
+	return e.isSuccess(s) && Number.isFinite(s.success.getTime()) && s.success.toISOString().slice(0, 10) === o;
+}, o = (t, r) => {
+	let i = Object.entries(t.fields).filter(([, e]) => e.type === "timestamp" || e.type === "date");
+	return r.map((r, o) => {
+		let s = { ...r };
+		for (let [c, l] of i) {
+			let i = r[c];
+			if (i == null || i instanceof Date && Number.isFinite(i.getTime())) continue;
+			let u = n(i);
+			if (!a(i, l.type) || e.isFailure(u) || !Number.isFinite(u.success.getTime())) throw TypeError(`hydrateFixtureRows: table '${t.tableName}', row ${o}, column '${c}' requires a valid Date or ISO date-time with Z or an offset${l.type === "date" ? " (YYYY-MM-DD is also accepted as UTC midnight)" : ""}.`);
+			s[c] = u.success;
+		}
+		return s;
+	});
+};
+//#endregion
+export { o as hydrateFixtureRows };

package/dist/index.d.ts

@@ -13,7 +13,6 @@ import { EventPublisher } from '@voltro/runtime';
 import { InspectedStep } from '@voltro/workflow';
 import { InspectedWorkflow } from '@voltro/workflow';
 import { Layer } from 'effect';
-import { ParseResult } from 'effect';
 import { ProcedureDescriptor } from '@voltro/protocol';
 import { PublicApiDescriptor } from '@voltro/protocol/rest';
 import { PublicApiProfileConfig } from '@voltro/protocol';
@@ -27,6 +26,7 @@ import { RpcConnection } from '@voltro/runtime';
 import { RpcInterceptor } from '@voltro/protocol';
 import { RpcKind } from '@voltro/protocol';
 import { Schema } from 'effect';
+import { SchemaError } from 'effect/Schema';
 import { Scope } from 'effect';
 import { ServiceApi } from '@voltro/protocol';
 import { Subject } from '@voltro/protocol';
@@ -678,8 +678,6 @@ export declare const nextSequence: () => number;
 /** Delivery nudges emitted through `ctx.outbox` on this context. */
 export declare const outboxNudgesOf: (ctx: TestContext) => ReadonlyArray<string>;
 
-export { ParseResult }
-
 /** The plugins a context was built with — for the REST harness, which hands
  *  their cross-cutting errors to the `publicApi` projection the way both boot
  *  paths do. */
@@ -809,6 +807,8 @@ export declare const runAfterCommit: (ctx: TestContext) => Promise<void>;
  */
 export declare const runInStoreTransaction: <T>(ctx: TestContext, work: (txCtx: TestContext) => Promise<T>) => Promise<T>;
 
+export { SchemaError }
+
 /** A machine subject scoped to ONE tenant (a per-tenant integration, a
  *  `storeForTenant` view). NOT the cross-tenant `system()` below. */
 export declare const serviceAccount: (id: string, options?: TestSubjectOptions) => Subject;
@@ -1020,11 +1020,11 @@ export declare interface TestEventBus {
      * descriptor fails here, which is the point: a harness that skipped validation
      * would let a test pass on a payload production rejects.
      */
-    publish<Name extends string, Key extends Schema.Schema.Any, Payload extends Schema.Schema.Any>(descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, payload: Schema.Schema.Type<Payload>): Promise<{
+    publish<Name extends string, Key extends Schema.Top, Payload extends Schema.Top>(descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, payload: Schema.Schema.Type<Payload>): Promise<{
         readonly n: number;
     }>;
     /** Publish and ASSERT it succeeded — the common case, one line. */
-    subscribe<Name extends string, Key extends Schema.Schema.Any, Payload extends Schema.Schema.Any>(descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, options?: {
+    subscribe<Name extends string, Key extends Schema.Top, Payload extends Schema.Top>(descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, options?: {
         readonly tenantId?: string | null;
         readonly resume?: ReadonlyArray<{
             origin: string;
@@ -1040,7 +1040,7 @@ export declare interface TestEventBus {
      * is owed messages the ring never held — exactly the shape a slow consumer
      * produces, deterministically.
      */
-    skipSerials<Name extends string, Key extends Schema.Schema.Any, Payload extends Schema.Schema.Any>(descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, count: number, options?: {
+    skipSerials<Name extends string, Key extends Schema.Top, Payload extends Schema.Top>(descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, count: number, options?: {
         readonly tenantId?: string | null;
     }): void;
     /** The underlying bus, for a test that needs something not exposed here. */
@@ -1094,13 +1094,13 @@ export declare interface TestResponse {
     readonly headers: Readonly<Record<string, string | ReadonlyArray<string>>>;
     /** The raw response body as text (empty string when there was none). */
     readonly text: string;
-    /** The body parsed as JSON when the route answered with a JSON content-type,
-     *  otherwise `undefined`. Every framework REST response is JSON; a streaming
-     *  (SSE) route answers with neither — see `stream`. */
+    /** Byte-exact buffered body, including a consumed finite byte stream. SSE remains unconsumed. */
+    readonly bytes?: Uint8Array;
+    /** Parsed JSON when the response has a JSON content-type; otherwise
+     *  `undefined`. SSE responses remain unconsumed. */
     readonly body: unknown;
-    /** `true` for a streaming (SSE) route: the response has no buffered body, so
-     *  `text` is empty and `body` is `undefined`. Stated rather than silently
-     *  looking like an empty 200. */
+    /** True for SSE and byte streams. Finite byte streams populate `bytes` and
+     *  `text`; SSE remains unconsumed, with empty text and undefined body. */
     readonly stream: boolean;
 }
 
@@ -1161,7 +1161,7 @@ export declare const withFrozenTime: <A>(at: Date | number | string | MockClock,
 export declare const withRpcConnection: (ctx: TestContext, connection: RpcConnection | undefined) => TestContext;
 
 /** A workflow + its execute function, as the framework pairs them via
- *  `workflow.toLayer(execute)`. Structural (no `@effect/workflow` generic
+ *  `workflow.toLayer(execute)`. Structural (no `effect/workflow` generic
  *  signature) so callers can pass the value from `workflow({ name, ... })`
  *  plus its `(payload, executionId) => Effect` execute directly — type-erased
  *  over the workflow's payload/success/error/requirement shapes. */