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

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

@@ -0,0 +1,6 @@
+import { RequestInit } from 'node-fetch';
+export declare class Client {
+    #private;
+    constructor(token: string, efHost?: string);
+    authenticatedFetch: (path: string, init?: RequestInit) => Promise<import('node-fetch').Response>;
+}

package/dist/client.js

@@ -2,27 +2,33 @@ import debug from "debug";
 import fetch from "node-fetch";
 const log = debug("ef:api:client");
 class Client {
-  constructor(token, efHost) {
-    this.token = token;
-    this.efHost = efHost;
+  constructor(token, efHost = "https://editframe.dev") {
     this.authenticatedFetch = async (path, init = {}) => {
       init.headers ||= {};
+      const url = new URL(path, this.#efHost);
       log(
         "Authenticated fetch",
-        { path, init },
+        { url: url.toString(), init },
         "(Token will be added as Bearer token)"
       );
       Object.assign(init.headers, {
-        Authorization: `Bearer ${this.token}`,
+        Authorization: `Bearer ${this.#token}`,
         "Content-Type": "application/json"
       });
-      const url = new URL(path, this.efHost);
       const response = await fetch(url, init);
       log("Authenticated fetch response", response.status, response.statusText);
       return response;
     };
-    log("Creating client with efHost", efHost, "and !!token", !!token);
+    log("Creating client with efHost", { efHost, tokenIsSet: !!token });
+    this.#token = token;
+    this.#efHost = efHost;
+    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/client.test.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createCaptionFile, CreateCaptionFilePayload, type CreateCaptionFileResult, uploadCaptionFile, } from './resources/caption-file.ts';
+export { createImageFile, CreateImageFilePayload, type CreateImageFileResult, uploadImageFile, } from './resources/image-file.ts';
+export { createISOBMFFFile, CreateISOBMFFFilePayload, type CreateISOBMFFFileResult, uploadFragmentIndex, } from './resources/isobmff-file.ts';
+export { createISOBMFFTrack, CreateISOBMFFTrackPayload, type CreateISOBMFFTrackResult, uploadISOBMFFTrack, } from './resources/isobmff-track.ts';
+export { createRender, CreateRenderPayload, type CreateRenderResult, uploadRender, } from './resources/renders.ts';
+export { createURLToken, type URLTokenResult, } from './resources/url-token.ts';
+export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, updateUnprocessedFile, UpdateUnprocessedFilePayload, type UpdateUnprocessedFileResult, uploadUnprocessedFile, processAVFile, processAVFileBuffer, } from './resources/unprocessed-file.ts';
+export { Client } from './client.ts';

package/dist/index.js

@@ -3,6 +3,8 @@ import { CreateImageFilePayload, createImageFile, uploadImageFile } from "./reso
 import { CreateISOBMFFFilePayload, createISOBMFFFile, uploadFragmentIndex } from "./resources/isobmff-file.js";
 import { CreateISOBMFFTrackPayload, createISOBMFFTrack, uploadISOBMFFTrack } from "./resources/isobmff-track.js";
 import { CreateRenderPayload, createRender, uploadRender } from "./resources/renders.js";
+import { createURLToken } from "./resources/url-token.js";
+import { CreateUnprocessedFilePayload, UpdateUnprocessedFilePayload, createUnprocessedFile, processAVFile, processAVFileBuffer, updateUnprocessedFile, uploadUnprocessedFile } from "./resources/unprocessed-file.js";
 import { Client } from "./client.js";
 export {
   Client,
@@ -11,14 +13,22 @@ export {
   CreateISOBMFFTrackPayload,
   CreateImageFilePayload,
   CreateRenderPayload,
+  CreateUnprocessedFilePayload,
+  UpdateUnprocessedFilePayload,
   createCaptionFile,
   createISOBMFFFile,
   createISOBMFFTrack,
   createImageFile,
   createRender,
+  createURLToken,
+  createUnprocessedFile,
+  processAVFile,
+  processAVFileBuffer,
+  updateUnprocessedFile,
   uploadCaptionFile,
   uploadFragmentIndex,
   uploadISOBMFFTrack,
   uploadImageFile,
-  uploadRender
+  uploadRender,
+  uploadUnprocessedFile
 };

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

@@ -0,0 +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;
+}
+/**
+ * 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

@@ -0,0 +1,31 @@
+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";
+}>;
+export interface CreateImageFileResult {
+    complete: boolean | null;
+    id: string;
+}
+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

@@ -0,0 +1,19 @@
+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;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+}, {
+    id: string;
+    filename: string;
+}>;
+export interface CreateISOBMFFFileResult {
+    fragment_index_complete: boolean;
+    id: string;
+}
+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 {};