@pogodisco/zephyr 1.3.4 → 1.3.6

package/dist/index.d.ts

@@ -8,4 +8,4 @@ export * from "./types.js";
 export * from "./utils.js";
 export * from "./node/index.js";
 export * from "./session.js";
-export { useMetrics, useLog } from "./middleware.js";
+export { useMetrics, useLog } from "./observer.js";

package/dist/index.js

@@ -8,4 +8,4 @@ export * from "./types.js";
 export * from "./utils.js";
 export * from "./node/index.js";
 export * from "./session.js";
-export { useMetrics, useLog } from "./middleware.js";
+export { useMetrics, useLog } from "./observer.js";

package/dist/observer.d.ts

@@ -0,0 +1,4 @@
+import { ActionRegistry, WorkflowObserver } from "./types.js";
+export declare function composeObserver<Reg extends ActionRegistry>(middleware: WorkflowObserver<Reg>[], ctx: Parameters<WorkflowObserver<Reg>>[0], core: () => Promise<any>): () => Promise<any>;
+export declare function useLog(): WorkflowObserver;
+export declare function useMetrics(): WorkflowObserver;

package/dist/observer.js

@@ -0,0 +1,69 @@
+import { eventStream } from "./event-stream.js";
+export function composeObserver(middleware, ctx, core) {
+    let index = -1;
+    async function dispatch(i) {
+        if (i <= index)
+            throw new Error("next() called multiple times");
+        index = i;
+        const fn = middleware[i];
+        if (!fn)
+            return core();
+        return fn(ctx, () => dispatch(i + 1));
+    }
+    return () => dispatch(0);
+}
+export function useLog() {
+    return async ({ frame, stepId }, next) => {
+        eventStream.emit({
+            type: "node_start",
+            node: stepId,
+            timestamp: frame.start,
+            input: frame.input,
+        });
+        try {
+            const res = await next();
+            eventStream.emit({
+                type: "node_success",
+                node: stepId,
+                output: frame.output,
+                duration: frame.end - frame.start,
+                attempts: frame.attempts,
+                timestamp: Date.now(),
+            });
+            return res;
+        }
+        catch (err) {
+            eventStream.emit({
+                type: "node_fail",
+                node: stepId,
+                error: frame.error,
+                timestamp: Date.now(),
+                attempts: frame.attempts,
+            });
+            throw err;
+        }
+    };
+}
+export function useMetrics() {
+    return async ({ stepId, extras }, next) => {
+        if (!extras?.metrics) {
+            extras.metrics = {};
+        }
+        const start = Date.now();
+        try {
+            const res = await next();
+            extras.metrics[stepId] = {
+                status: "success",
+                duration: Date.now() - start,
+            };
+            return res;
+        }
+        catch (err) {
+            extras.metrics[stepId] = {
+                status: "fail",
+                duration: Date.now() - start,
+            };
+            throw err;
+        }
+    };
+}

package/dist/registry.js

@@ -1,43 +1,3 @@
-// import { Action, ActionRegistry, MergeActionRegistries } from "./types.js";
-//
-// export class ActionRegistryBuilder<R extends ActionRegistry = {}> {
-//   private registry: Partial<R> = {};
-//
-//   constructor(initial?: R) {
-//     if (initial) {
-//       this.registry = { ...initial };
-//     }
-//   }
-//
-//   action<K extends string, I, O>(
-//     key: K,
-//     action: Action<I, O>,
-//   ): ActionRegistryBuilder<MergeActionRegistries<R, Record<K, Action<I, O>>>> {
-//     (this.registry as any)[key] = action;
-//     return this as any;
-//   }
-//
-//   // Extend with another registry (with override)
-//   extend<Other extends ActionRegistry>(
-//     other: ActionRegistryBuilder<Other> | Other,
-//   ): ActionRegistryBuilder<MergeActionRegistries<R, Other>> {
-//     const otherRegistry =
-//       other instanceof ActionRegistryBuilder ? other.build() : other;
-//
-//     Object.assign(this.registry, otherRegistry);
-//     return this as any;
-//   }
-//
-//   build(): R {
-//     return this.registry as R;
-//   }
-// }
-//
-// export function createActionRegistry<R extends ActionRegistry = {}>(
-//   initial?: R,
-// ): ActionRegistryBuilder<R> {
-//   return new ActionRegistryBuilder(initial);
-// }
 export class ActionRegistryBuilder {
     constructor(initial) {
         this.registry = {};

package/dist/session.d.ts

@@ -1,4 +1,4 @@
-import { ActionRegistry, WorkflowMiddleware } from "./types.js";
+import { ActionRegistry, WorkflowObserver } from "./types.js";
 import { WorkflowDef } from "./workflow-composer.js";
 type ModuleFlows<Reg extends ActionRegistry> = Record<string, WorkflowDef<Reg, any, any>>;
 export declare class WorkflowSession<Reg extends ActionRegistry, State extends Record<string, any>> {
@@ -7,14 +7,14 @@ export declare class WorkflowSession<Reg extends ActionRegistry, State extends R
     private running;
     private queue;
     state: State;
-    middleware: WorkflowMiddleware[];
+    observers: WorkflowObserver[];
     private moduleFlows;
     /**
      * @param baseModule Module to extend (inherits workflows)
      * @param registry Action registry
      * @param initialContext Initial context (session state) — will be mutated in workflows
      */
-    constructor(baseModule: ModuleFlows<Reg>, registry: Reg, initialContext: State, middleware: WorkflowMiddleware[]);
+    constructor(baseModule: ModuleFlows<Reg>, registry: Reg, initialContext: State, observers: WorkflowObserver[]);
     getState(): State;
     subscribe(fn: (state: Partial<State>) => void): () => boolean;
     private notify;

package/dist/session.js

@@ -6,15 +6,15 @@ export class WorkflowSession {
      * @param registry Action registry
      * @param initialContext Initial context (session state) — will be mutated in workflows
      */
-    constructor(baseModule, registry, initialContext, middleware) {
+    constructor(baseModule, registry, initialContext, observers) {
         this.registry = registry;
         this.subscribers = new Set();
         this.running = false;
         this.queue = [];
-        this.middleware = [];
+        this.observers = [];
         // Use the same object for session state and module context
         this.state = initialContext;
-        this.middleware = middleware;
+        this.observers = observers;
         // Per-session module: inherits workflows, shares the same state/context object
         this.moduleFlows = createModule({
             registry: this.registry,
@@ -49,7 +49,7 @@ export class WorkflowSession {
             if (!workflow)
                 throw new Error(`Workflow ${String(key)} not found`);
             // state/context already lives on the module; no need to pass a separate context
-            await executeWorkflow(workflow, this.registry, input, this.middleware);
+            await executeWorkflow(workflow, this.registry, input, this.observers);
             // Notify subscribers after workflow mutates state
             this.notify();
         }

package/dist/types.d.ts

@@ -14,7 +14,7 @@ export type ExecutionFrame = {
 };
 export type ActionParams<Reg, K extends keyof Reg> = Reg[K] extends (...args: infer P) => any ? P : never;
 export type ActionReturn<Reg, K extends keyof Reg> = Reg[K] extends (...args: any[]) => infer R ? Awaited<R> : never;
-export type WorkflowMiddleware<Reg extends ActionRegistry = any> = {
+export type WorkflowObserver<Reg extends ActionRegistry = any> = {
     (ctx: {
         stepId: string;
         input: any;

package/dist/types.js

@@ -1,47 +1 @@
-// import { createWorkflow } from "./workflow-composer.js";
-//
-// export type Action<I = any, O = any> = (args: I) => Promise<O>;
-//
-// export interface ActionRegistry {
-//   [key: string]: Action;
-// }
-//
-// export type MergeActionRegistries<
-//   A extends ActionRegistry,
-//   B extends ActionRegistry,
-// > = Omit<A, keyof B> & B;
-//
-// export type ExecutionFrame = {
-//   stepId: string;
-//   attempts: number;
-//   start: number;
-//   end?: number;
-//   input?: any;
-//   output?: any;
-//   error?: any;
-// };
-//
-// export type WorkflowMiddleware<Reg extends ActionRegistry = any> = {
-//   (
-//     ctx: {
-//       stepId: string;
-//       input: any;
-//       results: Record<string, any>;
-//       registry: Reg;
-//       extras: Record<string, any>;
-//       frame: ExecutionFrame;
-//     },
-//     next: () => Promise<any>,
-//   ): Promise<any>;
-// };
-//
-// export type WF<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any>,
-// > = ReturnType<typeof createWorkflow<Reg, Context>>;
-// // TODO: this needs enforcing
-// type Observer = (
-//   frame: Readonly<ExecutionFrame>,
-//   extras: Record<string, any>,
-// ) => void | Promise<void>;
 export {};

package/dist/utils.js

@@ -1,44 +1,3 @@
-// import { defineNode, execNode } from "./node/main.js";
-// import { TaskMap, TaskNodeWithContracts, TasksFromFns } from "./node/types.js";
-//
-// export function createAction<
-//   FN extends (args: any) => any, // Allow sync or async
-//   Out = Awaited<ReturnType<FN>>, // Unwrap Promise if present
-// >(fn: FN) {
-//   // Just return the raw node definition, not wrapped with useNode
-//   return defineNode<TasksFromFns<{ run: FN }>, Parameters<FN>[0], Out>({
-//     run: {
-//       fn, // Function can throw or return data
-//       argMap: (r) => r._init,
-//     },
-//     _output: (r) => r.run as Out,
-//   });
-// }
-//
-// export function genericAction<FN extends (args: any) => any>(fn: FN) {
-//   return <T = Awaited<ReturnType<FN>>>() => useAction(createAction<FN, T>(fn));
-// }
-//
-// export function fixedAction<
-//   FN extends (args: any) => any,
-//   T = Awaited<ReturnType<FN>>,
-// >(fn: FN): () => (args: Parameters<FN>[0]) => Promise<T> {
-//   return () => useAction(createAction<FN, T>(fn));
-// }
-//
-// export function useAction<
-//   T extends TaskMap,
-//   I extends Record<string, any> | undefined,
-//   O,
-// >(node: TaskNodeWithContracts<T, I, O>) {
-//   // Returns a function that graph can call, but WITHOUT withResponse
-//   // Just a simple adapter that calls callNode and returns raw _output
-//   return async (initArgs: I): Promise<O> => {
-//     const result = await execNode(node, initArgs);
-//     return result._output; // Just raw data, throws on error
-//   };
-// }
-//
 /**
  * For generic actions - preserves the generic parameter
  */

package/dist/workflow-composer.d.ts

@@ -1,11 +1,52 @@
-import { ActionRegistry, ActionParams, ActionReturn } from "./types.js";
+import { ActionParams, ActionRegistry, ActionReturn } from "./types.js";
+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;
+    };
+};
 type SubflowResult<SubResults, SubOutput> = SubOutput extends undefined ? SubResults : SubOutput;
-type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg> = ActionReturn<Reg, ActionName>;
+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>;
 export type StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
     id: ID;
     action: ActionName;
     dependsOn: string[];
-    resolve: (ctx: any) => ActionParams<Reg, ActionName>;
+    resolve: (ctx: any) => ResolvedStepInput;
     when?: (ctx: any) => boolean;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
@@ -27,53 +68,45 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     private frontier;
     private outputResolver?;
     constructor(name: string, registry: Reg, context: Context);
-    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
+    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;
-    }) => undefined : (ctx: {
-        input: Input;
-        results: Results;
-        context: Context;
-    }) => ActionParams<Reg, ActionName>, dependsOn?: string[]): WorkflowBuilder<Reg, Input, Context, [
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: {}): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Results & {
-        [K in ID]: StepResult<Reg, ActionName>;
+        [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>;
     }>;
-    seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
-        input: Input;
-        results: Results;
-        context: Context;
-    }) => undefined : (ctx: {
+    seq<ID extends string, ActionName extends keyof Reg & string, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => ActionParams<Reg, ActionName>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: ActionReturn<Reg, ActionName>; }, undefined>;
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: {}): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
     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, 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?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
+    join<ID extends string, ActionName extends keyof Reg & string, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => undefined : (ctx: {
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: {}): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
+    subflow<Prefix extends string, SubSteps extends StepDef<Reg, any, any>[], WF extends WorkflowDef<Reg, any, any, SubSteps, any>>(prefix: Prefix, workflow: WF, resolveInput: WorkflowInput<WF> extends undefined ? ((ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => ActionParams<Reg, ActionName>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: ActionReturn<Reg, ActionName>; }, undefined>;
-    subflow<Prefix extends string, SubInput, SubResults, SubSteps extends StepDef<Reg, any, any>[], SubOutput>(prefix: Prefix, workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps, SubOutput>, resolveInput?: (ctx: {
+    }) => WorkflowInput<WF>) | undefined : (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => [SubInput] extends [never] ? any : SubInput & Record<Exclude<keyof SubInput, keyof any>, never>): WorkflowBuilder<Reg, Input, Context, [
+    }) => WorkflowInput<WF>, options?: {}): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
-        ...SubSteps
+        ...WF["steps"]
     ], Results & {
-        [K in Prefix]: SubflowResult<SubResults, SubOutput>;
+        [K in Prefix]: SubflowResult<WorkflowResults<WF>, WorkflowOutput<WF>>;
     }>;
     when(predicate: (ctx: {
         input: Input;