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

package/dist/resources/transcriptions.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { CompletionIterator } from '../ProgressIterator.ts';
+import { Client } from '../client.ts';
+export declare const CreateTranscriptionPayload: z.ZodObject<{
+    file_id: z.ZodString;
+    track_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    file_id: string;
+    track_id: number;
+}, {
+    file_id: string;
+    track_id: number;
+}>;
+export interface CreateTranscriptionResult {
+    id: string;
+    status: "complete" | "created" | "failed" | "pending" | "transcribing";
+}
+export interface TranscriptionInfoResult {
+    id: string;
+    status: "complete" | "created" | "failed" | "pending" | "transcribing";
+}
+export declare const createTranscription: (client: Client, payload: z.infer<typeof CreateTranscriptionPayload>) => Promise<CreateTranscriptionResult>;
+export declare const getTranscriptionProgress: (client: Client, id: string) => Promise<CompletionIterator>;
+export declare const getTranscriptionInfo: (client: Client, id: string) => Promise<TranscriptionInfoResult>;

package/dist/resources/transcriptions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/resources/unprocessed-file.d.ts

@@ -1,78 +1,40 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
-import { IteratorWithPromise, UploadChunkEvent } from '../uploadChunks.ts';
-declare const FileProcessors: z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"image">, z.ZodLiteral<"captions">, z.ZodString]>, "many">, string[], string[]>;
 export declare const CreateUnprocessedFilePayload: z.ZodObject<{
     md5: z.ZodString;
     filename: z.ZodString;
-    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"image">, z.ZodLiteral<"captions">, z.ZodString]>, "many">, string[], string[]>>;
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     md5: string;
     filename: string;
     byte_size: number;
-    processes?: string[] | undefined;
 }, {
     md5: string;
     filename: string;
     byte_size: number;
-    processes?: string[] | undefined;
 }>;
-export declare const UpdateUnprocessedFilePayload: z.ZodObject<{
-    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"image">, z.ZodLiteral<"captions">, z.ZodString]>, "many">, string[], string[]>>;
-}, "strip", z.ZodTypeAny, {
-    processes?: string[] | undefined;
-}, {
-    processes?: string[] | undefined;
-}>;
-export interface CreateUnprocessedFileResult {
+export declare const UpdateUnprocessedFilePayload: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+interface UnprocessedFile {
     byte_size: number;
     next_byte: number;
     complete: boolean;
     id: string;
     md5: string;
-    processes: z.infer<typeof FileProcessors> & string[];
-    asset_id: string;
 }
-export interface UpdateUnprocessedFileResult {
-    byte_size?: number;
-    next_byte: number;
-    complete: boolean;
+type UnprocessedFileUploadDetails = Pick<UnprocessedFile, "id" | "byte_size">;
+export interface CreateUnprocessedFileResult extends UnprocessedFile {
+}
+export interface LookupUnprocessedFileByMd5Result extends UnprocessedFile {
+}
+export interface UpdateUnprocessedFileResult extends UnprocessedFile {
+}
+export interface ProcessIsobmffFileResult {
     id: string;
-    md5: string;
-    processes: z.infer<typeof FileProcessors>;
-    asset_id: string;
 }
+export declare const createUnprocessedFileFromPath: (client: Client, path: string) => Promise<CreateUnprocessedFileResult>;
 export declare const createUnprocessedFile: (client: Client, payload: z.infer<typeof CreateUnprocessedFilePayload>) => Promise<CreateUnprocessedFileResult>;
-export declare const updateUnprocessedFile: (client: Client, fileId: string, payload: Partial<z.infer<typeof UpdateUnprocessedFilePayload>>) => Promise<UpdateUnprocessedFileResult>;
-export declare const uploadUnprocessedFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => IteratorWithPromise<UploadChunkEvent>;
-export declare const processAVFileBuffer: (client: Client, buffer: Buffer, filename?: string) => {
-    progress(): AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
-export declare const processAVFile: (client: Client, filePath: string) => {
-    progress: () => Promise<AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
-export declare const processImageFileBuffer: (client: Client, buffer: Buffer, filename?: string) => {
-    progress(): AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
-export declare const processImageFile: (client: Client, filePath: string) => {
-    progress: () => Promise<AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
+export declare const uploadUnprocessedFile: (client: Client, uploadDetails: UnprocessedFileUploadDetails, path: string) => Promise<import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>>;
+export declare const uploadUnprocessedReadableStream: (client: Client, uploadDetails: UnprocessedFileUploadDetails, fileStream: ReadableStream) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const lookupUnprocessedFileByMd5: (client: Client, md5: string) => Promise<LookupUnprocessedFileByMd5Result | null>;
+export declare const processIsobmffFile: (client: Client, id: string) => Promise<ProcessIsobmffFileResult>;
 export {};

package/dist/streamChunker.d.ts

@@ -1,2 +1 @@
-import { Readable } from 'node:stream';
-export declare function streamChunker(readableStream: Readable, chunkSize?: number): AsyncGenerator<Buffer, void, unknown>;
+export declare function streamChunker(readableStream: ReadableStream, chunkSize?: number): AsyncGenerator<Uint8Array, void, unknown>;

package/dist/uploadChunks.d.ts

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { Client } from './client.ts';
 export interface IteratorWithPromise<T> extends AsyncGenerator<T, void, unknown> {
     whenUploaded: () => Promise<T[]>;
@@ -6,7 +5,7 @@ export interface IteratorWithPromise<T> extends AsyncGenerator<T, void, unknown>
 export declare const fakeCompleteUpload: () => IteratorWithPromise<UploadChunkEvent>;
 interface UploadChunksOptions {
     url: string;
-    fileStream: Readable;
+    fileStream: ReadableStream;
     fileSize: number;
     maxSize: number;
     chunkSizeBytes?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/api",
-  "version": "0.11.0-beta.9",
+  "version": "0.12.0-beta.10",
   "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.10",
     "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");
@@ -93,9 +97,8 @@ describe("ImageFile", () => {
       await expect(
         uploadImageFile(
           client,
-          "test-file-id",
-          readableFromBuffers(Buffer.from("test")),
-          1024 * 1024 * 17,
+          { id: "test-file-id", byte_size: 1024 * 1024 * 17 },
+          webReadableFromBuffers(Buffer.from("test")),
         ).whenUploaded(),
       ).rejects.toThrowError(
         "File size 17825792 bytes exceeds limit 16777216 bytes",
@@ -114,9 +117,8 @@ describe("ImageFile", () => {
       await expect(
         uploadImageFile(
           client,
-          "test-file-id",
-          readableFromBuffers(Buffer.from("test")),
-          4,
+          { id: "test-file-id", byte_size: 4 },
+          webReadableFromBuffers(Buffer.from("test")),
         ).whenUploaded(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/image_files/test-file-id/upload 500 Internal Server Error",
@@ -135,9 +137,8 @@ describe("ImageFile", () => {
       await expect(
         uploadImageFile(
           client,
-          "test-file-id",
-          readableFromBuffers(Buffer.from("test")),
-          4,
+          { id: "test-file-id", byte_size: 4 },
+          webReadableFromBuffers(Buffer.from("test")),
         ).whenUploaded(),
       ).resolves.toEqual([
         { type: "progress", progress: 0 },
@@ -145,4 +146,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,6 +1,5 @@
-import type { Readable } from "node:stream";
-
 import debug from "debug";
+import mime from "mime";
 import { z } from "zod";
 
 import type { Client } from "../client.ts";
@@ -21,11 +20,51 @@ export const CreateImageFilePayload = z.object({
 
 export interface CreateImageFileResult {
   complete: boolean | null;
+  byte_size: number;
   id: string;
   md5: string;
-  asset_id: string;
 }
 
+export interface LookupImageFileByMd5Result {
+  complete: boolean | null;
+  byte_size: number;
+  id: string;
+  md5: string;
+}
+
+export const createImageFileFromPath = async (client: Client, path: string) => {
+  const [{ stat }, { basename }, { md5FilePath }] = await Promise.all([
+    import("node:fs/promises"),
+    import("node:path"),
+    import("@editframe/assets"),
+  ]).catch((error) => {
+    console.error("Error importing modules", error);
+    console.error(
+      "This is likely because you are bundling for the browser. createImageFileFromPath can only be run in environments that support importing `node:path`",
+    );
+    throw error;
+  });
+
+  const fileInfo = await stat(path);
+
+  const byte_size = fileInfo.size;
+
+  const md5 = await md5FilePath(path);
+
+  const mime_type = mime.getType(path);
+
+  return createImageFile(client, {
+    ...CreateImageFilePayload.parse({
+      md5,
+      height: 0,
+      width: 0,
+      mime_type,
+      filename: basename(path),
+      byte_size,
+    }),
+  });
+};
+
 export const createImageFile = async (
   client: Client,
   payload: z.infer<typeof CreateImageFilePayload>,
@@ -50,16 +89,43 @@ export const createImageFile = async (
 
 export const uploadImageFile = (
   client: Client,
-  fileId: string,
-  fileStream: Readable,
-  fileSize: number,
+  uploadDetails: {
+    id: string;
+    byte_size: number;
+  },
+  fileStream: ReadableStream,
 ) => {
-  log("Uploading image file", fileId);
+  log("Uploading image file", uploadDetails.id);
 
   return uploadChunks(client, {
-    url: `/api/v1/image_files/${fileId}/upload`,
-    fileSize,
+    url: `/api/v1/image_files/${uploadDetails.id}/upload`,
+    fileSize: uploadDetails.byte_size,
     fileStream,
     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",
+      );
+    });
+  });
 });