ocel 0.0.1-alpha.1 → 0.0.1

package/src/lambda/index.ts

@@ -1,8 +0,0 @@
-import { Lambda, type LambdaConfig, type TriggerMap } from "./lambda";
-
-export function lambda<T extends keyof TriggerMap>(
-  id: string,
-  config: LambdaConfig<T>
-) {
-  return new Lambda(id, config);
-}

package/src/lambda/integrations/express.ts

@@ -1,25 +0,0 @@
-import {
-  Lambda,
-  type LambdaConfig,
-  type TriggerMap,
-  type TriggerUnion,
-} from "../lambda";
-import sls from "serverless-http";
-import type { Express } from "express";
-
-export function lambda<T extends keyof TriggerMap>(
-  id: string,
-  app: Express,
-  config?: Omit<LambdaConfig<T>, "trigger" | "handler">,
-) {
-  const handler = sls(app);
-
-  return new Lambda(id, {
-    ...config,
-    handler: handler as any,
-    trigger: {
-      type: "url",
-      config: {},
-    } as Extract<TriggerUnion, { type: T }>,
-  });
-}

package/src/lambda/integrations/hono.ts

@@ -1,25 +0,0 @@
-import {
-  Lambda,
-  type LambdaConfig,
-  type TriggerMap,
-  type TriggerUnion,
-} from "../lambda";
-import type { Hono } from "hono";
-import { handle } from "hono/aws-lambda";
-
-export function lambda<T extends keyof TriggerMap>(
-  id: string,
-  app: Hono,
-  config?: Omit<LambdaConfig<T>, "trigger" | "handler">,
-) {
-  const handler = handle(app);
-
-  return new Lambda(id, {
-    ...config,
-    handler: handler as any,
-    trigger: {
-      type: "url",
-      config: {},
-    } as Extract<TriggerUnion, { type: T }>,
-  });
-}

package/src/lambda/lambda.ts

@@ -1,94 +0,0 @@
-import type { Component } from "../utils/component";
-import { rpc } from "../utils/rpc";
-import { getCallerFile } from "../utils/stack";
-import type {
-  Context,
-  APIGatewayEvent,
-  S3Event,
-  LambdaFunctionURLEvent,
-} from "aws-lambda";
-
-export type TriggerMap = {
-  s3: {
-    bucket: string;
-    events: string[];
-  };
-  cron: {
-    schedule: string;
-  };
-  url: {
-    streaming?: boolean;
-  };
-  api: {
-    id?: string;
-    path: string;
-    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "*";
-  };
-};
-
-export type TriggerUnion = {
-  [K in keyof TriggerMap]: { type: K; config: TriggerMap[K] };
-}[keyof TriggerMap];
-
-export type LambdaHandlerOutput<T extends keyof TriggerMap> = T extends "api"
-  ? {
-      statusCode: number;
-      headers: Record<string, string>;
-      body: string;
-    }
-  : any;
-
-export type LambdaEvent<T extends keyof TriggerMap> = T extends "s3"
-  ? S3Event
-  : T extends "api"
-    ? APIGatewayEvent
-    : T extends "url"
-      ? LambdaFunctionURLEvent
-      : any;
-
-export interface LambdaConfig<T extends keyof TriggerMap> {
-  handler: (
-    event: LambdaEvent<T>,
-    context: Context,
-  ) => Promise<LambdaHandlerOutput<T>> | LambdaHandlerOutput<T>;
-
-  trigger: Extract<TriggerUnion, { type: T }>;
-  link?: Component[];
-}
-
-export class Lambda<T extends keyof TriggerMap> implements Component {
-  constructor(
-    public id: string,
-    config: LambdaConfig<T>,
-  ) {
-    // remove non-serializable stuff
-    const { handler, link, ...rest } = config;
-    const links = link?.map((component) => component.__id()) || [];
-
-    // @ts-expect-error - accessed by cli during build
-    this.__handler = handler;
-    // @ts-expect-error - accessed by cli during build
-    this[Symbol.for("ocel:lambda:id")] = id;
-
-    if (process.env.OCEL_PHASE === "discovery") {
-      const source = getCallerFile();
-
-      if (!source) {
-        throw new Error(
-          "Could not determine caller file for lambda registration",
-        );
-      }
-
-      rpc.register({
-        id: this.id,
-        type: "lambda",
-        source,
-        config: { ...rest, links },
-      });
-    }
-  }
-
-  __id(): string {
-    return this.id;
-  }
-}

package/src/postgres/index.ts

@@ -1,5 +0,0 @@
-import { Postgres, type PostgresConfig } from "./pg";
-
-export function postgres(id: string, config: PostgresConfig) {
-  return new Postgres(id, config);
-}

package/src/postgres/pg.ts

@@ -1,33 +0,0 @@
-import type { Component } from "../utils/component";
-import { rpc } from "../utils/rpc";
-import { getCallerFile } from "../utils/stack";
-
-export interface PostgresConfig {
-  version?: string;
-  migrations?: string;
-}
-
-export class Postgres implements Component {
-  constructor(public id: string, config: PostgresConfig) {
-    // remove non-serializable stuff
-
-    if (process.env.OCEL_PHASE === "discovery") {
-      const source = getCallerFile();
-
-      rpc.register({
-        id: this.id,
-        type: "postgres",
-        source: source || "unknown",
-        config: {},
-      });
-    }
-  }
-
-  __id(): string {
-    return this.id;
-  }
-
-  async sql(query: string) {
-    return {};
-  }
-}

package/src/utils/component.ts

@@ -1,3 +0,0 @@
-export interface Component {
-  __id(): string;
-}

package/src/utils/constants.ts

@@ -1,2 +0,0 @@
-export const IS_DISCOVERY_PHASE = process.env.OCEL_PHASE === "discovery";
-export const IS_DEV_MODE = process.env.OCEL_DEV === "1";

package/src/utils/nanoid.ts

@@ -1,9 +0,0 @@
-import { customAlphabet } from "nanoid";
-
-export function getNanoid(length = 7) {
-  const alphabet =
-    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  const nanoid = customAlphabet(alphabet, length);
-
-  return nanoid();
-}

package/src/utils/rpc.ts

@@ -1,28 +0,0 @@
-declare global {
-  var __ocelRegister: Promise<unknown>[];
-}
-
-export const rpc = {
-  register: async (args: {
-    id: string;
-    type: "lambda" | "bucket" | "workflow" | "postgres";
-    source: string;
-    config?: Record<string, unknown>;
-  }) => {
-    const SERVER_URL = process.env.OCEL_SERVER;
-    if (!SERVER_URL) {
-      throw new Error("OCEL_SERVER environment variable is not set");
-    }
-
-    const p = fetch(`${SERVER_URL}/register`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(args),
-    });
-
-    globalThis.__ocelRegister ??= [];
-    globalThis.__ocelRegister.push(p);
-  },
-};

package/src/utils/stack.ts

@@ -1,26 +0,0 @@
-/**
- * Returns absolute path of the caller file.
- */
-export function getCallerFile(depth = 1): string | null {
-  const original = Error.prepareStackTrace;
-
-  try {
-    Error.prepareStackTrace = (_, stack) => stack;
-    const err = new Error();
-
-    const frames = err.stack as unknown as NodeJS.CallSite[];
-
-    // index 0 = getCallerFile
-    // index 1 = the function that called getCallerFile
-    return (
-      frames[2 + depth]
-        ?.getFileName()
-        ?.replace("file://", "")
-        ?.split("?")?.[0] ?? null
-    );
-  } catch {
-    return null;
-  } finally {
-    Error.prepareStackTrace = original;
-  }
-}

package/src/workflow/index.ts

@@ -1,9 +0,0 @@
-import type { ZodType } from "zod";
-import { Workflow, type WorkflowConfig } from "./workflow";
-
-export function workflow<TInput extends ZodType = never>(
-  id: string,
-  config: WorkflowConfig<TInput>
-) {
-  return new Workflow<TInput>(id, config);
-}

package/src/workflow/workflow.ts

@@ -1,235 +0,0 @@
-import type { z, ZodType } from "zod";
-import type { Component } from "../utils/component";
-import {
-  withDurableExecution,
-  type DurableContext,
-} from "@aws/durable-execution-sdk-js";
-import { getCallerFile } from "../utils/stack";
-import { rpc } from "../utils/rpc";
-import { SpanStatusCode, trace } from "@opentelemetry/api";
-
-export interface WorkflowConfig<TInput extends ZodType = never> {
-  input?: TInput;
-  queue?: {
-    concurrencyLimit?: number;
-  };
-  cron?: string;
-  run: [TInput] extends [never]
-    ? (args: { ctx: DurableContext }) => Promise<void>
-    : (args: { input: z.infer<TInput>; ctx: DurableContext }) => Promise<void>;
-  link?: Component[];
-  retry?:
-    | {
-        maxAttempts: number;
-        backoffRate?: number;
-        intervalSeconds?: number;
-        maxTimeoutSeconds?: number;
-      }
-    | false;
-}
-
-export class Workflow<TInput extends ZodType = never> implements Component {
-  constructor(private id: string, config: WorkflowConfig<TInput>) {
-    const { run, input, link, ...rest } = config;
-    const links = link?.map((component) => component.__id()) || [];
-    const tracer = trace.getTracer("ocel/workflow");
-
-    const handler = (originalEvent: any, originalFnContext: any) => {
-      return withDurableExecution(async (event, durableCtx) => {
-        const ctx = durableCtx as any;
-        const isReplay = ctx.durableExecutionMode === "ReplayMode";
-        const ops = originalEvent.InitialExecutionState?.Operations || [];
-
-        const stepCompleted = (name: string) => {
-          return (
-            isReplay &&
-            ops.some((op: any) => op.Name === name && op.Status === "SUCCEEDED")
-          );
-        };
-
-        return tracer.startActiveSpan(
-          isReplay ? `workflow-${id}-replay` : `workflow-${id}`,
-          {
-            attributes: { workflow_id: id },
-          },
-          async (rootSpan) => {
-            // override context to add tracing
-            const instrumentedCtx = new Proxy(durableCtx, {
-              get(target, prop, receiver) {
-                if (prop === "step") {
-                  return async (
-                    name: string,
-                    fn: () => Promise<any>,
-                    opts: any
-                  ) => {
-                    if (stepCompleted(name)) {
-                      return target.step(name, fn, opts);
-                    }
-
-                    return tracer.startActiveSpan(
-                      `step: ${name}`,
-                      async (stepSpan) => {
-                        try {
-                          console.info(
-                            `stepSpan isRecording=${stepSpan.isRecording()} spanContext=${JSON.stringify(
-                              stepSpan.spanContext()
-                            )}`
-                          );
-
-                          const result = await target.step(name, fn, opts);
-                          stepSpan.setStatus({ code: SpanStatusCode.OK });
-                          return result;
-                        } catch (err) {
-                          // Only record legitimate errors, not Durable Suspend/Sleep interruptions
-                          // (You can filter specifically if you know the Suspend error type)
-                          stepSpan.recordException(err as Error);
-                          stepSpan.setStatus({ code: SpanStatusCode.ERROR });
-                          throw err;
-                        } finally {
-                          stepSpan.end();
-                        }
-                      }
-                    );
-                  };
-                }
-
-                if (prop === "wait") {
-                  return async (name: string, opts: any) => {
-                    if (stepCompleted(name)) {
-                      return target.wait(name, opts);
-                    }
-
-                    return tracer.startActiveSpan(
-                      `wait: ${name}`,
-                      async (waitSpan) => {
-                        console.info(
-                          `waitSpan isRecording=${waitSpan.isRecording()} spanContext=${JSON.stringify(
-                            waitSpan.spanContext()
-                          )}`
-                        );
-
-                        waitSpan.setAttribute("duration_seconds", opts.seconds);
-                        waitSpan.setAttribute("workflow.status", "suspending");
-
-                        console.log(
-                          "[OTEL-FIX] Closing spans before suspend..."
-                        );
-
-                        waitSpan.setStatus({ code: SpanStatusCode.OK });
-                        waitSpan.end();
-
-                        rootSpan.setAttribute("workflow.suspend_trigger", name);
-                        rootSpan.setStatus({ code: SpanStatusCode.OK });
-                        rootSpan.end();
-
-                        const provider = trace.getTracerProvider();
-                        // @ts-ignore
-                        if (typeof provider.forceFlush === "function") {
-                          // @ts-ignore
-                          await provider.forceFlush();
-                          console.log("[OTEL-FIX] Flush complete.");
-                        }
-
-                        await target.wait(name, opts);
-                      }
-                    );
-                  };
-                }
-
-                // Default: Return the original property (e.g., ctx.runId, ctx.now)
-                return Reflect.get(target, prop, receiver);
-              },
-            });
-
-            console.log("eventss", {
-              originalEvent,
-              originalFnContext,
-            });
-
-            const executionArn = originalEvent.DurableExecutionArn;
-            const parts = executionArn.split("/");
-            const executionId = `${parts[parts.length - 2]}/${
-              parts[parts.length - 1]
-            }`;
-
-            console.log("execution details", {
-              event,
-              originalCtx: durableCtx,
-              executionArn,
-              executionId,
-            });
-
-            rootSpan.setAttribute("execution_id", executionId);
-
-            try {
-              console.info(
-                `startRootSpan isRecording=${rootSpan.isRecording()} spanContext=${JSON.stringify(
-                  rootSpan.spanContext()
-                )}`
-              );
-
-              if (input) {
-                const parsed = input.parse(event);
-                await run({ input: parsed, ctx: instrumentedCtx });
-              } else {
-                await run({ ctx: instrumentedCtx, input: event });
-              }
-
-              rootSpan.setStatus({ code: 1 });
-            } catch (error) {
-              console.log("Error in workflow:", error);
-              throw error;
-            } finally {
-              console.log("Ending span for workflow:", id);
-              console.log("Span details:", rootSpan);
-
-              if (rootSpan.isRecording()) {
-                console.log("Ending root span (normal exit)");
-                rootSpan.end();
-              }
-            }
-          }
-        );
-      })(originalEvent, originalFnContext);
-    };
-
-    // @ts-expect-error - accessed by cli during build
-    this.__handler = handler;
-    // @ts-expect-error - accessed by cli during build
-    this[Symbol.for("ocel:lambda:id")] = id;
-
-    if (process.env.OCEL_PHASE === "discovery") {
-      const source = getCallerFile();
-
-      if (!source) {
-        throw new Error(
-          "Could not determine caller file for workflow registration"
-        );
-      }
-
-      rpc.register({
-        id: this.id,
-        type: "workflow",
-        source,
-        config: { ...rest, links },
-      });
-    }
-  }
-
-  __id() {
-    return this.id;
-  }
-
-  trigger(
-    payload: [TInput] extends [never] ? {} : z.infer<TInput>,
-    opts?: {
-      idempotencyKey?: string;
-    }
-  ) {}
-
-  batchTrigger() {}
-
-  triggerAndWait() {}
-
-  batchTriggerAndWait() {}
-}