@oomol-lab/open-flow 0.1.0-alpha.0

package/dist/common/scheduler.d.ts

@@ -0,0 +1,99 @@
+import type { ConnectorCapability, JsonValue } from '../browser/project-change.js';
+import type { PreparedFlow } from './project-semantics.js';
+export type SchedulerEvent = {
+    readonly flowId: string;
+    readonly parentJobId?: string;
+    readonly parentRunId?: string;
+    readonly runId: string;
+    readonly type: 'run.started';
+} | {
+    readonly parentJobId?: string;
+    readonly parentRunId?: string;
+    readonly progress: number;
+    readonly runId: string;
+    readonly type: 'run.progress';
+} | {
+    readonly inputs: Readonly<Record<string, JsonValue>>;
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly nodeKind: 'condition' | 'connector' | 'javascript' | 'llm' | 'subflow' | 'value';
+    readonly nodeTitle?: string;
+    readonly runId: string;
+    readonly type: 'node.started';
+} | {
+    readonly handle: string;
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly runId: string;
+    readonly type: 'node.output';
+    readonly value: JsonValue;
+} | {
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly runId: string;
+    readonly type: 'node.completed';
+} | {
+    readonly code: string;
+    readonly jobId: string;
+    readonly message: string;
+    readonly nodeId: string;
+    readonly runId: string;
+    readonly type: 'node.failed';
+} | {
+    readonly result: FlowRunResult | SubflowRunResult;
+    readonly runId: string;
+    readonly type: 'run.completed';
+} | {
+    readonly message: string;
+    readonly runId: string;
+    readonly type: 'run.failed';
+};
+export interface FlowRunResult {
+    readonly kind: 'node-results';
+    readonly nodes: readonly {
+        readonly jobs: readonly {
+            readonly jobId: string;
+            readonly outputs: Readonly<Record<string, JsonValue>>;
+        }[];
+        readonly nodeId: string;
+    }[];
+}
+export interface SubflowRunResult {
+    readonly kind: 'function-outputs';
+    readonly outputs: Readonly<Record<string, JsonValue>>;
+    readonly target: 'subflow';
+}
+interface TaskInvocationBase {
+    readonly input: Readonly<Record<string, JsonValue>>;
+    readonly invocationId: string;
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly runId: string;
+    readonly signal: AbortSignal;
+}
+export type TaskInvocation = TaskInvocationBase & ({
+    readonly capabilities: readonly ConnectorCapability[];
+    readonly moduleId: string;
+} | {
+    readonly taskId: string;
+});
+export interface TriggerSeed {
+    readonly nodeId: string;
+    readonly payload: JsonValue;
+}
+export interface SchedulerFailure {
+    readonly code: string;
+    readonly message: string;
+}
+export interface FlowRunOptions {
+    readonly createId: () => string;
+    readonly emit?: (event: SchedulerEvent) => void | Promise<void>;
+    readonly inputs?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+    readonly invokeTask: (invocation: TaskInvocation) => Promise<unknown>;
+    readonly projectFailure?: (error: unknown) => SchedulerFailure;
+    readonly runId: string;
+    readonly signal?: AbortSignal;
+    readonly trigger?: TriggerSeed;
+}
+export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Promise<FlowRunResult>;
+export {};

package/dist/common/scheduler.js

@@ -0,0 +1,379 @@
+//#region src/execution/common/scheduler.ts
+function e(e, t) {
+	return t?.(e) ?? {
+		code: "node.failed",
+		message: e instanceof Error ? e.message : String(e)
+	};
+}
+var t = class {
+	#e = [];
+	#t = 0;
+	get length() {
+		return this.#e.length - this.#t;
+	}
+	push(e) {
+		this.#e.push(e);
+	}
+	shift() {
+		let e = this.#e[this.#t];
+		return this.#t += 1, this.#t >= 64 && this.#t * 2 >= this.#e.length && (this.#e.splice(0, this.#t), this.#t = 0), e;
+	}
+}, n = class {
+	#e;
+	#t = new t();
+	#n;
+	#r;
+	constructor(e, t, n) {
+		let r = e.inputs[t];
+		this.#e = r?.kind == "sources", this.#n = !this.#e && (r?.kind == "value" || Object.hasOwn(n, "value")), this.#r = r?.kind == "value" ? r.value : n.value ?? null;
+	}
+	get ready() {
+		return this.#t.length > 0 || this.#n;
+	}
+	get dynamic() {
+		return this.#e;
+	}
+	provide(e) {
+		this.#e || (this.#n = !0, this.#r = e);
+	}
+	push(e) {
+		this.#t.push(e);
+	}
+	take() {
+		return this.#t.length > 0 ? this.#t.shift() : this.#r;
+	}
+}, r = class {
+	#e;
+	#t;
+	#n;
+	#r = !1;
+	constructor(e, t, r) {
+		this.#t = e, this.#n = new Map(Object.entries(r).map(([e, r]) => [e, new n(t, e, r)])), this.#e = [...this.#n.values()].some((e) => e.dynamic);
+	}
+	get ready() {
+		return (!this.#r || this.#e) && [...this.#n.values()].every((e) => e.ready);
+	}
+	launch(e, t) {
+		let n = this.#n.get(e);
+		n?.dynamic ? n.push(t) : n?.provide(t);
+	}
+	push(e, t) {
+		let n = this.#n.get(e);
+		if (n == null) throw Error(`Node "${this.#t}" has no input "${e}".`);
+		n.push(t);
+	}
+	take() {
+		if (!this.ready) throw Error(`Node "${this.#t}" inputs are not ready.`);
+		return this.#e || (this.#r = !0), Object.fromEntries([...this.#n].map(([e, t]) => [e, t.take()]));
+	}
+};
+function i(e, t) {
+	switch (t.kind) {
+		case "condition": return { [t.input.handle]: t.input };
+		case "value": return {};
+		case "subflow": return e.subflows[t.subflowId].inputs;
+		case "task": return t.task == null ? e.tasks[t.taskId].inputs : t.task.inputs;
+	}
+}
+function a(e, t) {
+	if (t.name != null) return t.name;
+	switch (t.kind) {
+		case "condition": return;
+		case "value": return "Value";
+		case "subflow": return e.subflows[t.subflowId].name;
+		case "task": return t.task == null ? e.tasks[t.taskId].name : t.task.name;
+	}
+}
+function o(e, t) {
+	return t.kind == "task" ? t.task == null ? e.tasks[t.taskId].executor.kind : "javascript" : t.kind;
+}
+function s(e, t, n, r) {
+	let i = e.get(t) ?? /* @__PURE__ */ new Map(), a = i.get(n) ?? [];
+	a.push(r), i.set(n, a), e.set(t, i);
+}
+function c(e, t, n) {
+	return e.get(t)?.get(n) ?? [];
+}
+function l(e) {
+	let t = new Map(Object.entries(e.nodes).map(([t, n]) => [t, new Set(Object.values(n.inputs).flatMap((t) => t.kind == "sources" ? t.sources.flatMap((t) => t.kind == "node" && e.nodes[t.nodeId] != null ? [t.nodeId] : []) : []))])), n = [];
+	for (; t.size > 0;) {
+		let e = [...t].filter(([, e]) => e.size == 0).map(([e]) => e).toSorted();
+		if (e.length == 0) throw Error("Prepared graph contains a dependency cycle.");
+		for (let r of e) t.delete(r), n.push(r);
+		for (let n of t.values()) for (let t of e) n.delete(t);
+	}
+	return n;
+}
+function u(e, t) {
+	if (e === t) return !0;
+	if (e == null || t == null || typeof e != "object" || typeof t != "object") return !1;
+	if (Array.isArray(e) || Array.isArray(t)) return Array.isArray(e) && Array.isArray(t) && e.length == t.length && e.every((e, n) => u(e, t[n]));
+	let n = Object.entries(e), r = Object.entries(t), i = t;
+	return n.length == r.length && n.every(([e, t]) => Object.hasOwn(i, e) && u(t, i[e]));
+}
+function d(e, t, n) {
+	let r = Object.hasOwn(n, t.input) ? n[t.input] : null, i = t.value;
+	switch (t.operator) {
+		case "==": return i !== void 0 && u(r, i);
+		case "!=": return i !== void 0 && !u(r, i);
+		case ">": return typeof r == "number" && typeof i == "number" && r > i;
+		case ">=": return typeof r == "number" && typeof i == "number" && r >= i;
+		case "<": return typeof r == "number" && typeof i == "number" && r < i;
+		case "<=": return typeof r == "number" && typeof i == "number" && r <= i;
+		case "contains":
+		case "notContains": {
+			let e;
+			return typeof r == "string" && typeof i == "string" ? e = r.includes(i) : Array.isArray(r) && i !== void 0 && (e = r.some((e) => u(e, i))), e == null ? !1 : t.operator == "contains" ? e : !e;
+		}
+		case "startsWith": return typeof r == "string" && typeof i == "string" && r.startsWith(i);
+		case "endsWith": return typeof r == "string" && typeof i == "string" && r.endsWith(i);
+		case "hasKey":
+		case "notHasKey": {
+			if (r == null || Array.isArray(r) || typeof r != "object" || typeof i != "string") return !1;
+			let e = Object.hasOwn(r, i);
+			return t.operator == "hasKey" ? e : !e;
+		}
+		case "hasValue":
+		case "notHasValue": {
+			if (r == null || Array.isArray(r) || typeof r != "object" || i === void 0) return !1;
+			let e = Object.values(r).some((e) => u(e, i));
+			return t.operator == "hasValue" ? e : !e;
+		}
+		case "isEmpty":
+		case "isNotEmpty": {
+			let e = r === null || typeof r == "string" && r.length == 0 || Array.isArray(r) && r.length == 0 || typeof r == "object" && !Array.isArray(r) && Object.keys(r).length == 0;
+			return (r === null || typeof r == "string" || typeof r == "object") && (t.operator == "isEmpty" ? e : !e);
+		}
+		case "isNull": return r === null;
+		case "isNotNull": return r !== null;
+		case "isTrue": return r === !0;
+		case "isFalse": return r === !1;
+	}
+}
+function f(e, t) {
+	if (typeof e != "object" || !e || Array.isArray(e)) throw Error(`Node "${t}" must return an object.`);
+	return e;
+}
+function p(e) {
+	return e.reason instanceof Error ? e.reason : /* @__PURE__ */ Error("Run canceled.");
+}
+function m(e, t) {
+	return t.aborted ? Promise.reject(p(t)) : new Promise((n, r) => {
+		let i = () => {
+			t.removeEventListener("abort", i), r(p(t));
+		};
+		t.addEventListener("abort", i, { once: !0 }), e.then((e) => {
+			t.removeEventListener("abort", i), n(e);
+		}, (e) => {
+			t.removeEventListener("abort", i), r(e);
+		});
+	});
+}
+async function h(t, n, u, p, g, v, y = {}, b, x) {
+	g.throwIfAborted(), await t.emit({
+		flowId: n.flowId,
+		...v == null ? {} : {
+			parentJobId: v.jobId,
+			parentRunId: v.runId
+		},
+		runId: u,
+		type: "run.started"
+	});
+	let S = l(n.graph), C = S.length, w = new Map(Object.entries(n.graph.nodes).map(([e, n]) => [e, new r(e, n, i(t.prepared, n))])), T = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Map();
+	for (let [e, t] of Object.entries(n.graph.nodes)) for (let [n, r] of Object.entries(t.inputs)) if (r.kind == "sources") for (let t of r.sources) if (t.kind == "flow") {
+		let r = T.get(t.input) ?? [];
+		r.push({
+			handle: n,
+			nodeId: e
+		}), T.set(t.input, r);
+	} else t.kind == "node" && s(E, t.nodeId, t.output, {
+		handle: n,
+		nodeId: e
+	});
+	for (let [e, t] of Object.entries(n.outputs)) for (let n of t.sources) n.kind == "node" && s(D, n.nodeId, n.output, e);
+	let O = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Set(), A = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), N = /* @__PURE__ */ new Set(), P = new AbortController(), F = AbortSignal.any([g, P.signal]), I, L = !1, R, z = (e, t) => {
+		P.signal.aborted || (w.get(e.nodeId).push(e.handle, t), R(e.nodeId));
+	}, B = async (e, n, r, i) => {
+		await t.emit({
+			handle: r,
+			jobId: n,
+			nodeId: e,
+			runId: u,
+			type: "node.output",
+			value: i
+		});
+		for (let t of c(E, e, r)) z(t, i);
+		for (let t of c(D, e, r)) M.set(t, i), await b?.(t, i);
+	}, V = async (e, n, r, i) => {
+		let s = o(t.prepared, n), c = a(t.prepared, n);
+		await t.emit({
+			inputs: i,
+			jobId: r,
+			nodeId: e,
+			nodeKind: s,
+			...c == null ? {} : { nodeTitle: c },
+			runId: u,
+			type: "node.started"
+		});
+		let l = n.timeoutMs == null ? void 0 : new AbortController(), p = l == null ? void 0 : setTimeout(() => l.abort(/* @__PURE__ */ Error(`Node "${e}" timed out.`)), n.timeoutMs), g = l == null ? F : AbortSignal.any([F, l.signal]);
+		try {
+			let a;
+			switch (n.kind) {
+				case "condition": {
+					let t = n.cases.find((e) => {
+						if (e.expressions.length == 0) return !1;
+						let t = e.expressions.map((e) => d(n, e, i));
+						return e.relation == "all" ? t.every(Boolean) : t.some(Boolean);
+					})?.output ?? n.defaultOutput;
+					a = t == null ? {} : { [t]: i[n.input.handle] ?? null }, t != null && await B(e, r, t, a[t]);
+					break;
+				}
+				case "value":
+					a = Object.fromEntries(Object.entries(n.values).map(([e, t]) => [e, t.value ?? null]));
+					for (let [t, n] of Object.entries(a)) await B(e, r, t, n);
+					break;
+				case "subflow": {
+					let o = t.prepared.subflows[n.subflowId];
+					a = await m(h(t, {
+						flowId: n.subflowId,
+						graph: _(o.graph),
+						inputs: o.inputs,
+						kind: "subflow",
+						outputs: o.outputs
+					}, t.createId(), i, g, {
+						jobId: r,
+						runId: u
+					}, {}, (t, n) => B(e, r, t, n)), g);
+					break;
+				}
+				case "task":
+					a = f(await m(t.invokeTask({
+						input: i,
+						invocationId: t.createId(),
+						jobId: r,
+						nodeId: e,
+						runId: u,
+						signal: g,
+						...n.task == null ? { taskId: n.taskId } : {
+							capabilities: n.task.capabilities ?? [],
+							moduleId: n.task.moduleId
+						}
+					}), g), e);
+					for (let [t, n] of Object.entries(a)) await B(e, r, t, n);
+			}
+			return await t.emit({
+				jobId: r,
+				nodeId: e,
+				runId: u,
+				type: "node.completed"
+			}), a;
+		} finally {
+			p != null && clearTimeout(p);
+		}
+	}, H = (r) => {
+		let i = n.graph.nodes[r], a = w.get(r).take(), o = t.createId(), s = j.get(r) ?? 0;
+		j.set(r, s + 1), O.set(r, (O.get(r) ?? 0) + 1);
+		let c = Promise.resolve();
+		c = V(r, i, o, a).then(async (e) => {
+			let n = A.get(r) ?? [];
+			n.push({
+				jobId: o,
+				order: s,
+				outputs: e
+			}), A.set(r, n), N.has(r) || (N.add(r), await t.emit({
+				...v == null ? {} : {
+					parentJobId: v.jobId,
+					parentRunId: v.runId
+				},
+				progress: N.size / C * 100,
+				runId: u,
+				type: "run.progress"
+			}));
+		}).catch(async (n) => {
+			L || (L = !0, I = n, P.abort(n));
+			let i = e(n, t.projectFailure);
+			await t.emit({
+				...i,
+				jobId: o,
+				nodeId: r,
+				runId: u,
+				type: "node.failed"
+			}).catch(() => void 0);
+		}).finally(() => {
+			k.delete(c), O.set(r, (O.get(r) ?? 1) - 1), R(r);
+		}), k.add(c);
+	};
+	R = (e) => {
+		if (P.signal.aborted) return;
+		let t = n.graph.nodes[e], r = w.get(e);
+		for (; r.ready && (O.get(e) ?? 0) < t.concurrency;) H(e);
+	};
+	for (let [e, t] of Object.entries(y)) {
+		let n = w.get(e);
+		if (n != null) for (let [e, r] of Object.entries(t)) n.launch(e, r);
+	}
+	for (let [e, t] of Object.entries(n.inputs)) {
+		let r = Object.hasOwn(p, e) ? p[e] : t.value;
+		if (r !== void 0) {
+			for (let t of Object.entries(n.outputs)) t[1].sources.some((t) => t.kind == "flow" && t.input == e) && (M.set(t[0], r), await b?.(t[0], r));
+			for (let t of T.get(e) ?? []) z(t, r);
+		}
+	}
+	if (x != null) for (let e of c(E, x.nodeId, "payload")) z(e, x.payload);
+	for (let e of S) R(e);
+	for (; k.size > 0;) await Promise.race(k);
+	if (L) throw await t.emit({
+		message: I instanceof Error ? I.message : String(I),
+		runId: u,
+		type: "run.failed"
+	}).catch(() => void 0), I;
+	if (F.throwIfAborted(), n.kind == "subflow") {
+		let e = Object.fromEntries(M);
+		return await t.emit({
+			result: {
+				kind: "function-outputs",
+				outputs: e,
+				target: "subflow"
+			},
+			runId: u,
+			type: "run.completed"
+		}), e;
+	}
+	let U = new Set(Object.values(n.graph.nodes).flatMap((e) => Object.values(e.inputs).flatMap((e) => e.kind == "sources" ? e.sources.filter((e) => e.kind == "node").map((e) => e.nodeId) : []))), W = {
+		kind: "node-results",
+		nodes: S.filter((e) => !U.has(e)).map((e) => ({
+			jobs: (A.get(e) ?? []).toSorted((e, t) => e.order - t.order).map(({ jobId: e, outputs: t }) => ({
+				jobId: e,
+				outputs: t
+			})),
+			nodeId: e
+		}))
+	};
+	return await t.emit({
+		result: W,
+		runId: u,
+		type: "run.completed"
+	}), W;
+}
+async function g(e, t) {
+	let n = async (e) => await t.emit?.(e), r = t.signal ?? new AbortController().signal, i = t.trigger == null ? void 0 : e.flow.graph.nodes[t.trigger.nodeId];
+	if (t.trigger != null && (i == null || "inputs" in i)) throw Error(`Node "${t.trigger.nodeId}" is not a TriggerNode in Flow "${e.flowId}".`);
+	return await h({
+		createId: t.createId,
+		emit: n,
+		invokeTask: t.invokeTask,
+		prepared: e,
+		projectFailure: t.projectFailure
+	}, {
+		flowId: e.flowId,
+		graph: _(e.flow.graph),
+		inputs: {},
+		kind: "flow",
+		outputs: {}
+	}, t.runId, {}, r, void 0, t.inputs, void 0, t.trigger);
+}
+function _(e) {
+	return { nodes: Object.fromEntries(Object.entries(e.nodes).filter((e) => "inputs" in e[1])) };
+}
+//#endregion
+export { g as runFlow };

package/dist/common/webhook-trigger.d.ts

@@ -0,0 +1,22 @@
+import type { JsonValue, WebhookInputDefinition, WebhookOptions } from '../browser/project-change.js';
+export declare const maximumWebhookBodyBytes: number;
+export declare function webhookEndpointId(url: URL): string | undefined;
+export declare function webhookOccurrenceId(endpointId: string, runtimeVersion: number, key: string | null): Promise<string | undefined>;
+export interface WebhookConformanceFixture {
+    readonly inputsDef: readonly WebhookInputDefinition[];
+    readonly options?: WebhookOptions;
+}
+export interface WebhookConformanceHarness {
+    readonly endpointUrl: string;
+    dispose(): Promise<void>;
+    payloads(): Promise<readonly JsonValue[]>;
+    republish(): Promise<void>;
+    request(request: Request): Promise<Response>;
+    retire(): Promise<void>;
+}
+export interface WebhookConformanceCase {
+    readonly fixture: WebhookConformanceFixture;
+    readonly name: string;
+    verify(harness: WebhookConformanceHarness): Promise<void>;
+}
+export declare const webhookConformanceCases: readonly WebhookConformanceCase[];