@jant/core 0.6.16 → 0.7.1

package/src/services/__tests__/auth.test.ts

@@ -18,6 +18,7 @@ import {
   siteDomains,
   siteMembers,
   sites,
+  smartCollections,
   user,
   verification,
 } from "../../db/schema.js";
@@ -172,6 +173,56 @@ describe("AuthService", () => {
       createdAt: timestamp,
     });
 
+    // A smart collection that filters *by* the collection above, with every row
+    // that hangs off it. This is the shape a factory reset used to die on: the
+    // condition column once carried `ON DELETE restrict`, so clearing
+    // `collection` threw halfway through a reset that runs without a
+    // transaction on SQLite and D1, leaving a half-erased site behind.
+    await db.insert(smartCollections).values({
+      id: "smc_01km9authdelete00000000000",
+      siteId: DEFAULT_TEST_SITE_ID,
+      title: "Untitled notes",
+      collectionId: "col_01km9authdelete00000000000",
+      format: "note",
+      hasTitle: false,
+      sort: "newest",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+
+    await db.insert(pathRegistry).values({
+      id: "pth_01km9authsmart0000000000000",
+      siteId: DEFAULT_TEST_SITE_ID,
+      path: "untitled-notes",
+      kind: "slug",
+      smartCollectionId: "smc_01km9authdelete00000000000",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+
+    await db.insert(collectionDirectoryItems).values({
+      id: "cdi_01km9authsmart0000000000000",
+      siteId: DEFAULT_TEST_SITE_ID,
+      type: "smart_collection",
+      smartCollectionId: "smc_01km9authdelete00000000000",
+      label: null,
+      position: "a1",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+
+    await db.insert(navItems).values({
+      id: "nav_01km9authsmart0000000000000",
+      siteId: DEFAULT_TEST_SITE_ID,
+      type: "smart_collection",
+      smartCollectionId: "smc_01km9authdelete00000000000",
+      label: "",
+      url: "/untitled-notes",
+      position: "a1",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+
     await db.insert(navItems).values({
       id: "nav_01km9authdelete00000000000",
       siteId: DEFAULT_TEST_SITE_ID,
@@ -241,6 +292,9 @@ describe("AuthService", () => {
       const remainingPosts = await db.select().from(posts);
       const remainingMedia = await db.select().from(media);
       const remainingCollections = await db.select().from(collections);
+      const remainingSmartCollections = await db
+        .select()
+        .from(smartCollections);
       const remainingPaths = await db.select().from(pathRegistry);
       const remainingDirectoryItems = await db
         .select()
@@ -262,6 +316,7 @@ describe("AuthService", () => {
       expect(remainingPosts).toHaveLength(0);
       expect(remainingMedia).toHaveLength(0);
       expect(remainingCollections).toHaveLength(0);
+      expect(remainingSmartCollections).toHaveLength(0);
       expect(remainingPaths).toHaveLength(0);
       expect(remainingDirectoryItems).toHaveLength(0);
       expect(remainingThreadCollections).toHaveLength(0);
@@ -287,12 +342,16 @@ describe("AuthService", () => {
       const remainingSiteMembers = await db.select().from(siteMembers);
       const remainingUsers = await db.select().from(user);
       const remainingPosts = await db.select().from(posts);
+      const remainingSmartCollections = await db
+        .select()
+        .from(smartCollections);
       const remainingSettings = await db.select().from(settingsTable);
       const existingSites = await db.select().from(sites);
       const existingSiteDomains = await db.select().from(siteDomains);
       expect(remainingSiteMembers).toHaveLength(0);
       expect(remainingUsers).toHaveLength(0);
       expect(remainingPosts).toHaveLength(0);
+      expect(remainingSmartCollections).toHaveLength(0);
       expect(remainingSettings).toHaveLength(0);
       expect(existingSites).toHaveLength(0);
       expect(existingSiteDomains).toHaveLength(0);
@@ -305,22 +364,72 @@ describe("AuthService", () => {
       db = testDb.db as unknown as Database;
     });
 
-    it("validates delete CSRF tokens in Node runtimes", async () => {
+    function createTokenService(authSecret = "test-auth-secret") {
       const settingsService = createSettingsService(db, DEFAULT_TEST_SITE_ID);
-      const authService = createAuthService(db, settingsService, {
+      return createAuthService(db, settingsService, {
         databaseDialect: "pg",
+        authSecret,
       });
+    }
+
+    it("validates delete CSRF tokens in Node runtimes", async () => {
+      const authService = createTokenService();
 
-      const token = await authService.generateDeleteCsrfToken();
+      const token = await authService.generateDeleteCsrfToken("ses_1");
 
-      await expect(authService.validateDeleteCsrfToken(token)).resolves.toBe(
-        true,
-      );
       await expect(
-        authService.validateDeleteCsrfToken(`${token}nope`),
+        authService.validateDeleteCsrfToken(token, "ses_1"),
+      ).resolves.toBe(true);
+      await expect(
+        authService.validateDeleteCsrfToken(`${token}nope`, "ses_1"),
       ).resolves.toBe(false);
     });
 
+    it("issues the same delete token however often a session asks", async () => {
+      // Rendering the delete page is a GET. Issuing twice must not invalidate
+      // the copy already sitting in an open tab — that turned any prefetch or
+      // browser extension re-fetching the page into a dead delete button.
+      const authService = createTokenService();
+
+      const first = await authService.generateDeleteCsrfToken("ses_1");
+      const second = await authService.generateDeleteCsrfToken("ses_1");
+
+      expect(second).toBe(first);
+      await expect(
+        authService.validateDeleteCsrfToken(first, "ses_1"),
+      ).resolves.toBe(true);
+    });
+
+    it("refuses a delete token minted for another session", async () => {
+      const authService = createTokenService();
+
+      const token = await authService.generateDeleteCsrfToken("ses_1");
+
+      await expect(
+        authService.validateDeleteCsrfToken(token, "ses_2"),
+      ).resolves.toBe(false);
+    });
+
+    it("refuses a delete token minted under another signing key", async () => {
+      const token =
+        await createTokenService("secret-a").generateDeleteCsrfToken("ses_1");
+
+      await expect(
+        createTokenService("secret-b").validateDeleteCsrfToken(token, "ses_1"),
+      ).resolves.toBe(false);
+    });
+
+    it("refuses to mint a delete token without a signing key", async () => {
+      const settingsService = createSettingsService(db, DEFAULT_TEST_SITE_ID);
+      const authService = createAuthService(db, settingsService, {
+        databaseDialect: "pg",
+      });
+
+      await expect(
+        authService.generateDeleteCsrfToken("ses_1"),
+      ).rejects.toThrow(/AUTH_SECRET/);
+    });
+
     it("validates password reset tokens in Node runtimes", async () => {
       const settingsService = createSettingsService(db, DEFAULT_TEST_SITE_ID);
       const authService = createAuthService(db, settingsService, {

package/src/services/__tests__/bootstrap-setup-instance.test.ts

@@ -0,0 +1,230 @@
+import { sql } from "drizzle-orm";
+import { beforeEach, describe, expect, it } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import type { Database } from "../../db/index.js";
+import {
+  account,
+  navItems,
+  settings,
+  siteDomains,
+  siteMembers,
+  sites,
+  user,
+} from "../../db/schema.js";
+import { verifyPassword } from "../../lib/password.js";
+import { createBootstrapService } from "../bootstrap.js";
+import { createSiteService, TRANSIENT_SINGLE_SITE_ID } from "../site.js";
+
+const SNAPSHOT_SITE_ID = "sit_01kn8jq3t4famtyg9hjd074ckr";
+const OWNER = { email: "owner@example.com", password: "correct horse" };
+
+async function readSettings(db: Database, siteId: string) {
+  const rows = await db.select().from(settings);
+  return Object.fromEntries(
+    rows
+      .filter((row) => row.siteId === siteId)
+      .map((row) => [row.key, row.value]),
+  );
+}
+
+async function storedPasswordHash(db: Database) {
+  const rows = await db.select({ password: account.password }).from(account);
+  expect(rows).toHaveLength(1);
+  return rows[0]?.password ?? "";
+}
+
+describe("EnsureSingleSiteOptions.id", () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = createTestDatabase().db as unknown as Database;
+    await db.run(sql`DELETE FROM "site"`);
+  });
+
+  it("creates the site with the given id", async () => {
+    const { site } = await createSiteService(db).ensureSingleSite({
+      id: SNAPSHOT_SITE_ID,
+    });
+
+    expect(site.id).toBe(SNAPSHOT_SITE_ID);
+  });
+
+  // Like the host and key, the id says what a new site is created with. It is
+  // never a request to rename a site that exists.
+  it("leaves an existing site's id alone", async () => {
+    const { site: existing } = await createSiteService(db).ensureSingleSite();
+    const { site } = await createSiteService(db).ensureSingleSite({
+      id: SNAPSHOT_SITE_ID,
+    });
+
+    expect(site.id).toBe(existing.id);
+    expect(await db.select().from(sites)).toHaveLength(1);
+  });
+});
+
+describe("BootstrapService.setUpInstance", () => {
+  let db: Database;
+
+  function bootstrap(options?: Parameters<typeof createBootstrapService>[2]) {
+    return createBootstrapService(db, TRANSIENT_SINGLE_SITE_ID, options);
+  }
+
+  beforeEach(async () => {
+    db = createTestDatabase().db as unknown as Database;
+    await db.run(sql`DELETE FROM "site"`);
+  });
+
+  it("leaves a fresh install set up, the way both screens would", async () => {
+    const result = await bootstrap().setUpInstance({
+      ...OWNER,
+      siteId: SNAPSHOT_SITE_ID,
+      siteName: "Field Notes",
+      siteLanguage: "zh-Hans",
+      timeZone: "Asia/Shanghai",
+    });
+
+    expect(result).toEqual({ outcome: "created", siteId: SNAPSHOT_SITE_ID });
+
+    const [owner] = await db.select().from(user);
+    expect(owner).toMatchObject({
+      email: OWNER.email,
+      name: "Field Notes",
+      role: "admin",
+    });
+    expect(
+      await verifyPassword({
+        hash: await storedPasswordHash(db),
+        password: OWNER.password,
+      }),
+    ).toBe(true);
+
+    expect(await db.select().from(siteMembers)).toEqual([
+      expect.objectContaining({
+        siteId: SNAPSHOT_SITE_ID,
+        userId: owner?.id,
+        role: "owner",
+      }),
+    ]);
+    expect(await db.select().from(navItems)).toHaveLength(5);
+    expect(await readSettings(db, SNAPSHOT_SITE_ID)).toMatchObject({
+      ONBOARDING_STATUS: "completed",
+      SITE_NAME: "Field Notes",
+      SITE_LANGUAGE: "zh-Hans",
+      TIME_ZONE: "Asia/Shanghai",
+    });
+  });
+
+  // An empty answer on the screens: the base locale and UTC, and no name, so
+  // the site keeps its fallback and the account keeps the address's stand-in.
+  it("gives unanswered questions the screens' defaults", async () => {
+    const result = await bootstrap().setUpInstance(OWNER);
+
+    expect(result.outcome).toBe("created");
+    expect(result.siteId).toMatch(/^sit_/);
+    const stored = await readSettings(db, result.siteId);
+    expect(stored).toMatchObject({
+      ONBOARDING_STATUS: "completed",
+      SITE_LANGUAGE: "en",
+      TIME_ZONE: "UTC",
+    });
+    expect(stored.SITE_NAME).toBeUndefined();
+    expect((await db.select().from(user))[0]?.name).toBe("owner");
+  });
+
+  it("gives the site its configured domain", async () => {
+    await createBootstrapService(db, TRANSIENT_SINGLE_SITE_ID, {
+      bootstrapSite: { host: "notes.example.com" },
+    }).setUpInstance(OWNER);
+
+    expect(await db.select().from(siteDomains)).toEqual([
+      expect.objectContaining({ host: "notes.example.com", kind: "primary" }),
+    ]);
+  });
+
+  // A deployment runs this on every start. The owner may have changed the
+  // password since, and a restart must not quietly put the old one back.
+  it("changes nothing on an install that finished setup", async () => {
+    const first = await bootstrap().setUpInstance({
+      ...OWNER,
+      siteName: "Field Notes",
+    });
+    const hashBefore = await storedPasswordHash(db);
+
+    const second = await bootstrap().setUpInstance({
+      email: "someone-else@example.com",
+      password: "a different password",
+      siteName: "Renamed",
+    });
+
+    expect(second).toEqual({
+      outcome: "already-set-up",
+      siteId: first.siteId,
+    });
+    expect(await storedPasswordHash(db)).toBe(hashBefore);
+    expect(await db.select().from(user)).toHaveLength(1);
+    expect((await readSettings(db, first.siteId)).SITE_NAME).toBe(
+      "Field Notes",
+    );
+  });
+
+  it("refuses a site id that is not the install's", async () => {
+    await bootstrap().setUpInstance(OWNER);
+
+    await expect(
+      bootstrap().setUpInstance({ ...OWNER, siteId: SNAPSHOT_SITE_ID }),
+    ).rejects.toThrow(`not ${SNAPSHOT_SITE_ID}`);
+  });
+
+  describe("after a run that stopped once the account existed", () => {
+    beforeEach(async () => {
+      await bootstrap().setUpInstance(OWNER);
+      // Undo everything past the account, which is where an interrupted run
+      // leaves an install.
+      await db.run(sql`DELETE FROM "site"`);
+    });
+
+    it("finishes with the same address and password", async () => {
+      const result = await bootstrap().setUpInstance({
+        ...OWNER,
+        siteId: SNAPSHOT_SITE_ID,
+        siteName: "Field Notes",
+      });
+
+      expect(result).toEqual({ outcome: "resumed", siteId: SNAPSHOT_SITE_ID });
+      expect(await db.select().from(user)).toHaveLength(1);
+      expect((await db.select().from(user))[0]?.name).toBe("Field Notes");
+      expect((await readSettings(db, SNAPSHOT_SITE_ID)).ONBOARDING_STATUS).toBe(
+        "completed",
+      );
+    });
+
+    it("refuses the wrong password", async () => {
+      await expect(
+        bootstrap().setUpInstance({ ...OWNER, password: "not the password" }),
+      ).rejects.toThrow("does not match");
+      expect(await db.select().from(sites)).toHaveLength(0);
+    });
+
+    it("refuses another address", async () => {
+      await expect(
+        bootstrap().setUpInstance({
+          email: "someone-else@example.com",
+          password: OWNER.password,
+        }),
+      ).rejects.toThrow("already has an account under another address");
+      expect(await db.select().from(user)).toHaveLength(1);
+      expect(await db.select().from(sites)).toHaveLength(0);
+    });
+  });
+
+  // A hosted site's owner arrives through the control plane's handoff, so
+  // this refuses before creating an account in a database every tenant shares.
+  it("refuses a host-based install before writing anything", async () => {
+    await expect(
+      bootstrap({ siteResolutionMode: "host-based" }).setUpInstance(OWNER),
+    ).rejects.toThrow("setUpInstance runs on self-hosted installs only");
+
+    expect(await db.select().from(user)).toHaveLength(0);
+    expect(await db.select().from(sites)).toHaveLength(0);
+  });
+});

package/src/services/__tests__/collection.test.ts

@@ -267,6 +267,102 @@ describe("CollectionService", () => {
   });
 
   describe("listDirectoryData", () => {
+    it("counts only what this reader can see", async () => {
+      const reading = await collectionService.create({
+        slug: "reading",
+        title: "Reading",
+      });
+
+      const published = await postService.create({
+        format: "note",
+        bodyMarkdown: "Published",
+      });
+      const draft = await postService.create({
+        format: "note",
+        bodyMarkdown: "Draft",
+        status: "draft",
+      });
+      const secret = await postService.create({
+        format: "note",
+        bodyMarkdown: "Private",
+        visibility: "private",
+      });
+      for (const post of [published, draft, secret]) {
+        await collectionService.addThread(reading.id, post.id);
+      }
+
+      // A stranger who could subtract the directory's number from the
+      // collection page's would learn how much unpublished work is in here.
+      const anonymous = await collectionService.listDirectoryData({
+        isAuthenticated: false,
+      });
+      expect(anonymous.collections[0]?.threadCount).toBe(1);
+      expect(anonymous.collections[0]?.recentActivityAt).toBe(
+        published.lastActivityAt,
+      );
+
+      const author = await collectionService.listDirectoryData({
+        isAuthenticated: true,
+      });
+      expect(author.collections[0]?.threadCount).toBe(2);
+    });
+
+    it("counts a Thread once, whichever of its posts matched", async () => {
+      const reading = await collectionService.create({
+        slug: "reading",
+        title: "Reading",
+      });
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "Root",
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Reply",
+        replyToId: root.id,
+      });
+      await collectionService.addThread(reading.id, root.id);
+
+      const directory = await collectionService.listDirectoryData({
+        isAuthenticated: false,
+      });
+      expect(directory.collections[0]?.threadCount).toBe(1);
+    });
+
+    it("narrows counts to the view's language", async () => {
+      const reading = await collectionService.create({
+        slug: "reading",
+        title: "Reading",
+      });
+      const english = await postService.create({
+        format: "note",
+        bodyMarkdown: "English",
+        language: "en",
+      });
+      const japanese = await postService.create({
+        format: "note",
+        bodyMarkdown: "Japanese",
+        language: "ja",
+      });
+      for (const post of [english, japanese]) {
+        await collectionService.addThread(reading.id, post.id);
+      }
+
+      const englishView = await collectionService.listDirectoryData({
+        isAuthenticated: false,
+        lang: "en",
+      });
+      expect(englishView.collections[0]?.threadCount).toBe(1);
+
+      // The row itself stays listed in every view — only its number narrows.
+      const japaneseView = await collectionService.listDirectoryData({
+        isAuthenticated: false,
+        lang: "ja",
+      });
+      expect(japaneseView.collections).toHaveLength(1);
+      expect(japaneseView.collections[0]?.threadCount).toBe(1);
+    });
+
     it("returns collections with recent activity and labeled dividers", async () => {
       const reading = await collectionService.create({
         slug: "reading",
@@ -283,7 +379,9 @@ describe("CollectionService", () => {
       });
       await collectionService.addThread(reading.id, post.id);
 
-      const directory = await collectionService.listDirectoryData();
+      const directory = await collectionService.listDirectoryData({
+        isAuthenticated: false,
+      });
 
       expect(directory.collections).toHaveLength(1);
       expect(directory.collections[0]?.recentActivityAt).toBe(
@@ -329,7 +427,9 @@ describe("CollectionService", () => {
         vi.setSystemTime(new Date("2024-01-01T00:01:00Z"));
         await postService.update(root.id, { bodyMarkdown: "after" });
 
-        const directory = await collectionService.listDirectoryData();
+        const directory = await collectionService.listDirectoryData({
+          isAuthenticated: false,
+        });
         expect(directory.collections[0]?.recentActivityAt).toBe(1704067200);
       } finally {
         vi.useRealTimers();
@@ -357,7 +457,9 @@ describe("CollectionService", () => {
           replyToId: root.id,
         });
 
-        const directory = await collectionService.listDirectoryData();
+        const directory = await collectionService.listDirectoryData({
+          isAuthenticated: false,
+        });
         expect(directory.collections[0]?.recentActivityAt).toBe(1704067260);
       } finally {
         vi.useRealTimers();
@@ -371,7 +473,9 @@ describe("CollectionService", () => {
         url: "/archive?format=quote",
       });
 
-      const directory = await collectionService.listDirectoryData();
+      const directory = await collectionService.listDirectoryData({
+        isAuthenticated: false,
+      });
 
       expect(directory.directoryItems).toContainEqual(
         expect.objectContaining({

package/src/services/__tests__/custom-url.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, beforeEach } from "vitest";
+import { sql } from "drizzle-orm";
 import {
   createTestDatabase,
   DEFAULT_TEST_SITE_ID,
@@ -96,6 +97,39 @@ describe("CustomUrlService", () => {
     });
   });
 
+  // Postgres gives no order among rows that tie on the sort key, so paging
+  // by created_at alone repeated some custom URLs and never showed others
+  // (482 rows listed, 478 distinct, on a real site).
+  describe("list order", () => {
+    it("orders custom URLs created in the same second by ID", async () => {
+      const created = [];
+      for (const path of ["a-page", "b-page", "c-page"]) {
+        created.push(
+          await customUrlService.create({
+            path,
+            targetType: "redirect",
+            toPath: "/target",
+            redirectType: 301,
+          }),
+        );
+      }
+      await db.run(sql`UPDATE path_registry SET created_at = 1000`);
+
+      const listed = await customUrlService.list();
+      const expected = created
+        .map((url) => url.id)
+        .sort()
+        .reverse();
+      expect(listed.map((url) => url.id)).toEqual(expected);
+
+      const pages = [
+        ...(await customUrlService.list({ limit: 2, offset: 0 })),
+        ...(await customUrlService.list({ limit: 2, offset: 2 })),
+      ];
+      expect(pages.map((url) => url.id)).toEqual(expected);
+    });
+  });
+
   describe("getByPath", () => {
     it("returns custom URL by path", async () => {
       await customUrlService.create({