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

package/dist/ProgressIterator.d.ts

@@ -0,0 +1,25 @@
+import { CompleteEvent, ProgressEvent, StreamEventSource } from './StreamEventSource.ts';
+declare abstract class BaseEventIterator<T extends CompleteEvent | any> implements AsyncIterable<T> {
+    protected eventSource: StreamEventSource;
+    protected queue: T[];
+    protected index: number;
+    protected isComplete: boolean;
+    protected resolversNext: PromiseWithResolvers<void>;
+    constructor(eventSource: StreamEventSource);
+    whenComplete(): Promise<T[]>;
+    on: (event: "progress", callback: (event: ProgressEvent) => void) => this;
+    protected push(event: T): void;
+    protected get queueLength(): number;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+export declare class ProgressIterator extends BaseEventIterator<ProgressEvent | CompleteEvent> {
+    constructor(eventSource: StreamEventSource);
+    private initializeListeners;
+}
+export declare class CompletionIterator extends BaseEventIterator<CompleteEvent | ProgressEvent> {
+    private totalSize;
+    private currentProgress;
+    constructor(eventSource: StreamEventSource);
+    private initializeListeners;
+}
+export {};

package/dist/ProgressIterator.test.d.ts

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

package/dist/StreamEventSource.d.ts

@@ -0,0 +1,50 @@
+type EventCallback<T> = (event: T) => void;
+export type StreamEventSourceEventMap = {
+    progress: ProgressEvent;
+    complete: CompleteEvent;
+    size: SizeEvent;
+    completion: CompletionEvent;
+    message: {
+        id: string | undefined;
+        data: string;
+    };
+    end: [];
+    error: Error;
+};
+export type ProgressEvent = {
+    type: "progress";
+    data: {
+        progress: number;
+    };
+};
+export type CompleteEvent = {
+    type: "complete";
+    data: object;
+};
+export type SizeEvent = {
+    type: "size";
+    data: {
+        size: number;
+    };
+};
+export type CompletionEvent = {
+    type: "completion";
+    data: {
+        count: number;
+    };
+};
+export declare class StreamEventSource {
+    private stream;
+    private activeReader;
+    private decoder;
+    private parser;
+    private listeners;
+    constructor(stream: ReadableStream);
+    on<K extends keyof StreamEventSourceEventMap>(event: K, callback: EventCallback<StreamEventSourceEventMap[K]>): this;
+    off<K extends keyof StreamEventSourceEventMap>(event: K, callback: EventCallback<StreamEventSourceEventMap[K]>): this;
+    protected emit<K extends keyof StreamEventSourceEventMap>(event: K, data: StreamEventSourceEventMap[K]): void;
+    whenClosed(): Promise<void>;
+    private startReading;
+    close(): void;
+}
+export {};

package/dist/StreamEventSource.test.d.ts

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

package/dist/{CHUNK_SIZE_BYTES.js → api/src/CHUNK_SIZE_BYTES.js}

@@ -1,5 +1,5 @@
 let CHUNK_SIZE_BYTES = 8 * 1024 * 1024;
-if (process.env.CHUNK_SIZE_BYTES) {
+if ("process" in globalThis && process.env.CHUNK_SIZE_BYTES) {
   CHUNK_SIZE_BYTES = Number.parseInt(process.env.CHUNK_SIZE_BYTES, 10);
 }
 export {

package/dist/api/src/ProgressIterator.js

@@ -0,0 +1,99 @@
+class BaseEventIterator {
+  constructor(eventSource) {
+    this.queue = [];
+    this.index = 0;
+    this.isComplete = false;
+    this.resolversNext = Promise.withResolvers();
+    this.eventSource = eventSource;
+  }
+  async whenComplete() {
+    for await (const _ of this) {
+    }
+    return this.queue;
+  }
+  push(event) {
+    this.queue.push(event);
+    this.resolversNext.resolve();
+    this.resolversNext = Promise.withResolvers();
+  }
+  get queueLength() {
+    return this.queue.length - this.index;
+  }
+  async *[Symbol.asyncIterator]() {
+    try {
+      while (!this.isComplete || this.queueLength > 0) {
+        if (this.queueLength === 0) {
+          await this.resolversNext.promise;
+        } else {
+          const item = this.queue[this.index];
+          if (!item) {
+            throw new Error("Queue is corrupted");
+          }
+          yield item;
+          this.index++;
+        }
+      }
+    } finally {
+      this.eventSource.close();
+    }
+  }
+}
+class ProgressIterator extends BaseEventIterator {
+  constructor(eventSource) {
+    super(eventSource);
+    this.initializeListeners();
+  }
+  initializeListeners() {
+    this.eventSource.on("progress", (event) => {
+      this.push(event);
+    });
+    this.eventSource.on("complete", (event) => {
+      this.isComplete = true;
+      this.push(event);
+    });
+    this.eventSource.on("error", (error) => {
+      this.eventSource.close();
+      this.resolversNext.reject(error);
+    });
+  }
+}
+class CompletionIterator extends BaseEventIterator {
+  constructor(eventSource) {
+    super(eventSource);
+    this.totalSize = 0;
+    this.currentProgress = 0;
+    this.initializeListeners();
+  }
+  initializeListeners() {
+    this.eventSource.on("size", (event) => {
+      this.totalSize = event.data.size;
+      this.push({
+        type: "progress",
+        data: {
+          progress: 0
+        }
+      });
+    });
+    this.eventSource.on("completion", (event) => {
+      this.currentProgress += Number(event.data.count);
+      this.push({
+        type: "progress",
+        data: {
+          progress: this.currentProgress / this.totalSize
+        }
+      });
+    });
+    this.eventSource.on("complete", (event) => {
+      this.isComplete = true;
+      this.push(event);
+    });
+    this.eventSource.on("error", (error) => {
+      this.eventSource.close();
+      this.resolversNext.reject(error);
+    });
+  }
+}
+export {
+  CompletionIterator,
+  ProgressIterator
+};

package/dist/api/src/StreamEventSource.js

@@ -0,0 +1,130 @@
+import debug from "debug";
+import { createParser } from "eventsource-parser";
+const log = debug("ef:StreamEventSource");
+class StreamEventSource {
+  constructor(stream) {
+    this.activeReader = null;
+    this.decoder = new TextDecoder();
+    this.listeners = {};
+    if (!stream) {
+      console.error("StreamEventSource: Stream is null or undefined");
+      throw new Error("Stream is required");
+    }
+    this.stream = stream;
+    this.parser = createParser({
+      onError: (err) => {
+        console.error("StreamEventSource: Parser error:", err);
+        this.emit("error", err);
+      },
+      onEvent: (event) => {
+        if (event.event) {
+          switch (event.event) {
+            case "size":
+              this.emit("size", {
+                type: "size",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "completion":
+              this.emit("completion", {
+                type: "completion",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "progress":
+              this.emit("progress", {
+                type: "progress",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "complete":
+              this.emit("complete", {
+                type: "complete",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "error":
+              log("StreamEventSource: Error event", event.data);
+              this.emit("error", new Error(event.data));
+              break;
+            default:
+              this.emit(
+                "error",
+                new Error(`Unknown event: ${event.event} data: ${event.data}`)
+              );
+          }
+        } else {
+          this.emit("message", {
+            id: event.id,
+            data: event.data
+          });
+        }
+      }
+    });
+    this.startReading().catch((error) => {
+      console.error("StreamEventSource: Error in startReading:", error);
+      this.emit("error", error);
+    });
+  }
+  on(event, callback) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event]?.push(callback);
+    return this;
+  }
+  off(event, callback) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      const index = listeners.indexOf(callback);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  emit(event, data) {
+    for (const callback of this.listeners[event] ?? []) {
+      callback(data);
+    }
+  }
+  whenClosed() {
+    return new Promise((resolve) => {
+      this.on("end", () => resolve());
+    });
+  }
+  async startReading() {
+    try {
+      this.activeReader = this.stream.getReader();
+      while (true) {
+        const { done, value } = await this.activeReader.read();
+        if (done) break;
+        const chunk = this.decoder.decode(value);
+        if (!value) {
+          throw new Error("Chunk is null");
+        }
+        this.parser.feed(chunk);
+      }
+      this.activeReader.releaseLock();
+      this.activeReader = null;
+      this.emit("end", []);
+    } catch (error) {
+      console.error("StreamEventSource: Error reading stream:", error);
+      if (error instanceof Error) {
+        this.emit("error", error);
+      } else {
+        this.emit("error", new Error(String(error)));
+      }
+    }
+  }
+  close() {
+    if (this.activeReader) {
+      this.activeReader.releaseLock();
+      this.activeReader = null;
+    }
+    this.parser.reset();
+  }
+}
+export {
+  StreamEventSource
+};

package/dist/api/src/client.js

@@ -0,0 +1,49 @@
+import debug from "debug";
+import { StreamEventSource } from "./StreamEventSource.js";
+const log = debug("ef:api:client");
+class Client {
+  constructor(token, efHost = "https://editframe.dev") {
+    this.authenticatedEventSource = async (path, init = {}) => {
+      const response = await this.authenticatedFetch(path, init);
+      if (response.body === null) {
+        throw new Error("Could not create event source. Response body is null.");
+      }
+      return new StreamEventSource(response.body);
+    };
+    this.authenticatedFetch = async (path, init = {}) => {
+      init.headers ||= {};
+      const url = new URL(path, this.#efHost);
+      log(
+        "Authenticated fetch",
+        { url: url.toString(), init },
+        this.#token ? "(Token will be added as Bearer token)" : "(Using session cookie)"
+      );
+      if (this.#token) {
+        Object.assign(init.headers, {
+          Authorization: `Bearer ${this.#token}`
+        });
+      }
+      Object.assign(init.headers, {
+        "Content-Type": "application/json"
+      });
+      init.credentials = "include";
+      const response = await fetch(url, init);
+      log("Authenticated fetch response", response.status, response.statusText);
+      return response;
+    };
+    log("Creating client with efHost", { efHost, tokenIsSet: !!token });
+    this.#token = token;
+    this.#efHost = efHost;
+    if (token) {
+      const { apiKey, apiSecret } = token.match(/^(?<apiSecret>ef_[^_]+)_(?<apiKey>.+)$/)?.groups ?? {};
+      if (!apiKey || !apiSecret) {
+        throw new Error("Invalid token format. Must look like: ef_{}_{}");
+      }
+    }
+  }
+  #token;
+  #efHost;
+}
+export {
+  Client
+};

package/dist/api/src/index.js

@@ -0,0 +1,49 @@
+import { CreateCaptionFilePayload, createCaptionFile, lookupCaptionFileByMd5, uploadCaptionFile } from "./resources/caption-file.js";
+import { CreateImageFilePayload, createImageFile, lookupImageFileByMd5, uploadImageFile } from "./resources/image-file.js";
+import { CreateISOBMFFFilePayload, TranscribeISOBMFFFilePayload, createISOBMFFFile, getISOBMFFFileTranscription, lookupISOBMFFFileByMd5, transcribeISOBMFFFile, uploadFragmentIndex } from "./resources/isobmff-file.js";
+import { CreateISOBMFFTrackPayload, createISOBMFFTrack, uploadISOBMFFTrack } from "./resources/isobmff-track.js";
+import { CreateRenderPayload, createRender, lookupRenderByMd5, uploadRender } from "./resources/renders.js";
+import { CreateTranscriptionPayload, createTranscription, getTranscriptionInfo, getTranscriptionProgress } from "./resources/transcriptions.js";
+import { createURLToken } from "./resources/url-token.js";
+import { CreateUnprocessedFilePayload, createUnprocessedFile, createUnprocessedFileFromPath, lookupUnprocessedFileByMd5, processIsobmffFile, uploadUnprocessedFile, uploadUnprocessedReadableStream } from "./resources/unprocessed-file.js";
+import { getIsobmffProcessInfo, getIsobmffProcessProgress } from "./resources/process-isobmff.js";
+import { Client } from "./client.js";
+export {
+  Client,
+  CreateCaptionFilePayload,
+  CreateISOBMFFFilePayload,
+  CreateISOBMFFTrackPayload,
+  CreateImageFilePayload,
+  CreateRenderPayload,
+  CreateTranscriptionPayload,
+  CreateUnprocessedFilePayload,
+  TranscribeISOBMFFFilePayload,
+  createCaptionFile,
+  createISOBMFFFile,
+  createISOBMFFTrack,
+  createImageFile,
+  createRender,
+  createTranscription,
+  createURLToken,
+  createUnprocessedFile,
+  createUnprocessedFileFromPath,
+  getISOBMFFFileTranscription,
+  getIsobmffProcessInfo,
+  getIsobmffProcessProgress,
+  getTranscriptionInfo,
+  getTranscriptionProgress,
+  lookupCaptionFileByMd5,
+  lookupISOBMFFFileByMd5,
+  lookupImageFileByMd5,
+  lookupRenderByMd5,
+  lookupUnprocessedFileByMd5,
+  processIsobmffFile,
+  transcribeISOBMFFFile,
+  uploadCaptionFile,
+  uploadFragmentIndex,
+  uploadISOBMFFTrack,
+  uploadImageFile,
+  uploadRender,
+  uploadUnprocessedFile,
+  uploadUnprocessedReadableStream
+};

package/dist/{resources → api/src/resources}/caption-file.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 const log = debug("ef:api:caption-file");
 const MAX_CAPTION_SIZE = 1024 * 1024 * 2;
 const CreateCaptionFilePayload = z.object({
@@ -37,7 +37,8 @@ const uploadCaptionFile = async (client, fileId, fileStream, fileSize) => {
     `/api/v1/caption_files/${fileId}/upload`,
     {
       method: "POST",
-      body: fileStream
+      body: fileStream,
+      duplex: "half"
     }
   );
   log("Caption file uploaded", response);
@@ -48,8 +49,27 @@ const uploadCaptionFile = async (client, fileId, fileStream, fileSize) => {
     `Failed to upload caption ${response.status} ${response.statusText}`
   );
 };
+const lookupCaptionFileByMd5 = async (client, md5) => {
+  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();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup caption by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateCaptionFilePayload,
   createCaptionFile,
+  lookupCaptionFileByMd5,
   uploadCaptionFile
 };

package/dist/{resources → api/src/resources}/image-file.js

@@ -1,4 +1,5 @@
 import debug from "debug";
+import "mime";
 import { z } from "zod";
 import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:image-file");
@@ -26,17 +27,36 @@ const createImageFile = async (client, payload) => {
     `Failed to create file ${response.status} ${response.statusText}`
   );
 };
-const uploadImageFile = (client, fileId, fileStream, fileSize) => {
-  log("Uploading image file", fileId);
+const uploadImageFile = (client, uploadDetails, fileStream) => {
+  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
   });
 };
+const lookupImageFileByMd5 = async (client, md5) => {
+  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();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup image by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateImageFilePayload,
   createImageFile,
+  lookupImageFileByMd5,
   uploadImageFile
 };

package/dist/api/src/resources/isobmff-file.js

@@ -0,0 +1,102 @@
+import debug from "debug";
+import { z } from "zod";
+const log = debug("ef:api:isobmff-file");
+const FILE_SIZE_LIMIT = 1024 * 1024 * 2;
+const CreateISOBMFFFilePayload = z.object({
+  md5: z.string(),
+  filename: z.string()
+});
+const createISOBMFFFile = async (client, payload) => {
+  log("Creating isobmff file", payload);
+  const response = await client.authenticatedFetch("/api/v1/isobmff_files", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+  log("ISOBMFF file created", response);
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to create isobmff file ${response.status} ${response.statusText}`
+  );
+};
+const uploadFragmentIndex = async (client, fileId, fileStream, fileSize) => {
+  log("Uploading fragment index", fileId);
+  if (fileSize > FILE_SIZE_LIMIT) {
+    throw new Error(`File size exceeds limit of ${FILE_SIZE_LIMIT} bytes`);
+  }
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${fileId}/index/upload`,
+    {
+      method: "POST",
+      body: fileStream,
+      duplex: "half"
+    }
+  );
+  log("Fragment index uploaded", response);
+  if (response.ok) {
+    return response.json();
+  }
+  throw new Error(
+    `Failed to create fragment index ${response.status} ${response.statusText}`
+  );
+};
+const lookupISOBMFFFileByMd5 = async (client, md5) => {
+  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();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup isobmff file by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
+const getISOBMFFFileTranscription = async (client, id) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${id}/transcription`
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to get isobmff file transcription ${id} ${response.status} ${response.statusText}`
+  );
+};
+const TranscribeISOBMFFFilePayload = z.object({
+  trackId: z.string().optional()
+});
+const transcribeISOBMFFFile = async (client, id, payload = {}) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${id}/transcribe`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to transcribe isobmff file ${id} ${response.status} ${response.statusText}`
+  );
+};
+export {
+  CreateISOBMFFFilePayload,
+  TranscribeISOBMFFFilePayload,
+  createISOBMFFFile,
+  getISOBMFFFileTranscription,
+  lookupISOBMFFFileByMd5,
+  transcribeISOBMFFFile,
+  uploadFragmentIndex
+};

package/dist/{resources → api/src/resources}/isobmff-track.js

@@ -1,7 +1,50 @@
 import debug from "debug";
 import { z } from "zod";
-import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
 import { uploadChunks } from "../uploadChunks.js";
+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())
+});
+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())
+});
 const log = debug("ef:api:isobmff-track");
 const MAX_TRACK_SIZE = 1024 * 1024 * 1024;
 const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [

package/dist/api/src/resources/process-isobmff.js

@@ -0,0 +1,22 @@
+import { ProgressIterator } from "../ProgressIterator.js";
+const getIsobmffProcessProgress = async (client, id) => {
+  const eventSource = await client.authenticatedEventSource(
+    `/api/v1/process_isobmff/${id}/progress`
+  );
+  return new ProgressIterator(eventSource);
+};
+const getIsobmffProcessInfo = async (client, id) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/process_isobmff/${id}`
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to get isobmff process info ${response.status} ${response.statusText}`
+  );
+};
+export {
+  getIsobmffProcessInfo,
+  getIsobmffProcessProgress
+};