@oomol-lab/open-flow 0.1.0-beta.68 → 0.1.0-beta.69

package/dist/common/decision.js

@@ -6571,6 +6571,18 @@ function preprocess(fn, schema) {
 	});
 }
 //#endregion
+//#region src/flow/common/retry.ts
+var nodeRetryLimits = {
+	maxRetries: 5,
+	minIntervalMs: 1e3,
+	maxIntervalMs: 6e4,
+	intervalStepMs: 1e3
+};
+var retryConfigurationSchema = strictObject({
+	maxRetries: number().int().min(0).max(nodeRetryLimits.maxRetries),
+	intervalMs: number().int().min(nodeRetryLimits.minIntervalMs).max(nodeRetryLimits.maxIntervalMs).multipleOf(nodeRetryLimits.intervalStepMs)
+});
+//#endregion
 //#region src/flow/common/triggerScheduleSchema.ts
 var triggerScheduleSchema = array(union([object({
 	type: literal("cron"),
@@ -6616,6 +6628,7 @@ var source = union([object({
 	kind: literal("node"),
 	nodeId: text,
 	output: text,
+	system: literal(true).optional(),
 	field: text.optional()
 }), object({
 	kind: literal("binding"),
@@ -6874,7 +6887,9 @@ var base = {
 	name: text.optional(),
 	description: text.optional(),
 	icon: text.optional(),
-	timeoutMs: number().optional()
+	timeoutMs: number().optional(),
+	retry: retryConfigurationSchema.optional(),
+	onError: _enum(["stop", "error"]).optional()
 };
 var node = union([
 	strictObject({
@@ -6995,7 +7010,8 @@ object({
 		literal(5),
 		literal(6),
 		literal(7),
-		literal(8)
+		literal(8),
+		literal(9)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -7056,6 +7072,13 @@ var shapes = {
 	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
+		object({
+			...at,
+			kind: literal("graph.node.field.set"),
+			field: literal("retry"),
+			before: retryConfigurationSchema.optional(),
+			value: retryConfigurationSchema.optional()
+		}),
 		object({
 			...at,
 			kind: literal("graph.node.field.set"),
@@ -7069,7 +7092,8 @@ var shapes = {
 			field: _enum([
 				"description",
 				"icon",
-				"name"
+				"name",
+				"onError"
 			]),
 			before: text.optional(),
 			value: text.optional()

package/dist/common/engine-contract.d.ts

@@ -4,6 +4,6 @@ export interface EngineContract {
     readonly platformModule: string;
     readonly platformSource: string;
 }
-export declare const currentEngineContract = "open-flow-engine/v5";
-export declare const nodejsEngineContract = "open-flow-engine/v5/nodejs-compat-v1";
+export declare const currentEngineContract = "open-flow-engine/v6";
+export declare const nodejsEngineContract = "open-flow-engine/v6/nodejs-compat-v1";
 export declare function findEngineContract(contract: string): EngineContract | undefined;

package/dist/common/event-source-definition.d.ts

@@ -7,33 +7,51 @@ export interface SourceConfiguration {
     readonly state: Readonly<Record<string, JsonValue>>;
 }
 export interface SourceEvent {
+    readonly ordering?: {
+        readonly key: string;
+        readonly version: number;
+    };
     readonly id: string;
     readonly type: string;
     readonly payload: Readonly<Record<string, JsonValue>>;
+    readonly matches: readonly string[];
 }
 export interface SourceSubscription {
     readonly key: string;
     readonly config: Readonly<Record<string, JsonValue>>;
 }
-export interface EventSourceDefinition<Create, Update, View> {
+export interface EventSourceDefinition {
     readonly kind: string;
     readonly provider: string;
+    readonly triggerId: string;
     readonly maximumBodyBytes: number;
-    readonly initialize: (input: Create, accountId: string | undefined) => SourceConfiguration;
-    readonly update: (source: SourceConfiguration, input: Update) => SourceConfiguration;
-    readonly view: (source: SourceConfiguration) => View;
-    readonly ready: (source: SourceConfiguration) => boolean;
-    readonly receive: (source: SourceConfiguration, bytes: Uint8Array, headers: Headers, now: number) => Promise<{
-        readonly response: Response;
-        readonly state: SourceConfiguration['state'];
-    } | {
-        readonly event: SourceEvent;
-    }>;
-    readonly matches: (config: Readonly<Record<string, JsonValue>>, event: SourceEvent) => boolean;
-    readonly resources: {
-        readonly triggerId: string;
-        readonly requests: (source: SourceConfiguration, provider: string, config: Readonly<Record<string, JsonValue>>) => readonly SourceSubscription[];
-    };
+    readonly applicationIngress: boolean;
+    readonly managed: boolean;
 }
+export type SourceOperation = {
+    readonly action: 'initialize';
+    readonly input: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly action: 'update';
+    readonly source: SourceConfiguration;
+    readonly input: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly action: 'inspect';
+    readonly source: SourceConfiguration;
+} | {
+    readonly action: 'prepare';
+    readonly source: SourceConfiguration;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly endpointUrl?: string;
+} | {
+    readonly action: 'receive';
+    readonly source: SourceConfiguration;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly rawBody: string;
+    readonly consumers: readonly {
+        readonly id: string;
+        readonly config: Readonly<Record<string, JsonValue>>;
+    }[];
+};
 export declare class SourceIdentityError extends Error {
 }

package/dist/common/event-source.d.ts

@@ -1,6 +1,64 @@
-import { feishuApplication } from './event-source-feishu.js';
-export type { EventSourceDefinition, SourceConfiguration, SourceEvent, SourceSubscription } from './event-source-definition.js';
+import type { EventSourceDefinition, SourceConfiguration } from './event-source-definition.js';
+import { z } from 'zod';
+import { eventSourceViewSchema } from './event-sources.js';
+export type { EventSourceDefinition, SourceConfiguration, SourceEvent, SourceSubscription, SourceOperation } from './event-source-definition.js';
 export { SourceIdentityError } from './event-source-definition.js';
-export { feishuApplication } from './event-source-feishu.js';
-declare const definitions: readonly (typeof feishuApplication)[];
-export declare function eventSourceDefinition(kind: string): (typeof definitions)[number];
+export declare function eventSourceDefinition(kind: string): EventSourceDefinition;
+export declare const sourceConfigurationSchema: z.ZodObject<{
+    identity: z.ZodString;
+    eventTypes: z.ZodArray<z.ZodString>;
+    config: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    secrets: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    state: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strip>;
+export declare function sourceReady(source: SourceConfiguration, now?: number): boolean;
+export declare function sourceView(source: SourceConfiguration, now?: number): z.infer<typeof eventSourceViewSchema>;
+export declare const sourceResultSchema: z.ZodObject<{
+    source: z.ZodObject<{
+        identity: z.ZodString;
+        eventTypes: z.ZodArray<z.ZodString>;
+        config: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        secrets: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        state: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const preparedSourceSchema: z.ZodObject<{
+    source: z.ZodObject<{
+        identity: z.ZodString;
+        eventTypes: z.ZodArray<z.ZodString>;
+        config: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        secrets: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        state: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip>;
+    subscriptions: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const sourceReceiptSchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodObject<{
+        identity: z.ZodString;
+        eventTypes: z.ZodArray<z.ZodString>;
+        config: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        secrets: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        state: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip>>;
+    response: z.ZodOptional<z.ZodObject<{
+        status: z.ZodNumber;
+        body: z.ZodString;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+    event: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        payload: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        matches: z.ZodArray<z.ZodString>;
+        ordering: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SourceResult = z.infer<typeof sourceResultSchema>;
+export type PreparedSource = z.infer<typeof preparedSourceSchema>;
+export type SourceReceipt = z.infer<typeof sourceReceiptSchema>;