@editframe/api 0.7.0-beta.8 → 0.8.0-beta.10

package/dist/resources/isobmff-track.d.ts

@@ -0,0 +1,270 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    file_id: z.ZodString;
+    track_id: z.ZodNumber;
+    type: z.ZodLiteral<"audio">;
+    probe_info: z.ZodObject<{
+        index: z.ZodNumber;
+        codec_name: z.ZodString;
+        codec_long_name: z.ZodString;
+        codec_type: z.ZodLiteral<"audio">;
+        codec_tag_string: z.ZodString;
+        codec_tag: z.ZodString;
+        sample_fmt: z.ZodString;
+        sample_rate: z.ZodString;
+        channels: z.ZodNumber;
+        channel_layout: z.ZodString;
+        bits_per_sample: z.ZodNumber;
+        initial_padding: z.ZodOptional<z.ZodNumber>;
+        r_frame_rate: z.ZodString;
+        avg_frame_rate: z.ZodString;
+        time_base: z.ZodString;
+        start_pts: z.ZodNumber;
+        start_time: z.ZodNumber;
+        duration_ts: z.ZodNumber;
+        duration: z.ZodNumber;
+        bit_rate: z.ZodString;
+        disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    }, {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    }>;
+    duration_ms: z.ZodNumber;
+    codec_name: z.ZodString;
+    byte_size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    byte_size: number;
+    type: "audio";
+    codec_name: string;
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    };
+    duration_ms: number;
+}, {
+    byte_size: number;
+    type: "audio";
+    codec_name: string;
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    };
+    duration_ms: number;
+}>, z.ZodObject<{
+    file_id: z.ZodString;
+    track_id: z.ZodNumber;
+    type: z.ZodLiteral<"video">;
+    probe_info: z.ZodObject<{
+        index: z.ZodNumber;
+        codec_name: z.ZodString;
+        codec_long_name: z.ZodString;
+        codec_type: z.ZodLiteral<"video">;
+        codec_tag_string: z.ZodString;
+        codec_tag: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        coded_width: z.ZodNumber;
+        coded_height: z.ZodNumber;
+        r_frame_rate: z.ZodString;
+        avg_frame_rate: z.ZodString;
+        time_base: z.ZodString;
+        start_pts: z.ZodOptional<z.ZodNumber>;
+        start_time: z.ZodOptional<z.ZodNumber>;
+        duration_ts: z.ZodOptional<z.ZodNumber>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        bit_rate: z.ZodOptional<z.ZodString>;
+        disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        height: number;
+        width: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        coded_width: number;
+        coded_height: number;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    }, {
+        height: number;
+        width: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        coded_width: number;
+        coded_height: number;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    }>;
+    duration_ms: z.ZodNumber;
+    codec_name: z.ZodString;
+    byte_size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    byte_size: number;
+    type: "video";
+    codec_name: string;
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        height: number;
+        width: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        coded_width: number;
+        coded_height: number;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+}, {
+    byte_size: number;
+    type: "video";
+    codec_name: string;
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        height: number;
+        width: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        coded_width: number;
+        coded_height: number;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+}>]>;
+export interface CreateISOBMFFTrackResult {
+    next_byte: number;
+    byte_size: number;
+    track_id: number;
+    file_id: string;
+}
+export declare const createISOBMFFTrack: (client: Client, payload: z.infer<typeof CreateISOBMFFTrackPayload>) => Promise<CreateISOBMFFTrackResult>;
+export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: Readable, trackSize: number) => Promise<void>;

package/dist/resources/isobmff-track.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
 import debug from "debug";
 import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
+import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:isobmff-track");
+const MAX_TRACK_SIZE = 1024 * 1024 * 1024;
 const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
   z.object({
     file_id: z.string(),
@@ -10,7 +12,7 @@ const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
     probe_info: AudioStreamSchema,
     duration_ms: z.number().int(),
     codec_name: z.string(),
-    byte_size: z.number().int()
+    byte_size: z.number().int().max(MAX_TRACK_SIZE)
   }),
   z.object({
     file_id: z.string(),
@@ -19,11 +21,12 @@ const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
     probe_info: VideoStreamSchema,
     duration_ms: z.number().int(),
     codec_name: z.string(),
-    byte_size: z.number().int()
+    byte_size: z.number().int().max(MAX_TRACK_SIZE)
   })
 ]);
 const createISOBMFFTrack = async (client, payload) => {
   log("Creating isobmff track", payload);
+  CreateISOBMFFTrackPayload.parse(payload);
   const response = await client.authenticatedFetch(
     "/api/video2/isobmff_tracks",
     {
@@ -32,37 +35,21 @@ const createISOBMFFTrack = async (client, payload) => {
     }
   );
   log("ISOBMFF track created", response);
-  switch (response.status) {
-    case 200: {
-      return await response.json();
-    }
-    default: {
-      console.error("Failed to create track");
-      console.error(await response.json());
-      return;
-    }
+  if (response.ok) {
+    return await response.json();
   }
-};
-const uploadISOBMFFTrack = async (client, fileId, trackId, fileStream) => {
-  log("Uploading isobmff track", fileId, trackId);
-  const trackIndex = await client.authenticatedFetch(
-    `/api/video2/isobmff_tracks/${fileId}/${trackId}/upload`,
-    {
-      method: "POST",
-      body: fileStream
-    }
+  throw new Error(
+    `Failed to create isobmff track ${response.status} ${response.statusText}`
   );
-  log("ISOBMFF track uploaded", trackIndex);
-  switch (trackIndex.status) {
-    case 200: {
-      return trackIndex.json();
-    }
-    default: {
-      console.error("Failed to upload track");
-      console.error(trackIndex.status, trackIndex.statusText);
-      return;
-    }
-  }
+};
+const uploadISOBMFFTrack = async (client, fileId, trackId, fileStream, trackSize) => {
+  log("Uploading fragment track", fileId);
+  await uploadChunks(client, {
+    url: `/api/video2/isobmff_tracks/${fileId}/${trackId}/upload`,
+    fileStream,
+    fileSize: trackSize
+  });
+  log("Fragment track upload complete");
 };
 export {
   CreateISOBMFFTrackPayload,

package/dist/resources/isobmff-track.test.d.ts

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

package/dist/resources/renders.d.ts

@@ -0,0 +1,34 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+export declare const CreateRenderPayload: z.ZodObject<{
+    id: z.ZodString;
+    fps: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    work_slice_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+    strategy: z.ZodEnum<["v1", "v2"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    height: number;
+    width: number;
+    strategy: "v1" | "v2";
+    duration_ms: number;
+    fps: number;
+    work_slice_ms: number;
+}, {
+    id: string;
+    height: number;
+    width: number;
+    strategy: "v1" | "v2";
+    duration_ms: number;
+    fps: number;
+    work_slice_ms: number;
+}>;
+export interface CreateRenderResult {
+    status: "complete" | "created" | "failed" | "pending" | "rendering";
+    id: string;
+}
+export declare const createRender: (client: Client, payload: z.infer<typeof CreateRenderPayload>) => Promise<CreateRenderResult>;
+export declare const uploadRender: (client: Client, fileId: string, fileStream: Readable, folderSize: number) => Promise<unknown>;

package/dist/resources/renders.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import debug from "debug";
 const log = debug("ef:api:renders");
+const FILE_SIZE_LIMIT = 1024 * 1024 * 16;
 const CreateRenderPayload = z.object({
   id: z.string().uuid(),
   fps: z.number(),
@@ -17,37 +18,32 @@ const createRender = async (client, payload) => {
     body: JSON.stringify(payload)
   });
   log("Render created", response);
-  switch (response.status) {
-    case 200: {
-      return await response.json();
-    }
-    default: {
-      console.error("Failed to create render");
-      console.error(await response.json());
-      return;
-    }
+  if (response.ok) {
+    return await response.json();
   }
+  throw new Error(
+    `Failed to create render ${response.status} ${response.statusText}`
+  );
 };
-const uploadRender = async (client, fileId, fileStream) => {
+const uploadRender = async (client, fileId, fileStream, folderSize) => {
   log("Uploading render", fileId);
-  const fileIndex = await client.authenticatedFetch(
+  log("Folder size", folderSize, "bytes");
+  if (folderSize > FILE_SIZE_LIMIT) {
+    throw new Error(`File size exceeds limit of ${FILE_SIZE_LIMIT} bytes`);
+  }
+  const response = await client.authenticatedFetch(
     `/api/video2/renders/${fileId}/upload`,
     {
       method: "POST",
       body: fileStream
     }
   );
-  log("Render uploaded", fileIndex);
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error("Failed to upload render");
-      console.error(fileIndex.status, fileIndex.statusText);
-      return;
-    }
+  if (response.ok) {
+    return response.json();
   }
+  throw new Error(
+    `Failed to upload render ${response.status} ${response.statusText}`
+  );
 };
 export {
   CreateRenderPayload,

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

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

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

@@ -0,0 +1,45 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+declare const FileProcessors: z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"captions">]>, "many">, ("captions" | "isobmff")[], ("captions" | "isobmff")[]>;
+export declare const CreateUnprocessedFilePayload: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"captions">]>, "many">, ("captions" | "isobmff")[], ("captions" | "isobmff")[]>>;
+    byte_size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+    byte_size: number;
+    processes?: ("captions" | "isobmff")[] | undefined;
+}, {
+    id: string;
+    filename: string;
+    byte_size: number;
+    processes?: ("captions" | "isobmff")[] | undefined;
+}>;
+export declare const UpdateUnprocessedFilePayload: z.ZodObject<{
+    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"captions">]>, "many">, ("captions" | "isobmff")[], ("captions" | "isobmff")[]>>;
+}, "strip", z.ZodTypeAny, {
+    processes?: ("captions" | "isobmff")[] | undefined;
+}, {
+    processes?: ("captions" | "isobmff")[] | undefined;
+}>;
+export interface CreateUnprocessedFileResult {
+    byte_size: number;
+    next_byte: number;
+    id: string;
+    processes: z.infer<typeof FileProcessors>;
+}
+export interface UpdateUnprocessedFileResult {
+    byte_size?: number;
+    next_byte: number;
+    id: string;
+    processes: z.infer<typeof FileProcessors>;
+}
+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) => Promise<void>;
+export declare const processAVFileBuffer: (client: Client, buffer: Buffer, filename?: string) => Promise<UpdateUnprocessedFileResult>;
+export declare const processAVFile: (client: Client, filePath: string) => Promise<UpdateUnprocessedFileResult>;
+export {};

package/dist/resources/unprocessed-file.js

@@ -0,0 +1,133 @@
+import { Readable } from "node:stream";
+import { basename } from "node:path";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { z } from "zod";
+import debug from "debug";
+import { md5Buffer, md5FilePath } from "@editframe/assets";
+import { uploadChunks } from "../uploadChunks.js";
+const log = debug("ef:api:unprocessed-file");
+const FileProcessors = z.array(z.union([z.literal("isobmff"), z.literal("captions")])).refine(
+  (value) => {
+    return new Set(value).size === value.length;
+  },
+  {
+    message: "Processors list must not include duplicates"
+  }
+);
+const MAX_FILE_SIZE = 1024 * 1024 * 1024;
+const CreateUnprocessedFilePayload = z.object({
+  id: z.string(),
+  filename: z.string(),
+  processes: FileProcessors.optional(),
+  byte_size: z.number().int().max(MAX_FILE_SIZE)
+});
+const UpdateUnprocessedFilePayload = z.object({
+  processes: FileProcessors.optional()
+});
+const createUnprocessedFile = async (client, payload) => {
+  log("Creating an unprocessed file", payload);
+  CreateUnprocessedFilePayload.parse(payload);
+  const response = await client.authenticatedFetch(
+    "/api/v1/unprocessed_files",
+    {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }
+  );
+  log(
+    "Unprocessed file created",
+    response.status,
+    response.statusText,
+    response.headers
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to create unprocessed file ${response.status} ${response.statusText}`
+  );
+};
+const updateUnprocessedFile = async (client, fileId, payload) => {
+  log("Updating unprocessed file", fileId, payload);
+  UpdateUnprocessedFilePayload.parse(payload);
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${fileId}`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }
+  );
+  log("Unprocessed file updated", response);
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to update unprocessed file ${response.status} ${response.statusText}`
+  );
+};
+const uploadUnprocessedFile = async (client, fileId, fileStream, fileSize) => {
+  log("Uploading unprocessed file", fileId);
+  await uploadChunks(client, {
+    url: `/api/v1/unprocessed_files/${fileId}/upload`,
+    fileSize,
+    fileStream
+  });
+  log("Unprocessed file upload complete");
+};
+const processAVFileBuffer = async (client, buffer, filename = "buffer") => {
+  log("Processing AV file buffer");
+  const fileId = md5Buffer(buffer);
+  log("File ID", fileId);
+  log(`File size: ${buffer.byteLength} bytes`);
+  await createUnprocessedFile(client, {
+    id: fileId,
+    processes: [],
+    filename,
+    byte_size: buffer.byteLength
+  });
+  const readStream = new Readable({
+    read() {
+      readStream.push(buffer);
+      readStream.push(null);
+    }
+  });
+  await uploadUnprocessedFile(client, fileId, readStream, buffer.byteLength);
+  const fileInformation = await updateUnprocessedFile(client, fileId, {
+    processes: ["isobmff"]
+  });
+  log("File processed", fileInformation);
+  return fileInformation;
+};
+const processAVFile = async (client, filePath) => {
+  log("Processing AV file", filePath);
+  const fileId = await md5FilePath(filePath);
+  log("File ID", fileId);
+  await createUnprocessedFile(client, {
+    id: fileId,
+    processes: [],
+    filename: basename(filePath),
+    byte_size: (await stat(filePath)).size
+  });
+  const readStream = createReadStream(filePath);
+  await uploadUnprocessedFile(
+    client,
+    fileId,
+    readStream,
+    (await stat(filePath)).size
+  );
+  const fileInformation = await updateUnprocessedFile(client, fileId, {
+    processes: ["isobmff"]
+  });
+  log("File processed", fileInformation);
+  return fileInformation;
+};
+export {
+  CreateUnprocessedFilePayload,
+  UpdateUnprocessedFilePayload,
+  createUnprocessedFile,
+  processAVFile,
+  processAVFileBuffer,
+  updateUnprocessedFile,
+  uploadUnprocessedFile
+};

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

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

package/dist/resources/url-token.d.ts

@@ -0,0 +1,5 @@
+import { Client } from '../client.ts';
+export interface URLTokenResult {
+    token: string;
+}
+export declare const createURLToken: (client: Client, url: string) => Promise<string>;

package/dist/resources/url-token.js

@@ -0,0 +1,20 @@
+import debug from "debug";
+const log = debug("ef:api:url-token");
+const createURLToken = async (client, url) => {
+  log("Creating signed url for", url);
+  const response = await client.authenticatedFetch("/api/v1/url-token", {
+    method: "POST",
+    body: JSON.stringify({
+      url
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to create signed url: ${response.status} ${response.statusText} ${await response.text()}`
+    );
+  }
+  return (await response.json()).token;
+};
+export {
+  createURLToken
+};

package/dist/resources/url-token.test.d.ts

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

package/dist/streamChunker.d.ts

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

package/dist/streamChunker.js

@@ -0,0 +1,17 @@
+import { CHUNK_SIZE_BYTES } from "./CHUNK_SIZE_BYTES.js";
+async function* streamChunker(readableStream, chunkSize = CHUNK_SIZE_BYTES) {
+  let buffer = Buffer.alloc(0);
+  for await (const chunk of readableStream) {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (buffer.length >= chunkSize) {
+      yield buffer.slice(0, chunkSize);
+      buffer = buffer.slice(chunkSize);
+    }
+  }
+  if (buffer.length > 0) {
+    yield buffer;
+  }
+}
+export {
+  streamChunker
+};