@voltro/testing 0.86.0 → 0.87.0

package/dist/fieldKeys.js

@@ -0,0 +1,73 @@
+import { declaredEncryptedColumns as e, declaredRenames as t, getFieldCipher as n, isFieldKeyring as r, makeFieldKeyring as i, openCell as a, setFieldCipher as o } from "@voltro/runtime";
+//#region src/fieldKeys.ts
+var s = /* @__PURE__ */ new WeakMap(), c = (e) => {
+	let t = i(e);
+	return s.set(t, e), o(t), t;
+}, l = (e, t = e.active) => {
+	let n = e.keys.find((e) => e.id === t);
+	if (n === void 0) throw Error(`the keyring does not hold its active key "${t}"`);
+	return i({
+		active: n.id,
+		keys: [n]
+	});
+}, u = (e = (() => {
+	let e = n();
+	return r(e) ? e : void 0;
+})(), t) => {
+	if (t !== void 0) return l(t);
+	if (e === void 0) throw Error("no field keyring is registered — pass `fieldKeys` to makeTestContext, or call registerTestFieldKeys");
+	let i = s.get(e);
+	if (i === void 0) throw Error("the registered field keyring was not built by the test helpers, so its keys are unknown here — register it with `fieldKeys` / registerTestFieldKeys");
+	return l(i, e.activeKeyId);
+}, d = /* @__PURE__ */ new WeakMap(), f = (e, t) => {
+	d.set(e, t);
+}, p = (e) => typeof e == "string" ? e : e?.tableName, m = async (n, r) => {
+	let i = d.get(n) ?? n;
+	if (typeof i.query != "function") throw Error("pass a test context (makeTestContext) or a DataStore");
+	let o = [...r.tables], s = e(o), c = t(o), l = u(r.keyring), f = 0, m = [];
+	for (let e of o) {
+		let t = p(e);
+		if (t === void 0) continue;
+		let n = await i.query({
+			table: t,
+			predicate: void 0,
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of n) {
+			let { id: n, ...r } = e;
+			for (let [i, o] of Object.entries(e)) {
+				if (o == null) continue;
+				let e = typeof o == "string" ? o : JSON.stringify(o);
+				if (!e.includes("enc:v")) continue;
+				let u = a(e, l, {
+					table: t,
+					column: i,
+					rowId: n,
+					row: r,
+					declared: s,
+					renames: c
+				});
+				f += u.opened, u.unopened > 0 && m.push({
+					table: t,
+					column: i,
+					rowId: n,
+					count: u.unopened
+				});
+			}
+		}
+	}
+	return {
+		activeKeyId: l.activeKeyId,
+		opened: f,
+		unopened: m
+	};
+}, h = (e) => `${e.unopened.reduce((e, t) => e + t.count, 0)} sealed value(s) do not open with the active key ${e.activeKeyId} alone:\n` + e.unopened.slice(0, 20).map((e) => `  ${e.table}.${e.column}${e.rowId === void 0 ? "" : ` (row ${String(e.rowId)})`}: ${e.count}`).join("\n") + (e.unopened.length > 20 ? `\n  … and ${e.unopened.length - 20} more place(s)` : ""), g = async (e, t) => {
+	let n = await m(e, t);
+	if (n.unopened.length > 0) throw Error(h(n));
+	return n;
+};
+//#endregion
+export { u as activeKeyAlone, h as describeActiveKeyAloneFailures, g as expectSealedWithActiveKeyAlone, f as recordTestRawStore, c as registerTestFieldKeys, m as sealedValuesWithActiveKeyAlone };

package/dist/fieldKeysSql.js

@@ -0,0 +1,14 @@
+import { activeKeyAlone as e } from "./fieldKeys.js";
+import { Effect as t } from "effect";
+import { verifySealedValues as n } from "@voltro/runtime";
+//#region src/fieldKeysSql.ts
+var r = async (r) => {
+	let i = e(r.keyring, r.fieldKeys), a = await t.runPromise(t.scoped(n(r.dialect, i, r.tables ?? [])).pipe(t.provide(r.layer))), o = {
+		activeKeyId: i.activeKeyId,
+		...a
+	};
+	if (o.unopened.length > 0 || o.unreadable.length > 0) throw Error(`${o.unopened.reduce((e, t) => e + t.count, 0)} sealed value(s) do not open with the active key ${o.activeKeyId} alone` + (o.unopened.length === 0 ? "" : `:\n${o.unopened.map((e) => `  ${e.table}.${e.column}: ${e.count}`).join("\n")}`) + (o.unreadable.length === 0 ? "" : `\n${o.unreadable.length} column(s) could not be read:\n${o.unreadable.map((e) => `  ${e.table}.${e.column}: ${e.reason}`).join("\n")}`));
+	return o;
+};
+//#endregion
+export { r as expectSealedWithActiveKeyAloneInSql };

package/dist/hotStoreSqlParity.js

@@ -0,0 +1,132 @@
+import { eq as e, queryFor as t, registerTable as n } from "@voltro/database";
+import { Effect as r, Layer as i, Option as a, Result as o, Stream as s } from "effect";
+import { describe as c, expect as l, it as u } from "vitest";
+import { randomUUID as d } from "node:crypto";
+import { HotStore as f } from "@voltro/kv/hot/contract";
+import { hotStoreConformance as p } from "@voltro/kv/hot/testing";
+import { dataStoreHotStore as m, hotDataStoreTables as h, hotKvTable as g, hotZTable as _ } from "@voltro/runtime/hot";
+//#region src/hotStoreSqlParity.ts
+var v = (v) => {
+	h.forEach(n), p(v.name, () => {
+		let e = 0;
+		return {
+			layer: i.effect(f, r.acquireRelease(r.promise(v.make), (e) => r.promise(e.dispose)).pipe(r.map((t) => m(t.store, {
+				dialect: v.dialect,
+				namespace: d(),
+				now: () => e
+			})))),
+			advance: (t) => r.sync(() => {
+				e += t;
+			}),
+			capabilities: {
+				atomicMulti: !0,
+				crossNode: !0,
+				persistent: !0
+			}
+		};
+	});
+	let y = (e, t) => u(e, async () => {
+		let e = await v.make();
+		try {
+			await t(e);
+		} finally {
+			await e.dispose();
+		}
+	}, 6e4);
+	c(`HotStore SQL parity — ${v.name}`, () => {
+		y("idempotent table DDL preserves exact normalized scores and physical deletion", async (e) => {
+			let n = m(e.store, {
+				dialect: v.dialect,
+				namespace: "sql"
+			}), i = 1.2345678901234567;
+			await r.runPromise(n.zadd("player:subject", [{
+				member: "member",
+				score: i
+			}])), await e.migrate(), l(await e.store.query(t(_).descriptor)).toEqual([l.objectContaining({
+				member: "member",
+				score: i
+			})]), await r.runPromise(n.delete("player:subject")), l(await e.store.query(t(_).descriptor)).toEqual([]), l(await e.store.query(t(g).descriptor)).toEqual([l.objectContaining({
+				keyHash: "lock",
+				namespace: null,
+				key: null,
+				payload: null,
+				expiresAtMs: null
+			})]);
+		}), y("wrong-type batches roll back every preceding SQL write", async (n) => {
+			let i = m(n.store, {
+				dialect: v.dialect,
+				namespace: "atomic"
+			});
+			await r.runPromise(i.zadd("board", [{
+				member: "m",
+				score: 1
+			}]));
+			let s = await r.runPromise(i.multi([{
+				op: "incrBy",
+				key: "other",
+				delta: 1
+			}, {
+				op: "incrBy",
+				key: "board",
+				delta: 1
+			}]).pipe(r.result));
+			l(o.isFailure(s)).toBe(!0), l(await n.store.query(t(g).where(e("key", "other")).descriptor)).toEqual([]), l(a.getOrNull(await r.runPromise(i.zscore("board", "m")))).toBe(1);
+		}), y("namespace/key boundaries, case, wildcard prefixes and long Unicode values remain exact", async (e) => {
+			let t = m(e.store, {
+				dialect: v.dialect,
+				namespace: "n"
+			}), n = m(e.store, {
+				dialect: v.dialect,
+				namespace: "n:tenant"
+			}), i = m(e.store, {
+				dialect: v.dialect,
+				namespace: "N"
+			});
+			await r.runPromise(t.incrBy("tenant:key", 4)), await r.runPromise(n.incrBy("key", 2)), await r.runPromise(i.incrBy("tenant:key", 9)), await r.runPromise(t.incrBy("%_:key", 1)), await r.runPromise(t.incrBy("wildcard-key", 1));
+			let o = "🎮".repeat(2e3);
+			await r.runPromise(t.zadd(o, [{
+				member: o,
+				score: -1.5
+			}])), l(await r.runPromise(t.incrBy("tenant:key", 0))).toBe(4), l(await r.runPromise(n.incrBy("key", 0))).toBe(2), l(await r.runPromise(i.incrBy("tenant:key", 0))).toBe(9), l(await r.runPromise(s.runCollect(t.scanPrefix("%_:")))).toEqual(["%_:key"]), l(await r.runPromise(s.runCollect(i.scanPrefix("")))).toEqual(["tenant:key"]), l(a.getOrNull(await r.runPromise(t.zscore(o, o)))).toBe(-1.5);
+		}), y("independent connections retain every cold-key increment and have one lease winner", async (e) => {
+			let t = [e.store];
+			for (let n = 0; n < 3; n++) t.push(await e.connect());
+			let n = t.map((e) => m(e, {
+				dialect: v.dialect,
+				namespace: "connections"
+			})), i = await Promise.all(Array.from({ length: 32 }, (e, t) => r.runPromise(n[t % n.length].incrBy("counter", 1))));
+			l(new Set(i).size).toBe(32), l(await r.runPromise(n[0].incrBy("counter", 0))).toBe(32);
+			let a = await Promise.all(Array.from({ length: 32 }, (e, t) => r.runPromise(n[t % n.length].setNx("seat", String(t), 6e4))));
+			l(a.filter(Boolean)).toHaveLength(1);
+		}), y("concurrent first-use ports admit coordination before application writes", async (e) => {
+			let t = [e.store];
+			for (let n = 0; n < 3; n++) t.push(await e.connect());
+			let n = Array.from({ length: 32 }, (e, n) => m(t[n % t.length], {
+				dialect: v.dialect,
+				namespace: "first-use"
+			})), i = (await Promise.allSettled(n.map((e) => r.runPromise(e.incrBy("counter", 1))))).map((e) => {
+				if (e.status === "rejected") throw e.reason;
+				return e.value;
+			});
+			l(new Set(i).size).toBe(32), l(await r.runPromise(n[0].incrBy("counter", 0))).toBe(32);
+		}), y("new connections rebuild the port from persisted SQL and apply stored expiry", async (e) => {
+			let t = 0, n = m(e.store, {
+				dialect: v.dialect,
+				namespace: "reconnect",
+				now: () => t
+			});
+			await r.runPromise(n.incrBy("counter", 7)), await r.runPromise(n.zadd("board", [{
+				member: "𐀀",
+				score: 1.2345678901234567
+			}])), await r.runPromise(n.setNx("seat", "holder", 100));
+			let i = m(await e.connect(), {
+				dialect: v.dialect,
+				namespace: "reconnect",
+				now: () => t
+			});
+			l(await r.runPromise(i.incrBy("counter", 0))).toBe(7), l(a.getOrNull(await r.runPromise(i.zscore("board", "𐀀")))).toBe(1.2345678901234567), l(await r.runPromise(i.setNx("seat", "replacement", 100))).toBe(!1), t = 100, l(await r.runPromise(i.setNx("seat", "replacement", 100))).toBe(!0);
+		});
+	});
+};
+//#endregion
+export { v as runHotStoreSqlParity };

package/dist/index.d.ts

@@ -6,22 +6,33 @@ import { ChangeEvent } from '@voltro/database';
 import { changeInsert } from '@voltro/database';
 import { changeSoftDelete } from '@voltro/database';
 import { changeUpdate } from '@voltro/database';
+import { ComputedQueryCacheDeps } from '@voltro/runtime';
+import { ConnectionRef } from '@voltro/kv/connection';
+import { ConnectionRegistry } from '@voltro/kv/connection';
+import { ConnectionRegistryOptions } from '@voltro/kv/connection';
+import { ConnectionsConfig } from '@voltro/kv/connection';
+import { DialectId } from '@voltro/database';
 import { Effect } from 'effect';
 import { EventBus } from '@voltro/runtime';
 import { EventDescriptor } from '@voltro/protocol';
 import { EventPublisher } from '@voltro/runtime';
+import { FieldKeyring } from '@voltro/runtime';
+import { FieldKeyringConfig } from '@voltro/runtime';
 import { InspectedStep } from '@voltro/workflow';
 import { InspectedWorkflow } from '@voltro/workflow';
 import { Layer } from 'effect';
+import { MemoryRedisConnection } from '@voltro/kv/connection';
 import { ProcedureDescriptor } from '@voltro/protocol';
 import { PublicApiDescriptor } from '@voltro/protocol/rest';
 import { PublicApiProfileConfig } from '@voltro/protocol';
 import { PublicApiSpec } from '@voltro/protocol';
+import { RedisConnections } from '@voltro/kv';
 import { RelationsSpec } from '@voltro/database';
 import { RestRouteDescriptor } from '@voltro/protocol/rest';
 import { RestServeBindings } from '@voltro/protocol/rest';
 import { Row } from '@voltro/database';
 import { RowFilter } from '@voltro/runtime';
+import { RowFilterScope } from '@voltro/runtime';
 import { RpcConnection } from '@voltro/runtime';
 import { RpcInterceptor } from '@voltro/protocol';
 import { RpcKind } from '@voltro/protocol';
@@ -29,12 +40,46 @@ import { Schema } from 'effect';
 import { SchemaError } from 'effect/Schema';
 import { Scope } from 'effect';
 import { ServiceApi } from '@voltro/protocol';
+import { SqlClient } from 'effect/sql';
 import { Subject } from '@voltro/protocol';
 import { SubscribeContext } from '@voltro/runtime';
 import { SyncLogger } from '@voltro/logger';
 import { TableLike } from '@voltro/database';
 import { VoltroPlugin } from '@voltro/protocol';
 
+/**
+ * The keyring reduced to its active key — `fieldKeys` when given (a
+ * configuration, e.g. the one a rotation printed), else the registered one.
+ */
+export declare const activeKeyAlone: (keyring?: FieldKeyring | undefined, fieldKeys?: FieldKeyringConfig) => FieldKeyring;
+
+/** Values the active key alone does not open, per place. */
+export declare interface ActiveKeyAloneReport {
+    readonly activeKeyId: string;
+    readonly opened: number;
+    readonly unopened: ReadonlyArray<{
+        readonly table: string;
+        readonly column: string;
+        readonly rowId: unknown;
+        readonly count: number;
+    }>;
+}
+
+export declare interface ActiveKeyAloneSqlReport {
+    readonly activeKeyId: string;
+    readonly opened: number;
+    readonly unopened: ReadonlyArray<{
+        readonly table: string;
+        readonly column: string;
+        readonly count: number;
+    }>;
+    readonly unreadable: ReadonlyArray<{
+        readonly table: string;
+        readonly column: string;
+        readonly reason: string;
+    }>;
+}
+
 /** An unauthenticated caller, optionally carrying a tenant (what the
  *  `x-tenant` header resolves to when no auth strategy matches). Delegates to
  *  the protocol's own constructor so the harness cannot drift from it. */
@@ -142,6 +187,28 @@ export declare interface EmittedWebhook {
  *  ergonomic without an `any` in the public type. */
 declare type ErasedWorkflowEffect = Effect.Effect<unknown, unknown, never>;
 
+/** Assert that after a rotation every sealed value opens with the active key alone. Returns the report. */
+export declare const expectSealedWithActiveKeyAlone: (source: object, options: {
+    readonly tables: Iterable<unknown>;
+    readonly keyring?: FieldKeyring;
+}) => Promise<ActiveKeyAloneReport>;
+
+/**
+ * Assert that every sealed value in the database `layer` connects to opens with
+ * the active key alone. `tables` are the app's declared tables (their
+ * `.encrypted()` columns are always checked); `keyring` defaults to the one
+ * registered with `fieldKeys` / `registerTestFieldKeys`. Columns that cannot be
+ * read fail the assertion too — a check that skipped them would pass vacuously.
+ */
+export declare const expectSealedWithActiveKeyAloneInSql: (options: {
+    readonly dialect: DialectId;
+    readonly layer: Layer.Layer<SqlClient.SqlClient, unknown, never>;
+    readonly tables?: Iterable<unknown>;
+    readonly keyring?: FieldKeyring;
+    /** The keyring as configured (ids and keys, the active one named) — instead of a registered keyring. */
+    readonly fieldKeys?: FieldKeyringConfig;
+}) => Promise<ActiveKeyAloneSqlReport>;
+
 export declare interface Factory {
     /** The table this factory builds rows for. */
     readonly table: TableLike;
@@ -482,6 +549,14 @@ export declare interface MakeTestContextOptions<RowFilterCtx = unknown> {
      * gate, and the gate is what turns the variable into a cipher.
      */
     readonly fieldEncryptionKey?: string;
+    /**
+     * A keyring instead of one key — several ids, one active — registered the way
+     * the boot registers `VOLTRO_FIELD_ENCRYPTION_KEYS` (`registerTestFieldKeys`).
+     * With it, `expectSealedWithActiveKeyAlone(ctx, { tables })` checks what a
+     * rotation ends with: every sealed value opens with the active key alone.
+     * Not together with `fieldEncryptionKey`.
+     */
+    readonly fieldKeys?: FieldKeyringConfig;
     /**
      * Plugins whose rpc interceptors (`interceptMutation` / `interceptQuery` /
      * `interceptAction`) wrap every `invoke` on this context — the same list an
@@ -528,7 +603,7 @@ export declare interface MakeTestContextOptions<RowFilterCtx = unknown> {
      * Merged LAST, so a user layer overrides a plugin layer declaring the same
      * Tag — the ordering `makeHandlerServiceLayer` uses on both boot paths.
      */
-    readonly layers?: ReadonlyArray<Layer.Layer<unknown, never, never>>;
+    readonly layers?: ReadonlyArray<Layer.Layer<never, never, never>>;
     /**
      * Row-level security for this context, WITHOUT touching the process global.
      *
@@ -706,6 +781,8 @@ export declare interface PublicApiBinding {
     readonly handler: (input: never, ctx: TestContext) => unknown;
 }
 
+export declare const queryCacheOf: (ctx: TestContext) => TestQueryCache | undefined;
+
 export declare interface ReachableTarget {
     readonly host: string;
     readonly port: number;
@@ -721,6 +798,14 @@ export declare interface RecordedDelivery<P = unknown> {
     readonly n: number;
 }
 
+/**
+ * Register a keyring as this process's field cipher — what the boot builds from
+ * `VOLTRO_FIELD_ENCRYPTION_KEYS` — and remember its keys, so the active-key-alone
+ * check can open values with the active key and nothing else. Call it again with
+ * the next configuration to rotate inside a test.
+ */
+export declare const registerTestFieldKeys: (config: FieldKeyringConfig) => FieldKeyring;
+
 /**
  * The engine BUILD behind a target, printed once per file.
  *
@@ -809,6 +894,16 @@ export declare const runInStoreTransaction: <T>(ctx: TestContext, work: (txCtx:
 
 export { SchemaError }
 
+/**
+ * Every sealed value in `tables` — the app's declared tables, or names — opened
+ * with the active key alone; the values it does not open are listed. Reads the
+ * RAW rows (envelopes as stored), not through the store's decryption.
+ */
+export declare const sealedValuesWithActiveKeyAlone: (source: object, options: {
+    readonly tables: Iterable<unknown>;
+    readonly keyring?: FieldKeyring;
+}) => Promise<ActiveKeyAloneReport>;
+
 /** 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;
@@ -1071,6 +1166,22 @@ export declare interface TestEventBusOptions {
 
 export declare const TESTING_PRESET_VERSION: 1;
 
+/**
+ * The query cache a context's `invoke` serves `cache:` queries through — the
+ * runtime's own `cachedComputedCall` over a real `@voltro/cache` `Cache` (memory
+ * backend, ttl on `ctx.clock`). A write through any context of the tree drops
+ * the entries tagged with its table, synchronously, so a test can assert
+ * "write X invalidates query Y" and "a revoked grant refuses a hit" without a
+ * redis and without waiting.
+ */
+export declare interface TestQueryCache {
+    readonly deps: ComputedQueryCacheDeps;
+    /** This context's resolved row-filter visibility (`undefined`: no filter). */
+    readonly rowFilter: () => Promise<RowFilterScope | undefined>;
+    /** Results a cached compute did not keep, and why — the dev log's lines. */
+    readonly notices: ReadonlyArray<string>;
+}
+
 export declare interface TestRequestOptions {
     /** Extra headers for this call, merged over the app's (`actingAs` /
      *  `withHeaders`) headers. Names are lowercased, as the transport delivers
@@ -1138,6 +1249,13 @@ export declare interface TestSubscriber<P = unknown> {
  */
 export declare const user: (id: string, options?: TestSubjectOptions) => Subject;
 
+/** Replace named app entries with scoped local transports, without changing a
+ * handler's references. Provide this layer last in a test context's layers. */
+export declare const withConnections: (overrides: Readonly<Record<ConnectionRef<"redis">, MemoryRedisConnection>>, options?: {
+    readonly connections?: ConnectionsConfig;
+    readonly connectAnalytics?: ConnectionRegistryOptions["connectAnalytics"];
+}) => Layer.Layer< ConnectionRegistry | RedisConnections, never, never>;
+
 /**
  * Run `body` with global time frozen at `at`, then restore — whether the body
  * returns, throws, resolves or rejects.

package/dist/index.js

@@ -2,19 +2,22 @@ import { fixtureRow as e, nextSequence as t } from "./fixtureRow.js";
 import { hydrateFixtureRows as n } from "./hydrateFixtureRows.js";
 import { defineFactory as r } from "./factory.js";
 import { MockClock as i, frozenTime as a, withFrozenTime as o } from "./mockClock.js";
-import { MockWebhooks as s } from "./mockWebhooks.js";
-import { testEventBus as c } from "./testEventBus.js";
-import { MockLLM as l } from "./mockLLM.js";
-import { makeTestContext as u, markRestInvocation as d, mockStore as f, outboxNudgesOf as p, pluginsOf as m, resetAfterCommit as h, restInvocationOf as g, rpcInterceptorFor as _, runAfterCommit as v, runInStoreTransaction as y, serviceLayerFor as b, withRpcConnection as x } from "./testContext.js";
-import { invoke as S } from "./invoke.js";
-import { describeIfAvailable as C, describeIfReachable as w, isTcpReachable as T, reportEngineVersion as E } from "./reachable.js";
-import { TEST_TENANT_ID as D, anonymous as O, apiKey as k, serviceAccount as A, system as j, user as M } from "./subject.js";
-import { makeTestApp as N } from "./testRequest.js";
-import { changeDelete as P, changeInsert as F, changeSoftDelete as I, changeUpdate as L, makeSubscribeContext as R } from "./subscribeContext.js";
-import { makeWorkflowRunner as z } from "./workflowRunner.js";
-import { makeServiceApiMock as B } from "./serviceApiMock.js";
-import { startTestApps as V } from "./testApps.js";
+import { activeKeyAlone as s, expectSealedWithActiveKeyAlone as c, registerTestFieldKeys as l, sealedValuesWithActiveKeyAlone as u } from "./fieldKeys.js";
+import { MockWebhooks as d } from "./mockWebhooks.js";
+import { testEventBus as f } from "./testEventBus.js";
+import { MockLLM as p } from "./mockLLM.js";
+import { makeTestContext as m, markRestInvocation as h, mockStore as g, outboxNudgesOf as _, pluginsOf as v, queryCacheOf as y, resetAfterCommit as b, restInvocationOf as x, rpcInterceptorFor as S, runAfterCommit as C, runInStoreTransaction as w, serviceLayerFor as T, withRpcConnection as E } from "./testContext.js";
+import { invoke as D } from "./invoke.js";
+import { describeIfAvailable as O, describeIfReachable as k, isTcpReachable as A, reportEngineVersion as j } from "./reachable.js";
+import { TEST_TENANT_ID as M, anonymous as N, apiKey as P, serviceAccount as F, system as I, user as L } from "./subject.js";
+import { makeTestApp as R } from "./testRequest.js";
+import { expectSealedWithActiveKeyAloneInSql as z } from "./fieldKeysSql.js";
+import { changeDelete as B, changeInsert as V, changeSoftDelete as H, changeUpdate as U, makeSubscribeContext as W } from "./subscribeContext.js";
+import { makeWorkflowRunner as G } from "./workflowRunner.js";
+import { makeServiceApiMock as K } from "./serviceApiMock.js";
+import { startTestApps as q } from "./testApps.js";
+import { withConnections as J } from "./withConnections.js";
 //#region src/index.ts
-var H = 1;
+var Y = 1;
 //#endregion
-export { i as MockClock, l as MockLLM, s as MockWebhooks, H as TESTING_PRESET_VERSION, D as TEST_TENANT_ID, O as anonymous, k as apiKey, P as changeDelete, F as changeInsert, I as changeSoftDelete, L as changeUpdate, r as defineFactory, C as describeIfAvailable, w as describeIfReachable, e as fixtureRow, a as frozenTime, n as hydrateFixtureRows, S as invoke, T as isTcpReachable, B as makeServiceApiMock, R as makeSubscribeContext, N as makeTestApp, u as makeTestContext, z as makeWorkflowRunner, d as markRestInvocation, f as mockStore, t as nextSequence, p as outboxNudgesOf, m as pluginsOf, E as reportEngineVersion, h as resetAfterCommit, g as restInvocationOf, _ as rpcInterceptorFor, v as runAfterCommit, y as runInStoreTransaction, A as serviceAccount, b as serviceLayerFor, V as startTestApps, j as system, c as testEventBus, M as user, o as withFrozenTime, x as withRpcConnection };
+export { i as MockClock, p as MockLLM, d as MockWebhooks, Y as TESTING_PRESET_VERSION, M as TEST_TENANT_ID, s as activeKeyAlone, N as anonymous, P as apiKey, B as changeDelete, V as changeInsert, H as changeSoftDelete, U as changeUpdate, r as defineFactory, O as describeIfAvailable, k as describeIfReachable, c as expectSealedWithActiveKeyAlone, z as expectSealedWithActiveKeyAloneInSql, e as fixtureRow, a as frozenTime, n as hydrateFixtureRows, D as invoke, A as isTcpReachable, K as makeServiceApiMock, W as makeSubscribeContext, R as makeTestApp, m as makeTestContext, G as makeWorkflowRunner, h as markRestInvocation, g as mockStore, t as nextSequence, _ as outboxNudgesOf, v as pluginsOf, y as queryCacheOf, l as registerTestFieldKeys, j as reportEngineVersion, b as resetAfterCommit, x as restInvocationOf, S as rpcInterceptorFor, C as runAfterCommit, w as runInStoreTransaction, u as sealedValuesWithActiveKeyAlone, F as serviceAccount, T as serviceLayerFor, q as startTestApps, I as system, f as testEventBus, L as user, J as withConnections, o as withFrozenTime, E as withRpcConnection };

package/dist/invoke.js

@@ -1,44 +1,82 @@
-import { resetAfterCommit as e, restInvocationOf as t, rpcInterceptorFor as n, runAfterCommit as r, runInStoreTransaction as i, serviceLayerFor as a } from "./testContext.js";
-import { Cause as o, Effect as s, Exit as c, Schema as l } from "effect";
-import { SubjectService as u, checkGuardsEffect as d } from "@voltro/protocol";
-import { makeEffectStoreLayer as f, runProvidedEffect as p, runWithDeadlockRetry as m } from "@voltro/runtime";
+import { queryCacheOf as e, resetAfterCommit as t, restInvocationOf as n, rpcInterceptorFor as r, runAfterCommit as i, runInStoreTransaction as a, serviceLayerFor as o } from "./testContext.js";
+import { Cause as s, Effect as c, Exit as l, Schema as u } from "effect";
+import { SubjectService as d, checkGuardsEffect as f } from "@voltro/protocol";
+import { cachedComputedCall as p, computedCacheKey as m, makeEffectStoreLayer as h, runProvidedEffect as g, runWithDeadlockRetry as _ } from "@voltro/runtime";
 //#region src/invoke.ts
-var h = (e, t) => {
-	let n = a(t);
-	return (n === void 0 ? e : s.provide(e, n)).pipe(s.provide(f(t.store)), s.provideService(u, t.request.subject));
-}, g = async (a, u, f, g) => {
-	let _ = a.input, v = await l.decodeUnknownPromise(_)(f), y = a.kind, b = async (e) => {
-		let t = u(v, e);
-		return s.isEffect(t) ? p(h(t, e)) : t;
-	}, x = async () => {
-		let t = a.guards;
-		if (t !== void 0 && t.length > 0) {
-			let e = await s.runPromise(d(g.request.subject, t, v));
-			if (e !== null) throw e;
+var v = (e, t) => {
+	let n = o(t);
+	return (n === void 0 ? e : c.provide(e, n)).pipe(c.provide(h(t.store)), c.provideService(d, t.request.subject));
+}, y = async (o, h, y, x) => {
+	let S = o.input, C = await u.decodeUnknownPromise(S)(y), w = o.kind, T = async (e) => {
+		let t = h(C, e);
+		return c.isEffect(t) ? g(v(t, e)) : t;
+	}, E = async () => {
+		let t = e(x), n = o.cache;
+		if (t === void 0 || n === void 0) return b;
+		let r = t.deps.policyFor(n);
+		if (r === void 0) return b;
+		let i = o, a = i.name ?? "", s = i.source === void 0 ? [] : typeof i.source == "string" ? [i.source] : [...i.source], l = await t.rowFilter(), u = m({
+			name: a,
+			codeIdentity: t.deps.codeIdentity,
+			output: i.output,
+			input: i.input,
+			decodedInput: C,
+			scope: r.scope,
+			subject: x.request.subject,
+			rowFilter: l,
+			declaredSources: s
+		});
+		return "bypass" in u ? b : g(p({
+			cache: t.deps,
+			policy: r,
+			key: u.key,
+			name: a,
+			sources: s,
+			output: i.output,
+			subject: x.request.subject,
+			rowFilter: l,
+			ctx: x,
+			execute: async (e, t) => {
+				let n = h(C, e);
+				return c.isEffect(n) ? g(v(n.pipe(c.provideService(d, t)), x)) : n;
+			},
+			onDescriptor: () => {},
+			isDescriptor: () => !1,
+			unwrap: (e) => e
+		}).pipe(c.map(({ value: e }) => e)));
+	}, D = async () => {
+		let e = o.guards;
+		if (e !== void 0 && e.length > 0) {
+			let t = await c.runPromise(f(x.request.subject, e, C));
+			if (t !== null) throw t;
 		}
-		if (y !== "mutation") return b(g);
-		let n = await m(async () => i(g, async (t) => (e(g), b(t))), { delay: () => Promise.resolve() });
-		return await r(g), n;
-	}, S = y === "mutation" || y === "query" || y === "action" ? y : void 0, C = S === void 0 ? void 0 : n(g, S);
-	if (C === void 0 || S === void 0) return await x();
-	let w = s.tryPromise({
-		try: () => x(),
+		if (w === "query") {
+			let e = await E();
+			if (e !== b) return e;
+		}
+		if (w !== "mutation") return T(x);
+		let n = await _(async () => a(x, async (e) => (t(x), T(e))), { delay: () => Promise.resolve() });
+		return await i(x), n;
+	}, O = w === "mutation" || w === "query" || w === "action" ? w : void 0, k = O === void 0 ? void 0 : r(x, O);
+	if (k === void 0 || O === void 0) return await D();
+	let A = c.tryPromise({
+		try: () => D(),
 		catch: (e) => e
-	}), T = t(g), E = C(w, {
-		tag: a.name ?? "",
-		kind: S,
-		input: v,
-		subject: g.request.subject,
-		traceId: g.request.traceId,
-		...g.request.spanId === void 0 ? {} : { spanId: g.request.spanId },
-		...T === void 0 ? {} : {
+	}), j = n(x), M = k(A, {
+		tag: o.name ?? "",
+		kind: O,
+		input: C,
+		subject: x.request.subject,
+		traceId: x.request.traceId,
+		...x.request.spanId === void 0 ? {} : { spanId: x.request.spanId },
+		...j === void 0 ? {} : {
 			surface: "rest",
-			publicApi: T.publicApi
+			publicApi: j.publicApi
 		},
-		...T?.remoteAddr === void 0 ? {} : { remoteAddr: T.remoteAddr }
-	}), D = await s.runPromiseExit(E);
-	if (c.isSuccess(D)) return D.value;
-	throw o.squash(D.cause);
-};
+		...j?.remoteAddr === void 0 ? {} : { remoteAddr: j.remoteAddr }
+	}), N = await c.runPromiseExit(M);
+	if (l.isSuccess(N)) return N.value;
+	throw s.squash(N.cause);
+}, b = Symbol("voltro:testing:not-cached");
 //#endregion
-export { g as invoke };
+export { y as invoke };