@pogodisco/zephyr 1.4.1 → 1.5.0

package/dist/workflow-executor.js

@@ -1,234 +1,3 @@
-// import { composeObserver } from "./observer.js";
-// import { ActionRegistry, ExecutionFrame, WorkflowObserver } from "./types.js";
-// import {
-//   StepDef,
-//   WorkflowDef,
-//   ResolvedStepInput,
-// } from "./workflow-composer.js";
-//
-// export function createCallHelpers() {
-//   return {
-//     args: (...args: any[]) => ({ kind: "positional", args }),
-//     obj: (arg: any) => ({ kind: "object", args: arg }),
-//     none: () => ({ kind: "none" }),
-//     loop: (items: any[]) => ({ kind: "loop", items }),
-//   };
-// }
-//
-// // Helper to wrap action execution with timeout
-// async function withTimeout<T>(promise: Promise<T>, ms?: number): Promise<T> {
-//   if (!ms) return promise;
-//   return Promise.race([
-//     promise,
-//     new Promise<T>((_, reject) =>
-//       setTimeout(() => reject(new Error("Timeout")), ms),
-//     ),
-//   ]);
-// }
-//
-// // Helper to run action with retry support
-// async function runWithRetry(
-//   actionFn: () => Promise<any>,
-//   stepOptions?: {
-//     retry?: number;
-//     retryDelay?: number | ((attempt: number) => number);
-//   },
-// ): Promise<any> {
-//   const maxRetries = stepOptions?.retry ?? 0;
-//   let lastError: any;
-//
-//   for (let attempt = 0; attempt <= maxRetries; attempt++) {
-//     try {
-//       return await actionFn();
-//     } catch (err) {
-//       lastError = err;
-//
-//       if (attempt === maxRetries) break;
-//
-//       const delay = stepOptions?.retryDelay;
-//       if (typeof delay === "number") {
-//         await new Promise((r) => setTimeout(r, delay));
-//       } else if (typeof delay === "function") {
-//         await new Promise((r) => setTimeout(r, delay(attempt)));
-//       }
-//     }
-//   }
-//
-//   throw lastError;
-// }
-//
-// export async function executeWorkflow<
-//   Reg extends ActionRegistry,
-//   I,
-//   R,
-//   O = R,
-//   Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[],
-// >(
-//   workflow: WorkflowDef<Reg, I, R, Steps, O>,
-//   registry: Reg,
-//   input: I,
-//   context: any,
-//   observers: WorkflowObserver<Reg>[] = [],
-// ): Promise<{ results: R; output: O; extras: Record<string, any> }> {
-//   const results: Record<string, any> = {};
-//   const extras: Record<string, any> = {};
-//   extras.frames = {} as Record<string, ExecutionFrame>;
-//
-//   // -----------------------------
-//   // Fully typed step map
-//   // -----------------------------
-//   const stepById: Map<string, StepDef<Reg, any, any>> = new Map(
-//     workflow.steps.map((s: StepDef<Reg, any, any>) => [s.id, s]),
-//   );
-//
-//   const remainingDeps = new Map<string, number>();
-//   const dependents = new Map<string, string[]>();
-//   const ready: string[] = [];
-//
-//   for (const step of workflow.steps) {
-//     remainingDeps.set(step.id, step.dependsOn.length);
-//     if (step.dependsOn.length === 0) ready.push(step.id);
-//
-//     for (const dep of step.dependsOn) {
-//       if (!dependents.has(dep)) dependents.set(dep, []);
-//       dependents.get(dep)!.push(step.id);
-//     }
-//   }
-//
-//   let completed = 0;
-//
-//   // -----------------------------
-//   // Normalized runner
-//   // -----------------------------
-//   const runAction = async (
-//     input: ResolvedStepInput | undefined,
-//     action: any,
-//   ): Promise<any> => {
-//     if (!input) return await action();
-//
-//     switch (input.kind) {
-//       case "none":
-//         return await action();
-//       case "positional":
-//         return await action(...input.args);
-//       case "object":
-//         return await action(input.args);
-//       case "loop":
-//         return await Promise.all(
-//           input.items.map((item) => runAction(item, action)),
-//         );
-//       default:
-//         throw new Error(
-//           `Unknown ResolvedStepInput kind: ${(input as any).kind}`,
-//         );
-//     }
-//   };
-//
-//   // -----------------------------
-//   // Execution loop
-//   // -----------------------------
-//   while (ready.length > 0) {
-//     const batch = ready.splice(0);
-//
-//     await Promise.all(
-//       batch.map(async (stepId) => {
-//         const step = stepById.get(stepId)!;
-//
-//         const frame: ExecutionFrame = {
-//           stepId,
-//           attempts: 0,
-//           start: Date.now(),
-//         };
-//         extras.frames[stepId] = frame;
-//
-//         const ctx = {
-//           stepId,
-//           input,
-//           results,
-//           context,
-//           registry,
-//           extras,
-//           frame,
-//         };
-//
-//         const core = async () => {
-//           frame.attempts++;
-//           const stepCtx = { input, results, context, ...createCallHelpers() };
-//
-//           // Conditional skip
-//           if (step.when && !step.when(stepCtx)) {
-//             frame.output = undefined;
-//             frame.end = Date.now();
-//             frame.skipped = true;
-//             results[step.id] = undefined;
-//             return undefined;
-//           }
-//
-//           const resolvedArgs = step.resolve?.(stepCtx);
-//           frame.input = resolvedArgs;
-//
-//           const actionFn = async () => {
-//             const action = registry[step.action];
-//             return await runAction(resolvedArgs, action);
-//           };
-//
-//           try {
-//             const result = await withTimeout(
-//               runWithRetry(actionFn, step.options),
-//               step.options?.timeout,
-//             );
-//
-//             frame.output = result;
-//             frame.end = Date.now();
-//             results[step.id] = result;
-//             return result;
-//           } catch (err) {
-//             frame.error = err;
-//             frame.end = Date.now();
-//
-//             if (step.options?.onError) {
-//               const fallback = step.options.onError(err, ctx);
-//               results[step.id] = fallback;
-//               return fallback;
-//             }
-//
-//             if (step.options?.continueOnError) {
-//               results[step.id] = undefined;
-//               return undefined;
-//             }
-//
-//             throw err;
-//           }
-//         };
-//
-//         const composed = composeObserver(observers, ctx, core);
-//         await composed();
-//
-//         for (const childId of dependents.get(stepId) ?? []) {
-//           const remaining = remainingDeps.get(childId)! - 1;
-//           remainingDeps.set(childId, remaining);
-//           if (remaining === 0) ready.push(childId);
-//         }
-//
-//         completed++;
-//       }),
-//     );
-//   }
-//
-//   if (completed !== workflow.steps.length) {
-//     throw new Error("Workflow execution failed (cycle or missing dependency)");
-//   }
-//
-//   const output: O = workflow.outputResolver
-//     ? workflow.outputResolver({
-//         input,
-//         results: results as R,
-//         context: (workflow as any).__context,
-//       })
-//     : (results as unknown as O);
-//
-//   return { results: results as R, output, extras };
-// }
 import { composeObserver } from "./observer.js";
 export function createCallHelpers() {
     return {
@@ -270,11 +39,7 @@ async function runWithRetry(actionFn, stepOptions) {
     }
     throw lastError;
 }
-export async function executeWorkflow(workflowId, workflowRegistry, actionRegistry, input, context, observers = []) {
-    const workflow = workflowRegistry[workflowId];
-    if (!workflow) {
-        throw new Error(`Workflow not found: ${String(workflowId)}`);
-    }
+export async function executeWorkflow({ workflow, actionRegistry, services, input, depsExecutors, observers = [], }) {
     const results = {};
     const extras = {};
     extras.frames = {};
@@ -335,40 +100,64 @@ export async function executeWorkflow(workflowId, workflowRegistry, actionRegist
                 stepId,
                 input,
                 results,
-                context,
                 actionRegistry,
                 extras,
                 frame,
             };
+            const stepCtx = {
+                input,
+                results,
+                ...createCallHelpers(),
+            };
+            const resolvedArgs = step.resolve?.(stepCtx);
+            frame.input = resolvedArgs;
             const core = async () => {
                 frame.attempts++;
-                const stepCtx = { input, results, context, ...createCallHelpers() };
-                // Conditional skip
+                // -----------------------------
+                // ✅ SINGLE when evaluation
+                // -----------------------------
                 if (step.when && !step.when(stepCtx)) {
+                    frame.input = undefined; // 👈 important for observer consistency
                     frame.output = undefined;
                     frame.end = Date.now();
                     frame.skipped = true;
                     results[step.id] = undefined;
                     return undefined;
                 }
-                const resolvedArgs = step.resolve?.(stepCtx);
-                frame.input = resolvedArgs;
                 // -----------------------------
                 // Subflow handling
                 // -----------------------------
                 if (step.__subflowId) {
-                    const subWorkflow = step.__subflow;
-                    const subInput = resolvedArgs;
-                    const subExecution = await executeWorkflow(step.__subflowId, workflowRegistry, actionRegistry, resolvedArgs, context, observers);
-                    // Assign output to this step
+                    const [modId, subWfId] = step.__subflowId.split(".");
+                    const exec = depsExecutors[modId];
+                    const subExecution = await exec.run(subWfId, resolvedArgs, services, observers);
+                    // const subExecution = await executeWorkflow(
+                    //   step.__subflowId,
+                    //   workflowRegistry,
+                    //   actionRegistry,
+                    //   resolvedArgs as any,
+                    //   context,
+                    //   observers,
+                    // );
                     frame.output = subExecution.output;
+                    frame.end = Date.now();
                     results[step.id] = subExecution.output;
-                    // Merge extras
                     Object.assign(extras, subExecution.extras);
                     return subExecution.output;
                 }
+                // -----------------------------
+                // Normal action
+                // -----------------------------
                 const actionFn = async () => {
-                    const action = actionRegistry[step.action];
+                    let action = null;
+                    if (step.action === "__service__") {
+                        const { service, method } = step.serviceCall;
+                        action = services[service][method];
+                    }
+                    else {
+                        action = actionRegistry[step.action];
+                    }
+                    console.log("action", action);
                     return await runAction(resolvedArgs, action);
                 };
                 try {
@@ -411,7 +200,6 @@ export async function executeWorkflow(workflowId, workflowRegistry, actionRegist
         ? workflow.outputResolver({
             input,
             results,
-            context: workflow.__context,
         })
         : results;
     return {

package/dist/workflow-module.d.ts

@@ -1,42 +1,47 @@
-import { ActionRegistry, WorkflowObserver } from "./types.js";
+import { ActionRegistry, ServiceRegistry, Executor, Simplify, WorkflowObserver } from "./types.js";
 import { createWorkflow, WorkflowDef } from "./workflow-composer.js";
 type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
-type EnsureWorkflowRecord<T> = T extends Record<string, WorkflowDef<any, any, any, any, any>> ? T : Record<string, WorkflowDef<any, any, any, any, any>>;
-type DepWorkflows<Deps extends ModuleMap> = keyof Deps extends never ? {} : EnsureWorkflowRecord<UnionToIntersection<{
+type EnsureWorkflowShape<T> = {
+    [K in keyof T]: T[K] extends WorkflowDef<any, any, any, any, any> ? T[K] : never;
+};
+type DepWorkflows<Deps extends ModuleMap> = keyof Deps extends never ? {} : Simplify<EnsureWorkflowShape<UnionToIntersection<{
     [D in keyof Deps & string]: {
         [K in keyof Deps[D]["workflows"] & string as `${D}.${K}`]: Deps[D]["workflows"][K];
     };
-}[keyof Deps & string]>>;
+}[keyof Deps & string]>>>;
 type WorkflowRegistry<Own extends ModuleShape, Deps extends ModuleMap> = Own & DepWorkflows<Deps>;
 type AnyWorkflow = WorkflowDef<any, any, any, any, any>;
 type ModuleShape = Record<string, AnyWorkflow>;
 type ModuleMap = Record<string, Module<any, any, any, any>>;
-type ContextFromDeps<Deps> = [keyof Deps] extends [never] ? {} : {
-    [K in keyof Deps]: Deps[K] extends Module<any, infer Ctx, any, any> ? Ctx : never;
-}[keyof Deps];
-type FinalContext<Reg extends ActionRegistry, Context extends Record<string, any>, Deps extends ModuleMap> = Context & ContextFromDeps<Deps>;
+type FinalServices<S extends ServiceRegistry, Deps extends ModuleMap> = S & ServicesFromDepsRecursive<Deps>;
+type ServicesFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
+    never
+] ? {} : UnionToIntersection<{
+    [K in keyof Deps]: Deps[K] extends Module<any, infer S, any, infer SubDeps> ? S & ServicesFromDepsRecursive<SubDeps> : never;
+}[keyof Deps]>;
 export type WorkflowInput<W> = W extends WorkflowDef<any, infer I, any, any, any> ? I : never;
 export type WorkflowResults<W> = W extends WorkflowDef<any, any, infer R, any, any> ? R : never;
 export type WorkflowOutput<W> = W extends WorkflowDef<any, any, any, any, infer O> ? O : never;
-type Module<Reg extends ActionRegistry, Context extends Record<string, any>, Own extends ModuleShape, Deps extends ModuleMap> = {
+type Module<Reg extends ActionRegistry, S extends ServiceRegistry, Own extends ModuleShape, Deps extends ModuleMap> = {
     workflows: Own;
+    __getExecutor: () => Executor;
     createRuntime: (config: {
-        registry: Reg;
-        context: FinalContext<Reg, Context, Deps>;
+        services: FinalServices<S, Deps>;
     }) => {
         run: <K extends keyof WorkflowRegistry<Own, Deps>>(workflow: K, input: WorkflowInput<WorkflowRegistry<Own, Deps>[K]>, observers?: WorkflowObserver<Reg>[]) => Promise<{
             output: WorkflowOutput<WorkflowRegistry<Own, Deps>[K]>;
             extras: Record<string, any>;
         }>;
-        getContext: () => FinalContext<Reg, Context, Deps>;
+        getServices: () => FinalServices<S, Deps>;
     };
 };
-export type ModuleContext<Reg extends ActionRegistry, WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, Context extends Record<string, any>> = {
-    wf: ReturnType<typeof createWorkflow<Reg, WFReg, Context>>;
-    context: Context;
+type ModuleContext<Reg extends ActionRegistry, WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, S extends ServiceRegistry> = {
+    wf: ReturnType<typeof createWorkflow<Reg, WFReg, S>>;
+    services: S;
 };
-export declare function createModuleFactory<Reg extends ActionRegistry, Context extends Record<string, any>>(): <Use extends ModuleMap = {}, Own extends ModuleShape = {}>(config: {
+export declare function createModuleFactory<S extends ServiceRegistry>(): <Reg extends ActionRegistry = Record<string, any>, Use extends ModuleMap = {}, Own extends ModuleShape = {}>(config: {
+    actionRegistry: Reg;
     use?: Use;
-    define: (ctx: ModuleContext<Reg, DepWorkflows<Use>, Context>) => Own;
-}) => Module<Reg, Context, Own, Use>;
+    define: (ctx: ModuleContext<typeof config.actionRegistry, DepWorkflows<Use>, S>) => Own;
+}) => Module<Reg, S, Own, Use>;
 export {};