@tailor-platform/sdk 2.2.0 → 2.4.0

package/dist/vitest/index.mjs

@@ -1,5 +1,5 @@
 import { i as getRegisteredJob, t as START_DEFAULT } from "../registry-BIGVUrMB.mjs";
-import { a as writeWorkflowTestEnv, n as clearWorkflowTestEnv, r as readWorkflowTestEnv, t as buildJobContext } from "../test-env-key-D7UkZp99.mjs";
+import { a as getWaitPointKey, c as readWorkflowTestEnv, i as getWaitPointInvoker, o as buildJobContext, s as clearWorkflowTestEnv, u as writeWorkflowTestEnv } from "../wait-point-invoker-__oE88_P.mjs";
 import { t as assertDefined } from "../assert-DBxo8jPo.mjs";
 import { n as isNodeBuiltinImport, t as getNodeBuiltinMessage } from "../node-builtins-CmaL2Cbq.mjs";
 import { t as platformSerialize } from "../platform-serialize-RoRtBS0v.mjs";
@@ -253,7 +253,8 @@ function createEnvironmentPlugin(options) {
 			}
 			delete process.env.__TAILOR_RUNTIME_CONFIG;
 			if (options?.config && usesTailorRuntime) {
-				const configAbsPath = resolve(config.root ?? process.cwd(), options.config);
+				const configRoot = config.root ?? process.cwd();
+				const configAbsPath = resolve(configRoot, options.config);
 				process.env.__TAILOR_RUNTIME_CONFIG = configAbsPath;
 			}
 			if (testConfig && typeof testConfig.setupFiles === "string") testConfig.setupFiles = [testConfig.setupFiles];
@@ -521,7 +522,7 @@ function mockFile(options = {}) {
 	function allMocks() {
 		return FILE_METHODS.map((method) => mocks[method]);
 	}
-	return withDispose({
+	const facade = {
 		...mocks,
 		setResolver(value) {
 			resolver = value;
@@ -555,7 +556,8 @@ function mockFile(options = {}) {
 			resolver = () => null;
 			for (const mock of allMocks()) mock.mockReset();
 		}
-	}, () => {
+	};
+	return withDispose(facade, () => {
 		root.file = prev;
 	});
 }
@@ -1177,6 +1179,8 @@ function mockTailordb(options = {}) {
 
 //#endregion
 //#region src/vitest/mocks/workflow.ts
+const baseInvokerWait = /* @__PURE__ */ new WeakMap();
+const baseInvokerResolve = /* @__PURE__ */ new WeakMap();
 const originalProcedures = /* @__PURE__ */ new WeakMap();
 function replaceProcedure(target, key, current) {
 	const original = originalProcedures.get(current) ?? current;
@@ -1226,7 +1230,56 @@ function mockWorkflow() {
 	const jobSpies = /* @__PURE__ */ new Map();
 	const workflowSpies = /* @__PURE__ */ new Map();
 	const waitPointMocks = /* @__PURE__ */ new Map();
+	const keyDispatchers = /* @__PURE__ */ new Map();
 	const scopedMocks = /* @__PURE__ */ new Set();
+	const installKeyDispatcher = (definition) => {
+		const cached = keyDispatchers.get(definition);
+		if (cached) return cached;
+		const invoker = getWaitPointInvoker(definition);
+		if (!invoker) throw new Error("waitPointWith expects a wait point definition created by createWaitPoint or createWaitPoints.");
+		const record = invoker;
+		const prevWait = invoker.wait;
+		const prevResolve = invoker.resolve;
+		const baseWait = baseInvokerWait.get(prevWait) ?? prevWait;
+		const baseResolve = baseInvokerResolve.get(prevResolve) ?? prevResolve;
+		const slot = {
+			perKey: /* @__PURE__ */ new Map(),
+			originalWait: (key, payload) => baseWait.call(invoker, key, payload),
+			originalResolve: (key, executionId, callback) => baseResolve.call(invoker, key, executionId, callback)
+		};
+		const dispatchWait = (key, payload) => {
+			const mock = slot.perKey.get(key);
+			if (!mock) return slot.originalWait(key, payload);
+			return payload === void 0 ? mock.wait() : mock.wait(payload);
+		};
+		const dispatchResolve = async (key, executionId, callback) => {
+			const mock = slot.perKey.get(key);
+			if (!mock) return slot.originalResolve(key, executionId, callback);
+			await mock.resolve(executionId, callback);
+		};
+		baseInvokerWait.set(dispatchWait, baseWait);
+		baseInvokerResolve.set(dispatchResolve, baseResolve);
+		record.wait = dispatchWait;
+		record.resolve = dispatchResolve;
+		const eachSpy = (fn) => {
+			for (const mock of slot.perKey.values()) {
+				const pair = mock;
+				fn(pair.wait);
+				fn(pair.resolve);
+			}
+		};
+		scopedMocks.add({
+			mockClear: () => eachSpy((spy) => spy.mockClear()),
+			mockReset: () => eachSpy((spy) => spy.mockReset()),
+			restore: () => {
+				record.wait = prevWait;
+				record.resolve = prevResolve;
+				keyDispatchers.delete(definition);
+			}
+		});
+		keyDispatchers.set(definition, slot);
+		return slot;
+	};
 	const defaultExecJob = (jobName, _args, _options) => {
 		throw new Error(`No workflow job mock for "${jobName}". Call mockWorkflow().setJobHandler(...) or enqueueResult(...), or use runWorkflowLocally() for local workflow execution.`);
 	};
@@ -1317,7 +1370,8 @@ function mockWorkflow() {
 				*/
 				setResolvePayload(payload) {
 					resolveSpy.mockImplementation(async (_executionId, callback) => {
-						platformSerialize(await callback(platformSerialize(payload)));
+						const result = await callback(platformSerialize(payload));
+						platformSerialize(result);
 					});
 				}
 			};
@@ -1325,6 +1379,38 @@ function mockWorkflow() {
 			return waitPointMock;
 		},
 		/**
+		* Get stable, typed mocks for one param binding of a parameterized wait point.
+		* Calls made with other bindings fall through to the platform mock.
+		* @param definition - Parameterized wait point definition to mock
+		* @param params - Param binding to intercept, as passed to `.with()`
+		* @returns Typed wait point mock control object
+		*/
+		waitPointWith(definition, params) {
+			const key = getWaitPointKey(definition.with(params));
+			if (key === void 0) throw new Error("waitPointWith expects a wait point declared with $params. Use waitPoint() for a wait point with a fixed key.");
+			const slot = installKeyDispatcher(definition);
+			const existing = slot.perKey.get(key);
+			if (existing) return existing;
+			const waitSpy = vi.fn((payload) => Promise.resolve(slot.originalWait(key, payload)));
+			const resolveSpy = vi.fn((executionId, callback) => slot.originalResolve(key, executionId, callback));
+			const waitPointMock = {
+				wait: waitSpy,
+				resolve: resolveSpy,
+				/**
+				* Invoke the next and subsequent resolve callbacks with a wait payload.
+				* @param payload - Payload originally supplied to the wait point
+				*/
+				setResolvePayload(payload) {
+					resolveSpy.mockImplementation(async (_executionId, callback) => {
+						const result = await callback(platformSerialize(payload));
+						platformSerialize(result);
+					});
+				}
+			};
+			slot.perKey.set(key, waitPointMock);
+			return waitPointMock;
+		},
+		/**
 		* Set a fallback job handler. Called when the enqueue queue is empty.
 		* @param handler - Function returning a result for a job name, args, and options
 		*/
@@ -1477,8 +1563,10 @@ async function runWorkflowLocally(workflow, args, options) {
 	} finally {
 		if (previousTailor) root.tailor = previousTailor;
 		else delete root.tailor;
-		if (options?.env !== void 0) if (hasPreviousEnv) writeWorkflowTestEnv(previousEnv);
-		else clearWorkflowTestEnv();
+		if (options?.env !== void 0) {
+			if (hasPreviousEnv) writeWorkflowTestEnv(previousEnv);
+			else clearWorkflowTestEnv();
+		}
 	}
 }
 function createLocalJobRunner() {