@jant/core 0.3.24 → 0.3.25

package/src/routes/api/__tests__/nav-items.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { navItemsApiRoutes } from "../nav-items.js";
+
+describe("Nav Items API Routes", () => {
+  describe("GET /api/nav-items", () => {
+    it("returns empty list when no nav items exist", async () => {
+      const { app } = createTestApp();
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const res = await app.request("/api/nav-items");
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.navItems).toEqual([]);
+    });
+
+    it("returns nav items ordered by position", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      await services.navItems.create({
+        type: "link",
+        label: "Home",
+        url: "/",
+      });
+      await services.navItems.create({
+        type: "link",
+        label: "Blog",
+        url: "/blog",
+      });
+
+      const res = await app.request("/api/nav-items");
+      const body = await res.json();
+
+      expect(body.navItems).toHaveLength(2);
+      expect(body.navItems[0].label).toBe("Home");
+      expect(body.navItems[1].label).toBe("Blog");
+    });
+  });
+
+  describe("POST /api/nav-items", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const res = await app.request("/api/nav-items", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          type: "link",
+          label: "Home",
+          url: "/",
+        }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("creates a nav item when authenticated", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const res = await app.request("/api/nav-items", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          type: "link",
+          label: "GitHub",
+          url: "https://github.com",
+        }),
+      });
+
+      expect(res.status).toBe(201);
+      const body = await res.json();
+      expect(body.label).toBe("GitHub");
+      expect(body.url).toBe("https://github.com");
+      expect(body.type).toBe("link");
+    });
+
+    it("returns 400 for missing required fields", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const res = await app.request("/api/nav-items", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "link" }),
+      });
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe("PUT /api/nav-items/reorder", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const res = await app.request("/api/nav-items/reorder", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids: [1, 2] }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("reorders nav items when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const item1 = await services.navItems.create({
+        type: "link",
+        label: "First",
+        url: "/first",
+      });
+      const item2 = await services.navItems.create({
+        type: "link",
+        label: "Second",
+        url: "/second",
+      });
+
+      // Reverse order
+      const res = await app.request("/api/nav-items/reorder", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids: [item2.id, item1.id] }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.navItems[0].label).toBe("Second");
+      expect(body.navItems[1].label).toBe("First");
+    });
+  });
+
+  describe("PUT /api/nav-items/:id", () => {
+    it("updates a nav item when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const item = await services.navItems.create({
+        type: "link",
+        label: "Old Label",
+        url: "/old",
+      });
+
+      const res = await app.request(`/api/nav-items/${item.id}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ label: "New Label" }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.label).toBe("New Label");
+    });
+
+    it("returns 404 for non-existent item", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const res = await app.request("/api/nav-items/9999", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ label: "test" }),
+      });
+
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe("DELETE /api/nav-items/:id", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const item = await services.navItems.create({
+        type: "link",
+        label: "Delete Me",
+        url: "/delete",
+      });
+
+      const res = await app.request(`/api/nav-items/${item.id}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("deletes a nav item when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const item = await services.navItems.create({
+        type: "link",
+        label: "Delete Me",
+        url: "/delete",
+      });
+
+      const res = await app.request(`/api/nav-items/${item.id}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.success).toBe(true);
+    });
+
+    it("returns 404 for non-existent item", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/nav-items", navItemsApiRoutes);
+
+      const res = await app.request("/api/nav-items/9999", {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(404);
+    });
+  });
+});

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

@@ -0,0 +1,218 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { pagesApiRoutes } from "../pages.js";
+
+describe("Pages API Routes", () => {
+  describe("GET /api/pages", () => {
+    it("returns empty list when no pages exist", async () => {
+      const { app } = createTestApp();
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages");
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.pages).toEqual([]);
+    });
+
+    it("returns pages list", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/pages", pagesApiRoutes);
+
+      await services.pages.create({ slug: "about", title: "About" });
+      await services.pages.create({ slug: "contact", title: "Contact" });
+
+      const res = await app.request("/api/pages");
+      const body = await res.json();
+
+      expect(body.pages).toHaveLength(2);
+    });
+  });
+
+  describe("GET /api/pages/:id", () => {
+    it("returns a page by id", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/pages", pagesApiRoutes);
+
+      const page = await services.pages.create({
+        slug: "about",
+        title: "About Us",
+      });
+
+      const res = await app.request(`/api/pages/${page.id}`);
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.title).toBe("About Us");
+      expect(body.slug).toBe("about");
+    });
+
+    it("returns 400 for invalid id", async () => {
+      const { app } = createTestApp();
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages/abc");
+      expect(res.status).toBe(400);
+    });
+
+    it("returns 404 for non-existent page", async () => {
+      const { app } = createTestApp();
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages/9999");
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe("POST /api/pages", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ slug: "about", title: "About" }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("creates a page when authenticated", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          slug: "about",
+          title: "About Us",
+          body: "We are Jant.",
+          status: "published",
+        }),
+      });
+
+      expect(res.status).toBe(201);
+      const body = await res.json();
+      expect(body.slug).toBe("about");
+      expect(body.title).toBe("About Us");
+    });
+
+    it("returns 400 for missing slug", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title: "No Slug" }),
+      });
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe("PUT /api/pages/:id", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const page = await services.pages.create({
+        slug: "about",
+        title: "About",
+      });
+
+      const res = await app.request(`/api/pages/${page.id}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title: "Updated" }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("updates a page when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const page = await services.pages.create({
+        slug: "about",
+        title: "About",
+      });
+
+      const res = await app.request(`/api/pages/${page.id}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title: "Updated About" }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.title).toBe("Updated About");
+    });
+
+    it("returns 404 for non-existent page", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages/9999", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title: "test" }),
+      });
+
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe("DELETE /api/pages/:id", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const page = await services.pages.create({
+        slug: "about",
+        title: "About",
+      });
+
+      const res = await app.request(`/api/pages/${page.id}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("deletes a page when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const page = await services.pages.create({
+        slug: "about",
+        title: "About",
+      });
+
+      const res = await app.request(`/api/pages/${page.id}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.success).toBe(true);
+
+      const found = await services.pages.getById(page.id);
+      expect(found).toBeNull();
+    });
+
+    it("returns 404 for non-existent page", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/pages", pagesApiRoutes);
+
+      const res = await app.request("/api/pages/9999", {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(404);
+    });
+  });
+});

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

@@ -0,0 +1,132 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { settingsApiRoutes } from "../settings.js";
+
+describe("Settings API Routes", () => {
+  describe("GET /api/settings", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings");
+      expect(res.status).toBe(401);
+    });
+
+    it("returns default settings when none are stored", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings");
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.settings).toBeDefined();
+      expect(body.settings.SITE_NAME).toBe("Jant");
+      expect(body.settings.SITE_DESCRIPTION).toBe(
+        "A microblog powered by Jant",
+      );
+      expect(body.settings.SITE_LANGUAGE).toBe("en");
+    });
+
+    it("returns stored settings overriding defaults", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/settings", settingsApiRoutes);
+
+      await services.settings.set("SITE_NAME" as never, "My Blog");
+
+      const res = await app.request("/api/settings");
+      const body = await res.json();
+
+      expect(body.settings.SITE_NAME).toBe("My Blog");
+    });
+
+    it("does not include env-only settings", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings");
+      const body = await res.json();
+
+      // Env-only keys should not be in the response
+      expect(body.settings.AUTH_SECRET).toBeUndefined();
+      expect(body.settings.SITE_URL).toBeUndefined();
+    });
+  });
+
+  describe("PUT /api/settings", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ SITE_NAME: "New Name" }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("updates editable settings", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ SITE_NAME: "Updated Blog" }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.settings.SITE_NAME).toBe("Updated Blog");
+    });
+
+    it("rejects env-only keys", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ AUTH_SECRET: "should-not-work" }),
+      });
+
+      expect(res.status).toBe(400);
+      const body = await res.json();
+      expect(body.rejectedKeys).toContain("AUTH_SECRET");
+    });
+
+    it("partially applies when mixing editable and env-only keys", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          SITE_NAME: "Mixed Update",
+          AUTH_SECRET: "ignored",
+        }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.settings.SITE_NAME).toBe("Mixed Update");
+      expect(body.rejectedKeys).toContain("AUTH_SECRET");
+    });
+
+    it("returns 400 for invalid body", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/settings", settingsApiRoutes);
+
+      const res = await app.request("/api/settings", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify("not an object"),
+      });
+
+      expect(res.status).toBe(400);
+    });
+  });
+});