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

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