@jant/core 0.3.2 → 0.3.4

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

@@ -0,0 +1,110 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createRedirectService } from "../redirect.js";
+import type { Database } from "../../db/index.js";
+
+describe("RedirectService", () => {
+  let db: Database;
+  let redirectService: ReturnType<typeof createRedirectService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    redirectService = createRedirectService(db);
+  });
+
+  describe("create", () => {
+    it("creates a 301 redirect by default", async () => {
+      const redirect = await redirectService.create("/old-path", "/new-path");
+
+      expect(redirect.fromPath).toBe("old-path"); // normalizePath removes leading slash
+      expect(redirect.toPath).toBe("/new-path");
+      expect(redirect.type).toBe(301);
+      expect(redirect.id).toBe(1);
+    });
+
+    it("creates a 302 redirect", async () => {
+      const redirect = await redirectService.create(
+        "/temp",
+        "/destination",
+        302,
+      );
+
+      expect(redirect.type).toBe(302);
+    });
+
+    it("normalizes from path", async () => {
+      const redirect = await redirectService.create(
+        "  /OLD-PATH/  ",
+        "/new-path",
+      );
+
+      expect(redirect.fromPath).toBe("old-path");
+    });
+
+    it("replaces existing redirect for same from path", async () => {
+      await redirectService.create("/old", "/first");
+      const second = await redirectService.create("/old", "/second");
+
+      expect(second.toPath).toBe("/second");
+
+      const list = await redirectService.list();
+      expect(list).toHaveLength(1);
+    });
+  });
+
+  describe("getByPath", () => {
+    it("finds redirect by from path", async () => {
+      await redirectService.create("/old-page", "/new-page");
+
+      const found = await redirectService.getByPath("/old-page");
+      expect(found).not.toBeNull();
+      expect(found?.toPath).toBe("/new-page");
+    });
+
+    it("normalizes the lookup path", async () => {
+      await redirectService.create("/old-page", "/new-page");
+
+      const found = await redirectService.getByPath("  /OLD-PAGE/  ");
+      expect(found).not.toBeNull();
+    });
+
+    it("returns null for non-existent path", async () => {
+      const found = await redirectService.getByPath("/nonexistent");
+      expect(found).toBeNull();
+    });
+  });
+
+  describe("delete", () => {
+    it("deletes a redirect by ID", async () => {
+      const redirect = await redirectService.create("/old", "/new");
+      const result = await redirectService.delete(redirect.id);
+
+      expect(result).toBe(true);
+
+      const found = await redirectService.getByPath("/old");
+      expect(found).toBeNull();
+    });
+
+    it("returns false for non-existent ID", async () => {
+      const result = await redirectService.delete(9999);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("list", () => {
+    it("returns empty array when no redirects exist", async () => {
+      const redirects = await redirectService.list();
+      expect(redirects).toEqual([]);
+    });
+
+    it("returns all redirects", async () => {
+      await redirectService.create("/a", "/b");
+      await redirectService.create("/c", "/d");
+      await redirectService.create("/e", "/f");
+
+      const redirects = await redirectService.list();
+      expect(redirects).toHaveLength(3);
+    });
+  });
+});

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

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createSearchService } from "../search.js";
+import { createPostService } from "../post.js";
+import type { Database } from "../../db/index.js";
+import type BetterSqlite3 from "better-sqlite3";
+
+describe("SearchService", () => {
+  let db: Database;
+  let sqlite: BetterSqlite3.Database;
+  let postService: ReturnType<typeof createPostService>;
+
+  // Create a mock D1Database interface wrapping better-sqlite3
+  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;
+  }
+
+  beforeEach(() => {
+    const testDb = createTestDatabase({ fts: true });
+    db = testDb.db as unknown as Database;
+    sqlite = testDb.sqlite;
+    postService = createPostService(db);
+  });
+
+  it("returns empty results for empty query", async () => {
+    const d1 = createMockD1(sqlite);
+    const searchService = createSearchService(d1);
+
+    const results = await searchService.search("");
+    expect(results).toEqual([]);
+  });
+
+  it("returns empty results for whitespace-only query", async () => {
+    const d1 = createMockD1(sqlite);
+    const searchService = createSearchService(d1);
+
+    const results = await searchService.search("   ");
+    expect(results).toEqual([]);
+  });
+
+  it("finds posts by content", async () => {
+    await postService.create({
+      type: "note",
+      content: "Hello world from jant",
+      visibility: "featured",
+    });
+    await postService.create({
+      type: "note",
+      content: "Another post entirely",
+      visibility: "featured",
+    });
+
+    const d1 = createMockD1(sqlite);
+    const searchService = createSearchService(d1);
+
+    const results = await searchService.search("jant");
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results[0]?.post.content).toContain("jant");
+  });
+
+  it("finds posts by title", async () => {
+    await postService.create({
+      type: "article",
+      title: "Introduction to TypeScript",
+      content: "Some article body",
+      visibility: "quiet",
+    });
+
+    const d1 = createMockD1(sqlite);
+    const searchService = createSearchService(d1);
+
+    const results = await searchService.search("TypeScript");
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results[0]?.post.title).toContain("TypeScript");
+  });
+
+  it("respects visibility filter", async () => {
+    await postService.create({
+      type: "note",
+      content: "visible post about testing",
+      visibility: "featured",
+    });
+    await postService.create({
+      type: "note",
+      content: "draft post about testing",
+      visibility: "draft",
+    });
+
+    const d1 = createMockD1(sqlite);
+    const searchService = createSearchService(d1);
+
+    const results = await searchService.search("testing", {
+      visibility: ["featured"],
+    });
+
+    expect(results.every((r) => r.post.visibility === "featured")).toBe(true);
+  });
+
+  it("excludes deleted posts", async () => {
+    const post = await postService.create({
+      type: "note",
+      content: "deleted post with unique search term xyzzy",
+      visibility: "featured",
+    });
+    await postService.delete(post.id);
+
+    const d1 = createMockD1(sqlite);
+    const searchService = createSearchService(d1);
+
+    const results = await searchService.search("xyzzy");
+    expect(results).toHaveLength(0);
+  });
+
+  it("supports limit and offset", async () => {
+    for (let i = 0; i < 5; i++) {
+      await postService.create({
+        type: "note",
+        content: `searchable post number ${i}`,
+        visibility: "featured",
+      });
+    }
+
+    const d1 = createMockD1(sqlite);
+    const searchService = createSearchService(d1);
+
+    const limited = await searchService.search("searchable", { limit: 2 });
+    expect(limited.length).toBeLessThanOrEqual(2);
+  });
+});

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

@@ -0,0 +1,110 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createSettingsService } from "../settings.js";
+import type { Database } from "../../db/index.js";
+
+describe("SettingsService", () => {
+  let db: Database;
+  let settingsService: ReturnType<typeof createSettingsService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    settingsService = createSettingsService(db);
+  });
+
+  describe("get", () => {
+    it("returns null for non-existent key", async () => {
+      const result = await settingsService.get("SITE_NAME");
+      expect(result).toBeNull();
+    });
+
+    it("returns value after set", async () => {
+      await settingsService.set("SITE_NAME", "My Blog");
+      const result = await settingsService.get("SITE_NAME");
+      expect(result).toBe("My Blog");
+    });
+  });
+
+  describe("set", () => {
+    it("creates a new setting", async () => {
+      await settingsService.set("SITE_NAME", "Test Site");
+      const result = await settingsService.get("SITE_NAME");
+      expect(result).toBe("Test Site");
+    });
+
+    it("updates existing setting (upsert)", async () => {
+      await settingsService.set("SITE_NAME", "Original");
+      await settingsService.set("SITE_NAME", "Updated");
+      const result = await settingsService.get("SITE_NAME");
+      expect(result).toBe("Updated");
+    });
+  });
+
+  describe("getAll", () => {
+    it("returns empty object when no settings exist", async () => {
+      const result = await settingsService.getAll();
+      expect(result).toEqual({});
+    });
+
+    it("returns all settings as key-value pairs", async () => {
+      await settingsService.set("SITE_NAME", "My Blog");
+      await settingsService.set("SITE_DESCRIPTION", "A cool blog");
+
+      const result = await settingsService.getAll();
+      expect(result).toEqual({
+        SITE_NAME: "My Blog",
+        SITE_DESCRIPTION: "A cool blog",
+      });
+    });
+  });
+
+  describe("setMany", () => {
+    it("sets multiple values at once", async () => {
+      await settingsService.setMany({
+        SITE_NAME: "My Blog",
+        SITE_DESCRIPTION: "Description",
+      });
+
+      expect(await settingsService.get("SITE_NAME")).toBe("My Blog");
+      expect(await settingsService.get("SITE_DESCRIPTION")).toBe("Description");
+    });
+
+    it("skips undefined values", async () => {
+      await settingsService.set("SITE_NAME", "Original");
+      await settingsService.setMany({
+        SITE_NAME: undefined,
+        SITE_DESCRIPTION: "New",
+      });
+
+      expect(await settingsService.get("SITE_NAME")).toBe("Original");
+      expect(await settingsService.get("SITE_DESCRIPTION")).toBe("New");
+    });
+  });
+
+  describe("remove", () => {
+    it("removes a setting", async () => {
+      await settingsService.set("SITE_NAME", "Test");
+      await settingsService.remove("SITE_NAME");
+      const result = await settingsService.get("SITE_NAME");
+      expect(result).toBeNull();
+    });
+
+    it("does not throw when removing non-existent key", async () => {
+      await expect(settingsService.remove("SITE_NAME")).resolves.not.toThrow();
+    });
+  });
+
+  describe("onboarding", () => {
+    it("returns false when onboarding is not complete", async () => {
+      const result = await settingsService.isOnboardingComplete();
+      expect(result).toBe(false);
+    });
+
+    it("returns true after completing onboarding", async () => {
+      await settingsService.completeOnboarding();
+      const result = await settingsService.isOnboardingComplete();
+      expect(result).toBe(true);
+    });
+  });
+});