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

package/src/resources/caption-file.ts

@@ -7,9 +7,12 @@ import type { Client } from "../client.ts";
 
 const log = debug("ef:api:caption-file");
 
+const MAX_CAPTION_SIZE = 1024 * 1024 * 2; // 2MB
+
 export const CreateCaptionFilePayload = z.object({
   id: z.string(),
   filename: z.string(),
+  byte_size: z.number().int().max(MAX_CAPTION_SIZE),
 });
 
 export interface CreateCaptionFileResult {
@@ -17,56 +20,78 @@ export interface CreateCaptionFileResult {
   id: string;
 }
 
+const restrictSize = (size: number) => {
+  if (size > MAX_CAPTION_SIZE) {
+    throw new Error(
+      `File size ${size} bytes exceeds limit ${MAX_CAPTION_SIZE} bytes\n`,
+    );
+  }
+};
+
+/**
+ * Create a caption file
+ * @param client - The authenticated client to use for the request
+ * @param payload -  The payload to send to the server
+ * @returns The result of the request
+ * @example
+ * ```ts
+ * const result = await createCaptionFile(client, {
+ *  id: "123",
+ * filename: "caption.srt",
+ * });
+ * console.log(result);
+ * ```
+ * @category CaptionFile
+ * @resource
+ * @beta
+ */
 export const createCaptionFile = async (
   client: Client,
   payload: z.infer<typeof CreateCaptionFilePayload>,
 ) => {
   log("Creating caption file", payload);
-  const fileCreation = await client.authenticatedFetch(
+  restrictSize(payload.byte_size);
+  const response = await client.authenticatedFetch(
     "/api/video2/caption_files",
     {
       method: "POST",
       body: JSON.stringify(payload),
     },
   );
-  log("Caption file created", fileCreation);
+  log("Caption file created", response);
 
-  switch (fileCreation.status) {
-    case 200: {
-      return (await fileCreation.json()) as CreateCaptionFileResult;
-    }
-    default: {
-      console.error(
-        `Failed to create file ${fileCreation.status} ${fileCreation.statusText}`,
-      );
-      return;
-    }
+  if (response.ok) {
+    return (await response.json()) as CreateCaptionFileResult;
   }
+
+  throw new Error(
+    `Failed to create caption ${response.status} ${response.statusText}`,
+  );
 };
 
 export const uploadCaptionFile = async (
   client: Client,
   fileId: string,
   fileStream: Readable,
+  fileSize: number,
 ) => {
   log("Uploading caption file", fileId);
-  const fileIndex = await client.authenticatedFetch(
+  restrictSize(fileSize);
+
+  const response = await client.authenticatedFetch(
     `/api/video2/caption_files/${fileId}/upload`,
     {
       method: "POST",
       body: fileStream,
     },
   );
-  log("Caption file uploaded", fileIndex);
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error(
-        `Failed to upload caption ${fileIndex.status} ${fileIndex.statusText}`,
-      );
-      return;
-    }
+  log("Caption file uploaded", response);
+
+  if (response.ok) {
+    return response.json();
   }
+
+  throw new Error(
+    `Failed to upload caption ${response.status} ${response.statusText}`,
+  );
 };

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

@@ -0,0 +1,138 @@
+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 { createImageFile, uploadImageFile } from "./image-file.ts";
+import { readableFromBuffers } from "../readableFromBuffers.ts";
+
+const server = setupServer();
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+describe("ImageFile", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  describe("createImageFile", () => {
+    test("Throws when file is too large", async () => {
+      await expect(
+        createImageFile(client, {
+          id: "test-id",
+          filename: "test",
+          byte_size: 1024 * 1024 * 17,
+          height: 100,
+          width: 100,
+          mime_type: "image/jpeg",
+        }),
+      ).rejects.toThrowError(
+        new ZodError([
+          {
+            code: "too_big",
+            maximum: 16777216,
+            type: "number",
+            inclusive: true,
+            exact: false,
+            message: "Number must be less than or equal to 16777216",
+            path: ["byte_size"],
+          },
+        ]),
+      );
+    });
+
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/image_files", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        createImageFile(client, {
+          id: "test-id",
+          filename: "test",
+          byte_size: 4,
+          height: 100,
+          width: 100,
+          mime_type: "image/jpeg",
+        }),
+      ).rejects.toThrowError("Failed to create file 500 Internal Server Error");
+    });
+
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/video2/image_files", () =>
+          HttpResponse.json(
+            { id: "test-id" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await createImageFile(client, {
+        id: "test-id",
+        filename: "test",
+        byte_size: 4,
+        height: 100,
+        width: 100,
+        mime_type: "image/jpeg",
+      });
+
+      expect(response).toEqual({ id: "test-id" });
+    });
+  });
+
+  describe("uploadImageFile", () => {
+    test("Throws when file is too large", async () => {
+      await expect(
+        uploadImageFile(
+          client,
+          "test-file-id",
+          readableFromBuffers(Buffer.from("test")),
+          1024 * 1024 * 17,
+        ),
+      ).rejects.toThrowError(
+        "File size 17825792 bytes exceeds limit 16777216 bytes",
+      );
+    });
+
+    test("Throws if upload fails", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/video2/image_files/test-file-id/upload",
+          () => HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        uploadImageFile(
+          client,
+          "test-file-id",
+          readableFromBuffers(Buffer.from("test")),
+          4,
+        ),
+      ).rejects.toThrowError(
+        "Failed to upload chunk 0 for /api/video2/image_files/test-file-id/upload 500 Internal Server Error",
+      );
+    });
+
+    test("Uploads file", async () => {
+      server.use(
+        http.post(
+          "http://localhost/api/video2/image_files/test-file-id/upload",
+          () => HttpResponse.json(null, { status: 201 }),
+        ),
+      );
+
+      await expect(
+        uploadImageFile(
+          client,
+          "test-file-id",
+          readableFromBuffers(Buffer.from("test")),
+          4,
+        ),
+      ).resolves.toBeUndefined();
+    });
+  });
+});

package/src/resources/image-file.ts

@@ -4,15 +4,19 @@ import { z } from "zod";
 import debug from "debug";
 
 import type { Client } from "../client.ts";
+import { uploadChunks } from "../uploadChunks.ts";
 
 const log = debug("ef:api:image-file");
 
+const MAX_IMAGE_SIZE = 1024 * 1024 * 16; // 16MB
+
 export const CreateImageFilePayload = z.object({
   id: z.string(),
   height: z.number().int(),
   width: z.number().int(),
   mime_type: z.enum(["image/jpeg", "image/png", "image/jpg", "image/webp"]),
   filename: z.string(),
+  byte_size: z.number().int().max(MAX_IMAGE_SIZE),
 });
 
 export interface CreateImageFileResult {
@@ -25,44 +29,43 @@ export const createImageFile = async (
   payload: z.infer<typeof CreateImageFilePayload>,
 ) => {
   log("Creating image file", payload);
+  CreateImageFilePayload.parse(payload);
   const response = await client.authenticatedFetch("/api/video2/image_files", {
     method: "POST",
     body: JSON.stringify(payload),
   });
 
   log("Image file created", response);
-  switch (response.status) {
-    case 200: {
-      return (await response.json()) as CreateImageFileResult;
-    }
-    default: {
-      console.error(
-        `Failed to create file ${response.status} ${response.statusText}`,
-      );
-      return;
-    }
+
+  if (response.ok) {
+    return (await response.json()) as CreateImageFileResult;
   }
+
+  throw new Error(
+    `Failed to create file ${response.status} ${response.statusText}`,
+  );
 };
 
 export const uploadImageFile = async (
   client: Client,
   fileId: string,
   fileStream: Readable,
+  fileSize: number,
 ) => {
-  const fileIndex = await client.authenticatedFetch(
-    `/api/video2/image_files/${fileId}/upload`,
-    {
-      method: "POST",
-      body: fileStream,
-    },
-  );
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error("Failed to upload image");
-      return;
-    }
+  log("Uploading image file", fileId);
+  if (fileSize > MAX_IMAGE_SIZE) {
+    throw new Error(
+      `File size ${fileSize} bytes exceeds limit ${MAX_IMAGE_SIZE} bytes`,
+    );
   }
+
+  const result = await uploadChunks(client, {
+    url: `/api/video2/image_files/${fileId}/upload`,
+    fileSize,
+    fileStream,
+  });
+
+  log("Image file upload complete");
+
+  return result;
 };

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

@@ -6,6 +6,7 @@ import debug from "debug";
 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,
+  );
+}