ocel 0.0.1-alpha.0 → 0.0.1

package/dist/blob/parse.js

@@ -1,69 +0,0 @@
-import { UploadError } from "./upload-error";
-export function parseReq(req) {
-    if (req instanceof Request) {
-        const headers = {};
-        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 = {};
-    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) {
-    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 = {
-        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/dist/blob/s3-listener.d.ts

@@ -1,7 +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 } from "aws-lambda";
-export declare const handler: S3Handler;

package/dist/blob/s3-listener.js

@@ -1,35 +0,0 @@
-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 = async (event) => {
-    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);
-        }
-    }
-};

package/dist/blob/types.d.ts

@@ -1,128 +0,0 @@
-import type { IncomingMessage } from "node:http";
-import z, { type ZodType } from "zod";
-import type { KnownMimeType } from "./mime-types";
-import type { UploadError } from "./upload-error";
-type SuggestedSize = "1KB" | "100KB" | "1MB" | "10MB" | "100MB" | "1GB";
-export type FileSizeUnit = "B" | "KB" | "MB" | "GB";
-export type UnitAutocomplete<TUnit extends string> = `${number}${TUnit}`;
-export type FileSize = SuggestedSize | UnitAutocomplete<FileSizeUnit> | number | (string & {});
-export type StringWithAutocomplete<T extends string> = T | (string & {});
-export type HandleUploadBody = PresignUploadBody | CallbackBody<any>;
-export type HandleUploadResult = PresignUploadResponse;
-export type PresignUploadBody = {
-    files: {
-        name: string;
-        size: number;
-        mimeType: string;
-        lastModified: number;
-    }[];
-    input?: Record<string, any>;
-};
-export type PresignUploadResponse = {
-    files: {
-        url: string;
-        key: string;
-        name: string;
-    }[];
-    sessionId: string;
-};
-export type CallbackBody<TMeta> = {
-    metadata: TMeta;
-    file: {
-        path: string;
-        contentDisposition: string;
-        contentType: string;
-    };
-};
-export type UploadFileBody = {
-    key: string;
-    name: string;
-    size: number;
-    mimeType: string;
-    disposition: string;
-    lastModified: number;
-    metadata?: Record<string, string>;
-};
-export type PathConfig = {
-    prefix?: string;
-    suffix?: string;
-    randomSuffix?: boolean;
-};
-export type PathContext<TMeta> = [TMeta] extends [never] ? {
-    /**
-     * File extension including the dot (e.g., .jpg, .png)
-     */
-    ext: string;
-    /**
-     * File name without extension
-     */
-    fileNameWithoutExt: string;
-    /**
-     * Original file name as uploaded by user
-     */
-    fileNameWithExt: string;
-} : {
-    /**
-     * File extension including the dot (e.g., .jpg, .png)
-     */
-    ext: string;
-    /**
-     * File name without extension
-     */
-    fileNameWithoutExt: string;
-    /**
-     * Original file name as uploaded by user
-     */
-    fileNameWithExt: string;
-    /**
-     * Any metadata returned by middleware function
-     */
-    metadata: TMeta;
-};
-export type PathGenerator<TMeta> = (ctx: PathContext<TMeta>) => string;
-export type PathInput<TMeta> = PathConfig | PathGenerator<TMeta>;
-export type TUploaderConfig<TInput extends ZodType = never, TMeta = never, TReturn = unknown> = {
-    path?: PathInput<TMeta>;
-    input?: TInput;
-    accept?: StringWithAutocomplete<KnownMimeType>[];
-    limits?: {
-        maxFileSize?: FileSize | ((ctx: {
-            metadata?: TMeta;
-        }) => FileSize);
-        maxFileCount?: number | ((ctx: {
-            metadata?: TMeta;
-        }) => number);
-        minFileCount?: number | ((ctx: {
-            metadata?: TMeta;
-        }) => number);
-    };
-    contentDisposition?: "inline" | "attachment";
-    onBeforeUpload: (opts: [TInput] extends [never] ? {
-        files: PresignUploadBody["files"];
-        req: Request | IncomingMessage;
-    } : {
-        files: PresignUploadBody["files"];
-        input: z.infer<TInput>;
-        req: Request | IncomingMessage;
-    }) => TMeta | Promise<TMeta>;
-    onUploadError?: (args: {
-        error: UploadError;
-    }) => void | Promise<void>;
-    onUploadComplete?: (args: {
-        metadata: TMeta;
-        file: {
-            path: string;
-            contentDisposition: string;
-            contentType: string;
-        };
-    }) => TReturn | Promise<TReturn>;
-    _def: {
-        meta: TMeta;
-        input: TInput;
-        output: TReturn;
-    };
-};
-export type TBucketConfig<TUploaderShape> = {
-    uploaders: TUploaderShape;
-};
-export {};

package/dist/blob/types.js

@@ -1 +0,0 @@
-import z, {} from "zod";

package/dist/blob/upload-error.d.ts

@@ -1,35 +0,0 @@
-export declare class UploadError extends Error {
-    readonly statusCode: number;
-    readonly code: string;
-    constructor(message: string, statusCode?: number, code?: string);
-    /**
-     * 400 Bad Request
-     * Use when the input is invalid (e.g. file too big, wrong extension)
-     */
-    static badRequest(message?: string): UploadError;
-    /**
-     * 401 Unauthorized
-     * Use when the user is not logged in or missing headers
-     */
-    static unauthorized(message?: string): UploadError;
-    /**
-     * 403 Forbidden
-     * Use when the user is logged in but doesn't have permission (e.g. wrong plan)
-     */
-    static forbidden(message?: string): UploadError;
-    /**
-     * 404 Not Found
-     * Use when a resource required for the upload is missing
-     */
-    static notFound(message?: string): UploadError;
-    /**
-     * 429 Too Many Requests
-     * Use for rate limiting logic
-     */
-    static tooManyRequests(message?: string): UploadError;
-    /**
-     * 500 Internal Server Error
-     * Use for unexpected crashes or database failures
-     */
-    static internal(message?: string): UploadError;
-}

package/dist/blob/upload-error.js

@@ -1,54 +0,0 @@
-export class UploadError extends Error {
-    statusCode;
-    code;
-    constructor(message, statusCode = 500, code = "INTERNAL_SERVER_ERROR") {
-        super(message);
-        this.statusCode = statusCode;
-        this.code = code;
-        // Essential for 'instanceof' to work correctly when extending built-in classes in TypeScript
-        Object.setPrototypeOf(this, UploadError.prototype);
-    }
-    // --- Static Factory Helpers (The DX Magic) ---
-    /**
-     * 400 Bad Request
-     * Use when the input is invalid (e.g. file too big, wrong extension)
-     */
-    static badRequest(message = "Bad Request") {
-        return new UploadError(message, 400, "BAD_REQUEST");
-    }
-    /**
-     * 401 Unauthorized
-     * Use when the user is not logged in or missing headers
-     */
-    static unauthorized(message = "Unauthorized") {
-        return new UploadError(message, 401, "UNAUTHORIZED");
-    }
-    /**
-     * 403 Forbidden
-     * Use when the user is logged in but doesn't have permission (e.g. wrong plan)
-     */
-    static forbidden(message = "Forbidden") {
-        return new UploadError(message, 403, "FORBIDDEN");
-    }
-    /**
-     * 404 Not Found
-     * Use when a resource required for the upload is missing
-     */
-    static notFound(message = "Not Found") {
-        return new UploadError(message, 404, "NOT_FOUND");
-    }
-    /**
-     * 429 Too Many Requests
-     * Use for rate limiting logic
-     */
-    static tooManyRequests(message = "Too many requests") {
-        return new UploadError(message, 429, "TOO_MANY_REQUESTS");
-    }
-    /**
-     * 500 Internal Server Error
-     * Use for unexpected crashes or database failures
-     */
-    static internal(message = "Internal Server Error") {
-        return new UploadError(message, 500, "INTERNAL_SERVER_ERROR");
-    }
-}

package/dist/blob/uploader.d.ts

@@ -1,67 +0,0 @@
-import type { HandleUploadBody, PathConfig, PathGenerator, TUploaderConfig, UploadFileBody } from "./types";
-import type { IncomingMessage } from "node:http";
-import type { Bucket } from "./bucket";
-export declare class Uploader<TMeta = unknown> {
-    private bucket;
-    private name;
-    private config;
-    private pathGenerator;
-    constructor(bucket: Bucket<any>, name: string, config: TUploaderConfig<any, TMeta>);
-    handleUpload({ action, body, request, sessionId, }: {
-        request: Request | IncomingMessage;
-        body: HandleUploadBody;
-        action: "presign" | "callback" | "poll";
-        sessionId?: string;
-    }): Promise<{
-        files: {
-            url: string;
-            key: string;
-            name: string;
-        }[];
-        sessionId: string;
-    } | {
-        files: {
-            fileKey: string;
-            status: "PENDING" | "SUCCESS" | "FAILED";
-            file: {
-                path: string;
-                contentDisposition: string;
-                contentType: string;
-            } | undefined;
-            metadata: TMeta;
-        }[];
-        completed: boolean;
-        type?: undefined;
-        response?: undefined;
-        error?: undefined;
-    } | {
-        type: "UPLOAD_COMPLETED";
-        response: "ok";
-        files?: undefined;
-        completed?: undefined;
-        error?: undefined;
-    } | {
-        error: {
-            message: string;
-            code: string;
-            status: number;
-        };
-        files?: undefined;
-        completed?: undefined;
-        type?: undefined;
-        response?: undefined;
-    }>;
-    private startPolling;
-    getProvider(): {
-        presign: (files: UploadFileBody[]) => Promise<{
-            files: {
-                url: string;
-                key: string;
-                name: string;
-            }[];
-            sessionId: string;
-        }>;
-    };
-    createConfigBasedGenerator(config: PathConfig): PathGenerator<any>;
-    private validateFiles;
-}