@editframe/api 0.8.0-beta.5 → 0.8.0-beta.7

package/src/resources/isobmff-track.ts

@@ -6,9 +6,12 @@ import debug from "debug";
 import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
 
 import type { Client } from "../client.ts";
+import { uploadChunks } from "../uploadChunks.ts";
 
 const log = debug("ef:api:isobmff-track");
 
+const MAX_TRACK_SIZE = 1024 * 1024 * 1024; // 1GB
+
 export const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
   z.object({
     file_id: z.string(),
@@ -17,7 +20,7 @@ export const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
     probe_info: AudioStreamSchema,
     duration_ms: z.number().int(),
     codec_name: z.string(),
-    byte_size: z.number().int(),
+    byte_size: z.number().int().max(MAX_TRACK_SIZE),
   }),
   z.object({
     file_id: z.string(),
@@ -26,12 +29,12 @@ export const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
     probe_info: VideoStreamSchema,
     duration_ms: z.number().int(),
     codec_name: z.string(),
-    byte_size: z.number().int(),
+    byte_size: z.number().int().max(MAX_TRACK_SIZE),
   }),
 ]);
 
 export interface CreateISOBMFFTrackResult {
-  last_received_byte: number;
+  next_byte: number;
   byte_size: number;
   track_id: number;
   file_id: string;
@@ -42,6 +45,7 @@ export const createISOBMFFTrack = async (
   payload: z.infer<typeof CreateISOBMFFTrackPayload>,
 ) => {
   log("Creating isobmff track", payload);
+  CreateISOBMFFTrackPayload.parse(payload);
   const response = await client.authenticatedFetch(
     "/api/video2/isobmff_tracks",
     {
@@ -51,16 +55,13 @@ export const createISOBMFFTrack = async (
   );
 
   log("ISOBMFF track created", response);
-  switch (response.status) {
-    case 200: {
-      return (await response.json()) as CreateISOBMFFTrackResult;
-    }
-    default: {
-      console.error("Failed to create track");
-      console.error(await response.json());
-      return;
-    }
+  if (response.ok) {
+    return (await response.json()) as CreateISOBMFFTrackResult;
   }
+
+  throw new Error(
+    `Failed to create isobmff track ${response.status} ${response.statusText}`,
+  );
 };
 
 export const uploadISOBMFFTrack = async (
@@ -68,25 +69,15 @@ export const uploadISOBMFFTrack = async (
   fileId: string,
   trackId: number,
   fileStream: Readable,
+  trackSize: number,
 ) => {
-  log("Uploading isobmff track", fileId, trackId);
-  const trackIndex = await client.authenticatedFetch(
-    `/api/video2/isobmff_tracks/${fileId}/${trackId}/upload`,
-    {
-      method: "POST",
-      body: fileStream,
-    },
-  );
+  log("Uploading fragment track", fileId);
 
-  log("ISOBMFF track uploaded", trackIndex);
-  switch (trackIndex.status) {
-    case 200: {
-      return trackIndex.json();
-    }
-    default: {
-      console.error("Failed to upload track");
-      console.error(trackIndex.status, trackIndex.statusText);
-      return;
-    }
-  }
+  await uploadChunks(client, {
+    url: `/api/video2/isobmff_tracks/${fileId}/${trackId}/upload`,
+    fileStream,
+    fileSize: trackSize,
+  });
+
+  log("Fragment track upload complete");
 };

package/src/resources/renders.test.ts

@@ -0,0 +1,112 @@
+import { test, expect, beforeAll, afterEach, afterAll, describe } from "vitest";
+import { http, HttpResponse } from "msw";
+import { setupServer } from "msw/node";
+
+import { Client } from "../client.ts";
+import { readableFromBuffers } from "../readableFromBuffers.ts";
+import { createRender, uploadRender } from "./renders.ts";
+
+const server = setupServer();
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+describe("Renders", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  describe("createRender", () => {
+    test("throws if server returns an error", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/renders", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        createRender(client, createTestRender()),
+      ).rejects.toThrowError(
+        "Failed to create render 500 Internal Server Error",
+      );
+    });
+
+    test("returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/renders", () =>
+          HttpResponse.json(
+            { testResponse: "test" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await createRender(client, createTestRender());
+
+      expect(response).toEqual({ testResponse: "test" });
+    });
+  });
+
+  describe("uploadRender", () => {
+    test("throws if file size exceeds limit", async () => {
+      await expect(
+        uploadRender(
+          client,
+          "test-id",
+          readableFromBuffers(Buffer.from("test")),
+          1024 * 1024 * 17,
+        ),
+      ).rejects.toThrowError(
+        new Error("File size exceeds limit of 16777216 bytes"),
+      );
+    });
+
+    test("throws if server returns an error", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/renders/test-id/upload", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        uploadRender(
+          client,
+          "test-id",
+          readableFromBuffers(Buffer.from("test")),
+          1024 * 1024 * 2,
+        ),
+      ).rejects.toThrowError(
+        "Failed to upload render 500 Internal Server Error",
+      );
+    });
+
+    test("returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/renders/test-id/upload", () =>
+          HttpResponse.json(
+            { testResponse: "test" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await uploadRender(
+        client,
+        "test-id",
+        readableFromBuffers(Buffer.from("test")),
+        1024 * 1024 * 2,
+      );
+
+      expect(response).toEqual({ testResponse: "test" });
+    });
+  });
+});
+
+const createTestRender = () =>
+  ({
+    id: "test-id",
+    fps: 30,
+    width: 1920,
+    height: 1080,
+    work_slice_ms: 100,
+    duration_ms: 1000,
+    strategy: "v1",
+  }) as const;

package/src/resources/renders.ts

@@ -6,6 +6,7 @@ import debug from "debug";
 import type { Client } from "../client.ts";
 
 const log = debug("ef:api:renders");
+const FILE_SIZE_LIMIT = 1024 * 1024 * 16; // 16MiB
 
 export const CreateRenderPayload = z.object({
   id: z.string().uuid(),
@@ -33,25 +34,27 @@ export const createRender = async (
   });
 
   log("Render created", response);
-  switch (response.status) {
-    case 200: {
-      return (await response.json()) as CreateRenderResult;
-    }
-    default: {
-      console.error("Failed to create render");
-      console.error(await response.json());
-      return;
-    }
+  if (response.ok) {
+    return (await response.json()) as CreateRenderResult;
   }
+
+  throw new Error(
+    `Failed to create render ${response.status} ${response.statusText}`,
+  );
 };
 
 export const uploadRender = async (
   client: Client,
   fileId: string,
   fileStream: Readable,
+  folderSize: number,
 ) => {
   log("Uploading render", fileId);
-  const fileIndex = await client.authenticatedFetch(
+  log("Folder size", folderSize, "bytes");
+  if (folderSize > FILE_SIZE_LIMIT) {
+    throw new Error(`File size exceeds limit of ${FILE_SIZE_LIMIT} bytes`);
+  }
+  const response = await client.authenticatedFetch(
     `/api/video2/renders/${fileId}/upload`,
     {
       method: "POST",
@@ -59,15 +62,11 @@ export const uploadRender = async (
     },
   );
 
-  log("Render uploaded", fileIndex);
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error("Failed to upload render");
-      console.error(fileIndex.status, fileIndex.statusText);
-      return;
-    }
+  if (response.ok) {
+    return response.json();
   }
+
+  throw new Error(
+    `Failed to upload render ${response.status} ${response.statusText}`,
+  );
 };

package/src/resources/test-av-file.txt

@@ -0,0 +1 @@
+test

package/src/resources/unprocessed-file.test.ts

@@ -0,0 +1,312 @@
+import { join } from "node:path";
+
+import { test, expect, beforeAll, afterEach, afterAll, describe } from "vitest";
+import { http, HttpResponse } from "msw";
+import { setupServer } from "msw/node";
+import { ZodError } from "zod";
+
+import { Client } from "../client.ts";
+import {
+  createUnprocessedFile,
+  processAVFile,
+  processAVFileBuffer,
+  updateUnprocessedFile,
+  uploadUnprocessedFile,
+} from "./unprocessed-file.ts";
+import { readableFromBuffers } from "../readableFromBuffers.ts";
+
+const server = setupServer();
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+const TEST_AV_FILE = join(__dirname, "test-av-file.txt");
+
+describe("Unprocessed File", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  describe("createUnprocessedFile", () => {
+    test("Throws when file is too large", async () => {
+      await expect(
+        createUnprocessedFile(client, {
+          id: "test-file",
+          filename: "test-file",
+          processes: [],
+          byte_size: 1024 * 1024 * 1025,
+        }),
+      ).rejects.toThrowError(
+        new ZodError([
+          {
+            code: "too_big",
+            maximum: 1073741824,
+            type: "number",
+            inclusive: true,
+            exact: false,
+            message: "Number must be less than or equal to 1073741824",
+            path: ["byte_size"],
+          },
+        ]),
+      );
+    });
+
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        createUnprocessedFile(client, {
+          id: "test-file",
+          filename: "test-file",
+          processes: [],
+          byte_size: 1024 * 1024,
+        }),
+      ).rejects.toThrowError(
+        "Failed to create unprocessed file 500 Internal Server Error",
+      );
+    });
+
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.json(
+            { testResponse: "test" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const result = await createUnprocessedFile(client, {
+        id: "test-file",
+        filename: "test-file",
+        processes: [],
+        byte_size: 1024 * 1024,
+      });
+
+      expect(result).toEqual({ testResponse: "test" });
+    });
+  });
+
+  describe("updateUnprocessedFile", () => {
+    test("Throws when server responds with an error", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files/test-file", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        updateUnprocessedFile(client, "test-file", {
+          processes: [],
+        }),
+      ).rejects.toThrowError(
+        "Failed to update unprocessed file 500 Internal Server Error",
+      );
+    });
+
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files/test-file", () =>
+          HttpResponse.json(
+            { testResponse: "test" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const result = await updateUnprocessedFile(client, "test-file", {
+        processes: [],
+      });
+
+      expect(result).toEqual({ testResponse: "test" });
+    });
+  });
+
+  describe("uploadUnprocessedFile", () => {
+    test("Throws when server responds with an error", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/test-file/upload",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        uploadUnprocessedFile(
+          client,
+          "test-file",
+          readableFromBuffers(Buffer.from("test")),
+          4,
+        ),
+      ).rejects.toThrowError(
+        "Failed to upload chunk 0 for /api/v1/unprocessed_files/test-file/upload 500 Internal Server Error",
+      );
+    });
+
+    test("Succeeds when server returns a success", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/test-file/upload",
+          () => HttpResponse.json({}, { status: 201 }),
+        ),
+      );
+
+      await expect(
+        uploadUnprocessedFile(
+          client,
+          "test-file",
+          readableFromBuffers(Buffer.from("test")),
+          4,
+        ),
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("processAVFileBuffer", () => {
+    test("Throws when server responds with an error when creating file", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+      ).rejects.toThrowError(
+        "Failed to create unprocessed file 500 Internal Server Error",
+      );
+    });
+
+    test("Throws when server responds with an error when uploading file", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.json({}, { status: 200 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+      ).rejects.toThrowError(
+        "Failed to upload chunk 0 for /api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload 500 Internal Server Error",
+      );
+    });
+
+    test("Throws when server responds with an error when updating file", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.json({}, { status: 200 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload",
+          () => HttpResponse.json({ test }, { status: 201 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+      ).rejects.toThrowError(
+        "Failed to update unprocessed file 500 Internal Server Error",
+      );
+    });
+
+    test("Returns json data when upload is successful", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.json({}, { status: 200 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload",
+          () => HttpResponse.json({}, { status: 201 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6",
+          () => HttpResponse.json({ test: "response" }, { status: 200 }),
+        ),
+      );
+
+      await expect(
+        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+      ).resolves.toEqual({ test: "response" });
+    });
+  });
+
+  describe("processAVFile", () => {
+    test("Throws when server responds with an error when creating file", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(processAVFile(client, TEST_AV_FILE)).rejects.toThrowError(
+        "Failed to create unprocessed file 500 Internal Server Error",
+      );
+    });
+
+    test("Throws when server responds with an error when uploading file", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.json({}, { status: 200 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(processAVFile(client, TEST_AV_FILE)).rejects.toThrowError(
+        "Failed to upload chunk 0 for /api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload 500 Internal Server Error",
+      );
+    });
+
+    test("Throws when server responds with an error when updating file", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.json({}, { status: 200 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload",
+          () => HttpResponse.json({ test }, { status: 201 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(processAVFile(client, TEST_AV_FILE)).rejects.toThrowError(
+        "Failed to update unprocessed file 500 Internal Server Error",
+      );
+    });
+
+    test("Returns json data when upload is successful", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/unprocessed_files", () =>
+          HttpResponse.json({}, { status: 200 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload",
+          () => HttpResponse.json({}, { status: 201 }),
+        ),
+        http.post(
+          "http://localhost/api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6",
+          () => HttpResponse.json({ test: "response" }, { status: 200 }),
+        ),
+      );
+
+      await expect(processAVFile(client, TEST_AV_FILE)).resolves.toEqual({
+        test: "response",
+      });
+    });
+  });
+});