@versori/run 0.0.1-alpha.0

package/script/dsl/tasks/SerialTask.js

@@ -0,0 +1,56 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerialTask = void 0;
+const ensureTask_js_1 = require("../ensureTask.js");
+const Task_js_1 = require("../Task.js");
+const BackgroundTask_js_1 = require("./BackgroundTask.js");
+const CatchTask_js_1 = require("./CatchTask.js");
+const ChainTask_js_1 = require("./ChainTask.js");
+const UnpackTask_js_1 = require("./UnpackTask.js");
+/**
+ * SerialTask is a Task which expects an array of elements as input, and applies a Task to each element.
+ *
+ * The output of the SerialTask is an array of the outputs of the each element.
+ */
+class SerialTask {
+    constructor(base, task) {
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Serial'
+        });
+        Object.defineProperty(this, "_base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_each", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._base = base;
+        this._each = task;
+    }
+    then(task) {
+        return new ChainTask_js_1.ChainTask(this.clone(), (0, ensureTask_js_1.ensureTask)(task));
+    }
+    catch(task) {
+        return new CatchTask_js_1.CatchTask(this.clone(), (0, ensureTask_js_1.ensureTask)(task));
+    }
+    background() {
+        return new BackgroundTask_js_1.BackgroundTask(this.clone());
+    }
+    unpack(mapper) {
+        return new UnpackTask_js_1.UnpackTask(this.clone(), mapper);
+    }
+    clone() {
+        return new SerialTask(this._base.clone(), this._each.clone());
+    }
+}
+exports.SerialTask = SerialTask;
+_a = Task_js_1.TaskType;

package/script/dsl/tasks/UnpackTask.d.ts

@@ -0,0 +1,15 @@
+import { ArrayTask, Task, Taskable, TaskType } from '../Task.js';
+export declare class UnpackTask<In, Out, UnpackedOut = Out> implements ArrayTask<In, UnpackedOut> {
+    [TaskType]: string;
+    _base: Task<In, Out>;
+    _mapper?: (data: Out) => UnpackedOut[];
+    constructor(base: Task<In, Out>, mapper?: (data: Out) => UnpackedOut[]);
+    parallel<NextOut>(task: Taskable<UnpackedOut, NextOut, number>): Task<In, NextOut[]>;
+    serial<NextOut>(task: Taskable<UnpackedOut, NextOut, number>): Task<In, NextOut[]>;
+    then<NextOut>(task: Taskable<UnpackedOut[], NextOut>): Task<In, NextOut>;
+    catch<NextOut>(task: Taskable<Error, NextOut>): Task<In, NextOut>;
+    background(): Task<In, void>;
+    unpack<NextOut>(mapper?: (data: UnpackedOut[]) => NextOut[]): ArrayTask<In, NextOut>;
+    clone(): Task<In, UnpackedOut[]>;
+}
+//# sourceMappingURL=UnpackTask.d.ts.map

package/script/dsl/tasks/UnpackTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnpackTask.d.ts","sourceRoot":"","sources":["../../../src/dsl/tasks/UnpackTask.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAOjE,qBAAa,UAAU,CAAC,EAAE,EAAE,GAAG,EAAE,WAAW,GAAG,GAAG,CAC9C,YAAW,SAAS,CAAC,EAAE,EAAE,WAAW,CAAC;IAErC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAY;IAE9B,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IAErB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,WAAW,EAAE,CAAC;gBAE3B,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,WAAW,EAAE;IAKtE,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IAIpF,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IAIlF,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,WAAW,EAAE,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIxE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC;IAIjE,UAAU,IAAI,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC;IAI5B,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,OAAO,EAAE,GAAG,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC;IAIpF,KAAK,IAAI,IAAI,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC;CAGnC"}

package/script/dsl/tasks/UnpackTask.js

@@ -0,0 +1,58 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnpackTask = void 0;
+const ensureTask_js_1 = require("../ensureTask.js");
+const Task_js_1 = require("../Task.js");
+const BackgroundTask_js_1 = require("./BackgroundTask.js");
+const CatchTask_js_1 = require("./CatchTask.js");
+const ChainTask_js_1 = require("./ChainTask.js");
+const SerialTask_js_1 = require("./SerialTask.js");
+const ParallelTask_js_1 = require("./ParallelTask.js");
+class UnpackTask {
+    constructor(base, mapper) {
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Unpack'
+        });
+        Object.defineProperty(this, "_base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._base = base;
+        this._mapper = mapper;
+    }
+    parallel(task) {
+        return new ParallelTask_js_1.ParallelTask(this.clone(), (0, ensureTask_js_1.ensureTask)(task));
+    }
+    serial(task) {
+        return new SerialTask_js_1.SerialTask(this.clone(), (0, ensureTask_js_1.ensureTask)(task));
+    }
+    then(task) {
+        return new ChainTask_js_1.ChainTask(this.clone(), (0, ensureTask_js_1.ensureTask)(task));
+    }
+    catch(task) {
+        return new CatchTask_js_1.CatchTask(this.clone(), (0, ensureTask_js_1.ensureTask)(task));
+    }
+    background() {
+        return new BackgroundTask_js_1.BackgroundTask(this.clone());
+    }
+    unpack(mapper) {
+        return new UnpackTask(this.clone(), mapper);
+    }
+    clone() {
+        return new UnpackTask(this._base.clone(), this._mapper);
+    }
+}
+exports.UnpackTask = UnpackTask;
+_a = Task_js_1.TaskType;

package/script/dsl/triggers/ScheduleTrigger.d.ts

@@ -0,0 +1,14 @@
+import { Taskable } from '../Task.js';
+import { Trigger, TriggerType } from '../Trigger.js';
+import { Workflow } from '../Workflow.js';
+export type ScheduleData = Record<string, never>;
+export declare class ScheduleTrigger implements Trigger<ScheduleData> {
+    id: string;
+    [TriggerType]: string;
+    schedule: string;
+    constructor(id: string, schedule: string);
+    then<OO>(task: Taskable<ScheduleData, OO>): Workflow<OO>;
+    catch<OO>(error: any): Workflow<OO>;
+}
+export declare function schedule(id: string, schedule: string): Workflow<ScheduleData>;
+//# sourceMappingURL=ScheduleTrigger.d.ts.map

package/script/dsl/triggers/ScheduleTrigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleTrigger.d.ts","sourceRoot":"","sources":["../../../src/dsl/triggers/ScheduleTrigger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAgB,MAAM,gBAAgB,CAAC;AAExD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAEjD,qBAAa,eAAgB,YAAW,OAAO,CAAC,YAAY,CAAC;IACzD,EAAE,EAAE,MAAM,CAAC;IAEX,CAAC,WAAW,CAAC,EAAE,MAAM,CAAc;IAEnC,QAAQ,EAAE,MAAM,CAAC;gBAEL,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAKxC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;IAIxD,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,QAAQ,CAAC,EAAE,CAAC;CAGtC;AAED,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC,YAAY,CAAC,CAE7E"}

package/script/dsl/triggers/ScheduleTrigger.js

@@ -0,0 +1,43 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleTrigger = void 0;
+exports.schedule = schedule;
+const ensureTask_js_1 = require("../ensureTask.js");
+const Trigger_js_1 = require("../Trigger.js");
+const Workflow_js_1 = require("../Workflow.js");
+class ScheduleTrigger {
+    constructor(id, schedule) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'schedule'
+        });
+        Object.defineProperty(this, "schedule", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.id = id;
+        this.schedule = schedule;
+    }
+    then(task) {
+        return new Workflow_js_1.WorkflowImpl(this, (0, ensureTask_js_1.ensureTask)(task));
+    }
+    catch(error) {
+        return this;
+    }
+}
+exports.ScheduleTrigger = ScheduleTrigger;
+_a = Trigger_js_1.TriggerType;
+function schedule(id, schedule) {
+    return new ScheduleTrigger(id, schedule);
+}

package/script/interpreter/memory/ExecutionError.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '../../context/Context.js';
+export declare class ExecutionError extends Error {
+    ctx: Context<any>;
+    constructor(ctx: Context<any>, message: string, opts?: ErrorOptions);
+}
+//# sourceMappingURL=ExecutionError.d.ts.map

package/script/interpreter/memory/ExecutionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionError.d.ts","sourceRoot":"","sources":["../../../src/interpreter/memory/ExecutionError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,qBAAa,cAAe,SAAQ,KAAK;IACrC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;gBAEN,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY;CAMtE"}

package/script/interpreter/memory/ExecutionError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionError = void 0;
+class ExecutionError extends Error {
+    constructor(ctx, message, opts) {
+        super(message, opts);
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'ExecutionError';
+        this.ctx = ctx;
+    }
+}
+exports.ExecutionError = ExecutionError;

package/script/interpreter/memory/MemoryInterpreter.d.ts

@@ -0,0 +1,18 @@
+import { ContextProvider } from '../../context/ContextProvider.js';
+import { Workflow } from '../../dsl/Workflow.js';
+import { Logger } from '../../observability/logging/Logger.js';
+import { ObservableCompiler } from './ObservableCompiler.js';
+export type MemoryInterpreterOptions = {
+    logger?: Logger;
+    compiler?: ObservableCompiler;
+    contextProvider?: ContextProvider;
+    signal?: AbortSignal;
+};
+export declare class MemoryInterpreter {
+    private log;
+    private compiler;
+    private contextProvider;
+    constructor(options?: MemoryInterpreterOptions);
+    run<O>(workflow: Workflow<O>, options?: MemoryInterpreterOptions): Promise<void>;
+}
+//# sourceMappingURL=MemoryInterpreter.d.ts.map

package/script/interpreter/memory/MemoryInterpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryInterpreter.d.ts","sourceRoot":"","sources":["../../../src/interpreter/memory/MemoryInterpreter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAuB,MAAM,kCAAkC,CAAC;AACxF,OAAO,EAAE,QAAQ,EAAgB,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAC/D,OAAO,EAAmB,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAG9E,MAAM,MAAM,wBAAwB,GAAG;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB,CAAC;AAEF,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,eAAe,CAAkB;gBAE7B,OAAO,GAAE,wBAA6B;IAMlD,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;CAyEnF"}

package/script/interpreter/memory/MemoryInterpreter.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryInterpreter = void 0;
+const dntShim = __importStar(require("../../_dnt.shims.js"));
+const rxjs_1 = require("rxjs");
+const ContextProvider_js_1 = require("../../context/ContextProvider.js");
+const Workflow_js_1 = require("../../dsl/Workflow.js");
+const ObservableCompiler_js_1 = require("./ObservableCompiler.js");
+const ConsoleLogger_js_1 = require("../../observability/logging/ConsoleLogger.js");
+class MemoryInterpreter {
+    constructor(options = {}) {
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "compiler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contextProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.log = options.logger || new ConsoleLogger_js_1.ConsoleLogger('debug');
+        this.compiler = options.compiler || new ObservableCompiler_js_1.ObservableCompiler();
+        this.contextProvider = options.contextProvider || new ContextProvider_js_1.ContextProviderImpl(this.log);
+    }
+    run(workflow, options) {
+        const localAbortController = new AbortController();
+        // Combine the local and passed-in abort signals
+        const combinedSignal = options?.signal
+            ? AbortSignal.any([localAbortController.signal, options.signal])
+            : localAbortController.signal;
+        // TODO: test whether this is required once we can run outside of a Deno test.
+        const sigintListener = () => {
+            this.log.info('Received SIGINT, shutting down workflow');
+            localAbortController.abort();
+        };
+        dntShim.Deno.addSignalListener('SIGINT', sigintListener);
+        if (!(workflow instanceof Workflow_js_1.WorkflowImpl)) {
+            throw new Error('workflow is not an instance of WorkflowImpl');
+        }
+        this.log.info('MemoryInterpreter.start', { workflow });
+        const compilerContext = {
+            compiler: this.compiler,
+            log: this.log,
+            contextProvider: this.contextProvider,
+        };
+        const trigger$ = this.compiler.compileTrigger(compilerContext, workflow.trigger, combinedSignal);
+        const task$ = this.compiler.compileTask(compilerContext, workflow.task);
+        return new Promise((resolve, reject) => {
+            trigger$
+                .pipe((0, rxjs_1.tap)((ctx) => {
+                ctx.log.info('MemoryInterpreter.executionStarted', { data: ctx.data });
+            }), (0, rxjs_1.mergeMap)((ctx) => (0, rxjs_1.of)(ctx).pipe(task$, (0, rxjs_1.catchError)((error) => {
+                ctx.log.error('MemoryInterpreter.executionError', { error });
+                return rxjs_1.EMPTY;
+            }))))
+                .subscribe({
+                next: (ctx) => {
+                    const durationMs = Date.now() - ctx.startTime.getTime();
+                    ctx.log.info('MemoryInterpreter.executionCompleted', {
+                        durationMs,
+                        data: ctx.data,
+                    });
+                },
+                error: (err) => {
+                    this.log.error('MemoryInterpreter.error', { error: err });
+                    dntShim.Deno.removeSignalListener('SIGINT', sigintListener);
+                    reject(err);
+                },
+                complete: () => {
+                    this.log.info('MemoryInterpreter.workflowCompleted');
+                    dntShim.Deno.removeSignalListener('SIGINT', sigintListener);
+                    resolve();
+                },
+            });
+        });
+    }
+}
+exports.MemoryInterpreter = MemoryInterpreter;

package/script/interpreter/memory/ObservableCompiler.d.ts

@@ -0,0 +1,23 @@
+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';
+export type CompilerContext = {
+    compiler: ObservableCompiler;
+    log: Logger;
+    contextProvider: ContextProvider;
+};
+export type CompilerFunc<In = any, Out = any, T extends Task<In, Out> = Task<In, Out>> = (ctx: CompilerContext, task: T) => OperatorFunction<In, Out>;
+export declare class ObservableCompiler {
+    private taskCompilers;
+    private triggerCompilers;
+    constructor();
+    compileTask<In = any, Out = any, Index = void>(ctx: CompilerContext, task: Task<In, Out>): ContextOperatorFunction<In, Out, Index>;
+    compileTrigger<Out = any, T extends Trigger<Out> = Trigger<Out>>(ctx: CompilerContext, 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/interpreter/memory/ObservableCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservableCompiler.d.ts","sourceRoot":"","sources":["../../../src/interpreter/memory/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;AAE5D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGvD,MAAM,MAAM,eAAe,GAAG;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,eAAe,CAAC;CACpC,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,eAAe,EACpB,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;;IAexE,WAAW,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,GAAG,IAAI,EACzC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GACpB,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC;IAa1C,cAAc,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,EAC3D,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,WAAW,GACpB,UAAU,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAarC,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/interpreter/memory/ObservableCompiler.js

@@ -0,0 +1,69 @@
+"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 http_js_1 = require("./compilers/http.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);
+    }
+    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/interpreter/memory/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/interpreter/memory/compilers/background.d.ts.map

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

package/script/interpreter/memory/compilers/background.js

@@ -0,0 +1,23 @@
+"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/interpreter/memory/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/interpreter/memory/compilers/catch.d.ts.map

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

package/script/interpreter/memory/compilers/catch.js

@@ -0,0 +1,22 @@
+"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(ctx, task) {
+    const baseOperator = ctx.compiler.compileTask(ctx, task._base);
+    const errorOperator = ctx.compiler.compileTask(ctx, task._errorHandler);
+    return (src) => src.pipe((0, rxjs_1.mergeMap)((ctx) => {
+        return baseOperator((0, rxjs_1.of)(ctx)).pipe((0, rxjs_1.catchError)((error) => {
+            if (error instanceof Error) {
+                return errorOperator((0, rxjs_1.of)(ctx.withData(new ExecutionError_js_1.ExecutionError(ctx, error.message, { cause: error }))));
+            }
+            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/interpreter/memory/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/interpreter/memory/compilers/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../../../src/interpreter/memory/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/interpreter/memory/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/interpreter/memory/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/interpreter/memory/compilers/fn.d.ts.map

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

package/script/interpreter/memory/compilers/fn.js

@@ -0,0 +1,19 @@
+"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(ctx, task) {
+    return (src) => src.pipe((0, rxjs_1.tap)({
+        complete: () => ctx.log.debug('fn.complete')
+    }), (0, rxjs_1.mergeMap)(async (ctx) => {
+        if (typeof ctx.idx === 'number') {
+            return ctx.withData(await task._fn(ctx, ctx.idx));
+        }
+        return ctx.withData(await task._fn(ctx));
+    }));
+}
+exports.fnCompiler = {
+    ctor: FnTask_js_1.FnTask,
+    compile: compileFn,
+};

package/script/interpreter/memory/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/interpreter/memory/compilers/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../../src/interpreter/memory/compilers/http.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,OAAO,EAA2B,YAAY,EAAE,MAAM,YAAY,CAAC;AA4BnE,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAG5E,CAAC"}

package/script/interpreter/memory/compilers/http.js

@@ -0,0 +1,27 @@
+"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(ctx, task) {
+    return (src) => src.pipe((0, operators_1.tap)({
+        complete: () => ctx.log.debug('http.complete')
+    }), (0, rxjs_1.mergeMap)(async (ctx) => {
+        const httpContext = {
+            ...ctx,
+            fetch,
+            connectionVariables: {}, // TODO: Implement connection variables
+            pageParams: undefined,
+            nextPage: () => {
+                throw new Error('Pagination not yet implemented');
+            },
+        };
+        const result = await task.fn(httpContext);
+        return ctx.withData(result);
+    }));
+}
+exports.httpCompiler = {
+    ctor: HttpTask_js_1.HttpTaskImpl,
+    compile: compileHttp,
+};

package/script/interpreter/memory/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/interpreter/memory/compilers/parallel.d.ts.map

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