@jant/core 0.3.46 → 0.3.47

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import {
+  assertSnapshotDialectMatches,
+  assertSnapshotMeta,
+  buildSnapshotMeta,
+  getSnapshotDialect,
+} from "../../../bin/lib/site-snapshot.js";
+
+const SITE = { id: "sit_test", key: "default" };
+
+describe("buildSnapshotMeta", () => {
+  it("includes the dialect when provided", () => {
+    const meta = buildSnapshotMeta(SITE, { dialect: "pg" });
+    expect(meta.dialect).toBe("pg");
+    expect(meta.site).toEqual({ id: "sit_test", key: "default" });
+  });
+
+  it("omits the dialect field when not provided (back-compat)", () => {
+    const meta = buildSnapshotMeta(SITE);
+    expect("dialect" in meta).toBe(false);
+  });
+
+  it("rejects unknown dialects at build time", () => {
+    expect(() => buildSnapshotMeta(SITE, { dialect: "mysql" })).toThrow(
+      /Unsupported snapshot dialect/,
+    );
+  });
+});
+
+describe("assertSnapshotMeta", () => {
+  it("accepts a known dialect", () => {
+    expect(() =>
+      assertSnapshotMeta(buildSnapshotMeta(SITE, { dialect: "sqlite" })),
+    ).not.toThrow();
+  });
+
+  it("accepts a snapshot without a dialect (legacy)", () => {
+    expect(() => assertSnapshotMeta(buildSnapshotMeta(SITE))).not.toThrow();
+  });
+
+  it("rejects an unknown dialect at read time", () => {
+    expect(() =>
+      assertSnapshotMeta({
+        format: "jant-site-snapshot",
+        version: 1,
+        dialect: "mysql",
+        site: SITE,
+      }),
+    ).toThrow(/Snapshot meta has unsupported dialect/);
+  });
+});
+
+describe("getSnapshotDialect", () => {
+  it("returns the dialect when valid", () => {
+    expect(getSnapshotDialect({ dialect: "pg" })).toBe("pg");
+    expect(getSnapshotDialect({ dialect: "sqlite" })).toBe("sqlite");
+  });
+
+  it("returns undefined for missing or invalid dialect", () => {
+    expect(getSnapshotDialect({})).toBeUndefined();
+    expect(getSnapshotDialect({ dialect: "mysql" })).toBeUndefined();
+    expect(getSnapshotDialect(null)).toBeUndefined();
+  });
+});
+
+describe("assertSnapshotDialectMatches", () => {
+  it("passes when source and target dialects match", () => {
+    expect(() =>
+      assertSnapshotDialectMatches({ dialect: "pg" }, "pg"),
+    ).not.toThrow();
+  });
+
+  it("throws a descriptive error when dialects mismatch", () => {
+    expect(() =>
+      assertSnapshotDialectMatches({ dialect: "sqlite" }, "pg"),
+    ).toThrow(/Snapshot dialect mismatch.*source is sqlite.*target is pg/s);
+  });
+
+  it("skips validation when the snapshot predates the dialect field", () => {
+    // Older snapshots have no dialect field — we don't know the source, so we
+    // can't refuse them. The user opts into the looser check by importing
+    // legacy snapshots; cross-dialect SQL errors will surface mid-import.
+    expect(() => assertSnapshotDialectMatches({}, "pg")).not.toThrow();
+  });
+});

package/src/node/__tests__/cli-sql-export.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { getTableColumns } from "../../../bin/lib/sql-export.js";
+
+interface CapturedQueryRunner {
+  query: (sql: string) => Promise<Array<Record<string, unknown>>>;
+  lastSql?: string;
+}
+
+function createQueryRunner(
+  rows: Array<Record<string, unknown>>,
+): CapturedQueryRunner {
+  const runner: CapturedQueryRunner = {
+    async query(sql: string) {
+      runner.lastSql = sql;
+      return rows;
+    },
+  };
+  return runner;
+}
+
+describe("getTableColumns", () => {
+  it("filters Postgres GENERATED ALWAYS columns out of the dump column list", async () => {
+    const runner = createQueryRunner([
+      { name: "id" },
+      { name: "title" },
+      // pg already filters via is_generated = 'NEVER', so the runner only
+      // returns the storable columns. We capture the SQL to assert the WHERE.
+    ]);
+
+    const columns = await getTableColumns(runner, "post", "pg");
+
+    expect(columns).toEqual(["id", "title"]);
+    expect(runner.lastSql).toMatch(/is_generated\s*=\s*'NEVER'/);
+  });
+
+  it("filters SQLite STORED/VIRTUAL generated columns via table_xinfo.hidden", async () => {
+    const runner = createQueryRunner([
+      { cid: 0, name: "id", hidden: 0 },
+      { cid: 1, name: "title", hidden: 0 },
+      { cid: 2, name: "search_virtual", hidden: 2 },
+      { cid: 3, name: "search_stored", hidden: 3 },
+    ]);
+
+    const columns = await getTableColumns(runner, "post", "sqlite");
+
+    expect(columns).toEqual(["id", "title"]);
+    expect(runner.lastSql).toMatch(/PRAGMA\s+table_xinfo/);
+  });
+});

package/src/node/index.ts

@@ -8,6 +8,7 @@ export {
   createNodeRequestRuntime,
 } from "../runtime/node.js";
 export { createExportService } from "../services/export.js";
+export { createStorageDriver } from "../lib/storage.js";
 export { resolveConfig } from "../lib/resolve-config.js";
 export { buildThemeStyle } from "../lib/theme.js";
 export { BUILTIN_COLOR_THEMES } from "../ui/color-themes.js";

package/src/preset.css

@@ -490,7 +490,8 @@ html {
 .feed-link-domain,
 .feed-continue-link,
 [data-post-body].prose,
-[data-post-meta] {
+[data-post-meta],
+[data-post-end] {
   width: var(--layout-content-width);
 }
 
@@ -498,6 +499,10 @@ html {
   width: min(80%, 45rem);
 }
 
+[data-post-end]:not(:empty) {
+  margin-top: 3rem;
+}
+
 @media (max-width: 1024px) {
   [data-page="search"],
   .site-home-header,
@@ -512,7 +517,8 @@ html {
   .feed-link-domain,
   .feed-continue-link,
   [data-post-body].prose,
-  [data-post-meta] {
+  [data-post-meta],
+  [data-post-end] {
     width: min(100%, 35rem);
   }
 }

package/src/routes/api/__tests__/settings.test.ts

@@ -542,8 +542,9 @@ describe("Settings API Routes", () => {
       expect(storage.put).toHaveBeenCalledTimes(2);
 
       const mediaList = await services.media.list();
-      expect(mediaList).toHaveLength(1);
-      expect(mediaList[0]?.originalName).toBe("avatar.png");
+      expect(mediaList).toHaveLength(2);
+      const originalNames = mediaList.map((entry) => entry.originalName).sort();
+      expect(originalNames).toEqual(["apple-touch-icon.png", "avatar.png"]);
     });
   });
 

package/src/routes/api/github-sync.tsx

@@ -256,7 +256,7 @@ const ConnectSchema = z.object({
 // Connect: validate token, save config, create webhook
 githubSyncAdminRoutes.post("/setup", requireAuthApi(), async (c) => {
   // PAT connect is disabled when a GitHub App is configured — see the
-  // dashboard route for rationale.
+  // settings route for rationale.
   if (getGitHubAppConfig(c.env)) {
     return c.json(
       {

package/src/routes/api/settings.ts

@@ -176,7 +176,10 @@ settingsApiRoutes.post("/avatar", requireAuthApi(), async (c) => {
 
 // Remove site avatar (requires auth)
 settingsApiRoutes.delete("/avatar", requireAuthApi(), async (c) => {
-  await c.var.services.settings.removeAvatar(c.var.storage);
+  await c.var.services.settings.removeAvatar(c.var.storage, {
+    media: c.var.services.media,
+    storageProvider: c.var.appConfig.storageDriver,
+  });
   try {
     await syncHostedControlPlaneSiteAvatar({
       appConfig: c.var.appConfig,

package/src/routes/auth/signin.tsx

@@ -128,6 +128,12 @@ signinRoutes.get("/signin", async (c) => {
     ? rawRedirect
     : undefined;
 
+  if (c.var.isAuthenticated) {
+    return c.redirect(
+      toPublicPath(redirect ?? "/", c.var.appConfig.sitePathPrefix),
+    );
+  }
+
   const hostedSigninUrl = getHostedControlPlaneSigninUrl(
     c.env,
     c.var.publicRequestUrl,

package/src/routes/pages/archive.tsx

@@ -521,13 +521,15 @@ async function buildArchiveFeedData(
     ? await services.collections.getBySlug(params.collectionSlug)
     : undefined;
 
-  // Feed always serves public-only content
+  // Feed mirrors the unauthenticated archive page: published + non-private,
+  // including Hidden-from-Latest. /archive is the canonical "all posts" view,
+  // so its feed must match.
   const filters: PostFilters = {
     format: params.format,
     status: "published",
     excludeReplies: true,
     excludePrivate: true,
-    excludeLatestHidden: true,
+    excludeLatestHidden: false,
     collectionId: collection?.id,
     mediaKinds: params.mediaKinds,
     hasMedia: params.hasMedia,

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

@@ -82,7 +82,6 @@ describe("PostService", () => {
       expect(post.visibility).toBe("public");
       expect(post.pinnedAt).toBeNull();
       expect(post.bodyHtml).toContain("<p>Hello world</p>");
-      expect(post.deletedAt).toBeNull();
       expect(post.threadId).toBe(post.id);
     });
 
@@ -787,7 +786,7 @@ describe("PostService", () => {
       ]);
     });
 
-    it("excludes deleted posts by default", async () => {
+    it("excludes deleted posts", async () => {
       const post = await postService.create({
         format: "note",
         bodyMarkdown: "test",
@@ -800,17 +799,6 @@ describe("PostService", () => {
       expect(posts[0]?.bodyText).toBe("kept");
     });
 
-    it("includes deleted posts when requested", async () => {
-      const post = await postService.create({
-        format: "note",
-        bodyMarkdown: "test",
-      });
-      await postService.delete(post.id);
-
-      const posts = await postService.list({ includeDeleted: true });
-      expect(posts).toHaveLength(1);
-    });
-
     it("supports limit", async () => {
       for (let i = 0; i < 5; i++) {
         await postService.create({ format: "note", bodyMarkdown: `post ${i}` });
@@ -1485,8 +1473,8 @@ describe("PostService", () => {
     });
   });
 
-  describe("delete (soft delete)", () => {
-    it("soft-deletes a post", async () => {
+  describe("delete", () => {
+    it("removes a post", async () => {
       const post = await postService.create({
         format: "note",
         bodyMarkdown: "test",
@@ -1495,7 +1483,6 @@ describe("PostService", () => {
       const result = await postService.delete(post.id);
       expect(result).toBe(true);
 
-      // Should not appear in regular queries
       const found = await postService.getById(post.id);
       expect(found).toBeNull();
     });
@@ -1518,7 +1505,6 @@ describe("PostService", () => {
 
       await postService.delete(root.id);
 
-      // Both root and reply should be soft-deleted
       expect(await postService.getById(root.id)).toBeNull();
       expect(await postService.getById(reply.id)).toBeNull();
     });
@@ -1541,11 +1527,25 @@ describe("PostService", () => {
 
       await postService.delete(reply1.id);
 
-      // Root should still exist
       expect(await postService.getById(root.id)).not.toBeNull();
-      // reply1 should be deleted
       expect(await postService.getById(reply1.id)).toBeNull();
     });
+
+    it("frees the slug for reuse after deletion", async () => {
+      const post = await postService.create({
+        format: "note",
+        bodyMarkdown: "first",
+        title: "Same Title",
+      });
+      await postService.delete(post.id);
+
+      const reused = await postService.create({
+        format: "note",
+        bodyMarkdown: "second",
+        title: "Same Title",
+      });
+      expect(reused.slug).toBe(post.slug);
+    });
   });
 
   describe("threads", () => {

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

@@ -44,7 +44,6 @@ function createSearchRow(overrides?: Partial<Record<string, unknown>>) {
     collection_id: null,
     reply_to_id: null,
     thread_id: "pst_01jpyz2pvf4m7s2k8r5c9t0qce",
-    deleted_at: null,
     published_at: 1774009100,
     last_activity_at: 1774009100,
     created_at: 1774009100,

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

@@ -264,13 +264,32 @@ describe("SettingsService", () => {
       expect(result.languageChanged).toBe(true);
     });
 
-    it("rejects unsupported locales", async () => {
+    it("accepts a locale without a shipped catalog (e.g. Swedish)", async () => {
+      const result = await settingsService.updateGeneral(
+        { ...defaults, siteLanguage: "sv" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(result.languageChanged).toBe(true);
+      expect(await settingsService.get("SITE_LANGUAGE")).toBe("sv");
+    });
+
+    it("normalizes BCP 47 casing to canonical form", async () => {
+      await settingsService.updateGeneral(
+        { ...defaults, siteLanguage: "ZH-hans" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("SITE_LANGUAGE")).toBe("zh-Hans");
+    });
+
+    it("rejects values that are not valid BCP 47 tags", async () => {
       await expect(
         settingsService.updateGeneral(
-          { ...defaults, siteLanguage: "sv" },
+          { ...defaults, siteLanguage: "not a locale!!!" },
           { oldLanguage: "en", fallbackSiteName: "Jant" },
         ),
-      ).rejects.toThrow(/supported language/i);
+      ).rejects.toThrow(/BCP 47/i);
     });
 
     it("returns no language change when same", async () => {

package/src/services/bootstrap.ts

@@ -9,7 +9,11 @@ import {
   sqliteSchemaBundle,
   type DatabaseSchema,
 } from "../db/schema-bundle.js";
-import { baseLocale, isLocale } from "../i18n/locales.js";
+import {
+  baseLocale,
+  isValidContentLanguage,
+  normalizeContentLanguage,
+} from "../i18n/locales.js";
 import { createNavItemService } from "./navigation.js";
 import { createSettingsService } from "./settings.js";
 import { createSiteMemberService } from "./site-member.js";
@@ -57,8 +61,8 @@ export function createBootstrapService(
       await settings.set("SITE_NAME", data.siteName.trim());
       await settings.set("TIME_ZONE", data.timeZone ?? "UTC");
       const siteLanguage =
-        data.siteLanguage && isLocale(data.siteLanguage)
-          ? data.siteLanguage
+        data.siteLanguage && isValidContentLanguage(data.siteLanguage)
+          ? normalizeContentLanguage(data.siteLanguage)
           : baseLocale;
       await settings.set("SITE_LANGUAGE", siteLanguage);
       if (data.cjkSerifFont && data.cjkSerifFont !== "off") {

package/src/services/collection.ts

@@ -432,14 +432,14 @@ export function createCollectionService(
     const postCount = sql<number>`
       CAST(COUNT(
         CASE
-          WHEN ${posts.id} IS NOT NULL AND ${posts.deletedAt} IS NULL THEN 1
+          WHEN ${posts.id} IS NOT NULL THEN 1
         END
       ) AS INTEGER)
     `.as("post_count");
     const recentActivityAt = sql<number | null>`
       MAX(
         CASE
-          WHEN ${posts.id} IS NOT NULL AND ${posts.deletedAt} IS NULL
+          WHEN ${posts.id} IS NOT NULL
           THEN COALESCE(
             ${posts.lastActivityAt},
             ${posts.publishedAt},
@@ -1050,7 +1050,7 @@ export function createCollectionService(
         .from(postCollections)
         .innerJoin(
           sql`post`,
-          sql`post.id = ${postCollections.postId} AND post.deleted_at IS NULL AND post.site_id = ${siteId}`,
+          sql`post.id = ${postCollections.postId} AND post.site_id = ${siteId}`,
         )
         .where(eq(postCollections.siteId, siteId))
         .groupBy(postCollections.collectionId);

package/src/services/export.ts

@@ -1274,9 +1274,6 @@ function buildExportedCollectionMetrics(
   }
 
   for (const post of posts) {
-    if (post.deletedAt !== null) {
-      continue;
-    }
     // Drafts and private posts are excluded — they won't reach Hugo.
     if (post.status === "draft" || post.visibility === "private") {
       continue;

package/src/services/navigation.ts

@@ -446,14 +446,12 @@ export function createNavItemService(
             sql`(
               ${postCollections.createdAt} > ${threshold}
               OR (${posts.updatedAt} > ${threshold}
-                AND ${posts.deletedAt} IS NULL
                 AND ${posts.status} = 'published')
               OR EXISTS (
                 SELECT 1 FROM ${posts} reply
                 WHERE reply.site_id = ${postCollections.siteId}
                   AND reply.thread_id = ${postCollections.postId}
                   AND reply.reply_to_id IS NOT NULL
-                  AND reply.deleted_at IS NULL
                   AND reply.status = 'published'
                   AND reply.created_at > ${threshold}
               )

package/src/services/path.ts

@@ -6,7 +6,7 @@
  * slash (for example: "hello-world" or "collections/reading+tools").
  */
 
-import { and, eq, inArray, isNotNull, isNull, ne, sql } from "drizzle-orm";
+import { and, eq, inArray, isNotNull, ne } from "drizzle-orm";
 import { type Database, batchQuery } from "../db/index.js";
 import {
   sqliteSchemaBundle,
@@ -95,36 +95,10 @@ export function createPathService(
     return normalizePath(path);
   }
 
-  /**
-   * Removes a path_registry entry for the given normalized path if it belongs
-   * to a soft-deleted post, allowing the path to be reused.
-   */
-  async function reclaimDeletedPostPath(
-    normalizedPath: string,
-    excludePostId?: string,
-  ): Promise<void> {
-    const conditions = [
-      eq(pathRegistry.siteId, siteId),
-      eq(pathRegistry.path, normalizedPath),
-      isNotNull(pathRegistry.postId),
-      sql`EXISTS (
-        SELECT 1 FROM ${posts}
-        WHERE ${posts.id} = ${pathRegistry.postId}
-          AND ${posts.deletedAt} IS NOT NULL
-      )`,
-    ];
-    if (excludePostId) {
-      conditions.push(ne(pathRegistry.postId, excludePostId));
-    }
-    await db.delete(pathRegistry).where(and(...conditions));
-  }
-
   async function insertPath(input: CreatePathInput): Promise<PathRecord> {
     const timestamp = now();
     const normalizedPath = normalizeStoredPath(input.path);
 
-    await reclaimDeletedPostPath(normalizedPath);
-
     try {
       const result = await db
         .insert(pathRegistry)
@@ -192,14 +166,6 @@ export function createPathService(
       const conditions = [
         eq(pathRegistry.siteId, siteId),
         eq(pathRegistry.path, normalized),
-        // Ignore paths owned by soft-deleted posts — those slugs are available
-        // for reuse. Paths not linked to a post (collections, redirects,
-        // archives) always block.
-        sql`(${pathRegistry.postId} IS NULL OR NOT EXISTS (
-          SELECT 1 FROM ${posts}
-          WHERE ${posts.id} = ${pathRegistry.postId}
-            AND ${posts.deletedAt} IS NOT NULL
-        ))`,
       ];
       if (excludeId) conditions.push(ne(pathRegistry.id, excludeId));
 
@@ -310,8 +276,6 @@ export function createPathService(
       const timestamp = now();
       const normalized = normalizeStoredPath(slug);
 
-      await reclaimDeletedPostPath(normalized, postId);
-
       try {
         await db
           .update(pathRegistry)
@@ -424,7 +388,6 @@ export function createPathService(
             eq(pathRegistry.kind, "slug"),
             isNotNull(pathRegistry.postId),
             isNotNull(posts.title),
-            isNull(posts.deletedAt),
             eq(posts.format, "note"),
           ),
         );