@uploadista/core 0.0.13-beta.5 → 0.0.13

package/src/testing/mock-upload-server.ts

@@ -0,0 +1,176 @@
+import { Effect, Layer } from "effect";
+import type { InputFile, UploadFile, WebSocketConnection } from "../types";
+import { UploadServer } from "../upload";
+import type { DataStoreCapabilities } from "../types/data-store";
+
+/**
+ * Mock UploadServer implementation for testing.
+ *
+ * Provides a complete in-memory implementation of all UploadServer methods
+ * suitable for unit and integration tests.
+ *
+ * @example
+ * ```typescript
+ * import { TestUploadServer } from "@uploadista/core/testing";
+ *
+ * const program = Effect.gen(function* () {
+ *   const server = yield* UploadServer;
+ *   const upload = yield* server.createUpload(inputFile, "client-123");
+ *   return upload;
+ * }).pipe(Effect.provide(TestUploadServer));
+ * ```
+ */
+export const TestUploadServer = Layer.succeed(
+  UploadServer,
+  UploadServer.of({
+    read: (fileId: string, _clientId: string | null) =>
+      Effect.sync(() => {
+        // Generate mock file data based on fileId
+        const text = `Content of file ${fileId}`;
+        return new TextEncoder().encode(text);
+      }),
+    upload: (file, _clientId, stream) =>
+      Effect.gen(function* () {
+        // Read stream to completion
+        const reader = stream.getReader();
+        let totalSize = 0;
+        const chunks: Uint8Array[] = [];
+
+        while (true) {
+          const { done, value } = yield* Effect.promise(() => reader.read());
+          if (done) break;
+          if (value) {
+            chunks.push(value);
+            totalSize += value.byteLength;
+          }
+        }
+
+        // Parse existing metadata
+        const existingMetadata =
+          typeof file.metadata === "string"
+            ? JSON.parse(file.metadata)
+            : file.metadata || {};
+
+        // Extract extension from fileName
+        const extension = file.fileName
+          ? file.fileName.split(".").pop()
+          : existingMetadata.extension;
+
+        // Create new UploadFile with merged metadata
+        return {
+          id: `uploaded-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+          offset: totalSize,
+          size: totalSize,
+          storage: {
+            id: file.storageId,
+            type: "memory",
+          },
+          metadata: {
+            ...existingMetadata,
+            // Update with InputFile type and fileName
+            mimeType: file.type,
+            type: file.type,
+            "content-type": file.type,
+            fileName: file.fileName,
+            originalName: file.fileName,
+            name: file.fileName,
+            extension,
+          },
+          creationDate: new Date().toISOString(),
+        } satisfies UploadFile;
+      }),
+    delete: (_fileId: string, _clientId: string | null) => Effect.void,
+    createUpload: (file: InputFile, _clientId: string | null) =>
+      Effect.succeed({
+        id: `uploaded-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+        offset: 0,
+        size: 0,
+        storage: { id: file.storageId, type: "memory" },
+        metadata:
+          typeof file.metadata === "string"
+            ? JSON.parse(file.metadata)
+            : file.metadata,
+      } satisfies UploadFile),
+    uploadChunk: (
+      uploadId: string,
+      _clientId: string | null,
+      chunk: ReadableStream,
+    ) =>
+      Effect.gen(function* () {
+        // Read stream to completion
+        const reader = chunk.getReader();
+        let totalSize = 0;
+        const chunks: Uint8Array[] = [];
+
+        while (true) {
+          const { done, value } = yield* Effect.promise(() => reader.read());
+          if (done) break;
+          if (value) {
+            chunks.push(value);
+            totalSize += value.byteLength;
+          }
+        }
+        return {
+          id: uploadId,
+          offset: totalSize,
+          size: totalSize,
+          storage: { id: "test-storage", type: "memory" },
+          metadata: { mimeType: "application/octet-stream", extension: "bin" },
+          creationDate: new Date().toISOString(),
+        } satisfies UploadFile;
+      }),
+    getCapabilities: (_storageId: string, _clientId: string | null) =>
+      Effect.succeed({
+        supportsParallelUploads: true,
+        supportsConcatenation: true,
+        supportsDeferredLength: true,
+        supportsResumableUploads: true,
+        supportsTransactionalUploads: false,
+        maxConcurrentUploads: 10,
+        minChunkSize: 5 * 1024 * 1024, // 5MB
+        maxChunkSize: 100 * 1024 * 1024, // 100MB
+        maxParts: 10000,
+        optimalChunkSize: 10 * 1024 * 1024, // 10MB
+        requiresOrderedChunks: false,
+        requiresMimeTypeValidation: false,
+      } satisfies DataStoreCapabilities),
+    uploadFromUrl: (
+      inputFile: InputFile,
+      _clientId: string | null,
+      url: string,
+    ) =>
+      Effect.succeed({
+        id: `uploaded-from-url-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+        offset: 0,
+        size: 0,
+        storage: { id: inputFile.storageId, type: "memory" },
+        metadata:
+          typeof inputFile.metadata === "string"
+            ? JSON.parse(inputFile.metadata)
+            : inputFile.metadata,
+        url,
+        creationDate: new Date().toISOString(),
+      } satisfies UploadFile),
+    getUpload: (uploadId: string) =>
+      Effect.succeed({
+        id: uploadId,
+        offset: 0,
+        size: 1024,
+        storage: {
+          id: "test-storage",
+          type: "memory",
+        },
+        metadata: {
+          mimeType: "text/plain",
+          originalName: `file-${uploadId}.txt`,
+          extension: "txt",
+        },
+        creationDate: new Date().toISOString(),
+      } satisfies UploadFile),
+    subscribeToUploadEvents: (
+      _uploadId: string,
+      _connection: WebSocketConnection,
+    ) => Effect.void,
+    unsubscribeFromUploadEvents: (_uploadId: string) => Effect.void,
+  }),
+);

package/src/testing/mock-video-plugin.ts

@@ -0,0 +1,94 @@
+import { Effect, Layer } from "effect";
+import { VideoPlugin } from "../flow";
+import type { DescribeVideoMetadata } from "../flow/plugins/types/describe-video-node";
+
+/**
+ * Mock VideoPlugin implementation for testing.
+ *
+ * Provides simple mock implementations of video processing operations
+ * that return mock Uint8Array data without requiring FFmpeg or node-av.
+ *
+ * @example
+ * ```typescript
+ * import { TestVideoPlugin } from "@uploadista/core/testing";
+ *
+ * const program = Effect.gen(function* () {
+ *   const plugin = yield* VideoPlugin;
+ *   const transcoded = yield* plugin.transcode(videoBytes, { format: "webm", codec: "vp9" });
+ *   return transcoded;
+ * }).pipe(Effect.provide(TestVideoPlugin));
+ * ```
+ */
+export const TestVideoPlugin = Layer.succeed(
+  VideoPlugin,
+  VideoPlugin.of({
+    describe: (input: Uint8Array) =>
+      Effect.sync(() => {
+        // Mock describe: return fake metadata based on input size
+        const metadata: DescribeVideoMetadata = {
+          duration: 120, // 2 minutes
+          width: 1920,
+          height: 1080,
+          codec: "h264",
+          format: "mp4",
+          bitrate: 5000000, // 5 Mbps
+          frameRate: 30,
+          aspectRatio: "16:9",
+          hasAudio: true,
+          audioCodec: "aac",
+          audioBitrate: 128000, // 128 kbps
+          size: input.byteLength,
+        };
+        return metadata;
+      }),
+    transcode: (_input: Uint8Array, options) =>
+      Effect.sync(() => {
+        // Mock transcode: return modified array
+        // Simulate different file sizes for different codecs
+        let sizeMultiplier = 1.0;
+        if (options.codec === "vp9") {
+          sizeMultiplier = 0.8; // VP9 is more efficient
+        } else if (options.codec === "h265") {
+          sizeMultiplier = 0.7; // H265 is even more efficient
+        }
+
+        const newSize = Math.floor(_input.byteLength * sizeMultiplier);
+        return new Uint8Array(newSize).fill(42);
+      }),
+    resize: (input: Uint8Array, options) =>
+      Effect.sync(() => {
+        // Mock resize: return array with size based on dimensions
+        const width = options.width || 1280;
+        const height = options.height || 720;
+        // Simulate file size roughly proportional to resolution
+        const mockSize = Math.floor((width * height) / 50);
+        return new Uint8Array(mockSize).fill(84);
+      }),
+    trim: (_input: Uint8Array, options) =>
+      Effect.sync(() => {
+        // Mock trim: return smaller array based on duration
+        let duration: number;
+        if (options.duration !== undefined) {
+          duration = options.duration;
+        } else if (options.endTime !== undefined) {
+          duration = options.endTime - options.startTime;
+        } else {
+          // Assume 120s total duration
+          duration = 120 - options.startTime;
+        }
+
+        // Simulate proportional file size based on duration
+        const ratio = duration / 120; // Assuming 120s original
+        const newSize = Math.floor(_input.byteLength * ratio);
+        return new Uint8Array(newSize).fill(63);
+      }),
+    extractFrame: (input: Uint8Array, options) =>
+      Effect.sync(() => {
+        // Mock extractFrame: return image bytes (smaller than video)
+        const format = options.format || "jpeg";
+        // JPEG typically smaller than PNG
+        const mockSize = format === "png" ? 50000 : 30000;
+        return new Uint8Array(mockSize).fill(255);
+      }),
+  }),
+);

package/src/testing/mock-zip-plugin.ts

@@ -0,0 +1,41 @@
+import { Effect, Layer } from "effect";
+import { ZipPlugin } from "../flow";
+
+/**
+ * Mock ZipPlugin implementation for testing.
+ *
+ * Provides a simple in-memory implementation that creates mock zip data
+ * by serializing file metadata as JSON.
+ *
+ * @example
+ * ```typescript
+ * import { TestZipPlugin } from "@uploadista/core/testing";
+ *
+ * const program = Effect.gen(function* () {
+ *   const zipPlugin = yield* ZipPlugin;
+ *   const zipData = yield* zipPlugin.zip(inputs, options);
+ *   return zipData;
+ * }).pipe(Effect.provide(TestZipPlugin));
+ * ```
+ */
+export const TestZipPlugin = Layer.succeed(
+  ZipPlugin,
+  ZipPlugin.of({
+    zip: (inputs, options) =>
+      Effect.gen(function* () {
+        // Create mock zip data
+        const files = inputs.map((input) => ({
+          id: input.id,
+          size: input.data.byteLength,
+        }));
+
+        const zipContent = JSON.stringify({
+          zipName: options.zipName,
+          includeMetadata: options.includeMetadata,
+          files,
+        });
+
+        return new TextEncoder().encode(zipContent);
+      }),
+  }),
+);

package/src/types/data-store.ts

@@ -158,7 +158,7 @@ export type DataStore<TData = unknown> = {
       onProgress?: (chunkSize: number) => void;
     },
   ) => Effect.Effect<number, UploadistaError>;
-  readonly deleteExpired?: Effect.Effect<number, UploadistaError>;
+  readonly deleteExpired?: () => Effect.Effect<number, UploadistaError>;
   readonly getCapabilities: () => DataStoreCapabilities;
   readonly validateUploadStrategy: (
     strategy: UploadStrategy,

package/{src/errors/__tests__ → tests/errors}/uploadista-error.test.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Exit } from "effect";
 import { describe, expect, it } from "vitest";
 import {
   ERROR_CATALOG,
@@ -6,7 +6,7 @@ import {
   isUploadistaError,
   UploadistaError,
   type UploadistaErrorCode,
-} from "../uploadista-error";
+} from "../../src/errors";
 
 describe("ERROR_CATALOG", () => {
   it("should contain all error codes with status and body", () => {
@@ -76,7 +76,6 @@ describe("UploadistaError", () => {
     expect(error.status).toBe(404);
     expect(error.status_code).toBe(404); // legacy alias
     expect(error.body).toBe("File not found");
-    expect(error.message).toBe("File not found");
     expect(error.details).toEqual({ fileId: "123" });
     expect((error as { cause?: unknown }).cause).toBeInstanceOf(Error);
   });
@@ -173,12 +172,14 @@ describe("UploadistaError", () => {
   });
 
   describe("toFailure", () => {
-    it("should convert error to failure result", () => {
+    it("should convert error to failure result", async () => {
       const error = UploadistaError.fromCode("FILE_NOT_FOUND");
-      const result = error.toEffect();
+      const effect = error.toEffect();
 
-      expect(Effect.isFailure(result)).toBe(true);
-      expect(Effect.isSuccess(result)).toBe(false);
+      const result = await Effect.runPromiseExit(effect);
+
+      expect(Exit.isFailure(result)).toBe(true);
+      expect(Exit.isSuccess(result)).toBe(false);
     });
   });
 });
@@ -216,25 +217,27 @@ describe("isUploadistaError", () => {
 });
 
 describe("httpFailure", () => {
-  it("should create failure result from error code", () => {
-    const result = httpFailure("FILE_NOT_FOUND");
+  it("should create failure result from error code", async () => {
+    const effect = httpFailure("FILE_NOT_FOUND");
+    const result = await Effect.runPromiseExit(effect);
 
-    expect(Effect.isFailure(result)).toBe(true);
-    expect(Effect.isSuccess(result)).toBe(false);
+    expect(Exit.isFailure(result)).toBe(true);
+    expect(Exit.isSuccess(result)).toBe(false);
   });
 
-  it("should allow overriding error properties", () => {
-    const result = httpFailure("UNKNOWN_ERROR", {
+  it("should allow overriding error properties", async () => {
+    const effect = httpFailure("UNKNOWN_ERROR", {
       status: 503,
       body: "Service unavailable",
       details: { retryAfter: 60 },
     });
+    const result = await Effect.runPromiseExit(effect);
 
-    expect(Effect.isFailure(result)).toBe(true);
-    expect(Effect.isSuccess(result)).toBe(false);
+    expect(Exit.isFailure(result)).toBe(true);
+    expect(Exit.isSuccess(result)).toBe(false);
   });
 
-  it("should work with all error codes", () => {
+  it("should work with all error codes", async () => {
     const errorCodes: UploadistaErrorCode[] = [
       "MISSING_OFFSET",
       "FLOW_NODE_ERROR",
@@ -242,9 +245,10 @@ describe("httpFailure", () => {
     ];
 
     for (const code of errorCodes) {
-      const result = httpFailure(code);
-      expect(Effect.isFailure(result)).toBe(true);
-      expect(Effect.isSuccess(result)).toBe(false);
+      const effect = httpFailure(code);
+      const result = await Effect.runPromiseExit(effect);
+      expect(Exit.isFailure(result)).toBe(true);
+      expect(Exit.isSuccess(result)).toBe(false);
     }
   });
 });

package/{src → tests}/flow/edge.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createFlowEdge, type FlowEdge } from "./edge";
+import { createFlowEdge, type FlowEdge } from "../../src/flow/edge";
 
 describe("FlowEdge", () => {
   describe("createFlowEdge", () => {