@jant/core 0.3.1 → 0.3.3

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);
+    });
+  });
+});

package/src/theme/layouts/DashLayout.tsx

@@ -135,15 +135,6 @@ function DashLayoutContent({
                 comment: "@context: Dashboard navigation - site settings",
               })}
             </a>
-            <a
-              href="/dash/appearance"
-              class={navClass("/dash/appearance", /^\/dash\/appearance/)}
-            >
-              {t({
-                message: "Appearance",
-                comment: "@context: Dashboard navigation - appearance settings",
-              })}
-            </a>
           </nav>
         </aside>
 

package/dist/routes/dash/appearance.d.ts

@@ -1,13 +0,0 @@
-/**
- * Dashboard Appearance Routes
- */
-import { Hono } from "hono";
-import type { Bindings } from "../../types.js";
-import type { AppVariables } from "../../app.js";
-type Env = {
-    Bindings: Bindings;
-    Variables: AppVariables;
-};
-export declare const appearanceRoutes: Hono<Env, import("hono/types").BlankSchema, "/">;
-export {};
-//# sourceMappingURL=appearance.d.ts.map

package/dist/routes/dash/appearance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"appearance.d.ts","sourceRoot":"","sources":["../../../src/routes/dash/appearance.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAQjD,KAAK,GAAG,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;AAE3D,eAAO,MAAM,gBAAgB,kDAAkB,CAAC"}

package/dist/routes/dash/appearance.js

@@ -1,160 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
-/**
- * Dashboard Appearance Routes
- */ import { Hono } from "hono";
-import { useLingui as $_useLingui } from "@jant/core/i18n";
-import { DashLayout } from "../../theme/layouts/index.js";
-import { dsRedirect, dsToast } from "../../lib/sse.js";
-import { getSiteName } from "../../lib/config.js";
-import { SETTINGS_KEYS } from "../../lib/constants.js";
-import { getAvailableThemes } from "../../lib/theme.js";
-export const appearanceRoutes = new Hono();
-function ThemeCard({ theme, selected }) {
-    const expr = `$theme === '${theme.id}'`;
-    const { preview } = theme;
-    return /*#__PURE__*/ _jsx("label", {
-        class: `block cursor-pointer rounded-lg border overflow-hidden transition-colors ${selected ? "border-primary" : "border-border"}`,
-        "data-class:border-primary": expr,
-        "data-class:border-border": `$theme !== '${theme.id}'`,
-        children: /*#__PURE__*/ _jsxs("div", {
-            class: "grid grid-cols-2",
-            children: [
-                /*#__PURE__*/ _jsxs("div", {
-                    class: "p-5",
-                    style: `background-color:${preview.lightBg};color:${preview.lightText}`,
-                    children: [
-                        /*#__PURE__*/ _jsx("input", {
-                            type: "radio",
-                            name: "theme",
-                            value: theme.id,
-                            "data-bind": "theme",
-                            checked: selected || undefined,
-                            class: "mb-1"
-                        }),
-                        /*#__PURE__*/ _jsx("h3", {
-                            class: "font-bold text-lg",
-                            children: theme.name
-                        }),
-                        /*#__PURE__*/ _jsxs("p", {
-                            class: "text-sm mt-2 leading-relaxed",
-                            children: [
-                                "This is the ",
-                                theme.name,
-                                " theme in light mode. Links",
-                                " ",
-                                /*#__PURE__*/ _jsx("a", {
-                                    tabIndex: -1,
-                                    class: "underline",
-                                    style: `color:${preview.lightLink}`,
-                                    children: "look like this"
-                                }),
-                                ". We'll show the correct light or dark mode based on your visitor's settings."
-                            ]
-                        })
-                    ]
-                }),
-                /*#__PURE__*/ _jsxs("div", {
-                    class: "p-5",
-                    style: `background-color:${preview.darkBg};color:${preview.darkText}`,
-                    children: [
-                        /*#__PURE__*/ _jsx("h3", {
-                            class: "font-bold text-lg",
-                            children: theme.name
-                        }),
-                        /*#__PURE__*/ _jsxs("p", {
-                            class: "text-sm mt-2 leading-relaxed",
-                            children: [
-                                "This is the ",
-                                theme.name,
-                                " theme in dark mode. Links",
-                                " ",
-                                /*#__PURE__*/ _jsx("a", {
-                                    tabIndex: -1,
-                                    class: "underline",
-                                    style: `color:${preview.darkLink}`,
-                                    children: "look like this"
-                                }),
-                                ". We'll show the correct light or dark mode based on your visitor's settings."
-                            ]
-                        })
-                    ]
-                })
-            ]
-        })
-    });
-}
-function AppearanceContent({ themes, currentThemeId }) {
-    const { i18n: $__i18n, _: $__ } = $_useLingui();
-    const signals = JSON.stringify({
-        theme: currentThemeId
-    }).replace(/</g, "\\u003c");
-    return /*#__PURE__*/ _jsx("div", {
-        "data-signals": signals,
-        "data-on:change": "@post('/dash/appearance')",
-        class: "max-w-3xl",
-        children: /*#__PURE__*/ _jsxs("fieldset", {
-            children: [
-                /*#__PURE__*/ _jsx("legend", {
-                    class: "text-lg font-semibold",
-                    children: $__i18n._({
-                        id: "rFmBG3",
-                        message: "Color theme"
-                    })
-                }),
-                /*#__PURE__*/ _jsx("p", {
-                    class: "text-sm text-muted-foreground mb-4",
-                    children: $__i18n._({
-                        id: "07Epll",
-                        message: "This will theme both your site and your dashboard. All color themes support dark mode."
-                    })
-                }),
-                /*#__PURE__*/ _jsx("div", {
-                    class: "flex flex-col gap-4",
-                    children: themes.map((theme)=>/*#__PURE__*/ _jsx(ThemeCard, {
-                            theme: theme,
-                            selected: theme.id === currentThemeId
-                        }, theme.id))
-                })
-            ]
-        })
-    });
-}
-// Appearance page
-appearanceRoutes.get("/", async (c)=>{
-    const { settings } = c.var.services;
-    const siteName = await getSiteName(c);
-    const currentThemeId = await settings.get(SETTINGS_KEYS.THEME) ?? "default";
-    const themes = getAvailableThemes(c.var.config);
-    const saved = c.req.query("saved") !== undefined;
-    return c.html(/*#__PURE__*/ _jsx(DashLayout, {
-        c: c,
-        title: "Appearance",
-        siteName: siteName,
-        currentPath: "/dash/appearance",
-        toast: saved ? {
-            message: "Theme saved successfully."
-        } : undefined,
-        children: /*#__PURE__*/ _jsx(AppearanceContent, {
-            themes: themes,
-            currentThemeId: currentThemeId
-        })
-    }));
-});
-// Save theme
-appearanceRoutes.post("/", async (c)=>{
-    const body = await c.req.json();
-    const { settings } = c.var.services;
-    const themes = getAvailableThemes(c.var.config);
-    // Validate theme ID
-    const validTheme = themes.find((t)=>t.id === body.theme);
-    if (!validTheme) {
-        return dsToast("Invalid theme selected.", "error");
-    }
-    if (validTheme.id === "default") {
-        await settings.remove(SETTINGS_KEYS.THEME);
-    } else {
-        await settings.set(SETTINGS_KEYS.THEME, validTheme.id);
-    }
-    // Full page reload to apply the new theme CSS
-    return dsRedirect("/dash/appearance?saved");
-});