@editframe/api 0.8.0-beta.1 → 0.8.0-beta.10

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",
+      });
+    });
+  });
+});

package/src/resources/unprocessed-file.ts

@@ -1,6 +1,7 @@
 import { Readable } from "node:stream";
 import { basename } from "node:path";
 import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
 
 import { z } from "zod";
 import debug from "debug";
@@ -8,6 +9,7 @@ import debug from "debug";
 import { md5FilePath, md5Buffer } from "@editframe/assets";
 
 import type { Client } from "../client.ts";
+import { uploadChunks } from "../uploadChunks.ts";
 
 const log = debug("ef:api:unprocessed-file");
 
@@ -22,10 +24,13 @@ const FileProcessors = z
     },
   );
 
+const MAX_FILE_SIZE = 1024 * 1024 * 1024; // 1GiB
+
 export const CreateUnprocessedFilePayload = z.object({
   id: z.string(),
   filename: z.string(),
   processes: FileProcessors.optional(),
+  byte_size: z.number().int().max(MAX_FILE_SIZE),
 });
 
 export const UpdateUnprocessedFilePayload = z.object({
@@ -34,14 +39,14 @@ export const UpdateUnprocessedFilePayload = z.object({
 
 export interface CreateUnprocessedFileResult {
   byte_size: number;
-  last_received_byte: number;
+  next_byte: number;
   id: string;
   processes: z.infer<typeof FileProcessors>;
 }
 
 export interface UpdateUnprocessedFileResult {
-  byte_size: number;
-  last_received_byte: number;
+  byte_size?: number;
+  next_byte: number;
   id: string;
   processes: z.infer<typeof FileProcessors>;
 }
@@ -51,6 +56,7 @@ export const createUnprocessedFile = async (
   payload: z.infer<typeof CreateUnprocessedFilePayload>,
 ) => {
   log("Creating an unprocessed file", payload);
+  CreateUnprocessedFilePayload.parse(payload);
   const response = await client.authenticatedFetch(
     "/api/v1/unprocessed_files",
     {
@@ -66,18 +72,13 @@ export const createUnprocessedFile = async (
     response.headers,
   );
 
-  switch (response.status) {
-    case 200: {
-      return (await response.json()) as CreateUnprocessedFileResult;
-    }
-    default: {
-      console.error(
-        `Failed to create file ${response.status} ${response.statusText}`,
-      );
-      console.error(await response.text());
-      throw new Error("Failed to create unprocessed file");
-    }
+  if (response.ok) {
+    return (await response.json()) as CreateUnprocessedFileResult;
   }
+
+  throw new Error(
+    `Failed to create unprocessed file ${response.status} ${response.statusText}`,
+  );
 };
 
 export const updateUnprocessedFile = async (
@@ -86,6 +87,7 @@ export const updateUnprocessedFile = async (
   payload: Partial<z.infer<typeof UpdateUnprocessedFilePayload>>,
 ) => {
   log("Updating unprocessed file", fileId, payload);
+  UpdateUnprocessedFilePayload.parse(payload);
   const response = await client.authenticatedFetch(
     `/api/v1/unprocessed_files/${fileId}`,
     {
@@ -96,44 +98,30 @@ export const updateUnprocessedFile = async (
 
   log("Unprocessed file updated", response);
 
-  switch (response.status) {
-    case 200: {
-      return (await response.json()) as UpdateUnprocessedFileResult;
-    }
-    default: {
-      console.error(
-        `Failed to update file ${response.status} ${response.statusText}`,
-      );
-      throw new Error("Failed to update unprocessed file");
-    }
+  if (response.ok) {
+    return (await response.json()) as UpdateUnprocessedFileResult;
   }
+
+  throw new Error(
+    `Failed to update unprocessed file ${response.status} ${response.statusText}`,
+  );
 };
 
 export const uploadUnprocessedFile = async (
   client: Client,
   fileId: string,
   fileStream: Readable,
+  fileSize: number,
 ) => {
   log("Uploading unprocessed file", fileId);
-  const unprocessedFile = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${fileId}/upload`,
-    {
-      method: "POST",
-      body: fileStream,
-    },
-  );
 
-  log("Unprocessed file track uploaded", unprocessedFile);
-  switch (unprocessedFile.status) {
-    case 200: {
-      return unprocessedFile.json();
-    }
-    default: {
-      console.error("Failed to upload unprocessed file");
-      console.error(unprocessedFile.status, unprocessedFile.statusText);
-      throw new Error("Failed to upload unprocessed file");
-    }
-  }
+  await uploadChunks(client, {
+    url: `/api/v1/unprocessed_files/${fileId}/upload`,
+    fileSize,
+    fileStream,
+  });
+
+  log("Unprocessed file upload complete");
 };
 
 export const processAVFileBuffer = async (
@@ -145,10 +133,13 @@ export const processAVFileBuffer = async (
   const fileId = md5Buffer(buffer);
 
   log("File ID", fileId);
+  log(`File size: ${buffer.byteLength} bytes`);
+
   await createUnprocessedFile(client, {
     id: fileId,
     processes: [],
     filename,
+    byte_size: buffer.byteLength,
   });
 
   const readStream = new Readable({
@@ -158,7 +149,7 @@ export const processAVFileBuffer = async (
     },
   });
 
-  await uploadUnprocessedFile(client, fileId, readStream);
+  await uploadUnprocessedFile(client, fileId, readStream, buffer.byteLength);
 
   const fileInformation = await updateUnprocessedFile(client, fileId, {
     processes: ["isobmff"],
@@ -177,11 +168,17 @@ export const processAVFile = async (client: Client, filePath: string) => {
     id: fileId,
     processes: [],
     filename: basename(filePath),
+    byte_size: (await stat(filePath)).size,
   });
 
   const readStream = createReadStream(filePath);
 
-  await uploadUnprocessedFile(client, fileId, readStream);
+  await uploadUnprocessedFile(
+    client,
+    fileId,
+    readStream,
+    (await stat(filePath)).size,
+  );
 
   const fileInformation = await updateUnprocessedFile(client, fileId, {
     processes: ["isobmff"],

package/src/resources/url-token.test.ts

@@ -0,0 +1,46 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { http, HttpResponse } from "msw";
+import { setupServer } from "msw/node";
+
+import { Client } from "../client.ts";
+import { createURLToken } from "./url-token.ts";
+
+const server = setupServer();
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+describe("URL Token", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  describe("createURLToken", () => {
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/url-token", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        createURLToken(client, "http://example.com"),
+      ).rejects.toThrowError(
+        "Failed to create signed url: 500 Internal Server Error Internal Server Error",
+      );
+    });
+
+    test("Returns token from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/url-token", () =>
+          HttpResponse.json(
+            { token: "test-token" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      await expect(createURLToken(client, "http://example.com")).resolves.toBe(
+        "test-token",
+      );
+    });
+  });
+});

package/src/resources/{signed-url.ts → url-token.ts}

@@ -2,15 +2,15 @@ import debug from "debug";
 
 import type { Client } from "../client.ts";
 
-const log = debug("ef:api:signed-url");
+const log = debug("ef:api:url-token");
 
-export interface SignedURLResult {
-  url: string;
+export interface URLTokenResult {
+  token: string;
 }
 
-export const createSignedURL = async (client: Client, url: string) => {
+export const createURLToken = async (client: Client, url: string) => {
   log("Creating signed url for", url);
-  const response = await client.authenticatedFetch("/api/v1/signed-url", {
+  const response = await client.authenticatedFetch("/api/v1/url-token", {
     method: "POST",
     body: JSON.stringify({
       url,
@@ -23,5 +23,5 @@ export const createSignedURL = async (client: Client, url: string) => {
     );
   }
 
-  return ((await response.json()) as SignedURLResult).url;
+  return ((await response.json()) as URLTokenResult).token;
 };

package/dist/resources/signed-url.d.ts

@@ -1,6 +0,0 @@
-import { Client } from '../client.ts';
-
-export interface SignedURLResult {
-    url: string;
-}
-export declare const createSignedURL: (client: Client, url: string) => Promise<string>;