ocel 0.0.1-alpha.0 → 0.0.1

package/dist/workflow/index.js

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

package/dist/workflow/workflow.d.ts

@@ -1,34 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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/src/blob/bucket.ts

@@ -1,92 +0,0 @@
-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

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

package/src/blob/integrations/client.ts

@@ -1,127 +0,0 @@
-import type z from "zod";
-import type { Bucket } from "../bucket";
-import type { PresignUploadBody, PresignUploadResponse } from "../types";
-
-type PollResponse = {
-  files: Array<{
-    fileKey: string;
-    status: "PENDING" | "SUCCESS" | "FAILED";
-    file?: { path: string; contentDisposition: string; contentType: string };
-    metadata?: unknown;
-  }>;
-  completed: boolean;
-};
-
-type InferReturn<TRouter, K extends keyof TRouter> = TRouter[K] extends {
-  _def: { output: infer R };
-}
-  ? R
-  : never;
-
-type InferInput<TRouter, K extends keyof TRouter> = TRouter[K] extends {
-  _def: { input: infer R };
-}
-  ? R
-  : never;
-
-export function createUploadClient<TBucket extends Bucket<any>>(opts: {
-  url: string;
-}) {
-  return {
-    upload: async <K extends keyof TBucket["_shape"]>(
-      uploader: K,
-      args: InferInput<TBucket["_shape"], K> extends never
-        ? {
-            files: File[];
-            onClientUploadComplete?: (
-              res: InferReturn<TBucket["_shape"], K>,
-            ) => void;
-          }
-        : {
-            files: File[];
-            input: z.infer<InferInput<TBucket["_shape"], K>>;
-            onClientUploadComplete?: (
-              res: InferReturn<TBucket["_shape"], K>,
-            ) => void;
-          },
-    ) => {
-      const url = opts.url;
-      const searchParams = new URLSearchParams();
-      searchParams.append("action", "presign");
-      searchParams.append("uploader", String(uploader));
-
-      // get presign urls
-      const result = (await fetch(`${url}?${searchParams.toString()}`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          files: args.files.map((f) => {
-            return {
-              name: f.name,
-              size: f.size,
-              type: f.type,
-              lastModified: f.lastModified,
-              mimeType: f.type,
-            };
-          }),
-          ...("input" in args ? { input: args.input } : {}),
-        } satisfies PresignUploadBody),
-      }).then((r) => r.json())) as PresignUploadResponse;
-
-      // upload files to presign urls (sessionId required for S3 listener to update DynamoDB)
-      await Promise.all(
-        args.files.map((file, index) => {
-          if (!result.files[index]?.url) {
-            throw new Error(`No presign URL returned for file index ${index}`);
-          }
-
-          return fetch(result.files[index].url, {
-            method: "PUT",
-            headers: {
-              "Content-Type": file.type,
-              "Content-Disposition": "inline",
-            },
-            body: file,
-          });
-        }),
-      );
-
-      // poll for completion (S3 listener Lambda updates DynamoDB when upload lands)
-      const pollParams = new URLSearchParams();
-      pollParams.append("action", "poll");
-      pollParams.append("uploader", String(uploader));
-      pollParams.append("sessionId", result.sessionId);
-
-      const pollUntilComplete = async (): Promise<PollResponse> => {
-        const res = await fetch(`${url}?${pollParams.toString()}`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({}),
-        });
-        const data = (await res.json()) as PollResponse;
-        if (data.completed) return data;
-        await new Promise((r) => setTimeout(r, 1000));
-        return pollUntilComplete();
-      };
-
-      const pollResult = await pollUntilComplete();
-
-      if (args.onClientUploadComplete && pollResult.files) {
-        const completedFiles = pollResult.files.filter(
-          (f) => f.status === "SUCCESS" && f.file,
-        );
-        const results = completedFiles.map((f) => ({
-          file: f.file!,
-          metadata: f.metadata ?? {},
-        }));
-        if (results.length > 0) {
-          args.onClientUploadComplete(
-            results.length === 1 ? results[0] : (results as any),
-          );
-        }
-      }
-    },
-  };
-}

package/src/blob/integrations/hono.ts

@@ -1,16 +0,0 @@
-import type { Context } from "hono";
-import type { Bucket } from "../bucket";
-
-export function createRouteHandler(bucket: Bucket<any>) {
-  return async (c: Context) => {
-    const req = c.req.raw;
-    const body = (await req.json()) as any;
-
-    const result = await bucket.handleUpload({
-      body,
-      request: req,
-    });
-
-    return c.json(result);
-  };
-}

package/src/blob/mime-types.ts

@@ -1,68 +0,0 @@
-export type KnownMimeType =
-  // --- APPLICATION ---
-  | "application/json"
-  | "application/xml"
-  | "application/octet-stream" // Generic binary data
-  | "application/zip"
-  | "application/gzip"
-  | "application/x-tar"
-  | "application/wasm"
-  | "application/x-7z-compressed" // 7z files
-  | "application/x-sh" // Shell script
-  | "application/*"
-
-  // --- DOCUMENTS / TEXT ---
-  | "text/plain"
-  | "text/csv"
-  | "text/html"
-  | "text/css"
-  | "text/javascript" // Use application/javascript in production
-  | "application/javascript"
-  | "application/typescript"
-  | "application/pdf"
-  | "application/rtf"
-  | "text/*"
-
-  // --- IMAGES ---
-  | "image/jpeg"
-  | "image/png"
-  | "image/gif"
-  | "image/webp"
-  | "image/svg+xml"
-  | "image/bmp"
-  | "image/tiff"
-  | "image/avif"
-  | "image/vnd.microsoft.icon" // ICO files
-  | "image/*"
-
-  // --- AUDIO ---
-  | "audio/mpeg" // MP3
-  | "audio/wav"
-  | "audio/ogg"
-  | "audio/aac"
-  | "audio/flac"
-  | "audio/*"
-
-  // --- VIDEO ---
-  | "video/mp4"
-  | "video/webm"
-  | "video/ogg"
-  | "video/quicktime" // MOV
-  | "video/x-msvideo" // AVI
-  | "video/*"
-
-  // --- MICROSOFT OFFICE / OPEN OFFICE (Crucial for Business Apps) ---
-  | "application/msword" // .doc
-  | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" // .docx
-  | "application/vnd.ms-excel" // .xls
-  | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" // .xlsx
-  | "application/vnd.ms-powerpoint" // .ppt
-  | "application/vnd.openxmlformats-officedocument.presentationml.presentation" // .pptx
-  | "application/vnd.oasis.opendocument.text" // .odt
-  | "application/vnd.oasis.opendocument.spreadsheet" // .ods
-
-  // --- FONT ---
-  | "font/otf"
-  | "font/ttf"
-  | "font/woff"
-  | "font/woff2";

package/src/blob/parse.ts

@@ -1,93 +0,0 @@
-import type { IncomingMessage } from "node:http";
-import type { FileSize } from "./types";
-import { UploadError } from "./upload-error";
-
-export function parseReq(req: Request | IncomingMessage): {
-  headers: Record<string, string>;
-  method: string;
-  url: string;
-  path: string;
-  query: URLSearchParams;
-} {
-  if (req instanceof Request) {
-    const headers: Record<string, string> = {};
-    req.headers.forEach((value, key) => {
-      headers[key] = value;
-    });
-    return {
-      headers,
-      method: req.method,
-      url: req.url,
-      path: new URL(req.url).pathname,
-      query: new URL(req.url).searchParams,
-    };
-  }
-
-  const headers: Record<string, string> = {};
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (typeof value === "string") {
-      headers[key] = value;
-    } else if (Array.isArray(value)) {
-      headers[key] = value.join(", ");
-    }
-  }
-
-  const url = new URL(req.url || "", "http://localhost");
-
-  return {
-    headers,
-    method: req.method || "GET",
-    url: req.url || "",
-    path: url.pathname,
-    query: url.searchParams,
-  };
-}
-
-/**
- * Converts a human-readable file size string (e.g., "10MB", "2.5GB") into bytes.
- * Throws an error for invalid input formats.
- * * @param size The file size represented as a number (bytes) or a string with units (KB, MB, GB, B).
- * @returns The size in bytes (number).
- */
-export function parseFileSize(size: FileSize): number {
-  if (typeof size === "number") {
-    if (size < 0) {
-      throw UploadError.badRequest("File size cannot be negative.");
-    }
-    return size;
-  }
-
-  // Convert the input to uppercase to handle 'mb', 'MB', 'Mb' uniformly
-  const cleanSize = size.toUpperCase().trim();
-
-  // Regular expression to extract the numeric value and the unit
-  // Captures: (1) The number part, (2) The unit part (B, KB, MB, GB)
-  const match = cleanSize.match(/^(\d+(\.\d+)?)([A-Z]+)$/);
-
-  if (!match) {
-    throw UploadError.badRequest(
-      `Invalid file size format: "${size}". Expected formats: "10MB", "2GB", "512KB", or raw bytes.`
-    );
-  }
-
-  const numericValue = Number.parseFloat(match[1] ?? "0");
-  const unit = match[3] ?? "";
-
-  const byteConversionMap: Record<string, number> = {
-    B: 1,
-    KB: 1024,
-    MB: 1024 ** 2, // 1,048,576
-    GB: 1024 ** 3, // 1,073,741,824
-  };
-
-  const multiplier = byteConversionMap[unit];
-
-  if (!multiplier) {
-    throw new Error(
-      `Invalid file size unit: "${unit}". Must be B, KB, MB, or GB.`
-    );
-  }
-
-  // Return the size rounded to the nearest integer byte
-  return Math.round(numericValue * multiplier);
-}

package/src/blob/s3-listener.ts

@@ -1,48 +0,0 @@
-/**
- * S3 event listener Lambda for ocel/blob.
- * Receives ObjectCreated events, reads x-ocel-session-id from object metadata,
- * and updates the UploadSession in DynamoDB to SUCCESS.
- */
-import type { S3Handler, S3Event } from "aws-lambda";
-import { HeadObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { UpdateItemCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
-
-const s3 = new S3Client({});
-const dynamo = new DynamoDBClient({});
-const TABLE_NAME = process.env.OCEL_TABLE_NAME || "OcelTable";
-
-export const handler: S3Handler = async (event: S3Event) => {
-  for (const record of event.Records) {
-    const bucket = record.s3.bucket.name;
-    const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, " "));
-
-    try {
-      const head = await s3.send(
-        new HeadObjectCommand({ Bucket: bucket, Key: key }),
-      );
-      const sessionId = head.Metadata?.["x-ocel-session-id"];
-      if (!sessionId) continue;
-
-      const pk = `SESSION#${sessionId}`.toLowerCase();
-      const sk = `FILE#${bucket}#${key}`.toLowerCase();
-
-      await dynamo.send(
-        new UpdateItemCommand({
-          TableName: TABLE_NAME,
-          Key: {
-            pk: { S: pk },
-            sk: { S: sk },
-          },
-          UpdateExpression: "SET #status = :status, updatedAt = :now",
-          ExpressionAttributeNames: { "#status": "status" },
-          ExpressionAttributeValues: {
-            ":status": { S: "SUCCESS" },
-            ":now": { S: new Date().toISOString() },
-          },
-        }),
-      );
-    } catch (err) {
-      console.error(`Failed to update session for ${bucket}/${key}:`, err);
-    }
-  }
-};