@pogodisco/zephyr 1.4.1 → 1.5.0

package/dist/index.d.ts

@@ -3,8 +3,6 @@ export * from "./registry.js";
 export * from "./workflow-executor.js";
 export * from "./workflow-composer.js";
 export * from "./workflow-module.js";
-export * from "./utils.js";
 export * from "./types.js";
-export * from "./utils.js";
 export * from "./session.js";
 export { useMetrics, useLog } from "./observer.js";

package/dist/index.js

@@ -3,8 +3,6 @@ export * from "./registry.js";
 export * from "./workflow-executor.js";
 export * from "./workflow-composer.js";
 export * from "./workflow-module.js";
-export * from "./utils.js";
 export * from "./types.js";
-export * from "./utils.js";
 export * from "./session.js";
 export { useMetrics, useLog } from "./observer.js";

package/dist/observer.js

@@ -15,16 +15,17 @@ export function composeObserver(middleware, ctx, core) {
 export function useLog() {
     return async ({ frame, stepId }, next) => {
         eventStream.emit({
-            type: "node_start",
-            node: stepId,
+            stepId: frame.stepId,
+            state: "start",
+            start: frame.start,
             timestamp: frame.start,
             input: frame.input,
         });
         try {
             const res = await next();
             eventStream.emit({
-                type: "node_success",
-                node: stepId,
+                id: frame.stepId,
+                state: frame.skipped ? "skipped" : "success",
                 output: frame.output,
                 duration: frame.end - frame.start,
                 attempts: frame.attempts,
@@ -34,11 +35,11 @@ export function useLog() {
         }
         catch (err) {
             eventStream.emit({
-                type: "node_fail",
-                node: stepId,
+                ...frame,
+                state: "fail",
                 error: frame.error,
                 timestamp: Date.now(),
-                attempts: frame.attempts,
+                // attempts: frame.attempts,
             });
             throw err;
         }

package/dist/types.d.ts

@@ -26,3 +26,9 @@ export type WorkflowObserver<Reg extends ActionRegistry = any> = {
         frame: ExecutionFrame;
     }, next: () => Promise<any>): Promise<any>;
 };
+export interface Executor {
+    run: (wfId: string, input: Record<string, any>, services: ServiceRegistry, obsververs?: WorkflowObserver[]) => Promise<any>;
+}
+export type ServiceRegistry = Record<string, Record<string, (...args: any[]) => any>>;
+export type ServiceParams<S extends ServiceRegistry, K extends keyof S, M extends keyof S[K]> = Parameters<S[K][M]>;
+export type ServiceReturn<S extends ServiceRegistry, K extends keyof S, M extends keyof S[K]> = Awaited<ReturnType<S[K][M]>>;

package/dist/utils.d.ts

@@ -1,10 +1 @@
-type AnyFn = (...args: any[]) => any;
-/**
- * For generic actions - preserves the generic parameter
- */
-export declare function genericAction<F extends AnyFn>(fn: F): <T>() => ((...args: Parameters<F>) => ReturnType<F>);
-/**
- * For fixed actions
- */
-export declare function fixedAction<F extends AnyFn>(fn: F): () => ((...args: Parameters<F>) => ReturnType<F>);
-export {};
+export declare function generateWorkflowId(name: string): string;

package/dist/utils.js

@@ -1,35 +1,6 @@
-/**
- * For generic actions - preserves the generic parameter
- */
-export function genericAction(fn) {
-    // Return a function that takes a type parameter and returns the typed function
-    return () => {
-        return fn;
-    };
+export function generateWorkflowId(name) {
+    // Short random + timestamp for practically unique ID
+    const random = Math.random().toString(36).slice(2, 10);
+    const time = Date.now().toString(36);
+    return `${name}-${time}-${random}`;
 }
-/**
- * For fixed actions
- */
-export function fixedAction(fn) {
-    return () => {
-        return fn;
-    };
-}
-// export function createRuntime<Reg extends ActionRegistry, Context>(
-//   registry: Reg,
-//   context: Context,
-// ) {
-//   return {
-//     run: async <W extends WorkflowDef<Reg, any, any, any, any>>(
-//       workflow: W,
-//       input: W extends WorkflowDef<Reg, infer I, any, any, any> ? I : never,
-//       observers?: WorkflowObserver[],
-//     ): Promise<{
-//       output: W extends WorkflowDef<Reg, any, any, any, infer O> ? O : never;
-//       results: W extends WorkflowDef<Reg, any, infer R, any, any> ? R : never;
-//       extras: Record<string, any>;
-//     }> => {
-//       return executeWorkflow(workflow, registry, input, context, observers);
-//     },
-//   };
-// }

package/dist/workflow-composer.d.ts

@@ -1,4 +1,4 @@
-import { ActionParams, ActionRegistry, ActionReturn, Simplify } from "./types.js";
+import { ActionParams, ActionRegistry, ActionReturn, ServiceParams, ServiceRegistry, ServiceReturn, Simplify } from "./types.js";
 type NormalizedCall = {
     kind: "none";
 } | {
@@ -40,17 +40,22 @@ type WorkflowOutput<T> = T extends WorkflowDef<any, any, any, any, infer O> ? un
 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 ServiceStepResultFromResolve<S extends ServiceRegistry, SK extends keyof S, MK extends keyof S[SK], R extends ResolvedStepInput> = R extends {
+    kind: "loop";
+} ? ServiceReturn<S, SK, MK>[] : ServiceReturn<S, SK, MK>;
 export type StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
     id: ID;
-    action: ActionName;
+    action: ActionName | "__service__";
     dependsOn: string[];
     resolve: (ctx: any) => ResolvedStepInput;
     when?: (ctx: any) => boolean;
-    options?: StepOptions<any, any, any>;
+    options?: StepOptions<any, any>;
     __subflowId?: string;
+    serviceCall?: ServiceCall;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
     name: string;
+    _id: string;
     steps: Steps;
     entrySteps: StepDef<Reg>[];
     endSteps: StepDef<Reg>[];
@@ -58,27 +63,30 @@ export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extend
     results: Results;
     outputResolver?: (ctx: any) => Output;
 };
-type StepRuntimeCtx<I, R, C> = {
+type StepRuntimeCtx<I, R> = {
     input: I;
     results: R;
-    context: C;
 };
-type StepOptions<Input, Results, Context> = {
+type StepOptions<Input, Results> = {
     retry?: number;
     retryDelay?: number | ((attempt: number) => number);
     timeout?: number;
     continueOnError?: boolean;
-    onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results, Context>) => any;
+    onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results>) => any;
     label?: string;
     meta?: Record<string, any>;
 };
-type MergeBranchResults<Branches extends readonly any[], Acc> = Branches extends readonly [infer Head, ...infer Tail] ? MergeBranchResults<Tail, Acc & (Head extends WorkflowBuilder<any, any, any, any, any, infer R> ? R : {})> : Acc;
+type ServiceCall = {
+    service: string;
+    method: string;
+};
+type MergeBranchResults<Branches extends readonly any[], Acc> = Branches extends readonly [infer Head, ...infer Tail] ? MergeBranchResults<Tail, Acc & (Head extends WorkflowBuilder<any, any, any, any, any, infer Results> ? Results : {})> : 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, any, infer S, any> ? S : [])
+    ...(Head extends WorkflowBuilder<any, any, any, any, infer Steps, any> ? Steps : [])
 ]> : Acc;
-export declare class WorkflowBuilder<Reg extends ActionRegistry, WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, //
-Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
+export declare class WorkflowBuilder<Reg extends ActionRegistry, Services extends ServiceRegistry, WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, //
+Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
     private name;
     private steps;
     private frontier;
@@ -89,8 +97,7 @@ Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [],
     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, WFReg, Input, Context, [
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Simplify<Results & {
@@ -99,41 +106,67 @@ Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [],
     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>): WorkflowBuilder<Reg, WFReg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
-    as<NewType>(): WorkflowBuilder<Reg, WFReg, Input, Context, Steps, Steps extends [...infer Rest, infer Last] ? Last extends StepDef<Reg, infer ID, any> ? Simplify<Omit<Results, ID> & {
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
+    service<ID extends string, SK extends keyof Services & string, MK extends keyof Services[SK] & string, ResolveOut extends NormalizedCall = NormalizedCall>(id: ID, service: SK, method: MK, resolve?: (ctx: {
+        input: Input;
+        results: Results;
+    } & {
+        args: (...args: ServiceParams<Services, SK, MK>) => {
+            kind: "positional";
+            args: ServiceParams<Services, SK, MK>;
+        };
+        obj: ServiceParams<Services, SK, MK> extends [infer A] ? (arg: A) => {
+            kind: "object";
+            args: A;
+        } : never;
+        none: () => {
+            kind: "none";
+        };
+        loop: (items: {
+            kind: "positional";
+            args: ServiceParams<Services, SK, MK>;
+        }[] | {
+            kind: "object";
+            args: ServiceParams<Services, SK, MK>[0];
+        }[]) => {
+            kind: "loop";
+            items: typeof items;
+        };
+    }) => ResolveOut): WorkflowBuilder<Reg, Services, WFReg, Input, [
+        ...Steps,
+        StepDef<Reg, ID, any>
+    ], Simplify<Results & {
+        [K in ID]: ServiceStepResultFromResolve<Services, SK, MK, ResolveOut>;
+    }>>;
+    as<NewType>(): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Steps extends [...infer Rest, infer Last] ? Last extends StepDef<Reg, infer ID, any> ? Simplify<Omit<Results, ID> & {
         [K in ID]: NewType;
     }> : Results : Results, Output>;
-    parallel<Branches extends readonly WorkflowBuilder<Reg, WFReg, Input, Context, any, any>[]>(...branches: {
-        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, WFReg, Input, Context, [], Results>) => Branches[K];
-    }): WorkflowBuilder<Reg, WFReg, Input, Context, MergeBranchSteps<Branches, Steps>, Simplify<MergeBranchResults<Branches, Results>>>;
+    parallel<Branches extends readonly WorkflowBuilder<Reg, Services, WFReg, Input, any, any>[]>(...branches: {
+        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Services, WFReg, Input, [], Results>) => Branches[K];
+    }): WorkflowBuilder<Reg, Services, WFReg, Input, MergeBranchSteps<Branches, Steps>, Simplify<MergeBranchResults<Branches, Results>>>;
     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>): WorkflowBuilder<Reg, WFReg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
     subflow<Prefix extends string, K extends keyof WFReg & string>(prefix: Prefix, workflowKey: K, resolveInput: (ctx: {
         input: Input;
         results: Results;
-        context: Context;
-    }) => WorkflowInput<WFReg[K]>, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, WFReg, Input, Context, Steps, Results & {
+    }) => WorkflowInput<WFReg[K]>, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results & {
         [P in Prefix]: WorkflowOutput<WFReg[K]>;
     }>;
     when(predicate: (ctx: {
         input: Input;
         results: Results;
-        context: Context;
-    }) => boolean): WorkflowBuilder<Reg, WFReg, Input, Context, Steps, Results, Output>;
+    }) => boolean): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results, Output>;
     endWhen(): this;
     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, WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, // 👈 NEW
-Context extends Record<string, any> = {}>(): <Input = unknown>(name: string) => WorkflowBuilder<Reg, WFReg, Input, Context, [], {}, undefined>;
+Services extends ServiceRegistry>(): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Services, WFReg, Input, [], {}, undefined>;
 export {};