@akshatmittal/invoker 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,81 +1,100 @@
 import { beforeAll, describe, test } from "vitest";
+import { z } from "zod";
 //#region src/task.ts
 const taskDefinitionBrand = Symbol("invoker.task");
 function defineTask(definition) {
 	return {
 		...definition,
-		matrix: definition.matrix ?? {},
+		matrix: definition.matrix ?? (async () => ({})),
 		[taskDefinitionBrand]: true
 	};
 }
 //#endregion
 //#region src/json.ts
-function assertJson(value, owner, path, ancestors = /* @__PURE__ */ new Set()) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) fail(owner, path, "expected a finite number");
-		return;
-	}
-	if (typeof value !== "object") fail(owner, path, `expected JSON, received ${typeof value}`);
+const scalarSchema = z.union([
+	z.null(),
+	z.string(),
+	z.boolean(),
+	z.number()
+]);
+const nameSchema = z.string().trim().min(1);
+function snapshotJson(value, owner, path, ancestors = /* @__PURE__ */ new Set()) {
+	return cloneJson(value, owner, path, ancestors);
+}
+function cloneJson(value, owner, path, ancestors) {
+	if (scalarSchema.safeParse(value).success) return value;
+	if (!isJsonContainer(value)) fail(owner, path, "expected JSON");
 	if (ancestors.has(value)) fail(owner, path, "cyclic values are not JSON");
 	ancestors.add(value);
-	if (Array.isArray(value)) for (let index = 0; index < value.length; index += 1) {
-		if (!(index in value)) fail(owner, `${path}[${index}]`, "sparse arrays are not JSON");
-		assertJson(value[index], owner, `${path}[${index}]`, ancestors);
-	}
-	else {
+	if (Array.isArray(value)) {
+		const snapshot = [];
+		for (let index = 0; index < value.length; index += 1) {
+			if (!(index in value)) fail(owner, `${path}[${index}]`, "sparse arrays are not JSON");
+			snapshot.push(cloneJson(value[index], owner, `${path}[${index}]`, ancestors));
+		}
+		ancestors.delete(value);
+		return snapshot;
+	} else {
 		assertPlainObject(value, owner, path);
 		if (Object.getOwnPropertySymbols(value).length > 0) fail(owner, path, "JSON objects cannot have symbol keys");
-		for (const [key, child] of Object.entries(value)) assertJson(child, owner, `${path}.${key}`, ancestors);
+		const snapshot = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneJson(child, owner, `${path}.${key}`, ancestors)]));
+		ancestors.delete(value);
+		return snapshot;
 	}
-	ancestors.delete(value);
 }
 function assertPlainObject(value, owner, path) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) fail(owner, path, "expected a plain object");
+	if (Object(value) !== value || Array.isArray(value)) fail(owner, path, "expected a plain object");
 	const prototype = Object.getPrototypeOf(value);
 	if (prototype !== Object.prototype && prototype !== null) fail(owner, path, "expected a plain object");
 }
 function assertName(value, owner, path) {
-	if (typeof value !== "string" || value.trim() === "") fail(owner, path, "expected a non-empty string");
+	if (!nameSchema.safeParse(value).success) fail(owner, path, "expected a non-empty string");
 }
 function assertOnlyKeys(value, allowed, owner) {
 	for (const key of Object.keys(value)) if (!allowed.includes(key)) fail(owner, `.${key}`, "unknown property");
 }
 function canonicalJson(value) {
 	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-	if (value !== null && typeof value === "object") {
-		const object = value;
-		return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
-	}
+	if (isJsonObject(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
 	return JSON.stringify(value);
 }
 function fail(owner, path, message) {
 	throw new TypeError(`${owner}${path}: ${message}`);
 }
+function isJsonContainer(value) {
+	return value !== null && Object(value) === value;
+}
+function isJsonObject(value) {
+	return isJsonContainer(value) && !Array.isArray(value);
+}
 //#endregion
 //#region src/matrix.ts
+const axisSchema = z.string();
 function expandMatrix(matrix, owner) {
-	if (matrix === void 0) return [{}];
 	assertPlainObject(matrix, owner, ".matrix");
 	let cases = [{}];
-	for (const [axis, values] of Object.entries(matrix)) {
+	for (const candidate of Reflect.ownKeys(matrix)) {
+		const parsed = axisSchema.safeParse(candidate);
+		if (!parsed.success || !Object.prototype.propertyIsEnumerable.call(matrix, candidate)) fail(owner, ".matrix", "axis names must be enumerable strings");
+		const axis = parsed.data;
 		if (axis.trim() === "") fail(owner, ".matrix", "axis names must not be empty");
+		const index = Number(axis);
+		if (Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === axis) fail(owner, `.matrix.${axis}`, "array-index axis names cannot preserve insertion order");
+		const values = matrix[axis];
 		if (!Array.isArray(values)) fail(owner, `.matrix.${axis}`, "expected an array");
 		if (values.length === 0) fail(owner, `.matrix.${axis}`, "expected at least one value");
-		values.forEach((value, index) => {
-			assertJson(value, owner, `.matrix.${axis}[${index}]`);
-		});
-		cases = cases.flatMap((coordinates) => values.map((value) => ({
+		const snapshots = values.map((value, index) => snapshotJson(value, owner, `.matrix.${axis}[${index}]`));
+		const axisValues = /* @__PURE__ */ new Set();
+		for (const [index, value] of snapshots.entries()) {
+			const key = canonicalJson(value);
+			if (axisValues.has(key)) fail(owner, `.matrix.${axis}[${index}]`, `duplicate axis value ${JSON.stringify(value)}`);
+			axisValues.add(key);
+		}
+		cases = cases.flatMap((coordinates) => snapshots.map((value) => ({
 			...coordinates,
 			[axis]: value
 		})));
 	}
-	const coordinates = /* @__PURE__ */ new Set();
-	for (const value of cases) {
-		const key = canonicalJson(value);
-		if (coordinates.has(key)) fail(owner, ".matrix", `duplicate coordinate ${JSON.stringify(value)}`);
-		coordinates.add(key);
-	}
 	return cases;
 }
 function caseName(matrix, index) {
@@ -85,9 +104,9 @@ function caseName(matrix, index) {
 //#endregion
 //#region src/workflow.ts
 function defineWorkflow(definition) {
-	const workflow = prepareWorkflow(definition);
-	describe(workflow.name, { concurrent: false }, () => {
-		for (const prepared of workflow.tasks) describe(prepared.task.name, { concurrent: false }, () => {
+	describe(definition.name, { concurrent: false }, async () => {
+		const tasks = await prepareWorkflow(definition);
+		for (const prepared of tasks) describe(prepared.task.name, { concurrent: false }, () => {
 			let setup;
 			const setupTask = prepared.task.setup;
 			if (setupTask) beforeAll(async () => {
@@ -109,33 +128,30 @@ function defineWorkflow(definition) {
 						setup,
 						vitest
 					});
-					assertJson(output, `Task ${JSON.stringify(prepared.task.name)}`, ".output");
-					meta.invoker.output = output;
+					meta.invoker.output = snapshotJson(output, `Task ${JSON.stringify(prepared.task.name)}`, ".output");
 				});
 			}
 		});
 	});
 }
-function prepareWorkflow(definition) {
+async function prepareWorkflow(definition) {
 	assertPlainObject(definition, "Workflow", "");
 	assertOnlyKeys(definition, [
 		"name",
 		"metadata",
 		"tasks"
 	], "Workflow");
-	assertName(definition.name, "Workflow", ".name");
-	const metadata = definition.metadata;
-	if (metadata !== void 0) {
-		assertJson(metadata, `Workflow ${JSON.stringify(definition.name)}`, ".metadata");
-		assertPlainObject(metadata, `Workflow ${JSON.stringify(definition.name)}`, ".metadata");
-	}
-	if (!Array.isArray(definition.tasks) || definition.tasks.length === 0) fail("Workflow", ".tasks", "expected a non-empty Task tuple");
+	const { name, metadata: workflowMetadata, tasks: taskDefinitions } = definition;
+	assertName(name, "Workflow", ".name");
+	const metadata = workflowMetadata === void 0 ? void 0 : snapshotJson(workflowMetadata, `Workflow ${JSON.stringify(name)}`, ".metadata");
+	if (metadata !== void 0) assertPlainObject(metadata, `Workflow ${JSON.stringify(name)}`, ".metadata");
+	if (!Array.isArray(taskDefinitions) || taskDefinitions.length === 0) fail("Workflow", ".tasks", "expected a non-empty Task tuple");
 	const names = /* @__PURE__ */ new Set();
-	const tasks = definition.tasks.map((value, index) => {
-		const owner = `Workflow ${JSON.stringify(definition.name)} Task ${index + 1}`;
+	const tasks = taskDefinitions.map((value, index) => {
+		const owner = `Workflow ${JSON.stringify(name)} Task ${index + 1}`;
 		assertPlainObject(value, owner, "");
+		if (value[taskDefinitionBrand] !== true) fail(owner, "", "expected a Task created by defineTask");
 		const task = value;
-		if (task[taskDefinitionBrand] !== true) fail(owner, "", "expected a Task created by defineTask");
 		assertOnlyKeys(task, [
 			"name",
 			"matrix",
@@ -143,14 +159,19 @@ function prepareWorkflow(definition) {
 			"run",
 			"teardown"
 		], owner);
-		assertName(task.name, owner, ".name");
-		if (names.has(task.name)) fail(owner, ".name", `duplicate Task name ${JSON.stringify(task.name)}`);
-		names.add(task.name);
-		if (typeof task.run !== "function") fail(owner, ".run", "expected a function");
-		if (task.setup !== void 0 && typeof task.setup !== "function") fail(owner, ".setup", "expected a function");
-		if (task.teardown !== void 0 && typeof task.teardown !== "function") fail(owner, ".teardown", "expected a function");
-		if (task.teardown && !task.setup) fail(owner, ".teardown", "requires setup");
-		const cases = expandMatrix(task.matrix, `Task ${JSON.stringify(task.name)}`);
+		const taskSnapshot = { ...task };
+		assertName(taskSnapshot.name, owner, ".name");
+		if (names.has(taskSnapshot.name)) fail(owner, ".name", `duplicate Task name ${JSON.stringify(taskSnapshot.name)}`);
+		names.add(taskSnapshot.name);
+		if (!z.function().safeParse(taskSnapshot.run).success) fail(owner, ".run", "expected a function");
+		if (!z.function().safeParse(taskSnapshot.matrix).success) fail(owner, ".matrix", "expected a function");
+		if (taskSnapshot.setup !== void 0 && !z.function().safeParse(taskSnapshot.setup).success) fail(owner, ".setup", "expected a function");
+		if (taskSnapshot.teardown !== void 0 && !z.function().safeParse(taskSnapshot.teardown).success) fail(owner, ".teardown", "expected a function");
+		if (taskSnapshot.teardown && !taskSnapshot.setup) fail(owner, ".teardown", "requires setup");
+		return taskSnapshot;
+	});
+	return await Promise.all(tasks.map(async (task) => {
+		const cases = expandMatrix(await task.matrix(), `Task ${JSON.stringify(task.name)}`);
 		return {
 			task,
 			cases,
@@ -164,11 +185,7 @@ function prepareWorkflow(definition) {
 				metadata
 			})
 		};
-	});
-	return {
-		name: definition.name,
-		tasks
-	};
+	}));
 }
 //#endregion
 export { defineTask, defineWorkflow };

package/dist/slack.d.mts

@@ -0,0 +1,10 @@
+import { Reporter } from "vitest/reporters";
+//#region src/slack/reporter.d.ts
+type SlackReporterOptions = {
+  readonly token: string;
+  readonly channel: string;
+  readonly runUrl?: string;
+};
+declare function slackReporter(options: SlackReporterOptions): Reporter;
+//#endregion
+export { type SlackReporterOptions, slackReporter };