ocel 0.0.0 → 0.0.1-alpha.1

package/dist/lambda/lambda.js

@@ -0,0 +1,30 @@
+import { rpc } from "../utils/rpc";
+import { getCallerFile } from "../utils/stack";
+export class Lambda {
+    id;
+    constructor(id, config) {
+        this.id = id;
+        // 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() {
+        return this.id;
+    }
+}

package/dist/postgres/index.d.ts

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

package/dist/postgres/index.js

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

package/dist/postgres/pg.d.ts

@@ -0,0 +1,11 @@
+import type { Component } from "../utils/component";
+export interface PostgresConfig {
+    version?: string;
+    migrations?: string;
+}
+export declare class Postgres implements Component {
+    id: string;
+    constructor(id: string, config: PostgresConfig);
+    __id(): string;
+    sql(query: string): Promise<{}>;
+}

package/dist/postgres/pg.js

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

package/dist/utils/component.d.ts

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

package/dist/utils/component.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_DISCOVERY_PHASE: boolean;
+export declare const IS_DEV_MODE: boolean;

package/dist/utils/constants.js

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

package/dist/utils/nanoid.d.ts

@@ -0,0 +1 @@
+export declare function getNanoid(length?: number): string;

package/dist/utils/nanoid.js

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

package/dist/utils/rpc.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    var __ocelRegister: Promise<unknown>[];
+}
+export declare const rpc: {
+    register: (args: {
+        id: string;
+        type: "lambda" | "bucket" | "workflow" | "postgres";
+        source: string;
+        config?: Record<string, unknown>;
+    }) => Promise<void>;
+};

package/dist/utils/rpc.js

@@ -0,0 +1,17 @@
+export const rpc = {
+    register: async (args) => {
+        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/dist/utils/stack.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns absolute path of the caller file.
+ */
+export declare function getCallerFile(depth?: number): string | null;

package/dist/utils/stack.js

@@ -0,0 +1,23 @@
+/**
+ * Returns absolute path of the caller file.
+ */
+export function getCallerFile(depth = 1) {
+    const original = Error.prepareStackTrace;
+    try {
+        Error.prepareStackTrace = (_, stack) => stack;
+        const err = new Error();
+        const frames = err.stack;
+        // 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/dist/workflow/index.d.ts

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

package/dist/workflow/index.js

@@ -0,0 +1,4 @@
+import { Workflow } from "./workflow";
+export function workflow(id, config) {
+    return new Workflow(id, config);
+}

package/dist/workflow/workflow.d.ts

@@ -0,0 +1,34 @@
+import type { z, ZodType } from "zod";
+import type { Component } from "../utils/component";
+import { type DurableContext } from "@aws/durable-execution-sdk-js";
+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 declare class Workflow<TInput extends ZodType = never> implements Component {
+    private id;
+    constructor(id: string, config: WorkflowConfig<TInput>);
+    __id(): string;
+    trigger(payload: [TInput] extends [never] ? {} : z.infer<TInput>, opts?: {
+        idempotencyKey?: string;
+    }): void;
+    batchTrigger(): void;
+    triggerAndWait(): void;
+    batchTriggerAndWait(): void;
+}

package/dist/workflow/workflow.js

@@ -0,0 +1,146 @@
+import { withDurableExecution, } from "@aws/durable-execution-sdk-js";
+import { getCallerFile } from "../utils/stack";
+import { rpc } from "../utils/rpc";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+export class Workflow {
+    id;
+    constructor(id, config) {
+        this.id = id;
+        const { run, input, link, ...rest } = config;
+        const links = link?.map((component) => component.__id()) || [];
+        const tracer = trace.getTracer("ocel/workflow");
+        const handler = (originalEvent, originalFnContext) => {
+            return withDurableExecution(async (event, durableCtx) => {
+                const ctx = durableCtx;
+                const isReplay = ctx.durableExecutionMode === "ReplayMode";
+                const ops = originalEvent.InitialExecutionState?.Operations || [];
+                const stepCompleted = (name) => {
+                    return (isReplay &&
+                        ops.some((op) => 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, fn, opts) => {
+                                    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);
+                                            stepSpan.setStatus({ code: SpanStatusCode.ERROR });
+                                            throw err;
+                                        }
+                                        finally {
+                                            stepSpan.end();
+                                        }
+                                    });
+                                };
+                            }
+                            if (prop === "wait") {
+                                return async (name, opts) => {
+                                    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, opts) { }
+    batchTrigger() { }
+    triggerAndWait() { }
+    batchTriggerAndWait() { }
+}

package/package.json

@@ -1,13 +1,98 @@
 {
   "name": "ocel",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "0.0.1-alpha.1",
+  "type": "module",
+  "description": "The power of AWS with the DX of Vercel",
+  "bin": {
+    "ocel": "./bin/run.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "src/",
+    "README.md"
+  ],
+  "exports": {
+    "./blob": {
+      "import": "./dist/blob/index.js",
+      "types": "./dist/blob/index.d.ts"
+    },
+    "./blob/client": {
+      "import": "./dist/blob/integrations/client.js",
+      "types": "./dist/blob/integrations/client.d.ts"
+    },
+    "./blob/*": {
+      "import": "./dist/blob/integrations/*.js",
+      "types": "./dist/blob/integrations/*.d.ts"
+    },
+    "./lambda": {
+      "import": "./dist/lambda/index.js",
+      "types": "./dist/lambda/index.d.ts"
+    },
+    "./lambda/*": {
+      "import": "./dist/lambda/integrations/*.js",
+      "types": "./dist/lambda/integrations/*.d.ts"
+    },
+    "./workflow": {
+      "import": "./dist/workflow/index.js",
+      "types": "./dist/workflow/index.d.ts"
+    },
+    "./postgres": {
+      "import": "./dist/postgres/index.js",
+      "types": "./dist/postgres/index.d.ts"
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "build:listener": "bun build src/blob/s3-listener.ts --outfile=dist/blob-listener/index.js --target=node --format=cjs --minify"
+  },
+  "license": "MIT",
+  "packageManager": "pnpm@10.18.3",
+  "optionalDependencies": {
+    "@ocel/linux-x64": "^0.0.1-alpha.1",
+    "@ocel/win32-x64": "^0.0.1-alpha.1",
+    "@ocel/darwin-arm64": "^0.0.1-alpha.1",
+    "@ocel/darwin-x64": "^0.0.1-alpha.1"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.160",
+    "@types/express": "~5.0.0",
+    "express": "~5.0.0",
+    "hono": "~4.11.1",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.958.0",
+    "@aws-sdk/client-lambda": "^3.958.0",
+    "@aws-sdk/client-s3": "^3.958.0",
+    "@aws-sdk/client-xray": "^3.958.0",
+    "@aws-sdk/s3-request-presigner": "^3.958.0",
+    "@aws/durable-execution-sdk-js": "^1.0.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@sindresorhus/slugify": "^3.0.0",
+    "electrodb": "^3.5.0",
+    "nanoid": "^5.1.6",
+    "serverless-http": "^4.0.0",
+    "zod": "^4.2.1"
+  },
+  "peerDependencies": {
+    "hono": ">=4.11.1",
+    "@types/express": ">=5.0.0",
+    "express": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "hono": {
+      "optional": true
+    },
+    "@types/express": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    }
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.18.3"
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
 }

package/src/blob/bucket.ts

@@ -0,0 +1,92 @@
+import type { IncomingMessage } from "node:http";
+import z from "zod";
+import { getCallerFile } from "../utils/stack";
+import { rpc } from "../utils/rpc";
+import type { HandleUploadBody, TBucketConfig, TUploaderConfig } from "./types";
+import { Uploader } from "./uploader";
+import { parseReq } from "./parse";
+import type { Component } from "../utils/component";
+
+export class Bucket<
+  TUploaderShape extends Record<string, TUploaderConfig<any, any>>
+> implements Component
+{
+  public readonly _shape: TUploaderShape = {} as any;
+  private uploaders: Record<string, Uploader<any>> = {};
+
+  constructor(
+    public readonly name: string,
+    args: TBucketConfig<TUploaderShape>
+  ) {
+    if (process.env.OCEL_PHASE === "discovery") {
+      rpc.register({
+        id: name,
+        type: "bucket",
+        source: getCallerFile() || "unknown",
+        // TODO:
+        config: {},
+      });
+    }
+
+    this._shape = args.uploaders;
+
+    Object.entries(args.uploaders).forEach(([key, config]) => {
+      this.uploaders[key] = new Uploader(this, key, config);
+    });
+  }
+
+  __id() {
+    return this.name;
+  }
+
+  __name() {
+    const id = process.env[`RESOURCE_${this.name}_BUCKET_NAME`];
+    if (!id) {
+      throw new Error(
+        `Bucket ID for bucket "${this.name}" is not defined. Make sure the bucket is properly configured in your Ocel project.`
+      );
+    }
+    return id;
+  }
+
+  upload = async () => {};
+
+  uploadExternal = async () => {};
+
+  handleUpload = async ({
+    body,
+    request,
+  }: {
+    request: Request | IncomingMessage;
+    body: HandleUploadBody;
+  }) => {
+    const parsedReq = parseReq(request);
+    const hasUploaders = Object.keys(this._shape).length > 0;
+    if (!hasUploaders) {
+      throw new Error("No uploaders configured for this bucket");
+    }
+
+    const querySchema = z.object({
+      action: z.enum(["presign", "callback", "poll"]),
+      uploader: z.enum(Object.keys(this._shape) as [string, ...string[]]),
+      sessionId: z.string().optional(),
+    });
+    const queryRes = querySchema.safeParse(Object.fromEntries(parsedReq.query));
+    if (!queryRes.success) {
+      throw new Error(`Invalid query parameters: ${queryRes.error.message}`);
+    }
+
+    const query = queryRes.data;
+    const uploader = this.uploaders[query.uploader];
+    if (!uploader) {
+      throw new Error(`Uploader not found: ${query.uploader}`);
+    }
+
+    return uploader.handleUpload({
+      body,
+      request,
+      action: query.action,
+      sessionId: query.sessionId,
+    });
+  };
+}

package/src/blob/index.ts

@@ -0,0 +1,34 @@
+import { type ZodType } from "zod";
+import type { TBucketConfig, TUploaderConfig } from "./types";
+import { Bucket } from "./bucket";
+
+export function bucket<
+  TUploaderShape extends Record<string, TUploaderConfig<any, any>>
+>(name: string, args: TBucketConfig<TUploaderShape>) {
+  return new Bucket<TUploaderShape>(name, args);
+}
+
+export function uploader<
+  TInput extends ZodType = never,
+  TMeta = never,
+  TReturn = void
+>(
+  {
+    middleware,
+    input,
+  }: {
+    input?: TInput;
+    middleware: TUploaderConfig<TInput, TMeta, TReturn>["onBeforeUpload"];
+  },
+  config: Omit<
+    TUploaderConfig<TInput, TMeta, TReturn>,
+    "onBeforeUpload" | "_def" | "input"
+  >
+) {
+  return {
+    ...config,
+    input,
+    onBeforeUpload: middleware,
+    _def: {} as any,
+  } as TUploaderConfig<TInput, TMeta, TReturn>;
+}