@editframe/api 0.12.0-beta.6 → 0.13.0-beta.1

package/src/resources/isobmff-track.ts

@@ -1,7 +1,10 @@
 import debug from "debug";
 import { z } from "zod";
+import type { Client } from "../client.js";
+import { uploadChunks } from "../uploadChunks.js";
+import { assertTypesMatch } from "../utils/assertTypesMatch.ts";
 
-const AudioStreamSchema = z.object({
+export const AudioStreamSchema = z.object({
   index: z.number(),
   codec_name: z.string(),
   codec_long_name: z.string(),
@@ -25,9 +28,54 @@ const AudioStreamSchema = z.object({
   disposition: z.record(z.unknown()),
 });
 
-type AudioStreamSchema = z.infer<typeof AudioStreamSchema>;
+export interface AudioStreamSchema {
+  /** The index of the stream in the file */
+  index: number;
+  /** The name of the codec */
+  codec_name: string;
+  /** The long name of the codec */
+  codec_long_name: string;
+  /** The type of the codec */
+  codec_type: "audio";
+  /** The tag string of the codec */
+  codec_tag_string: string;
+  /** The tag of the codec */
+  codec_tag: string;
+  /** The sample format */
+  sample_fmt: string;
+  /** The sample rate */
+  sample_rate: string;
+  /** The number of channels */
+  channels: number;
+  /** The channel layout */
+  channel_layout: string;
+  /** The number of bits per sample */
+  bits_per_sample: number;
+  /** The initial padding */
+  initial_padding?: number;
+  /** The frame rate */
+  r_frame_rate: string;
+  /** The average frame rate */
+  avg_frame_rate: string;
+  /** The time base */
+  time_base: string;
+  /** The start presentation timestamp */
+  start_pts: number;
+  /** The start time */
+  start_time: number;
+  /** The duration timestamp */
+  duration_ts: number;
+  /** The duration */
+  duration: number;
+  /** The bit rate */
+  bit_rate: string;
+  /** The disposition record. Subject to change, not documented. */
+  disposition: Record<string, unknown>;
+}
+
+assertTypesMatch<z.infer<typeof AudioStreamSchema>, AudioStreamSchema>(true);
 
-const VideoStreamSchema = z.object({
+export const VideoStreamSchema = z.object({
   index: z.number(),
   codec_name: z.string(),
   codec_long_name: z.string(),
@@ -49,36 +97,110 @@ const VideoStreamSchema = z.object({
   disposition: z.record(z.unknown()),
 });
 
-type VideoStreamSchema = z.infer<typeof VideoStreamSchema>;
+export interface VideoStreamSchema {
+  /** The index of the stream in the file */
+  index: number;
+  /** The name of the codec */
+  codec_name: string;
+  /** The long name of the codec */
+  codec_long_name: string;
+  /** The type of the codec */
+  codec_type: "video";
+  /** The tag string of the codec */
+  codec_tag_string: string;
+  /** The tag of the codec */
+  codec_tag: string;
+  /** The width */
+  width: number;
+  /** The height */
+  height: number;
+  /** The coded width */
+  coded_width: number;
+  /** The coded height */
+  coded_height: number;
+  /** The frame rate */
+  r_frame_rate: string;
+  /** The average frame rate */
+  avg_frame_rate: string;
+  /** The time base */
+  time_base: string;
+  /** The start presentation timestamp */
+  start_pts?: number;
+  /** The start time */
+  start_time?: number;
+  /** The duration timestamp */
+  duration_ts?: number;
+  /** The duration */
+  duration?: number;
+  /** The bit rate */
+  bit_rate?: string;
+  /** The disposition record. Subject to change, not documented. */
+  disposition: Record<string, unknown>;
+}
 
-import type { Client } from "../client.ts";
-import { uploadChunks } from "../uploadChunks.ts";
+assertTypesMatch<z.infer<typeof VideoStreamSchema>, VideoStreamSchema>(true);
 
 const log = debug("ef:api:isobmff-track");
 
 const MAX_TRACK_SIZE = 1024 * 1024 * 1024; // 1GB
 
+export const AudioTrackPayload = 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().max(MAX_TRACK_SIZE),
+});
+
+export interface AudioTrackPayload {
+  file_id: string;
+  track_id: number;
+  type: "audio";
+  probe_info: AudioStreamSchema;
+  duration_ms: number;
+  codec_name: string;
+  byte_size: number;
+}
+
+// These will actually error if types don't match
+assertTypesMatch<z.infer<typeof AudioTrackPayload>, AudioTrackPayload>(true);
+
+export const VideoTrackPayload = 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().max(MAX_TRACK_SIZE),
+});
+
+export interface VideoTrackPayload {
+  file_id: string;
+  track_id: number;
+  type: "video";
+  probe_info: VideoStreamSchema;
+  duration_ms: number;
+  codec_name: string;
+  byte_size: number;
+}
+
+assertTypesMatch<z.infer<typeof VideoTrackPayload>, VideoTrackPayload>(true);
+
 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().max(MAX_TRACK_SIZE),
-  }),
-  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().max(MAX_TRACK_SIZE),
-  }),
+  AudioTrackPayload,
+  VideoTrackPayload,
 ]);
 
+export type CreateISOBMFFTrackPayload = VideoTrackPayload | AudioTrackPayload;
+
+assertTypesMatch<
+  z.infer<typeof CreateISOBMFFTrackPayload>,
+  CreateISOBMFFTrackPayload
+>(true);
+
 export interface CreateISOBMFFTrackResult {
   next_byte: number;
   byte_size: number;
@@ -89,7 +211,7 @@ export interface CreateISOBMFFTrackResult {
 
 export const createISOBMFFTrack = async (
   client: Client,
-  payload: z.infer<typeof CreateISOBMFFTrackPayload>,
+  payload: CreateISOBMFFTrackPayload,
 ) => {
   log("Creating isobmff track", payload);
   CreateISOBMFFTrackPayload.parse(payload);

package/src/resources/process-isobmff.test.ts

@@ -2,11 +2,11 @@ import { describe, expect, test } from "vitest";
 import {
   getIsobmffProcessInfo,
   getIsobmffProcessProgress,
-} from "./process-isobmff.ts";
+} from "./process-isobmff.js";
 
-import { useMSW } from "TEST/useMSW.ts";
+import { useMSW } from "TEST/useMSW.js";
 import { http, HttpResponse } from "msw";
-import { Client } from "../client.ts";
+import { Client } from "../client.js";
 
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
 

package/src/resources/process-isobmff.ts

@@ -1,5 +1,5 @@
-import { ProgressIterator } from "../ProgressIterator.ts";
-import type { Client } from "../client.ts";
+import { ProgressIterator } from "../ProgressIterator.js";
+import type { Client } from "../client.js";
 
 export interface IsobmffProcessInfoResult {
   id: string;

package/src/resources/renders.test.ts

@@ -2,9 +2,9 @@ import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 
-import { Client } from "../client.ts";
-import { webReadableFromBuffers } from "../readableFromBuffers.ts";
-import { createRender, lookupRenderByMd5, uploadRender } from "./renders.ts";
+import { Client } from "../client.js";
+import { webReadableFromBuffers } from "../readableFromBuffers.js";
+import { createRender, lookupRenderByMd5, uploadRender } from "./renders.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -46,19 +46,6 @@ describe("Renders", () => {
   });
 
   describe("uploadRender", () => {
-    test("throws if file size exceeds limit", async () => {
-      await expect(
-        uploadRender(
-          client,
-          "test-id",
-          webReadableFromBuffers(Buffer.from("test")),
-          1024 * 1024 * 17,
-        ),
-      ).rejects.toThrowError(
-        new Error("File size exceeds limit of 16777216 bytes"),
-      );
-    });
-
     test("throws if server returns an error", async () => {
       server.use(
         http.post("http://localhost/api/v1/renders/test-id/upload", () =>
@@ -71,7 +58,6 @@ describe("Renders", () => {
           client,
           "test-id",
           webReadableFromBuffers(Buffer.from("test")),
-          1024 * 1024 * 2,
         ),
       ).rejects.toThrowError(
         "Failed to upload render 500 Internal Server Error",
@@ -92,7 +78,6 @@ describe("Renders", () => {
         client,
         "test-id",
         webReadableFromBuffers(Buffer.from("test")),
-        1024 * 1024 * 2,
       );
 
       expect(response).toEqual({ testResponse: "test" });

package/src/resources/renders.ts

@@ -1,21 +1,42 @@
 import debug from "debug";
 import { z } from "zod";
 
-import type { Client } from "../client.ts";
+import { CompletionIterator } from "../ProgressIterator.js";
+import type { Client } from "../client.js";
+import { assertTypesMatch } from "../utils/assertTypesMatch.ts";
 
 const log = debug("ef:api:renders");
-const FILE_SIZE_LIMIT = 1024 * 1024 * 16; // 16MiB
 
 export const CreateRenderPayload = z.object({
-  md5: z.string(),
-  fps: z.number(),
-  width: z.number().int(),
-  height: z.number().int(),
-  work_slice_ms: z.number().int(),
+  md5: z.string().optional(),
+  fps: z.number().int().min(1).max(120).default(30).optional(),
+  width: z.number().int().min(2),
+  height: z.number().int().min(2),
+  work_slice_ms: z
+    .number()
+    .int()
+    .min(1000)
+    .max(10_000)
+    .default(4_000)
+    .optional(),
   duration_ms: z.number().int(),
-  strategy: z.enum(["v1", "v2"]),
+  strategy: z.enum(["v1", "v2"]).default("v1").optional(),
 });
 
+export interface CreateRenderPayload {
+  md5?: string;
+  fps?: number;
+  width: number;
+  height: number;
+  work_slice_ms?: number;
+  duration_ms: number;
+  strategy?: "v1" | "v2";
+}
+
+assertTypesMatch<CreateRenderPayload, z.infer<typeof CreateRenderPayload>>(
+  true,
+);
+
 export interface CreateRenderResult {
   id: string;
   md5: string;
@@ -30,7 +51,7 @@ export interface LookupRenderByMd5Result {
 
 export const createRender = async (
   client: Client,
-  payload: z.infer<typeof CreateRenderPayload>,
+  payload: CreateRenderPayload,
 ) => {
   log("Creating render", payload);
   const response = await client.authenticatedFetch("/api/v1/renders", {
@@ -44,7 +65,7 @@ export const createRender = async (
   }
 
   throw new Error(
-    `Failed to create render ${response.status} ${response.statusText}`,
+    `Failed to create render ${response.status} ${response.statusText} ${await response.text()}`,
   );
 };
 
@@ -52,13 +73,8 @@ export const uploadRender = async (
   client: Client,
   fileId: string,
   fileStream: ReadableStream,
-  folderSize: number,
 ) => {
   log("Uploading render", fileId);
-  log("Folder size", folderSize, "bytes");
-  if (folderSize > FILE_SIZE_LIMIT) {
-    throw new Error(`File size exceeds limit of ${FILE_SIZE_LIMIT} bytes`);
-  }
   const response = await client.authenticatedFetch(
     `/api/v1/renders/${fileId}/upload`,
     {
@@ -77,6 +93,11 @@ export const uploadRender = async (
   );
 };
 
+export const getRenderInfo = async (client: Client, id: string) => {
+  const response = await client.authenticatedFetch(`/api/v1/renders/${id}`);
+  return response.json() as Promise<LookupRenderByMd5Result>;
+};
+
 export const lookupRenderByMd5 = async (
   client: Client,
   md5: string,
@@ -100,3 +121,11 @@ export const lookupRenderByMd5 = async (
     `Failed to lookup render by md5 ${md5} ${response.status} ${response.statusText}`,
   );
 };
+
+export const getRenderProgress = async (client: Client, id: string) => {
+  const eventSource = await client.authenticatedEventSource(
+    `/api/v1/renders/${id}/progress`,
+  );
+
+  return new CompletionIterator(eventSource);
+};

package/src/resources/transcriptions.test.ts

@@ -2,8 +2,8 @@ import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 
-import { Client } from "../client.ts";
-import { createTranscription } from "./transcriptions.ts";
+import { Client } from "../client.js";
+import { createTranscription } from "./transcriptions.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");

package/src/resources/transcriptions.ts

@@ -1,8 +1,8 @@
 import debug from "debug";
 import { z } from "zod";
 
-import { CompletionIterator } from "../ProgressIterator.ts";
-import type { Client } from "../client.ts";
+import { CompletionIterator } from "../ProgressIterator.js";
+import type { Client } from "../client.js";
 
 const log = debug("ef:api:transcriptions");
 
@@ -11,6 +11,10 @@ export const CreateTranscriptionPayload = z.object({
   track_id: z.number().int(),
 });
 
+export type CreateTranscriptionPayload = z.infer<
+  typeof CreateTranscriptionPayload
+>;
+
 export interface CreateTranscriptionResult {
   id: string;
   status: "complete" | "created" | "failed" | "pending" | "transcribing";
@@ -23,7 +27,7 @@ export interface TranscriptionInfoResult {
 
 export const createTranscription = async (
   client: Client,
-  payload: z.infer<typeof CreateTranscriptionPayload>,
+  payload: CreateTranscriptionPayload,
 ) => {
   log("Creating transcription", payload);
   const response = await client.authenticatedFetch("/api/v1/transcriptions", {

package/src/resources/unprocessed-file.test.ts

@@ -3,13 +3,13 @@ import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 import { ZodError } from "zod";
 
-import { Client } from "../client.ts";
-import { webReadableFromBuffers } from "../readableFromBuffers.ts";
+import { Client } from "../client.js";
+import { webReadableFromBuffers } from "../readableFromBuffers.js";
 import {
   createUnprocessedFile,
   lookupUnprocessedFileByMd5,
   uploadUnprocessedReadableStream,
-} from "./unprocessed-file.ts";
+} from "./unprocessed-file.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");

package/src/resources/unprocessed-file.ts

@@ -1,13 +1,9 @@
-import { stat } from "node:fs/promises";
 import debug from "debug";
 import { z } from "zod";
 
-import { createReadStream } from "node:fs";
-import { basename } from "node:path";
-import { md5FilePath } from "@editframe/assets";
-import { createReadableStreamFromReadable } from "packages/cli/src/utils/createReadableStreamFromReadable.ts";
-import type { Client } from "../client.ts";
-import { uploadChunks } from "../uploadChunks.ts";
+import type { Client } from "../client.js";
+import { uploadChunks } from "../uploadChunks.js";
+import { assertTypesMatch } from "../utils/assertTypesMatch.ts";
 
 const log = debug("ef:api:unprocessed-file");
 
@@ -21,7 +17,11 @@ export const CreateUnprocessedFilePayload = z.object({
 
 export const UpdateUnprocessedFilePayload = z.object({});
 
-interface UnprocessedFile {
+export type CreateUnprocessedFilePayload = z.infer<
+  typeof CreateUnprocessedFilePayload
+>;
+
+export interface UnprocessedFile {
   byte_size: number;
   next_byte: number;
   complete: boolean;
@@ -29,7 +29,17 @@ interface UnprocessedFile {
   md5: string;
 }
 
-type UnprocessedFileUploadDetails = Pick<UnprocessedFile, "id" | "byte_size">;
+export interface UnprocessedFileUploadDetails {
+  id: string;
+  byte_size: number;
+}
+
+// Ensure that the UnprocessedFileUploadDetails type matches the shape of the
+// UnprocessedFile type, but without the optional fields.
+assertTypesMatch<
+  Pick<UnprocessedFile, "id" | "byte_size">,
+  UnprocessedFileUploadDetails
+>(true);
 
 export interface CreateUnprocessedFileResult extends UnprocessedFile {}
 
@@ -41,26 +51,9 @@ export interface ProcessIsobmffFileResult {
   id: string;
 }
 
-export const createUnprocessedFileFromPath = async (
-  client: Client,
-  path: string,
-) => {
-  const fileInfo = await stat(path);
-
-  const byte_size = fileInfo.size;
-
-  const md5 = await md5FilePath(path);
-
-  return createUnprocessedFile(client, {
-    md5,
-    filename: basename(path),
-    byte_size,
-  });
-};
-
 export const createUnprocessedFile = async (
   client: Client,
-  payload: z.infer<typeof CreateUnprocessedFilePayload>,
+  payload: CreateUnprocessedFilePayload,
 ) => {
   log("Creating an unprocessed file", payload);
   CreateUnprocessedFilePayload.parse(payload);
@@ -88,20 +81,6 @@ export const createUnprocessedFile = async (
   );
 };
 
-export const uploadUnprocessedFile = async (
-  client: Client,
-  uploadDetails: UnprocessedFileUploadDetails,
-  path: string,
-) => {
-  const readStream = createReadStream(path);
-
-  return uploadUnprocessedReadableStream(
-    client,
-    uploadDetails,
-    createReadableStreamFromReadable(readStream),
-  );
-};
-
 export const uploadUnprocessedReadableStream = (
   client: Client,
   uploadDetails: UnprocessedFileUploadDetails,

package/src/resources/url-token.test.ts

@@ -1,9 +1,9 @@
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 
-import { Client } from "../client.ts";
-import { createURLToken } from "./url-token.ts";
+import { Client } from "../client.js";
+import { createURLToken } from "./url-token.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");

package/src/resources/url-token.ts

@@ -1,6 +1,6 @@
 import debug from "debug";
 
-import type { Client } from "../client.ts";
+import type { Client } from "../client.js";
 
 const log = debug("ef:api:url-token");
 

package/src/utils/assertTypesMatch.ts

@@ -0,0 +1,10 @@
+// Type helper that will cause a compilation error
+type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y
+  ? 1
+  : 2
+  ? true
+  : false;
+// Force error with const assertion
+export const assertTypesMatch = <T, U>(
+  value: Equals<T, U> extends true ? true : never,
+) => value;