@editframe/api 0.11.0-beta.9 → 0.12.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/api",
-  "version": "0.11.0-beta.9",
+  "version": "0.12.0-beta.2",
   "description": "API functions for EditFrame",
   "exports": {
     ".": {
@@ -21,6 +21,7 @@
   "devDependencies": {
     "@types/jsonwebtoken": "^9.0.6",
     "@types/node": "^20.14.13",
+    "eventsource-parser": "^3.0.0",
     "typedoc": "^0.26.5",
     "typescript": "^5.5.4",
     "vite": "^5.2.11",
@@ -28,7 +29,7 @@
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/assets": "0.11.0-beta.9",
+    "@editframe/assets": "0.12.0-beta.2",
     "debug": "^4.3.5",
     "jsonwebtoken": "^9.0.2",
     "node-fetch": "^3.3.2",

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

@@ -1,10 +1,14 @@
-import { test, expect, beforeAll, afterEach, afterAll, describe } from "vitest";
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 
 import { Client } from "../client.ts";
-import { createCaptionFile, uploadCaptionFile } from "./caption-file.ts";
-import { readableFromBuffers } from "../readableFromBuffers.ts";
+import { webReadableFromBuffers } from "../readableFromBuffers.ts";
+import {
+  createCaptionFile,
+  lookupCaptionFileByMd5,
+  uploadCaptionFile,
+} from "./caption-file.ts";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -71,7 +75,7 @@ describe("CaptionFile", () => {
         uploadCaptionFile(
           client,
           "test-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           1024 * 1024 * 3,
         ),
       ).rejects.toThrowError(
@@ -90,7 +94,7 @@ describe("CaptionFile", () => {
         uploadCaptionFile(
           client,
           "test-id",
-          readableFromBuffers(Buffer.from("nice")),
+          webReadableFromBuffers(Buffer.from("nice")),
           4,
         ),
       ).rejects.toThrowError(
@@ -111,11 +115,58 @@ describe("CaptionFile", () => {
       const response = await uploadCaptionFile(
         client,
         "test-id",
-        readableFromBuffers(Buffer.from("nice")),
+        webReadableFromBuffers(Buffer.from("nice")),
         4,
       );
 
       expect(response).toEqual({ id: "test-id" });
     });
   });
+
+  describe("lookupCaptionFileByMd5", () => {
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/caption_files/md5/test-md5", () =>
+          HttpResponse.json(
+            { id: "test-id", md5: "test-md5", complete: true },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await lookupCaptionFileByMd5(client, "test-md5");
+
+      expect(response).toEqual({
+        id: "test-id",
+        md5: "test-md5",
+        complete: true,
+      });
+    });
+
+    test("Returns null when file is not found", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/caption_files/md5/test-md5", () =>
+          HttpResponse.json({}, { status: 404 }),
+        ),
+      );
+
+      const response = await lookupCaptionFileByMd5(client, "test-md5");
+
+      expect(response).toBeNull();
+    });
+
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/caption_files/md5/test-md5", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        lookupCaptionFileByMd5(client, "test-md5"),
+      ).rejects.toThrowError(
+        "Failed to lookup caption by md5 test-md5 500 Internal Server Error",
+      );
+    });
+  });
 });

package/src/resources/caption-file.ts

@@ -1,7 +1,5 @@
-import type { Readable } from "node:stream";
-
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 
 import type { Client } from "../client.ts";
 
@@ -19,7 +17,12 @@ export interface CreateCaptionFileResult {
   complete: boolean | null;
   id: string;
   md5: string;
-  asset_id: string;
+}
+
+export interface LookupCaptionFileByMd5Result {
+  complete: boolean | null;
+  id: string;
+  md5: string;
 }
 
 const restrictSize = (size: number) => {
@@ -71,7 +74,7 @@ export const createCaptionFile = async (
 export const uploadCaptionFile = async (
   client: Client,
   fileId: string,
-  fileStream: Readable,
+  fileStream: ReadableStream,
   fileSize: number,
 ) => {
   log("Uploading caption file", fileId);
@@ -82,6 +85,7 @@ export const uploadCaptionFile = async (
     {
       method: "POST",
       body: fileStream,
+      duplex: "half",
     },
   );
   log("Caption file uploaded", response);
@@ -94,3 +98,28 @@ export const uploadCaptionFile = async (
     `Failed to upload caption ${response.status} ${response.statusText}`,
   );
 };
+
+export const lookupCaptionFileByMd5 = async (
+  client: Client,
+  md5: string,
+): Promise<LookupCaptionFileByMd5Result | null> => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/caption_files/md5/${md5}`,
+    {
+      method: "GET",
+    },
+  );
+  log("Caption file lookup", response);
+
+  if (response.ok) {
+    return (await response.json()) as LookupCaptionFileByMd5Result;
+  }
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  throw new Error(
+    `Failed to lookup caption by md5 ${md5} ${response.status} ${response.statusText}`,
+  );
+};

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

@@ -4,8 +4,12 @@ import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 import { ZodError } from "zod";
 
 import { Client } from "../client.ts";
-import { readableFromBuffers } from "../readableFromBuffers.ts";
-import { createImageFile, uploadImageFile } from "./image-file.ts";
+import { webReadableFromBuffers } from "../readableFromBuffers.ts";
+import {
+  createImageFile,
+  lookupImageFileByMd5,
+  uploadImageFile,
+} from "./image-file.ts";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -94,7 +98,7 @@ describe("ImageFile", () => {
         uploadImageFile(
           client,
           "test-file-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           1024 * 1024 * 17,
         ).whenUploaded(),
       ).rejects.toThrowError(
@@ -115,7 +119,7 @@ describe("ImageFile", () => {
         uploadImageFile(
           client,
           "test-file-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           4,
         ).whenUploaded(),
       ).rejects.toThrowError(
@@ -136,7 +140,7 @@ describe("ImageFile", () => {
         uploadImageFile(
           client,
           "test-file-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           4,
         ).whenUploaded(),
       ).resolves.toEqual([
@@ -145,4 +149,51 @@ describe("ImageFile", () => {
       ]);
     });
   });
+
+  describe("lookupImageFileByMd5", () => {
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/image_files/md5/test-md5", () =>
+          HttpResponse.json(
+            { id: "test-id", md5: "test-md5", complete: true },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await lookupImageFileByMd5(client, "test-md5");
+
+      expect(response).toEqual({
+        id: "test-id",
+        md5: "test-md5",
+        complete: true,
+      });
+    });
+
+    test("Returns null when file is not found", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/image_files/md5/test-md5", () =>
+          HttpResponse.json({}, { status: 404 }),
+        ),
+      );
+
+      const response = await lookupImageFileByMd5(client, "test-md5");
+
+      expect(response).toBeNull();
+    });
+
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/image_files/md5/test-md5", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        lookupImageFileByMd5(client, "test-md5"),
+      ).rejects.toThrowError(
+        "Failed to lookup image by md5 test-md5 500 Internal Server Error",
+      );
+    });
+  });
 });

package/src/resources/image-file.ts

@@ -1,5 +1,3 @@
-import type { Readable } from "node:stream";
-
 import debug from "debug";
 import { z } from "zod";
 
@@ -23,7 +21,12 @@ export interface CreateImageFileResult {
   complete: boolean | null;
   id: string;
   md5: string;
-  asset_id: string;
+}
+
+export interface LookupImageFileByMd5Result {
+  complete: boolean | null;
+  id: string;
+  md5: string;
 }
 
 export const createImageFile = async (
@@ -51,7 +54,7 @@ export const createImageFile = async (
 export const uploadImageFile = (
   client: Client,
   fileId: string,
-  fileStream: Readable,
+  fileStream: ReadableStream,
   fileSize: number,
 ) => {
   log("Uploading image file", fileId);
@@ -63,3 +66,28 @@ export const uploadImageFile = (
     maxSize: MAX_IMAGE_SIZE,
   });
 };
+
+export const lookupImageFileByMd5 = async (
+  client: Client,
+  md5: string,
+): Promise<LookupImageFileByMd5Result | null> => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/image_files/md5/${md5}`,
+    {
+      method: "GET",
+    },
+  );
+  log("Image file lookup", response);
+
+  if (response.ok) {
+    return (await response.json()) as LookupImageFileByMd5Result;
+  }
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  throw new Error(
+    `Failed to lookup image by md5 ${md5} ${response.status} ${response.statusText}`,
+  );
+};

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

@@ -1,10 +1,14 @@
-import { test, expect, beforeAll, afterEach, afterAll, describe } from "vitest";
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 
 import { Client } from "../client.ts";
-import { createISOBMFFFile, uploadFragmentIndex } from "./isobmff-file.ts";
-import { readableFromBuffers } from "../readableFromBuffers.ts";
+import { webReadableFromBuffers } from "../readableFromBuffers.ts";
+import {
+  createISOBMFFFile,
+  lookupISOBMFFFileByMd5,
+  uploadFragmentIndex,
+} from "./isobmff-file.ts";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -57,7 +61,7 @@ describe("ISOBMFFFile", () => {
         uploadFragmentIndex(
           client,
           "test-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           1024 * 1024 * 3,
         ),
       ).rejects.toThrowError("File size exceeds limit of 2097152 bytes");
@@ -75,7 +79,7 @@ describe("ISOBMFFFile", () => {
         uploadFragmentIndex(
           client,
           "test-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           4,
         ),
       ).rejects.toThrowError(
@@ -98,11 +102,58 @@ describe("ISOBMFFFile", () => {
       const response = await uploadFragmentIndex(
         client,
         "test-id",
-        readableFromBuffers(Buffer.from("test")),
+        webReadableFromBuffers(Buffer.from("test")),
         4,
       );
 
       expect(response).toEqual({ fragment_index_complete: true });
     });
   });
+
+  describe("lookupISOBMFFFileByMd5", () => {
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/isobmff_files/md5/test-md5", () =>
+          HttpResponse.json(
+            { id: "test-id", md5: "test-md5", fragment_index_complete: true },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await lookupISOBMFFFileByMd5(client, "test-md5");
+
+      expect(response).toEqual({
+        id: "test-id",
+        md5: "test-md5",
+        fragment_index_complete: true,
+      });
+    });
+
+    test("Returns null when file is not found", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/isobmff_files/md5/test-md5", () =>
+          HttpResponse.json({}, { status: 404 }),
+        ),
+      );
+
+      const response = await lookupISOBMFFFileByMd5(client, "test-md5");
+
+      expect(response).toBeNull();
+    });
+
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/isobmff_files/md5/test-md5", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        lookupISOBMFFFileByMd5(client, "test-md5"),
+      ).rejects.toThrowError(
+        "Failed to lookup isobmff file by md5 test-md5 500 Internal Server Error",
+      );
+    });
+  });
 });

package/src/resources/isobmff-file.ts

@@ -1,7 +1,5 @@
-import type { Readable } from "node:stream";
-
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 
 import type { Client } from "../client.ts";
 
@@ -18,7 +16,21 @@ export interface CreateISOBMFFFileResult {
   filename: string;
   id: string;
   md5: string;
-  asset_id: string;
+}
+
+export interface LookupISOBMFFFileByMd5Result {
+  fragment_index_complete: boolean;
+  filename: string;
+  id: string;
+  md5: string;
+}
+
+export interface GetISOBMFFFileTranscriptionResult {
+  id: string;
+  work_slice_ms: number;
+  isobmff_track: {
+    duration_ms: number;
+  };
 }
 
 export const createISOBMFFFile = async (
@@ -45,7 +57,7 @@ export const createISOBMFFFile = async (
 export const uploadFragmentIndex = async (
   client: Client,
   fileId: string,
-  fileStream: Readable,
+  fileStream: ReadableStream,
   fileSize: number,
 ) => {
   log("Uploading fragment index", fileId);
@@ -57,6 +69,7 @@ export const uploadFragmentIndex = async (
     {
       method: "POST",
       body: fileStream,
+      duplex: "half",
     },
   );
 
@@ -69,3 +82,49 @@ export const uploadFragmentIndex = async (
     `Failed to create fragment index ${response.status} ${response.statusText}`,
   );
 };
+
+export const lookupISOBMFFFileByMd5 = async (
+  client: Client,
+  md5: string,
+): Promise<LookupISOBMFFFileByMd5Result | null> => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/md5/${md5}`,
+    {
+      method: "GET",
+    },
+  );
+  log("ISOBMFF file lookup", response);
+
+  if (response.ok) {
+    return (await response.json()) as LookupISOBMFFFileByMd5Result;
+  }
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  throw new Error(
+    `Failed to lookup isobmff file by md5 ${md5} ${response.status} ${response.statusText}`,
+  );
+};
+
+export const getISOBMFFFileTranscription = async (
+  client: Client,
+  id: string,
+): Promise<GetISOBMFFFileTranscriptionResult | null> => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${id}/transcription`,
+  );
+
+  if (response.ok) {
+    return (await response.json()) as GetISOBMFFFileTranscriptionResult;
+  }
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  throw new Error(
+    `Failed to get isobmff file transcription ${id} ${response.status} ${response.statusText}`,
+  );
+};

package/src/resources/isobmff-track.test.ts

@@ -5,7 +5,7 @@ import { ZodError } from "zod";
 
 import { createTestTrack } from "TEST/createTestTrack.ts";
 import { Client } from "../client.ts";
-import { readableFromBuffers } from "../readableFromBuffers.ts";
+import { webReadableFromBuffers } from "../readableFromBuffers.ts";
 import { createISOBMFFTrack, uploadISOBMFFTrack } from "./isobmff-track.ts";
 
 const server = setupServer();
@@ -92,7 +92,7 @@ describe("ISOBMFF Track", () => {
           client,
           "test-file",
           1,
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           4,
         ).whenUploaded(),
       ).rejects.toThrowError(
@@ -114,7 +114,7 @@ describe("ISOBMFF Track", () => {
           client,
           "test-file",
           1,
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           4,
         ).whenUploaded(),
       ).resolves.toEqual([

package/src/resources/isobmff-track.ts

@@ -1,9 +1,55 @@
-import type { Readable } from "node:stream";
-
 import debug from "debug";
 import { z } from "zod";
 
-import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
+const AudioStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("audio"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  sample_fmt: z.string(),
+  sample_rate: z.string(),
+  channels: z.number(),
+  channel_layout: z.string(),
+  bits_per_sample: z.number(),
+  initial_padding: z.number().optional(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number(),
+  start_time: z.coerce.number(),
+  duration_ts: z.number(),
+  duration: z.coerce.number(),
+  bit_rate: z.string(),
+  disposition: z.record(z.unknown()),
+});
+
+type AudioStreamSchema = z.infer<typeof AudioStreamSchema>;
+
+const VideoStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("video"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  width: z.number(),
+  height: z.number(),
+  coded_width: z.number(),
+  coded_height: z.number(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number().optional(),
+  start_time: z.coerce.number().optional(),
+  duration_ts: z.number().optional(),
+  duration: z.coerce.number().optional(),
+  bit_rate: z.string().optional(),
+  disposition: z.record(z.unknown()),
+});
+
+type VideoStreamSchema = z.infer<typeof VideoStreamSchema>;
 
 import type { Client } from "../client.ts";
 import { uploadChunks } from "../uploadChunks.ts";
@@ -38,7 +84,6 @@ export interface CreateISOBMFFTrackResult {
   byte_size: number;
   track_id: number;
   file_id: string;
-  asset_id: string;
   complete: boolean;
 }
 
@@ -67,7 +112,7 @@ export const uploadISOBMFFTrack = (
   client: Client,
   fileId: string,
   trackId: number,
-  fileStream: Readable,
+  fileStream: ReadableStream,
   trackSize: number,
 ) => {
   log("Uploading fragment track", fileId);

package/src/resources/process-isobmff.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "vitest";
+import {
+  getIsobmffProcessInfo,
+  getIsobmffProcessProgress,
+} from "./process-isobmff.ts";
+
+import { useMSW } from "TEST/useMSW.ts";
+import { http, HttpResponse } from "msw";
+import { Client } from "../client.ts";
+
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+describe("process-isobmff", () => {
+  const server = useMSW();
+  describe("getIsobmffProcessInfo", () => {
+    test("returns the process info", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/process_isobmff/123", async () => {
+          return HttpResponse.json({
+            id: "123",
+            created_at: "2021-01-01T00:00:00.000Z",
+            updated_at: "2021-01-01T00:00:00.000Z",
+          });
+        }),
+      );
+      const info = await getIsobmffProcessInfo(client, "123");
+      expect(info).toEqual({
+        id: "123",
+        created_at: "2021-01-01T00:00:00.000Z",
+        updated_at: "2021-01-01T00:00:00.000Z",
+      });
+    });
+
+    test("throws when the server returns an error", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/process_isobmff/123", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+      await expect(getIsobmffProcessInfo(client, "123")).rejects.toThrow(
+        "Failed to get isobmff process info 500 Internal Server Error",
+      );
+    });
+  });
+
+  describe("getIsobmffProcessProgress", () => {
+    test("returns the progress", async () => {
+      server.use(
+        http.get(
+          "http://localhost/api/v1/process_isobmff/123/progress",
+          async () => {
+            return HttpResponse.text("event: complete\ndata: {}\n\n");
+          },
+        ),
+      );
+      const progress = await getIsobmffProcessProgress(client, "123");
+      await expect(progress.whenComplete()).resolves.toEqual([
+        { type: "complete", data: {} },
+      ]);
+    });
+  });
+});