@editframe/api 0.7.0-beta.4

package/dist/client.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const debug = require("debug");
+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/client.js

@@ -0,0 +1,28 @@
+import debug from "debug";
+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);
+  }
+}
+export {
+  Client
+};

package/dist/index.cjs

@@ -0,0 +1,24 @@
+"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/index.js

@@ -0,0 +1,24 @@
+import { CreateCaptionFilePayload, createCaptionFile, uploadCaptionFile } from "./resources/caption-file.js";
+import { CreateImageFilePayload, createImageFile, uploadImageFile } from "./resources/image-file.js";
+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 { Client } from "./client.js";
+export {
+  Client,
+  CreateCaptionFilePayload,
+  CreateISOBMFFFilePayload,
+  CreateISOBMFFTrackPayload,
+  CreateImageFilePayload,
+  CreateRenderPayload,
+  createCaptionFile,
+  createISOBMFFFile,
+  createISOBMFFTrack,
+  createImageFile,
+  createRender,
+  uploadCaptionFile,
+  uploadFragmentIndex,
+  uploadISOBMFFTrack,
+  uploadImageFile,
+  uploadRender
+};

package/dist/resources/caption-file.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const zod = require("zod");
+const debug = require("debug");
+const nodeStreamToWebStream = require("../util/nodeStreamToWebStream.cjs");
+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: nodeStreamToWebStream.nodeStreamToWebStream(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/caption-file.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import debug from "debug";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
+const log = debug("ef:api:caption-file");
+const CreateCaptionFilePayload = z.object({
+  id: z.string(),
+  filename: 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: nodeStreamToWebStream(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;
+    }
+  }
+};
+export {
+  CreateCaptionFilePayload,
+  createCaptionFile,
+  uploadCaptionFile
+};

package/dist/resources/image-file.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const zod = require("zod");
+const debug = require("debug");
+const nodeStreamToWebStream = require("../util/nodeStreamToWebStream.cjs");
+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: nodeStreamToWebStream.nodeStreamToWebStream(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/image-file.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import debug from "debug";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
+const log = debug("ef:api:image-file");
+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()
+});
+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: nodeStreamToWebStream(fileStream)
+    }
+  );
+  switch (fileIndex.status) {
+    case 200: {
+      return fileIndex.json();
+    }
+    default: {
+      console.error("Failed to upload image");
+      return;
+    }
+  }
+};
+export {
+  CreateImageFilePayload,
+  createImageFile,
+  uploadImageFile
+};

package/dist/resources/isobmff-file.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const zod = require("zod");
+const debug = require("debug");
+const nodeStreamToWebStream = require("../util/nodeStreamToWebStream.cjs");
+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: nodeStreamToWebStream.nodeStreamToWebStream(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-file.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import debug from "debug";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
+const log = debug("ef:api:isobmff-file");
+const CreateISOBMFFFilePayload = z.object({
+  id: z.string(),
+  filename: 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: nodeStreamToWebStream(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;
+    }
+  }
+};
+export {
+  CreateISOBMFFFilePayload,
+  createISOBMFFFile,
+  uploadFragmentIndex
+};

package/dist/resources/isobmff-track.cjs

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const zod = require("zod");
+const debug = require("debug");
+const assets = require("@editframe/assets");
+const nodeStreamToWebStream = require("../util/nodeStreamToWebStream.cjs");
+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: nodeStreamToWebStream.nodeStreamToWebStream(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/isobmff-track.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import debug from "debug";
+import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
+const log = debug("ef:api:isobmff-track");
+const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
+  z.object({
+    file_id: z.string(),
+    track_id: z.number().int(),
+    type: z.literal("audio"),
+    probe_info: AudioStreamSchema,
+    duration_ms: z.number().int(),
+    codec_name: z.string(),
+    byte_size: z.number().int()
+  }),
+  z.object({
+    file_id: z.string(),
+    track_id: z.number().int(),
+    type: z.literal("video"),
+    probe_info: VideoStreamSchema,
+    duration_ms: z.number().int(),
+    codec_name: z.string(),
+    byte_size: 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: nodeStreamToWebStream(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;
+    }
+  }
+};
+export {
+  CreateISOBMFFTrackPayload,
+  createISOBMFFTrack,
+  uploadISOBMFFTrack
+};

package/dist/resources/renders.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const zod = require("zod");
+const debug = require("debug");
+const nodeStreamToWebStream = require("../util/nodeStreamToWebStream.cjs");
+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: nodeStreamToWebStream.nodeStreamToWebStream(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/dist/resources/renders.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import debug from "debug";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
+const log = debug("ef:api:renders");
+const CreateRenderPayload = z.object({
+  id: z.string().uuid(),
+  fps: z.number(),
+  width: z.number().int(),
+  height: z.number().int(),
+  work_slice_ms: z.number().int(),
+  duration_ms: z.number().int(),
+  strategy: 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: nodeStreamToWebStream(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;
+    }
+  }
+};
+export {
+  CreateRenderPayload,
+  createRender,
+  uploadRender
+};

package/dist/util/nodeStreamToWebStream.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nodeStreamToWebStream = (nodeStream) => {
+  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();
+    }
+  });
+};
+exports.nodeStreamToWebStream = nodeStreamToWebStream;

package/dist/util/nodeStreamToWebStream.js

@@ -0,0 +1,21 @@
+const nodeStreamToWebStream = (nodeStream) => {
+  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();
+    }
+  });
+};
+export {
+  nodeStreamToWebStream
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@editframe/api",
+  "version": "0.7.0-beta.4",
+  "description": "API functions for EditFrame",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "typecheck": "tsc --noEmit --emitDeclarationOnly false",
+    "build": "vite build",
+    "build:watch": "vite build --watch"
+  },
+  "author": "",
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "@types/node": "^20.14.9",
+    "typescript": "^5.2.2",
+    "vite": "^5.2.11",
+    "vite-plugin-dts": "^3.9.1",
+    "vite-tsconfig-paths": "^4.3.2"
+  },
+  "dependencies": {
+    "@editframe/assets": "0.7.0-beta.4",
+    "debug": "^4.3.5",
+    "zod": "^3.23.8"
+  }
+}

package/src/resources/caption-file.ts

@@ -0,0 +1,73 @@
+import type { Readable } from "node:stream";
+
+import { z } from "zod";
+import debug from "debug";
+
+import type { Client } from "../client";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream";
+
+const log = debug("ef:api:caption-file");
+
+export const CreateCaptionFilePayload = z.object({
+  id: z.string(),
+  filename: z.string(),
+});
+
+export interface CreateCaptionFileResult {
+  complete: boolean | null;
+  id: string;
+}
+
+export const createCaptionFile = async (
+  client: Client,
+  payload: z.infer<typeof CreateCaptionFilePayload>,
+) => {
+  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()) as CreateCaptionFileResult;
+    }
+    default: {
+      console.error(
+        `Failed to create file ${fileCreation.status} ${fileCreation.statusText}`,
+      );
+      return;
+    }
+  }
+};
+
+export const uploadCaptionFile = async (
+  client: Client,
+  fileId: string,
+  fileStream: Readable,
+) => {
+  log("Uploading caption file", fileId);
+  const fileIndex = await client.authenticatedFetch(
+    `/api/video2/caption_files/${fileId}/upload`,
+    {
+      method: "POST",
+      body: nodeStreamToWebStream(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;
+    }
+  }
+};

package/src/resources/image-file.ts

@@ -0,0 +1,69 @@
+import type { Readable } from "node:stream";
+
+import { z } from "zod";
+import debug from "debug";
+
+import type { Client } from "../client";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream";
+
+const log = debug("ef:api:image-file");
+
+export 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(),
+});
+
+export interface CreateImageFileResult {
+  complete: boolean | null;
+  id: string;
+}
+
+export const createImageFile = async (
+  client: Client,
+  payload: z.infer<typeof CreateImageFilePayload>,
+) => {
+  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()) as CreateImageFileResult;
+    }
+    default: {
+      console.error(
+        `Failed to create file ${response.status} ${response.statusText}`,
+      );
+      return;
+    }
+  }
+};
+
+export const uploadImageFile = async (
+  client: Client,
+  fileId: string,
+  fileStream: Readable,
+) => {
+  const fileIndex = await client.authenticatedFetch(
+    `/api/video2/image_files/${fileId}/upload`,
+    {
+      method: "POST",
+      body: nodeStreamToWebStream(fileStream),
+    },
+  );
+  switch (fileIndex.status) {
+    case 200: {
+      return fileIndex.json();
+    }
+    default: {
+      console.error("Failed to upload image");
+      return;
+    }
+  }
+};

package/src/resources/isobmff-file.ts

@@ -0,0 +1,75 @@
+import type { Readable } from "node:stream";
+
+import { z } from "zod";
+import debug from "debug";
+
+import type { Client } from "../client";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream";
+
+const log = debug("ef:api:isobmff-file");
+
+export const CreateISOBMFFFilePayload = z.object({
+  id: z.string(),
+  filename: z.string(),
+});
+
+export interface CreateISOBMFFFileResult {
+  fragment_index_complete: boolean;
+  id: string;
+}
+
+export const createISOBMFFFile = async (
+  client: Client,
+  payload: z.infer<typeof CreateISOBMFFFilePayload>,
+) => {
+  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()) as CreateISOBMFFFileResult;
+    }
+    default: {
+      console.error(
+        `Failed to create file ${response.status} ${response.statusText}`,
+      );
+      return;
+    }
+  }
+};
+
+export const uploadFragmentIndex = async (
+  client: Client,
+  fileId: string,
+  fileStream: Readable,
+) => {
+  log("Uploading fragment index", fileId);
+  const fileIndex = await client.authenticatedFetch(
+    `/api/video2/isobmff_files/${fileId}/index/upload`,
+    {
+      method: "POST",
+      body: nodeStreamToWebStream(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;
+    }
+  }
+};

package/src/resources/isobmff-track.ts

@@ -0,0 +1,93 @@
+import type { Readable } from "node:stream";
+
+import { z } from "zod";
+import debug from "debug";
+
+import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
+
+import type { Client } from "../client";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream";
+
+const log = debug("ef:api:isobmff-track");
+
+export const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
+  z.object({
+    file_id: z.string(),
+    track_id: z.number().int(),
+    type: z.literal("audio"),
+    probe_info: AudioStreamSchema,
+    duration_ms: z.number().int(),
+    codec_name: z.string(),
+    byte_size: z.number().int(),
+  }),
+  z.object({
+    file_id: z.string(),
+    track_id: z.number().int(),
+    type: z.literal("video"),
+    probe_info: VideoStreamSchema,
+    duration_ms: z.number().int(),
+    codec_name: z.string(),
+    byte_size: z.number().int(),
+  }),
+]);
+
+export interface CreateISOBMFFTrackResult {
+  last_received_byte: number;
+  byte_size: number;
+  track_id: number;
+  file_id: string;
+}
+
+export const createISOBMFFTrack = async (
+  client: Client,
+  payload: z.infer<typeof CreateISOBMFFTrackPayload>,
+) => {
+  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()) as CreateISOBMFFTrackResult;
+    }
+    default: {
+      console.error("Failed to create track");
+      console.error(await response.json());
+      return;
+    }
+  }
+};
+
+export const uploadISOBMFFTrack = async (
+  client: Client,
+  fileId: string,
+  trackId: number,
+  fileStream: Readable,
+) => {
+  log("Uploading isobmff track", fileId, trackId);
+  const trackIndex = await client.authenticatedFetch(
+    `/api/video2/isobmff_tracks/${fileId}/${trackId}/upload`,
+    {
+      method: "POST",
+      body: nodeStreamToWebStream(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;
+    }
+  }
+};

package/src/resources/renders.ts

@@ -0,0 +1,74 @@
+import type { Readable } from "node:stream";
+
+import { z } from "zod";
+import debug from "debug";
+
+import type { Client } from "../client";
+import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream";
+
+const log = debug("ef:api:renders");
+
+export const CreateRenderPayload = z.object({
+  id: z.string().uuid(),
+  fps: z.number(),
+  width: z.number().int(),
+  height: z.number().int(),
+  work_slice_ms: z.number().int(),
+  duration_ms: z.number().int(),
+  strategy: z.enum(["v1", "v2"]),
+});
+
+export interface CreateRenderResult {
+  status: "complete" | "created" | "failed" | "pending" | "rendering";
+  id: string;
+}
+
+export const createRender = async (
+  client: Client,
+  payload: z.infer<typeof CreateRenderPayload>,
+) => {
+  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()) as CreateRenderResult;
+    }
+    default: {
+      console.error("Failed to create render");
+      console.error(await response.json());
+      return;
+    }
+  }
+};
+
+export const uploadRender = async (
+  client: Client,
+  fileId: string,
+  fileStream: Readable,
+) => {
+  log("Uploading render", fileId);
+  const fileIndex = await client.authenticatedFetch(
+    `/api/video2/renders/${fileId}/upload`,
+    {
+      method: "POST",
+      body: nodeStreamToWebStream(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;
+    }
+  }
+};

package/src/util/nodeStreamToWebStream.ts

@@ -0,0 +1,20 @@
+import type { Readable } from "node:stream";
+
+export const nodeStreamToWebStream = (nodeStream: Readable): ReadableStream => {
+  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();
+    },
+  });
+};