@jant/core 0.6.14 → 0.6.15

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

@@ -8,6 +8,9 @@ import { createPostService } from "../post.js";
 import type { Database } from "../../db/index.js";
 import type { RawQueryClient } from "../../db/raw-query.js";
 import type BetterSqlite3 from "better-sqlite3";
+import { eq } from "drizzle-orm";
+import { posts } from "../../db/schema.js";
+import { POST_BODY_HTML_VERSION } from "../../lib/post-body-html.js";
 
 /** Wraps plain text in a minimal valid TipTap JSON document. */
 function tiptapDoc(text: string): string {
@@ -37,11 +40,11 @@ function createSearchRow(overrides?: Partial<Record<string, unknown>>) {
     url: null,
     body: tiptapDoc("Hello world"),
     body_html: "<p>Hello world</p>",
+    body_html_version: POST_BODY_HTML_VERSION,
     body_text: "Hello world",
     quote_text: null,
     summary: null,
     rating: null,
-    collection_id: null,
     reply_to_id: null,
     thread_id: "pst_01jpyz2pvf4m7s2k8r5c9t0qce",
     published_at: 1774009100,
@@ -138,6 +141,50 @@ describe("SearchService", () => {
     expect(results[0]?.post.title).toContain("TypeScript");
   });
 
+  it("resolves stale body HTML on the raw search read path", async () => {
+    const body = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "semanticneedle" },
+            { type: "footnoteReference", attrs: { label: "1" } },
+          ],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "1" },
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Definition" }],
+            },
+          ],
+        },
+      ],
+    });
+    const post = await postService.create({ format: "note", body });
+    await db
+      .update(posts)
+      .set({
+        bodyHtml: '<span class="sidenote">legacy</span>',
+        bodyHtmlVersion: 1,
+      })
+      .where(eq(posts.id, post.id));
+
+    const searchService = createSearchService(
+      createMockD1(sqlite),
+      DEFAULT_TEST_SITE_ID,
+    );
+    const results = await searchService.search("semanticneedle");
+
+    expect(results[0]?.post.bodyHtml).toContain('role="doc-noteref"');
+    expect(results[0]?.post.bodyHtml).toMatch(/id="fn-[a-z0-9]{13}-1"/);
+    expect(results[0]?.post.bodyHtml).not.toContain(post.id);
+    expect(results[0]?.post.bodyHtml).not.toContain("legacy");
+  });
+
   it("respects status filter", async () => {
     await postService.create({
       format: "note",

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

@@ -50,6 +50,14 @@ describe("SettingsService", () => {
       expect(result).toBe("Asia/Shanghai");
     });
 
+    it("preserves runtime-supported IANA zones and fixed offsets", async () => {
+      await settingsService.set("TIME_ZONE", "America/Phoenix");
+      expect(await settingsService.get("TIME_ZONE")).toBe("America/Phoenix");
+
+      await settingsService.set("TIME_ZONE", "+08");
+      expect(await settingsService.get("TIME_ZONE")).toBe("+08:00");
+    });
+
     it("rejects unsupported timezone values", async () => {
       await expect(settingsService.set("TIME_ZONE", "+8")).rejects.toThrowError(
         "Choose a valid time zone.",

package/src/services/__tests__/site-admin.test.ts

@@ -44,10 +44,68 @@ describe("SiteAdminService", () => {
       .all(created.site.id) as { key: string }[];
 
     expect(siteRows).toEqual([{ key: "demo-cloud" }]);
+
+    const navigationRows = sqlite
+      .prepare(
+        'SELECT "system_key" AS systemKey, "placement" FROM "nav_item" WHERE "site_id" = ? ORDER BY "position"',
+      )
+      .all(created.site.id) as { systemKey: string; placement: string }[];
+
+    expect(navigationRows).toEqual([
+      { systemKey: "featured", placement: "header" },
+      { systemKey: "collections", placement: "header" },
+      { systemKey: "archive", placement: "header" },
+      { systemKey: "rss", placement: "more" },
+      { systemKey: "settings", placement: "more" },
+    ]);
+  });
+
+  it("preserves valid browser timezones during managed site creation", async () => {
+    const { db, sqlite } = createTestDatabase();
+    const service = createSiteAdminService(db, sqliteSchemaBundle, "sqlite", {
+      siteResolutionMode: "host-based",
+    });
+
+    const created = await service.createManagedSite({
+      key: "timezone-site",
+      primaryHost: "timezone-site.example.com",
+      siteName: "Timezone Site",
+      timeZone: "Etc/GMT-8",
+    });
+
+    const timeZone = sqlite
+      .prepare(
+        'SELECT "value" FROM "site_setting" WHERE "site_id" = ? AND "key" = \'TIME_ZONE\'',
+      )
+      .get(created.site.id) as { value: string } | undefined;
+
+    expect(timeZone?.value).toBe("Etc/GMT-8");
+  });
+
+  it("falls back to UTC when optional provisioning timezone metadata is invalid", async () => {
+    const { db, sqlite } = createTestDatabase();
+    const service = createSiteAdminService(db, sqliteSchemaBundle, "sqlite", {
+      siteResolutionMode: "host-based",
+    });
+
+    const created = await service.createManagedSite({
+      key: "fallback-site",
+      primaryHost: "fallback-site.example.com",
+      siteName: "Fallback Site",
+      timeZone: "Unknown/Zone",
+    });
+
+    const timeZone = sqlite
+      .prepare(
+        'SELECT "value" FROM "site_setting" WHERE "site_id" = ? AND "key" = \'TIME_ZONE\'',
+      )
+      .get(created.site.id) as { value: string } | undefined;
+
+    expect(timeZone).toBeUndefined();
   });
 
   it("returns the existing site when replayed with the same idempotency key", async () => {
-    const { db } = createTestDatabase();
+    const { db, sqlite } = createTestDatabase();
     const service = createSiteAdminService(db, sqliteSchemaBundle, "sqlite", {
       siteResolutionMode: "host-based",
     });
@@ -59,6 +117,12 @@ describe("SiteAdminService", () => {
       idempotencyKey: "job_abc",
     });
 
+    sqlite
+      .prepare(
+        'DELETE FROM "nav_item" WHERE "site_id" = ? AND "system_key" = \'featured\'',
+      )
+      .run(first.site.id);
+
     const second = await service.createManagedSite({
       key: "idem-site",
       primaryHost: "idem-site.example.com",
@@ -68,6 +132,62 @@ describe("SiteAdminService", () => {
 
     expect(second.site.id).toBe(first.site.id);
     expect(second.domain.id).toBe(first.domain.id);
+    const featuredCount = sqlite
+      .prepare(
+        'SELECT COUNT(*) AS count FROM "nav_item" WHERE "site_id" = ? AND "system_key" = \'featured\'',
+      )
+      .get(first.site.id) as { count: number };
+    expect(featuredCount.count).toBe(0);
+  });
+
+  it("recovers an incomplete idempotent provisioning attempt", async () => {
+    const { db, sqlite } = createTestDatabase();
+    const service = createSiteAdminService(db, sqliteSchemaBundle, "sqlite", {
+      siteResolutionMode: "host-based",
+    });
+
+    const first = await service.createManagedSite({
+      key: "recovery-site",
+      primaryHost: "recovery-site.example.com",
+      siteName: "Recovery Site",
+      idempotencyKey: "job_recovery",
+    });
+    sqlite
+      .prepare('DELETE FROM "nav_item" WHERE "site_id" = ?')
+      .run(first.site.id);
+    sqlite
+      .prepare(
+        'DELETE FROM "site_setting" WHERE "site_id" = ? AND "key" = \'ONBOARDING_STATUS\'',
+      )
+      .run(first.site.id);
+
+    const recovered = await service.createManagedSite({
+      key: "recovery-site",
+      primaryHost: "recovery-site.example.com",
+      siteName: "Recovery Site",
+      idempotencyKey: "job_recovery",
+    });
+
+    const navigationRows = sqlite
+      .prepare(
+        'SELECT "system_key" AS systemKey FROM "nav_item" WHERE "site_id" = ? ORDER BY "position"',
+      )
+      .all(first.site.id) as { systemKey: string }[];
+    const onboarding = sqlite
+      .prepare(
+        'SELECT "value" FROM "site_setting" WHERE "site_id" = ? AND "key" = \'ONBOARDING_STATUS\'',
+      )
+      .get(first.site.id) as { value: string };
+
+    expect(recovered.site.id).toBe(first.site.id);
+    expect(navigationRows.map((row) => row.systemKey)).toEqual([
+      "featured",
+      "collections",
+      "archive",
+      "rss",
+      "settings",
+    ]);
+    expect(onboarding.value).toBe("completed");
   });
 
   it("rejects reuse of an idempotency key with different key or primary host", async () => {

package/src/services/auth.ts

@@ -97,7 +97,7 @@ export function createAuthService(
     verification,
     media,
     collections,
-    postCollections,
+    threadCollections,
     pathRegistry,
     collectionDirectoryItems: directoryItemsTable,
     navItems,
@@ -111,7 +111,7 @@ export function createAuthService(
 
   async function deleteDataRows(targetDb: Database): Promise<void> {
     // Junction/dependent tables first
-    await targetDb.delete(postCollections);
+    await targetDb.delete(threadCollections);
     await targetDb.delete(pathRegistry);
     await targetDb.delete(directoryItemsTable);
     await targetDb.delete(media);

package/src/services/bootstrap.ts

@@ -31,7 +31,8 @@ export interface CompleteInitialSetupData {
 export interface BootstrapService {
   /**
    * Complete first-run setup for a newly created account.
-   * Ensures default system navigation exists and marks onboarding complete last.
+   * Materializes the versioned navigation profile and marks onboarding complete
+   * last so an interrupted setup can recover safely.
    *
    * @param data - Initial site shell values captured during setup
    */
@@ -58,7 +59,7 @@ export function createBootstrapService(
       const siteMembers = createSiteMemberService(db, databaseSchema);
 
       await siteMembers.ensure(site.id, data.ownerUserId, "owner");
-      await navItems.ensureSystemDefaults();
+      await navItems.materializeDefaultNavigation();
       await settings.set("SITE_NAME", data.siteName.trim());
       await settings.set("TIME_ZONE", data.timeZone ?? "UTC");
       const siteLanguage =