@jant/core 0.6.16 → 0.7.1

package/src/node/__tests__/cli-reset-password.test.ts

@@ -7,17 +7,23 @@ import { run } from "../../../bin/commands/reset-password.js";
 import { migrate } from "../runtime.js";
 import type { Bindings } from "../../types.js";
 import { createBootstrapService } from "../../services/bootstrap.js";
+import { createSiteService } from "../../services/site.js";
 import { createNodeDatabase } from "../../db/index.js";
 
 describe("jant reset-password", () => {
   const tempDirs: string[] = [];
-  const originalEnv = process.env.DATABASE_URL;
+  const originalEnv = {
+    DATABASE_URL: process.env.DATABASE_URL,
+    SITE_RESOLUTION_MODE: process.env.SITE_RESOLUTION_MODE,
+  };
 
   afterEach(async () => {
-    if (originalEnv === undefined) {
-      delete process.env.DATABASE_URL;
-    } else {
-      process.env.DATABASE_URL = originalEnv;
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
     }
 
     await Promise.all(
@@ -37,7 +43,14 @@ describe("jant reset-password", () => {
 
     const sqlite = new Database(databasePath);
     try {
-      const bootstrap = createBootstrapService(createNodeDatabase(sqlite));
+      const db = createNodeDatabase(sqlite);
+      // Each setup screen is its own request, bound to the site it resolved:
+      // none before the account step, the one it created after.
+      const bootstrapForRequest = async () =>
+        createBootstrapService(
+          db,
+          (await createSiteService(db).resolveSingleSite()).site.id,
+        );
       await sqlite
         .prepare(
           `
@@ -53,10 +66,17 @@ describe("jant reset-password", () => {
           new Date().toISOString(),
           new Date().toISOString(),
         );
-      await bootstrap.completeInitialSetup({
+      await (
+        await bootstrapForRequest()
+      ).provisionOwnerAccount({
         ownerUserId: "usr_reset_password_test",
-        siteName: "Reset Password Test",
       });
+      await (
+        await bootstrapForRequest()
+      ).completeSiteSetup(
+        { siteName: "Reset Password Test" },
+        { oldLanguage: "" },
+      );
     } finally {
       sqlite.close();
     }
@@ -88,4 +108,57 @@ describe("jant reset-password", () => {
       expect.stringMatching(/^Visit: \/reset\?token=[a-f0-9]{64}$/),
     );
   });
+
+  // A hosted database holds every tenant, so the token goes to the site the
+  // operator named — and nowhere when they named none.
+  it("writes the token to the site --site names on a host-based database", async () => {
+    const root = await mkdtemp(join(tmpdir(), "jant-reset-password-hosted-"));
+    tempDirs.push(root);
+
+    const databasePath = join(root, "jant.sqlite");
+    await migrate({ DATABASE_URL: `file:${databasePath}` } as Bindings);
+    process.env.DATABASE_URL = `file:${databasePath}`;
+    process.env.SITE_RESOLUTION_MODE = "host-based";
+
+    const sqlite = new Database(databasePath);
+    try {
+      sqlite
+        .prepare(
+          `
+            INSERT INTO site (id, key, status, created_at, updated_at)
+            VALUES
+              ('sit_alpha000000000000000000000', 'alpha', 'active', 1774200000, 1774200000),
+              ('sit_beta0000000000000000000000', 'beta', 'active', 1774200001, 1774200001)
+          `,
+        )
+        .run();
+    } finally {
+      sqlite.close();
+    }
+
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(run([])).rejects.toThrow(
+      "host-based mode needs a target site. Pass --site <key|id>, --host <host>, or --url <url>.",
+    );
+    await run(["--site", "beta"]);
+
+    const sqliteReadonly = new Database(databasePath, { readonly: true });
+    try {
+      const owners = sqliteReadonly
+        .prepare(
+          `
+            SELECT site_id
+            FROM "site_setting"
+            WHERE "key" = 'PASSWORD_RESET_TOKEN'
+          `,
+        )
+        .pluck()
+        .all();
+
+      expect(owners).toEqual(["sit_beta0000000000000000000000"]);
+    } finally {
+      sqliteReadonly.close();
+    }
+  });
 });

package/src/node/__tests__/cli-runtime-target.test.ts

@@ -2,7 +2,7 @@ import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { loadNodeEnvFile } from "../../../bin/lib/node-env.js";
+import { findNodeEnvPath, loadNodeEnvFile } from "../../../bin/lib/node-env.js";
 import {
   formatRuntimeBanner,
   resolveCliRuntime,
@@ -106,6 +106,53 @@ describe("loadNodeEnvFile", () => {
   });
 });
 
+describe("findNodeEnvPath", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "jant-env-path-"));
+  });
+
+  it("finds .env.node in the given directory when JANT_ENV_FILE is unset", () => {
+    const envPath = join(tmpDir, ".env.node");
+    writeFileSync(envPath, "DATABASE_URL=file:./jant.sqlite\n");
+
+    expect(findNodeEnvPath(tmpDir, {})).toBe(envPath);
+  });
+
+  it("loads nothing when JANT_ENV_FILE is empty", () => {
+    writeFileSync(
+      join(tmpDir, ".env.node"),
+      "DATABASE_URL=file:./local.sqlite\n",
+    );
+
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "" })).toBeNull();
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "  " })).toBeNull();
+  });
+
+  it("uses the file JANT_ENV_FILE names, resolved against the directory", () => {
+    writeFileSync(
+      join(tmpDir, ".env.node"),
+      "DATABASE_URL=file:./local.sqlite\n",
+    );
+    const overridePath = join(tmpDir, "staging.env");
+    writeFileSync(overridePath, "DATABASE_URL=postgres://example/db\n");
+
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "staging.env" })).toBe(
+      overridePath,
+    );
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: overridePath })).toBe(
+      overridePath,
+    );
+  });
+
+  it("throws when JANT_ENV_FILE names a file that does not exist", () => {
+    expect(() =>
+      findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "missing.env" }),
+    ).toThrow(/JANT_ENV_FILE points at "missing.env"/);
+  });
+});
+
 describe("formatRuntimeBanner", () => {
   const originalLog = console.log;
   beforeEach(() => {

package/src/node/__tests__/cli-setup.test.ts

@@ -0,0 +1,163 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import Database from "better-sqlite3";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { run } from "../../../bin/commands/setup.js";
+import { verifyPassword } from "../../lib/password.js";
+import type { Bindings } from "../../types.js";
+import { migrate } from "../runtime.js";
+
+const SITE_ID = "sit_01kn8jq3t4famtyg9hjd074ckr";
+const ENV_KEYS = [
+  "DATABASE_URL",
+  "DATA_DIR",
+  "SITE_ORIGIN",
+  "SITE_RESOLUTION_MODE",
+] as const;
+
+function pipe(text: string) {
+  return { stdin: Readable.from([text]) };
+}
+
+describe("jant setup", () => {
+  const originalEnv = Object.fromEntries(
+    ENV_KEYS.map((key) => [key, process.env[key]]),
+  );
+  let root: string;
+  let databasePath: string;
+
+  beforeEach(async () => {
+    for (const key of ENV_KEYS) delete process.env[key];
+    root = await mkdtemp(join(tmpdir(), "jant-setup-"));
+    databasePath = join(root, "jant.sqlite");
+    await migrate({ DATABASE_URL: `file:${databasePath}` } as Bindings);
+    process.env.DATABASE_URL = `file:${databasePath}`;
+    vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(async () => {
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    await rm(root, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function readDatabase<T>(read: (sqlite: Database.Database) => T): T {
+    const sqlite = new Database(databasePath, { readonly: true });
+    try {
+      return read(sqlite);
+    } finally {
+      sqlite.close();
+    }
+  }
+
+  it("sets up the install with the piped password", async () => {
+    process.env.SITE_ORIGIN = "https://notes.example.com";
+
+    const result = await run(
+      [
+        "--email",
+        "Owner@Example.com",
+        "--password-stdin",
+        "--site-id",
+        SITE_ID,
+        "--site-name",
+        "Field Notes",
+      ],
+      // `echo` ends the password with a line break that is not part of it.
+      pipe("correct horse\n"),
+    );
+
+    expect(result).toEqual({ outcome: "created", siteId: SITE_ID });
+    expect(console.log).toHaveBeenCalledWith(`Set up site ${SITE_ID}.`);
+
+    const stored = readDatabase((sqlite) => ({
+      email: sqlite.prepare('SELECT email FROM "user"').pluck().get(),
+      hash: sqlite.prepare('SELECT password FROM "account"').pluck().get(),
+      host: sqlite.prepare('SELECT host FROM "site_domain"').pluck().get(),
+      status: sqlite
+        .prepare(
+          `SELECT value FROM "site_setting" WHERE "key" = 'ONBOARDING_STATUS'`,
+        )
+        .pluck()
+        .get(),
+    }));
+    expect(stored).toMatchObject({
+      email: "owner@example.com",
+      host: "notes.example.com",
+      status: "completed",
+    });
+    expect(
+      await verifyPassword({
+        hash: String(stored.hash),
+        password: "correct horse",
+      }),
+    ).toBe(true);
+  });
+
+  it("changes nothing when run again", async () => {
+    const args = ["--email", "owner@example.com", "--password-stdin"];
+    const first = await run(args, pipe("correct horse"));
+    const second = await run(args, pipe("a different password"));
+
+    expect(second).toEqual({
+      outcome: "already-set-up",
+      siteId: first.siteId,
+    });
+    expect(console.log).toHaveBeenLastCalledWith(
+      `Site ${first.siteId} was already set up. Nothing changed.`,
+    );
+  });
+
+  it("refuses a password passed any way but standard input", async () => {
+    await expect(
+      run(["--email", "owner@example.com"], pipe("correct horse")),
+    ).rejects.toThrow("Pass --password-stdin");
+  });
+
+  it("refuses to wait on a terminal for the password", async () => {
+    const stdin = Object.assign(Readable.from([]), { isTTY: true });
+
+    await expect(
+      run(["--email", "owner@example.com", "--password-stdin"], { stdin }),
+    ).rejects.toThrow("reads the password from a pipe");
+  });
+
+  it("rejects answers the setup screens would reject", async () => {
+    const args = ["--email", "owner@example.com", "--password-stdin"];
+
+    await expect(run(args, pipe("short"))).rejects.toThrow(
+      "Password must be at least 8 characters",
+    );
+    await expect(
+      run(
+        [...args, "--site-id", "pst_01kn8jq3t4famtyg9hjd074ckr"],
+        pipe("correct horse"),
+      ),
+    ).rejects.toThrow("Invalid ID");
+    await expect(
+      run([...args, "--time-zone", "Mars/Olympus"], pipe("correct horse")),
+    ).rejects.toThrow("Choose a valid time zone.");
+
+    expect(
+      readDatabase((sqlite) =>
+        sqlite.prepare('SELECT COUNT(*) FROM "user"').pluck().get(),
+      ),
+    ).toBe(0);
+  });
+
+  it("refuses to run without a Node database", async () => {
+    delete process.env.DATABASE_URL;
+
+    await expect(
+      run(
+        ["--email", "owner@example.com", "--password-stdin"],
+        pipe("correct horse"),
+      ),
+    ).rejects.toThrow("jant setup runs against a Node database");
+  });
+});

package/src/node/__tests__/cli-site-selection.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
-import { resolveCliSite } from "../../../bin/lib/site-selection.js";
+import {
+  parseCliSiteSelector,
+  resolveCliSite,
+} from "../../../bin/lib/site-selection.js";
 
 function createSiteRow(id, key) {
   return {
@@ -11,6 +14,8 @@ function createSiteRow(id, key) {
   };
 }
 
+const HOST_BASED_ENV = { SITE_RESOLUTION_MODE: "host-based" };
+
 describe("CLI site selection", () => {
   it("resolves a host-scoped site in host-based mode", async () => {
     const query = vi.fn(async (sql) => {
@@ -26,9 +31,7 @@ describe("CLI site selection", () => {
         query,
       },
       {
-        env: {
-          SITE_RESOLUTION_MODE: "host-based",
-        },
+        env: HOST_BASED_ENV,
         host: "demo.jant.blog",
       },
     );
@@ -54,9 +57,7 @@ describe("CLI site selection", () => {
         query,
       },
       {
-        env: {
-          SITE_RESOLUTION_MODE: "host-based",
-        },
+        env: HOST_BASED_ENV,
         url: "https://demo.jant.blog/base/",
       },
     );
@@ -64,49 +65,91 @@ describe("CLI site selection", () => {
     expect(resolved.site.key).toBe("demo");
   });
 
-  it("falls back to the only site in host-based mode", async () => {
-    const query = vi.fn(async (sql) => {
-      if (sql.includes('FROM "site_domain"')) {
-        return [];
-      }
-
-      return [createSiteRow("sit_only", "only")];
-    });
+  it("resolves --site by key or by id", async () => {
+    const sites = [
+      createSiteRow("sit_one", "one"),
+      createSiteRow("sit_two", "two"),
+    ];
+    const query = vi.fn(async (sql) =>
+      sites.filter(
+        (site) =>
+          sql.includes(`"id" = '${site.id}'`) ||
+          sql.includes(`"key" = '${site.key}'`),
+      ),
+    );
 
-    const resolved = await resolveCliSite(
-      {
-        query,
-      },
-      {
-        env: {
-          SITE_RESOLUTION_MODE: "host-based",
-        },
-      },
+    const byKey = await resolveCliSite(
+      { query },
+      { env: HOST_BASED_ENV, site: "two" },
+    );
+    const byId = await resolveCliSite(
+      { query },
+      { env: HOST_BASED_ENV, site: "sit_one" },
     );
 
-    expect(resolved.site.id).toBe("sit_only");
+    expect(byKey.site.id).toBe("sit_two");
+    expect(byId.site.id).toBe("sit_one");
   });
 
-  it("requires explicit selection for host-based multi-site instances", async () => {
+  // Unreachable through the managed API, whose keys cannot contain `_`, but a
+  // hand-edited row must not make `--site` pick a tenant by accident.
+  it("prefers the id match when a key equals another site's id", async () => {
     const query = vi.fn(async () => [
-      createSiteRow("sit_one", "one"),
-      createSiteRow("sit_two", "two"),
+      createSiteRow("sit_other", "sit_target"),
+      createSiteRow("sit_target", "target"),
     ]);
 
+    const resolved = await resolveCliSite(
+      { query },
+      { env: HOST_BASED_ENV, site: "sit_target" },
+    );
+
+    expect(resolved.site.key).toBe("target");
+  });
+
+  it("names the --site value that matched nothing", async () => {
+    const query = vi.fn(async () => []);
+
+    await expect(
+      resolveCliSite({ query }, { env: HOST_BASED_ENV, site: "missing" }),
+    ).rejects.toThrow("No site found for --site missing.");
+  });
+
+  // A hosted database holds every tenant. Falling back to "the only site"
+  // would work until the day a second tenant signs up, so host-based mode
+  // never guesses — it fails before running a single query.
+  it("requires a site flag in host-based mode, however many sites exist", async () => {
+    const query = vi.fn(async () => [createSiteRow("sit_only", "only")]);
+
+    await expect(
+      resolveCliSite({ query }, { env: HOST_BASED_ENV }),
+    ).rejects.toThrow(
+      "host-based mode needs a target site. Pass --site <key|id>, --host <host>, or --url <url>.",
+    );
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it("rejects more than one site flag instead of picking one", async () => {
+    const query = vi.fn(async () => []);
+
     await expect(
       resolveCliSite(
-        {
-          query,
-        },
-        {
-          env: {
-            SITE_RESOLUTION_MODE: "host-based",
-          },
-        },
+        { query },
+        { env: HOST_BASED_ENV, site: "one", host: "two.jant.blog" },
       ),
-    ).rejects.toThrow(
-      "host-based mode requires --site, --host, or --url when the database contains multiple sites.",
+    ).rejects.toThrow("Choose only one of --site, --host, or --url.");
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it("uses the only site in single-site mode", async () => {
+    const query = vi.fn(async () => [createSiteRow("sit_only", "only")]);
+
+    const resolved = await resolveCliSite(
+      { query },
+      { env: { SITE_RESOLUTION_MODE: "single-site" } },
     );
+
+    expect(resolved.site.id).toBe("sit_only");
   });
 
   it("returns an actionable message for single-site multi-site instances", async () => {
@@ -131,3 +174,50 @@ describe("CLI site selection", () => {
     );
   });
 });
+
+describe("parseCliSiteSelector", () => {
+  it("returns null when no site flag was passed", () => {
+    expect(parseCliSiteSelector({ pathPrefix: "/blog" })).toBeNull();
+  });
+
+  it("reads --site as a key or id", () => {
+    expect(parseCliSiteSelector({ site: " demo " })).toEqual({
+      kind: "site",
+      idOrKey: "demo",
+    });
+  });
+
+  it("splits --url into its host and path prefix", () => {
+    expect(parseCliSiteSelector({ url: "https://demo.jant.blog/" })).toEqual({
+      kind: "host",
+      host: "demo.jant.blog",
+      pathPrefix: null,
+    });
+    expect(
+      parseCliSiteSelector({ url: "https://demo.jant.blog/blog/" }),
+    ).toEqual({
+      kind: "host",
+      host: "demo.jant.blog",
+      pathPrefix: "/blog",
+    });
+  });
+
+  it("pairs --host with --path-prefix", () => {
+    expect(
+      parseCliSiteSelector({ host: "demo.jant.blog", pathPrefix: "blog/" }),
+    ).toEqual({
+      kind: "host",
+      host: "demo.jant.blog",
+      pathPrefix: "/blog",
+    });
+  });
+
+  it("rejects --url together with --host", () => {
+    expect(() =>
+      parseCliSiteSelector({
+        host: "demo.jant.blog",
+        url: "https://demo.jant.blog/",
+      }),
+    ).toThrow("Choose only one of --site, --host, or --url.");
+  });
+});

package/src/node/__tests__/cli-site-snapshot.test.ts

@@ -780,6 +780,73 @@ describe("jant site snapshot export/import", () => {
     expect(await targetStorage.get(SNAPSHOT_MEDIA_KEY)).not.toBeNull();
   });
 
+  // The snapshot was exported where the bytes lived in R2; this import puts
+  // them in local storage. Rows left saying `r2` would look for R2_PUBLIC_URL,
+  // miss the avatar's existing row on replacement, and never purge their trash.
+  it("records imported media under the storage the import wrote it to", async () => {
+    const root = await mkdtemp(join(tmpdir(), "jant-site-snapshot-provider-"));
+    tempDirs.push(root);
+
+    const targetDbPath = join(root, "target.sqlite");
+    const targetStoragePath = join(root, "target-media");
+    const snapshotPath = join(root, "snapshot");
+
+    await migrate({ DATABASE_URL: `file:${targetDbPath}` } as Bindings);
+    const targetSqlite = new Database(targetDbPath);
+    try {
+      targetSqlite.exec(`
+        INSERT INTO "site" ("id", "key", "status", "created_at", "updated_at")
+        VALUES ('${SNAPSHOT_SITE_ID}', '${SNAPSHOT_SITE_KEY}', 'active', 1774009000, 1774009000);
+      `);
+    } finally {
+      targetSqlite.close();
+    }
+
+    await mkdir(
+      join(snapshotPath, "objects", "media", SNAPSHOT_SITE_ID, "files"),
+      {
+        recursive: true,
+      },
+    );
+    await writeFile(join(snapshotPath, "objects", SNAPSHOT_MEDIA_KEY), "png");
+    await writeFile(
+      join(snapshotPath, "meta.json"),
+      JSON.stringify({
+        format: "jant-site-snapshot",
+        version: 2,
+        dialect: "sqlite",
+        site: { id: SNAPSHOT_SITE_ID, key: SNAPSHOT_SITE_KEY },
+      }),
+    );
+    await writeFile(
+      join(snapshotPath, "db.sql"),
+      `INSERT INTO "media" ("id", "site_id", "post_id", "filename", "original_name", "mime_type", "size", "storage_key", "provider", "position", "media_kind", "created_at", "updated_at") VALUES('${SNAPSHOT_MEDIA_ID}', '${SNAPSHOT_SITE_ID}', NULL, '${SNAPSHOT_MEDIA_ID}.png', 'sample.png', 'image/png', 3, '${SNAPSHOT_MEDIA_KEY}', 'r2', 'a0', 'image', 1774009200, 1774009200);\n`,
+    );
+
+    useLocalSnapshotRuntime(`file:${targetDbPath}`, targetStoragePath);
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    const { run: runImport } =
+      await import("../../../bin/commands/site/snapshot/import.js");
+    await runImport(["--path", snapshotPath, "--replace"]);
+
+    const verifySqlite = new Database(targetDbPath, { readonly: true });
+    try {
+      expect(
+        verifySqlite
+          .prepare(`SELECT "provider" FROM "media" WHERE "id" = ?`)
+          .pluck()
+          .get(SNAPSHOT_MEDIA_ID),
+      ).toBe("local");
+    } finally {
+      verifySqlite.close();
+    }
+    expect(
+      await createLocalDriver({ rootPath: targetStoragePath }).get(
+        SNAPSHOT_MEDIA_KEY,
+      ),
+    ).not.toBeNull();
+  });
+
   it("requires --replace for snapshot import", async () => {
     const root = await mkdtemp(join(tmpdir(), "jant-site-snapshot-replace-"));
     tempDirs.push(root);

package/src/node/__tests__/cli-snapshot-meta.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 import {
   assertSnapshotDialectMatches,
   assertSnapshotMeta,
+  buildMediaProviderSql,
   buildSnapshotMeta,
   getSnapshotDialect,
   SNAPSHOT_VERSION,
@@ -183,3 +184,22 @@ describe("assertSnapshotDialectMatches", () => {
     expect(() => assertSnapshotDialectMatches({}, "pg")).not.toThrow();
   });
 });
+
+describe("buildMediaProviderSql", () => {
+  it("records the site's media under the given storage driver", () => {
+    expect(buildMediaProviderSql("sit_o'brien", "s3")).toBe(
+      `UPDATE "media" SET "provider" = 's3' WHERE "site_id" = 'sit_o''brien';`,
+    );
+  });
+
+  // The value is written into SQL and read back as where the bytes live, so
+  // anything but a real driver is refused rather than quoted.
+  it("refuses anything that is not a storage driver", () => {
+    expect(() => buildMediaProviderSql("sit_test", "gcs")).toThrow(
+      'Snapshot import cannot record media under storage driver "gcs".',
+    );
+    expect(() => buildMediaProviderSql("sit_test", "s3' OR '1")).toThrow(
+      "cannot record media under storage driver",
+    );
+  });
+});