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

package/dist/common/webhook-trigger.js

@@ -0,0 +1,270 @@
+//#region ../../node_modules/dequal/lite/index.mjs
+var e = Object.prototype.hasOwnProperty;
+function t(n, r) {
+	var i, a;
+	if (n === r) return !0;
+	if (n && r && (i = n.constructor) === r.constructor) {
+		if (i === Date) return n.getTime() === r.getTime();
+		if (i === RegExp) return n.toString() === r.toString();
+		if (i === Array) {
+			if ((a = n.length) === r.length) for (; a-- && t(n[a], r[a]););
+			return a === -1;
+		}
+		if (!i || typeof n == "object") {
+			for (i in a = 0, n) if (e.call(n, i) && ++a && !e.call(r, i) || !(i in r) || !t(n[i], r[i])) return !1;
+			return Object.keys(r).length === a;
+		}
+	}
+	return n !== n && r !== r;
+}
+//#endregion
+//#region src/trigger/common/webhook.ts
+var n = 65536, r = /^\/v1\/webhooks\/(endpoint_[0-9a-f]{32})$/, i = new TextEncoder();
+function a(e) {
+	return r.exec(e.pathname)?.[1];
+}
+async function o(e, t, n) {
+	if (n == null) return `webhook_${crypto.randomUUID().replaceAll("-", "")}`;
+	if (n.trim().length == 0 || n.length > 256) return;
+	let r = JSON.stringify([
+		1,
+		"webhook-occurrence",
+		e,
+		t,
+		n
+	]);
+	return [...new Uint8Array(await crypto.subtle.digest("SHA-256", i.encode(r)))].map((e) => e.toString(16).padStart(2, "0")).join("");
+}
+function s(e, n, r) {
+	if (!t(e, n)) throw Error(`${r}: expected ${JSON.stringify(n)}, received ${JSON.stringify(e)}.`);
+}
+async function c(e, t, n) {
+	s(e.status, t.status, `${n} status`), t.body != null && s(await e.text(), t.body, `${n} body`);
+	for (let [r, i] of Object.entries(t.headers ?? {})) s(e.headers.get(r), i, `${n} header ${r}`);
+}
+function l(e, t = {}) {
+	return e.request(new Request(t.url ?? e.endpointUrl, {
+		...t.body == null ? {} : { body: t.body },
+		headers: t.headers,
+		method: t.method ?? "POST"
+	}));
+}
+var u = [], d = [{
+	handle: "event",
+	jsonSchema: {
+		additionalProperties: !1,
+		properties: { message: { type: "string" } },
+		required: ["message"],
+		type: "object"
+	},
+	nullable: !1
+}], f = { event: { message: "hello" } }, p = [
+	{
+		fixture: { inputsDef: u },
+		name: "rejects malformed and unknown endpoint identities",
+		async verify(e) {
+			let t = new URL(e.endpointUrl);
+			await c(await l(e, { url: new URL("/v1/webhooks/not-an-endpoint", t).href }), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 404
+			}, "Malformed endpoint"), await c(await l(e, { url: new URL("/v1/webhooks/endpoint_00000000000000000000000000000000", t).href }), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 404
+			}, "Unknown endpoint");
+		}
+	},
+	{
+		fixture: { inputsDef: u },
+		name: "uses POST by default and decodes an empty body as an empty object",
+		async verify(e) {
+			await c(await l(e, { method: "GET" }), {
+				headers: {
+					allow: "POST",
+					"cache-control": "no-store"
+				},
+				status: 405
+			}, "Default method"), await c(await l(e), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 200
+			}, "Empty payload"), s(await e.payloads(), [{}], "Decoded empty payloads");
+		}
+	},
+	{
+		fixture: {
+			inputsDef: u,
+			options: {
+				allowedMethods: ["PUT"],
+				allowedOrigins: ["https://client.example"],
+				responseData: "accepted",
+				responseHeaders: { "x-webhook-response": "configured" },
+				responseStatusCode: 202
+			}
+		},
+		name: "applies configured methods, CORS, preflight, and success response",
+		async verify(e) {
+			await c(await l(e, {
+				headers: {
+					"access-control-request-headers": "content-type, idempotency-key",
+					"access-control-request-method": "PUT",
+					origin: "https://client.example"
+				},
+				method: "OPTIONS"
+			}), {
+				body: "",
+				headers: {
+					"access-control-allow-headers": "content-type, idempotency-key",
+					"access-control-allow-methods": "PUT",
+					"access-control-allow-origin": "https://client.example",
+					"access-control-max-age": "600"
+				},
+				status: 204
+			}, "Preflight"), await c(await l(e, {
+				body: "{}",
+				headers: { origin: "https://client.example" },
+				method: "PUT"
+			}), {
+				body: "accepted",
+				headers: {
+					"access-control-allow-origin": "https://client.example",
+					"cache-control": "no-store",
+					"x-webhook-response": "configured"
+				},
+				status: 202
+			}, "Configured success"), await c(await l(e, {
+				body: "{}",
+				headers: { origin: "https://other.example" },
+				method: "PUT"
+			}), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 403
+			}, "Disallowed origin");
+		}
+	},
+	{
+		fixture: { inputsDef: d },
+		name: "rejects invalid JSON, invalid payloads, invalid idempotency keys, and oversized bodies",
+		async verify(e) {
+			await c(await l(e, { body: "{" }), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 400
+			}, "Invalid JSON"), await c(await l(e, { body: JSON.stringify({ event: {} }) }), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 400
+			}, "Invalid payload"), await c(await l(e, {
+				body: JSON.stringify(f),
+				headers: { "idempotency-key": "   " }
+			}), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 400
+			}, "Empty key"), await c(await l(e, {
+				body: JSON.stringify(f),
+				headers: { "idempotency-key": "x".repeat(257) }
+			}), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 400
+			}, "Oversized key"), await c(await l(e, { body: "x".repeat(65537) }), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 413
+			}, "Oversized body"), s(await e.payloads(), [], "Rejected payloads");
+		}
+	},
+	{
+		fixture: { inputsDef: d },
+		name: "replays one idempotent occurrence and rejects conflicting payloads",
+		async verify(e) {
+			let t = { "idempotency-key": "delivery-1" };
+			await c(await l(e, {
+				body: JSON.stringify(f),
+				headers: t
+			}), { status: 200 }, "Initial delivery"), await c(await l(e, {
+				body: JSON.stringify(f),
+				headers: t
+			}), { status: 200 }, "Repeated delivery"), await c(await l(e, {
+				body: JSON.stringify({ event: { message: "different" } }),
+				headers: t
+			}), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 409
+			}, "Conflicting delivery"), s(await e.payloads(), [f], "Idempotent payloads");
+		}
+	},
+	{
+		fixture: { inputsDef: d },
+		name: "admits requests without an idempotency key as separate occurrences",
+		async verify(e) {
+			let t = JSON.stringify(f);
+			await c(await l(e, { body: t }), { status: 200 }, "First unkeyed delivery"), await c(await l(e, { body: t }), { status: 200 }, "Second unkeyed delivery"), s(await e.payloads(), [f, f], "Unkeyed payloads");
+		}
+	},
+	{
+		fixture: { inputsDef: d },
+		name: "scopes occurrence identity to the current runtime version",
+		async verify(e) {
+			let t = JSON.stringify(f), n = { "idempotency-key": "delivery-across-publish" };
+			await c(await l(e, {
+				body: t,
+				headers: n
+			}), { status: 200 }, "Delivery before publish");
+			let r = e.endpointUrl;
+			await e.republish(), s(e.endpointUrl, r, "Endpoint after publish"), await c(await l(e, {
+				body: t,
+				headers: n
+			}), { status: 200 }, "Delivery after publish"), s(await e.payloads(), [f, f], "Payloads across publish");
+		}
+	},
+	{
+		fixture: { inputsDef: u },
+		name: "fails closed after its trigger is retired",
+		async verify(e) {
+			await e.retire(), await c(await l(e, { body: "{}" }), {
+				body: "",
+				headers: { "cache-control": "no-store" },
+				status: 404
+			}, "Retired endpoint"), s(await e.payloads(), [], "Payloads after retirement");
+		}
+	},
+	{
+		fixture: {
+			inputsDef: u,
+			options: {
+				responseData: "ignored",
+				responseStatusCode: 204
+			}
+		},
+		name: "omits a configured response body for null-body statuses",
+		async verify(e) {
+			await c(await l(e, { body: "{}" }), {
+				body: "",
+				status: 204
+			}, "Null-body status");
+		}
+	},
+	{
+		fixture: {
+			inputsDef: u,
+			options: {
+				allowedMethods: ["HEAD"],
+				responseData: "ignored"
+			}
+		},
+		name: "omits the response body for HEAD requests",
+		async verify(e) {
+			await c(await l(e, { method: "HEAD" }), {
+				body: "",
+				status: 200
+			}, "HEAD response");
+		}
+	}
+];
+//#endregion
+export { n as maximumWebhookBodyBytes, p as webhookConformanceCases, a as webhookEndpointId, o as webhookOccurrenceId };

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+export interface ArtifactRef {
+    readonly kind: 'artifact';
+    readonly id: string;
+    readonly name: string;
+    readonly mediaType: string | undefined;
+    readonly size: number;
+    readonly digest: string;
+}
+export interface ArtifactPutOptions {
+    readonly name: string;
+    readonly mediaType?: string | undefined;
+}
+export type ArtifactData = Uint8Array | Blob | ReadableStream<Uint8Array>;
+export interface ArtifactCapability {
+    put(data: ArtifactData, options: ArtifactPutOptions): Promise<ArtifactRef>;
+    open(ref: ArtifactRef): Promise<ReadableStream<Uint8Array>>;
+}
+export interface MediaPreviewPayload {
+    readonly type: 'video' | 'audio' | 'markdown' | 'iframe' | 'html';
+    readonly data: string;
+}
+export interface TextPreviewPayload {
+    readonly type: 'json' | 'text' | `text/${string}`;
+    readonly data: unknown;
+}
+export interface ImagePreviewPayload {
+    readonly type: 'image';
+    readonly data: string | readonly string[];
+}
+export interface TablePreviewData {
+    readonly columns: readonly (string | number)[];
+    readonly rows: readonly (readonly (string | number | boolean)[])[];
+    readonly row_count?: number;
+}
+export interface TablePreviewPayload {
+    readonly type: 'table';
+    readonly data: TablePreviewData | string;
+}
+export interface CsvPreviewPayload {
+    readonly type: 'csv';
+    readonly data: string;
+}
+export type PreviewPayload = MediaPreviewPayload | TextPreviewPayload | ImagePreviewPayload | TablePreviewPayload | CsvPreviewPayload;
+export type PreviewType = PreviewPayload['type'];
+export interface TaskLogger {
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+export interface TaskContext<Outputs extends object = Record<string, unknown>> {
+    readonly signal: AbortSignal;
+    readonly flowId: string;
+    readonly runId: string;
+    readonly blockId: string;
+    readonly artifact: ArtifactCapability;
+    readonly fetch: typeof fetch;
+    readonly logger: TaskLogger;
+    output<Handle extends keyof Outputs & string>(handle: Handle, value: Outputs[Handle]): Promise<void>;
+    preview(payload: PreviewPayload, id?: string): Promise<void>;
+    reportProgress(progress: number): Promise<void>;
+}
+export type TaskResult<Outputs extends object> = Partial<Outputs> | void;
+export interface Task<Inputs extends object = Record<string, unknown>, Outputs extends object = Record<string, unknown>> {
+    (inputs: Inputs, context: TaskContext<Outputs>): TaskResult<Outputs> | Promise<TaskResult<Outputs>>;
+}

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@oomol-lab/open-flow",
+  "version": "0.1.0-alpha.0",
+  "description": "TypeScript contracts and Browser runtime for Open Flow.",
+  "license": "Apache-2.0",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts"
+    },
+    "./connector-action": {
+      "types": "./dist/common/connector-action.d.ts",
+      "import": "./dist/common/connector-action.js"
+    },
+    "./connector-proxy": {
+      "types": "./dist/common/connector-proxy.d.ts",
+      "import": "./dist/common/connector-proxy.js"
+    },
+    "./control-api": {
+      "types": "./dist/common/control-api.d.ts",
+      "import": "./dist/common/control-api.js"
+    },
+    "./control-api-conformance": {
+      "types": "./dist/common/control-api-conformance.d.ts",
+      "import": "./dist/common/control-api-conformance.js"
+    },
+    "./cron-trigger": {
+      "types": "./dist/common/cron-trigger.d.ts",
+      "import": "./dist/common/cron-trigger.js"
+    },
+    "./integration-trigger": {
+      "types": "./dist/common/integration-trigger.d.ts",
+      "import": "./dist/common/integration-trigger.js"
+    },
+    "./poll-trigger": {
+      "types": "./dist/common/poll-trigger.d.ts",
+      "import": "./dist/common/poll-trigger.js"
+    },
+    "./provider-triggers": {
+      "types": "./dist/common/provider-triggers.d.ts",
+      "import": "./dist/common/provider-triggers.js"
+    },
+    "./project-change": {
+      "types": "./dist/browser/project-change.d.ts",
+      "import": "./dist/browser/project-change.js"
+    },
+    "./project-encoding": {
+      "types": "./dist/common/project-encoding.d.ts",
+      "import": "./dist/common/project-encoding.js"
+    },
+    "./project-semantics": {
+      "types": "./dist/common/project-semantics.d.ts",
+      "import": "./dist/common/project-semantics.js"
+    },
+    "./run-lifecycle": {
+      "types": "./dist/common/run-lifecycle.d.ts",
+      "import": "./dist/common/run-lifecycle.js"
+    },
+    "./run-events": {
+      "types": "./dist/common/run-events.d.ts",
+      "import": "./dist/common/run-events.js"
+    },
+    "./runtime-contract": {
+      "types": "./dist/common/runtime-contract.d.ts",
+      "import": "./dist/common/runtime-contract.js"
+    },
+    "./scheduler": {
+      "types": "./dist/common/scheduler.d.ts",
+      "import": "./dist/common/scheduler.js"
+    },
+    "./webhook-trigger": {
+      "types": "./dist/common/webhook-trigger.d.ts",
+      "import": "./dist/common/webhook-trigger.js"
+    },
+    "./workbench": {
+      "types": "./dist/browser/workbench.d.ts",
+      "import": "./dist/browser/workbench.js"
+    },
+    "./workbench.css": {
+      "types": "./dist/browser/workbench.css.d.ts",
+      "default": "./dist/browser/workbench.css"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "NOTICE",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "react": "^18.3.1 || ^19.0.0",
+    "react-dom": "^18.3.1 || ^19.0.0"
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  }
+}