@pogodisco/zephyr 1.4.1 → 1.5.0

package/dist/workflow-composer.js

@@ -1,354 +1,3 @@
-// import {
-//   ActionParams,
-//   ActionRegistry,
-//   ActionReturn,
-//   Simplify,
-// } from "./types.js";
-//
-// /* ------------------------------------------------ */
-// /* STEP INPUT NORMALIZATION TYPES                  */
-// /* ------------------------------------------------ */
-//
-// type NormalizedCall =
-//   | { kind: "none" }
-//   | { kind: "positional"; args: any[] }
-//   | { kind: "object"; args: any };
-//
-// export type ResolvedStepInput =
-//   | NormalizedCall
-//   | { kind: "loop"; items: NormalizedCall[] };
-//
-// type CallHelpers<Reg extends ActionRegistry, ActionName extends keyof Reg> = {
-//   args: (...args: ActionParams<Reg, ActionName>) => {
-//     kind: "positional";
-//     args: ActionParams<Reg, ActionName>;
-//   };
-//
-//   obj: ActionParams<Reg, ActionName> extends [infer A]
-//     ? (arg: A) => { kind: "object"; args: A }
-//     : never;
-//
-//   none: () => { kind: "none" };
-//   loop: (
-//     items:
-//       | { kind: "positional"; args: ActionParams<Reg, ActionName> }[]
-//       | { kind: "object"; args: ActionParams<Reg, ActionName>[0] }[],
-//   ) => {
-//     kind: "loop";
-//     items: typeof items;
-//   };
-// };
-//
-// /* ------------------------------------------------ */
-// /* STEP RESULT TYPES                               */
-// /* ------------------------------------------------ */
-//
-// type SubflowResult<SubResults, SubOutput> = SubOutput extends undefined
-//   ? SubResults
-//   : SubOutput;
-//
-// type WorkflowInput<T> =
-//   T extends WorkflowDef<any, infer I, any, any, any> ? I : never;
-//
-// type WorkflowResults<T> =
-//   T extends WorkflowDef<any, any, infer R, any, any> ? R : never;
-//
-// type WorkflowOutput<T> =
-//   T extends WorkflowDef<any, any, any, any, infer O> ? O : never;
-//
-// export type StepResultFromResolve<
-//   Reg extends ActionRegistry,
-//   ActionName extends keyof Reg,
-//   R extends ResolvedStepInput,
-// > = R extends { kind: "loop" }
-//   ? ActionReturn<Reg, ActionName>[]
-//   : ActionReturn<Reg, ActionName>;
-//
-// /* ------------------------------------------------ */
-// /* STEP DEFINITION                                 */
-// /* ------------------------------------------------ */
-//
-// export type StepDef<
-//   Reg extends ActionRegistry,
-//   ID extends string = string,
-//   ActionName extends keyof Reg = any,
-// > = {
-//   id: ID;
-//   action: ActionName;
-//   dependsOn: string[];
-//   resolve: (ctx: any) => ResolvedStepInput;
-//   when?: (ctx: any) => boolean;
-//   options?: StepOptions<any, any, any>;
-// };
-//
-// /* ------------------------------------------------ */
-// /* WORKFLOW DEFINITION                             */
-// /* ------------------------------------------------ */
-//
-// 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;
-//   // __context?: any;
-// };
-// type StepRuntimeCtx<I, R, C> = {
-//   input: I;
-//   results: R;
-//   context: C;
-// };
-// type StepOptions<Input, Results, Context> = {
-//   retry?: number;
-//   retryDelay?: number | ((attempt: number) => number);
-//   timeout?: number;
-//
-//   continueOnError?: boolean;
-//
-//   onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results, Context>) => any;
-//
-//   // optional later:
-//   label?: string;
-//   meta?: Record<string, any>;
-// };
-//
-// /* ------------------------------------------------ */
-// /* HELPER TYPES                                    */
-// /* ------------------------------------------------ */
-//
-// type MergeBranchResults<
-//   Branches extends readonly any[],
-//   Acc,
-// > = Branches extends readonly [infer Head, ...infer Tail]
-//   ? MergeBranchResults<
-//       Tail,
-//       Acc & (Head extends WorkflowBuilder<any, any, any, any, infer R> ? R : {})
-//     >
-//   : Acc;
-//
-// type MergeBranchSteps<
-//   Branches extends readonly any[],
-//   Acc extends any[],
-// > = Branches extends readonly [infer Head, ...infer Tail]
-//   ? MergeBranchSteps<
-//       Tail,
-//       [
-//         ...Acc,
-//         ...(Head extends WorkflowBuilder<any, any, any, infer S, any> ? S : []),
-//       ]
-//     >
-//   : Acc;
-//
-// // type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (
-// //   x: infer I,
-// // ) => any
-// //   ? I
-// //   : never;
-// //
-// // type ExtractBranchResults<Branches extends readonly any[]> =
-// //   Branches[number] extends WorkflowBuilder<any, any, any, any, infer R>
-// //     ? R
-// //     : never;
-// //
-// // type MergeBranchResults<Branches extends readonly any[], Acc> = Simplify<
-// //   Acc & Partial<ExtractBranchResults<Branches>>
-// // >;
-//
-// /* ------------------------------------------------ */
-// /* FLUENT WORKFLOW BUILDER                          */
-// /* ------------------------------------------------ */
-//
-// export class WorkflowBuilder<
-//   Reg extends ActionRegistry,
-//   Input = unknown,
-//   Context = unknown,
-//   Steps extends StepDef<Reg, any, any>[] = [],
-//   Results = {},
-//   Output = undefined,
-// > {
-//   private steps: StepDef<Reg, any, any>[] = [];
-//   private frontier: string[] = [];
-//   private pendingWhen?: (ctx: {
-//     input: Input;
-//     results: Results;
-//     context: Context;
-//   }) => boolean;
-//   private outputResolver?: (ctx: any) => any;
-//   private clearPendingWhen() {
-//     this.pendingWhen = undefined;
-//   }
-//
-//   constructor(private name: string) {}
-//
-//   step<
-//     ID extends string,
-//     ActionName extends keyof Reg & string,
-//     ResolveOut extends ResolvedStepInput = ResolvedStepInput,
-//   >(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (
-//       ctx: {
-//         input: Input;
-//         results: Results;
-//         context: Context;
-//       } & CallHelpers<Reg, ActionName>,
-//     ) => ResolveOut,
-//     dependsOn?: string[],
-//     options?: StepOptions<Input, Results, Context>,
-//   ): WorkflowBuilder<
-//     Reg,
-//     Input,
-//     Context,
-//     [...Steps, StepDef<Reg, ID, ActionName>],
-//     Simplify<
-//       Results & {
-//         [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>;
-//       }
-//     >
-//   > {
-//     const deps = dependsOn ?? [...this.frontier];
-//
-//     this.steps.push({
-//       id,
-//       action,
-//       resolve: resolve ?? (() => ({ kind: "none" })),
-//       dependsOn: deps,
-//       when: this.pendingWhen,
-//       options,
-//     });
-//
-//     this.frontier = [id];
-//
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Sequential shortcut                             */
-//   /* ------------------------------------------------ */
-//   seq<
-//     ID extends string = string,
-//     ActionName extends keyof Reg & string = any,
-//     ResolveOut extends ResolvedStepInput = ResolvedStepInput,
-//   >(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (
-//       ctx: {
-//         input: Input;
-//         results: Results;
-//         context: Context;
-//       } & CallHelpers<Reg, ActionName>,
-//     ) => ResolveOut,
-//     options?: StepOptions<Input, Results, Context>,
-//   ) {
-//     return this.step<ID, ActionName, ResolveOut>(
-//       id,
-//       action,
-//       resolve,
-//       undefined,
-//       options,
-//     );
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Override the result of the last step            */
-//   /* ------------------------------------------------ */
-//   as<NewType>(): WorkflowBuilder<
-//     Reg,
-//     Input,
-//     Context,
-//     Steps,
-//     // Override the result of the last step only
-//     Steps extends [...infer Rest, infer Last]
-//       ? Last extends StepDef<Reg, infer ID, any>
-//         ? Simplify<Omit<Results, ID> & { [K in ID]: NewType }>
-//         : Results
-//       : Results,
-//     Output
-//   > {
-//     return this as any;
-//   }
-//
-//   parallel<
-//     Branches extends readonly WorkflowBuilder<Reg, Input, Context, any, any>[],
-//   >(
-//     ...branches: {
-//       [K in keyof Branches]: (
-//         builder: WorkflowBuilder<Reg, Input, Context, [], Results>,
-//       ) => Branches[K];
-//     }
-//   ): WorkflowBuilder<
-//     Reg,
-//     Input,
-//     Context,
-//     MergeBranchSteps<Branches, Steps>,
-//     // [
-//     //   ...Steps,
-//     //   ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any>
-//     //     ? S
-//     //     : never),
-//     // ],
-//     Simplify<MergeBranchResults<Branches, Results>>
-//   > {
-//     const parentFrontier = [...this.frontier];
-//     const branchEnds: string[] = [];
-//
-//     branches.forEach((branch) => {
-//       const b = new WorkflowBuilder<Reg, Input, Context, [], Results>(
-//         this.name,
-//       );
-//
-//       b.frontier = parentFrontier;
-//       branch(b);
-//       branchEnds.push(...b.frontier);
-//       this.steps.push(...(b as any).steps);
-//     });
-//
-//     this.frontier = branchEnds;
-//     this.clearPendingWhen();
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Join helper                                     */
-//   /* ------------------------------------------------ */
-//   join<
-//     ID extends string = string,
-//     ActionName extends keyof Reg & string = any,
-//     ResolveOut extends ResolvedStepInput = ResolvedStepInput,
-//   >(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (
-//       ctx: {
-//         input: Input;
-//         results: Results;
-//         context: Context;
-//       } & CallHelpers<Reg, ActionName>,
-//     ) => ResolveOut,
-//     options?: StepOptions<Input, Results, Context>,
-//   ) {
-//     const result = this.step<ID, ActionName, ResolveOut>(
-//       id,
-//       action,
-//       resolve,
-//       [...this.frontier],
-//       options,
-//     );
-//
-//     this.clearPendingWhen();
-//     return result;
-//   }
-//
 //   /* ------------------------------------------------ */
 //   /* Subflow                                         */
 //   /* ------------------------------------------------ */
@@ -419,90 +68,7 @@
 //   /* Conditional                                      */
 //   /* ------------------------------------------------ */
 //
-//   when(
-//     predicate: (ctx: {
-//       input: Input;
-//       results: Results;
-//       context: Context;
-//     }) => boolean,
-//   ): WorkflowBuilder<Reg, Input, Context, Steps, Results, Output> {
-//     this.pendingWhen = predicate;
-//     return this;
-//   }
-//
-//   endWhen(): this {
-//     this.clearPendingWhen();
-//
-//     return this;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Workflow output                                  */
-//   /* ------------------------------------------------ */
-//   output<Output>(
-//     fn: (ctx: { input: Input; results: Results; context: Context }) => Output,
-//   ): WorkflowDef<Reg, Input, Results, Steps, Output> {
-//     this.outputResolver = fn;
-//     return this.build() as WorkflowDef<Reg, Input, Results, Steps, Output>;
-//   }
-//
-//   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));
-//   }
-// }
-//
-// /* ------------------------------------------------ */
-// /* WORKFLOW CREATOR                                 */
-// /* ------------------------------------------------ */
-// // export function createWorkflow<
-// //   Reg extends ActionRegistry,
-// //   Context extends Record<string, any> = {},
-// // >(registry: Reg, context?: Context) {
-// //   return function workflow<Input = unknown>(name: string) {
-// //     return new WorkflowBuilder<Reg, Input, Context>(name);
-// //   };
-// // }
-//
-// export function createWorkflow<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any> = {},
-// >() {
-//   return function workflow<Input = unknown>(name: string) {
-//     return new WorkflowBuilder<Reg, Input, Context>(name);
-//   };
-// }
-//
-//
-//
-//
+import { generateWorkflowId } from "./utils.js";
 /* ------------------------------------------------ */
 /* FLUENT WORKFLOW BUILDER                          */
 /* ------------------------------------------------ */
@@ -534,6 +100,22 @@ export class WorkflowBuilder {
     seq(id, action, resolve, options) {
         return this.step(id, action, resolve, undefined, options);
     }
+    service(id, service, method, resolve) {
+        const deps = [...this.frontier];
+        this.steps.push({
+            id,
+            action: "__service__",
+            serviceCall: {
+                service,
+                method,
+            },
+            resolve: resolve ?? (() => ({ kind: "none" })),
+            dependsOn: deps,
+            when: this.pendingWhen,
+        });
+        this.frontier = [id];
+        return this;
+    }
     /* ------------------------------------------------ */
     /* Override the result of the last step            */
     /* ------------------------------------------------ */
@@ -546,12 +128,12 @@ export class WorkflowBuilder {
         branches.forEach((branch) => {
             const b = new WorkflowBuilder(this.name);
             b.frontier = parentFrontier;
+            b.pendingWhen = this.pendingWhen;
             branch(b);
             branchEnds.push(...b.frontier);
             this.steps.push(...b.steps);
         });
         this.frontier = branchEnds;
-        this.clearPendingWhen();
         return this;
     }
     /* ------------------------------------------------ */
@@ -567,10 +149,8 @@ export class WorkflowBuilder {
             id: prefix,
             action: "__subflow__",
             dependsOn: [...this.frontier],
-            resolve: (ctx) => ({
-                kind: "object",
-                args: resolveInput(ctx),
-            }),
+            when: this.pendingWhen,
+            resolve: (ctx) => resolveInput(ctx),
             options,
             __subflowId: workflowKey, // 👈 STRING ONLY
         });
@@ -598,6 +178,7 @@ export class WorkflowBuilder {
     build() {
         this.validateDependencies();
         return {
+            _id: generateWorkflowId(this.name),
             name: this.name,
             steps: this.steps,
             entrySteps: this.steps.filter((s) => s.dependsOn.length === 0),
@@ -625,17 +206,6 @@ export class WorkflowBuilder {
         return this.steps.filter((s) => !hasDependents.has(s.id));
     }
 }
-/* ------------------------------------------------ */
-/* WORKFLOW CREATOR                                 */
-/* ------------------------------------------------ */
-// export function createWorkflow<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any> = {},
-// >(registry: Reg, context?: Context) {
-//   return function workflow<Input = unknown>(name: string) {
-//     return new WorkflowBuilder<Reg, Input, Context>(name);
-//   };
-// }
 export function createWorkflow() {
     return function workflow(name) {
         return new WorkflowBuilder(name);

package/dist/workflow-executor.d.ts

@@ -1,6 +1,5 @@
-import { ActionRegistry, WorkflowObserver } from "./types.js";
+import { ActionRegistry, Executor, ServiceRegistry, WorkflowObserver } from "./types.js";
 import { WorkflowDef } from "./workflow-composer.js";
-import { WorkflowInput, WorkflowOutput } from "./workflow-module.js";
 export declare function createCallHelpers(): {
     args: (...args: any[]) => {
         kind: string;
@@ -18,7 +17,14 @@ export declare function createCallHelpers(): {
         items: any[];
     };
 };
-export declare function executeWorkflow<Reg extends ActionRegistry, WR extends Record<string, WorkflowDef<any, any, any, any, any>>, K extends keyof WR>(workflowId: K, workflowRegistry: WR, actionRegistry: Reg, input: WorkflowInput<WR[K]>, context: any, observers?: WorkflowObserver<Reg>[]): Promise<{
-    output: WorkflowOutput<WR[K]>;
+export declare function executeWorkflow<Reg extends ActionRegistry, I, R, O = R>({ workflow, actionRegistry, services, input, depsExecutors, observers, }: {
+    workflow: WorkflowDef<Reg, I, any, any, O>;
+    actionRegistry: Reg;
+    services: ServiceRegistry;
+    input: I;
+    depsExecutors: Record<string, Executor>;
+    observers: WorkflowObserver<Reg>[];
+}): Promise<{
+    output: O;
     extras: Record<string, any>;
 }>;