@editframe/api 0.7.0-beta.8 → 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

@@ -0,0 +1,189 @@
+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";
+
+import { md5FilePath, md5Buffer } from "@editframe/assets";
+
+import type { Client } from "../client.ts";
+import { uploadChunks } from "../uploadChunks.ts";
+
+const log = debug("ef:api:unprocessed-file");
+
+const FileProcessors = z
+  .array(z.union([z.literal("isobmff"), z.literal("captions")]))
+  .refine(
+    (value) => {
+      return new Set(value).size === value.length;
+    },
+    {
+      message: "Processors list must not include duplicates",
+    },
+  );
+
+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({
+  processes: FileProcessors.optional(),
+});
+
+export interface CreateUnprocessedFileResult {
+  byte_size: number;
+  next_byte: number;
+  id: string;
+  processes: z.infer<typeof FileProcessors>;
+}
+
+export interface UpdateUnprocessedFileResult {
+  byte_size?: number;
+  next_byte: number;
+  id: string;
+  processes: z.infer<typeof FileProcessors>;
+}
+
+export const createUnprocessedFile = async (
+  client: Client,
+  payload: z.infer<typeof CreateUnprocessedFilePayload>,
+) => {
+  log("Creating an unprocessed file", payload);
+  CreateUnprocessedFilePayload.parse(payload);
+  const response = await client.authenticatedFetch(
+    "/api/v1/unprocessed_files",
+    {
+      method: "POST",
+      body: JSON.stringify(payload),
+    },
+  );
+
+  log(
+    "Unprocessed file created",
+    response.status,
+    response.statusText,
+    response.headers,
+  );
+
+  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 (
+  client: Client,
+  fileId: string,
+  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}`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload),
+    },
+  );
+
+  log("Unprocessed file updated", response);
+
+  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);
+
+  await uploadChunks(client, {
+    url: `/api/v1/unprocessed_files/${fileId}/upload`,
+    fileSize,
+    fileStream,
+  });
+
+  log("Unprocessed file upload complete");
+};
+
+export const processAVFileBuffer = async (
+  client: Client,
+  buffer: Buffer,
+  filename = "buffer",
+) => {
+  log("Processing AV file buffer");
+  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({
+    read() {
+      readStream.push(buffer);
+      readStream.push(null);
+    },
+  });
+
+  await uploadUnprocessedFile(client, fileId, readStream, buffer.byteLength);
+
+  const fileInformation = await updateUnprocessedFile(client, fileId, {
+    processes: ["isobmff"],
+  });
+
+  log("File processed", fileInformation);
+  return fileInformation;
+};
+
+export const processAVFile = async (client: Client, filePath: string) => {
+  log("Processing AV file", filePath);
+  const fileId = await md5FilePath(filePath);
+
+  log("File ID", fileId);
+  await createUnprocessedFile(client, {
+    id: fileId,
+    processes: [],
+    filename: basename(filePath),
+    byte_size: (await stat(filePath)).size,
+  });
+
+  const readStream = createReadStream(filePath);
+
+  await uploadUnprocessedFile(
+    client,
+    fileId,
+    readStream,
+    (await stat(filePath)).size,
+  );
+
+  const fileInformation = await updateUnprocessedFile(client, fileId, {
+    processes: ["isobmff"],
+  });
+
+  log("File processed", fileInformation);
+  return fileInformation;
+};

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/url-token.ts

@@ -0,0 +1,27 @@
+import debug from "debug";
+
+import type { Client } from "../client.ts";
+
+const log = debug("ef:api:url-token");
+
+export interface URLTokenResult {
+  token: string;
+}
+
+export const createURLToken = async (client: Client, url: string) => {
+  log("Creating signed url for", url);
+  const response = await client.authenticatedFetch("/api/v1/url-token", {
+    method: "POST",
+    body: JSON.stringify({
+      url,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to create signed url: ${response.status} ${response.statusText} ${await response.text()}`,
+    );
+  }
+
+  return ((await response.json()) as URLTokenResult).token;
+};

package/dist/client.cjs

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const debug = require("debug");
-const fetch = require("node-fetch");
-const log = debug("ef:api:client");
-class Client {
-  constructor(token, efHost) {
-    this.token = token;
-    this.efHost = efHost;
-    this.authenticatedFetch = async (path, init = {}) => {
-      init.headers ||= {};
-      log(
-        "Authenticated fetch",
-        { path, init },
-        "(Token will be added as Bearer token)"
-      );
-      Object.assign(init.headers, {
-        Authorization: `Bearer ${this.token}`,
-        "Content-Type": "application/json"
-      });
-      const url = new URL(path, this.efHost);
-      const response = await fetch(url, init);
-      log("Authenticated fetch response", response.status, response.statusText);
-      return response;
-    };
-    log("Creating client with efHost", efHost, "and !!token", !!token);
-  }
-}
-exports.Client = Client;

package/dist/index.cjs

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const captionFile = require("./resources/caption-file.cjs");
-const imageFile = require("./resources/image-file.cjs");
-const isobmffFile = require("./resources/isobmff-file.cjs");
-const isobmffTrack = require("./resources/isobmff-track.cjs");
-const renders = require("./resources/renders.cjs");
-const client = require("./client.cjs");
-exports.CreateCaptionFilePayload = captionFile.CreateCaptionFilePayload;
-exports.createCaptionFile = captionFile.createCaptionFile;
-exports.uploadCaptionFile = captionFile.uploadCaptionFile;
-exports.CreateImageFilePayload = imageFile.CreateImageFilePayload;
-exports.createImageFile = imageFile.createImageFile;
-exports.uploadImageFile = imageFile.uploadImageFile;
-exports.CreateISOBMFFFilePayload = isobmffFile.CreateISOBMFFFilePayload;
-exports.createISOBMFFFile = isobmffFile.createISOBMFFFile;
-exports.uploadFragmentIndex = isobmffFile.uploadFragmentIndex;
-exports.CreateISOBMFFTrackPayload = isobmffTrack.CreateISOBMFFTrackPayload;
-exports.createISOBMFFTrack = isobmffTrack.createISOBMFFTrack;
-exports.uploadISOBMFFTrack = isobmffTrack.uploadISOBMFFTrack;
-exports.CreateRenderPayload = renders.CreateRenderPayload;
-exports.createRender = renders.createRender;
-exports.uploadRender = renders.uploadRender;
-exports.Client = client.Client;

package/dist/resources/caption-file.cjs

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const zod = require("zod");
-const debug = require("debug");
-const log = debug("ef:api:caption-file");
-const CreateCaptionFilePayload = zod.z.object({
-  id: zod.z.string(),
-  filename: zod.z.string()
-});
-const createCaptionFile = async (client, payload) => {
-  log("Creating caption file", payload);
-  const fileCreation = await client.authenticatedFetch(
-    "/api/video2/caption_files",
-    {
-      method: "POST",
-      body: JSON.stringify(payload)
-    }
-  );
-  log("Caption file created", fileCreation);
-  switch (fileCreation.status) {
-    case 200: {
-      return await fileCreation.json();
-    }
-    default: {
-      console.error(
-        `Failed to create file ${fileCreation.status} ${fileCreation.statusText}`
-      );
-      return;
-    }
-  }
-};
-const uploadCaptionFile = async (client, fileId, fileStream) => {
-  log("Uploading caption file", fileId);
-  const fileIndex = 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;
-    }
-  }
-};
-exports.CreateCaptionFilePayload = CreateCaptionFilePayload;
-exports.createCaptionFile = createCaptionFile;
-exports.uploadCaptionFile = uploadCaptionFile;