@tailor-platform/sdk 2.0.0-next.9 → 2.0.0

package/dist/vitest/index.mjs

@@ -1,52 +1,23 @@
-import { i as getRegisteredJob, t as START_DEFAULT } from "../registry-i7EdJ-D5.mjs";
+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 { 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";
 import { i as withDispose, n as tailorRoot, r as tailordbRoot, t as mockSecretmanager } from "../secretmanager-IY4UvinW.mjs";
-import { builtinModules } from "node:module";
 import { isEqual } from "es-toolkit";
 import { fileURLToPath } from "node:url";
-import { dirname, isAbsolute, matchesGlob, relative, resolve } from "node:path";
 import { ColumnNode, InsertQueryNode, Kysely, PostgresAdapter, PostgresIntrospector, PostgresQueryCompiler, PrimitiveValueListNode, ReferenceNode, UpdateQueryNode, ValueListNode, ValueNode, ValuesNode } from "kysely";
+import { dirname, isAbsolute, matchesGlob, relative, resolve } from "node:path";
 import { vi } from "vitest";
 
 //#region src/vitest/blocked-modules.ts
 /**
-* Blocked Node.js built-in modules and their Web Standard API alternatives.
-*
-* The Tailor Platform runtime only provides Web Standard APIs.
-* These Node.js modules are not available and should be replaced with
-* the suggested alternatives.
-*/
-const SUGGESTIONS = {
-	crypto: "Use the Web Crypto API (globalThis.crypto) instead.",
-	buffer: "Use Uint8Array or ArrayBuffer instead.",
-	fs: "File system access is not available in the Tailor Platform runtime.",
-	"fs/promises": "File system access is not available in the Tailor Platform runtime.",
-	path: "Use URL or URLPattern for path manipulation.",
-	http: "Use the Fetch API (globalThis.fetch) for HTTP requests instead.",
-	https: "Use the Fetch API (globalThis.fetch) for HTTPS requests instead.",
-	url: "Use the URL and URLSearchParams Web APIs instead.",
-	util: "Use Web Standard APIs instead.",
-	stream: "Use Web Streams API (ReadableStream, WritableStream, TransformStream) instead.",
-	"stream/web": "Use Web Streams API (ReadableStream, WritableStream, TransformStream) instead.",
-	events: "Use EventTarget instead.",
-	zlib: "Use CompressionStream and DecompressionStream Web APIs instead.",
-	querystring: "Use URLSearchParams instead.",
-	string_decoder: "Use TextDecoder instead."
-};
-const BLOCKED_MODULES = /* @__PURE__ */ new Set();
-for (const mod of builtinModules) {
-	BLOCKED_MODULES.add(mod);
-	BLOCKED_MODULES.add(`node:${mod}`);
-}
-/**
 * Check if a module specifier is a blocked Node.js built-in.
 * @param specifier - Module specifier to check (e.g. "node:crypto", "fs")
 * @returns Whether the specifier is blocked
 */
 function isBlockedModule(specifier) {
-	return BLOCKED_MODULES.has(specifier);
+	return isNodeBuiltinImport(specifier);
 }
 /**
 * Get the error message for a blocked module import.
@@ -54,10 +25,7 @@ function isBlockedModule(specifier) {
 * @returns Error message with optional suggestion for the Web Standard API alternative
 */
 function getBlockedMessage(specifier) {
-	const bare = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-	const suggestion = SUGGESTIONS[bare];
-	const base = `"${specifier}" is not available in the Tailor Platform runtime.`;
-	return suggestion ? `${base} ${suggestion}` : base;
+	return getNodeBuiltinMessage(specifier);
 }
 
 //#endregion
@@ -901,6 +869,86 @@ function mockIdp(options = {}) {
 	});
 }
 
+//#endregion
+//#region src/vitest/mocks/logger.ts
+/**
+* Acquire a disposable mock for `tailor.logger`. Each method is a `vi.fn`, so
+* calls can be asserted directly; `calls` returns the `debug`/`info`/`warn`/
+* `error` entries in the order they were emitted. Restored on dispose.
+* @param _options - Reserved for future initial fixtures
+* @returns Disposable logger mock control object
+* @example
+* ```typescript
+* import { mockLogger } from "@tailor-platform/sdk/vitest";
+*
+* test("logs the processed order", () => {
+*   using logger = mockLogger();
+*   // …run code that calls tailor.logger.info…
+*   expect(logger.info).toHaveBeenCalledWith("order processed", { orderId: "o-1" });
+* });
+* ```
+*/
+function mockLogger(_options = {}) {
+	const root = tailorRoot();
+	const prev = root.logger;
+	const debug = vi.fn((_message, _attributes) => {});
+	const info = vi.fn((_message, _attributes) => {});
+	const warn = vi.fn((_message, _attributes) => {});
+	const error = vi.fn((_message, _attributes) => {});
+	const setAttributes = vi.fn((_attributes) => {});
+	root.logger = {
+		debug,
+		info,
+		warn,
+		error,
+		setAttributes
+	};
+	const severityFns = {
+		debug,
+		info,
+		warn,
+		error
+	};
+	return withDispose({
+		/** The `debug` `vi.fn`. */
+		debug,
+		/** The `info` `vi.fn`. */
+		info,
+		/** The `warn` `vi.fn`. */
+		warn,
+		/** The `error` `vi.fn`. */
+		error,
+		/** The `setAttributes` `vi.fn`. */
+		setAttributes,
+		get calls() {
+			return Object.entries(severityFns).flatMap(([severity, fn]) => fn.mock.calls.map((args, i) => ({
+				order: fn.mock.invocationCallOrder[i] ?? 0,
+				call: {
+					severity,
+					message: args[0],
+					attributes: args[1]
+				}
+			}))).toSorted((a, b) => a.order - b.order).map((e) => e.call);
+		},
+		clear() {
+			debug.mockClear();
+			info.mockClear();
+			warn.mockClear();
+			error.mockClear();
+			setAttributes.mockClear();
+		},
+		reset() {
+			debug.mockReset();
+			info.mockReset();
+			warn.mockReset();
+			error.mockReset();
+			setAttributes.mockReset();
+		}
+	}, () => {
+		root.logger = prev;
+	});
+}
+
 //#endregion
 //#region src/vitest/mocks/tailordb.ts
 function testRegex(regex, value) {
@@ -1156,6 +1204,7 @@ function replaceStart(definition) {
 /**
 * Acquire a disposable mock for workflow operations (`tailor.workflow`).
 * Restored on dispose.
+
 * @returns Disposable workflow mock control object
 * @example
 * ```typescript
@@ -1178,26 +1227,26 @@ function mockWorkflow() {
 	const workflowSpies = /* @__PURE__ */ new Map();
 	const waitPointMocks = /* @__PURE__ */ new Map();
 	const scopedMocks = /* @__PURE__ */ new Set();
-	const defaultStartJob = (jobName, _args, _options) => {
+	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.`);
 	};
 	const defaultStartWorkflow = async (_workflowName, _args, _options) => {
 		return START_DEFAULT;
 	};
 	const defaultResumeWorkflowExecution = async (executionId) => executionId;
-	const startJobFunction = vi.fn(defaultStartJob);
+	const execJobFunction = vi.fn(defaultExecJob);
 	const startWorkflow = vi.fn(defaultStartWorkflow);
 	const resumeWorkflowExecution = vi.fn(defaultResumeWorkflowExecution);
 	const wait = vi.fn((_key, _payload) => null);
 	const resolve = vi.fn(async (_executionId, _key, _callback) => {});
 	const jobFunctionShim = (...call) => {
-		const out = call.length >= 3 ? startJobFunction(call[0], platformSerialize(call[1]), call[2]) : startJobFunction(call[0], platformSerialize(call[1]));
+		const out = call.length >= 3 ? execJobFunction(call[0], platformSerialize(call[1]), call[2]) : execJobFunction(call[0], platformSerialize(call[1]));
 		return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
 	};
 	const workflowShim = (...call) => call.length >= 3 ? startWorkflow(call[0], platformSerialize(call[1]), call[2]) : startWorkflow(call[0], platformSerialize(call[1]));
 	const resumeShim = (executionId) => resumeWorkflowExecution(executionId);
 	root.workflow = {
-		startJobFunction: jobFunctionShim,
+		execJobFunction: jobFunctionShim,
 		startWorkflow: workflowShim,
 		resumeWorkflowExecution: resumeShim,
 		wait: (key, payload) => wait(key, platformSerialize(payload)),
@@ -1207,8 +1256,8 @@ function mockWorkflow() {
 		})
 	};
 	return withDispose({
-		/** The `startJobFunction` `vi.fn`. */
-		startJobFunction,
+		/** The `execJobFunction` `vi.fn`. */
+		execJobFunction,
 		/** The `startWorkflow` `vi.fn`. */
 		startWorkflow,
 		/** The `resumeWorkflowExecution` `vi.fn`. */
@@ -1280,29 +1329,29 @@ function mockWorkflow() {
 		* @param handler - Function returning a result for a job name, args, and options
 		*/
 		setJobHandler(handler) {
-			startJobFunction.mockImplementation((name, args, options) => handler(name, args, options));
+			execJobFunction.mockImplementation((name, args, options) => handler(name, args, options));
 		},
 		/**
-		* Enqueue a single result for the next `startJobFunction` call (FIFO;
+		* Enqueue a single result for the next `execJobFunction` call (FIFO;
 		* takes priority over `setJobHandler`).
 		* @param result - Result to return from the next call
 		*/
 		enqueueResult(result) {
-			startJobFunction.mockImplementationOnce(() => result);
+			execJobFunction.mockImplementationOnce(() => result);
 		},
 		/**
-		* Enqueue results for multiple subsequent `startJobFunction` calls (FIFO).
+		* Enqueue results for multiple subsequent `execJobFunction` calls (FIFO).
 		* @param results - Results to enqueue, one per upcoming call
 		*/
 		enqueueResults(...results) {
-			for (const result of results) startJobFunction.mockImplementationOnce(() => result);
+			for (const result of results) execJobFunction.mockImplementationOnce(() => result);
 		},
 		/**
-		* All jobs started via `startJobFunction`, in order.
+		* All jobs executed via `execJobFunction`, in order.
 		* @returns Started jobs array
 		*/
 		get startedJobs() {
-			return startJobFunction.mock.calls.map(([jobName, args, options]) => ({
+			return execJobFunction.mock.calls.map(([jobName, args, options]) => ({
 				jobName,
 				args,
 				...options !== void 0 && { options }
@@ -1372,7 +1421,7 @@ function mockWorkflow() {
 		},
 		/** Clear recorded calls while preserving configured responses. */
 		clear() {
-			startJobFunction.mockClear();
+			execJobFunction.mockClear();
 			startWorkflow.mockClear();
 			resumeWorkflowExecution.mockClear();
 			wait.mockClear();
@@ -1381,8 +1430,8 @@ function mockWorkflow() {
 		},
 		/** Reset all workflow responses and recorded calls (keeps the mock installed). */
 		reset() {
-			startJobFunction.mockReset();
-			startJobFunction.mockImplementation(defaultStartJob);
+			execJobFunction.mockReset();
+			execJobFunction.mockImplementation(defaultExecJob);
 			startWorkflow.mockReset();
 			startWorkflow.mockImplementation(defaultStartWorkflow);
 			resumeWorkflowExecution.mockReset();
@@ -1421,7 +1470,7 @@ async function runWorkflowLocally(workflow, args, options) {
 	if (options?.env !== void 0) writeWorkflowTestEnv({ ...options.env });
 	root.tailor = {
 		...previousTailor,
-		workflow: createLocalWorkflowRuntime(previousTailor?.workflow, runner.startJobFunction)
+		workflow: createLocalWorkflowRuntime(previousTailor?.workflow, runner.execJobFunction)
 	};
 	try {
 		return await runner.runJob(workflow.mainJob.name, args);
@@ -1434,7 +1483,7 @@ async function runWorkflowLocally(workflow, args, options) {
 }
 function createLocalJobRunner() {
 	let activeExecution;
-	const startJobFunction = (jobName, args) => {
+	const execJobFunction = (jobName, args) => {
 		if (!activeExecution) throw new Error(`Cannot start workflow job "${jobName}" outside runWorkflowLocally() job execution.`);
 		if (activeExecution.pending) throw activeExecution.pending;
 		const serializedArgs = platformSerialize(args);
@@ -1483,7 +1532,7 @@ function createLocalJobRunner() {
 	};
 	return {
 		runJob,
-		startJobFunction
+		execJobFunction
 	};
 }
 async function settlePendingStart(records, pending, runJob) {
@@ -1507,7 +1556,7 @@ function assertSameStart(record, jobName, args) {
 	if (record.jobName === jobName && JSON.stringify(record.args) === JSON.stringify(args)) return;
 	throw new Error(`Workflow job start sequence changed while replaying. Expected ${record.jobName}(${JSON.stringify(record.args)}), but got ${jobName}(${JSON.stringify(args)}).`);
 }
-function createLocalWorkflowRuntime(previous, startJobFunction) {
+function createLocalWorkflowRuntime(previous, execJobFunction) {
 	const startWorkflow = async (name, args, options) => {
 		if (previous) return await previous.startWorkflow(name, args, options);
 		platformSerialize(args);
@@ -1518,7 +1567,7 @@ function createLocalWorkflowRuntime(previous, startJobFunction) {
 		return executionId;
 	};
 	return {
-		startJobFunction,
+		execJobFunction,
 		startWorkflow,
 		resumeWorkflowExecution,
 		wait: (key, payload) => {
@@ -1725,7 +1774,8 @@ function createKyselyMock() {
 *
 * 3. **Platform API mocks** (environment) — All platform APIs are auto-injected with
 *    control objects: `mockTailordb`, `mockWorkflow`, `mockSecretmanager`,
-*    `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`, `mockAigateway`. Each
+*    `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`, `mockAigateway`,
+*    `mockLogger`. Each
 *    provides response configuration, call recording, and reset.
 *
 * 4. **Environment resolution** — Rewrites `environment: "tailor-runtime"` to the
@@ -1735,8 +1785,8 @@ function createKyselyMock() {
 *
 * - **`process`** and **`require`** are NOT removed or blocked. Vitest's internal
 *   runner depends on them. On the real Tailor Platform runtime, they do not exist.
-* - **Dynamic `import()`** of bundled files (via `createImportMain()`) bypasses
-*   the transform hook since those files are loaded through Node.js native loader.
+* - **Dynamic `import()`** of bundled files bypasses the transform hook since
+*   those files are loaded through Node.js native loader.
 * ## Options
 *
 * - **`config`** — Path to `tailor.config.ts`. Loads `defineSecretManager()` values
@@ -1763,5 +1813,5 @@ function tailorRuntime(options) {
 }
 
 //#endregion
-export { createKyselyMock, mockAigateway, mockAuthconnection, mockFile, mockIconv, mockIdp, mockSecretmanager, mockTailordb, mockWorkflow, runWorkflowLocally, tailorRuntime };
+export { createKyselyMock, mockAigateway, mockAuthconnection, mockFile, mockIconv, mockIdp, mockLogger, mockSecretmanager, mockTailordb, mockWorkflow, runWorkflowLocally, tailorRuntime };
 //# sourceMappingURL=index.mjs.map