@pogodisco/task-runner 0.0.1 → 0.0.2

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./main";

package/dist/main.d.ts

@@ -0,0 +1,44 @@
+export type LogEvent = "start" | "finish" | "data" | "deferred" | "skipped" | "background" | "parallel" | "success" | "fail";
+export type TaskLogger = (event: LogEvent, key: string, meta?: any) => void;
+export interface SchemaOptions {
+    log?: TaskLogger;
+}
+export type TaskState = "pending" | "skipped" | "failed" | "success";
+export type TaskDefinition<F extends (...args: any) => any, T extends TaskMap, I extends Record<string, any>> = {
+    fn: F;
+    dependencies?: string[];
+    abort?: boolean;
+    bg?: boolean;
+    runIf?: ((results: TaskResultsData<T, I>) => boolean | Promise<boolean>)[];
+    argMap?: (results: TaskResultsData<T, I>) => Parameters<F>[0];
+};
+export type TaskMap = Record<string, TaskDefinition<any, any, any>>;
+type SuccessData<T> = T extends {
+    ok: true;
+    data: infer D;
+} ? D : never;
+export type TaskResultsData<T extends TaskMap, I> = {
+    _init: I;
+} & {
+    [K in keyof T]: TDResultData<T[K]>;
+};
+type TDResultData<TD extends TaskDefinition<any, any, any>> = TD extends TaskDefinition<infer F, any, any> ? SuccessData<Awaited<ReturnType<F>>> : never;
+export type TasksFromFns<T extends Record<string, (...args: any) => any>> = {
+    [K in keyof T]: TaskDefinition<T[K], any, any>;
+};
+export type TaskSchemaWithContracts<T extends TaskMap, I extends Record<string, any>, O> = {
+    [K in keyof T]: T[K] extends TaskDefinition<infer F, any, any> ? TaskDefinition<F, T, I> : never;
+} & {
+    _init?: I;
+    _output: (results: TaskResultsData<T, I>) => O;
+};
+export declare function defineSchema<T extends TaskMap, I extends Record<string, any>, O>(schema: {
+    [K in keyof T]: T[K] extends TaskDefinition<infer F, any, any> ? TaskDefinition<F, T, I> : never;
+} & {
+    _output: (results: TaskResultsData<T, I>) => O;
+}): TaskSchemaWithContracts<T, I, O>;
+export declare const runSchema: <T extends TaskMap, I extends Record<string, any>, O>(schema: TaskSchemaWithContracts<T, I, O>, initArgs: I, options?: SchemaOptions | undefined) => Promise<import("@pogodisco/response").TResponse<{
+    _output: O;
+    _status: Record<keyof T, TaskState>;
+}>>;
+export {};

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"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"}

package/dist/main.js

@@ -0,0 +1,154 @@
+import { isFailure, isSuccess, withResponse, } from "@pogodisco/response";
+// --- defineSchema ---
+export function defineSchema(schema) {
+    preflightCheck(schema);
+    return schema;
+}
+// --- preflight check ---
+function preflightCheck(schema) {
+    const keys = new Set();
+    for (const key in schema) {
+        if (key === "_output" || key === "_init")
+            continue;
+        if (keys.has(key))
+            throw new Error(`Duplicate task key: ${key}`);
+        keys.add(key);
+        const task = schema[key];
+        if (!task)
+            continue;
+        if (task.abort === undefined)
+            task.abort = true;
+        if (task.bg === undefined)
+            task.bg = false;
+        if (task.runIf === undefined)
+            task.runIf = [];
+    }
+    const visited = new Set();
+    const stack = new Set();
+    const visit = (taskKey) => {
+        if (taskKey === "_output" || taskKey === "_init")
+            return;
+        if (stack.has(taskKey))
+            throw new Error(`Circular dependency: ${[...stack, taskKey].join(" -> ")}`);
+        if (visited.has(taskKey))
+            return;
+        stack.add(taskKey);
+        const task = schema[taskKey];
+        const deps = task?.dependencies ?? [];
+        for (const dep of deps) {
+            if (!(dep in schema))
+                throw new Error(`Task "${taskKey}" depends on unknown "${dep}"`);
+            visit(dep);
+        }
+        stack.delete(taskKey);
+        visited.add(taskKey);
+    };
+    for (const key of Object.keys(schema))
+        visit(key);
+}
+// --- mark dependents skipped ---
+function markDependentsSkipped(schema, status, key) {
+    for (const k of Object.keys(schema)) {
+        const task = schema[k];
+        if ((task.dependencies ?? []).includes(key) &&
+            status[k] === "pending") {
+            status[k] = "skipped";
+            markDependentsSkipped(schema, status, k);
+        }
+    }
+}
+// --- runSchema, storing **only success data** ---
+export const runSchema = withResponse(async (schema, initArgs, options) => {
+    try {
+        const logger = options?.log;
+        const localSchema = {
+            ...schema,
+            _init: { fn: (x) => x, argMap: () => initArgs },
+        };
+        const taskKeys = Object.keys(localSchema).filter((k) => k !== "_output" && k !== "_init");
+        const results = {
+            _init: initArgs,
+        };
+        const status = {};
+        for (const key of taskKeys)
+            status[key] = "pending";
+        let progress = true;
+        let safety = 0;
+        const maxIterations = taskKeys.length * 2;
+        while (progress && safety < maxIterations) {
+            progress = false;
+            safety++;
+            for (const key of taskKeys) {
+                const task = localSchema[key];
+                if (status[key] !== "pending")
+                    continue;
+                const deps = task.dependencies ?? [];
+                if (!deps.every((d) => status[d] === "success"))
+                    continue;
+                if (task.runIf?.length) {
+                    const runIfResults = await Promise.all(task.runIf.map((fn) => fn(results)));
+                    if (!runIfResults.every(Boolean)) {
+                        status[key] = "skipped";
+                        logger?.("skipped", String(key), {
+                            reason: "runIf",
+                            results: runIfResults,
+                        });
+                        markDependentsSkipped(localSchema, status, key);
+                        continue;
+                    }
+                }
+                const args = task.argMap?.(results);
+                if (task.bg) {
+                    logger?.("background", String(key), args);
+                    Promise.resolve().then(async () => {
+                        try {
+                            await (args !== undefined ? task.fn(args) : task.fn());
+                            logger?.("success", String(key));
+                        }
+                        catch (err) {
+                            logger?.("fail", String(key), err);
+                        }
+                    });
+                    status[key] = "success";
+                    results[key] = undefined;
+                    progress = true;
+                    continue;
+                }
+                logger?.("start", String(key), args);
+                try {
+                    const result = args !== undefined ? await task.fn(args) : await task.fn();
+                    if (isFailure(result)) {
+                        status[key] = "failed";
+                        logger?.("fail", String(key), result);
+                        if (task.abort)
+                            throw result;
+                    }
+                    else if (isSuccess(result)) {
+                        status[key] = "success";
+                        results[key] = result.data;
+                        logger?.("success", String(key), result);
+                    }
+                }
+                catch (err) {
+                    status[key] = "failed";
+                    logger?.("fail", String(key), err);
+                    if (task.abort)
+                        throw err;
+                }
+                progress = true;
+            }
+        }
+        const pendingKeys = taskKeys.filter((k) => status[k] === "pending");
+        if (pendingKeys.length)
+            throw new Error(`Unresolved tasks (possible circular deps): ${pendingKeys.join(", ")}`);
+        const output = schema._output(results);
+        logger?.("finish", "_schema", { results, status, output });
+        return { _output: output, _status: status };
+    }
+    catch (err) {
+        throw err;
+    }
+});
+/// utility fn wrapper around runSchema
+//
+//

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pogodisco/task-runner",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "publishConfig": {
     "access": "public"
   },
@@ -22,6 +22,9 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "prepublishOnly": "npm run build",
     "build": "tsc",

package/src/main.ts

@@ -1,283 +0,0 @@
-import {
-	isFailure,
-	isSuccess,
-	withResponse,
-	type SuccessResponse,
-} from "@pogodisco/response";
-
-// --- logging / options ---
-export type LogEvent =
-	| "start"
-	| "finish"
-	| "data"
-	| "deferred"
-	| "skipped"
-	| "background"
-	| "parallel"
-	| "success"
-	| "fail";
-
-export type TaskLogger = (event: LogEvent, key: string, meta?: any) => void;
-
-export interface SchemaOptions {
-	log?: TaskLogger;
-}
-
-// --- core types ---
-export type TaskState = "pending" | "skipped" | "failed" | "success";
-
-// --- task definition ---
-export type TaskDefinition<
-	F extends (...args: any) => any,
-	T extends TaskMap,
-	I extends Record<string, any>,
-> = {
-	fn: F;
-	dependencies?: string[];
-	abort?: boolean;
-	bg?: boolean;
-	runIf?: ((results: TaskResultsData<T, I>) => boolean | Promise<boolean>)[];
-	argMap?: (results: TaskResultsData<T, I>) => Parameters<F>[0];
-};
-
-export type TaskMap = Record<string, TaskDefinition<any, any, any>>;
-
-type TaskFnResult<TD extends TaskDefinition<any, any, any>> = Awaited<
-	ReturnType<TD["fn"]>
->;
-
-type SuccessData<T> = T extends { ok: true; data: infer D } ? D : never;
-
-// --- **results only store unwrapped success data** ---
-// export type TaskResultsData<T extends TaskMap, I> = { _init: I } & {
-//   [K in keyof T]: TDResultData<T[K]>;
-// };
-
-export type TaskResultsData<T extends TaskMap, I> = { _init: I } & {
-	[K in keyof T]: TDResultData<T[K]>;
-};
-
-type TDResultData<TD extends TaskDefinition<any, any, any>> =
-	TD extends TaskDefinition<infer F, any, any>
-		? SuccessData<Awaited<ReturnType<F>>>
-		: never;
-
-type ReturnTypeSuccessData<F extends (...args: any) => any> = Awaited<
-	ReturnType<F>
-> extends SuccessResponse<infer D>
-	? D
-	: never;
-
-// --- helper to create task definitions from functions ---
-export type TasksFromFns<T extends Record<string, (...args: any) => any>> = {
-	[K in keyof T]: TaskDefinition<T[K], any, any>;
-};
-
-// --- typed schema ---
-export type TaskSchemaWithContracts<T extends TaskMap, I, O> = {
-	[K in keyof T]: T[K] extends TaskDefinition<infer F, any, any>
-		? TaskDefinition<F, T, I>
-		: never;
-} & {
-	_init?: I;
-	_output: (results: TaskResultsData<T, I>) => O;
-};
-
-// --- defineSchema ---
-export function defineSchema<T extends TaskMap, I, O>(
-	schema: {
-		[K in keyof T]: T[K] extends TaskDefinition<infer F, any, any>
-			? TaskDefinition<F, T, I>
-			: never;
-	} & { _output: (results: TaskResultsData<T, I>) => O },
-): TaskSchemaWithContracts<T, I, O> {
-	preflightCheck(schema);
-	return schema as any;
-}
-
-// --- preflight check ---
-function preflightCheck<T extends TaskMap>(
-	schema: T | (T & { _output?: any }),
-) {
-	const keys = new Set<string>();
-	for (const key in schema) {
-		if (key === "_output" || key === "_init") continue;
-		if (keys.has(key)) throw new Error(`Duplicate task key: ${key}`);
-		keys.add(key);
-
-		const task = (schema as T)[key];
-		if (!task) continue;
-		if (task.abort === undefined) task.abort = true;
-		if (task.bg === undefined) task.bg = false;
-		if (task.runIf === undefined) task.runIf = [];
-	}
-
-	const visited = new Set<string>();
-	const stack = new Set<string>();
-	const visit = (taskKey: string) => {
-		if (taskKey === "_output" || taskKey === "_init") return;
-		if (stack.has(taskKey))
-			throw new Error(
-				`Circular dependency: ${[...stack, taskKey].join(" -> ")}`,
-			);
-		if (visited.has(taskKey)) return;
-
-		stack.add(taskKey);
-		const task = (schema as T)[taskKey];
-		const deps = task?.dependencies ?? [];
-		for (const dep of deps) {
-			if (!(dep in schema))
-				throw new Error(`Task "${taskKey}" depends on unknown "${dep}"`);
-			visit(dep);
-		}
-		stack.delete(taskKey);
-		visited.add(taskKey);
-	};
-
-	for (const key of Object.keys(schema)) visit(key);
-}
-
-// --- mark dependents skipped ---
-function markDependentsSkipped<T extends TaskMap>(
-	schema: T,
-	status: Record<keyof T, TaskState>,
-	key: keyof T,
-) {
-	for (const k of Object.keys(schema) as (keyof T)[]) {
-		const task = schema[k];
-		if (
-			(task.dependencies ?? []).includes(key as string) &&
-			status[k] === "pending"
-		) {
-			status[k] = "skipped";
-			markDependentsSkipped(schema, status, k);
-		}
-	}
-}
-
-// --- runSchema, storing **only success data** ---
-export const runSchema = withResponse(
-	async <T extends TaskMap, I, O>(
-		schema: TaskSchemaWithContracts<T, I, O>,
-		initArgs: I,
-		options?: SchemaOptions,
-	): Promise<{ _output: O; _status: Record<keyof T, TaskState> }> => {
-		try {
-			const logger: TaskLogger | undefined = options?.log;
-
-			const localSchema = {
-				...schema,
-				_init: { fn: (x: I) => x, argMap: () => initArgs },
-			} as unknown as T & { _init: TaskDefinition<(x: I) => I, T, I> };
-
-			const taskKeys = Object.keys(localSchema).filter(
-				(k) => k !== "_output" && k !== "_init",
-			) as (keyof typeof localSchema)[];
-
-			const results: Partial<TaskResultsData<T, I>> = {
-				_init: initArgs,
-			} as any;
-
-			const status: { [K in keyof typeof localSchema]?: TaskState } = {};
-			for (const key of taskKeys) status[key] = "pending";
-
-			let progress = true;
-			let safety = 0;
-			const maxIterations = taskKeys.length * 2;
-
-			while (progress && safety < maxIterations) {
-				progress = false;
-				safety++;
-
-				for (const key of taskKeys) {
-					const task = localSchema[key];
-					if (status[key] !== "pending") continue;
-
-					const deps = task.dependencies ?? [];
-					if (
-						!deps.every(
-							(d) => status[d as keyof typeof localSchema] === "success",
-						)
-					)
-						continue;
-
-					if (task.runIf?.length) {
-						const runIfResults = await Promise.all(
-							task.runIf.map((fn) => fn(results as TaskResultsData<T, I>)),
-						);
-						if (!runIfResults.every(Boolean)) {
-							status[key] = "skipped";
-							logger?.("skipped", String(key), {
-								reason: "runIf",
-								results: runIfResults,
-							});
-							markDependentsSkipped(localSchema, status as any, key as any);
-							continue;
-						}
-					}
-
-					const args = task.argMap?.(results as TaskResultsData<T, I>);
-
-					if (task.bg) {
-						logger?.("background", String(key), args);
-						Promise.resolve().then(async () => {
-							try {
-								await (args !== undefined ? task.fn(args) : task.fn());
-								logger?.("success", String(key));
-							} catch (err) {
-								logger?.("fail", String(key), err);
-							}
-						});
-						status[key] = "success";
-						(results as any)[key] = undefined;
-						progress = true;
-						continue;
-					}
-
-					logger?.("start", String(key), args);
-
-					try {
-						const result =
-							args !== undefined ? await task.fn(args) : await task.fn();
-
-						if (isFailure(result)) {
-							status[key] = "failed";
-							logger?.("fail", String(key), result);
-							if (task.abort) throw result;
-						} else if (isSuccess(result)) {
-							status[key] = "success";
-							(results as any)[key] = result.data; // ✅ unwrap data automatically
-							logger?.("success", String(key), result);
-						}
-					} catch (err) {
-						status[key] = "failed";
-						logger?.("fail", String(key), err);
-						if (task.abort) throw err;
-					}
-
-					progress = true;
-				}
-			}
-
-			const pendingKeys = taskKeys.filter(
-				(k) => status[k as keyof typeof status] === "pending",
-			);
-			if (pendingKeys.length)
-				throw new Error(
-					`Unresolved tasks (possible circular deps): ${pendingKeys.join(", ")}`,
-				);
-
-			const output = schema._output(results as TaskResultsData<T, I>);
-			logger?.("finish", "_schema", { results, status, output });
-
-			return { _output: output, _status: status as Record<keyof T, TaskState> };
-		} catch (err) {
-			console.error("🔥 runSchema crashed before finish:", err);
-			throw err;
-		}
-	},
-);
-
-/// utility fn wrapper around runSchema
-//
-//

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "module": "ESNext",
-    "target": "ESNext",
-    "moduleResolution": "Node",
-    "skipLibCheck": true
-  },
-  "include": ["src"],
-  "exclude": ["dist", "node_modules"]
-}