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

package/dist/common/project-encoding.js

@@ -0,0 +1,242 @@
+//#region src/project/common/encoding.ts
+var e = new TextEncoder(), t = 64;
+function n(e) {
+	if (e == null || typeof e == "boolean" || typeof e == "string" || typeof e == "number") return JSON.stringify(e);
+	if (Array.isArray(e)) return `[${e.map(n).join(",")}]`;
+	let t = e;
+	return `{${Object.keys(t).toSorted().map((e) => `${JSON.stringify(e)}:${n(t[e])}`).join(",")}}`;
+}
+function r(t) {
+	return e.encode(n(t));
+}
+async function i(e) {
+	let t = new Uint8Array(e.byteLength);
+	return t.set(e), `sha256:${[...new Uint8Array(await crypto.subtle.digest("SHA-256", t))].map((e) => e.toString(16).padStart(2, "0")).join("")}`;
+}
+function a(e) {
+	return Object.keys(e).toSorted().map((t) => [t, e[t]]);
+}
+function o(e) {
+	return {
+		...e.description == null ? {} : { description: e.description },
+		jsonSchema: e.jsonSchema,
+		nullable: e.nullable,
+		...Object.hasOwn(e, "value") ? { value: e.value } : {}
+	};
+}
+function s(e) {
+	return Object.fromEntries(a(e).map(([e, t]) => [e, o(t)]));
+}
+function c(e) {
+	switch (e.kind) {
+		case "sources": return {
+			kind: e.kind,
+			sources: e.sources.map((e) => ({ ...e }))
+		};
+		case "value": return {
+			kind: e.kind,
+			value: e.value
+		};
+	}
+}
+function l(e) {
+	return Object.fromEntries(a(e).map(([e, t]) => [e, c(t)]));
+}
+function u(e) {
+	return Object.fromEntries(a(e).map(([e, t]) => [e, {
+		...t.description == null ? {} : { description: t.description },
+		jsonSchema: t.jsonSchema,
+		nullable: t.nullable,
+		sources: t.sources.map((e) => ({ ...e }))
+	}]));
+}
+function d(e) {
+	if (!("inputs" in e)) return v(e);
+	let t = {
+		concurrency: e.concurrency,
+		...e.description == null ? {} : { description: e.description },
+		inputs: l(e.inputs),
+		...e.name == null ? {} : { name: e.name },
+		...e.timeoutMs == null ? {} : { timeoutMs: e.timeoutMs }
+	};
+	switch (e.kind) {
+		case "condition": return {
+			...t,
+			cases: e.cases.map((e) => ({
+				expressions: e.expressions.map((e) => ({
+					input: e.input,
+					operator: e.operator,
+					...Object.hasOwn(e, "value") ? { value: e.value } : {}
+				})),
+				output: e.output,
+				relation: e.relation
+			})),
+			...e.defaultOutput == null ? {} : { defaultOutput: e.defaultOutput },
+			input: {
+				handle: e.input.handle,
+				...o(e.input)
+			},
+			kind: e.kind
+		};
+		case "subflow": return {
+			...t,
+			kind: e.kind,
+			subflowId: e.subflowId
+		};
+		case "task": return e.task == null ? {
+			...t,
+			kind: e.kind,
+			taskId: e.taskId
+		} : {
+			...t,
+			kind: e.kind,
+			task: m(e.task)
+		};
+		case "value": return {
+			...t,
+			kind: e.kind,
+			values: s(e.values)
+		};
+	}
+}
+function f(e) {
+	return { nodes: Object.fromEntries(a(e.nodes).map(([e, t]) => [e, d(t)])) };
+}
+function p(e) {
+	return {
+		executor: e.executor,
+		inputs: s(e.inputs),
+		name: e.name,
+		outputs: s(e.outputs)
+	};
+}
+function m(e) {
+	return {
+		...e.capabilities == null ? {} : { capabilities: e.capabilities.map(({ action: e, connectionId: t, kind: n }) => ({
+			action: e,
+			connectionId: t,
+			kind: n
+		})) },
+		inputs: s(e.inputs),
+		moduleId: e.moduleId,
+		name: e.name,
+		outputs: s(e.outputs)
+	};
+}
+function h(e) {
+	return {
+		configSchema: e.configSchema,
+		definitionVersion: e.definitionVersion,
+		description: e.description,
+		displayName: e.displayName,
+		...e.type == "integration" ? { endpoint: {
+			body: {
+				allowArray: e.endpoint.body.allowArray,
+				allowEmpty: e.endpoint.body.allowEmpty,
+				formats: e.endpoint.body.formats
+			},
+			methods: e.endpoint.methods,
+			successStatus: e.endpoint.successStatus
+		} } : {},
+		key: e.key,
+		name: e.name,
+		payloadSchema: e.payloadSchema,
+		provider: e.provider,
+		type: e.type
+	};
+}
+function g(e) {
+	return {
+		...e.allowedMethods == null ? {} : { allowedMethods: e.allowedMethods },
+		...e.allowedOrigins == null ? {} : { allowedOrigins: e.allowedOrigins },
+		...e.noResponseBody == null ? {} : { noResponseBody: e.noResponseBody },
+		...e.responseData == null ? {} : { responseData: e.responseData },
+		...e.responseHeaders == null ? {} : { responseHeaders: e.responseHeaders },
+		...e.responseStatusCode == null ? {} : { responseStatusCode: e.responseStatusCode }
+	};
+}
+function _(e) {
+	switch (e.type) {
+		case "cron": return {
+			expression: e.expression,
+			timezone: e.timezone,
+			type: e.type
+		};
+		case "every": return {
+			type: e.type,
+			unit: e.unit,
+			value: e.value
+		};
+	}
+}
+function v(e) {
+	let t = (t) => ({
+		...e.description == null ? {} : { description: e.description },
+		kind: t,
+		name: e.name
+	});
+	switch (e.kind) {
+		case "webhook": return {
+			...t(e.kind),
+			inputsDef: e.inputsDef.map((e) => ({
+				handle: e.handle,
+				...o(e)
+			})),
+			...e.options == null ? {} : { options: g(e.options) }
+		};
+		case "cron": return {
+			...t(e.kind),
+			cronTimes: e.cronTimes.map(_)
+		};
+		case "poll": return {
+			...t(e.kind),
+			bindingId: e.bindingId,
+			config: e.config,
+			definition: h(e.definition),
+			pollTimes: e.pollTimes.map(_)
+		};
+		case "integration": return {
+			...t(e.kind),
+			bindingId: e.bindingId,
+			config: e.config,
+			definition: h(e.definition)
+		};
+	}
+}
+function y(e) {
+	return {
+		bindings: Object.fromEntries(a(e.bindings)),
+		flows: Object.fromEntries(a(e.flows).map(([e, t]) => [e, {
+			graph: f(t.graph),
+			name: t.name
+		}])),
+		subflows: Object.fromEntries(a(e.subflows).map(([e, t]) => [e, {
+			graph: f(t.graph),
+			inputs: s(t.inputs),
+			name: t.name,
+			outputs: u(t.outputs)
+		}])),
+		tasks: Object.fromEntries(a(e.tasks).map(([e, t]) => [e, p(t)]))
+	};
+}
+function b(e) {
+	return {
+		imports: e.imports.toSorted(),
+		name: e.name,
+		source: e.source
+	};
+}
+function x(e) {
+	return {
+		document: y(e.document),
+		kind: "open-flow-project-revision",
+		modelVersion: e.modelVersion,
+		modules: Object.fromEntries(a(e.modules).map(([e, t]) => [e, b(t)])),
+		version: 1
+	};
+}
+function S(e) {
+	return r(x(e));
+}
+//#endregion
+export { y as canonicalDocument, f as canonicalGraph, r as canonicalJsonBytes, b as canonicalModule, u as canonicalOutputs, s as canonicalPorts, p as canonicalTask, i as digestBytes, S as encodeRevision, t as maxJsonDepth };

package/dist/common/project-notifications.d.ts

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

package/dist/common/project-semantics.d.ts

@@ -0,0 +1,55 @@
+import type { JsonValue, ProjectDocument, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/project-change';
+import type { EngineContract } from './engine-contract.js';
+import type { RuntimeProgram } from './runtime-contract.js';
+export interface SemanticClosure {
+    readonly dependencies: {
+        readonly bindings: ReadonlySet<string>;
+        readonly inputBindings: ReadonlySet<string>;
+        readonly modules: ReadonlySet<string>;
+        readonly subflows: ReadonlySet<string>;
+        readonly tasks: ReadonlySet<string>;
+    };
+    readonly digest: string;
+}
+export declare function flowClosure(content: RevisionContent, flowId: string): Promise<SemanticClosure | undefined>;
+export interface Diagnostic {
+    readonly code: string;
+    readonly column: number;
+    readonly line: number;
+    readonly message: string;
+    readonly path: string;
+}
+export interface FlowValidation {
+    readonly closure: SemanticClosure;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly valid: boolean;
+}
+export declare function triggerPayloadSchema(trigger: TriggerNode): JsonValue;
+export declare function matchesSchema(value: JsonValue, schema: JsonValue): boolean;
+export type FlowInputsValidation = 'flow-not-found' | 'invalid' | 'valid';
+export declare function validateFlowInputs(revision: RevisionContent, flowId: string, value: unknown): FlowInputsValidation;
+export declare function validateModules(revision: RevisionContent, moduleIds: readonly string[], engine: EngineContract): readonly Diagnostic[];
+export declare function validateFlow(revision: RevisionContent, flowId: string, engine: EngineContract): Promise<FlowValidation | undefined>;
+export interface PreparedFlow {
+    readonly closureDigest: string;
+    readonly engineContract: string;
+    readonly flow: ProjectDocument['flows'][string];
+    readonly flowId: string;
+    readonly modules: RevisionContent['modules'];
+    readonly subflows: ProjectDocument['subflows'];
+    readonly tasks: ProjectDocument['tasks'];
+}
+export type PrepareFlowResult = {
+    readonly kind: 'engine-unsupported';
+} | {
+    readonly kind: 'flow-invalid';
+    readonly validation: FlowValidation;
+} | {
+    readonly kind: 'flow-not-found';
+} | {
+    readonly flow: PreparedFlow;
+    readonly kind: 'prepared';
+    readonly validation: FlowValidation;
+};
+export declare function prepareFlow(revision: RevisionContent, flowId: string, engineContract: string): Promise<PrepareFlowResult>;
+export declare function createRuntimeProgram(prepared: PreparedFlow, entryModuleId: string, engineDigest: string): RuntimeProgram | undefined;