@editframe/api 0.26.3-beta.0 → 0.30.0-beta.13

package/src/resources/isobmff-track.ts

@@ -1,248 +0,0 @@
-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";
-
-export const AudioStreamSchema = z.object({
-  index: z.number(),
-  codec_name: z.string(),
-  codec_long_name: z.string(),
-  codec_type: z.literal("audio"),
-  codec_tag_string: z.string(),
-  codec_tag: z.string(),
-  sample_fmt: z.string(),
-  sample_rate: z.string(),
-  channels: z.number(),
-  channel_layout: z.string().optional(),
-  bits_per_sample: z.number(),
-  initial_padding: z.number().optional(),
-  r_frame_rate: z.string(),
-  avg_frame_rate: z.string(),
-  time_base: z.string(),
-  start_pts: z.number().optional(),
-  start_time: z.coerce.number().optional(),
-  duration_ts: z.number(),
-  duration: z.coerce.number(),
-  bit_rate: z.string(),
-  disposition: z.record(z.unknown()),
-});
-
-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);
-
-export const VideoStreamSchema = z.object({
-  index: z.number(),
-  codec_name: z.string(),
-  codec_long_name: z.string(),
-  codec_type: z.literal("video"),
-  codec_tag_string: z.string(),
-  codec_tag: z.string(),
-  width: z.number(),
-  height: z.number(),
-  coded_width: z.number(),
-  coded_height: z.number(),
-  r_frame_rate: z.string(),
-  avg_frame_rate: z.string(),
-  time_base: z.string(),
-  start_pts: z.number().optional(),
-  start_time: z.coerce.number().optional(),
-  duration_ts: z.number().optional(),
-  duration: z.coerce.number().optional(),
-  bit_rate: z.string().optional(),
-  disposition: z.record(z.unknown()),
-});
-
-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>;
-}
-
-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", [
-  AudioTrackPayload,
-  VideoTrackPayload,
-]);
-
-export type CreateISOBMFFTrackPayload = VideoTrackPayload | AudioTrackPayload;
-
-assertTypesMatch<
-  z.infer<typeof CreateISOBMFFTrackPayload>,
-  CreateISOBMFFTrackPayload
->(true);
-
-export interface CreateISOBMFFTrackResult {
-  next_byte: number;
-  byte_size: number;
-  track_id: number;
-  file_id: string;
-  complete: boolean;
-}
-
-export const createISOBMFFTrack = async (
-  client: Client,
-  payload: CreateISOBMFFTrackPayload,
-) => {
-  log("Creating isobmff track", payload);
-  CreateISOBMFFTrackPayload.parse(payload);
-  const response = await client.authenticatedFetch("/api/v1/isobmff_tracks", {
-    method: "POST",
-    body: JSON.stringify(payload),
-  });
-
-  log("ISOBMFF track created", response);
-  if (response.ok) {
-    return (await response.json()) as CreateISOBMFFTrackResult;
-  }
-
-  throw new Error(
-    `Failed to create isobmff track ${response.status} ${response.statusText}`,
-  );
-};
-
-export const uploadISOBMFFTrack = (
-  client: Client,
-  fileId: string,
-  trackId: number,
-  fileStream: ReadableStream,
-  trackSize: number,
-) => {
-  log("Uploading fragment track", fileId);
-
-  return uploadChunks(client, {
-    url: `/api/v1/isobmff_tracks/${fileId}/${trackId}/upload`,
-    fileStream,
-    fileSize: trackSize,
-    maxSize: MAX_TRACK_SIZE,
-  });
-};

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

@@ -1,68 +0,0 @@
-import { HttpResponse, http } from "msw";
-import { setupServer } from "msw/node";
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
-import { Client } from "../client.js";
-import {
-  getIsobmffProcessInfo,
-  getIsobmffProcessProgress,
-} from "./process-isobmff.js";
-
-const client = new Client("ef_TEST_TOKEN", "http://localhost");
-const server = setupServer();
-
-describe("process-isobmff", () => {
-  beforeAll(() => {
-    server.listen();
-    process.env.EF_TOKEN = "ef_SECRET_TOKEN";
-    process.env.EF_HOST = "http://localhost:3000";
-  });
-  afterAll(() => server.close());
-  afterEach(() => server.resetHandlers());
-  describe("getIsobmffProcessInfo", () => {
-    test("returns the process info", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/process_isobmff/123", async () => {
-          return HttpResponse.json({
-            id: "123",
-            created_at: "2021-01-01T00:00:00.000Z",
-            updated_at: "2021-01-01T00:00:00.000Z",
-          });
-        }),
-      );
-      const info = await getIsobmffProcessInfo(client, "123");
-      expect(info).toEqual({
-        id: "123",
-        created_at: "2021-01-01T00:00:00.000Z",
-        updated_at: "2021-01-01T00:00:00.000Z",
-      });
-    });
-
-    test("throws when the server returns an error", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/process_isobmff/123", () =>
-          HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-      await expect(getIsobmffProcessInfo(client, "123")).rejects.toThrow(
-        "Failed to get isobmff process info 500 Internal Server Error",
-      );
-    });
-  });
-
-  describe("getIsobmffProcessProgress", () => {
-    test("returns the progress", async () => {
-      server.use(
-        http.get(
-          "http://localhost/api/v1/process_isobmff/123/progress",
-          async () => {
-            return HttpResponse.text("event: complete\ndata: {}\n\n");
-          },
-        ),
-      );
-      const progress = await getIsobmffProcessProgress(client, "123");
-      await expect(progress.whenComplete()).resolves.toEqual([
-        { type: "complete", data: {} },
-      ]);
-    });
-  });
-});

package/src/resources/process-isobmff.ts

@@ -1,33 +0,0 @@
-import type { Client } from "../client.js";
-import { ProgressIterator } from "../ProgressIterator.js";
-
-export interface IsobmffProcessInfoResult {
-  id: string;
-  created_at: string;
-  completed_at: string | null;
-  failed_at: string | null;
-  isobmff_file_id: string | null;
-  unprocessed_file_id: string | null;
-}
-
-export const getIsobmffProcessProgress = async (client: Client, id: string) => {
-  const eventSource = await client.authenticatedEventSource(
-    `/api/v1/process_isobmff/${id}/progress`,
-  );
-
-  return new ProgressIterator(eventSource);
-};
-
-export const getIsobmffProcessInfo = async (client: Client, id: string) => {
-  const response = await client.authenticatedFetch(
-    `/api/v1/process_isobmff/${id}`,
-  );
-
-  if (response.ok) {
-    return (await response.json()) as IsobmffProcessInfoResult;
-  }
-
-  throw new Error(
-    `Failed to get isobmff process info ${response.status} ${response.statusText}`,
-  );
-};

package/src/resources/renders.bundle.ts

@@ -1,53 +0,0 @@
-import { randomUUID } from "node:crypto";
-import path from "node:path";
-import { PassThrough } from "node:stream";
-import react from "@vitejs/plugin-react";
-import * as tar from "tar";
-import { build } from "vite";
-import { viteSingleFile } from "vite-plugin-singlefile";
-import tsconfigPathsPlugin from "vite-tsconfig-paths";
-import { createReadableStreamFromReadable } from "../utils/createReadableStreamFromReadable.ts";
-
-interface BundlerOptions {
-  root: string;
-  renderData: any;
-}
-
-export const bundleRender = async (options: BundlerOptions) => {
-  const outDir = path.join(process.cwd(), "renders", randomUUID());
-
-  await build({
-    root: options.root,
-    define: {
-      RENDER_DATA: JSON.stringify(options.renderData),
-    },
-    build: {
-      outDir,
-      rollupOptions: {
-        input: path.resolve(options.root, "index.html"),
-      },
-    },
-    plugins: [
-      tsconfigPathsPlugin(),
-      react({
-        include: "**/*.{jsx,js,tsx,ts}",
-        jsxRuntime: "automatic",
-      }),
-      viteSingleFile(),
-    ],
-  });
-
-  const tarStream = tar.create(
-    {
-      gzip: true,
-      cwd: outDir,
-    },
-    ["."],
-  );
-
-  const passthrough = new PassThrough();
-  tarStream.pipe(passthrough);
-  const tarReadStream = createReadableStreamFromReadable(passthrough);
-
-  return tarReadStream;
-};

package/src/resources/renders.test.ts

@@ -1,202 +0,0 @@
-import { HttpResponse, http } from "msw";
-import { setupServer } from "msw/node";
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
-
-import { Client } from "../client.js";
-import { webReadableFromBuffers } from "../readableFromBuffers.js";
-import {
-  createRender,
-  lookupRenderByMd5,
-  OutputConfiguration,
-  uploadRender,
-} from "./renders.js";
-
-const server = setupServer();
-const client = new Client("ef_TEST_TOKEN", "http://localhost");
-
-describe("Renders", () => {
-  beforeAll(() => server.listen());
-  afterEach(() => server.resetHandlers());
-  afterAll(() => server.close());
-
-  describe("createRender", () => {
-    test("throws if server returns an error", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/renders", () =>
-          HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-
-      await expect(
-        createRender(client, createTestRender()),
-      ).rejects.toThrowError(
-        "Failed to create render 500 Internal Server Error",
-      );
-    });
-
-    test("returns json data from the http response", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/renders", () =>
-          HttpResponse.json(
-            { testResponse: "test" },
-            { status: 200, statusText: "OK" },
-          ),
-        ),
-      );
-
-      const response = await createRender(client, createTestRender());
-
-      expect(response).toEqual({ testResponse: "test" });
-    });
-  });
-
-  describe("uploadRender", () => {
-    test("throws if server returns an error", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/renders/test-id/upload", () =>
-          HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-
-      await expect(
-        uploadRender(
-          client,
-          "test-id",
-          webReadableFromBuffers(Buffer.from("test")),
-        ),
-      ).rejects.toThrowError(
-        "Failed to upload render 500 Internal Server Error",
-      );
-    });
-
-    test("returns json data from the http response", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/renders/test-id/upload", () =>
-          HttpResponse.json(
-            { testResponse: "test" },
-            { status: 200, statusText: "OK" },
-          ),
-        ),
-      );
-
-      const response = await uploadRender(
-        client,
-        "test-id",
-        webReadableFromBuffers(Buffer.from("test")),
-      );
-
-      expect(response).toEqual({ testResponse: "test" });
-    });
-  });
-
-  describe("lookupRenderByMd5", () => {
-    test("Returns json data from the http response", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/renders/md5/test-md5", () =>
-          HttpResponse.json(
-            { id: "test-id", md5: "test-md5", status: "complete" },
-            { status: 200, statusText: "OK" },
-          ),
-        ),
-      );
-
-      const response = await lookupRenderByMd5(client, "test-md5");
-
-      expect(response).toEqual({
-        id: "test-id",
-        md5: "test-md5",
-        status: "complete",
-      });
-    });
-
-    test("Returns null when file is not found", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/renders/md5/test-md5", () =>
-          HttpResponse.json({}, { status: 404 }),
-        ),
-      );
-
-      const response = await lookupRenderByMd5(client, "test-md5");
-
-      expect(response).toBeNull();
-    });
-
-    test("Throws when server returns an error", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/renders/md5/test-md5", () =>
-          HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-
-      await expect(lookupRenderByMd5(client, "test-md5")).rejects.toThrowError(
-        "Failed to lookup render by md5 test-md5 500 Internal Server Error",
-      );
-    });
-  });
-});
-
-describe("OutputConfiguration", () => {
-  test("should create a valid output configuration from nullish values", () => {
-    const outputConfiguration = OutputConfiguration.parse();
-    expect(outputConfiguration.output).toEqual({
-      container: "mp4",
-      audio: {
-        codec: "aac",
-      },
-      video: {
-        codec: "h264",
-      },
-    });
-  });
-
-  test("should permit mp4 configuration", () => {
-    const outputConfiguration = OutputConfiguration.parse({
-      container: "mp4",
-      video: {
-        codec: "h264",
-      },
-      audio: {
-        codec: "aac",
-      },
-    });
-    expect(outputConfiguration.isVideo).toBe(true);
-  });
-
-  test("should permit png configuration", () => {
-    const outputConfiguration = OutputConfiguration.parse({
-      container: "png",
-      compression: 100,
-      transparency: true,
-    });
-    expect(outputConfiguration.isStill).toBe(true);
-  });
-
-  test("should permit webp configuration", () => {
-    const outputConfiguration = OutputConfiguration.parse({
-      container: "webp",
-      quality: 100,
-      compression: 6,
-      transparency: true,
-    });
-    expect(outputConfiguration.isStill).toBe(true);
-  });
-
-  test("should permit jpeg configuration", () => {
-    const outputConfiguration = OutputConfiguration.parse({
-      container: "jpeg",
-      quality: 100,
-    });
-    expect(outputConfiguration.isStill).toBe(true);
-  });
-});
-
-const createTestRender = () =>
-  ({
-    md5: "test-md5",
-    fps: 30,
-    width: 1920,
-    height: 1080,
-    work_slice_ms: 100,
-    duration_ms: 1000,
-    strategy: "v1",
-  }) as const;