@pogodisco/zephyr 1.5.4 → 1.5.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +1 -0
- package/dist/index.js +1 -0
- package/dist/utils.d.ts +3 -0
- package/dist/utils.js +15 -0
- package/dist/workflow-composer.d.ts +1 -1
- package/dist/workflow-executor.js +34 -2
- package/dist/workflow-module.d.ts +9 -6
- package/dist/workflow-module.js +305 -5
- package/package.json +1 -1
package/dist/index.d.ts
CHANGED
|
@@ -3,6 +3,7 @@ export * from "./registry.js";
|
|
|
3
3
|
export * from "./workflow-executor.js";
|
|
4
4
|
export * from "./workflow-composer.js";
|
|
5
5
|
export * from "./workflow-module.js";
|
|
6
|
+
export { exposeAll, exposeAllAs } from "./utils.js";
|
|
6
7
|
export * from "./types.js";
|
|
7
8
|
export * from "./session.js";
|
|
8
9
|
export { useMetrics, useLog } from "./observer.js";
|
package/dist/index.js
CHANGED
|
@@ -3,6 +3,7 @@ export * from "./registry.js";
|
|
|
3
3
|
export * from "./workflow-executor.js";
|
|
4
4
|
export * from "./workflow-composer.js";
|
|
5
5
|
export * from "./workflow-module.js";
|
|
6
|
+
export { exposeAll, exposeAllAs } from "./utils.js";
|
|
6
7
|
export * from "./types.js";
|
|
7
8
|
export * from "./session.js";
|
|
8
9
|
export { useMetrics, useLog } from "./observer.js";
|
package/dist/utils.d.ts
CHANGED
|
@@ -1 +1,4 @@
|
|
|
1
|
+
import { Module } from "./workflow-module.js";
|
|
1
2
|
export declare function generateWorkflowId(name: string): string;
|
|
3
|
+
export declare function exposeAll<Name extends string, M extends Module<any, any, any, any>>(name: Name, mod: M): Record<`${Name}.${keyof M["workflows"] & string}`, `${Name}.${keyof M["workflows"] & string}`>;
|
|
4
|
+
export declare function exposeAllAs<Name extends string, M extends Module<any, any, any, any>>(name: Name, mod: M): Record<keyof M["workflows"] & string, `${Name}.${keyof M["workflows"] & string}`>;
|
package/dist/utils.js
CHANGED
|
@@ -3,3 +3,18 @@ export function generateWorkflowId(name) {
|
|
|
3
3
|
const time = Date.now().toString(36);
|
|
4
4
|
return `${name}-${time}-${random}`;
|
|
5
5
|
}
|
|
6
|
+
export function exposeAll(name, mod) {
|
|
7
|
+
const result = {};
|
|
8
|
+
for (const key in mod.workflows) {
|
|
9
|
+
const full = `${name}.${key}`;
|
|
10
|
+
result[full] = full;
|
|
11
|
+
}
|
|
12
|
+
return result;
|
|
13
|
+
}
|
|
14
|
+
export function exposeAllAs(name, mod) {
|
|
15
|
+
const result = {};
|
|
16
|
+
for (const key in mod.workflows) {
|
|
17
|
+
result[key] = `${name}.${key}`;
|
|
18
|
+
}
|
|
19
|
+
return result;
|
|
20
|
+
}
|
|
@@ -91,7 +91,7 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
|
|
|
91
91
|
pipe<ID extends string, Arr extends any[], PB extends PipeBuilder<any, Reg, Services, Results, any>>(id: ID, input: (ctx: {
|
|
92
92
|
input: Input;
|
|
93
93
|
results: Results;
|
|
94
|
-
}) => Arr, builder: (p: PipeBuilder<Arr[number], Reg, Services, Results>) => PB, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
|
|
94
|
+
} & Results) => Arr, builder: (p: PipeBuilder<Arr[number], Reg, Services, Results>) => PB, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
|
|
95
95
|
...Steps,
|
|
96
96
|
StepDef<Reg, ID, any>
|
|
97
97
|
], Simplify<Results & {
|
|
@@ -148,11 +148,43 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
|
|
|
148
148
|
const pipeResults = await Promise.all(items.map(async (item) => {
|
|
149
149
|
let current = item;
|
|
150
150
|
for (const pipeStep of step.pipe.steps) {
|
|
151
|
-
|
|
151
|
+
// return new Proxy(
|
|
152
|
+
// {
|
|
153
|
+
// input,
|
|
154
|
+
// results,
|
|
155
|
+
// ...helpers,
|
|
156
|
+
// },
|
|
157
|
+
// {
|
|
158
|
+
// get(target, prop) {
|
|
159
|
+
// // 1. explicit keys first
|
|
160
|
+
// if (prop in target) return target[prop as keyof typeof target];
|
|
161
|
+
//
|
|
162
|
+
// // 2. fallback to results
|
|
163
|
+
// if (prop in results) return results[prop as keyof typeof target];
|
|
164
|
+
//
|
|
165
|
+
// return undefined;
|
|
166
|
+
// },
|
|
167
|
+
// },
|
|
168
|
+
// );
|
|
169
|
+
// }
|
|
170
|
+
// const pipeCtx = {
|
|
171
|
+
// current,
|
|
172
|
+
// results,
|
|
173
|
+
// ...createCallHelpers(),
|
|
174
|
+
// };
|
|
175
|
+
const pipeCtx = new Proxy({
|
|
152
176
|
current,
|
|
153
177
|
results,
|
|
154
178
|
...createCallHelpers(),
|
|
155
|
-
}
|
|
179
|
+
}, {
|
|
180
|
+
get(target, prop) {
|
|
181
|
+
if (prop in target)
|
|
182
|
+
return target[prop];
|
|
183
|
+
if (prop in results)
|
|
184
|
+
return results[prop];
|
|
185
|
+
return undefined;
|
|
186
|
+
},
|
|
187
|
+
});
|
|
156
188
|
const resolved = pipeStep.resolve(pipeCtx);
|
|
157
189
|
let action;
|
|
158
190
|
if (pipeStep.type === "action") {
|
|
@@ -9,7 +9,6 @@ type DepWorkflows<Deps extends ModuleMap> = keyof Deps extends never ? {} : Simp
|
|
|
9
9
|
[K in keyof Deps[D]["workflows"] & string as `${D}.${K}`]: Deps[D]["workflows"][K];
|
|
10
10
|
};
|
|
11
11
|
}[keyof Deps & string]>>>;
|
|
12
|
-
type WorkflowRegistry<Own extends ModuleShape, Deps extends ModuleMap> = Own & DepWorkflows<Deps>;
|
|
13
12
|
type AnyWorkflow = WorkflowDef<any, any, any, any, any>;
|
|
14
13
|
type ModuleShape = Record<string, AnyWorkflow>;
|
|
15
14
|
type ModuleMap = Record<string, Module<any, any, any, any>>;
|
|
@@ -22,14 +21,14 @@ type ServicesFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
|
|
|
22
21
|
export type WorkflowInput<W> = W extends WorkflowDef<any, infer I, any, any, any> ? I : never;
|
|
23
22
|
export type WorkflowResults<W> = W extends WorkflowDef<any, any, infer R, any, any> ? R : never;
|
|
24
23
|
export type WorkflowOutput<W> = W extends WorkflowDef<any, any, any, any, infer O> ? O : never;
|
|
25
|
-
type Module<Reg extends ActionRegistry, S extends ServiceRegistry, Own extends ModuleShape, Deps extends ModuleMap> = {
|
|
24
|
+
export type Module<Reg extends ActionRegistry, S extends ServiceRegistry, Own extends ModuleShape, Deps extends ModuleMap, Public extends ModuleShape = Own> = {
|
|
26
25
|
workflows: Own;
|
|
27
26
|
__getExecutor: () => Executor;
|
|
28
27
|
createRuntime: (config: {
|
|
29
28
|
services: FinalServices<S, Deps>;
|
|
30
29
|
}) => {
|
|
31
|
-
run: <K extends keyof
|
|
32
|
-
output: WorkflowOutput<
|
|
30
|
+
run: <K extends keyof Public>(workflow: K, input: WorkflowInput<Public[K]>, observers?: WorkflowObserver<Reg>[]) => Promise<{
|
|
31
|
+
output: WorkflowOutput<Public[K]>;
|
|
33
32
|
extras: Record<string, any>;
|
|
34
33
|
}>;
|
|
35
34
|
getServices: () => FinalServices<S, Deps>;
|
|
@@ -39,9 +38,13 @@ type ModuleContext<Reg extends ActionRegistry, WFReg extends Record<string, Work
|
|
|
39
38
|
wf: ReturnType<typeof createWorkflow<Reg, WFReg, S>>;
|
|
40
39
|
services: S;
|
|
41
40
|
};
|
|
42
|
-
|
|
41
|
+
type ExposedWorkflows<Own extends ModuleShape, Use extends ModuleMap, Expose extends Record<string, keyof DepWorkflows<Use>> | undefined> = Own & (Expose extends Record<string, keyof DepWorkflows<Use>> ? {
|
|
42
|
+
[K in keyof Expose]: DepWorkflows<Use>[Expose[K]];
|
|
43
|
+
} : {});
|
|
44
|
+
export declare function createModuleFactory<S extends ServiceRegistry>(): <Reg extends ActionRegistry = Record<string, any>, Use extends ModuleMap = {}, Own extends ModuleShape = {}, Expose extends Record<string, keyof DepWorkflows<Use>> | undefined = undefined>(config: {
|
|
43
45
|
actionRegistry: Reg;
|
|
44
46
|
use?: Use;
|
|
47
|
+
expose?: Expose;
|
|
45
48
|
define: (ctx: ModuleContext<typeof config.actionRegistry, DepWorkflows<Use>, S>) => Own;
|
|
46
|
-
}) => Module<Reg, S, Own, Use
|
|
49
|
+
}) => Module<Reg, S, Own, Use, ExposedWorkflows<Own, Use, Expose>>;
|
|
47
50
|
export {};
|
package/dist/workflow-module.js
CHANGED
|
@@ -1,21 +1,316 @@
|
|
|
1
|
-
import {
|
|
1
|
+
// import {
|
|
2
|
+
// ActionRegistry,
|
|
3
|
+
// ServiceRegistry,
|
|
4
|
+
// Executor,
|
|
5
|
+
// Simplify,
|
|
6
|
+
// WorkflowObserver,
|
|
7
|
+
// } from "./types.js";
|
|
8
|
+
// import { createWorkflow, WorkflowDef } from "./workflow-composer.js";
|
|
9
|
+
// import { executeWorkflow } from "./workflow-executor.js";
|
|
10
|
+
// type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (
|
|
11
|
+
// x: infer I,
|
|
12
|
+
// ) => any
|
|
13
|
+
// ? I
|
|
14
|
+
// : never;
|
|
15
|
+
// /* ------------------------------------------------ */
|
|
16
|
+
// /* WORKFLOW REGISTRY TYPES */
|
|
17
|
+
// /* ------------------------------------------------ */
|
|
18
|
+
// type EnsureWorkflowRecord<T> =
|
|
19
|
+
// T extends Record<string, WorkflowDef<any, any, any, any, any>>
|
|
20
|
+
// ? T
|
|
21
|
+
// : Record<string, WorkflowDef<any, any, any, any, any>>;
|
|
22
|
+
//
|
|
23
|
+
// type EnsureWorkflowShape<T> = {
|
|
24
|
+
// [K in keyof T]: T[K] extends WorkflowDef<any, any, any, any, any>
|
|
25
|
+
// ? T[K]
|
|
26
|
+
// : never;
|
|
27
|
+
// };
|
|
28
|
+
//
|
|
29
|
+
// type DepWorkflows<Deps extends ModuleMap> = keyof Deps extends never
|
|
30
|
+
// ? {}
|
|
31
|
+
// : Simplify<
|
|
32
|
+
// EnsureWorkflowShape<
|
|
33
|
+
// UnionToIntersection<
|
|
34
|
+
// {
|
|
35
|
+
// [D in keyof Deps & string]: {
|
|
36
|
+
// [K in keyof Deps[D]["workflows"] &
|
|
37
|
+
// string as `${D}.${K}`]: Deps[D]["workflows"][K];
|
|
38
|
+
// };
|
|
39
|
+
// }[keyof Deps & string]
|
|
40
|
+
// >
|
|
41
|
+
// >
|
|
42
|
+
// >;
|
|
43
|
+
//
|
|
44
|
+
// type WorkflowRegistry<Own extends ModuleShape, Deps extends ModuleMap> = Own &
|
|
45
|
+
// DepWorkflows<Deps>;
|
|
46
|
+
//
|
|
47
|
+
// /* ------------------------------------------------ */
|
|
48
|
+
// /* MODULE TYPES */
|
|
49
|
+
// /* ------------------------------------------------ */
|
|
50
|
+
//
|
|
51
|
+
// type AnyWorkflow = WorkflowDef<any, any, any, any, any>;
|
|
52
|
+
// type ModuleShape = Record<string, AnyWorkflow>;
|
|
53
|
+
// type ModuleMap = Record<string, Module<any, any, any, any>>;
|
|
54
|
+
//
|
|
55
|
+
// // type ContextFromDeps<Deps> = [keyof Deps] extends [never]
|
|
56
|
+
// // ? {}
|
|
57
|
+
// // : {
|
|
58
|
+
// // [K in keyof Deps]: Deps[K] extends Module<any, infer Ctx, any, any>
|
|
59
|
+
// // ? Ctx
|
|
60
|
+
// // : never;
|
|
61
|
+
// // }[keyof Deps];
|
|
62
|
+
//
|
|
63
|
+
// type FinalServices<S extends ServiceRegistry, Deps extends ModuleMap> = S &
|
|
64
|
+
// ServicesFromDepsRecursive<Deps>;
|
|
65
|
+
//
|
|
66
|
+
// // type ContextFromDeps<Deps> = [keyof Deps] extends [never]
|
|
67
|
+
// // ? {}
|
|
68
|
+
// // : UnionToIntersection<
|
|
69
|
+
// // {
|
|
70
|
+
// // [K in keyof Deps]: Deps[K] extends Module<any, infer Ctx, any, any>
|
|
71
|
+
// // ? Ctx
|
|
72
|
+
// // : never;
|
|
73
|
+
// // }[keyof Deps]
|
|
74
|
+
// // >;
|
|
75
|
+
//
|
|
76
|
+
// type ServicesFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
|
|
77
|
+
// never,
|
|
78
|
+
// ]
|
|
79
|
+
// ? {} // no deps
|
|
80
|
+
// : UnionToIntersection<
|
|
81
|
+
// {
|
|
82
|
+
// [K in keyof Deps]: Deps[K] extends Module<
|
|
83
|
+
// any,
|
|
84
|
+
// infer S,
|
|
85
|
+
// any,
|
|
86
|
+
// infer SubDeps
|
|
87
|
+
// >
|
|
88
|
+
// ? S & ServicesFromDepsRecursive<SubDeps>
|
|
89
|
+
// : never;
|
|
90
|
+
// }[keyof Deps]
|
|
91
|
+
// >;
|
|
92
|
+
//
|
|
93
|
+
// /* ------------------------------------------------ */
|
|
94
|
+
// /* WORKFLOW IO TYPES */
|
|
95
|
+
// /* ------------------------------------------------ */
|
|
96
|
+
//
|
|
97
|
+
// export type WorkflowInput<W> =
|
|
98
|
+
// W extends WorkflowDef<any, infer I, any, any, any> ? I : never;
|
|
99
|
+
//
|
|
100
|
+
// export type WorkflowResults<W> =
|
|
101
|
+
// W extends WorkflowDef<any, any, infer R, any, any> ? R : never;
|
|
102
|
+
//
|
|
103
|
+
// export type WorkflowOutput<W> =
|
|
104
|
+
// W extends WorkflowDef<any, any, any, any, infer O> ? O : never;
|
|
105
|
+
//
|
|
106
|
+
// /* ------------------------------------------------ */
|
|
107
|
+
// /* MODULE RUNTIME */
|
|
108
|
+
// /* ------------------------------------------------ */
|
|
109
|
+
//
|
|
110
|
+
// type Module<
|
|
111
|
+
// Reg extends ActionRegistry,
|
|
112
|
+
// S extends ServiceRegistry,
|
|
113
|
+
// Own extends ModuleShape,
|
|
114
|
+
// Deps extends ModuleMap,
|
|
115
|
+
// > = {
|
|
116
|
+
// workflows: Own;
|
|
117
|
+
// __getExecutor: () => Executor;
|
|
118
|
+
//
|
|
119
|
+
// createRuntime: (config: { services: FinalServices<S, Deps> }) => {
|
|
120
|
+
// run: <K extends keyof WorkflowRegistry<Own, Deps>>(
|
|
121
|
+
// workflow: K,
|
|
122
|
+
// input: WorkflowInput<WorkflowRegistry<Own, Deps>[K]>,
|
|
123
|
+
// observers?: WorkflowObserver<Reg>[],
|
|
124
|
+
// ) => Promise<{
|
|
125
|
+
// // results: WorkflowResults<WorkflowRegistry<Own, Deps>[K]>;
|
|
126
|
+
// output: WorkflowOutput<WorkflowRegistry<Own, Deps>[K]>;
|
|
127
|
+
// extras: Record<string, any>;
|
|
128
|
+
// }>;
|
|
129
|
+
//
|
|
130
|
+
// getServices: () => FinalServices<S, Deps>;
|
|
131
|
+
// };
|
|
132
|
+
// };
|
|
133
|
+
//
|
|
134
|
+
// /* ------------------------------------------------ */
|
|
135
|
+
// /* MODULE CONTEXT (FIXED) */
|
|
136
|
+
// /* ------------------------------------------------ */
|
|
137
|
+
//
|
|
138
|
+
// type ModuleContext<
|
|
139
|
+
// Reg extends ActionRegistry,
|
|
140
|
+
// WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>,
|
|
141
|
+
// S extends ServiceRegistry,
|
|
142
|
+
// > = {
|
|
143
|
+
// wf: ReturnType<typeof createWorkflow<Reg, WFReg, S>>;
|
|
144
|
+
// services: S;
|
|
145
|
+
// };
|
|
146
|
+
//
|
|
147
|
+
// function createModule<
|
|
148
|
+
// Reg extends ActionRegistry,
|
|
149
|
+
// S extends ServiceRegistry,
|
|
150
|
+
// Use extends ModuleMap,
|
|
151
|
+
// Own extends ModuleShape,
|
|
152
|
+
// >(config: {
|
|
153
|
+
// actionRegistry: Reg;
|
|
154
|
+
// use?: Use;
|
|
155
|
+
// define: (ctx: ModuleContext<Reg, DepWorkflows<Use>, S>) => Own;
|
|
156
|
+
// }): Module<Reg, S, Own, Use> {
|
|
157
|
+
// const deps = (config.use ?? {}) as Use;
|
|
158
|
+
//
|
|
159
|
+
// const wf = createWorkflow<Reg, DepWorkflows<Use>, S>();
|
|
160
|
+
//
|
|
161
|
+
// const own = config.define({
|
|
162
|
+
// wf,
|
|
163
|
+
// services: {} as S,
|
|
164
|
+
// });
|
|
165
|
+
//
|
|
166
|
+
// function buildWorkflowMap(): WorkflowRegistry<Own, Use> {
|
|
167
|
+
// const depWFs = Object.fromEntries(
|
|
168
|
+
// Object.entries(deps).flatMap(([name, mod]) =>
|
|
169
|
+
// Object.entries(mod.workflows).map(([k, wf]) => [`${name}.${k}`, wf]),
|
|
170
|
+
// ),
|
|
171
|
+
// );
|
|
172
|
+
//
|
|
173
|
+
// return { ...own, ...depWFs } as WorkflowRegistry<Own, Use>;
|
|
174
|
+
// }
|
|
175
|
+
//
|
|
176
|
+
// const workflowMap = buildWorkflowMap();
|
|
177
|
+
//
|
|
178
|
+
// const depsExecutors = Object.fromEntries(
|
|
179
|
+
// Object.entries(deps).map(([name, mod]) => [name, mod.__getExecutor()]),
|
|
180
|
+
// );
|
|
181
|
+
//
|
|
182
|
+
// const executor: Executor = {
|
|
183
|
+
// run(wfId, input, services, observers = []) {
|
|
184
|
+
// const workflow = workflowMap[wfId];
|
|
185
|
+
//
|
|
186
|
+
// if (!workflow) {
|
|
187
|
+
// throw new Error(`Workflow not found: ${String(wfId)}`);
|
|
188
|
+
// }
|
|
189
|
+
//
|
|
190
|
+
// return executeWorkflow({
|
|
191
|
+
// workflow,
|
|
192
|
+
// actionRegistry: config.actionRegistry,
|
|
193
|
+
// depsExecutors,
|
|
194
|
+
// input,
|
|
195
|
+
// services,
|
|
196
|
+
// observers,
|
|
197
|
+
// });
|
|
198
|
+
// },
|
|
199
|
+
// };
|
|
200
|
+
//
|
|
201
|
+
// return {
|
|
202
|
+
// workflows: own,
|
|
203
|
+
// __getExecutor: () => executor,
|
|
204
|
+
//
|
|
205
|
+
// createRuntime({ services }) {
|
|
206
|
+
// let runtimeActions = config.actionRegistry;
|
|
207
|
+
//
|
|
208
|
+
// // const runtimeService = createServiceRegisty(services)
|
|
209
|
+
// return {
|
|
210
|
+
// run: async <K extends keyof WorkflowRegistry<Own, Use>>(
|
|
211
|
+
// workflowId: K,
|
|
212
|
+
// input: WorkflowInput<WorkflowRegistry<Own, Use>[K]>,
|
|
213
|
+
// observers: WorkflowObserver<Reg>[] = [],
|
|
214
|
+
// ) => {
|
|
215
|
+
// return executor.run(workflowId as string, input, services, observers);
|
|
216
|
+
// },
|
|
217
|
+
// // make it same, practically nothing changes but naming, and what context holds
|
|
218
|
+
// getServices: () => ({ ...services }) as FinalServices<S, Use>,
|
|
219
|
+
//
|
|
220
|
+
// setActionRegistry(reg: Reg) {
|
|
221
|
+
// runtimeActions = reg;
|
|
222
|
+
// // ⚠️ optional: if you REALLY want override, you'd need:
|
|
223
|
+
// // executor.actions = reg
|
|
224
|
+
// // but better keep actions immutable
|
|
225
|
+
// },
|
|
226
|
+
// };
|
|
227
|
+
// },
|
|
228
|
+
// };
|
|
229
|
+
// }
|
|
230
|
+
//
|
|
231
|
+
// /* ------------------------------------------------ */
|
|
232
|
+
// /* FACTORY (FIXED) */
|
|
233
|
+
// /* ------------------------------------------------ */
|
|
234
|
+
//
|
|
235
|
+
// export function createModuleFactory<
|
|
236
|
+
// // Reg extends ActionRegistry,
|
|
237
|
+
// S extends ServiceRegistry,
|
|
238
|
+
// >() {
|
|
239
|
+
// return function <
|
|
240
|
+
// Reg extends ActionRegistry = Record<string, any>,
|
|
241
|
+
// Use extends ModuleMap = {},
|
|
242
|
+
// Own extends ModuleShape = {},
|
|
243
|
+
// >(config: {
|
|
244
|
+
// actionRegistry: Reg;
|
|
245
|
+
// use?: Use;
|
|
246
|
+
// define: (
|
|
247
|
+
// ctx: ModuleContext<typeof config.actionRegistry, DepWorkflows<Use>, S>,
|
|
248
|
+
// ) => Own;
|
|
249
|
+
// }): Module<Reg, S, Own, Use> {
|
|
250
|
+
// return createModule<Reg, S, Use, Own>(config);
|
|
251
|
+
// };
|
|
252
|
+
// }
|
|
253
|
+
import { createWorkflow, } from "./workflow-composer.js";
|
|
2
254
|
import { executeWorkflow } from "./workflow-executor.js";
|
|
3
255
|
function createModule(config) {
|
|
4
256
|
const deps = (config.use ?? {});
|
|
5
257
|
const wf = createWorkflow();
|
|
258
|
+
// const macro = createMacro<Reg, S, DepWorkflows<Use>>();
|
|
6
259
|
const own = config.define({
|
|
7
260
|
wf,
|
|
8
261
|
services: {},
|
|
9
262
|
});
|
|
263
|
+
// function buildWorkflowMap(): WorkflowRegistry<Own, Use> {
|
|
264
|
+
// const depWFs = Object.fromEntries(
|
|
265
|
+
// Object.entries(deps).flatMap(([name, mod]) =>
|
|
266
|
+
// Object.entries(mod.workflows).map(([k, wf]) => [`${name}.${k}`, wf]),
|
|
267
|
+
// ),
|
|
268
|
+
// );
|
|
269
|
+
//
|
|
270
|
+
// const internal = { ...own, ...depWFs } as WorkflowRegistry<Own, Use>;
|
|
271
|
+
//
|
|
272
|
+
// const publicMap = own;
|
|
273
|
+
// return { internal, publicMap };
|
|
274
|
+
// }
|
|
10
275
|
function buildWorkflowMap() {
|
|
11
276
|
const depWFs = Object.fromEntries(Object.entries(deps).flatMap(([name, mod]) => Object.entries(mod.workflows).map(([k, wf]) => [`${name}.${k}`, wf])));
|
|
12
|
-
|
|
277
|
+
// const internal = { ...own, ...depWFs } as WorkflowRegistry<Own, Use>;
|
|
278
|
+
// const exposed = Object.fromEntries(
|
|
279
|
+
// Object.entries(config.expose ?? {}).map(([alias, key]) => [
|
|
280
|
+
// alias,
|
|
281
|
+
// internal[key], // reuse already resolved workflow
|
|
282
|
+
// ]),
|
|
283
|
+
// );
|
|
284
|
+
//
|
|
285
|
+
const internalBase = { ...own, ...depWFs };
|
|
286
|
+
const exposed = {};
|
|
287
|
+
if (config.expose) {
|
|
288
|
+
for (const alias in config.expose) {
|
|
289
|
+
const key = config.expose[alias];
|
|
290
|
+
exposed[alias] = internalBase[key];
|
|
291
|
+
}
|
|
292
|
+
}
|
|
293
|
+
const internal = {
|
|
294
|
+
...internalBase,
|
|
295
|
+
...exposed,
|
|
296
|
+
};
|
|
297
|
+
// if (config.expose) {
|
|
298
|
+
// for (const alias in config.expose) {
|
|
299
|
+
// const key = config.expose[alias];
|
|
300
|
+
// exposed[alias] = internal[key];
|
|
301
|
+
// }
|
|
302
|
+
// }
|
|
303
|
+
const publicMap = { ...own, ...exposed };
|
|
304
|
+
return { internal, publicMap };
|
|
13
305
|
}
|
|
14
|
-
const
|
|
306
|
+
const { internal, publicMap } = buildWorkflowMap();
|
|
15
307
|
const depsExecutors = Object.fromEntries(Object.entries(deps).map(([name, mod]) => [name, mod.__getExecutor()]));
|
|
16
308
|
const executor = {
|
|
17
309
|
run(wfId, input, services, observers = []) {
|
|
18
|
-
|
|
310
|
+
if (!(wfId in publicMap)) {
|
|
311
|
+
throw new Error(`Workflow not in public: ${wfId}`);
|
|
312
|
+
}
|
|
313
|
+
const workflow = internal[wfId];
|
|
19
314
|
if (!workflow) {
|
|
20
315
|
throw new Error(`Workflow not found: ${String(wfId)}`);
|
|
21
316
|
}
|
|
@@ -36,7 +331,12 @@ function createModule(config) {
|
|
|
36
331
|
let runtimeActions = config.actionRegistry;
|
|
37
332
|
// const runtimeService = createServiceRegisty(services)
|
|
38
333
|
return {
|
|
39
|
-
run: async (
|
|
334
|
+
run: async (
|
|
335
|
+
// run: async <K extends keyof WorkflowRegistry<Own, Use>>(
|
|
336
|
+
workflowId, input,
|
|
337
|
+
// input: WorkflowInput<WorkflowRegistry<Own, Use>[K]>,
|
|
338
|
+
// input: WorkflowInput<WorkflowRegistry<Own, Use>[K]>,
|
|
339
|
+
observers = []) => {
|
|
40
340
|
return executor.run(workflowId, input, services, observers);
|
|
41
341
|
},
|
|
42
342
|
// make it same, practically nothing changes but naming, and what context holds
|