@editframe/api 0.7.0-beta.8 → 0.8.0-beta.10

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

@@ -0,0 +1,108 @@
+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 { createISOBMFFFile, uploadFragmentIndex } from "./isobmff-file.ts";
+import { readableFromBuffers } from "../readableFromBuffers.ts";
+
+const server = setupServer();
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+describe("ISOBMFFFile", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  describe("createISOBMFFFile", () => {
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/isobmff_files", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        createISOBMFFFile(client, {
+          id: "test-id",
+          filename: "test",
+        }),
+      ).rejects.toThrowError(
+        "Failed to create isobmff file 500 Internal Server Error",
+      );
+    });
+
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/isobmff_files", () =>
+          HttpResponse.json(
+            { id: "test-id" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await createISOBMFFFile(client, {
+        id: "test-id",
+        filename: "test",
+      });
+
+      expect(response).toEqual({ id: "test-id" });
+    });
+  });
+
+  describe("uploadFragmentIndex", () => {
+    test("Throws when file size exceeds limit", async () => {
+      await expect(
+        uploadFragmentIndex(
+          client,
+          "test-id",
+          readableFromBuffers(Buffer.from("test")),
+          1024 * 1024 * 3,
+        ),
+      ).rejects.toThrowError("File size exceeds limit of 2097152 bytes");
+    });
+
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/video2/isobmff_files/test-id/index/upload",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        uploadFragmentIndex(
+          client,
+          "test-id",
+          readableFromBuffers(Buffer.from("test")),
+          4,
+        ),
+      ).rejects.toThrowError(
+        "Failed to create fragment index 500 Internal Server Error",
+      );
+    });
+
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/video2/isobmff_files/test-id/index/upload",
+          () =>
+            HttpResponse.json(
+              { fragment_index_complete: true },
+              { status: 200, statusText: "OK" },
+            ),
+        ),
+      );
+
+      const response = await uploadFragmentIndex(
+        client,
+        "test-id",
+        readableFromBuffers(Buffer.from("test")),
+        4,
+      );
+
+      expect(response).toEqual({ fragment_index_complete: true });
+    });
+  });
+});

package/src/resources/isobmff-file.ts

@@ -3,9 +3,10 @@ import type { Readable } from "node:stream";
 import { z } from "zod";
 import debug from "debug";
 
-import type { Client } from "../client";
+import type { Client } from "../client.ts";
 
 const log = debug("ef:api:isobmff-file");
+const FILE_SIZE_LIMIT = 1024 * 1024 * 2; // 32MB
 
 export const CreateISOBMFFFilePayload = z.object({
   id: z.string(),
@@ -32,26 +33,26 @@ export const createISOBMFFFile = async (
 
   log("ISOBMFF file created", response);
 
-  switch (response.status) {
-    case 200: {
-      return (await response.json()) as CreateISOBMFFFileResult;
-    }
-    default: {
-      console.error(
-        `Failed to create file ${response.status} ${response.statusText}`,
-      );
-      return;
-    }
+  if (response.ok) {
+    return (await response.json()) as CreateISOBMFFFileResult;
   }
+
+  throw new Error(
+    `Failed to create isobmff file ${response.status} ${response.statusText}`,
+  );
 };
 
 export const uploadFragmentIndex = async (
   client: Client,
   fileId: string,
   fileStream: Readable,
+  fileSize: number,
 ) => {
   log("Uploading fragment index", fileId);
-  const fileIndex = await client.authenticatedFetch(
+  if (fileSize > FILE_SIZE_LIMIT) {
+    throw new Error(`File size exceeds limit of ${FILE_SIZE_LIMIT} bytes`);
+  }
+  const response = await client.authenticatedFetch(
     `/api/video2/isobmff_files/${fileId}/index/upload`,
     {
       method: "POST",
@@ -59,16 +60,12 @@ export const uploadFragmentIndex = async (
     },
   );
 
-  log("Fragment index uploaded", fileIndex);
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error(
-        `Failed to create fragment index ${fileIndex.status} ${fileIndex.statusText}`,
-      );
-      return;
-    }
+  log("Fragment index uploaded", response);
+  if (response.ok) {
+    return response.json();
   }
+
+  throw new Error(
+    `Failed to create fragment index ${response.status} ${response.statusText}`,
+  );
 };

package/src/resources/isobmff-track.test.ts

@@ -0,0 +1,152 @@
+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 { createISOBMFFTrack, uploadISOBMFFTrack } from "./isobmff-track.ts";
+import { readableFromBuffers } from "../readableFromBuffers.ts";
+
+const server = setupServer();
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+describe("ISOBMFF Track", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  describe("createISOBMFFTrack", () => {
+    test("Throws when track is too large", async () => {
+      await expect(
+        createISOBMFFTrack(
+          client,
+          createTestTrack({ 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/video2/isobmff_tracks", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        createISOBMFFTrack(client, createTestTrack()),
+      ).rejects.toThrowError(
+        "Failed to create isobmff track 500 Internal Server Error",
+      );
+    });
+
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/isobmff_tracks", () =>
+          HttpResponse.json(
+            { testResponse: "test" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await createISOBMFFTrack(
+        client,
+        createTestTrack({ byte_size: 1024 * 1024 * 5 }),
+      );
+
+      expect(response).toEqual({ testResponse: "test" });
+    });
+  });
+
+  describe("uploadISOBMFFTrack", () => {
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/video2/isobmff_tracks/test-file/1/upload",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        uploadISOBMFFTrack(
+          client,
+          "test-file",
+          1,
+          readableFromBuffers(Buffer.from("test")),
+          4,
+        ),
+      ).rejects.toThrowError(
+        "Failed to upload chunk 0 for /api/video2/isobmff_tracks/test-file/1/upload 500 Internal Server Error",
+      );
+    });
+
+    test("Succeeds when server returns a success", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/video2/isobmff_tracks/test-file/1/upload",
+          () => HttpResponse.json({}, { status: 201 }),
+        ),
+      );
+
+      await expect(
+        uploadISOBMFFTrack(
+          client,
+          "test-file",
+          1,
+          readableFromBuffers(Buffer.from("test")),
+          4,
+        ),
+      ).resolves.toBeUndefined();
+    });
+  });
+});
+
+function createTestTrack(
+  options: Partial<Parameters<typeof createISOBMFFTrack>[1]> = {},
+) {
+  return Object.assign(
+    {
+      file_id: "test-id",
+      track_id: 1,
+      type: "audio",
+      probe_info: {
+        channels: 2,
+        sample_rate: "44100",
+        duration: 1000,
+        duration_ts: 1000,
+        start_time: 0,
+        start_pts: 0,
+        r_frame_rate: "100",
+        channel_layout: "stereo",
+        codec_tag_string: "mp3",
+        codec_long_name: "MP3",
+        codec_type: "audio",
+        codec_tag: "0x0000",
+        codec_name: "aac",
+        bits_per_sample: 16,
+        index: 0,
+        sample_fmt: "s16",
+        time_base: "100",
+        avg_frame_rate: "100",
+        disposition: {},
+        bit_rate: "100",
+      },
+      duration_ms: 1000,
+      codec_name: "mp3",
+      byte_size: 1024 * 1024 * 5,
+    } as const,
+    options,
+  );
+}

package/src/resources/isobmff-track.ts

@@ -5,10 +5,13 @@ import debug from "debug";
 
 import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
 
-import type { Client } from "../client";
+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

@@ -3,9 +3,10 @@ import type { Readable } from "node:stream";
 import { z } from "zod";
 import debug from "debug";
 
-import type { Client } from "../client";
+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