@jant/core 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "bin": {
@@ -25,7 +25,6 @@
   "files": [
     "bin",
     "dist",
-    "migrations",
     "src"
   ],
   "publishConfig": {
@@ -54,12 +53,15 @@
     "@lingui/swc-plugin": "^5.10.1",
     "@swc/cli": "^0.6.0",
     "@swc/core": "^1.15.11",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.1.0",
+    "better-sqlite3": "^12.6.2",
     "drizzle-kit": "^0.31.8",
     "glob": "^13.0.0",
     "tailwindcss": "^4.1.18",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   },
   "repository": {
     "type": "git",
@@ -86,12 +88,15 @@
   },
   "scripts": {
     "build": "pnpm build:lib",
-    "build:lib": "swc src -d dist --strip-leading-paths && pnpm build:types",
+    "build:lib": "swc src -d dist --strip-leading-paths --ignore '**/__tests__/**' && pnpm build:types",
     "build:types": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.client.json",
     "db:generate": "drizzle-kit generate",
     "i18n:extract": "lingui extract",
     "i18n:compile": "lingui compile --typescript",
-    "i18n:build": "pnpm i18n:extract && pnpm i18n:compile"
+    "i18n:build": "pnpm i18n:extract && pnpm i18n:compile",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   }
 }

package/src/__tests__/helpers/app.ts

@@ -0,0 +1,97 @@
+/**
+ * Test App Helper
+ *
+ * Creates a minimal Hono app with services wired up for route testing.
+ */
+
+import { Hono } from "hono";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { createTestDatabase } from "./db.js";
+import { createPostService } from "../../services/post.js";
+import { createSettingsService } from "../../services/settings.js";
+import { createRedirectService } from "../../services/redirect.js";
+import { createMediaService } from "../../services/media.js";
+import { createCollectionService } from "../../services/collection.js";
+import { createSearchService } from "../../services/search.js";
+import type { Database } from "../../db/index.js";
+import type BetterSqlite3 from "better-sqlite3";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+interface TestAppOptions {
+  /** If true, all requests are treated as authenticated */
+  authenticated?: boolean;
+  /** Enable FTS for search tests */
+  fts?: boolean;
+}
+
+/**
+ * Creates a test Hono app with real services backed by in-memory SQLite.
+ * Returns the app and service instances for assertions.
+ */
+export function createTestApp(options: TestAppOptions = {}) {
+  const testDb = createTestDatabase({ fts: options.fts });
+  const db = testDb.db as unknown as Database;
+  const sqlite = testDb.sqlite;
+
+  // Create a mock D1 for search service
+  const mockD1 = createMockD1(sqlite);
+
+  const services = {
+    posts: createPostService(db),
+    settings: createSettingsService(db),
+    redirects: createRedirectService(db),
+    media: createMediaService(db),
+    collections: createCollectionService(db),
+    search: createSearchService(mockD1),
+  };
+
+  const app = new Hono<Env>();
+
+  // Inject services middleware
+  app.use("*", async (c, next) => {
+    c.set("services", services as AppVariables["services"]);
+    c.set("config", {});
+
+    if (options.authenticated) {
+      // Mock auth that always returns a session
+      c.set("auth", {
+        api: {
+          getSession: async () => ({
+            user: { id: "test-user", email: "test@test.com", name: "Test" },
+            session: { id: "test-session" },
+          }),
+        },
+      } as AppVariables["auth"]);
+    } else {
+      c.set("auth", {
+        api: {
+          getSession: async () => null,
+        },
+      } as AppVariables["auth"]);
+    }
+
+    await next();
+  });
+
+  return { app, services, db, sqlite };
+}
+
+function createMockD1(sqliteDb: BetterSqlite3.Database) {
+  return {
+    prepare(query: string) {
+      return {
+        bind(...params: unknown[]) {
+          return {
+            async all<T>() {
+              const stmt = sqliteDb.prepare(query);
+              const rows = stmt.all(...(params as never[])) as T[];
+              return { results: rows };
+            },
+          };
+        },
+      };
+    },
+  } as unknown as D1Database;
+}

package/src/__tests__/helpers/db.ts

@@ -0,0 +1,85 @@
+/**
+ * Test Database Helper
+ *
+ * Creates an in-memory SQLite database with all migrations applied.
+ * Used for service integration tests.
+ */
+
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "../../db/schema.js";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+const MIGRATIONS_DIR = resolve(import.meta.dirname, "../../db/migrations");
+
+/**
+ * Creates a fresh in-memory SQLite database with all migrations applied.
+ * Each call returns an isolated database instance for test isolation.
+ *
+ * @param options.fts - Whether to apply FTS5 migration (default: false).
+ *   The trigram tokenizer used in production may not be available in all
+ *   better-sqlite3 builds, so FTS is opt-in for tests that need it.
+ */
+export function createTestDatabase(options?: { fts?: boolean }) {
+  const sqlite = new Database(":memory:");
+
+  // Enable WAL mode for better performance
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+
+  // Apply base schema migration
+  const migration0 = readFileSync(
+    resolve(MIGRATIONS_DIR, "0000_square_wallflower.sql"),
+    "utf-8",
+  );
+
+  // Drizzle migrations use --> statement-breakpoint as separator
+  for (const sql of migration0.split("--> statement-breakpoint")) {
+    const trimmed = sql.trim();
+    if (trimmed) sqlite.exec(trimmed);
+  }
+
+  // Optionally apply FTS5 migration (with fallback tokenizer)
+  if (options?.fts) {
+    try {
+      const migration1 = readFileSync(
+        resolve(MIGRATIONS_DIR, "0001_add_search_fts.sql"),
+        "utf-8",
+      );
+      sqlite.exec(migration1);
+    } catch {
+      // Fallback: create FTS table with default tokenizer if trigram not available
+      sqlite.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS posts_fts USING fts5(
+          title,
+          content,
+          content='posts',
+          content_rowid='id'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS posts_fts_insert AFTER INSERT ON posts
+        WHEN NEW.deleted_at IS NULL
+        BEGIN
+          INSERT INTO posts_fts(rowid, title, content)
+          VALUES (NEW.id, COALESCE(NEW.title, ''), COALESCE(NEW.content, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS posts_fts_update AFTER UPDATE ON posts BEGIN
+          DELETE FROM posts_fts WHERE rowid = OLD.id;
+          INSERT INTO posts_fts(rowid, title, content)
+          SELECT NEW.id, COALESCE(NEW.title, ''), COALESCE(NEW.content, '')
+          WHERE NEW.deleted_at IS NULL;
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS posts_fts_delete AFTER DELETE ON posts BEGIN
+          DELETE FROM posts_fts WHERE rowid = OLD.id;
+        END;
+      `);
+    }
+  }
+
+  const db = drizzle(sqlite, { schema });
+
+  return { db, sqlite };
+}

package/src/app.tsx

@@ -29,7 +29,6 @@ import { mediaRoutes as dashMediaRoutes } from "./routes/dash/media.js";
 import { settingsRoutes as dashSettingsRoutes } from "./routes/dash/settings.js";
 import { redirectsRoutes as dashRedirectsRoutes } from "./routes/dash/redirects.js";
 import { collectionsRoutes as dashCollectionsRoutes } from "./routes/dash/collections.js";
-import { appearanceRoutes as dashAppearanceRoutes } from "./routes/dash/appearance.js";
 
 // Routes - API
 import { postsApiRoutes } from "./routes/api/posts.js";
@@ -675,8 +674,6 @@ export function createApp(config: JantConfig = {}): App {
   app.route("/dash/settings", dashSettingsRoutes);
   app.route("/dash/redirects", dashRedirectsRoutes);
   app.route("/dash/collections", dashCollectionsRoutes);
-  app.route("/dash/appearance", dashAppearanceRoutes);
-
   // API routes
   app.route("/api/upload", uploadApiRoutes);
   app.route("/api/search", searchApiRoutes);

package/src/db/migrations/0001_add_search_fts.sql

@@ -0,0 +1,34 @@
+-- FTS5 virtual table for full-text search (trigram tokenizer for CJK support)
+CREATE VIRTUAL TABLE IF NOT EXISTS posts_fts USING fts5(
+  title,
+  content,
+  content='posts',
+  content_rowid='id',
+  tokenize='trigram'
+);
+
+-- Populate FTS with existing posts
+INSERT INTO posts_fts(rowid, title, content)
+SELECT id, COALESCE(title, ''), COALESCE(content, '')
+FROM posts WHERE deleted_at IS NULL;
+
+-- Trigger: sync FTS on INSERT
+CREATE TRIGGER posts_fts_insert AFTER INSERT ON posts
+WHEN NEW.deleted_at IS NULL
+BEGIN
+  INSERT INTO posts_fts(rowid, title, content)
+  VALUES (NEW.id, COALESCE(NEW.title, ''), COALESCE(NEW.content, ''));
+END;
+
+-- Trigger: sync FTS on UPDATE
+CREATE TRIGGER posts_fts_update AFTER UPDATE ON posts BEGIN
+  DELETE FROM posts_fts WHERE rowid = OLD.id;
+  INSERT INTO posts_fts(rowid, title, content)
+  SELECT NEW.id, COALESCE(NEW.title, ''), COALESCE(NEW.content, '')
+  WHERE NEW.deleted_at IS NULL;
+END;
+
+-- Trigger: sync FTS on DELETE
+CREATE TRIGGER posts_fts_delete AFTER DELETE ON posts BEGIN
+  DELETE FROM posts_fts WHERE rowid = OLD.id;
+END;

package/src/db/migrations/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1770564499811,
       "tag": "0000_square_wallflower",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1770564499812,
+      "tag": "0001_add_search_fts",
+      "breakpoints": true
     }
   ]
 }

package/src/lib/__tests__/constants.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { RESERVED_PATHS, isReservedPath } from "../constants.js";
+
+describe("RESERVED_PATHS", () => {
+  it("contains expected critical paths", () => {
+    expect(RESERVED_PATHS).toContain("dash");
+    expect(RESERVED_PATHS).toContain("api");
+    expect(RESERVED_PATHS).toContain("feed");
+    expect(RESERVED_PATHS).toContain("signin");
+    expect(RESERVED_PATHS).toContain("search");
+    expect(RESERVED_PATHS).toContain("p");
+    expect(RESERVED_PATHS).toContain("c");
+  });
+});
+
+describe("isReservedPath", () => {
+  it("returns true for reserved paths", () => {
+    expect(isReservedPath("dash")).toBe(true);
+    expect(isReservedPath("api")).toBe(true);
+    expect(isReservedPath("feed")).toBe(true);
+    expect(isReservedPath("signin")).toBe(true);
+  });
+
+  it("checks only the first segment", () => {
+    expect(isReservedPath("dash/settings")).toBe(true);
+    expect(isReservedPath("api/posts")).toBe(true);
+  });
+
+  it("is case-insensitive", () => {
+    expect(isReservedPath("DASH")).toBe(true);
+    expect(isReservedPath("Api")).toBe(true);
+    expect(isReservedPath("FEED")).toBe(true);
+  });
+
+  it("returns false for non-reserved paths", () => {
+    expect(isReservedPath("about")).toBe(false);
+    expect(isReservedPath("contact")).toBe(false);
+    expect(isReservedPath("my-custom-page")).toBe(false);
+  });
+
+  it("returns false for empty string", () => {
+    expect(isReservedPath("")).toBe(false);
+  });
+});

package/src/lib/__tests__/markdown.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "vitest";
+import { render, toPlainText, extractTitle } from "../markdown.js";
+
+describe("render", () => {
+  it("renders a heading", () => {
+    const html = render("# Hello");
+    expect(html).toContain("<h1>");
+    expect(html).toContain("Hello");
+  });
+
+  it("renders bold text", () => {
+    const html = render("This is **bold** text.");
+    expect(html).toContain("<strong>bold</strong>");
+  });
+
+  it("renders italic text", () => {
+    const html = render("This is *italic* text.");
+    expect(html).toContain("<em>italic</em>");
+  });
+
+  it("renders links", () => {
+    const html = render("[link](https://example.com)");
+    expect(html).toContain('href="https://example.com"');
+    expect(html).toContain(">link</a>");
+  });
+
+  it("renders code blocks", () => {
+    const html = render("```\nconst x = 1;\n```");
+    expect(html).toContain("<code>");
+  });
+
+  it("renders inline code", () => {
+    const html = render("Use `console.log()` here.");
+    expect(html).toContain("<code>console.log()</code>");
+  });
+
+  it("supports GFM line breaks", () => {
+    const html = render("Line 1\nLine 2");
+    expect(html).toContain("<br>");
+  });
+
+  it("returns a string", () => {
+    expect(typeof render("test")).toBe("string");
+  });
+
+  it("handles empty string", () => {
+    expect(render("")).toBe("");
+  });
+});
+
+describe("toPlainText", () => {
+  it("removes headers", () => {
+    expect(toPlainText("## Hello")).toBe("Hello");
+  });
+
+  it("removes bold syntax", () => {
+    expect(toPlainText("This is **bold** text")).toBe("This is bold text");
+  });
+
+  it("removes italic syntax", () => {
+    expect(toPlainText("This is *italic* text")).toBe("This is italic text");
+  });
+
+  it("extracts link text, removes URLs", () => {
+    expect(toPlainText("[a link](https://example.com)")).toBe("a link");
+  });
+
+  it("removes images (note: link regex runs first, leaving ! prefix)", () => {
+    // Known behavior: the link regex \[(.+?)\]\(.+?\) captures [alt](url) before
+    // the image regex !\[.*?\]\(.+?\) can match, leaving the "!" prefix
+    expect(toPlainText("![alt](image.png)")).toBe("!alt");
+  });
+
+  it("removes blockquotes", () => {
+    expect(toPlainText("> quoted text")).toBe("quoted text");
+  });
+
+  it("replaces newlines with spaces", () => {
+    const result = toPlainText("Line 1\nLine 2\nLine 3");
+    expect(result).toBe("Line 1 Line 2 Line 3");
+  });
+
+  it("handles complex markdown", () => {
+    const md = "## Hello\n\nThis is **bold** and [a link](url).";
+    const result = toPlainText(md);
+    expect(result).toBe("Hello This is bold and a link.");
+  });
+
+  it("handles empty string", () => {
+    expect(toPlainText("")).toBe("");
+  });
+});
+
+describe("extractTitle", () => {
+  it("extracts first sentence", () => {
+    expect(extractTitle("This is the first sentence. And another one.")).toBe(
+      "This is the first sentence",
+    );
+  });
+
+  it("extracts text before exclamation mark", () => {
+    expect(extractTitle("Hello world! More text here.")).toBe("Hello world");
+  });
+
+  it("extracts text before question mark", () => {
+    expect(extractTitle("What is this? Some answer.")).toBe("What is this");
+  });
+
+  it("truncates long text with ellipsis", () => {
+    const long = "A".repeat(200);
+    const result = extractTitle(long, 50);
+    expect(result.length).toBe(53); // 50 + "..."
+    expect(result.endsWith("...")).toBe(true);
+  });
+
+  it("returns full first sentence if under maxLength", () => {
+    expect(extractTitle("Short sentence.", 120)).toBe("Short sentence");
+  });
+
+  it("uses default maxLength of 120", () => {
+    const long = "A".repeat(200) + ".";
+    const result = extractTitle(long);
+    expect(result.length).toBe(123); // 120 + "..."
+  });
+
+  it("strips markdown before extracting", () => {
+    expect(extractTitle("## Hello world. More text.")).toBe("Hello world");
+  });
+
+  it("handles empty string", () => {
+    expect(extractTitle("")).toBe("");
+  });
+});