@editframe/api 0.8.0-beta.4 → 0.8.0-beta.7

package/dist/CHUNK_SIZE_BYTES.d.ts

@@ -0,0 +1 @@
+export declare let CHUNK_SIZE_BYTES: number;

package/dist/CHUNK_SIZE_BYTES.js

@@ -0,0 +1,7 @@
+let CHUNK_SIZE_BYTES = 8 * 1024 * 1024;
+if (process.env.CHUNK_SIZE_BYTES) {
+  CHUNK_SIZE_BYTES = Number.parseInt(process.env.CHUNK_SIZE_BYTES, 10);
+}
+export {
+  CHUNK_SIZE_BYTES
+};

package/dist/client.d.ts

@@ -1,8 +1,6 @@
 import { RequestInit } from 'node-fetch';
-import * as jwt from "jsonwebtoken";
 export declare class Client {
     #private;
     constructor(token: string, efHost?: string);
     authenticatedFetch: (path: string, init?: RequestInit) => Promise<import('node-fetch').Response>;
-    sign(payload: Record<string, unknown>, expiresIn?: Parameters<typeof jwt.sign>[2]["expiresIn"]): string;
 }

package/dist/client.js

@@ -1,5 +1,4 @@
 import debug from "debug";
-import * as jwt from "jsonwebtoken";
 import fetch from "node-fetch";
 const log = debug("ef:api:client");
 class Client {
@@ -9,7 +8,7 @@ class Client {
       const url = new URL(path, this.#efHost);
       log(
         "Authenticated fetch",
-        { url, init },
+        { url: url.toString(), init },
         "(Token will be added as Bearer token)"
       );
       Object.assign(init.headers, {
@@ -25,22 +24,11 @@ class Client {
     this.#efHost = efHost;
     const { apiKey, apiSecret } = token.match(/^(?<apiSecret>ef_[^_]+)_(?<apiKey>.+)$/)?.groups ?? {};
     if (!apiKey || !apiSecret) {
-      throw new Error("Invalid token format");
+      throw new Error("Invalid token format. Must look like: ef_{}_{}");
     }
-    this.#apiKey = apiKey;
-    this.#apiSecret = apiSecret;
   }
-  #apiKey;
-  #apiSecret;
   #token;
   #efHost;
-  sign(payload, expiresIn = 60) {
-    payload.cid = this.#apiKey;
-    return jwt.sign(payload, this.#apiSecret, {
-      algorithm: "HS256",
-      expiresIn
-    });
-  }
 }
 export {
   Client

package/dist/client.test.d.ts

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

package/dist/readableFromBuffers.d.ts

@@ -0,0 +1,2 @@
+import { Readable } from 'node:stream';
+export declare const readableFromBuffers: (...buffers: Buffer[]) => Readable;

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

@@ -1,20 +1,39 @@
 import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
-
 export declare const CreateCaptionFilePayload: z.ZodObject<{
     id: z.ZodString;
     filename: z.ZodString;
+    byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     id: string;
     filename: string;
+    byte_size: number;
 }, {
     id: string;
     filename: string;
+    byte_size: number;
 }>;
 export interface CreateCaptionFileResult {
     complete: boolean | null;
     id: string;
 }
-export declare const createCaptionFile: (client: Client, payload: z.infer<typeof CreateCaptionFilePayload>) => Promise<CreateCaptionFileResult | undefined>;
-export declare const uploadCaptionFile: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;
+/**
+ * Create a caption file
+ * @param client - The authenticated client to use for the request
+ * @param payload -  The payload to send to the server
+ * @returns The result of the request
+ * @example
+ * ```ts
+ * const result = await createCaptionFile(client, {
+ *  id: "123",
+ * filename: "caption.srt",
+ * });
+ * console.log(result);
+ * ```
+ * @category CaptionFile
+ * @resource
+ * @beta
+ */
+export declare const createCaptionFile: (client: Client, payload: z.infer<typeof CreateCaptionFilePayload>) => Promise<CreateCaptionFileResult>;
+export declare const uploadCaptionFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<unknown>;

package/dist/resources/caption-file.js

@@ -1,53 +1,55 @@
 import { z } from "zod";
 import debug from "debug";
 const log = debug("ef:api:caption-file");
+const MAX_CAPTION_SIZE = 1024 * 1024 * 2;
 const CreateCaptionFilePayload = z.object({
   id: z.string(),
-  filename: z.string()
+  filename: z.string(),
+  byte_size: z.number().int().max(MAX_CAPTION_SIZE)
 });
+const restrictSize = (size) => {
+  if (size > MAX_CAPTION_SIZE) {
+    throw new Error(
+      `File size ${size} bytes exceeds limit ${MAX_CAPTION_SIZE} bytes
+`
+    );
+  }
+};
 const createCaptionFile = async (client, payload) => {
   log("Creating caption file", payload);
-  const fileCreation = await client.authenticatedFetch(
+  restrictSize(payload.byte_size);
+  const response = await client.authenticatedFetch(
     "/api/video2/caption_files",
     {
       method: "POST",
       body: JSON.stringify(payload)
     }
   );
-  log("Caption file created", fileCreation);
-  switch (fileCreation.status) {
-    case 200: {
-      return await fileCreation.json();
-    }
-    default: {
-      console.error(
-        `Failed to create file ${fileCreation.status} ${fileCreation.statusText}`
-      );
-      return;
-    }
+  log("Caption file created", response);
+  if (response.ok) {
+    return await response.json();
   }
+  throw new Error(
+    `Failed to create caption ${response.status} ${response.statusText}`
+  );
 };
-const uploadCaptionFile = async (client, fileId, fileStream) => {
+const uploadCaptionFile = async (client, fileId, fileStream, fileSize) => {
   log("Uploading caption file", fileId);
-  const fileIndex = await client.authenticatedFetch(
+  restrictSize(fileSize);
+  const response = await client.authenticatedFetch(
     `/api/video2/caption_files/${fileId}/upload`,
     {
       method: "POST",
       body: fileStream
     }
   );
-  log("Caption file uploaded", fileIndex);
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error(
-        `Failed to upload caption ${fileIndex.status} ${fileIndex.statusText}`
-      );
-      return;
-    }
+  log("Caption file uploaded", response);
+  if (response.ok) {
+    return response.json();
   }
+  throw new Error(
+    `Failed to upload caption ${response.status} ${response.statusText}`
+  );
 };
 export {
   CreateCaptionFilePayload,

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

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

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

@@ -1,22 +1,24 @@
 import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
-
 export declare const CreateImageFilePayload: z.ZodObject<{
     id: z.ZodString;
     height: z.ZodNumber;
     width: z.ZodNumber;
     mime_type: z.ZodEnum<["image/jpeg", "image/png", "image/jpg", "image/webp"]>;
     filename: z.ZodString;
+    byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     id: string;
     filename: string;
+    byte_size: number;
     height: number;
     width: number;
     mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
 }, {
     id: string;
     filename: string;
+    byte_size: number;
     height: number;
     width: number;
     mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
@@ -25,5 +27,5 @@ export interface CreateImageFileResult {
     complete: boolean | null;
     id: string;
 }
-export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult | undefined>;
-export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;
+export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult>;
+export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<void>;

package/dist/resources/image-file.js

@@ -1,49 +1,45 @@
 import { z } from "zod";
 import debug from "debug";
+import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:image-file");
+const MAX_IMAGE_SIZE = 1024 * 1024 * 16;
 const CreateImageFilePayload = z.object({
   id: z.string(),
   height: z.number().int(),
   width: z.number().int(),
   mime_type: z.enum(["image/jpeg", "image/png", "image/jpg", "image/webp"]),
-  filename: z.string()
+  filename: z.string(),
+  byte_size: z.number().int().max(MAX_IMAGE_SIZE)
 });
 const createImageFile = async (client, payload) => {
   log("Creating image file", payload);
+  CreateImageFilePayload.parse(payload);
   const response = await client.authenticatedFetch("/api/video2/image_files", {
     method: "POST",
     body: JSON.stringify(payload)
   });
   log("Image file created", response);
-  switch (response.status) {
-    case 200: {
-      return await response.json();
-    }
-    default: {
-      console.error(
-        `Failed to create file ${response.status} ${response.statusText}`
-      );
-      return;
-    }
+  if (response.ok) {
+    return await response.json();
   }
-};
-const uploadImageFile = async (client, fileId, fileStream) => {
-  const fileIndex = await client.authenticatedFetch(
-    `/api/video2/image_files/${fileId}/upload`,
-    {
-      method: "POST",
-      body: fileStream
-    }
+  throw new Error(
+    `Failed to create file ${response.status} ${response.statusText}`
   );
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error("Failed to upload image");
-      return;
-    }
+};
+const uploadImageFile = async (client, fileId, fileStream, fileSize) => {
+  log("Uploading image file", fileId);
+  if (fileSize > MAX_IMAGE_SIZE) {
+    throw new Error(
+      `File size ${fileSize} bytes exceeds limit ${MAX_IMAGE_SIZE} bytes`
+    );
   }
+  const result = await uploadChunks(client, {
+    url: `/api/video2/image_files/${fileId}/upload`,
+    fileSize,
+    fileStream
+  });
+  log("Image file upload complete");
+  return result;
 };
 export {
   CreateImageFilePayload,

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

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

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

@@ -1,7 +1,6 @@
 import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
-
 export declare const CreateISOBMFFFilePayload: z.ZodObject<{
     id: z.ZodString;
     filename: z.ZodString;
@@ -16,5 +15,5 @@ export interface CreateISOBMFFFileResult {
     fragment_index_complete: boolean;
     id: string;
 }
-export declare const createISOBMFFFile: (client: Client, payload: z.infer<typeof CreateISOBMFFFilePayload>) => Promise<CreateISOBMFFFileResult | undefined>;
-export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;
+export declare const createISOBMFFFile: (client: Client, payload: z.infer<typeof CreateISOBMFFFilePayload>) => Promise<CreateISOBMFFFileResult>;
+export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<unknown>;

package/dist/resources/isobmff-file.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import debug from "debug";
 const log = debug("ef:api:isobmff-file");
+const FILE_SIZE_LIMIT = 1024 * 1024 * 2;
 const CreateISOBMFFFilePayload = z.object({
   id: z.string(),
   filename: z.string()
@@ -15,39 +16,32 @@ const createISOBMFFFile = async (client, payload) => {
     }
   );
   log("ISOBMFF file created", response);
-  switch (response.status) {
-    case 200: {
-      return await response.json();
-    }
-    default: {
-      console.error(
-        `Failed to create file ${response.status} ${response.statusText}`
-      );
-      return;
-    }
+  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) => {
+const uploadFragmentIndex = async (client, fileId, fileStream, fileSize) => {
   log("Uploading fragment index", fileId);
-  const fileIndex = await client.authenticatedFetch(
+  if (fileSize > FILE_SIZE_LIMIT) {
+    throw new Error(`File size exceeds limit of ${FILE_SIZE_LIMIT} bytes`);
+  }
+  const response = await client.authenticatedFetch(
     `/api/video2/isobmff_files/${fileId}/index/upload`,
     {
       method: "POST",
       body: fileStream
     }
   );
-  log("Fragment index uploaded", fileIndex);
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error(
-        `Failed to create fragment index ${fileIndex.status} ${fileIndex.statusText}`
-      );
-      return;
-    }
+  log("Fragment index uploaded", response);
+  if (response.ok) {
+    return response.json();
   }
+  throw new Error(
+    `Failed to create fragment index ${response.status} ${response.statusText}`
+  );
 };
 export {
   CreateISOBMFFFilePayload,

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

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

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

@@ -1,7 +1,6 @@
 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;
@@ -29,7 +28,6 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         bit_rate: z.ZodString;
         disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -47,11 +45,11 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         start_pts: number;
         start_time: number;
         duration_ts: number;
+        duration: number;
         bit_rate: string;
         disposition: Record<string, unknown>;
         initial_padding?: number | undefined;
     }, {
-        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -69,6 +67,7 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         start_pts: number;
         start_time: number;
         duration_ts: number;
+        duration: number;
         bit_rate: string;
         disposition: Record<string, unknown>;
         initial_padding?: number | undefined;
@@ -77,11 +76,12 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     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: {
-        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -99,19 +99,19 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         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;
-    codec_name: string;
-    byte_size: number;
 }, {
+    byte_size: number;
     type: "audio";
+    codec_name: string;
     file_id: string;
     track_id: number;
     probe_info: {
-        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -129,13 +129,12 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         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;
-    codec_name: string;
-    byte_size: number;
 }>, z.ZodObject<{
     file_id: z.ZodString;
     track_id: z.ZodNumber;
@@ -161,6 +160,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         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;
@@ -171,16 +172,16 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
-        width: number;
-        height: number;
         coded_width: number;
         coded_height: number;
-        duration?: number | undefined;
         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;
@@ -191,24 +192,26 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
-        width: number;
-        height: number;
         coded_width: number;
         coded_height: number;
-        duration?: number | undefined;
         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;
@@ -219,24 +222,24 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
-        width: number;
-        height: number;
         coded_width: number;
         coded_height: number;
-        duration?: number | undefined;
         start_pts?: number | undefined;
         start_time?: number | undefined;
         duration_ts?: number | undefined;
+        duration?: number | undefined;
         bit_rate?: string | undefined;
     };
     duration_ms: number;
-    codec_name: string;
-    byte_size: 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;
@@ -247,25 +250,21 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
-        width: number;
-        height: number;
         coded_width: number;
         coded_height: number;
-        duration?: number | undefined;
         start_pts?: number | undefined;
         start_time?: number | undefined;
         duration_ts?: number | undefined;
+        duration?: number | undefined;
         bit_rate?: string | undefined;
     };
     duration_ms: number;
-    codec_name: string;
-    byte_size: number;
 }>]>;
 export interface CreateISOBMFFTrackResult {
-    last_received_byte: number;
+    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 | undefined>;
-export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: Readable) => Promise<unknown>;
+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,