test(config): check settings import laziness in a fresh process

Author: bwachman

scripts/settings-lazy-probe.ts

@@ -0,0 +1,7 @@
+import { schemaMaterializations } from "../src/schema/lazy.js";
+
+const before = schemaMaterializations();
+await import("../src/config/settings.js");
+process.stdout.write(
+  JSON.stringify({ before, afterImport: schemaMaterializations() }),
+);

src/config/settings-lazy.test.ts

@@ -1,17 +1,26 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { expect, test } from "bun:test";
 
-test("importing settings allows a malformed file to fail when read", async () => {
-  const settings = await import("./settings.js");
+const settingsLazinessProbe = join(
+  import.meta.dirname,
+  "../../scripts/settings-lazy-probe.ts",
+);
 
-  const dir = await mkdtemp(join(tmpdir(), "lazy-settings-"));
-  try {
-    const path = join(dir, "settings.json");
-    await writeFile(path, JSON.stringify({ providers: "nope" }));
-    await expect(settings.loadSettings(path)).rejects.toThrow();
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
+test("importing settings does not build schemas", async () => {
+  const child = Bun.spawn([process.execPath, settingsLazinessProbe], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+
+  expect(exitCode, stderr).toBe(0);
+  const materializations = JSON.parse(stdout) as {
+    before: number;
+    afterImport: number;
+  };
+  expect(materializations.afterImport).toBe(materializations.before);
 });

src/schema/lazy.ts

@@ -1,10 +1,18 @@
+let materializations = 0;
+
+/** How many memoized schemas have been built in this process. */
+export function schemaMaterializations(): number {
+  return materializations;
+}
+
 export function memoSchema<T>(build: () => T): () => T {
   let cached: T | undefined;
   let ready = false;
   return () => {
     if (!ready) {
       cached = build();
       ready = true;
+      materializations += 1;
     }
     return cached as T;
   };