reelkit-cli 0.5.0 → 0.6.0

package/src/testing/conformance.ts

@@ -166,7 +166,7 @@ export function runConformance(name: string, start: (opts: StartOptions) => Prom
         ["an image type for an sfx", { kind: "sfx", contentType: "image/png" }],
         ["zero bytes", { bytes: 0 }],
         ["more than 200 MB", { bytes: MAX_UPLOAD_BYTES + 1 }],
-        ["a component", { kind: "component", filename: "X.tsx", contentType: "text/plain" }],
+        ["a component without a description or an example", { kind: "component", filename: "X.tsx", contentType: "text/plain" }],
       ])("refuses %s with invalid_request", async (_what, over) => {
         const e = await failure((await as("user-up00008"))("libraryUpload", upload(over) as never));
         expect(e.code).toBe("invalid_request");
@@ -182,6 +182,54 @@ export function runConformance(name: string, start: (opts: StartOptions) => Prom
       });
     });
 
+    describe("component uploads", () => {
+      const SOURCE = new TextEncoder().encode('import React from "react";\nexport const ZipBadge: React.FC<{ label: string }> = ({ label }) => <b>{label}</b>;\n');
+      const component = (over: object = {}) => upload({
+        kind: "component", title: "ZipBadge", description: "A small bold badge that shows a label.", tags: ["badge"], meta: { example: '<ZipBadge label="New" />' },
+        filename: "ZipBadge.tsx", contentType: "text/plain", bytes: SOURCE.length, ...over,
+      });
+
+      it("is committed into review, can be pulled by its owner, and is never in search or the public listing", async () => {
+        const mine = await as("user-cmp00001"), other = await as("user-cmp00002");
+        const up = await mine("libraryUpload", component());
+        expect((await put(up.uploadUrl, SOURCE, "text/plain")).ok).toBe(true);
+        const { item } = await mine("libraryCommit", { id: up.id });
+        expect(item).toMatchObject({ id: up.id, kind: "component", visibility: "review" });
+        expect((await mine("librarySearch", { q: "zipbadge badge", kind: "component" })).items.map((i) => i.id)).not.toContain(up.id);
+        expect((await other("librarySearch", { q: "zipbadge badge" })).items.map((i) => i.id)).not.toContain(up.id);
+        expect((await anon("publicLibrary", { q: "zipbadge badge" })).items.map((i) => i.id)).not.toContain(up.id);
+        expect((await mine("me", {})).contributions).toBe(0);
+        expect((await failure(other("libraryPull", { id: up.id }))).code).toBe("not_found");
+      });
+
+      it("refuses at commit a source that fails the static check, with the first problem", async () => {
+        const mine = await as("user-cmp00003");
+        const bad = new TextEncoder().encode('import fs from "node:fs";\nexport const ZipBadge = () => null;\n');
+        const up = await mine("libraryUpload", component({ bytes: bad.length }));
+        await put(up.uploadUrl, bad, "text/plain");
+        const e = await failure(mine("libraryCommit", { id: up.id }));
+        expect(e.code).toBe("invalid_request");
+        expect(e.message).toContain("node:fs");
+        expect((await failure(mine("libraryPull", { id: up.id }))).code).toBe("not_found");
+      });
+
+      it.each([
+        ["a file name that is not PascalCase .tsx", { filename: "zipBadge.tsx" }],
+        ["a file name that is not .tsx", { filename: "ZipBadge.ts" }],
+        ["a content type that is not text/plain", { contentType: "image/png" }],
+        ["more than 64 KB", { bytes: 65_537 }],
+        ["a description under 20 characters", { description: "a badge" }],
+        ["no example", { meta: {} }],
+        ["an example that does not start with the component's name", { meta: { example: '<Other label="x" />' } }],
+        ["an example over 2000 characters", { meta: { example: `<ZipBadge label="${"x".repeat(2000)}" />` } }],
+        ["a component that is not meant to be shared", { shareable: false }],
+      ])("refuses %s with invalid_request", async (_what, over) => {
+        const e = await failure((await as("user-cmp00004"))("libraryUpload", component(over) as never));
+        expect(e.code).toBe("invalid_request");
+        expect(e.message.length).toBeGreaterThan(0);
+      });
+    });
+
     describe("the library", () => {
       it("a seeded published item is found, pulled and downloaded byte for byte", async () => {
         const bytes = new Uint8Array(Array.from({ length: 300 }, (_, i) => i % 251));

package/src/testing/fake-api.ts

@@ -6,6 +6,7 @@ import type { AddressInfo } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { MAX_UPLOAD_BYTES, routes, type ErrorCode, type LibraryItem, type RouteName, type Voice } from "../contract";
+import { staticCheck } from "../render/validate";
 import { PIXEL_PNG, silentWav } from "./fixtures";
 
 type Blob = { filename: string; contentType: string; bytes: Uint8Array };
@@ -23,7 +24,7 @@ const WORD_SEC = 0.4;
 // of long media (music, overlays, clips) and a component's source do not. Any kind with a preview of its own would use that instead
 // (the fake has none).
 const PREVIEW_OF_ORIGINAL: readonly string[] = ["image", "sfx"];
-const MIME_PREFIX: Record<string, string> = { image: "image/", clip: "video/", overlay: "video/", sfx: "audio/", music: "audio/" };
+const MIME_PREFIX: Record<string, string> = { component: "text/plain", image: "image/", clip: "video/", overlay: "video/", sfx: "audio/", music: "audio/" };
 // The device-flow user of the fake is "tester"; anyone else is named from their id, as the API names a user with no profile.
 const handleOf = (userId: string) => (userId === "u-test" ? "tester" : `user-${userId.slice(0, 8)}`);
 const nextMonthStart = (now = new Date()) => new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1));
@@ -190,6 +191,11 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
       const s = store.get(id);
       if (!s || s.owner !== userId) throw new Fail(404, "not_found", `No upload with id ${id}.`);
       if (!s.file) throw new Fail(400, "invalid_request", `Nothing was uploaded for ${id}. Send the file to the upload URL first.`);
+      // A user's component is checked like a pulled one would be, before it is anything but an upload. It stays in review for the owner.
+      if (!s.committed && s.item.kind === "component") {
+        const problem = staticCheck(new TextDecoder().decode(s.file.bytes), s.filename, [])[0];
+        if (problem) throw new Fail(400, "invalid_request", `The component was refused: ${problem}`);
+      }
       // Committing again returns the same item and counts once.
       if (!s.committed) { s.committed = true; usage.uploads++; if (s.item.visibility === "review") meter(userId).uploads++; }
       return { item: s.item };