@pogodisco/zephyr 1.3.4 → 1.3.5

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/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/workflow-composer.d.ts

@@ -1,12 +1,26 @@
-import { ActionRegistry, ActionParams, ActionReturn } from "./types.js";
+import { ActionRegistry, ActionReturn } from "./types.js";
+export type NormalizedCall = {
+    kind: "none";
+} | {
+    kind: "positional";
+    args: any[];
+} | {
+    kind: "object";
+    args: any;
+};
+export type ResolvedStepInput = NormalizedCall | {
+    kind: "loop";
+    items: NormalizedCall[];
+};
 type SubflowResult<SubResults, SubOutput> = SubOutput extends undefined ? SubResults : SubOutput;
-type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg> = ActionReturn<Reg, ActionName>;
+export type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg, Loop extends boolean | undefined = undefined> = Loop extends true ? 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;
+    loop?: boolean;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
     name: string;
@@ -27,49 +41,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, Loop extends boolean | undefined = undefined>(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, [
+    }) => ResolvedStepInput, dependsOn?: string[], options?: {
+        loop?: Loop;
+    }): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Results & {
-        [K in ID]: StepResult<Reg, ActionName>;
+        [K in ID]: StepResult<Reg, ActionName, Loop>;
     }>;
-    seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
+    seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => 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>;
+    }) => ResolvedStepInput, options?: {
+        loop?: boolean;
+    }): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: ActionReturn<Reg, ActionName> | ActionReturn<Reg, ActionName>[]; }, 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?: {
-        input: Input;
-        results: Results;
-        context: Context;
-    }) => undefined : (ctx: {
+    join<ID extends string, ActionName extends keyof Reg & string>(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>;
+    }) => ResolvedStepInput, options?: {
+        loop?: boolean;
+    }): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: ActionReturn<Reg, ActionName> | 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: {
         input: Input;
         results: Results;
         context: Context;
-    }) => [SubInput] extends [never] ? any : SubInput & Record<Exclude<keyof SubInput, keyof any>, never>): WorkflowBuilder<Reg, Input, Context, [
+    }) => SubInput, options?: {
+        loop?: boolean;
+    }): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         ...SubSteps
     ], Results & {
@@ -88,6 +98,10 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     build(): WorkflowDef<Reg, Input, Results, Steps>;
     private validateDependencies;
     private getEndSteps;
+    static args: (...args: any[]) => NormalizedCall;
+    static obj: (args: any) => NormalizedCall;
+    static none: () => NormalizedCall;
+    static loop: (items: NormalizedCall[]) => ResolvedStepInput;
 }
 export declare function createWorkflow<Reg extends ActionRegistry, Context extends Record<string, any> = {}>(registry: Reg, context?: Context): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Input, Context, [], {}, undefined>;
 export {};