@editframe/api 0.16.4-beta.0 → 0.16.6-beta.0

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

@@ -1,7 +1,6 @@
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
-import { ZodError } from "zod";
 
 import { Client } from "../client.js";
 import { webReadableFromBuffers } from "../readableFromBuffers.js";
@@ -58,19 +57,21 @@ describe("ImageFile", () => {
           width: 100,
           mime_type: "image/jpeg",
         }),
-      ).rejects.toThrowError(
-        new ZodError([
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`
+        [ZodError: [
           {
-            code: "too_big",
-            maximum: 16777216,
-            type: "number",
-            inclusive: true,
-            exact: false,
-            message: "Number must be less than or equal to 16777216",
-            path: ["byte_size"],
-          },
-        ]),
-      );
+            "code": "too_big",
+            "maximum": 16777216,
+            "type": "number",
+            "inclusive": true,
+            "exact": false,
+            "message": "Number must be less than or equal to 16777216",
+            "path": [
+              "byte_size"
+            ]
+          }
+        ]]
+      `);
     });
 
     test("Throws when server returns an error", async () => {

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

@@ -1,7 +1,6 @@
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
-import { ZodError } from "zod";
 
 import { createTestTrack } from "TEST/createTestTrack.js";
 import { Client } from "../client.js";
@@ -29,19 +28,21 @@ describe("ISOBMFF Track", () => {
           client,
           createTestTrack({ byte_size: 1024 * 1024 * 1025 }),
         ),
-      ).rejects.toThrowError(
-        new ZodError([
+      ).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"],
-          },
-        ]),
-      );
+            "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 () => {

package/src/resources/renders.test.ts

@@ -4,7 +4,12 @@ import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 
 import { Client } from "../client.js";
 import { webReadableFromBuffers } from "../readableFromBuffers.js";
-import { createRender, lookupRenderByMd5, uploadRender } from "./renders.js";
+import {
+  OutputConfiguration,
+  createRender,
+  lookupRenderByMd5,
+  uploadRender,
+} from "./renders.js";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -130,6 +135,61 @@ describe("Renders", () => {
   });
 });
 
+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",

package/src/resources/renders.ts

@@ -7,6 +7,49 @@ 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(),
@@ -23,8 +66,83 @@ export const CreateRenderPayload = z.object({
   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;
@@ -35,6 +153,7 @@ export interface CreateRenderPayload {
   duration_ms?: number;
   metadata?: Record<string, string>;
   strategy?: "v1";
+  output?: z.infer<typeof RenderOutputConfiguration>;
 }
 
 assertTypesMatch<CreateRenderPayload, z.infer<typeof CreateRenderPayload>>(
@@ -65,6 +184,16 @@ export const createRender = async (
   // 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),

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

@@ -1,7 +1,6 @@
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
-import { ZodError } from "zod";
 
 import { Client } from "../client.js";
 import { webReadableFromBuffers } from "../readableFromBuffers.js";
@@ -32,19 +31,21 @@ describe("Unprocessed File", () => {
           filename: "test-file",
           byte_size: 1024 * 1024 * 1025,
         }),
-      ).rejects.toThrowError(
-        new ZodError([
+      ).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"],
-          },
-        ]),
-      );
+            "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 () => {