@pylonsync/functions 0.22.47 → 0.22.58

package/src/ssr-bucket-serverdata.test.ts

@@ -0,0 +1,167 @@
+// A page with `cache = "auth-bucketed"` is stored as ONE shared entry for
+// every signed-in visitor, so its render must not depend on who rendered it.
+// Safe serverData reads apply the caller's read policies on the host, so their
+// rows depend on the caller: a signed-in render that reads serverData is
+// identity-specific and must not carry the `x-pylon-bucket` proof. Before
+// this check, Alice's render of a page listing "my notes" was stored in the
+// signed-in bucket and served to Bob.
+//
+// Each render runs in a child process (ssr-runtime.ts imports runtime.ts,
+// whose main() owns stdin/stdout). The test plays the host: it answers the
+// child's `db` requests over stdin with the rows the policy would give the
+// render's auth.
+
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const SSR_RUNTIME = join(import.meta.dir, "ssr-runtime.ts");
+const PKG_NODE_MODULES = join(import.meta.dir, "..", "node_modules");
+
+interface Frame {
+  type: string;
+  status?: number;
+  headers?: Record<string, string>;
+  data?: string;
+}
+
+function makeApp(page: string): string {
+  const dir = mkdtempSync(join(tmpdir(), "pylon-bucket-sd-"));
+  mkdirSync(join(dir, "app"), { recursive: true });
+  mkdirSync(join(dir, ".pylon", "client-build"), { recursive: true });
+  symlinkSync(PKG_NODE_MODULES, join(dir, "node_modules"), "dir");
+  writeFileSync(
+    join(dir, "app", "layout.tsx"),
+    `export default function Layout({ children }: any) {
+  return <html><head><title>t</title></head><body>{children}</body></html>;
+}
+`,
+  );
+  writeFileSync(join(dir, "app", "page.tsx"), page);
+  writeFileSync(join(dir, ".pylon", "client-build", "entry.js"), "");
+  writeFileSync(
+    join(dir, ".pylon", "client-build", "manifest.json"),
+    JSON.stringify({
+      outdir: ".pylon/client-build",
+      public_prefix: "/_pylon/build/",
+      routes: { "app/page": { file: "entry.js", imports: [], css: [] } },
+    }),
+  );
+  return dir;
+}
+
+const NOTES_PAGE = `export const cache = "auth-bucketed";
+export const revalidate = 300;
+export default async function Page({ serverData }: any) {
+  const notes = await serverData.list("Note");
+  return <ul>{notes.map((n: any) => <li key={n.id}>{"NOTE:" + n.body}</li>)}</ul>;
+}
+`;
+
+const UNSAFE_NOTES_PAGE = NOTES_PAGE.replace("serverData.list", "serverData.unsafe.list");
+
+/** Rows a `Note` read returns: the caller's own notes (owner policy) for a
+ *  safe read, every note for `serverData.unsafe`. */
+function notesFor(userId: string | null, unsafe: boolean) {
+  const all = [
+    { id: "n1", userId: "alice", body: "alice-secret" },
+    { id: "n2", userId: "bob", body: "bob-secret" },
+  ];
+  return unsafe ? all : all.filter((n) => n.userId === userId);
+}
+
+async function render(dir: string, userId: string | null) {
+  const msg = {
+    type: "render_route",
+    call_id: "c1",
+    component: "app/page",
+    layouts: ["app/layout"],
+    route_path: "/",
+    url: "/",
+    params: {},
+    search_params: {},
+    headers: { host: "app.test" },
+    cookies: {},
+    host: "app.test",
+    session_present: userId != null,
+    auth: { user_id: userId, is_admin: false, tenant_id: null, roles: [] },
+  };
+  const probe = `
+import { handleRenderRoute } from ${JSON.stringify(SSR_RUNTIME)};
+const frames = [];
+await handleRenderRoute(${JSON.stringify(msg)}, (m) => frames.push(m));
+console.error("FRAMES " + JSON.stringify(frames));
+setTimeout(() => process.exit(0), 50);
+`;
+  const probePath = join(dir, `probe-${Math.random().toString(36).slice(2)}.ts`);
+  writeFileSync(probePath, probe);
+  const proc = Bun.spawn(["bun", "run", probePath], {
+    cwd: dir,
+    env: { ...process.env, PYLON_DEV_MODE: "0" },
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  // Answer the child's db requests the way the host would.
+  const answerDb = (async () => {
+    const decoder = new TextDecoder();
+    let buf = "";
+    for await (const chunk of proc.stdout) {
+      buf += decoder.decode(chunk);
+      let nl: number;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        let m: any;
+        try {
+          m = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (m.type !== "db") continue;
+        const data = m.entity === "Note" ? notesFor(userId, m.unsafe_op === true) : [];
+        proc.stdin.write(
+          JSON.stringify({ type: "result", call_id: m.call_id, op_id: m.op_id, data }) + "\n",
+        );
+        proc.stdin.flush();
+      }
+    }
+  })();
+  const err = await new Response(proc.stderr).text();
+  const code = await proc.exited;
+  await answerDb;
+  const line = err.split("\n").find((l) => l.includes("FRAMES "));
+  if (code !== 0 || !line) throw new Error(`probe failed (exit ${code})\nstderr: ${err}`);
+  const frames = JSON.parse(line.slice(line.indexOf("FRAMES ") + "FRAMES ".length)) as Frame[];
+  const html = frames
+    .filter((f) => f.type === "render_chunk")
+    .map((f) => Buffer.from(f.data!, "base64").toString("utf8"))
+    .join("");
+  const start = frames.find((f) => f.type === "response_start");
+  return { html, headers: start?.headers ?? {} };
+}
+
+test("a signed-in render that reads serverData is not stored in the shared bucket", async () => {
+  const dir = makeApp(NOTES_PAGE);
+  const alice = await render(dir, "alice");
+  expect(alice.html).toContain("NOTE:alice-secret");
+  // The proof the host needs to store this render under the signed-in
+  // bucket, where Bob's request would read it.
+  expect(alice.headers["x-pylon-bucket"]).toBeUndefined();
+});
+
+test("an anonymous render that reads serverData stays bucketable", async () => {
+  // Every anonymous visitor gets the same rows, so the signed-out entry is safe.
+  const dir = makeApp(NOTES_PAGE);
+  const anon = await render(dir, null);
+  expect(anon.html).not.toContain("NOTE:");
+  expect(anon.headers["x-pylon-bucket"]).toBe("300");
+});
+
+test("serverData.unsafe reads do not depend on the caller and stay bucketable", async () => {
+  const dir = makeApp(UNSAFE_NOTES_PAGE);
+  const signedIn = await render(dir, "alice");
+  expect(signedIn.html).toContain("NOTE:bob-secret");
+  expect(signedIn.headers["x-pylon-bucket"]).toBe("300");
+});

package/src/ssr-client-bundler.test.ts

@@ -909,3 +909,226 @@ describe("client router popstate", () => {
     expect(src.match(/renderedPath = location\.pathname \+ location\.search;/g)?.length).toBeGreaterThanOrEqual(3);
   });
 });
+
+describe("offline service worker (buildManifest({ offline }))", () => {
+  test("an offline app's build writes pylon-sw.js with each offline route's files", async () => {
+    tempDir = makeFixture(
+      {
+        "page.tsx": PAGE_BODY("Home"),
+        "leads/page.tsx": PAGE_BODY("Leads"),
+        "leads/[id]/page.tsx": PAGE_BODY("Lead"),
+        "settings/page.tsx": PAGE_BODY("Settings"),
+      },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    fs.writeFileSync(
+      path.join(tempDir, "pylon.manifest.json"),
+      JSON.stringify({
+        offline: {
+          name: "Field Sales",
+          icons: [{ src: "/icons/192.png", sizes: "192x192" }],
+          startUrl: "/leads",
+          display: "standalone",
+          routes: ["/leads", "/leads/[id]"],
+        },
+      }),
+    );
+    originalCwd = process.cwd();
+    process.chdir(tempDir);
+
+    const { manifestPath, outdir } = await buildClientBundle();
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    expect(manifest.offline?.routes).toEqual(["/leads", "/leads/[id]"]);
+    expect(manifest.offline?.version).toMatch(/^[0-9a-f]{16}$/);
+
+    const sw = fs.readFileSync(path.join(outdir, "pylon-sw.js"), "utf8");
+    // Valid script (compiled, not run).
+    const { Script } = await import("node:vm");
+    expect(() => new Script(sw)).not.toThrow();
+    const config = JSON.parse(sw.slice(sw.indexOf(")(self, ") + 8, sw.lastIndexOf(", function")));
+    expect(config.version).toBe(manifest.offline!.version);
+    expect(config.shells).toEqual(["/leads"]);
+    const prefix = manifest.public_prefix;
+    for (const component of ["app/leads/page", "app/leads/[id]/page"]) {
+      expect(config.precache).toContain(prefix + manifest.routes[component].file);
+    }
+    // Not an offline route: its entry is not precached.
+    expect(config.precache).not.toContain(prefix + manifest.routes["app/settings/page"].file);
+    expect(config.precache).toContain("/icons/192.png");
+
+    // `/_pylon/version` serves this file.
+    const versionFile = JSON.parse(fs.readFileSync(path.join(outdir, "pylon-version.json"), "utf8"));
+    expect(versionFile.version).toBe(manifest.offline!.version);
+    expect(versionFile.builtAt).toBe(manifest.offline!.builtAt);
+    expect(Number.isNaN(Date.parse(versionFile.builtAt))).toBe(false);
+    expect(versionFile.install).toMatch(/^[0-9a-f]{16}$/);
+
+    // The same build gives the same version: no reinstall per boot.
+    const again = await buildClientBundle();
+    const second = JSON.parse(fs.readFileSync(again.manifestPath, "utf8")) as PylonBundleManifest;
+    expect(second.offline?.version).toBe(manifest.offline!.version);
+  });
+
+  test("a change to the app's name or icon changes the version and the install identity", async () => {
+    const dir = makeFixture(
+      { "page.tsx": PAGE_BODY("Home"), "leads/page.tsx": PAGE_BODY("Leads") },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    tempDir = dir;
+    const offline = {
+      name: "Field Sales",
+      icons: [{ src: "/icons/192.png", sizes: "192x192" }],
+      startUrl: "/leads",
+      display: "standalone",
+      routes: ["/leads"],
+    };
+    const writeManifest = (o: object) =>
+      fs.writeFileSync(path.join(dir, "pylon.manifest.json"), JSON.stringify({ offline: o }));
+    fs.mkdirSync(path.join(dir, "public", "icons"), { recursive: true });
+    fs.writeFileSync(path.join(dir, "public", "icons", "192.png"), "icon-a");
+    writeManifest(offline);
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const read = async () => {
+      const { outdir } = await buildClientBundle();
+      return JSON.parse(fs.readFileSync(path.join(outdir, "pylon-version.json"), "utf8"));
+    };
+    const base = await read();
+
+    // New icon bytes at the same URL.
+    fs.writeFileSync(path.join(dir, "public", "icons", "192.png"), "icon-b");
+    const icon = await read();
+    expect(icon.install).not.toBe(base.install);
+    expect(icon.version).not.toBe(base.version);
+
+    // A new name.
+    writeManifest({ ...offline, name: "Veritas" });
+    const named = await read();
+    expect(named.install).not.toBe(icon.install);
+
+    // The app's own manifest file wins over the config.
+    fs.writeFileSync(
+      path.join(dir, "public", "manifest.webmanifest"),
+      JSON.stringify({ name: "Own", display: "standalone", icons: [] }),
+    );
+    const own = await read();
+    expect(own.install).not.toBe(named.install);
+    // A field iOS does not read at install (theme color) changes nothing.
+    fs.writeFileSync(
+      path.join(dir, "public", "manifest.webmanifest"),
+      JSON.stringify({ name: "Own", display: "standalone", icons: [], theme_color: "#000" }),
+    );
+    expect((await read()).install).toBe(own.install);
+  });
+
+  test("an app without offline gets no worker", async () => {
+    tempDir = makeFixture({ "page.tsx": PAGE_BODY("Home") }, { "layout.tsx": LAYOUT_BODY });
+    originalCwd = process.cwd();
+    process.chdir(tempDir);
+    const { manifestPath, outdir } = await buildClientBundle();
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    expect(manifest.offline).toBeUndefined();
+    expect(fs.existsSync(path.join(outdir, "pylon-sw.js"))).toBe(false);
+  });
+});
+
+describe("instant navigation (export const navigation = \"client\")", () => {
+  test("the manifest marks the page, and its entry passes the static metadata", async () => {
+    const dir = makeFixture(
+      {
+        "page.tsx": PAGE_BODY("Home"),
+        "leads/page.tsx":
+          `export const navigation = "client";\nexport const metadata = { title: "Leads" };\n` +
+          PAGE_BODY("Leads"),
+        "reports/page.tsx": PAGE_BODY("Reports"),
+      },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    tempDir = dir;
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const { manifestPath, outdir } = await buildClientBundle();
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    expect(manifest.routes["app/leads/page"].navigation).toBe("client");
+    expect(manifest.routes["app/reports/page"].navigation).toBeUndefined();
+    expect(manifest.routes["app/page"].navigation).toBeUndefined();
+
+    // The built client code carries the title for the runtime; a page without
+    // static metadata imports none.
+    const code = (component: string) => {
+      const r = manifest.routes[component];
+      return [r.file, ...r.imports]
+        .map((f) => fs.readFileSync(path.join(outdir, f), "utf8"))
+        .join("\n");
+    };
+    expect(code("app/leads/page")).toMatch(/title:\s*"Leads"/);
+  });
+});
+
+describe("precompressed build files", () => {
+  test("a production build writes .br and .gz copies of its chunks; precompress: false does not", async () => {
+    const dir = makeFixture({ "page.tsx": PAGE_BODY("Home") }, { "layout.tsx": LAYOUT_BODY });
+    tempDir = dir;
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const { manifestPath, outdir } = await _doBuildInner(fs, path, dir, "app", { precompress: true });
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    const route = manifest.routes["app/page"];
+    // The shared chunk holds React: large, and compressed.
+    const shared = route.imports
+      .map((f) => path.join(outdir, f))
+      .sort((a, b) => fs.statSync(b).size - fs.statSync(a).size)[0];
+    expect(fs.existsSync(shared + ".br")).toBe(true);
+    expect(fs.existsSync(shared + ".gz")).toBe(true);
+    expect(fs.statSync(shared + ".br").size).toBeLessThan(fs.statSync(shared).size / 2);
+
+    const again = await _doBuildInner(fs, path, dir, "app", { precompress: false });
+    const files = fs.readdirSync(again.outdir, { recursive: true }) as string[];
+    expect(files.filter((f) => f.endsWith(".br") || f.endsWith(".gz"))).toEqual([]);
+  });
+});
+
+describe("namespace barrels (radix-ui)", () => {
+  test("a route bundles only the barrel packages it imports", async () => {
+    const dir = makeFixture(
+      {
+        "alpha/page.tsx": `import { Alpha } from "fake-ui";\nexport default function P() { return <div>{Alpha.name}</div>; }\n`,
+        "beta/page.tsx": `import { Beta as B } from "fake-ui";\nexport default function P() { return <div>{B.name}</div>; }\n`,
+      },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    tempDir = dir;
+    // A barrel and the two packages it re-exports, resolvable from app/.
+    const nm = path.join(dir, "app", "node_modules");
+    const pkg = (name: string, files: Record<string, string>) => {
+      fs.mkdirSync(path.join(nm, name), { recursive: true });
+      for (const [f, body] of Object.entries(files)) fs.writeFileSync(path.join(nm, name, f), body);
+    };
+    pkg("fake-ui", {
+      "package.json": JSON.stringify({ name: "fake-ui", module: "index.mjs", main: "index.mjs", sideEffects: false }),
+      "index.mjs": `import * as Alpha from "@fake/alpha";\nimport * as Beta from "@fake/beta";\nexport { Alpha, Beta };\n`,
+    });
+    for (const [name, marker] of [["alpha", "ALPHA_ONLY_CODE"], ["beta", "BETA_ONLY_CODE"]]) {
+      pkg(`@fake/${name}`, {
+        "package.json": JSON.stringify({ name: `@fake/${name}`, module: "index.mjs", main: "index.mjs", sideEffects: false }),
+        "index.mjs": `export const name = ${JSON.stringify(marker + " " + "x".repeat(2000))};\n`,
+      });
+    }
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const { manifestPath, outdir } = await _doBuildInner(fs, path, dir, "app", { precompress: false });
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    const code = (component: string) => {
+      const r = manifest.routes[component];
+      return [r.file, ...r.imports].map((f) => fs.readFileSync(path.join(outdir, f), "utf8")).join("\n");
+    };
+    expect(code("app/alpha/page")).toContain("ALPHA_ONLY_CODE");
+    expect(code("app/alpha/page")).not.toContain("BETA_ONLY_CODE");
+    expect(code("app/beta/page")).toContain("BETA_ONLY_CODE");
+    expect(code("app/beta/page")).not.toContain("ALPHA_ONLY_CODE");
+  });
+});