@editframe/api 0.12.0-beta.2 → 0.12.0-beta.20

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

@@ -2,11 +2,11 @@ import { describe, expect, test } from "vitest";
 import {
   getIsobmffProcessInfo,
   getIsobmffProcessProgress,
-} from "./process-isobmff.ts";
+} from "./process-isobmff.js";
 
-import { useMSW } from "TEST/useMSW.ts";
+import { useMSW } from "TEST/useMSW.js";
 import { http, HttpResponse } from "msw";
-import { Client } from "../client.ts";
+import { Client } from "../client.js";
 
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
 

package/src/resources/process-isobmff.ts

@@ -1,5 +1,5 @@
-import { ProgressIterator } from "../ProgressIterator.ts";
-import type { Client } from "../client.ts";
+import { ProgressIterator } from "../ProgressIterator.js";
+import type { Client } from "../client.js";
 
 export interface IsobmffProcessInfoResult {
   id: string;

package/src/resources/renders.test.ts

@@ -2,9 +2,9 @@ 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 { webReadableFromBuffers } from "../readableFromBuffers.ts";
-import { createRender, lookupRenderByMd5, uploadRender } from "./renders.ts";
+import { Client } from "../client.js";
+import { webReadableFromBuffers } from "../readableFromBuffers.js";
+import { createRender, lookupRenderByMd5, uploadRender } from "./renders.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");

package/src/resources/renders.ts

@@ -1,7 +1,7 @@
 import debug from "debug";
 import { z } from "zod";
 
-import type { Client } from "../client.ts";
+import type { Client } from "../client.js";
 
 const log = debug("ef:api:renders");
 const FILE_SIZE_LIMIT = 1024 * 1024 * 16; // 16MiB
@@ -16,6 +16,7 @@ export const CreateRenderPayload = z.object({
   strategy: z.enum(["v1", "v2"]),
 });
 
+export type CreateRenderPayload = z.infer<typeof CreateRenderPayload>;
 export interface CreateRenderResult {
   id: string;
   md5: string;
@@ -30,7 +31,7 @@ export interface LookupRenderByMd5Result {
 
 export const createRender = async (
   client: Client,
-  payload: z.infer<typeof CreateRenderPayload>,
+  payload: CreateRenderPayload,
 ) => {
   log("Creating render", payload);
   const response = await client.authenticatedFetch("/api/v1/renders", {

package/src/resources/transcriptions.test.ts

@@ -2,8 +2,8 @@ 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";
+import { Client } from "../client.js";
+import { createTranscription } from "./transcriptions.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");

package/src/resources/transcriptions.ts

@@ -1,8 +1,8 @@
 import debug from "debug";
 import { z } from "zod";
 
-import { CompletionIterator } from "../ProgressIterator.ts";
-import type { Client } from "../client.ts";
+import { CompletionIterator } from "../ProgressIterator.js";
+import type { Client } from "../client.js";
 
 const log = debug("ef:api:transcriptions");
 
@@ -11,6 +11,10 @@ export const CreateTranscriptionPayload = z.object({
   track_id: z.number().int(),
 });
 
+export type CreateTranscriptionPayload = z.infer<
+  typeof CreateTranscriptionPayload
+>;
+
 export interface CreateTranscriptionResult {
   id: string;
   status: "complete" | "created" | "failed" | "pending" | "transcribing";
@@ -23,7 +27,7 @@ export interface TranscriptionInfoResult {
 
 export const createTranscription = async (
   client: Client,
-  payload: z.infer<typeof CreateTranscriptionPayload>,
+  payload: CreateTranscriptionPayload,
 ) => {
   log("Creating transcription", payload);
   const response = await client.authenticatedFetch("/api/v1/transcriptions", {

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

@@ -3,13 +3,13 @@ import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 import { ZodError } from "zod";
 
-import { Client } from "../client.ts";
-import { webReadableFromBuffers } from "../readableFromBuffers.ts";
+import { Client } from "../client.js";
+import { webReadableFromBuffers } from "../readableFromBuffers.js";
 import {
   createUnprocessedFile,
   lookupUnprocessedFileByMd5,
-  uploadUnprocessedFile,
-} from "./unprocessed-file.ts";
+  uploadUnprocessedReadableStream,
+} from "./unprocessed-file.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -96,11 +96,10 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        uploadUnprocessedFile(
+        uploadUnprocessedReadableStream(
           client,
-          "test-file",
+          { id: "test-file", byte_size: 4 },
           webReadableFromBuffers(Buffer.from("test")),
-          4,
         ).whenUploaded(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/unprocessed_files/test-file/upload 500 Internal Server Error",
@@ -117,11 +116,10 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        uploadUnprocessedFile(
+        uploadUnprocessedReadableStream(
           client,
-          "test-file",
+          { id: "test-file", byte_size: 4 },
           webReadableFromBuffers(Buffer.from("test")),
-          4,
         ).whenUploaded(),
       ).resolves.toEqual([
         { type: "progress", progress: 0 },

package/src/resources/unprocessed-file.ts

@@ -1,8 +1,8 @@
 import debug from "debug";
 import { z } from "zod";
 
-import type { Client } from "../client.ts";
-import { uploadChunks } from "../uploadChunks.ts";
+import type { Client } from "../client.js";
+import { uploadChunks } from "../uploadChunks.js";
 
 const log = debug("ef:api:unprocessed-file");
 
@@ -16,7 +16,11 @@ export const CreateUnprocessedFilePayload = z.object({
 
 export const UpdateUnprocessedFilePayload = z.object({});
 
-interface UnprocessedFile {
+export type CreateUnprocessedFilePayload = z.infer<
+  typeof CreateUnprocessedFilePayload
+>;
+
+export interface UnprocessedFile {
   byte_size: number;
   next_byte: number;
   complete: boolean;
@@ -24,6 +28,11 @@ interface UnprocessedFile {
   md5: string;
 }
 
+export type UnprocessedFileUploadDetails = Pick<
+  UnprocessedFile,
+  "id" | "byte_size"
+>;
+
 export interface CreateUnprocessedFileResult extends UnprocessedFile {}
 
 export interface LookupUnprocessedFileByMd5Result extends UnprocessedFile {}
@@ -36,7 +45,7 @@ export interface ProcessIsobmffFileResult {
 
 export const createUnprocessedFile = async (
   client: Client,
-  payload: z.infer<typeof CreateUnprocessedFilePayload>,
+  payload: CreateUnprocessedFilePayload,
 ) => {
   log("Creating an unprocessed file", payload);
   CreateUnprocessedFilePayload.parse(payload);
@@ -64,17 +73,16 @@ export const createUnprocessedFile = async (
   );
 };
 
-export const uploadUnprocessedFile = (
+export const uploadUnprocessedReadableStream = (
   client: Client,
-  fileId: string,
+  uploadDetails: UnprocessedFileUploadDetails,
   fileStream: ReadableStream,
-  fileSize: number,
 ) => {
-  log("Uploading unprocessed file", fileId);
+  log("Uploading unprocessed file", uploadDetails.id);
 
   return uploadChunks(client, {
-    url: `/api/v1/unprocessed_files/${fileId}/upload`,
-    fileSize,
+    url: `/api/v1/unprocessed_files/${uploadDetails.id}/upload`,
+    fileSize: uploadDetails.byte_size,
     fileStream,
     maxSize: MAX_FILE_SIZE,
   });
@@ -104,12 +112,9 @@ export const lookupUnprocessedFileByMd5 = async (
   );
 };
 
-export const processIsobmffFile = async (
-  client: Client,
-  unprocessedFileId: LookupUnprocessedFileByMd5Result["id"],
-) => {
+export const processIsobmffFile = async (client: Client, id: string) => {
   const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${unprocessedFileId}/isobmff`,
+    `/api/v1/unprocessed_files/${id}/isobmff`,
     {
       method: "POST",
     },
@@ -120,6 +125,6 @@ export const processIsobmffFile = async (
   }
 
   throw new Error(
-    `Failed to process isobmff file ${response.status} ${response.statusText}`,
+    `Failed to process isobmff file ${id} ${response.status} ${response.statusText}`,
   );
 };

package/src/resources/url-token.test.ts

@@ -1,9 +1,9 @@
-import { afterAll, afterEach, beforeAll, describe, expect, test } 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 { createURLToken } from "./url-token.ts";
+import { Client } from "../client.js";
+import { createURLToken } from "./url-token.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");

package/src/resources/url-token.ts

@@ -1,6 +1,6 @@
 import debug from "debug";
 
-import type { Client } from "../client.ts";
+import type { Client } from "../client.js";
 
 const log = debug("ef:api:url-token");
 

package/src/utils/assertTypesMatch.ts

@@ -0,0 +1,10 @@
+// Type helper that will cause a compilation error
+type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y
+  ? 1
+  : 2
+  ? true
+  : false;
+// Force error with const assertion
+export const assertTypesMatch = <T, U>(
+  value: Equals<T, U> extends true ? true : never,
+) => value;

package/src/utils/createReadableStreamFromReadable.ts

@@ -0,0 +1,117 @@
+import { type Readable, Stream } from "node:stream";
+
+export const createReadableStreamFromReadable = (
+  source: Readable & { readableHighWaterMark?: number },
+) => {
+  const pump = new StreamPump(source);
+  const stream = new ReadableStream(pump, pump);
+  return stream;
+};
+
+class StreamPump {
+  public highWaterMark: number;
+  public accumalatedSize: number;
+  private stream: Stream & {
+    readableHighWaterMark?: number;
+    readable?: boolean;
+    resume?: () => void;
+    pause?: () => void;
+    destroy?: (error?: Error) => void;
+  };
+  private controller?: ReadableStreamController<Uint8Array>;
+
+  constructor(
+    stream: Stream & {
+      readableHighWaterMark?: number;
+      readable?: boolean;
+      resume?: () => void;
+      pause?: () => void;
+      destroy?: (error?: Error) => void;
+    },
+  ) {
+    this.highWaterMark =
+      stream.readableHighWaterMark ||
+      new Stream.Readable().readableHighWaterMark;
+    this.accumalatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+
+  size(chunk: Uint8Array) {
+    return chunk?.byteLength || 0;
+  }
+
+  start(controller: ReadableStreamController<Uint8Array>) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  }
+
+  pull() {
+    this.resume();
+  }
+
+  cancel(reason?: Error) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  }
+
+  enqueue(chunk: Uint8Array | string) {
+    if (this.controller) {
+      try {
+        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+
+        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (error: any) {
+        this.controller.error(
+          new Error(
+            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object",
+          ),
+        );
+        this.cancel();
+      }
+    }
+  }
+
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      // biome-ignore lint/performance/noDelete: infrequent use
+      delete this.controller;
+    }
+  }
+
+  error(error: Error) {
+    if (this.controller) {
+      this.controller.error(error);
+      // biome-ignore lint/performance/noDelete: infrequent use
+      delete this.controller;
+    }
+  }
+}