@oomol-lab/open-flow 0.1.0-alpha.1 → 0.1.0-alpha.12

package/dist/browser/{project-change.d.ts → flow-change.d.ts}

@@ -4,6 +4,7 @@ export type JsonValue = null | boolean | number | string | readonly JsonValue[]
 export declare const resourceNameMaxLength = 80;
 export type ResourceNameIssue = 'controlCharacter' | 'empty' | 'specialCharacter' | 'tooLong';
 export declare function resourceNameIssue(value: string): ResourceNameIssue | undefined;
+export declare function validVariableName(value: string): boolean;
 export interface PortDefinition {
     readonly description?: string;
     readonly jsonSchema: JsonValue;
@@ -12,6 +13,13 @@ export interface PortDefinition {
 export interface InputPortDefinition extends PortDefinition {
     readonly value?: JsonValue;
 }
+export interface Port extends PortDefinition {
+    readonly handle: string;
+}
+export interface InputPort extends InputPortDefinition {
+    readonly handle: string;
+}
+export declare function portsByHandle<Value extends Port>(ports: readonly Value[]): Readonly<Record<string, Value>>;
 export interface NodeSource {
     readonly kind: 'node';
     readonly nodeId: string;
@@ -38,6 +46,7 @@ export interface OutputMapping {
 interface GraphNodeBase {
     readonly concurrency: number;
     readonly description?: string;
+    readonly icon?: string;
     readonly inputs: Readonly<Record<string, InputMapping>>;
     readonly name?: string;
     readonly timeoutMs?: number;
@@ -48,7 +57,7 @@ export interface SubflowNode extends GraphNodeBase {
 }
 export interface ValueNode extends GraphNodeBase {
     readonly kind: 'value';
-    readonly values: Readonly<Record<string, InputPortDefinition>>;
+    readonly values: readonly InputPort[];
 }
 export type ConditionOperator = '!=' | '<' | '<=' | '==' | '>' | '>=' | 'contains' | 'endsWith' | 'hasKey' | 'hasValue' | 'isEmpty' | 'isFalse' | 'isNotEmpty' | 'isNotNull' | 'isNull' | 'isTrue' | 'notContains' | 'notHasKey' | 'notHasValue' | 'startsWith';
 export interface ConditionExpression {
@@ -64,9 +73,7 @@ export interface ConditionCase {
 export interface ConditionNode extends GraphNodeBase {
     readonly cases: readonly ConditionCase[];
     readonly defaultOutput?: string;
-    readonly input: InputPortDefinition & {
-        readonly handle: string;
-    };
+    readonly input: InputPort;
     readonly kind: 'condition';
 }
 export type ManagedTaskExecutor = {
@@ -83,9 +90,9 @@ export interface ConnectorCapability {
     readonly kind: 'connector';
 }
 interface TaskDefinitionBase {
-    readonly inputs: Readonly<Record<string, InputPortDefinition>>;
+    readonly inputs: readonly InputPort[];
     readonly name: string;
-    readonly outputs: Readonly<Record<string, PortDefinition>>;
+    readonly outputs: readonly Port[];
 }
 export interface InlineTaskDefinition extends TaskDefinitionBase {
     readonly capabilities?: readonly ConnectorCapability[];
@@ -143,8 +150,7 @@ export type TriggerKeySnapshot = (TriggerKeySnapshotBase & {
     readonly endpoint: IntegrationEndpointDeclaration;
     readonly type: 'integration';
 });
-export interface WebhookInputDefinition extends InputPortDefinition {
-    readonly handle: string;
+export interface WebhookInputDefinition extends InputPort {
 }
 export interface WebhookOptions {
     readonly allowedMethods?: readonly string[];
@@ -156,6 +162,7 @@ export interface WebhookOptions {
 }
 interface TriggerNodeBase {
     readonly description?: string;
+    readonly icon?: string;
     readonly name: string;
 }
 export type TriggerNode = (TriggerNodeBase & {
@@ -182,20 +189,17 @@ export type TriggerNode = (TriggerNodeBase & {
     readonly kind: 'integration';
 });
 export type GraphNode = ConditionNode | SubflowNode | TaskNode | TriggerNode | ValueNode;
-export interface ProjectDocument {
+export interface FlowDocument {
     readonly bindings: Readonly<Record<string, {
-        readonly kind: 'connection' | 'secret';
+        readonly kind: 'connection' | 'variable';
         readonly target: string;
     }>>;
-    readonly flows: Readonly<Record<string, {
-        readonly graph: Graph;
-        readonly name: string;
-    }>>;
+    readonly graph: Graph;
     readonly subflows: Readonly<Record<string, {
         readonly graph: Graph;
-        readonly inputs: Readonly<Record<string, InputPortDefinition>>;
+        readonly inputs: readonly InputPort[];
         readonly name: string;
-        readonly outputs: Readonly<Record<string, OutputMapping & PortDefinition>>;
+        readonly outputs: readonly (OutputMapping & Port)[];
     }>>;
     readonly tasks: Readonly<Record<string, ManagedTaskDefinition>>;
 }
@@ -205,12 +209,11 @@ export interface CodeModule {
     readonly source: string;
 }
 export interface RevisionContent {
-    readonly document: ProjectDocument;
+    readonly document: FlowDocument;
     readonly modelVersion: 1;
     readonly modules: Readonly<Record<string, CodeModule>>;
 }
 export type GraphTarget = {
-    readonly id: string;
     readonly kind: 'flow';
 } | {
     readonly id: string;
@@ -223,27 +226,16 @@ export interface GraphEdge {
     readonly targetHandle: string;
 }
 export type ChangeOperation = {
-    readonly binding: ProjectDocument['bindings'][string];
+    readonly binding: FlowDocument['bindings'][string];
     readonly bindingId: string;
     readonly kind: 'binding.create';
 } | {
-    readonly binding: ProjectDocument['bindings'][string];
+    readonly binding: FlowDocument['bindings'][string];
     readonly bindingId: string;
     readonly kind: 'binding.replace';
 } | {
     readonly bindingId: string;
     readonly kind: 'binding.delete';
-} | {
-    readonly flow: ProjectDocument['flows'][string];
-    readonly flowId: string;
-    readonly kind: 'flow.create';
-} | {
-    readonly flowId: string;
-    readonly kind: 'flow.delete';
-} | {
-    readonly flowId: string;
-    readonly kind: 'flow.rename';
-    readonly name: string;
 } | {
     readonly kind: 'graph.edge.connect';
     readonly edge: GraphEdge;
@@ -284,10 +276,10 @@ export type ChangeOperation = {
     readonly source: string;
 } | {
     readonly kind: 'subflow.create';
-    readonly subflow: ProjectDocument['subflows'][string];
+    readonly subflow: FlowDocument['subflows'][string];
     readonly subflowId: string;
 } | {
-    readonly definition: Omit<ProjectDocument['subflows'][string], 'graph'>;
+    readonly definition: Omit<FlowDocument['subflows'][string], 'graph'>;
     readonly kind: 'subflow.definition.replace';
     readonly subflowId: string;
 } | {
@@ -295,17 +287,17 @@ export type ChangeOperation = {
     readonly subflowId: string;
 } | {
     readonly kind: 'task.create';
-    readonly task: ProjectDocument['tasks'][string];
+    readonly task: FlowDocument['tasks'][string];
     readonly taskId: string;
 } | {
     readonly kind: 'task.delete';
     readonly taskId: string;
 } | {
     readonly kind: 'task.replace';
-    readonly task: ProjectDocument['tasks'][string];
+    readonly task: FlowDocument['tasks'][string];
     readonly taskId: string;
 };
-export declare class ProjectChangeError extends Error {
+export declare class FlowChangeError extends Error {
 }
-export declare function applyProjectChanges(content: RevisionContent, operations: readonly ChangeOperation[]): RevisionContent;
+export declare function applyFlowChanges(content: RevisionContent, operations: readonly ChangeOperation[]): RevisionContent;
 export {};

package/dist/browser/flow-change.js

@@ -0,0 +1,234 @@
+//#region src/flow/common/change.ts
+var e = 80;
+function t(e) {
+	let t = e.trim();
+	if (t.length == 0) return "empty";
+	if (t.length > 80) return "tooLong";
+	for (let e of t) {
+		let t = e.charCodeAt(0);
+		if (t <= 31 || t >= 127 && t <= 159) return "controlCharacter";
+	}
+	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(t)) return "specialCharacter";
+}
+function n(e) {
+	return e.length <= 256 && /^[A-Za-z_][A-Za-z0-9_]*$/.test(e) && e.slice(0, 3).toUpperCase() != "OO_";
+}
+function r(e) {
+	return Object.fromEntries(e.map((e) => [e.handle, e]));
+}
+var i = class extends Error {};
+function a() {
+	throw new i();
+}
+function o(e, t) {
+	if (t.kind == "flow") return e.graph;
+	let n = e.subflows[t.id];
+	return n ?? a(), n.graph;
+}
+function s(e, t, n) {
+	if (t.kind == "flow") return {
+		...e,
+		graph: n
+	};
+	let r = e.subflows[t.id];
+	return r ?? a(), {
+		...e,
+		subflows: {
+			...e.subflows,
+			[t.id]: {
+				...r,
+				graph: n
+			}
+		}
+	};
+}
+function c(e, t) {
+	if (!("inputs" in e)) return e;
+	let n = { ...e.inputs };
+	for (let [e, r] of Object.entries(n)) {
+		if (r.kind != "sources") continue;
+		let i = r.sources.filter((e) => e.kind != "node" || !t.has(e.nodeId));
+		i.length == 0 ? delete n[e] : n[e] = {
+			kind: "sources",
+			sources: i
+		};
+	}
+	return {
+		...e,
+		inputs: n
+	};
+}
+function l(e, t) {
+	let n = { ...e.document }, r = { ...e.modules };
+	for (let e of t) switch (e.kind) {
+		case "binding.create":
+			n.bindings[e.bindingId] != null && a(), n.bindings = {
+				...n.bindings,
+				[e.bindingId]: e.binding
+			};
+			break;
+		case "binding.replace":
+			n.bindings[e.bindingId] ?? a(), n.bindings = {
+				...n.bindings,
+				[e.bindingId]: e.binding
+			};
+			break;
+		case "binding.delete": {
+			n.bindings[e.bindingId] ?? a();
+			let t = { ...n.bindings };
+			delete t[e.bindingId], n.bindings = t;
+			break;
+		}
+		case "graph.edge.connect": {
+			let t = o(n, e.target);
+			t.nodes[e.edge.source] ?? a();
+			let r = t.nodes[e.edge.target];
+			(r == null || !("inputs" in r)) && a();
+			let i = r.inputs[e.edge.targetHandle], c = {
+				kind: "node",
+				nodeId: e.edge.source,
+				output: e.edge.sourceHandle
+			}, l = i?.kind == "sources" ? i.sources.filter((e) => e.kind != "binding" || n.bindings[e.bindingId]?.kind != "variable") : [];
+			l.some((e) => e.kind == "node" && e.nodeId == c.nodeId && e.output == c.output) && a();
+			let u = {
+				...r,
+				inputs: {
+					...r.inputs,
+					[e.edge.targetHandle]: {
+						kind: "sources",
+						sources: [...l, c]
+					}
+				}
+			};
+			Object.assign(n, s(n, e.target, { nodes: {
+				...t.nodes,
+				[e.edge.target]: u
+			} }));
+			break;
+		}
+		case "graph.edge.disconnect": {
+			let t = o(n, e.target), r = t.nodes[e.edge.target];
+			(r == null || !("inputs" in r)) && a();
+			let i = r.inputs[e.edge.targetHandle];
+			i?.kind != "sources" && a();
+			let c = i.sources.filter((t) => t.kind != "node" || t.nodeId != e.edge.source || t.output != e.edge.sourceHandle);
+			c.length == i.sources.length && a();
+			let l = { ...r.inputs };
+			c.length == 0 ? delete l[e.edge.targetHandle] : l[e.edge.targetHandle] = {
+				kind: "sources",
+				sources: c
+			}, Object.assign(n, s(n, e.target, { nodes: {
+				...t.nodes,
+				[e.edge.target]: {
+					...r,
+					inputs: l
+				}
+			} }));
+			break;
+		}
+		case "graph.node.create": {
+			let t = o(n, e.target);
+			(t.nodes[e.nodeId] != null || e.target.kind == "subflow" && !("inputs" in e.node)) && a(), Object.assign(n, s(n, e.target, { nodes: {
+				...t.nodes,
+				[e.nodeId]: e.node
+			} }));
+			break;
+		}
+		case "graph.node.delete": {
+			let t = o(n, e.target);
+			t.nodes[e.nodeId] ?? a();
+			let r = /* @__PURE__ */ new Set([e.nodeId]), i = Object.fromEntries(Object.entries(t.nodes).flatMap(([e, t]) => r.has(e) ? [] : [[e, c(t, r)]]));
+			if (Object.assign(n, s(n, e.target, { nodes: i })), e.target.kind == "subflow") {
+				let t = n.subflows[e.target.id], i = t.outputs.map((e) => ({
+					...e,
+					sources: e.sources.filter((e) => e.kind != "node" || !r.has(e.nodeId))
+				}));
+				n.subflows = {
+					...n.subflows,
+					[e.target.id]: {
+						...t,
+						outputs: i
+					}
+				};
+			}
+			break;
+		}
+		case "graph.node.replace": {
+			let t = o(n, e.target);
+			(t.nodes[e.nodeId] == null || e.target.kind == "subflow" && !("inputs" in e.node)) && a(), Object.assign(n, s(n, e.target, { nodes: {
+				...t.nodes,
+				[e.nodeId]: e.node
+			} }));
+			break;
+		}
+		case "module.create":
+			r[e.moduleId] != null && a(), r[e.moduleId] = e.module;
+			break;
+		case "module.delete":
+			r[e.moduleId] ?? a(), delete r[e.moduleId];
+			break;
+		case "module.rename": {
+			let t = r[e.moduleId];
+			t ?? a(), r[e.moduleId] = {
+				...t,
+				name: e.name
+			};
+			break;
+		}
+		case "module.source.replace": {
+			let t = r[e.moduleId];
+			t ?? a(), r[e.moduleId] = {
+				...t,
+				imports: e.imports,
+				source: e.source
+			};
+			break;
+		}
+		case "subflow.create":
+			n.subflows[e.subflowId] != null && a(), n.subflows = {
+				...n.subflows,
+				[e.subflowId]: e.subflow
+			};
+			break;
+		case "subflow.definition.replace": {
+			let t = n.subflows[e.subflowId];
+			t ?? a(), n.subflows = {
+				...n.subflows,
+				[e.subflowId]: {
+					...e.definition,
+					graph: t.graph
+				}
+			};
+			break;
+		}
+		case "subflow.delete": {
+			n.subflows[e.subflowId] ?? a();
+			let t = { ...n.subflows };
+			delete t[e.subflowId], n.subflows = t;
+			break;
+		}
+		case "task.create":
+			n.tasks[e.taskId] != null && a(), n.tasks = {
+				...n.tasks,
+				[e.taskId]: e.task
+			};
+			break;
+		case "task.delete": {
+			n.tasks[e.taskId] ?? a();
+			let t = { ...n.tasks };
+			delete t[e.taskId], n.tasks = t;
+			break;
+		}
+		case "task.replace": n.tasks[e.taskId] ?? a(), n.tasks = {
+			...n.tasks,
+			[e.taskId]: e.task
+		};
+	}
+	return {
+		document: n,
+		modelVersion: e.modelVersion,
+		modules: r
+	};
+}
+//#endregion
+export { i as FlowChangeError, l as applyFlowChanges, r as portsByHandle, t as resourceNameIssue, e as resourceNameMaxLength, n as validVariableName };

package/dist/browser/{project-notifications.d.ts → flow-notifications.d.ts}

@@ -1,12 +1,15 @@
-export type ProjectChangeEvent = {
+export interface FlowCatalogEvent {
+    readonly kind: 'flows.changed';
+    readonly version: 1;
+}
+export type FlowChangeEvent = {
     readonly kind: 'draft.changed';
-    readonly projectId: string;
+    readonly flowId: string;
     readonly revisionId: string;
     readonly version: 1;
 } | {
     readonly flowId: string;
     readonly kind: 'run.created';
-    readonly projectId: string;
     readonly runId: string;
     readonly version: 1;
 };