@pogodisco/task-runner 0.2.2 → 0.2.3

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

@@ -0,0 +1,11 @@
+import { TasksFromFns } from "../types/index.js";
+export declare const startSchema: import("../types/index.js").TaskSchemaWithContracts<TasksFromFns<{}>, {
+    foo: string;
+}, {
+    data: string;
+}>;
+export declare const secondSchema: import("../types/index.js").TaskSchemaWithContracts<TasksFromFns<{}>, {
+    testNumber: number;
+}, {
+    numeric: number;
+}>;

package/dist/v2/check/index.js

@@ -0,0 +1,22 @@
+import { createGraph } from "../graph/main.js";
+import { createGraphRegistrar } from "../graph/registry.js";
+import { defineSchema } from "../main.js";
+import { wrapSchema } from "../utils/wrap-schema.js";
+export const startSchema = defineSchema({
+    _output: (r) => ({ data: r._init.foo }),
+});
+export const secondSchema = defineSchema({
+    _output: (r) => ({ numeric: r._init.testNumber }),
+});
+const g = createGraph()
+    .node("one", wrapSchema(startSchema), (ctx) => ({
+    foo: ctx._init.foo,
+}))
+    .node("two", wrapSchema(secondSchema))
+    .edge("one", "two", (ctx) => ctx.results.one.data === "bar")
+    .build();
+const reg = {
+    one: g,
+};
+const fromGraph = createGraphRegistrar(reg);
+const r = await fromGraph("one", { foo: "bar" });

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>>;

package/dist/v2/graph/main.js

@@ -1,10 +1,6 @@
-//  function edge<K extends keyof any>(
-// 	from: K,
-// 	to: K,
-// 	when?: (ctx: any) => boolean,
-// ): GraphEdge<K> {
-// 	return { from, to, when };
-// }
+export function edge(from, to, when) {
+    return { from, to, when };
+}
 export function createGraph() {
     const nodes = {};
     // const edges: GraphEdge<string>[] = [];
@@ -18,6 +14,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;
         },

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.3",
   "publishConfig": {
     "access": "public"
   },