@editframe/api 0.7.0-beta.10 → 0.7.0-beta.12

package/dist/client.d.ts

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

package/dist/client.js

@@ -7,21 +7,21 @@ class Client {
     this.efHost = efHost;
     this.authenticatedFetch = async (path, init = {}) => {
       init.headers ||= {};
+      const url = new URL(path, this.efHost);
       log(
         "Authenticated fetch",
-        { path, init },
+        { url, init },
         "(Token will be added as Bearer token)"
       );
       Object.assign(init.headers, {
         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 });
   }
 }
 export {

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+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 { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, updateUnprocessedFile, UpdateUnprocessedFilePayload, type UpdateUnprocessedFileResult, uploadUnprocessedFile, } from './resources/unprocessed-file.ts';
+export { Client } from './client.ts';

package/dist/index.js

@@ -3,6 +3,7 @@ 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 { CreateUnprocessedFilePayload, UpdateUnprocessedFilePayload, createUnprocessedFile, updateUnprocessedFile, uploadUnprocessedFile } from "./resources/unprocessed-file.js";
 import { Client } from "./client.js";
 export {
   Client,
@@ -11,14 +12,19 @@ export {
   CreateISOBMFFTrackPayload,
   CreateImageFilePayload,
   CreateRenderPayload,
+  CreateUnprocessedFilePayload,
+  UpdateUnprocessedFilePayload,
   createCaptionFile,
   createISOBMFFFile,
   createISOBMFFTrack,
   createImageFile,
   createRender,
+  createUnprocessedFile,
+  updateUnprocessedFile,
   uploadCaptionFile,
   uploadFragmentIndex,
   uploadISOBMFFTrack,
   uploadImageFile,
-  uploadRender
+  uploadRender,
+  uploadUnprocessedFile
 };

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

@@ -0,0 +1,20 @@
+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;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+}, {
+    id: string;
+    filename: string;
+}>;
+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>;

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

@@ -0,0 +1,29 @@
+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;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+    height: number;
+    width: number;
+    mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
+}, {
+    id: string;
+    filename: string;
+    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 | undefined>;
+export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;

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

@@ -0,0 +1,20 @@
+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 | undefined>;
+export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;

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

@@ -0,0 +1,271 @@
+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, {
+        duration: number;
+        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;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    }, {
+        duration: number;
+        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;
+        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, {
+    type: "audio";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        duration: number;
+        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;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    };
+    duration_ms: number;
+    codec_name: string;
+    byte_size: number;
+}, {
+    type: "audio";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        duration: number;
+        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;
+        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;
+    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, {
+        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>;
+        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;
+        bit_rate?: string | undefined;
+    }, {
+        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>;
+        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;
+        bit_rate?: string | undefined;
+    }>;
+    duration_ms: z.ZodNumber;
+    codec_name: z.ZodString;
+    byte_size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "video";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        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>;
+        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;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+    codec_name: string;
+    byte_size: number;
+}, {
+    type: "video";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        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>;
+        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;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+    codec_name: string;
+    byte_size: number;
+}>]>;
+export interface CreateISOBMFFTrackResult {
+    last_received_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>;

package/dist/resources/renders.d.ts

@@ -0,0 +1,35 @@
+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;
+    duration_ms: number;
+    fps: number;
+    work_slice_ms: number;
+    strategy: "v1" | "v2";
+}, {
+    id: string;
+    height: number;
+    width: number;
+    duration_ms: number;
+    fps: number;
+    work_slice_ms: number;
+    strategy: "v1" | "v2";
+}>;
+export interface CreateRenderResult {
+    status: "complete" | "created" | "failed" | "pending" | "rendering";
+    id: string;
+}
+export declare const createRender: (client: Client, payload: z.infer<typeof CreateRenderPayload>) => Promise<CreateRenderResult | undefined>;
+export declare const uploadRender: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;

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

@@ -0,0 +1,41 @@
+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">, ("isobmff" | "captions")[], ("isobmff" | "captions")[]>;
+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">, ("isobmff" | "captions")[], ("isobmff" | "captions")[]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+    processes?: ("isobmff" | "captions")[] | undefined;
+}, {
+    id: string;
+    filename: string;
+    processes?: ("isobmff" | "captions")[] | undefined;
+}>;
+export declare const UpdateUnprocessedFilePayload: z.ZodObject<{
+    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"captions">]>, "many">, ("isobmff" | "captions")[], ("isobmff" | "captions")[]>>;
+}, "strip", z.ZodTypeAny, {
+    processes?: ("isobmff" | "captions")[] | undefined;
+}, {
+    processes?: ("isobmff" | "captions")[] | undefined;
+}>;
+export interface CreateUnprocessedFileResult {
+    byte_size: number;
+    last_received_byte: number;
+    id: string;
+    processes: z.infer<typeof FileProcessors>;
+}
+export interface UpdateUnprocessedFileResult {
+    byte_size: number;
+    last_received_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) => Promise<unknown>;
+export {};

package/dist/resources/unprocessed-file.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import debug from "debug";
+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 CreateUnprocessedFilePayload = z.object({
+  id: z.string(),
+  filename: z.string(),
+  processes: FileProcessors.optional()
+});
+const UpdateUnprocessedFilePayload = z.object({
+  processes: FileProcessors.optional()
+});
+const createUnprocessedFile = async (client, payload) => {
+  log("Creating an unprocessed file", 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
+  );
+  switch (response.status) {
+    case 200: {
+      return await response.json();
+    }
+    default: {
+      console.error(
+        `Failed to create file ${response.status} ${response.statusText}`
+      );
+      console.error(await response.text());
+      throw new Error("Failed to create unprocessed file");
+    }
+  }
+};
+const updateUnprocessedFile = async (client, fileId, payload) => {
+  log("Updating unprocessed file", fileId, payload);
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${fileId}`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }
+  );
+  log("Unprocessed file updated", response);
+  switch (response.status) {
+    case 200: {
+      return await response.json();
+    }
+    default: {
+      console.error(
+        `Failed to update file ${response.status} ${response.statusText}`
+      );
+      throw new Error("Failed to update unprocessed file");
+    }
+  }
+};
+const uploadUnprocessedFile = async (client, fileId, fileStream) => {
+  log("Uploading unprocessed file", fileId);
+  const unprocessedFile = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${fileId}/upload`,
+    {
+      method: "POST",
+      body: fileStream
+    }
+  );
+  log("Unprocessed file track uploaded", unprocessedFile);
+  switch (unprocessedFile.status) {
+    case 200: {
+      return unprocessedFile.json();
+    }
+    default: {
+      console.error("Failed to upload unprocessed file");
+      console.error(unprocessedFile.status, unprocessedFile.statusText);
+      throw new Error("Failed to upload unprocessed file");
+    }
+  }
+};
+export {
+  CreateUnprocessedFilePayload,
+  UpdateUnprocessedFilePayload,
+  createUnprocessedFile,
+  updateUnprocessedFile,
+  uploadUnprocessedFile
+};

package/package.json

@@ -1,16 +1,12 @@
 {
   "name": "@editframe/api",
-  "version": "0.7.0-beta.10",
+  "version": "0.7.0-beta.12",
   "description": "API functions for EditFrame",
   "exports": {
     ".": {
       "import": {
-        "default": "./dist/index.js",
-        "types": "./dist/index.d.ts"
-      },
-      "require": {
-        "default": "./dist/index.cjs",
-        "types": "./dist/index.d.ts"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       }
     }
   },
@@ -23,14 +19,14 @@
   "author": "",
   "license": "UNLICENSED",
   "devDependencies": {
-    "@types/node": "^20.14.9",
-    "typescript": "^5.2.2",
+    "@types/node": "^20.14.13",
+    "typescript": "^5.5.4",
     "vite": "^5.2.11",
     "vite-plugin-dts": "^3.9.1",
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/assets": "0.7.0-beta.10",
+    "@editframe/assets": "0.7.0-beta.12",
     "debug": "^4.3.5",
     "zod": "^3.23.8"
   }

package/src/resources/caption-file.ts

@@ -3,7 +3,7 @@ import type { Readable } from "node:stream";
 import { z } from "zod";
 import debug from "debug";
 
-import type { Client } from "../client";
+import type { Client } from "../client.ts";
 
 const log = debug("ef:api:caption-file");
 

package/src/resources/image-file.ts

@@ -3,7 +3,7 @@ import type { Readable } from "node:stream";
 import { z } from "zod";
 import debug from "debug";
 
-import type { Client } from "../client";
+import type { Client } from "../client.ts";
 
 const log = debug("ef:api:image-file");
 

package/src/resources/isobmff-file.ts

@@ -3,7 +3,7 @@ import type { Readable } from "node:stream";
 import { z } from "zod";
 import debug from "debug";
 
-import type { Client } from "../client";
+import type { Client } from "../client.ts";
 
 const log = debug("ef:api:isobmff-file");
 

package/src/resources/isobmff-track.ts

@@ -5,7 +5,7 @@ import debug from "debug";
 
 import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
 
-import type { Client } from "../client";
+import type { Client } from "../client.ts";
 
 const log = debug("ef:api:isobmff-track");
 

package/src/resources/renders.ts

@@ -3,7 +3,7 @@ import type { Readable } from "node:stream";
 import { z } from "zod";
 import debug from "debug";
 
-import type { Client } from "../client";
+import type { Client } from "../client.ts";
 
 const log = debug("ef:api:renders");
 

package/src/resources/unprocessed-file.ts

@@ -0,0 +1,133 @@
+import type { Readable } from "node:stream";
+
+import { z } from "zod";
+import debug from "debug";
+
+import type { Client } from "../client.ts";
+
+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",
+    },
+  );
+
+export const CreateUnprocessedFilePayload = z.object({
+  id: z.string(),
+  filename: z.string(),
+  processes: FileProcessors.optional(),
+});
+
+export const UpdateUnprocessedFilePayload = z.object({
+  processes: FileProcessors.optional(),
+});
+
+export interface CreateUnprocessedFileResult {
+  byte_size: number;
+  last_received_byte: number;
+  id: string;
+  processes: z.infer<typeof FileProcessors>;
+}
+
+export interface UpdateUnprocessedFileResult {
+  byte_size: number;
+  last_received_byte: number;
+  id: string;
+  processes: z.infer<typeof FileProcessors>;
+}
+
+export const createUnprocessedFile = async (
+  client: Client,
+  payload: z.infer<typeof CreateUnprocessedFilePayload>,
+) => {
+  log("Creating an unprocessed file", 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,
+  );
+
+  switch (response.status) {
+    case 200: {
+      return (await response.json()) as CreateUnprocessedFileResult;
+    }
+    default: {
+      console.error(
+        `Failed to create file ${response.status} ${response.statusText}`,
+      );
+      console.error(await response.text());
+      throw new Error("Failed to create unprocessed file");
+    }
+  }
+};
+
+export const updateUnprocessedFile = async (
+  client: Client,
+  fileId: string,
+  payload: Partial<z.infer<typeof UpdateUnprocessedFilePayload>>,
+) => {
+  log("Updating unprocessed file", fileId, payload);
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${fileId}`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload),
+    },
+  );
+
+  log("Unprocessed file updated", response);
+
+  switch (response.status) {
+    case 200: {
+      return (await response.json()) as UpdateUnprocessedFileResult;
+    }
+    default: {
+      console.error(
+        `Failed to update file ${response.status} ${response.statusText}`,
+      );
+      throw new Error("Failed to update unprocessed file");
+    }
+  }
+};
+
+export const uploadUnprocessedFile = async (
+  client: Client,
+  fileId: string,
+  fileStream: Readable,
+) => {
+  log("Uploading unprocessed file", fileId);
+  const unprocessedFile = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${fileId}/upload`,
+    {
+      method: "POST",
+      body: fileStream,
+    },
+  );
+
+  log("Unprocessed file track uploaded", unprocessedFile);
+  switch (unprocessedFile.status) {
+    case 200: {
+      return unprocessedFile.json();
+    }
+    default: {
+      console.error("Failed to upload unprocessed file");
+      console.error(unprocessedFile.status, unprocessedFile.statusText);
+      throw new Error("Failed to upload unprocessed file");
+    }
+  }
+};

package/dist/client.cjs

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const debug = require("debug");
-const fetch = require("node-fetch");
-const log = debug("ef:api:client");
-class Client {
-  constructor(token, efHost) {
-    this.token = token;
-    this.efHost = efHost;
-    this.authenticatedFetch = async (path, init = {}) => {
-      init.headers ||= {};
-      log(
-        "Authenticated fetch",
-        { path, init },
-        "(Token will be added as Bearer token)"
-      );
-      Object.assign(init.headers, {
-        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);
-  }
-}
-exports.Client = Client;

package/dist/index.cjs

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const captionFile = require("./resources/caption-file.cjs");
-const imageFile = require("./resources/image-file.cjs");
-const isobmffFile = require("./resources/isobmff-file.cjs");
-const isobmffTrack = require("./resources/isobmff-track.cjs");
-const renders = require("./resources/renders.cjs");
-const client = require("./client.cjs");
-exports.CreateCaptionFilePayload = captionFile.CreateCaptionFilePayload;
-exports.createCaptionFile = captionFile.createCaptionFile;
-exports.uploadCaptionFile = captionFile.uploadCaptionFile;
-exports.CreateImageFilePayload = imageFile.CreateImageFilePayload;
-exports.createImageFile = imageFile.createImageFile;
-exports.uploadImageFile = imageFile.uploadImageFile;
-exports.CreateISOBMFFFilePayload = isobmffFile.CreateISOBMFFFilePayload;
-exports.createISOBMFFFile = isobmffFile.createISOBMFFFile;
-exports.uploadFragmentIndex = isobmffFile.uploadFragmentIndex;
-exports.CreateISOBMFFTrackPayload = isobmffTrack.CreateISOBMFFTrackPayload;
-exports.createISOBMFFTrack = isobmffTrack.createISOBMFFTrack;
-exports.uploadISOBMFFTrack = isobmffTrack.uploadISOBMFFTrack;
-exports.CreateRenderPayload = renders.CreateRenderPayload;
-exports.createRender = renders.createRender;
-exports.uploadRender = renders.uploadRender;
-exports.Client = client.Client;

package/dist/resources/caption-file.cjs

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const zod = require("zod");
-const debug = require("debug");
-const log = debug("ef:api:caption-file");
-const CreateCaptionFilePayload = zod.z.object({
-  id: zod.z.string(),
-  filename: zod.z.string()
-});
-const createCaptionFile = async (client, payload) => {
-  log("Creating caption file", payload);
-  const fileCreation = 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;
-    }
-  }
-};
-const uploadCaptionFile = async (client, fileId, fileStream) => {
-  log("Uploading caption file", fileId);
-  const fileIndex = 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;
-    }
-  }
-};
-exports.CreateCaptionFilePayload = CreateCaptionFilePayload;
-exports.createCaptionFile = createCaptionFile;
-exports.uploadCaptionFile = uploadCaptionFile;

package/dist/resources/image-file.cjs

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const zod = require("zod");
-const debug = require("debug");
-const log = debug("ef:api:image-file");
-const CreateImageFilePayload = zod.z.object({
-  id: zod.z.string(),
-  height: zod.z.number().int(),
-  width: zod.z.number().int(),
-  mime_type: zod.z.enum(["image/jpeg", "image/png", "image/jpg", "image/webp"]),
-  filename: zod.z.string()
-});
-const createImageFile = async (client, payload) => {
-  log("Creating image file", 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;
-    }
-  }
-};
-const uploadImageFile = async (client, fileId, fileStream) => {
-  const fileIndex = await client.authenticatedFetch(
-    `/api/video2/image_files/${fileId}/upload`,
-    {
-      method: "POST",
-      body: fileStream
-    }
-  );
-  switch (fileIndex.status) {
-    case 200: {
-      return fileIndex.json();
-    }
-    default: {
-      console.error("Failed to upload image");
-      return;
-    }
-  }
-};
-exports.CreateImageFilePayload = CreateImageFilePayload;
-exports.createImageFile = createImageFile;
-exports.uploadImageFile = uploadImageFile;

package/dist/resources/isobmff-file.cjs

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const zod = require("zod");
-const debug = require("debug");
-const log = debug("ef:api:isobmff-file");
-const CreateISOBMFFFilePayload = zod.z.object({
-  id: zod.z.string(),
-  filename: zod.z.string()
-});
-const createISOBMFFFile = async (client, payload) => {
-  log("Creating isobmff file", payload);
-  const response = await client.authenticatedFetch(
-    "/api/video2/isobmff_files",
-    {
-      method: "POST",
-      body: JSON.stringify(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;
-    }
-  }
-};
-const uploadFragmentIndex = async (client, fileId, fileStream) => {
-  log("Uploading fragment index", fileId);
-  const fileIndex = 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;
-    }
-  }
-};
-exports.CreateISOBMFFFilePayload = CreateISOBMFFFilePayload;
-exports.createISOBMFFFile = createISOBMFFFile;
-exports.uploadFragmentIndex = uploadFragmentIndex;

package/dist/resources/isobmff-track.cjs

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const zod = require("zod");
-const debug = require("debug");
-const assets = require("@editframe/assets");
-const log = debug("ef:api:isobmff-track");
-const CreateISOBMFFTrackPayload = zod.z.discriminatedUnion("type", [
-  zod.z.object({
-    file_id: zod.z.string(),
-    track_id: zod.z.number().int(),
-    type: zod.z.literal("audio"),
-    probe_info: assets.AudioStreamSchema,
-    duration_ms: zod.z.number().int(),
-    codec_name: zod.z.string(),
-    byte_size: zod.z.number().int()
-  }),
-  zod.z.object({
-    file_id: zod.z.string(),
-    track_id: zod.z.number().int(),
-    type: zod.z.literal("video"),
-    probe_info: assets.VideoStreamSchema,
-    duration_ms: zod.z.number().int(),
-    codec_name: zod.z.string(),
-    byte_size: zod.z.number().int()
-  })
-]);
-const createISOBMFFTrack = async (client, payload) => {
-  log("Creating isobmff track", payload);
-  const response = await client.authenticatedFetch(
-    "/api/video2/isobmff_tracks",
-    {
-      method: "POST",
-      body: JSON.stringify(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;
-    }
-  }
-};
-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
-    }
-  );
-  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;
-    }
-  }
-};
-exports.CreateISOBMFFTrackPayload = CreateISOBMFFTrackPayload;
-exports.createISOBMFFTrack = createISOBMFFTrack;
-exports.uploadISOBMFFTrack = uploadISOBMFFTrack;

package/dist/resources/renders.cjs

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const zod = require("zod");
-const debug = require("debug");
-const log = debug("ef:api:renders");
-const CreateRenderPayload = zod.z.object({
-  id: zod.z.string().uuid(),
-  fps: zod.z.number(),
-  width: zod.z.number().int(),
-  height: zod.z.number().int(),
-  work_slice_ms: zod.z.number().int(),
-  duration_ms: zod.z.number().int(),
-  strategy: zod.z.enum(["v1", "v2"])
-});
-const createRender = async (client, payload) => {
-  log("Creating render", payload);
-  const response = await client.authenticatedFetch("/api/video2/renders", {
-    method: "POST",
-    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;
-    }
-  }
-};
-const uploadRender = async (client, fileId, fileStream) => {
-  log("Uploading render", fileId);
-  const fileIndex = 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;
-    }
-  }
-};
-exports.CreateRenderPayload = CreateRenderPayload;
-exports.createRender = createRender;
-exports.uploadRender = uploadRender;

package/src/util/nodeStreamToWebStream.ts

@@ -1,20 +0,0 @@
-import type { Readable } from "node:stream";
-
-export const nodeStreamToWebStream = (nodeStream: Readable): BodyInit => {
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.on("data", (chunk) => {
-        controller.enqueue(chunk);
-      });
-      nodeStream.on("end", () => {
-        controller.close();
-      });
-      nodeStream.on("error", (err) => {
-        controller.error(err);
-      });
-    },
-    cancel() {
-      nodeStream.destroy();
-    },
-  });
-};