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

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,81 @@ 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}`,
+  );
+};
+
+export const TranscribeISOBMFFFilePayload = z.object({
+  trackId: z.string().optional(),
+});
+
+export interface TranscribeISOBMFFFileResult {
+  id: string;
+  file_id: string;
+  track_id: number;
+}
+
+export const transcribeISOBMFFFile = async (
+  client: Client,
+  id: string,
+  payload: z.infer<typeof TranscribeISOBMFFFilePayload> = {},
+) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${id}/transcribe`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload),
+    },
+  );
+
+  if (response.ok) {
+    return (await response.json()) as TranscribeISOBMFFFileResult;
+  }
+
+  throw new Error(
+    `Failed to transcribe isobmff file ${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: {} },
+      ]);
+    });
+  });
+});

package/src/resources/process-isobmff.ts

@@ -0,0 +1,33 @@
+import { ProgressIterator } from "../ProgressIterator.ts";
+import type { Client } from "../client.ts";
+
+export interface IsobmffProcessInfoResult {
+  id: string;
+  created_at: string;
+  completed_at: string | null;
+  failed_at: string | null;
+  isobmff_file_id: string | null;
+  unprocessed_file_id: string;
+}
+
+export const getIsobmffProcessProgress = async (client: Client, id: string) => {
+  const eventSource = await client.authenticatedEventSource(
+    `/api/v1/process_isobmff/${id}/progress`,
+  );
+
+  return new ProgressIterator(eventSource);
+};
+
+export const getIsobmffProcessInfo = async (client: Client, id: string) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/process_isobmff/${id}`,
+  );
+
+  if (response.ok) {
+    return (await response.json()) as IsobmffProcessInfoResult;
+  }
+
+  throw new Error(
+    `Failed to get isobmff process info ${response.status} ${response.statusText}`,
+  );
+};

package/src/resources/renders.test.ts

@@ -1,10 +1,10 @@
-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 { readableFromBuffers } from "../readableFromBuffers.ts";
-import { createRender, uploadRender } from "./renders.ts";
+import { webReadableFromBuffers } from "../readableFromBuffers.ts";
+import { createRender, lookupRenderByMd5, uploadRender } from "./renders.ts";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -51,7 +51,7 @@ describe("Renders", () => {
         uploadRender(
           client,
           "test-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           1024 * 1024 * 17,
         ),
       ).rejects.toThrowError(
@@ -70,7 +70,7 @@ describe("Renders", () => {
         uploadRender(
           client,
           "test-id",
-          readableFromBuffers(Buffer.from("test")),
+          webReadableFromBuffers(Buffer.from("test")),
           1024 * 1024 * 2,
         ),
       ).rejects.toThrowError(
@@ -91,13 +91,58 @@ describe("Renders", () => {
       const response = await uploadRender(
         client,
         "test-id",
-        readableFromBuffers(Buffer.from("test")),
+        webReadableFromBuffers(Buffer.from("test")),
         1024 * 1024 * 2,
       );
 
       expect(response).toEqual({ testResponse: "test" });
     });
   });
+
+  describe("lookupRenderByMd5", () => {
+    test("Returns json data from the http response", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/renders/md5/test-md5", () =>
+          HttpResponse.json(
+            { id: "test-id", md5: "test-md5", status: "complete" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await lookupRenderByMd5(client, "test-md5");
+
+      expect(response).toEqual({
+        id: "test-id",
+        md5: "test-md5",
+        status: "complete",
+      });
+    });
+
+    test("Returns null when file is not found", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/renders/md5/test-md5", () =>
+          HttpResponse.json({}, { status: 404 }),
+        ),
+      );
+
+      const response = await lookupRenderByMd5(client, "test-md5");
+
+      expect(response).toBeNull();
+    });
+
+    test("Throws when server returns an error", async () => {
+      server.use(
+        http.get("http://localhost/api/v1/renders/md5/test-md5", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(lookupRenderByMd5(client, "test-md5")).rejects.toThrowError(
+        "Failed to lookup render by md5 test-md5 500 Internal Server Error",
+      );
+    });
+  });
 });
 
 const createTestRender = () =>

package/src/resources/renders.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";
 
@@ -21,7 +19,13 @@ export const CreateRenderPayload = z.object({
 export interface CreateRenderResult {
   id: string;
   md5: string;
-  status: "complete" | "created" | "failed" | "pending" | "rendering";
+  status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
+}
+
+export interface LookupRenderByMd5Result {
+  id: string;
+  md5: string;
+  status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
 }
 
 export const createRender = async (
@@ -47,7 +51,7 @@ export const createRender = async (
 export const uploadRender = async (
   client: Client,
   fileId: string,
-  fileStream: Readable,
+  fileStream: ReadableStream,
   folderSize: number,
 ) => {
   log("Uploading render", fileId);
@@ -60,6 +64,7 @@ export const uploadRender = async (
     {
       method: "POST",
       body: fileStream,
+      duplex: "half",
     },
   );
 
@@ -71,3 +76,27 @@ export const uploadRender = async (
     `Failed to upload render ${response.status} ${response.statusText}`,
   );
 };
+
+export const lookupRenderByMd5 = async (
+  client: Client,
+  md5: string,
+): Promise<LookupRenderByMd5Result | null> => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/renders/md5/${md5}`,
+    {
+      method: "GET",
+    },
+  );
+
+  if (response.ok) {
+    return (await response.json()) as LookupRenderByMd5Result;
+  }
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  throw new Error(
+    `Failed to lookup render by md5 ${md5} ${response.status} ${response.statusText}`,
+  );
+};

package/src/resources/transcriptions.test.ts

@@ -0,0 +1,49 @@
+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 { createTranscription } from "./transcriptions.ts";
+
+const server = setupServer();
+const client = new Client("ef_TEST_TOKEN", "http://localhost");
+
+describe("Transcriptions", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  describe("createTranscription", () => {
+    test("throws if server returns an error", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/transcriptions", () =>
+          HttpResponse.text("Internal Server Error", { status: 500 }),
+        ),
+      );
+
+      await expect(
+        createTranscription(client, { file_id: "test", track_id: 1 }),
+      ).rejects.toThrowError(
+        "Failed to create transcription 500 Internal Server Error",
+      );
+    });
+
+    test("returns json data from the http response", async () => {
+      server.use(
+        http.post("http://localhost/api/v1/transcriptions", () =>
+          HttpResponse.json(
+            { testResponse: "test" },
+            { status: 200, statusText: "OK" },
+          ),
+        ),
+      );
+
+      const response = await createTranscription(client, {
+        file_id: "test",
+        track_id: 1,
+      });
+
+      expect(response).toEqual({ testResponse: "test" });
+    });
+  });
+});

package/src/resources/transcriptions.ts

@@ -0,0 +1,64 @@
+import debug from "debug";
+import { z } from "zod";
+
+import { CompletionIterator } from "../ProgressIterator.ts";
+import type { Client } from "../client.ts";
+
+const log = debug("ef:api:transcriptions");
+
+export const CreateTranscriptionPayload = z.object({
+  file_id: z.string(),
+  track_id: z.number().int(),
+});
+
+export interface CreateTranscriptionResult {
+  id: string;
+  status: "complete" | "created" | "failed" | "pending" | "transcribing";
+}
+
+export interface TranscriptionInfoResult {
+  id: string;
+  status: "complete" | "created" | "failed" | "pending" | "transcribing";
+}
+
+export const createTranscription = async (
+  client: Client,
+  payload: z.infer<typeof CreateTranscriptionPayload>,
+) => {
+  log("Creating transcription", payload);
+  const response = await client.authenticatedFetch("/api/v1/transcriptions", {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+
+  log("Transcription created", response);
+  if (response.ok) {
+    return (await response.json()) as CreateTranscriptionResult;
+  }
+
+  throw new Error(
+    `Failed to create transcription ${response.status} ${response.statusText}`,
+  );
+};
+
+export const getTranscriptionProgress = async (client: Client, id: string) => {
+  const eventSource = await client.authenticatedEventSource(
+    `/api/v1/transcriptions/${id}/progress`,
+  );
+
+  return new CompletionIterator(eventSource);
+};
+
+export const getTranscriptionInfo = async (client: Client, id: string) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/transcriptions/${id}`,
+  );
+
+  if (response.ok) {
+    return (await response.json()) as TranscriptionInfoResult;
+  }
+
+  throw new Error(
+    `Failed to get transcription info ${response.status} ${response.statusText}`,
+  );
+};