@pogodisco/zephyr 1.0.0 → 1.2.0

package/dist/workflow-composer.d.ts

@@ -17,17 +17,19 @@ export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extend
     outputResolver?: (ctx: any) => Output;
 };
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}> {
+export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown, Context extends Record<string, any> = {}, Steps extends StepDef<Reg, any, any>[] = [], Results = {}> {
     private name;
     private registry;
+    private context;
     private steps;
     private frontier;
     private outputResolver?;
-    constructor(name: string, registry: Reg);
+    constructor(name: string, registry: Reg, context: Context);
     step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
         input: Input;
         results: Results;
-    }) => Parameters<Reg[ActionName]>[0], dependsOn?: string[]): WorkflowBuilder<Reg, Input, [
+        context: Context;
+    }) => Parameters<Reg[ActionName]>[0], dependsOn?: string[]): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Results & {
@@ -36,21 +38,23 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
         input: Input;
         results: Results;
-    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }>;
-    parallel<Branches extends WorkflowBuilder<Reg, Input, any, any>[]>(...branches: {
-        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Input, [], Results>) => Branches[K];
-    }): WorkflowBuilder<Reg, Input, [
+        context: Context;
+    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }>;
+    parallel<Branches extends WorkflowBuilder<Reg, Input, Context, any, any>[]>(...branches: {
+        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Input, Context, [], Results>) => Branches[K];
+    }): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
-        ...(Branches[number] extends WorkflowBuilder<Reg, any, infer S, any> ? S : never)
-    ], Results & (Branches[number] extends WorkflowBuilder<Reg, any, any, infer R> ? UnionToIntersection<R> : {})>;
+        ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any> ? S : never)
+    ], Results & (Branches[number] extends WorkflowBuilder<Reg, any, any, any, infer R> ? UnionToIntersection<R> : {})>;
     join<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
         input: Input;
         results: Results;
-    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }>;
+    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }>;
     subflow<Prefix extends string, SubInput, SubResults, SubSteps extends StepDef<Reg, any, any>[]>(prefix: Prefix, workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps>, resolveInput: (ctx: {
         input: Input;
         results: Results;
-    }) => SubInput): WorkflowBuilder<Reg, Input, [
+        context: Context;
+    }) => SubInput): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         ...SubSteps
     ], Results & {
@@ -59,10 +63,11 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     output<Output>(fn: (ctx: {
         input: Input;
         results: Results;
+        context: Context;
     }) => Output): WorkflowDef<Reg, Input, Results, Steps, Output>;
     build(): WorkflowDef<Reg, Input, Results, Steps>;
     private validateDependencies;
     private getEndSteps;
 }
-export declare function createWorkflow<Reg extends ActionRegistry>(registry: Reg): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Input, [], {}>;
+export declare function createWorkflow<Reg extends ActionRegistry, Context extends Record<string, any> = {}>(registry: Reg, context?: Context): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Input, Context, [], {}>;
 export {};

package/dist/workflow-composer.js

@@ -276,10 +276,279 @@
 //   };
 // }
 //
+//////////////////////////////////////////////////////////////
+// import { ActionRegistry } from "./types.js";
+//
+// type StepResult<
+//   Reg extends ActionRegistry,
+//   ActionName extends keyof Reg,
+// > = Awaited<ReturnType<Reg[ActionName]>>;
+//
+// export type StepDef<
+//   Reg extends ActionRegistry,
+//   ID extends string = string,
+//   ActionName extends keyof Reg = any,
+// > = {
+//   id: ID;
+//   action: ActionName;
+//   dependsOn: string[];
+//   resolve: (ctx: any) => Parameters<Reg[ActionName]>[0];
+//   when?: (ctx: any) => boolean;
+// };
+//
+// export type WorkflowDef<
+//   Reg extends ActionRegistry,
+//   Input,
+//   Results,
+//   Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[],
+//   Output = undefined,
+// > = {
+//   name: string;
+//   steps: Steps;
+//   entrySteps: StepDef<Reg>[];
+//   endSteps: StepDef<Reg>[];
+//   input: Input;
+//   results: Results;
+//   outputResolver?: (ctx: any) => Output;
+// };
+//
+// type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+//   k: infer I,
+// ) => void
+//   ? I
+//   : never;
+//
+// export class WorkflowBuilder<
+//   Reg extends ActionRegistry,
+//   Input = unknown,
+//   Steps extends StepDef<Reg, any, any>[] = [],
+//   Results = {},
+// > {
+//   private steps: StepDef<Reg, any, any>[] = [];
+//   private frontier: string[] = [];
+//
+//   private outputResolver?: (ctx: any) => any;
+//   constructor(
+//     private name: string,
+//     private registry: Reg,
+//   ) {}
+//
+//   /* ------------------------------------------------ */
+//   /* Base Step                                         */
+//   /* ------------------------------------------------ */
+//
+//   step<ID extends string, ActionName extends keyof Reg & string>(
+//     id: ID,
+//     action: ActionName,
+//     resolve: (ctx: {
+//       input: Input;
+//       results: Results;
+//     }) => Parameters<Reg[ActionName]>[0],
+//     dependsOn?: string[],
+//   ): WorkflowBuilder<
+//     Reg,
+//     Input,
+//     [...Steps, StepDef<Reg, ID, ActionName>],
+//     Results & { [K in ID]: StepResult<Reg, ActionName> }
+//   > {
+//     const deps = dependsOn ?? [...this.frontier];
+//
+//     this.steps.push({
+//       id,
+//       action,
+//       resolve,
+//       dependsOn: deps,
+//     });
+//
+//     this.frontier = [id];
+//
+//     return this as any;
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Sequential shortcut                               */
+//   /* ------------------------------------------------ */
+//
+//   seq<ID extends string, ActionName extends keyof Reg & string>(
+//     id: ID,
+//     action: ActionName,
+//     resolve: (ctx: {
+//       input: Input;
+//       results: Results;
+//     }) => Parameters<Reg[ActionName]>[0],
+//   ) {
+//     return this.step(id, action, resolve);
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Parallel branches                                 */
+//   parallel<Branches extends WorkflowBuilder<Reg, Input, any, any>[]>(
+//     ...branches: {
+//       [K in keyof Branches]: (
+//         builder: WorkflowBuilder<Reg, Input, [], Results>,
+//       ) => Branches[K];
+//     }
+//   ): WorkflowBuilder<
+//     Reg,
+//     Input,
+//     [
+//       ...Steps,
+//       ...(Branches[number] extends WorkflowBuilder<Reg, any, infer S, any>
+//         ? S
+//         : never),
+//     ],
+//     Results &
+//       (Branches[number] extends WorkflowBuilder<Reg, any, any, infer R>
+//         ? UnionToIntersection<R>
+//         : {})
+//   > {
+//     const parentFrontier = [...this.frontier];
+//     const branchEnds: string[] = [];
+//
+//     branches.forEach((branch) => {
+//       const b = new WorkflowBuilder<Reg, Input, [], Results>(
+//         this.name,
+//         this.registry,
+//       );
+//
+//       b.frontier = parentFrontier;
+//
+//       branch(b);
+//
+//       branchEnds.push(...b.frontier);
+//
+//       this.steps.push(...(b as any).steps);
+//     });
+//
+//     this.frontier = branchEnds;
+//
+//     return this as any;
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Join helper                                       */
+//   /* ------------------------------------------------ */
+//
+//   join<ID extends string, ActionName extends keyof Reg & string>(
+//     id: ID,
+//     action: ActionName,
+//     resolve: (ctx: {
+//       input: Input;
+//       results: Results;
+//     }) => Parameters<Reg[ActionName]>[0],
+//   ) {
+//     return this.step(id, action, resolve, [...this.frontier]);
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Subflow                                           */
+//   /* ------------------------------------------------ */
+//
+//   subflow<
+//     Prefix extends string,
+//     SubInput,
+//     SubResults,
+//     SubSteps extends StepDef<Reg, any, any>[],
+//   >(
+//     prefix: Prefix,
+//     workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps>,
+//     resolveInput: (ctx: { input: Input; results: Results }) => SubInput,
+//   ): WorkflowBuilder<
+//     Reg,
+//     Input,
+//     [...Steps, ...SubSteps],
+//     Results & { [K in Prefix]: SubResults }
+//   > {
+//     const idMap = new Map<string, string>();
+//
+//     workflow.steps.forEach((step) => {
+//       idMap.set(step.id, `${prefix}.${step.id}`);
+//     });
+//
+//     workflow.steps.forEach((step) => {
+//       const newStep = {
+//         ...step,
+//
+//         id: idMap.get(step.id)!,
+//
+//         dependsOn: step.dependsOn.map((d) => idMap.get(d)!),
+//
+//         resolve: (ctx: any) => {
+//           const subInput = resolveInput(ctx);
+//
+//           return step.resolve({
+//             input: subInput,
+//             results: ctx.results,
+//           });
+//         },
+//       };
+//
+//       if (workflow.entrySteps.find((e) => e.id === step.id)) {
+//         newStep.dependsOn = [...this.frontier];
+//       }
+//
+//       this.steps.push(newStep);
+//     });
+//
+//     this.frontier = workflow.endSteps.map((e) => idMap.get(e.id)!);
+//
+//     return this as any;
+//   }
+//
+//   output<Output>(
+//     fn: (ctx: { input: Input; results: Results }) => Output,
+//   ): WorkflowDef<Reg, Input, Results, Steps, Output> {
+//     this.outputResolver = fn;
+//     return this.build() as WorkflowDef<Reg, Input, Results, Steps, Output>;
+//   }
+//   /* ------------------------------------------------ */
+//   /* Build                                             */
+//   /* ------------------------------------------------ */
+//   build(): WorkflowDef<Reg, Input, Results, Steps> {
+//     this.validateDependencies();
+//
+//     return {
+//       name: this.name,
+//       steps: this.steps as Steps,
+//       entrySteps: this.steps.filter((s) => s.dependsOn.length === 0),
+//       endSteps: this.getEndSteps(),
+//       input: {} as Input,
+//       results: {} as Results,
+//       outputResolver: this.outputResolver,
+//     };
+//   }
+//
+//   /* ------------------------------------------------ */
+//
+//   private validateDependencies() {
+//     const stepIds = new Set(this.steps.map((s) => s.id));
+//
+//     for (const step of this.steps) {
+//       for (const dep of step.dependsOn) {
+//         if (!stepIds.has(dep)) {
+//           throw new Error(`Step ${step.id} depends on unknown step ${dep}`);
+//         }
+//       }
+//     }
+//   }
+//
+//   private getEndSteps() {
+//     const hasDependents = new Set<string>();
+//
+//     for (const step of this.steps) {
+//       for (const dep of step.dependsOn) {
+//         hasDependents.add(dep);
+//       }
+//     }
+//
+//     return this.steps.filter((s) => !hasDependents.has(s.id));
+//   }
+// }
 export class WorkflowBuilder {
-    constructor(name, registry) {
+    constructor(name, registry, context) {
         this.name = name;
         this.registry = registry;
+        this.context = context;
         this.steps = [];
         this.frontier = [];
     }
@@ -309,7 +578,7 @@ export class WorkflowBuilder {
         const parentFrontier = [...this.frontier];
         const branchEnds = [];
         branches.forEach((branch) => {
-            const b = new WorkflowBuilder(this.name, this.registry);
+            const b = new WorkflowBuilder(this.name, this.registry, this.context);
             b.frontier = parentFrontier;
             branch(b);
             branchEnds.push(...b.frontier);
@@ -342,6 +611,7 @@ export class WorkflowBuilder {
                     return step.resolve({
                         input: subInput,
                         results: ctx.results,
+                        context: ctx.context,
                     });
                 },
             };
@@ -393,13 +663,8 @@ export class WorkflowBuilder {
         return this.steps.filter((s) => !hasDependents.has(s.id));
     }
 }
-// export function createWorkflow<Reg extends ActionRegistry, Input = unknown>(
-//   registry: Reg,
-// ) {
-//   return (name: string) => new WorkflowBuilder<Reg, Input>(name, registry);
-// }
-export function createWorkflow(registry) {
+export function createWorkflow(registry, context) {
     return function workflow(name) {
-        return new WorkflowBuilder(name, registry);
+        return new WorkflowBuilder(name, registry, context || {});
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pogodisco/zephyr",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "publishConfig": {
     "access": "public"
   },