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

package/src/resources/renders.ts

@@ -1,282 +0,0 @@
-import debug from "debug";
-import { z } from "zod";
-import type { Client } from "../client.js";
-import { CompletionIterator } from "../ProgressIterator.js";
-import { assertTypesMatch } from "../utils/assertTypesMatch.ts";
-
-const log = debug("ef:api:renders");
-
-const H264Configuration = z.object({
-  codec: z.literal("h264"),
-});
-
-const AACConfiguration = z.object({
-  codec: z.literal("aac"),
-});
-
-const MP4Configuration = z.object({
-  container: z.literal("mp4"),
-  video: H264Configuration,
-  audio: AACConfiguration,
-});
-
-const JpegConfiguration = z.object({
-  container: z.literal("jpeg"),
-  quality: z.number().int().min(1).max(100).default(80).optional(),
-});
-
-const PngConfiguration = z.object({
-  container: z.literal("png"),
-  compression: z.number().int().min(1).max(100).default(80).optional(),
-  transparency: z.boolean().default(false).optional(),
-});
-
-const WebpConfiguration = z.object({
-  container: z.literal("webp"),
-  quality: z.number().int().min(1).max(100).default(80).optional(),
-  compression: z.number().int().min(0).max(6).default(4).optional(),
-  transparency: z.boolean().default(false).optional(),
-});
-
-export const RenderOutputConfiguration = z.discriminatedUnion("container", [
-  MP4Configuration,
-  JpegConfiguration,
-  PngConfiguration,
-  WebpConfiguration,
-]);
-
-export type RenderOutputConfiguration = z.infer<
-  typeof RenderOutputConfiguration
->;
-
-export const CreateRenderPayload = z.object({
-  md5: z.string().optional(),
-  fps: z.number().int().min(1).max(120).default(30).optional(),
-  width: z.number().int().min(2).optional(),
-  height: z.number().int().min(2).optional(),
-  work_slice_ms: z
-    .number()
-    .int()
-    .min(1000)
-    .max(10_000)
-    .default(4_000)
-    .optional(),
-  html: z.string().optional(),
-  metadata: z.record(z.string(), z.string()).optional(),
-  duration_ms: z.number().int().optional(),
-  strategy: z.enum(["v1"]).default("v1").optional(),
-  output: RenderOutputConfiguration.default({
-    container: "mp4",
-    video: {
-      codec: "h264",
-    },
-    audio: {
-      codec: "aac",
-    },
-  }).optional(),
-});
-
-export const CreateRenderPayloadWithOutput = CreateRenderPayload.extend({
-  output: RenderOutputConfiguration,
-});
-
-export class OutputConfiguration {
-  static parse(input?: any) {
-    const output = RenderOutputConfiguration.parse(
-      input ?? {
-        container: "mp4",
-        video: {
-          codec: "h264",
-        },
-        audio: {
-          codec: "aac",
-        },
-      },
-    );
-    return new OutputConfiguration(output);
-  }
-
-  constructor(public readonly output: RenderOutputConfiguration) {}
-
-  get isStill() {
-    return (
-      this.output.container === "jpeg" ||
-      this.output.container === "png" ||
-      this.output.container === "webp"
-    );
-  }
-
-  get isVideo() {
-    return this.output.container === "mp4";
-  }
-
-  get fileExtension() {
-    return this.output.container;
-  }
-
-  get contentType() {
-    if (this.isStill) {
-      return `image/${this.fileExtension}`;
-    }
-    return `video/${this.fileExtension}`;
-  }
-
-  get container() {
-    return this.output.container;
-  }
-
-  get jpegConfig() {
-    return this.output.container === "jpeg" ? this.output : null;
-  }
-
-  get pngConfig() {
-    return this.output.container === "png" ? this.output : null;
-  }
-
-  get webpConfig() {
-    return this.output.container === "webp" ? this.output : null;
-  }
-
-  get mp4Config() {
-    return this.output.container === "mp4" ? this.output : null;
-  }
-}
-
-export interface CreateRenderPayload {
-  md5?: string;
-  fps?: number;
-  width?: number;
-  height?: number;
-  work_slice_ms?: number;
-  html?: string;
-  duration_ms?: number;
-  metadata?: Record<string, string>;
-  strategy?: "v1";
-  output?: z.infer<typeof RenderOutputConfiguration>;
-}
-
-assertTypesMatch<CreateRenderPayload, z.infer<typeof CreateRenderPayload>>(
-  true,
-);
-
-export interface CreateRenderResult {
-  id: string;
-  md5: string | null;
-  status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
-  metadata: Record<string, string>;
-}
-
-export interface LookupRenderByMd5Result {
-  id: string;
-  md5: string | null;
-  status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
-  metadata: Record<string, string>;
-}
-
-export const createRender = async (
-  client: Client,
-  payload: CreateRenderPayload,
-) => {
-  log("Creating render", payload);
-  // FIXME: The order of optional/default matters in zod
-  // And if we set the default last, the type is not inferred correctly
-  // Manually applying defaults here is a hack
-  payload.strategy ??= "v1";
-  payload.work_slice_ms ??= 4_000;
-  payload.output ??= {
-    container: "mp4",
-    video: {
-      codec: "h264",
-    },
-    audio: {
-      codec: "aac",
-    },
-  };
-
-  const response = await client.authenticatedFetch("/api/v1/renders", {
-    method: "POST",
-    body: JSON.stringify(payload),
-  });
-
-  log("Render created", response);
-  if (response.ok) {
-    return (await response.json()) as CreateRenderResult;
-  }
-
-  throw new Error(
-    `Failed to create render ${response.status} ${response.statusText} ${await response.text()}`,
-  );
-};
-
-export const uploadRender = async (
-  client: Client,
-  renderId: string,
-  fileStream: ReadableStream,
-) => {
-  log("Uploading render", renderId);
-  const response = await client.authenticatedFetch(
-    `/api/v1/renders/${renderId}/upload`,
-    {
-      method: "POST",
-      body: fileStream,
-      duplex: "half",
-    },
-  );
-
-  if (response.ok) {
-    return response.json();
-  }
-
-  throw new Error(
-    `Failed to upload render ${response.status} ${response.statusText}`,
-  );
-};
-
-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,
-): Promise<LookupRenderByMd5Result | null> => {
-  const response = await client.authenticatedFetch(
-    `/api/v1/renders/md5/${md5}`,
-    {
-      method: "GET",
-    },
-  );
-
-  if (response.ok) {
-    return (await response.json()) as LookupRenderByMd5Result;
-  }
-
-  if (response.status === 404) {
-    return null;
-  }
-
-  throw new Error(
-    `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);
-};
-
-export const downloadRender = async (client: Client, id: string) => {
-  const response = await client.authenticatedFetch(`/api/v1/renders/${id}.mp4`);
-
-  if (response.ok) {
-    return response;
-  }
-
-  throw new Error(
-    `Failed to download render ${id} ${response.status} ${response.statusText}`,
-  );
-};

package/src/resources/test-av-file.txt

@@ -1 +0,0 @@
-test

package/src/resources/transcriptions.test.ts

@@ -1,49 +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 { createTranscription } from "./transcriptions.js";
-
-const server = setupServer();
-const client = new Client("ef_TEST_TOKEN", "http://localhost");
-
-describe("Transcriptions", () => {
-  beforeAll(() => server.listen());
-  afterEach(() => server.resetHandlers());
-  afterAll(() => server.close());
-
-  describe("createTranscription", () => {
-    test("throws if server returns an error", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/transcriptions", () =>
-          HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-
-      await expect(
-        createTranscription(client, { file_id: "test", track_id: 1 }),
-      ).rejects.toThrowError(
-        "Failed to create transcription 500 Internal Server Error",
-      );
-    });
-
-    test("returns json data from the http response", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/transcriptions", () =>
-          HttpResponse.json(
-            { testResponse: "test" },
-            { status: 200, statusText: "OK" },
-          ),
-        ),
-      );
-
-      const response = await createTranscription(client, {
-        file_id: "test",
-        track_id: 1,
-      });
-
-      expect(response).toEqual({ testResponse: "test" });
-    });
-  });
-});

package/src/resources/transcriptions.ts

@@ -1,67 +0,0 @@
-import debug from "debug";
-import { z } from "zod";
-import type { Client } from "../client.js";
-import { CompletionIterator } from "../ProgressIterator.js";
-
-const log = debug("ef:api:transcriptions");
-
-export const CreateTranscriptionPayload = z.object({
-  file_id: z.string(),
-  track_id: z.number().int(),
-});
-
-export type CreateTranscriptionPayload = z.infer<
-  typeof CreateTranscriptionPayload
->;
-
-export interface CreateTranscriptionResult {
-  id: string;
-  status: "complete" | "created" | "failed" | "pending" | "transcribing";
-}
-
-export interface TranscriptionInfoResult {
-  id: string;
-  status: "complete" | "created" | "failed" | "pending" | "transcribing";
-}
-
-export const createTranscription = async (
-  client: Client,
-  payload: CreateTranscriptionPayload,
-) => {
-  log("Creating transcription", payload);
-  const response = await client.authenticatedFetch("/api/v1/transcriptions", {
-    method: "POST",
-    body: JSON.stringify(payload),
-  });
-
-  log("Transcription created", response);
-  if (response.ok) {
-    return (await response.json()) as CreateTranscriptionResult;
-  }
-
-  throw new Error(
-    `Failed to create transcription ${response.status} ${response.statusText}`,
-  );
-};
-
-export const getTranscriptionProgress = async (client: Client, id: string) => {
-  const eventSource = await client.authenticatedEventSource(
-    `/api/v1/transcriptions/${id}/progress`,
-  );
-
-  return new CompletionIterator(eventSource);
-};
-
-export const getTranscriptionInfo = async (client: Client, id: string) => {
-  const response = await client.authenticatedFetch(
-    `/api/v1/transcriptions/${id}`,
-  );
-
-  if (response.ok) {
-    return (await response.json()) as TranscriptionInfoResult;
-  }
-
-  throw new Error(
-    `Failed to get transcription info ${response.status} ${response.statusText}`,
-  );
-};

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

@@ -1,171 +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 {
-  createUnprocessedFile,
-  lookupUnprocessedFileByMd5,
-  uploadUnprocessedReadableStream,
-} from "./unprocessed-file.js";
-
-const server = setupServer();
-const client = new Client("ef_TEST_TOKEN", "http://localhost");
-
-const UploadMustContinue = (id = "test-file") =>
-  http.get(`http://localhost/api/v1/unprocessed_files/${id}/upload`, () =>
-    HttpResponse.json({}, { status: 202 }),
-  );
-
-describe("Unprocessed File", () => {
-  beforeAll(() => server.listen());
-  afterEach(() => server.resetHandlers());
-  afterAll(() => server.close());
-
-  describe("createUnprocessedFile", () => {
-    test("Throws when file is too large", async () => {
-      await expect(
-        createUnprocessedFile(client, {
-          md5: "test-file",
-          filename: "test-file",
-          byte_size: 1024 * 1024 * 1025,
-        }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(`
-        [ZodError: [
-          {
-            "code": "too_big",
-            "maximum": 1073741824,
-            "type": "number",
-            "inclusive": true,
-            "exact": false,
-            "message": "Number must be less than or equal to 1073741824",
-            "path": [
-              "byte_size"
-            ]
-          }
-        ]]
-      `);
-    });
-
-    test("Throws when server returns an error", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/unprocessed_files", () =>
-          HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-
-      await expect(
-        createUnprocessedFile(client, {
-          md5: "test-file",
-          filename: "test-file",
-          byte_size: 1024 * 1024,
-        }),
-      ).rejects.toThrowError(
-        "Failed to create unprocessed file 500 Internal Server Error",
-      );
-    });
-
-    test("Returns json data from the http response", async () => {
-      server.use(
-        http.post("http://localhost/api/v1/unprocessed_files", () =>
-          HttpResponse.json(
-            { testResponse: "test" },
-            { status: 200, statusText: "OK" },
-          ),
-        ),
-      );
-
-      const result = await createUnprocessedFile(client, {
-        md5: "test-file",
-        filename: "test-file",
-        byte_size: 1024 * 1024,
-      });
-
-      expect(result).toEqual({ testResponse: "test" });
-    });
-  });
-
-  describe("uploadUnprocessedFile", () => {
-    test("Throws when server responds with an error", async () => {
-      server.use(
-        UploadMustContinue(),
-        http.post(
-          "http://localhost/api/v1/unprocessed_files/test-file/upload",
-          () => HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-
-      await expect(
-        uploadUnprocessedReadableStream(
-          client,
-          { id: "test-file", byte_size: 4 },
-          webReadableFromBuffers(Buffer.from("test")),
-        ).whenUploaded(),
-      ).rejects.toThrowError(
-        "Failed to upload chunk 0 for /api/v1/unprocessed_files/test-file/upload 500 Internal Server Error",
-      );
-    });
-
-    test("Succeeds when server returns a success", async () => {
-      server.use(
-        UploadMustContinue(),
-        http.post(
-          "http://localhost/api/v1/unprocessed_files/test-file/upload",
-          () => HttpResponse.json({}, { status: 201 }),
-        ),
-      );
-
-      await expect(
-        uploadUnprocessedReadableStream(
-          client,
-          { id: "test-file", byte_size: 4 },
-          webReadableFromBuffers(Buffer.from("test")),
-        ).whenUploaded(),
-      ).resolves.toEqual([
-        { type: "progress", progress: 0 },
-        { type: "progress", progress: 1 },
-      ]);
-    });
-  });
-
-  describe("lookupUnprocessedFileByMd5", () => {
-    test("Returns json data from the http response", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/unprocessed_files/md5/test-md5", () =>
-          HttpResponse.json({ test: "response" }, { status: 200 }),
-        ),
-      );
-
-      const response = await lookupUnprocessedFileByMd5(client, "test-md5");
-
-      expect(response).toEqual({ test: "response" });
-    });
-
-    test("Returns null when file is not found", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/unprocessed_files/md5/test-md5", () =>
-          HttpResponse.json({}, { status: 404 }),
-        ),
-      );
-
-      const response = await lookupUnprocessedFileByMd5(client, "test-md5");
-
-      expect(response).toBeNull();
-    });
-
-    test("Throws when server returns an error", async () => {
-      server.use(
-        http.get("http://localhost/api/v1/unprocessed_files/md5/test-md5", () =>
-          HttpResponse.text("Internal Server Error", { status: 500 }),
-        ),
-      );
-
-      await expect(
-        lookupUnprocessedFileByMd5(client, "test-md5"),
-      ).rejects.toThrowError(
-        "Failed to lookup unprocessed file by md5 test-md5 500 Internal Server Error",
-      );
-    });
-  });
-});

package/src/resources/unprocessed-file.ts

@@ -1,138 +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";
-
-const log = debug("ef:api:unprocessed-file");
-
-const MAX_FILE_SIZE = 1024 * 1024 * 1024; // 1GiB
-
-export const CreateUnprocessedFilePayload = z.object({
-  md5: z.string(),
-  filename: z.string(),
-  byte_size: z.number().int().max(MAX_FILE_SIZE),
-});
-
-export const UpdateUnprocessedFilePayload = z.object({});
-
-export type CreateUnprocessedFilePayload = z.infer<
-  typeof CreateUnprocessedFilePayload
->;
-
-export interface UnprocessedFile {
-  byte_size: number;
-  next_byte: number;
-  complete: boolean;
-  id: string;
-  md5: string;
-}
-
-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 {}
-
-export interface LookupUnprocessedFileByMd5Result extends UnprocessedFile {}
-
-export interface UpdateUnprocessedFileResult extends UnprocessedFile {}
-
-export interface ProcessIsobmffFileResult {
-  id: string;
-}
-
-export const createUnprocessedFile = async (
-  client: Client,
-  payload: CreateUnprocessedFilePayload,
-) => {
-  log("Creating an unprocessed file", payload);
-  CreateUnprocessedFilePayload.parse(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,
-  );
-
-  if (response.ok) {
-    return (await response.json()) as CreateUnprocessedFileResult;
-  }
-
-  throw new Error(
-    `Failed to create unprocessed file ${response.status} ${response.statusText}`,
-  );
-};
-
-export const uploadUnprocessedReadableStream = (
-  client: Client,
-  uploadDetails: UnprocessedFileUploadDetails,
-  fileStream: ReadableStream,
-) => {
-  log("Uploading unprocessed file", uploadDetails.id);
-
-  return uploadChunks(client, {
-    url: `/api/v1/unprocessed_files/${uploadDetails.id}/upload`,
-    fileSize: uploadDetails.byte_size,
-    fileStream,
-    maxSize: MAX_FILE_SIZE,
-  });
-};
-
-export const lookupUnprocessedFileByMd5 = async (
-  client: Client,
-  md5: string,
-): Promise<LookupUnprocessedFileByMd5Result | null> => {
-  const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/md5/${md5}`,
-    {
-      method: "GET",
-    },
-  );
-
-  if (response.ok) {
-    return (await response.json()) as LookupUnprocessedFileByMd5Result;
-  }
-
-  if (response.status === 404) {
-    return null;
-  }
-
-  throw new Error(
-    `Failed to lookup unprocessed file by md5 ${md5} ${response.status} ${response.statusText}`,
-  );
-};
-
-export const processIsobmffFile = async (client: Client, id: string) => {
-  const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${id}/isobmff`,
-    {
-      method: "POST",
-    },
-  );
-
-  if (response.ok) {
-    return (await response.json()) as ProcessIsobmffFileResult;
-  }
-
-  throw new Error(
-    `Failed to process isobmff file ${id} ${response.status} ${response.statusText}`,
-  );
-};