@versori/run 0.2.13 → 0.2.15

package/script/src/interpreter/durable/ObservableCompiler.d.ts

@@ -0,0 +1,35 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { Task } from '../../dsl/Task.js';
+import { Logger } from '../../observability/logging/Logger.js';
+import { ContextOperatorFunction, TaskCompiler, TriggerCompiler } from './compilers/types.js';
+import { Trigger } from '../../dsl/Trigger.js';
+import { ContextProvider } from '../../context/ContextProvider.js';
+import { ContextImpl } from '../../context/Context.js';
+import { ConfigReader, ConnectionProvider, RoundTripperFactory } from '../../dsl/http/types.js';
+import { Router } from 'express';
+import { Tracer } from '@opentelemetry/api';
+import { QueueAPI } from './Queue.js';
+export type DurableCompilerContext = {
+    compiler: ObservableCompiler;
+    log: Logger;
+    tracer: Tracer;
+    contextProvider: ContextProvider;
+    roundTripperFactory: RoundTripperFactory;
+    connectionProvider: ConnectionProvider;
+    queueProvider: QueueAPI;
+    webhookRouter: Router;
+    cronRouter: Router;
+    configReader: ConfigReader;
+    cronRegistry: Map<string, string>;
+};
+export type CompilerFunc<In = any, Out = any, T extends Task<In, Out> = Task<In, Out>> = (ctx: DurableCompilerContext, task: T) => OperatorFunction<In, Out>;
+export declare class ObservableCompiler {
+    private taskCompilers;
+    private triggerCompilers;
+    constructor();
+    compileTask<In = any, Out = any, Index = void>(ctx: DurableCompilerContext, task: Task<In, Out>): ContextOperatorFunction<In, Out, Index>;
+    compileTrigger<Out = any, T extends Trigger<Out> = Trigger<Out>>(ctx: DurableCompilerContext, trigger: T, signal: AbortSignal): Observable<ContextImpl<Out, void>>;
+    registerTask<In, Out, T extends Task<In, Out>>(compiler: TaskCompiler<In, Out, T>): void;
+    registerTrigger<Out, T extends Trigger<Out>>(compiler: TriggerCompiler<Out, T>): void;
+}
+//# sourceMappingURL=ObservableCompiler.d.ts.map

package/script/src/interpreter/durable/ObservableCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservableCompiler.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/durable/ObservableCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AACpD,OAAO,EAAE,IAAI,EAAY,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAO/D,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE9F,OAAO,EAAE,OAAO,EAAe,MAAM,sBAAsB,CAAC;AAG5D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAChG,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,MAAM,MAAM,sBAAsB,GAAG;IACjC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,eAAe,CAAC;IACjC,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,aAAa,EAAE,QAAQ,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC,SAAS,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,CACrF,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,CAAC,KACN,gBAAgB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AAE/B,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,aAAa,CAAkD;IACvE,OAAO,CAAC,gBAAgB,CAAgD;;IAkBxE,WAAW,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,GAAG,IAAI,EACzC,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GACpB,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC;IAe1C,cAAc,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,EAC3D,GAAG,EAAE,sBAAsB,EAC3B,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,WAAW,GACpB,UAAU,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAgBrC,YAAY,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,SAAS,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IAKjF,eAAe,CAAC,GAAG,EAAE,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,eAAe,CAAC,GAAG,EAAE,CAAC,CAAC;CAIjF"}

package/script/src/interpreter/durable/ObservableCompiler.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableCompiler = void 0;
+const Task_js_1 = require("../../dsl/Task.js");
+const background_js_1 = require("./compilers/background.js");
+const catch_js_1 = require("./compilers/catch.js");
+const chain_js_1 = require("./compilers/chain.js");
+const fn_js_1 = require("./compilers/fn.js");
+const parallel_js_1 = require("./compilers/parallel.js");
+const serial_js_1 = require("./compilers/serial.js");
+const unpack_js_1 = require("./compilers/unpack.js");
+const Trigger_js_1 = require("../../dsl/Trigger.js");
+const schedule_js_1 = require("./compilers/schedule.js");
+const webhook_js_1 = require("./compilers/webhook.js");
+const http_js_1 = require("./compilers/http.js");
+const durableworkflow_js_1 = require("./compilers/durableworkflow.js");
+class ObservableCompiler {
+    constructor() {
+        Object.defineProperty(this, "taskCompilers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "triggerCompilers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // Register all available compilers
+        this.registerTask(parallel_js_1.parallelCompiler);
+        this.registerTask(serial_js_1.serialCompiler);
+        this.registerTask(catch_js_1.catchCompiler);
+        this.registerTask(chain_js_1.chainCompiler);
+        this.registerTask(fn_js_1.fnCompiler);
+        this.registerTask(background_js_1.backgroundCompiler);
+        this.registerTask(unpack_js_1.unpackCompiler);
+        this.registerTask(http_js_1.httpCompiler);
+        this.registerTrigger(schedule_js_1.scheduleCompiler);
+        this.registerTrigger(webhook_js_1.webhookCompiler);
+        this.registerTrigger(durableworkflow_js_1.durableWorkflowCompiler);
+    }
+    compileTask(ctx, task) {
+        const compiler = this.taskCompilers.get(task[Task_js_1.TaskType]);
+        if (!compiler) {
+            throw new Error(`No compiler registered for task type: ${task[Task_js_1.TaskType]}`);
+        }
+        if (!(task instanceof compiler.ctor)) {
+            throw new Error(`Task type mismatch: expected ${compiler.ctor.name}, got ${task.constructor.name}`);
+        }
+        return compiler.compile(ctx, task);
+    }
+    compileTrigger(ctx, trigger, signal) {
+        const compiler = this.triggerCompilers.get(trigger[Trigger_js_1.TriggerType]);
+        if (!compiler) {
+            throw new Error(`No compiler registered for trigger type: ${trigger[Trigger_js_1.TriggerType]}`);
+        }
+        if (!(trigger instanceof compiler.ctor)) {
+            throw new Error(`Trigger type mismatch: expected ${compiler.ctor.name}, got ${trigger.constructor.name}`);
+        }
+        return compiler.compile(ctx, trigger, signal);
+    }
+    registerTask(compiler) {
+        const task = new compiler.ctor();
+        this.taskCompilers.set(task[Task_js_1.TaskType], compiler);
+    }
+    registerTrigger(compiler) {
+        const trigger = new compiler.ctor();
+        this.triggerCompilers.set(trigger[Trigger_js_1.TriggerType], compiler);
+    }
+}
+exports.ObservableCompiler = ObservableCompiler;

package/script/src/interpreter/durable/Queue.d.ts

@@ -0,0 +1,60 @@
+import { Logger } from '../../observability/mod.js';
+export type WorkflowMsgMetadata = {
+    parentWorkflowId?: string;
+    executionId?: string;
+    activationId?: string;
+    userId?: string;
+};
+export type Workflows = {
+    workflows: WorkflowMsg[];
+};
+export type WorkflowMsg = {
+    id?: string;
+    projectId?: string;
+    group: string;
+    payload?: string;
+    output?: string;
+    status?: 'available' | 'locked' | 'completed' | 'failed';
+    attempt?: number;
+    timeout?: string;
+    createdAt?: string;
+    metadata?: WorkflowMsgMetadata;
+};
+export type CompleteWorkflowRequest = {
+    id: string;
+    output?: string;
+    status: 'completed' | 'failed';
+};
+export type FetchWorkflowsRequest = {
+    ttl?: number;
+    limit?: number;
+    group: string;
+    projectId?: string;
+};
+export type RescheduleWorkflowRequest = {
+    id: string;
+    after: string;
+};
+export type SubmitWorkflowsRequest = {
+    workflows: WorkflowMsg[];
+};
+export interface QueueAPI {
+    complete(request: CompleteWorkflowRequest): Promise<void>;
+    submit(request: SubmitWorkflowsRequest): Promise<Workflows>;
+    fetchWorkflows(request: FetchWorkflowsRequest): Promise<Workflows | undefined>;
+    reschedule(request: RescheduleWorkflowRequest): Promise<void>;
+    poll(workflowId: string): Promise<WorkflowMsg>;
+}
+export declare class QueueImpl implements QueueAPI {
+    private baseUrl;
+    private log;
+    private projectId;
+    constructor(baseUrl: string, projectId: string, log: Logger);
+    static fromEnv(log: Logger): QueueImpl;
+    complete(request: CompleteWorkflowRequest): Promise<void>;
+    submit(request: SubmitWorkflowsRequest): Promise<Workflows>;
+    fetchWorkflows(request: FetchWorkflowsRequest): Promise<Workflows | undefined>;
+    reschedule(request: RescheduleWorkflowRequest): Promise<void>;
+    poll(workflowId: string): Promise<WorkflowMsg>;
+}
+//# sourceMappingURL=Queue.d.ts.map

package/script/src/interpreter/durable/Queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Queue.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/durable/Queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAIpD,MAAM,MAAM,mBAAmB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACpB,SAAS,EAAE,WAAW,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,mBAAmB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACjC,SAAS,EAAE,WAAW,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,QAAQ;IACrB,QAAQ,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,MAAM,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5D,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAC/E,UAAU,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAClD;AAED,qBAAa,SAAU,YAAW,QAAQ;IACtC,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,GAAG,CAAS;IAEpB,OAAO,CAAC,SAAS,CAAS;gBAEd,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAM3D,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAchC,QAAQ,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBzD,MAAM,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,SAAS,CAAC;IA0B3D,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IA8B9E,UAAU,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB7D,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;CAevD"}

package/script/src/interpreter/durable/Queue.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueImpl = void 0;
+const mod_js_1 = require("../../mod.js");
+const constants_js_1 = require("../../dsl/http/versori/constants.js");
+class QueueImpl {
+    constructor(baseUrl, projectId, log) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "projectId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.baseUrl = baseUrl;
+        this.log = log;
+        this.projectId = projectId;
+    }
+    static fromEnv(log) {
+        // TODO make these environment variables configurable in constants/ts
+        const baseUrl = Deno.env.get(constants_js_1.envVarWorkflowApiBaseURL);
+        const _log = log || new mod_js_1.ConsoleLogger('debug');
+        const projectId = Deno.env.get(constants_js_1.envVarProjectId) || 'default-project';
+        if (!baseUrl) {
+            throw new Error('Missing required environment variables');
+        }
+        return new QueueImpl(baseUrl, projectId, _log);
+    }
+    async complete(request) {
+        const resp = await fetch(`${this.baseUrl}/v1/workflows/complete`, {
+            method: 'POST',
+            body: JSON.stringify({
+                id: request.id,
+                output: request.output,
+                status: request.status,
+            }),
+        });
+        if (!resp.ok) {
+            this.log.error('Failed to complete workflow', {
+                id: request.id,
+                output: request.output,
+                status: request.status,
+            });
+            throw new Error('Failed to complete workflow');
+        }
+        return;
+    }
+    async submit(request) {
+        // Ensure all workflows have the projectId set
+        const workflows = request.workflows.map((w) => ({
+            ...w,
+            projectId: this.projectId || w.projectId,
+        }));
+        const resp = await fetch(`${this.baseUrl}/v1/workflows/submit`, {
+            method: 'POST',
+            body: JSON.stringify({
+                workflows: workflows,
+            }),
+        });
+        if (!resp.ok) {
+            this.log.error('Failed to submit workflows', {
+                workflows: workflows,
+            });
+            throw new Error('Failed to submit workflows');
+        }
+        const result = (await resp.json());
+        return result;
+    }
+    async fetchWorkflows(request) {
+        const resp = await fetch(`${this.baseUrl}/v1/workflows/fetch`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ttl: request.ttl,
+                limit: request.limit,
+                group: request.group,
+                projectId: this.projectId || request.projectId,
+            }),
+        });
+        if (!resp.ok) {
+            this.log.error('Failed to fetch workflows', {
+                ttl: request.ttl,
+                limit: request.limit,
+                group: request.group,
+                projectId: this.projectId || request.projectId,
+            });
+            throw new Error('Failed to fetch workflows');
+        }
+        if (resp.status === 204) {
+            return undefined;
+        }
+        const result = (await resp.json());
+        return result;
+    }
+    async reschedule(request) {
+        const resp = await fetch(`${this.baseUrl}/v1/workflows/reschedule`, {
+            method: 'POST',
+            body: JSON.stringify({
+                id: request.id,
+                after: request.after,
+            }),
+        });
+        if (!resp.ok) {
+            this.log.error('Failed to reschedule workflow', {
+                id: request.id,
+                after: request.after,
+            });
+            throw new Error('Failed to reschedule workflow');
+        }
+        return;
+    }
+    async poll(workflowId) {
+        // this endpoint returns a 404 if the workflow is not completed
+        const resp = await fetch(`${this.baseUrl}/v1/workflows/fetch/${workflowId}`, {
+            method: 'GET',
+        });
+        if (!resp.ok) {
+            this.log.error('Failed to poll workflow', { workflowId });
+            throw new Error('Failed to poll workflow');
+        }
+        const result = (await resp.json());
+        return result;
+    }
+}
+exports.QueueImpl = QueueImpl;

package/script/src/interpreter/durable/compilers/background.d.ts

@@ -0,0 +1,4 @@
+import { BackgroundTask } from '../../../dsl/tasks/BackgroundTask.js';
+import { TaskCompiler } from './types.js';
+export declare const backgroundCompiler: TaskCompiler<any, any, BackgroundTask<any, any>>;
+//# sourceMappingURL=background.d.ts.map

package/script/src/interpreter/durable/compilers/background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/background.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAEtE,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AA0CnE,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,CAG/E,CAAC"}

package/script/src/interpreter/durable/compilers/background.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundCompiler = void 0;
+const rxjs_1 = require("rxjs");
+const BackgroundTask_js_1 = require("../../../dsl/tasks/BackgroundTask.js");
+function compileBackground(ctx, task) {
+    const base = ctx.compiler.compileTask(ctx, task._base);
+    return (src) => src.pipe((0, rxjs_1.connect)((shared$) => (0, rxjs_1.merge)(shared$.pipe((0, rxjs_1.mergeMap)((ctx) => base((0, rxjs_1.of)(ctx)).pipe((0, rxjs_1.subscribeOn)(rxjs_1.asyncScheduler), (0, rxjs_1.tap)({
+        next: (ctx) => ctx.log.debug('Background task emitted a value', {
+            data: ctx.data,
+        }),
+        complete: () => ctx.log.debug('Background task completed'),
+    }), (0, rxjs_1.catchError)((error) => {
+        ctx.log.error('Error in background task', {
+            error,
+            inputData: ctx.data,
+            executionId: ctx.executionId,
+        });
+        return rxjs_1.EMPTY;
+    }), (0, rxjs_1.ignoreElements)()))), shared$.pipe((0, rxjs_1.map)((ctx) => ctx.withData(void 0))))));
+}
+exports.backgroundCompiler = {
+    ctor: BackgroundTask_js_1.BackgroundTask,
+    compile: compileBackground,
+};

package/script/src/interpreter/durable/compilers/catch.d.ts

@@ -0,0 +1,4 @@
+import { CatchTask } from '../../../dsl/tasks/CatchTask.js';
+import { TaskCompiler } from './types.js';
+export declare const catchCompiler: TaskCompiler<any, any, CatchTask<any, any>>;
+//# sourceMappingURL=catch.d.ts.map

package/script/src/interpreter/durable/compilers/catch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/catch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG5D,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AAmDnE,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAGrE,CAAC"}

package/script/src/interpreter/durable/compilers/catch.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.catchCompiler = void 0;
+const rxjs_1 = require("rxjs");
+const CatchTask_js_1 = require("../../../dsl/tasks/CatchTask.js");
+const ExecutionError_js_1 = require("../ExecutionError.js");
+function compileCatch(compilerCtx, task) {
+    const baseOperator = compilerCtx.compiler.compileTask(compilerCtx, task._base);
+    const errorOperator = compilerCtx.compiler.compileTask(compilerCtx, task._errorHandler);
+    return (src) => src.pipe((0, rxjs_1.mergeMap)((ctx) => {
+        return baseOperator((0, rxjs_1.of)(ctx)).pipe((0, rxjs_1.catchError)((error) => {
+            return compilerCtx.tracer.startActiveSpan(`catch`, (span) => {
+                span.setAttribute('execution.id', ctx.executionId);
+                span.setAttribute('task.type', 'catch');
+                if (error instanceof Error) {
+                    span.recordException(error);
+                    span.setAttribute('error.message', error.message);
+                    span.setAttribute('error.stack', error.stack ?? '');
+                    span.end();
+                    ctx.log.error('execution has encountered an error', {
+                        error: error.message,
+                        stack: error.stack,
+                    });
+                    return errorOperator((0, rxjs_1.of)(ctx.withData(new ExecutionError_js_1.ExecutionError(ctx, error.message, { cause: error }))));
+                }
+                ctx.log.error('execution has encountered an error', {
+                    error: error,
+                });
+                span.setAttribute('error', `${error}`);
+                span.end();
+                return errorOperator((0, rxjs_1.of)(ctx.withData(new ExecutionError_js_1.ExecutionError(ctx, `${error}`, { cause: error }))));
+            });
+        }));
+    }));
+}
+exports.catchCompiler = {
+    ctor: CatchTask_js_1.CatchTask,
+    compile: compileCatch,
+};

package/script/src/interpreter/durable/compilers/chain.d.ts

@@ -0,0 +1,3 @@
+import { TaskCompiler } from './types.js';
+export declare const chainCompiler: TaskCompiler<any, any, any>;
+//# sourceMappingURL=chain.d.ts.map

package/script/src/interpreter/durable/compilers/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/chain.ts"],"names":[],"mappings":"AAIA,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AAYnE,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAGrD,CAAC"}

package/script/src/interpreter/durable/compilers/chain.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainCompiler = void 0;
+const ChainTask_js_1 = require("../../../dsl/tasks/ChainTask.js");
+function compileChain(ctx, task) {
+    const operators = task.tasks.map((t) => ctx.compiler.compileTask(ctx, t));
+    return (src) => operators.reduce((acc, curr) => curr(acc), src);
+}
+exports.chainCompiler = {
+    ctor: ChainTask_js_1.ChainTask,
+    compile: compileChain,
+};

package/script/src/interpreter/durable/compilers/durableworkflow.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { DurableCompilerContext } from '../mod.js';
+import { ContextImpl } from '../../../mod.js';
+import { DurableWorkflowData, DurableWorkflowTrigger } from '../../../dsl/triggers/DurableTrigger.js';
+import { TriggerCompiler } from './mod.js';
+export declare function compileDurableWorkflow(ctx: DurableCompilerContext, trigger: DurableWorkflowTrigger, signal: AbortSignal): Observable<ContextImpl<DurableWorkflowData>>;
+export declare const durableWorkflowCompiler: TriggerCompiler<DurableWorkflowData, DurableWorkflowTrigger>;
+//# sourceMappingURL=durableworkflow.d.ts.map

package/script/src/interpreter/durable/compilers/durableworkflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durableworkflow.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/durableworkflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EACH,mBAAmB,EACnB,sBAAsB,EACzB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3C,wBAAgB,sBAAsB,CAClC,GAAG,EAAE,sBAAsB,EAC3B,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,WAAW,GACpB,UAAU,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,CAwD9C;AAED,eAAO,MAAM,uBAAuB,EAAE,eAAe,CAAC,mBAAmB,EAAE,sBAAsB,CAI5F,CAAC"}

package/script/src/interpreter/durable/compilers/durableworkflow.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.durableWorkflowCompiler = void 0;
+exports.compileDurableWorkflow = compileDurableWorkflow;
+const rxjs_1 = require("rxjs");
+const DurableTrigger_js_1 = require("../../../dsl/triggers/DurableTrigger.js");
+function compileDurableWorkflow(ctx, trigger, signal) {
+    return new rxjs_1.Observable((subscriber) => {
+        function cleanup() {
+            ctx.log.debug('webhook trigger stopped');
+            subscriber.complete();
+        }
+        signal.addEventListener('abort', cleanup, { once: true });
+        (async () => {
+            while (true) {
+                if (signal.aborted) {
+                    cleanup();
+                    break;
+                }
+                try {
+                    // Right now the API itself will hang for a period of time if no workflows are available.
+                    // so we don't need to add a delay here.
+                    const wfs = await ctx.queueProvider.fetchWorkflows({
+                        group: trigger.id,
+                        ttl: trigger.options.ttl,
+                        limit: trigger.options.limit,
+                    });
+                    if (!wfs) {
+                        continue; // No workflows found, continue polling
+                    }
+                    for (const wf of wfs.workflows) {
+                        const data = JSON.parse(atob(wf.payload ?? "{}"));
+                        let activation;
+                        if (wf.metadata?.activationId) {
+                            activation = await ctx.connectionProvider.getActivation(wf.metadata.activationId);
+                        }
+                        const newContext = ctx.contextProvider.create(data, {
+                            activation: activation,
+                            workflowId: wf.id,
+                        });
+                        subscriber.next(newContext);
+                    }
+                }
+                catch (error) {
+                    ctx.log.error('Error fetching workflows', { error });
+                }
+            }
+        })();
+        return () => {
+            signal.removeEventListener('abort', cleanup);
+            ctx.log.debug('durable workflow cleanup');
+        };
+    });
+}
+exports.durableWorkflowCompiler = {
+    ctor: DurableTrigger_js_1.DurableWorkflowTrigger,
+    compile: compileDurableWorkflow,
+};

package/script/src/interpreter/durable/compilers/fn.d.ts

@@ -0,0 +1,4 @@
+import { FnTask } from '../../../dsl/tasks/FnTask.js';
+import { TaskCompiler } from './types.js';
+export declare const fnCompiler: TaskCompiler<any, any, FnTask<any, any>>;
+//# sourceMappingURL=fn.d.ts.map

package/script/src/interpreter/durable/compilers/fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/fn.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAEtD,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AA4BnE,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAG/D,CAAC"}

package/script/src/interpreter/durable/compilers/fn.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnCompiler = void 0;
+const rxjs_1 = require("rxjs");
+const FnTask_js_1 = require("../../../dsl/tasks/FnTask.js");
+function compileFn(compilerCtx, task) {
+    return (src) => src.pipe((0, rxjs_1.tap)({
+        complete: () => compilerCtx.log.debug('fn.complete')
+    }), (0, rxjs_1.mergeMap)(async (ctx) => {
+        return await compilerCtx.tracer.startActiveSpan(`fn-${task.id}`, async (span) => {
+            span.setAttribute('task.id', task.id);
+            span.setAttribute('execution.id', ctx.executionId);
+            if (typeof ctx.idx === 'number') {
+                span.end();
+                return ctx.withData(await task._fn(ctx, ctx.idx));
+            }
+            span.end();
+            return ctx.withData(await task._fn(ctx));
+        });
+    }));
+}
+exports.fnCompiler = {
+    ctor: FnTask_js_1.FnTask,
+    compile: compileFn,
+};

package/script/src/interpreter/durable/compilers/http.d.ts

@@ -0,0 +1,4 @@
+import { HttpTaskImpl } from '../../../dsl/tasks/HttpTask.js';
+import { TaskCompiler } from './types.js';
+export declare const httpCompiler: TaskCompiler<any, any, HttpTaskImpl<any, any, any>>;
+//# sourceMappingURL=http.d.ts.map

package/script/src/interpreter/durable/compilers/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/http.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE/E,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AAyDnE,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAG5E,CAAC"}

package/script/src/interpreter/durable/compilers/http.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpCompiler = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const HttpTask_js_1 = require("../../../dsl/tasks/HttpTask.js");
+function compileHttp(compilerCtx, task) {
+    const roundtripper = compilerCtx.roundTripperFactory.create(task.opts.connection);
+    const dynamicFetcher = compilerCtx.roundTripperFactory.createDynamic(task.opts.connection);
+    async function http(ctx) {
+        const _fetch = await roundtripper;
+        const _dynamicFetcher = await dynamicFetcher;
+        const httpContext = new HttpTask_js_1.HttpContextImpl(ctx, {}, _fetch, _dynamicFetcher);
+        const result = await task.fn(httpContext);
+        return ctx.withData(result);
+    }
+    return (src) => src.pipe((0, operators_1.tap)({
+        complete: () => compilerCtx.log.debug('http.complete'),
+    }), (0, rxjs_1.mergeMap)(async (ctx) => {
+        return compilerCtx.tracer.startActiveSpan(`http-${task.id}`, async (span) => {
+            span.setAttribute('task.id', task.id);
+            span.setAttribute('task.type', 'http');
+            span.setAttribute('execution.id', ctx.executionId);
+            span.setAttribute('connection.name', task.opts.connection);
+            try {
+                let result = await http(ctx);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    span.recordException(error);
+                }
+                else {
+                    span.recordException(new Error(String(error)));
+                }
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }));
+}
+exports.httpCompiler = {
+    ctor: HttpTask_js_1.HttpTaskImpl,
+    compile: compileHttp,
+};

package/script/src/interpreter/durable/compilers/mod.d.ts

@@ -0,0 +1,2 @@
+export type * from './types.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/src/interpreter/durable/compilers/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/mod.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAC"}

package/script/src/interpreter/durable/compilers/mod.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/src/interpreter/durable/compilers/parallel.d.ts

@@ -0,0 +1,4 @@
+import { ParallelTask } from '../../../dsl/tasks/ParallelTask.js';
+import { TaskCompiler } from './types.js';
+export declare const parallelCompiler: TaskCompiler<any, any, ParallelTask<any, any, any, any>>;
+//# sourceMappingURL=parallel.d.ts.map

package/script/src/interpreter/durable/compilers/parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/durable/compilers/parallel.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AAqCnE,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAGrF,CAAC"}

package/script/src/interpreter/durable/compilers/parallel.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelCompiler = void 0;
+const rxjs_1 = require("rxjs");
+const ParallelTask_js_1 = require("../../../dsl/tasks/ParallelTask.js");
+function compileParallel(ctx, task) {
+    const baseOperator = ctx.compiler.compileTask(ctx, task._base);
+    const eachOperator = ctx.compiler.compileTask(ctx, task._each);
+    return (src) => src.pipe(baseOperator, (0, rxjs_1.mergeMap)((ctx) => {
+        return (0, rxjs_1.from)(ctx.data).pipe((0, rxjs_1.map)((data, idx) => ctx.withData(data).setIndex(idx)), 
+        // Process items in parallel using mergeMap
+        (0, rxjs_1.mergeMap)((item) => eachOperator((0, rxjs_1.of)(item)).pipe((0, rxjs_1.map)((result) => result.setIndex(item.idx)))), (0, rxjs_1.toArray)(), (0, rxjs_1.map)((results) => {
+            // Sort by original index to maintain order
+            results.sort((a, b) => a.idx - b.idx);
+            return ctx.withData(results.map((r) => r.data));
+        }));
+    }));
+}
+exports.parallelCompiler = {
+    ctor: ParallelTask_js_1.ParallelTask,
+    compile: compileParallel,
+};

package/script/src/interpreter/durable/compilers/schedule.d.ts

@@ -0,0 +1,4 @@
+import { ScheduleData, ScheduleTrigger } from '../../../dsl/triggers/ScheduleTrigger.js';
+import { TriggerCompiler } from './types.js';
+export declare const scheduleCompiler: TriggerCompiler<ScheduleData, ScheduleTrigger>;
+//# sourceMappingURL=schedule.d.ts.map