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

package/dist/streamChunker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/uploadChunks.d.ts

@@ -0,0 +1,10 @@
+import { Readable } from 'node:stream';
+import { Client } from './client.ts';
+interface UploadChunksOptions {
+    url: string;
+    fileStream: Readable;
+    fileSize: number;
+    chunkSizeBytes?: number;
+}
+export declare function uploadChunks(client: Client, { url, fileSize, fileStream, chunkSizeBytes, }: UploadChunksOptions): Promise<void>;
+export {};

package/dist/uploadChunks.js

@@ -0,0 +1,65 @@
+import debug from "debug";
+import { streamChunker } from "./streamChunker.js";
+import { CHUNK_SIZE_BYTES } from "./CHUNK_SIZE_BYTES.js";
+const log = debug("ef:api:uploadChunk");
+const uploadChunk = async (client, {
+  url,
+  chunkBuffer,
+  chunkNumber,
+  fileSize,
+  chunkSizeBytes = CHUNK_SIZE_BYTES
+}) => {
+  const startByte = chunkNumber * chunkSizeBytes;
+  const endByte = startByte + chunkBuffer.length - 1;
+  log(`Uploading chunk ${chunkNumber} for ${url}`);
+  const response = await client.authenticatedFetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Range": `bytes=${startByte}-${endByte}/${fileSize}`,
+      "Content-Type": "application/octet-stream"
+    },
+    body: chunkBuffer
+  });
+  if (response.ok) {
+    if (response.status === 201) {
+      log(`File ${url} fully uploaded`);
+      return { complete: true, body: await response.json() };
+    }
+    if (response.status === 202) {
+      log(`File ${url} chunk ${chunkNumber} uploaded`);
+      return { complete: false, body: await response.json() };
+    }
+  }
+  throw new Error(
+    `Failed to upload chunk ${chunkNumber} for ${url} ${response.status} ${response.statusText}`
+  );
+};
+async function uploadChunks(client, {
+  url,
+  fileSize,
+  fileStream,
+  chunkSizeBytes = CHUNK_SIZE_BYTES
+}) {
+  let chunkNumber = 0;
+  let complete = false;
+  for await (const chunkBuffer of streamChunker(fileStream, chunkSizeBytes)) {
+    log(`Uploading chunk ${chunkNumber}`);
+    ({ complete } = await uploadChunk(client, {
+      url,
+      chunkBuffer,
+      chunkNumber,
+      fileSize,
+      chunkSizeBytes
+    }));
+    chunkNumber++;
+  }
+  if (!fileStream.readableEnded) {
+    throw new Error("Did not read entire file stream");
+  }
+  if (!complete) {
+    throw new Error("Did not complete upload");
+  }
+}
+export {
+  uploadChunks
+};

package/dist/uploadChunks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,16 +1,12 @@
 {
   "name": "@editframe/api",
-  "version": "0.7.0-beta.8",
+  "version": "0.8.0-beta.10",
   "description": "API functions for EditFrame",
   "exports": {
     ".": {
       "import": {
-        "default": "./dist/index.js",
-        "types": "./dist/index.d.ts"
-      },
-      "require": {
-        "default": "./dist/index.cjs",
-        "types": "./dist/index.d.ts"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       }
     }
   },
@@ -23,15 +19,19 @@
   "author": "",
   "license": "UNLICENSED",
   "devDependencies": {
-    "@types/node": "^20.14.9",
-    "typescript": "^5.2.2",
+    "@types/jsonwebtoken": "^9.0.6",
+    "@types/node": "^20.14.13",
+    "typedoc": "^0.26.5",
+    "typescript": "^5.5.4",
     "vite": "^5.2.11",
-    "vite-plugin-dts": "^3.9.1",
+    "vite-plugin-dts": "^4.0.3",
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/assets": "0.7.0-beta.8",
+    "@editframe/assets": "0.8.0-beta.10",
     "debug": "^4.3.5",
+    "jsonwebtoken": "^9.0.2",
+    "node-fetch": "^3.3.2",
     "zod": "^3.23.8"
   }
 }

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

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

package/src/resources/caption-file.ts

@@ -3,13 +3,16 @@ 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: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

@@ -3,16 +3,20 @@ 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";
+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;
 };