@versori/run 0.5.0-alpha.6 → 0.5.1

package/esm/src/interpreter/vanilla/VanillaInterpreter.js

@@ -0,0 +1,435 @@
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+import opentelemetry from '@opentelemetry/api';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import express from 'express';
+import { catchError, EMPTY, mergeMap, of, tap } from 'rxjs';
+import { DefaultConnectionFactory } from '../../connection/VanillaConnectionFactory.js';
+import { VanillaContextProvider } from '../../context/VanillaContext.js';
+import { VersoriConfigReader } from '../../dsl/http/versori/configloader.js';
+import { envVarEnvId, envVarEnvironmentName, envVarLocalRun, envVarOrgId, envVarOrgSlug, envVarOtelTracesURL, envVarProjectId, envVarVersion, } from '../../dsl/http/versori/constants.js';
+import { CronAPIClient } from '../../dsl/http/versori/cronapi.js';
+import { WorkflowImpl } from '../../dsl/Workflow.js';
+import { IssueImpl } from '../../issues/Issues.js';
+import { MemoryKeyValueProvider } from '../../kv/memory/MemoryKeyValueProvider.js';
+import { SDKKeyValueProvider } from '../../kv/sdk/SDKKeyValueProvider.js';
+import { ConsoleLogger } from '../../observability/logging/ConsoleLogger.js';
+import { QueueImpl } from '../durable/Queue.js';
+import { ObservableCompiler } from './ObservableCompiler.js';
+function getKVProvider(runLocal) {
+    if (runLocal) {
+        return Promise.resolve(new MemoryKeyValueProvider());
+    }
+    return SDKKeyValueProvider.fromEnv();
+}
+/**
+ * VanillaInterpreter is an interpreter for executing Versori workflows with support for durable, queue-based workflow
+ * execution. It supports all trigger types including the {@link workflow} trigger which allows workflows to be started
+ * programmatically.
+ *
+ * Unlike {@link DurableInterpreter}, this interpreter is incapable of using connections. Therefore, all fetch requests will need
+ * to use fully qualified URLs and authentication must be handled manually within the workflow.
+ *
+ * @example
+ * ```typescript
+ * import { VanillaInterpreter, workflow, fn } from '@versori/run';
+ *
+ * const processJob = workflow('process-job', { maxAttempts: 3 })
+ *   .then(fn('task', async (ctx) => {
+ *     ctx.log.info('Processing job', { data: ctx.data });
+ *     // ... long-running process
+ *   }));
+ *
+ * const interpreter = new VanillaInterpreter();
+ * interpreter.register(processJob);
+ * await interpreter.start();
+ * ```
+ */
+export class VanillaInterpreter {
+    constructor(log, compiler, contextProvider, webhookRouter, cronRouter, cronRegistry, cnxFetchFactory, cronProvider, tracer, cfgReader, queueProvider, otelSDK) {
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: log
+        });
+        Object.defineProperty(this, "compiler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: compiler
+        });
+        Object.defineProperty(this, "contextProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: contextProvider
+        });
+        Object.defineProperty(this, "webhookRouter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: webhookRouter
+        });
+        Object.defineProperty(this, "cronRouter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronRouter
+        });
+        Object.defineProperty(this, "cronRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronRegistry
+        });
+        Object.defineProperty(this, "cnxFetchFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cnxFetchFactory
+        });
+        Object.defineProperty(this, "cronProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronProvider
+        });
+        Object.defineProperty(this, "tracer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tracer
+        });
+        Object.defineProperty(this, "cfgReader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cfgReader
+        });
+        Object.defineProperty(this, "queueProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: queueProvider
+        });
+        Object.defineProperty(this, "otelSDK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: otelSDK
+        });
+        Object.defineProperty(this, "registeredWorkflows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "webhookServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cronServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shutdownServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isShuttingDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        if (typeof this.log === 'undefined') {
+            throw new Error('VanillaInterpreter should not be instantiated directly. Use VanillaInterpreter.newInstance() instead.');
+        }
+    }
+    static async newInstance(options = {}) {
+        const log = options.logger || new ConsoleLogger();
+        const compiler = options.compiler || new ObservableCompiler();
+        const serviceName = Deno.env.get(envVarProjectId) || 'example-service';
+        const environmentID = Deno.env.get(envVarEnvId) || 'development';
+        const version = Deno.env.get(envVarVersion) || '1.0.0';
+        const environment = Deno.env.get(envVarEnvironmentName) || 'development';
+        const orgId = Deno.env.get(envVarOrgId) || 'development';
+        const orgSlug = Deno.env.get(envVarOrgSlug) || 'development';
+        const otelTracesURL = Deno.env.get(envVarOtelTracesURL);
+        let otelSDK;
+        const configReader = VersoriConfigReader.fromEnv(log);
+        const runLocal = Deno.env.get(envVarLocalRun) === 'true';
+        await waitForReady(log);
+        // Do NOT change these attributes, they are used by the API to filter on
+        const resource = resourceFromAttributes({
+            'service.id': serviceName,
+            'service.environment': environment,
+            'service.environment_id': environmentID,
+            'service.version': version,
+            'service.organisation_id': orgId,
+            'service.organisation_slug': orgSlug,
+        });
+        if (otelTracesURL && serviceName) {
+            otelSDK = new NodeSDK({
+                traceExporter: new OTLPTraceExporter({
+                    url: otelTracesURL,
+                }),
+                serviceName: serviceName,
+                resource: resource,
+            });
+            log.info('Starting OpenTelemetry SDK');
+            otelSDK.start();
+        }
+        const tracer = opentelemetry.trace.getTracer(serviceName, version);
+        const queueProvider = await QueueImpl.fromEnv(log);
+        const connectionFactory = new DefaultConnectionFactory();
+        const issuesProvider = new IssueImpl(log);
+        if (options.contextProvider) {
+            return new VanillaInterpreter(log, compiler, options.contextProvider, express.Router(), express.Router(), new Map(), connectionFactory, CronAPIClient.fromEnv(), tracer, configReader, queueProvider, otelSDK);
+        }
+        const kvp = await getKVProvider(runLocal);
+        const organisationId = Deno.env.get(envVarOrgId) || 'development';
+        const environmentId = Deno.env.get(envVarEnvId) || 'development';
+        const ctxProvider = new VanillaContextProvider(log, kvp, organisationId, environmentId, issuesProvider);
+        return new VanillaInterpreter(log, compiler, ctxProvider, express.Router(), express.Router(), new Map(), connectionFactory, CronAPIClient.fromEnv(), tracer, configReader, queueProvider, otelSDK);
+    }
+    register(workflow, options) {
+        const localAbortController = new AbortController();
+        const combinedSignal = options?.signal
+            ? AbortSignal.any([localAbortController.signal, options.signal])
+            : localAbortController.signal;
+        if (!(workflow instanceof WorkflowImpl)) {
+            throw new Error('workflow is not an instance of WorkflowImpl');
+        }
+        const compilerContext = {
+            compiler: this.compiler,
+            log: this.log,
+            tracer: this.tracer,
+            contextProvider: this.contextProvider,
+            webhookRouter: this.webhookRouter,
+            queueProvider: this.queueProvider,
+            cronRouter: this.cronRouter,
+            cronRegistry: this.cronRegistry,
+            configReader: this.cfgReader,
+            cnxFactory: this.cnxFetchFactory,
+            organisationId: Deno.env.get(envVarOrgId) || 'development',
+        };
+        const trigger$ = this.compiler.compileTrigger(compilerContext, workflow.trigger, combinedSignal);
+        const task$ = this.compiler.compileTask(compilerContext, workflow.task);
+        const triggerName = 'id' in workflow.trigger && typeof workflow.trigger.id === 'string'
+            ? workflow.trigger.id
+            : workflow.trigger.constructor.name;
+        const registration = {
+            triggerName,
+            trigger$,
+            task$,
+            localAbortController,
+            sigintListener: () => {
+                this.log.info('Received SIGINT, shutting down workflow', { triggerName });
+                localAbortController.abort();
+            },
+        };
+        this.registeredWorkflows.push(registration);
+        return registration;
+    }
+    start() {
+        const port = Deno.env.get('PORT') || 3000;
+        const cronPort = Deno.env.get('CRON_PORT') || 3001;
+        const webhookApp = express();
+        const cronApp = express();
+        cronApp.use(express.json());
+        this.webhookRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        this.cronRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        webhookApp.use(this.webhookRouter);
+        cronApp.use(this.cronRouter);
+        for (const registration of this.registeredWorkflows) {
+            Deno.addSignalListener('SIGINT', registration.sigintListener);
+            registration.subscription = registration.trigger$
+                .pipe(tap((ctx) => {
+                ctx.log.info('VanillaInterpreter.executionStarted', {
+                    triggerName: registration.triggerName,
+                    data: ctx.data,
+                });
+            }), mergeMap((ctx) => of(ctx).pipe(registration.task$, catchError((err) => {
+                ctx.log.error('VanillaInterpreter.executionError', {
+                    triggerName: registration.triggerName,
+                    error: err instanceof Error ? err.toString() : err,
+                });
+                try {
+                    ctx.options.onError?.(ctx.withData(err));
+                }
+                catch (err) {
+                    ctx.log.error('VanillaInterpreter.onErrorError: failed to call onError handler', {
+                        triggerName: registration.triggerName,
+                        error: err instanceof Error ? err.toString() : err,
+                    });
+                    ctx.options.onError?.(ctx.withData({
+                        message: 'Internal server error',
+                        error: err instanceof Error ? err.toString() : err,
+                    }));
+                }
+                return EMPTY;
+            }))))
+                .subscribe({
+                next: (ctx) => {
+                    const durationMs = Date.now() - ctx.startTime.getTime();
+                    ctx.log.info('VanillaInterpreter.executionCompleted', {
+                        triggerName: registration.triggerName,
+                        durationMs,
+                    });
+                    try {
+                        ctx.options.onSuccess?.(ctx);
+                    }
+                    catch (err) {
+                        ctx.log.error('VanillaInterpreter.onSuccessError: failed to call onSuccess handler', {
+                            triggerName: registration.triggerName,
+                            error: err instanceof Error ? err.toString() : err,
+                        });
+                        ctx.options.onSuccess?.(ctx.withData({
+                            message: 'Internal server error',
+                            error: err instanceof Error ? err.toString() : err,
+                        }));
+                    }
+                    this.contextProvider.destroy(ctx);
+                },
+                error: (err) => {
+                    this.log.error('VanillaInterpreter.error', {
+                        triggerName: registration.triggerName,
+                        error: err instanceof Error ? err.toString() : err,
+                    });
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+                complete: () => {
+                    this.log.info('VanillaInterpreter.workflowCompleted', {
+                        triggerName: registration.triggerName,
+                    });
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+            });
+            registration.subscription.add(() => {
+                registration.subscription = undefined;
+            });
+        }
+        try {
+            this.cronProvider.updateCrons(this.cronRegistry);
+        }
+        catch (err) {
+            this.log.error('VanillaInterpreter.updateCronsError', {
+                error: err instanceof Error ? err.toString() : err,
+            });
+            throw new Error('Unable to register scheduler tasks with central cron provider');
+        }
+        this.webhookServer = webhookApp.listen(port, () => {
+            this.log.info(`Express server listening on port ${port}`);
+        });
+        this.cronServer = cronApp.listen(cronPort, () => {
+            this.log.info(`Cron server listening on port ${cronPort}`);
+        });
+        this.shutdownServer = () => {
+            if (this.isShuttingDown) {
+                return;
+            }
+            this.isShuttingDown = true;
+            this.log.info('Shutting down server');
+            if (this.webhookServer) {
+                this.webhookServer.close();
+            }
+            if (this.cronServer) {
+                this.cronServer.close();
+            }
+            for (const registration of this.registeredWorkflows) {
+                Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                if (registration.subscription) {
+                    registration.subscription.unsubscribe();
+                }
+                registration.localAbortController.abort();
+            }
+            if (this.shutdownServer) {
+                Deno.removeSignalListener('SIGINT', this.shutdownServer);
+            }
+        };
+        Deno.addSignalListener('SIGINT', this.shutdownServer);
+        return new Promise((resolve) => {
+            let serversClosed = 0;
+            const totalServers = [this.webhookServer, this.cronServer].filter(Boolean).length;
+            const checkResolve = () => {
+                serversClosed++;
+                if (serversClosed === totalServers) {
+                    this.log.info('All servers closed');
+                    resolve();
+                }
+            };
+            if (this.webhookServer) {
+                this.webhookServer.on('close', () => {
+                    this.log.info('Webhook server closed');
+                    checkResolve();
+                });
+            }
+            if (this.cronServer) {
+                this.cronServer.on('close', () => {
+                    this.log.info('Cron server closed');
+                    checkResolve();
+                });
+            }
+            if (!this.webhookServer && !this.cronServer) {
+                resolve();
+            }
+        });
+    }
+    stop() {
+        this.otelSDK?.shutdown();
+        if (this.shutdownServer) {
+            this.shutdownServer();
+        }
+        return Promise.resolve();
+    }
+}
+async function waitForReady(log) {
+    const readyCheckUrl = Deno.env.get('READY_CHECK_URL');
+    if (!readyCheckUrl) {
+        return Promise.resolve();
+    }
+    const maxAttempts = 40;
+    const delay = 500;
+    log.info('VanillaInterpreter.waitForReady: waiting for network to be ready', { readyCheckUrl });
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const response = await fetch(readyCheckUrl);
+            if (response.ok) {
+                log.info('VanillaInterpreter.waitForReady: network is ready');
+                return Promise.resolve();
+            }
+        }
+        catch (err) {
+            log.error('VanillaInterpreter.waitForReadyError', {
+                error: err instanceof Error ? err.toString() : err,
+            });
+        }
+        log.info('VanillaInterpreter.waitForReady: retrying...', { attempt: i });
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    throw new Error(`Network is not ready after ${maxAttempts * (delay / 1000)} seconds`);
+}

package/esm/src/interpreter/vanilla/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/esm/src/interpreter/vanilla/compilers/background.d.ts.map

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

package/esm/src/interpreter/vanilla/compilers/background.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+import { asyncScheduler, catchError, connect, EMPTY, ignoreElements, map, merge, mergeMap, of, subscribeOn, tap, } from 'rxjs';
+import { BackgroundTask } from '../../../dsl/tasks/BackgroundTask.js';
+function compileBackground(ctx, task) {
+    const base = ctx.compiler.compileTask(ctx, task._base);
+    return (src) => src.pipe(connect((shared$) => merge(shared$.pipe(mergeMap((ctx) => base(of(ctx)).pipe(subscribeOn(asyncScheduler), tap({
+        next: (ctx) => ctx.log.debug('Background task emitted a value', {
+            data: ctx.data,
+        }),
+        complete: () => ctx.log.debug('Background task completed'),
+    }), catchError((error) => {
+        ctx.log.error('Error in background task', {
+            error,
+            inputData: ctx.data,
+            executionId: ctx.executionId,
+        });
+        return EMPTY;
+    }), ignoreElements()))), shared$.pipe(map((ctx) => ctx.withData(void 0))))));
+}
+export const backgroundCompiler = {
+    ctor: BackgroundTask,
+    compile: compileBackground,
+};

package/esm/src/interpreter/vanilla/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/esm/src/interpreter/vanilla/compilers/catch.d.ts.map

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

package/esm/src/interpreter/vanilla/compilers/catch.js

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+import { catchError, mergeMap, of } from 'rxjs';
+import { CatchTask } from '../../../dsl/tasks/CatchTask.js';
+import { ExecutionError } from '../ExecutionError.js';
+function compileCatch(compilerCtx, task) {
+    const baseOperator = compilerCtx.compiler.compileTask(compilerCtx, task._base);
+    const errorOperator = compilerCtx.compiler.compileTask(compilerCtx, task._errorHandler);
+    return (src) => {
+        return src.pipe(mergeMap((ctx) => {
+            return baseOperator(of(ctx)).pipe(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,
+                        });
+                        // TODO: Do we want to submit issues for the VanillaInterpreter or not?
+                        // compilerCtx.issueProvider.submitIssue({
+                        //     annotations: {
+                        //         'error': error.message,
+                        //         'stack': error.stack || '',
+                        //         'workflowId': ctx.options.workflowId || ctx.workflowId || '',
+                        //         'executionId': ctx.executionId,
+                        //         'activationId': ctx.activation.id,
+                        //         'activationExternalId': ctx.activation?.user.externalId,
+                        //     },
+                        //     reason: 'error',
+                        //     severity: 'high',
+                        // });
+                        return errorOperator(of(ctx.withData(new ExecutionError(ctx, error.message, { cause: error }))));
+                    }
+                    ctx.log.error('execution has encountered an error', {
+                        error: error,
+                    });
+                    // compilerCtx.issueProvider.submitIssue({
+                    //     annotations: {
+                    //         'error': error.message,
+                    //         'stack': error.stack || '',
+                    //         'workflowId': ctx.options.workflowId || ctx.workflowId || '',
+                    //         'executionId': ctx.executionId,
+                    //         'activationId': ctx.activation.id,
+                    //         'activationExternalId': ctx.activation?.user.externalId,
+                    //     },
+                    //     reason: 'error',
+                    //     severity: 'low',
+                    // });
+                    span.setAttribute('error', `${error}`);
+                    span.end();
+                    return errorOperator(of(ctx.withData(new ExecutionError(ctx, `${error}`, { cause: error }))));
+                });
+            }));
+        }));
+    };
+}
+export const catchCompiler = {
+    ctor: CatchTask,
+    compile: compileCatch,
+};

package/esm/src/interpreter/vanilla/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/esm/src/interpreter/vanilla/compilers/chain.d.ts.map

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

package/esm/src/interpreter/vanilla/compilers/chain.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2025 Versori Group Inc
+ *
+ * Use of this software is governed by the Business Source License 1.1
+ * included in the LICENSE file at the root of this repository.
+ *
+ * Change Date: 2029-01-01
+ * Change License: Apache License, Version 2.0
+ *
+ * As of the Change Date, in accordance with the Business Source License,
+ * use of this software will be governed by the Apache License, Version 2.0.
+ */
+import { ChainTask } from '../../../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);
+}
+export const chainCompiler = {
+    ctor: ChainTask,
+    compile: compileChain,
+};

package/esm/src/interpreter/vanilla/compilers/durableworkflow.d.ts

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

package/esm/src/interpreter/vanilla/compilers/durableworkflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durableworkflow.d.ts","sourceRoot":"","sources":["../../../../../src/src/interpreter/vanilla/compilers/durableworkflow.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,EACH,mBAAmB,EACnB,sBAAsB,EACzB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAqB,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,wBAAgB,sBAAsB,CAClC,GAAG,EAAE,sBAAsB,EAC3B,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,WAAW,GACpB,UAAU,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC,CAuFjD;AAED,eAAO,MAAM,uBAAuB,EAAE,eAAe,CAAC,mBAAmB,EAAE,sBAAsB,CAI5F,CAAC"}