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

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