@versori/run 0.2.14 → 0.2.15

package/esm/src/interpreter/durable/DurableInterpreter.js

@@ -0,0 +1,433 @@
+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 xmlparser from 'express-xml-bodyparser';
+import { catchError, EMPTY, mergeMap, of, tap } from 'rxjs';
+import { ContextProviderImpl } from '../../context/ContextProvider.js';
+import { DefaultRoundTripperFactory } from '../../dsl/http/default.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 { PlatformAPIClient } from '../../dsl/http/versori/platformapi.js';
+import { VersoriCredentialsFactory } from '../../dsl/http/versori/roundtripper.js';
+import { WorkflowImpl } from '../../dsl/Workflow.js';
+import { MemoryKeyValueProvider } from '../../kv/memory/MemoryKeyValueProvider.js';
+import { NatsKeyValueProvider } from '../../kv/nats/NatsKeyValueProvider.js';
+import { ConsoleLogger } from '../../observability/logging/ConsoleLogger.js';
+import { ObservableCompiler } from './ObservableCompiler.js';
+import { ProxyRoundTripper } from '../../dsl/http/versori/proxyroundtripper.js';
+import { VersoriConfigReader } from '../../dsl/http/versori/configloader.js';
+import { QueueImpl } from './Queue.js';
+function getKVProvider(runLocal) {
+    if (runLocal) {
+        return Promise.resolve(new MemoryKeyValueProvider());
+    }
+    return NatsKeyValueProvider.fromEnv();
+}
+function getRoundTripperFactory(log, tracer, opts) {
+    if (opts && opts.runLocal) {
+        log.info('Running in local mode, using ProxyRoundTripperFactory');
+        return ProxyRoundTripper.fromEnv(log);
+    }
+    if (!opts || !opts.skipVersoriCredentials) {
+        return VersoriCredentialsFactory.fromEnv(log, tracer);
+    }
+    log.info('Running with default round tripper factory');
+    return new DefaultRoundTripperFactory();
+}
+export class DurableInterpreter {
+    constructor(log, compiler, contextProvider, roundTripperFactory, webhookRouter, cronRouter, cronRegistry, connectionProvider, 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, "roundTripperFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: roundTripperFactory
+        });
+        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, "connectionProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: connectionProvider
+        });
+        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') {
+            // this captures the old way of instantiating the DurableInterpreter and provides an
+            // error message back to the user to let them know they should use the new way.
+            throw new Error('DurableInterpreter should not be instantiated directly. Use DurableInterpreter.newInstance() instead.');
+        }
+    }
+    static async newInstance(options = {}) {
+        const log = options.logger || new ConsoleLogger('debug');
+        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 those 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 roundTripperFactory = getRoundTripperFactory(log, tracer, {
+            skipVersoriCredentials: options.skipVersoriCredentials,
+            runLocal: runLocal,
+        });
+        const queueProvider = await QueueImpl.fromEnv(log);
+        if (options.contextProvider) {
+            // no need to set up a key-value provider if options.contextProvider is already
+            // initialised.
+            return new DurableInterpreter(log, compiler, options.contextProvider, roundTripperFactory, express.Router(), express.Router(), new Map(), PlatformAPIClient.fromEnv(), CronAPIClient.fromEnv(), tracer, configReader, queueProvider, otelSDK);
+        }
+        const kvp = await getKVProvider(runLocal);
+        return new DurableInterpreter(log, compiler, new ContextProviderImpl(log, kvp, roundTripperFactory.credentials(), queueProvider), roundTripperFactory, express.Router(), express.Router(), new Map(), PlatformAPIClient.fromEnv(), 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');
+        }
+        this.log.info('DurableInterpreter.register', { workflow });
+        const compilerContext = {
+            compiler: this.compiler,
+            log: this.log,
+            tracer: this.tracer,
+            contextProvider: this.contextProvider,
+            roundTripperFactory: this.roundTripperFactory,
+            webhookRouter: this.webhookRouter,
+            queueProvider: this.queueProvider,
+            cronRouter: this.cronRouter,
+            cronRegistry: this.cronRegistry,
+            connectionProvider: this.connectionProvider,
+            configReader: this.cfgReader,
+        };
+        const trigger$ = this.compiler.compileTrigger(compilerContext, workflow.trigger, combinedSignal);
+        const task$ = this.compiler.compileTask(compilerContext, workflow.task);
+        const registration = {
+            trigger$,
+            task$,
+            localAbortController,
+            sigintListener: () => {
+                this.log.info('Received SIGINT, shutting down workflow');
+                localAbortController.abort();
+            },
+        };
+        this.registeredWorkflows.push(registration);
+        return registration;
+    }
+    async start() {
+        const port = Deno.env.get('PORT') || 3000;
+        const cronPort = Deno.env.get('CRON_PORT') || 3001;
+        const webhookApp = express();
+        webhookApp.use(express.json({ limit: '50mb' })); // Add JSON body parser middleware
+        const cronApp = express();
+        cronApp.use(express.json());
+        const xml2jsDefaults = {
+            explicitArray: false,
+            normalize: false,
+            normalizeTags: false,
+            trim: true,
+        };
+        webhookApp.use(xmlparser(xml2jsDefaults));
+        // Add health check route
+        this.webhookRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        this.cronRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        // Add router to the webhookApplication
+        webhookApp.use(this.webhookRouter);
+        cronApp.use(this.cronRouter);
+        // Start all registered workflows
+        for (const registration of this.registeredWorkflows) {
+            Deno.addSignalListener('SIGINT', registration.sigintListener);
+            registration.subscription = registration.trigger$
+                .pipe(tap((ctx) => {
+                ctx.log.info('DurableInterpreter.executionStarted', { data: ctx.data });
+            }), mergeMap((ctx) => of(ctx).pipe(registration.task$, catchError((err) => {
+                ctx.log.error('DurableInterpreter.executionError', {
+                    error: err instanceof Error ? err.toString() : err,
+                });
+                try {
+                    ctx.options.onError?.(ctx.withData(err));
+                }
+                catch (err) {
+                    ctx.log.error('DurableInterpreter.onErrorError: failed to call onError handler', { 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: async (ctx) => {
+                    const durationMs = Date.now() - ctx.startTime.getTime();
+                    ctx.log.info('DurableInterpreter.executionCompleted', {
+                        durationMs,
+                        data: ctx.data,
+                    });
+                    try {
+                        ctx.options.onSuccess?.(ctx);
+                    }
+                    catch (err) {
+                        ctx.log.error('DurableInterpreter.onSuccessError: failed to call onSuccess handler', { error: err instanceof Error ? err.toString() : err });
+                        ctx.options.onSuccess?.(ctx.withData({
+                            message: 'Internal server error',
+                            error: err instanceof Error ? err.toString() : err,
+                        }));
+                    }
+                    if (ctx.workflowId) {
+                        this.log.info('Async workflow completed', {
+                            workflowId: ctx.workflowId,
+                        });
+                        const output = ctx.data ? btoa(JSON.stringify(ctx.data)) : undefined;
+                        await ctx.queue?.complete({
+                            id: ctx.workflowId,
+                            output,
+                            status: 'completed',
+                        });
+                    }
+                    this.contextProvider.destroy(ctx);
+                },
+                error: (err) => {
+                    this.log.error('DurableInterpreter.error', {
+                        error: err instanceof Error ? err.toString() : err,
+                    });
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+                complete: () => {
+                    this.log.info('DurableInterpreter.workflowCompleted');
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+            });
+            registration.subscription.add(() => {
+                registration.subscription = undefined;
+            });
+        }
+        try {
+            this.cronProvider.updateCrons(this.cronRegistry);
+        }
+        catch (err) {
+            this.log.error('DurableInterpreter.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');
+            // Close the server
+            if (this.webhookServer) {
+                this.webhookServer.close();
+            }
+            if (this.cronServer) {
+                this.cronServer.close();
+            }
+            // Remove all signal listeners
+            for (const registration of this.registeredWorkflows) {
+                Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                // Unsubscribe from all observables
+                if (registration.subscription) {
+                    registration.subscription.unsubscribe();
+                }
+                // Abort all controllers
+                registration.localAbortController.abort();
+            }
+            // Remove the server shutdown listener
+            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();
+            }
+        });
+    }
+    async stop() {
+        this.otelSDK?.shutdown();
+        if (this.shutdownServer) {
+            this.shutdownServer();
+        }
+    }
+}
+async function waitForReady(log) {
+    const readyCheckUrl = Deno.env.get('READY_CHECK_URL');
+    if (!readyCheckUrl) {
+        return Promise.resolve();
+    }
+    const maxAttempts = 40; // should be 20 seconds
+    const delay = 500;
+    log.info('DurableInterpreter.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('DurableInterpreter.waitForReady: network is ready');
+                return Promise.resolve();
+            }
+        }
+        catch (err) {
+            log.error('DurableInterpreter.waitForReadyError', {
+                error: err instanceof Error ? err.toString() : err,
+            });
+        }
+        log.info('DurableInterpreter.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/durable/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/esm/src/interpreter/durable/ExecutionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionError.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/durable/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/esm/src/interpreter/durable/ExecutionError.js

@@ -0,0 +1,13 @@
+export 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;
+    }
+}

package/esm/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/esm/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/esm/src/interpreter/durable/ObservableCompiler.js

@@ -0,0 +1,69 @@
+import { TaskType } from '../../dsl/Task.js';
+import { backgroundCompiler } from './compilers/background.js';
+import { catchCompiler } from './compilers/catch.js';
+import { chainCompiler } from './compilers/chain.js';
+import { fnCompiler } from './compilers/fn.js';
+import { parallelCompiler } from './compilers/parallel.js';
+import { serialCompiler } from './compilers/serial.js';
+import { unpackCompiler } from './compilers/unpack.js';
+import { TriggerType } from '../../dsl/Trigger.js';
+import { scheduleCompiler } from './compilers/schedule.js';
+import { webhookCompiler } from './compilers/webhook.js';
+import { httpCompiler } from './compilers/http.js';
+import { durableWorkflowCompiler } from './compilers/durableworkflow.js';
+export 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(parallelCompiler);
+        this.registerTask(serialCompiler);
+        this.registerTask(catchCompiler);
+        this.registerTask(chainCompiler);
+        this.registerTask(fnCompiler);
+        this.registerTask(backgroundCompiler);
+        this.registerTask(unpackCompiler);
+        this.registerTask(httpCompiler);
+        this.registerTrigger(scheduleCompiler);
+        this.registerTrigger(webhookCompiler);
+        this.registerTrigger(durableWorkflowCompiler);
+    }
+    compileTask(ctx, task) {
+        const compiler = this.taskCompilers.get(task[TaskType]);
+        if (!compiler) {
+            throw new Error(`No compiler registered for task type: ${task[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[TriggerType]);
+        if (!compiler) {
+            throw new Error(`No compiler registered for trigger type: ${trigger[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[TaskType], compiler);
+    }
+    registerTrigger(compiler) {
+        const trigger = new compiler.ctor();
+        this.triggerCompilers.set(trigger[TriggerType], compiler);
+    }
+}

package/esm/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/esm/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"}