@jant/core 0.3.2 → 0.3.3

package/dist/routes/api/posts.js

@@ -27,7 +27,7 @@ postsApiRoutes.get("/", async (c)=>{
                 ...p,
                 sqid: sqid.encode(p.id)
             })),
-        nextCursor: posts.length === limit ? sqid.encode(posts[posts.length - 1].id) : null
+        nextCursor: posts.length === limit ? sqid.encode(posts[posts.length - 1]?.id ?? 0) : null
     });
 });
 // Get single post

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "bin": {
@@ -53,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",
@@ -85,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/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("");
+  });
+});

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

@@ -0,0 +1,220 @@
+import { describe, it, expect } from "vitest";
+import {
+  PostTypeSchema,
+  VisibilitySchema,
+  RedirectTypeSchema,
+  CreatePostSchema,
+  UpdatePostSchema,
+  parseFormData,
+  parseFormDataOptional,
+} from "../schemas.js";
+import { z } from "zod";
+import { POST_TYPES, VISIBILITY_LEVELS } from "../../types.js";
+
+describe("PostTypeSchema", () => {
+  it("accepts all valid post types", () => {
+    for (const type of POST_TYPES) {
+      expect(PostTypeSchema.parse(type)).toBe(type);
+    }
+  });
+
+  it("rejects invalid post types", () => {
+    expect(() => PostTypeSchema.parse("invalid")).toThrow();
+    expect(() => PostTypeSchema.parse("")).toThrow();
+    expect(() => PostTypeSchema.parse(123)).toThrow();
+  });
+});
+
+describe("VisibilitySchema", () => {
+  it("accepts all valid visibility levels", () => {
+    for (const level of VISIBILITY_LEVELS) {
+      expect(VisibilitySchema.parse(level)).toBe(level);
+    }
+  });
+
+  it("rejects invalid visibility levels", () => {
+    expect(() => VisibilitySchema.parse("public")).toThrow();
+    expect(() => VisibilitySchema.parse("private")).toThrow();
+  });
+});
+
+describe("RedirectTypeSchema", () => {
+  it("accepts 301 and 302 as strings", () => {
+    expect(RedirectTypeSchema.parse("301")).toBe("301");
+    expect(RedirectTypeSchema.parse("302")).toBe("302");
+  });
+
+  it("rejects other values", () => {
+    expect(() => RedirectTypeSchema.parse("200")).toThrow();
+    expect(() => RedirectTypeSchema.parse("404")).toThrow();
+    expect(() => RedirectTypeSchema.parse(301)).toThrow();
+  });
+});
+
+describe("CreatePostSchema", () => {
+  const validPost = {
+    type: "note",
+    content: "Hello world",
+    visibility: "quiet",
+  };
+
+  it("accepts a valid post with required fields", () => {
+    const result = CreatePostSchema.parse(validPost);
+    expect(result.type).toBe("note");
+    expect(result.content).toBe("Hello world");
+    expect(result.visibility).toBe("quiet");
+  });
+
+  it("accepts all post types", () => {
+    for (const type of POST_TYPES) {
+      expect(() =>
+        CreatePostSchema.parse({ ...validPost, type }),
+      ).not.toThrow();
+    }
+  });
+
+  it("accepts optional title", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      title: "My Post",
+    });
+    expect(result.title).toBe("My Post");
+  });
+
+  it("accepts valid path format", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      path: "my-post-slug",
+    });
+    expect(result.path).toBe("my-post-slug");
+  });
+
+  it("accepts empty path", () => {
+    const result = CreatePostSchema.parse({ ...validPost, path: "" });
+    expect(result.path).toBe("");
+  });
+
+  it("rejects invalid path format (uppercase)", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "MyPost" }),
+    ).toThrow();
+  });
+
+  it("rejects invalid path format (special chars)", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "my post!" }),
+    ).toThrow();
+  });
+
+  it("accepts valid source URL", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      sourceUrl: "https://example.com",
+    });
+    expect(result.sourceUrl).toBe("https://example.com");
+  });
+
+  it("accepts empty source URL", () => {
+    const result = CreatePostSchema.parse({ ...validPost, sourceUrl: "" });
+    expect(result.sourceUrl).toBe("");
+  });
+
+  it("rejects invalid source URL", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, sourceUrl: "not-a-url" }),
+    ).toThrow();
+  });
+
+  it("accepts optional publishedAt as positive integer", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      publishedAt: 1706745600,
+    });
+    expect(result.publishedAt).toBe(1706745600);
+  });
+
+  it("rejects negative publishedAt", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, publishedAt: -1 }),
+    ).toThrow();
+  });
+
+  it("rejects non-integer publishedAt", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, publishedAt: 1.5 }),
+    ).toThrow();
+  });
+
+  it("rejects missing required fields", () => {
+    expect(() => CreatePostSchema.parse({})).toThrow();
+    expect(() => CreatePostSchema.parse({ type: "note" })).toThrow();
+    expect(() => CreatePostSchema.parse({ content: "hello" })).toThrow();
+  });
+});
+
+describe("UpdatePostSchema", () => {
+  it("accepts empty object (all fields optional)", () => {
+    const result = UpdatePostSchema.parse({});
+    expect(result).toEqual({});
+  });
+
+  it("accepts partial updates", () => {
+    const result = UpdatePostSchema.parse({ title: "New Title" });
+    expect(result.title).toBe("New Title");
+  });
+
+  it("accepts only type", () => {
+    const result = UpdatePostSchema.parse({ type: "article" });
+    expect(result.type).toBe("article");
+  });
+
+  it("still validates field types", () => {
+    expect(() => UpdatePostSchema.parse({ type: "invalid" })).toThrow();
+  });
+});
+
+describe("parseFormData", () => {
+  it("parses a valid form field", () => {
+    const form = new FormData();
+    form.set("name", "hello");
+    expect(parseFormData(form, "name", z.string())).toBe("hello");
+  });
+
+  it("throws for missing required field", () => {
+    const form = new FormData();
+    expect(() => parseFormData(form, "missing", z.string())).toThrow(
+      "Missing required field: missing",
+    );
+  });
+
+  it("throws for invalid value", () => {
+    const form = new FormData();
+    form.set("type", "invalid-type");
+    expect(() => parseFormData(form, "type", PostTypeSchema)).toThrow();
+  });
+});
+
+describe("parseFormDataOptional", () => {
+  it("returns parsed value when present", () => {
+    const form = new FormData();
+    form.set("name", "hello");
+    expect(parseFormDataOptional(form, "name", z.string())).toBe("hello");
+  });
+
+  it("returns undefined when field is missing", () => {
+    const form = new FormData();
+    expect(parseFormDataOptional(form, "missing", z.string())).toBeUndefined();
+  });
+
+  it("returns undefined when field is empty string", () => {
+    const form = new FormData();
+    form.set("name", "");
+    expect(parseFormDataOptional(form, "name", z.string())).toBeUndefined();
+  });
+
+  it("throws for invalid value", () => {
+    const form = new FormData();
+    form.set("type", "invalid");
+    expect(() => parseFormDataOptional(form, "type", PostTypeSchema)).toThrow();
+  });
+});

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

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import { encode, decode, isValidSqid } from "../sqid.js";
+
+describe("encode", () => {
+  it("encodes a numeric ID to a string", () => {
+    const result = encode(1);
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThanOrEqual(4);
+  });
+
+  it("produces minimum 4-character strings", () => {
+    expect(encode(0).length).toBeGreaterThanOrEqual(4);
+    expect(encode(1).length).toBeGreaterThanOrEqual(4);
+    expect(encode(100).length).toBeGreaterThanOrEqual(4);
+  });
+
+  it("produces different strings for different IDs", () => {
+    const a = encode(1);
+    const b = encode(2);
+    const c = encode(100);
+    expect(a).not.toBe(b);
+    expect(b).not.toBe(c);
+  });
+
+  it("produces consistent results for the same ID", () => {
+    expect(encode(42)).toBe(encode(42));
+  });
+});
+
+describe("decode", () => {
+  it("decodes an encoded string back to the original ID", () => {
+    for (const id of [0, 1, 42, 100, 999, 10000]) {
+      const encoded = encode(id);
+      expect(decode(encoded)).toBe(id);
+    }
+  });
+
+  it("returns null for empty string", () => {
+    expect(decode("")).toBe(null);
+  });
+
+  it("handles round-trip encoding", () => {
+    const original = 12345;
+    const sqid = encode(original);
+    const decoded = decode(sqid);
+    expect(decoded).toBe(original);
+  });
+});
+
+describe("isValidSqid", () => {
+  it("returns true for valid encoded sqids", () => {
+    const sqid = encode(1);
+    expect(isValidSqid(sqid)).toBe(true);
+  });
+
+  it("returns true for various valid sqids", () => {
+    for (const id of [0, 1, 100, 999]) {
+      expect(isValidSqid(encode(id))).toBe(true);
+    }
+  });
+
+  it("returns false for empty string", () => {
+    expect(isValidSqid("")).toBe(false);
+  });
+});