@pogodisco/task-runner 0.2.2 → 0.2.4

package/dist/v2/check/index.d.ts

@@ -0,0 +1,10 @@
+import { TasksFromFns } from "../index.js";
+declare const taskOne: () => Promise<import("@pogodisco/response").TResponse<never>>;
+export declare const schema: import("../index.js").TaskSchemaWithContracts<TasksFromFns<{
+    t1: typeof taskOne;
+}>, {
+    foo: string;
+}, {
+    data: string;
+}>;
+export {};

package/dist/v2/check/index.js

@@ -0,0 +1,34 @@
+import { isFailure, withResponse } from "@pogodisco/response";
+import { createGraph, createGraphRegistrar, defineSchema, runGraph, wrapSchema, } from "../index.js";
+import { useLogger } from "./logger.js";
+const taskOne = withResponse(async () => {
+    // throw
+    //
+    throw Error("Task one resulted in error");
+});
+export const schema = defineSchema({
+    t1: {
+        fn: taskOne,
+        argMap: (r) => ({}),
+    },
+    _output: (r) => ({ data: r._init.foo }),
+});
+const graph = createGraph()
+    .node("one", wrapSchema(schema, { log: useLogger() }))
+    .build();
+const graphWithResponse = withResponse(async () => {
+    const r = await runGraph(graph, { foo: "FOO ONE" });
+});
+const wg = await graphWithResponse();
+console.log("wrapped graph result", wg);
+const g = await runGraph(graph, { foo: "FOO TWO" });
+console.log("graph one", g);
+const r = {
+    test: graph,
+};
+const fromGraph = createGraphRegistrar(r);
+const resFromGraph = await fromGraph("test", { foo: "BAR" });
+if (isFailure(resFromGraph)) {
+    console.log("tresponse error", resFromGraph.error);
+}
+console.log("res from graph reg", resFromGraph);

package/dist/v2/check/logger.d.ts

@@ -0,0 +1,2 @@
+import { TaskLogger } from "../types/index.js";
+export declare const useLogger: () => TaskLogger;

package/dist/v2/check/logger.js

@@ -0,0 +1,118 @@
+import chalk from "chalk";
+import { format } from "pretty-format";
+const startTimes = new Map();
+const advancedLogger = (event, key, meta = {}) => {
+    const now = Date.now();
+    const prefix = `[${new Date().toISOString()}]`;
+    const label = event.toUpperCase().padEnd(9);
+    const colored = colorize(event, label);
+    if (event === "start") {
+        startTimes.set(key, now);
+        console.group(`${prefix} ${colored} ${key}`);
+        if (meta && Object.keys(meta).length > 0) {
+            console.log(chalk.gray("↪ Args:"), format(meta, { indent: 2, maxDepth: 3 }));
+        }
+        return;
+    }
+    if (event === "success" || event === "fail") {
+        const start = startTimes.get(key) ?? now;
+        const duration = now - start;
+        console.log(`${prefix} ${colored} ${key} (${formatDuration(duration)})`);
+        if (meta !== undefined) {
+            logResult(meta);
+        }
+        console.groupEnd();
+        startTimes.delete(key);
+        return;
+    }
+    if (event === "skipped") {
+        console.log(`${prefix} ${colored} ${key} (skipped)`, meta);
+        return;
+    }
+    if (event === "finish") {
+        const prefix = `[${new Date().toISOString()}]`;
+        const colored = chalk.bgMagenta.white.bold(" FINISH  ");
+        console.group(`${prefix} ${colored} ${key}`);
+        if (meta?.status) {
+            console.log(chalk.bold("Statuses:"));
+            for (const [task, st] of Object.entries(meta.status)) {
+                const stColored = st === "success"
+                    ? chalk.green(st)
+                    : st === "failed"
+                        ? chalk.red(st)
+                        : st === "skipped"
+                            ? chalk.gray(st)
+                            : chalk.yellow(st);
+                console.log(`  ${task}: ${stColored}`);
+            }
+        }
+        if (meta?.results) {
+            console.log(chalk.bold("\nResults:"));
+            logResult(meta.results);
+        }
+        if (meta?.output !== undefined) {
+            console.log(chalk.bold("\nOutput:"));
+            logResult(meta.output);
+        }
+        console.groupEnd();
+        return;
+    }
+    if (event === "data" ||
+        event === "background" ||
+        event === "parallel" ||
+        event === "deferred") {
+        console.log(`${prefix} ${colored} ${key}`, meta);
+    }
+};
+// Color mapping utility
+function colorize(event, label) {
+    switch (event) {
+        case "start":
+            return chalk.cyan(label);
+        case "finish":
+            return chalk.magentaBright(label);
+        case "success":
+            return chalk.green(label);
+        case "fail":
+            return chalk.red(label);
+        case "skipped":
+            return chalk.gray(label);
+        case "data":
+            return chalk.magenta(label);
+        case "background":
+            return chalk.blue(label);
+        case "parallel":
+            return chalk.yellow(label);
+        case "deferred":
+            return chalk.dim(label);
+        default:
+            return label;
+    }
+}
+// Fancy duration formatter
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const sec = (ms / 1000).toFixed(2);
+    return `${sec}s`;
+}
+// Clean, safe result logging
+function logResult(result) {
+    try {
+        const output = format(result, {
+            indent: 2,
+            min: false,
+            maxDepth: 6,
+            callToJSON: false,
+            printFunctionName: false,
+        });
+        console.log(chalk.gray("↪ Result:"), output);
+    }
+    catch (err) {
+        console.warn(chalk.red("! Failed to format result:"), err);
+        console.dir(result); // fallback
+    }
+}
+export const useLogger = () => {
+    return advancedLogger;
+};

package/dist/v2/graph/main.d.ts

@@ -1,3 +1,4 @@
-import { GraphBuilder, GraphNode, RuntimeCtx, SchemaGraph } from "./types/index.js";
+import { GraphBuilder, GraphEdge, GraphNode, RuntimeCtx, SchemaGraph } from "./types/index.js";
+export declare function edge<K extends keyof any>(from: K, to: K, when?: (ctx: any) => boolean): GraphEdge<K>;
 export declare function createGraph<Init = {}>(): GraphBuilder<{}, Init>;
-export declare function runGraph<Nodes extends Record<string, GraphNode<any>>, Init>(graph: SchemaGraph<Nodes, Init>, initArgs: Init): Promise<RuntimeCtx<Nodes, Init>>;
+export declare const runGraph: <Nodes extends Record<string, GraphNode<any>>, Init>(graph: SchemaGraph<Nodes, Init>, initArgs: Init) => Promise<import("@pogodisco/response").TResponse<RuntimeCtx<Nodes, Init>>>;

package/dist/v2/graph/main.js

@@ -1,10 +1,7 @@
-//  function edge<K extends keyof any>(
-// 	from: K,
-// 	to: K,
-// 	when?: (ctx: any) => boolean,
-// ): GraphEdge<K> {
-// 	return { from, to, when };
-// }
+import { withResponse } from "@pogodisco/response";
+export function edge(from, to, when) {
+    return { from, to, when };
+}
 export function createGraph() {
     const nodes = {};
     // const edges: GraphEdge<string>[] = [];
@@ -18,6 +15,10 @@ export function createGraph() {
             return builder;
         },
         edge(from, to, when) {
+            // if (!(from in nodes))
+            // 	throw new Error(`Edge 'from' node "${from}" does not exist`);
+            // if (!(to in nodes))
+            // 	throw new Error(`Edge 'to' node "${to}" does not exist`);
             edges.push({ from, to, when });
             return builder;
         },
@@ -33,7 +34,43 @@ export function createGraph() {
     };
     return builder;
 }
-export async function runGraph(graph, initArgs) {
+// export async function runGraph<
+// 	Nodes extends Record<string, GraphNode<any>>,
+// 	Init,
+// >(
+// 	graph: SchemaGraph<Nodes, Init>,
+// 	initArgs: Init,
+// ): Promise<RuntimeCtx<Nodes, Init>> {
+// 	const ctx: RuntimeCtx<Nodes, Init> = {
+// 		_init: initArgs,
+// 		results: {} as any,
+// 	};
+//
+// 	const queue: (keyof Nodes)[] = [graph.entry];
+// 	const visited = new Set<keyof Nodes>();
+//
+// 	while (queue.length) {
+// 		const nodeName = queue.shift()!;
+// 		if (visited.has(nodeName)) continue;
+//
+// 		const node = graph.nodes[nodeName];
+// 		const input = node.mapInput ? node.mapInput(ctx) : ctx._init;
+// 		const res = await node.schema(input);
+// 		if (!res.ok) throw res;
+//
+// 		ctx.results[nodeName] = res.data;
+// 		visited.add(nodeName);
+//
+// 		const nextEdges = graph.edges.filter(
+// 			(e) => e.from === nodeName && (!e.when || e.when(ctx)),
+// 		);
+//
+// 		for (const e of nextEdges) queue.push(e.to);
+// 	}
+//
+// 	return ctx;
+// }
+export const runGraph = withResponse(async (graph, initArgs) => {
     const ctx = {
         _init: initArgs,
         results: {},
@@ -56,4 +93,4 @@ export async function runGraph(graph, initArgs) {
             queue.push(e.to);
     }
     return ctx;
-}
+});

package/dist/v2/graph/registry.d.ts

@@ -1,5 +1,6 @@
+import { TResponse } from "@pogodisco/response";
 import { RuntimeCtx, SchemaGraph } from "./types/index.js";
 export type GraphInputFor<R extends Record<string, SchemaGraph<any, any>>, K extends keyof R> = R[K] extends SchemaGraph<any, infer I> ? I : never;
 export type GraphOutputFor<R extends Record<string, SchemaGraph<any, any>>, K extends keyof R> = R[K] extends SchemaGraph<infer N, infer I> ? RuntimeCtx<N, I> : never;
-export type GraphRegistrar<R extends Record<string, SchemaGraph<any, any>>> = <K extends keyof R & string>(name: K, params: GraphInputFor<R, K>) => Promise<GraphOutputFor<R, K>>;
+export type GraphRegistrar<R extends Record<string, SchemaGraph<any, any>>> = <K extends keyof R & string>(name: K, params: GraphInputFor<R, K>) => Promise<TResponse<GraphOutputFor<R, K>>>;
 export declare function createGraphRegistrar<R extends Record<string, SchemaGraph<any, any>>>(registry: R): GraphRegistrar<R>;

package/dist/v2/graph/registry.js

@@ -2,6 +2,14 @@ import { runGraph } from "./main.js";
 // -----------------------------
 // Factory
 // -----------------------------
+// export function createGraphRegistrar<
+// 	R extends Record<string, SchemaGraph<any, any>>,
+// >(registry: R): GraphRegistrar<R> {
+// 	return async (name, params) => {
+// 		const graph = registry[name];
+// 		return runGraph(graph, params) as any;
+// 	};
+// }
 export function createGraphRegistrar(registry) {
     return async (name, params) => {
         const graph = registry[name];

package/dist/v2/graph/types/index.d.ts

@@ -12,20 +12,20 @@ export type RuntimeCtx<Nodes extends Record<string, GraphNode<any>>, Init> = {
         [K in keyof Nodes]: ExtractOutput<Nodes[K]["schema"]>;
     };
 };
-export type GraphEdge<Nodes extends Record<string, GraphNode<any>>, Init> = {
-    from: keyof Nodes;
-    to: keyof Nodes;
-    when?: (ctx: RuntimeCtx<Nodes, Init>) => boolean;
+export type GraphEdge<NodeKeys extends keyof any> = {
+    from: NodeKeys;
+    to: NodeKeys;
+    when?: (ctx: any) => boolean;
 };
 export type BuiltNode<FN extends WrappedSchema<any, any>, Nodes extends Record<string, GraphNode<any>>> = GraphNode<FN>;
 export type SchemaGraph<Nodes extends Record<string, GraphNode<any>>, Init> = {
     entry: keyof Nodes;
     nodes: Nodes;
-    edges: GraphEdge<Nodes, Init>[];
+    edges: GraphEdge<keyof Nodes>[];
 };
 export type GraphBuilder<Nodes extends Record<string, GraphNode<any>> = {}, Init = {}> = {
     node<K extends string, FN extends WrappedSchema<any, any>>(key: K, schema: FN, mapInput?: (ctx: RuntimeCtx<Nodes & Record<K, GraphNode<FN>>, Init>) => ExtractInput<FN>): GraphBuilder<Nodes & Record<K, GraphNode<FN>>, Init>;
-    edge<From extends keyof Nodes, To extends keyof Nodes>(from: From, to: To, when?: (ctx: RuntimeCtx<Nodes, Init>) => boolean): GraphBuilder<Nodes, Init>;
+    edge<From extends keyof Nodes, To extends keyof Nodes>(from: From, to: To, when?: (ctx: any) => boolean): GraphBuilder<Nodes, Init>;
     build(): SchemaGraph<Nodes, Init>;
 };
 export type GraphEntryInput<G extends SchemaGraph<any, any>> = G extends SchemaGraph<infer Nodes, any> ? RuntimeCtx<Nodes, any>["_init"] : never;

package/dist/v2/test/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v2/test/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pogodisco/task-runner",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "publishConfig": {
     "access": "public"
   },
@@ -28,7 +28,11 @@
   "scripts": {
     "prepublishOnly": "npm run build",
     "build": "tsc -p tsconfig.build.json",
-    "dev": "tsc -w -p tsconfig.json"
+    "dev": "tsc -w -p tsconfig.json",
+    "test:types": "tsd"
+  },
+  "tsd": {
+    "directory": "test-dts"
   },
   "peerDependencies": {
     "@pogodisco/response": "~0.0.1",
@@ -37,6 +41,7 @@
   "devDependencies": {
     "@pogodisco/response": "~0.0.1",
     "chalk": "^5.6.2",
-    "pretty-format": "^30.2.0"
+    "pretty-format": "^30.2.0",
+    "tsd": "^0.33.0"
   }
 }