@jant/core 0.3.23 → 0.3.25

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

@@ -0,0 +1,249 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { collectionsApiRoutes } from "../collections.js";
+
+describe("Collections API Routes", () => {
+  describe("GET /api/collections", () => {
+    it("returns empty list when no collections exist", async () => {
+      const { app } = createTestApp();
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections");
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.collections).toEqual([]);
+    });
+
+    it("returns collections with post counts", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+      await services.posts.create({
+        format: "note",
+        body: "tech post",
+        collectionId: col.id,
+      });
+
+      const res = await app.request("/api/collections");
+      const body = await res.json();
+
+      expect(body.collections).toHaveLength(1);
+      expect(body.collections[0].slug).toBe("tech");
+      expect(body.collections[0].postCount).toBe(1);
+    });
+  });
+
+  describe("GET /api/collections/:id", () => {
+    it("returns a collection by id", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech Articles",
+      });
+
+      const res = await app.request(`/api/collections/${col.id}`);
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.title).toBe("Tech Articles");
+      expect(body.slug).toBe("tech");
+    });
+
+    it("returns 400 for invalid id", async () => {
+      const { app } = createTestApp();
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections/abc");
+      expect(res.status).toBe(400);
+    });
+
+    it("returns 404 for non-existent collection", async () => {
+      const { app } = createTestApp();
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections/9999");
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe("POST /api/collections", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ slug: "tech", title: "Tech" }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("creates a collection when authenticated", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          slug: "tech",
+          title: "Tech",
+          description: "Tech articles",
+        }),
+      });
+
+      expect(res.status).toBe(201);
+      const body = await res.json();
+      expect(body.slug).toBe("tech");
+      expect(body.title).toBe("Tech");
+      expect(body.description).toBe("Tech articles");
+    });
+
+    it("returns 400 for missing required fields", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ slug: "tech" }),
+      });
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe("PUT /api/collections/reorder", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections/reorder", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids: [1, 2] }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("reorders collections when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col1 = await services.collections.create({
+        slug: "first",
+        title: "First",
+      });
+      const col2 = await services.collections.create({
+        slug: "second",
+        title: "Second",
+      });
+
+      const res = await app.request("/api/collections/reorder", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids: [col2.id, col1.id] }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.collections[0].slug).toBe("second");
+      expect(body.collections[1].slug).toBe("first");
+    });
+  });
+
+  describe("PUT /api/collections/:id", () => {
+    it("updates a collection when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+
+      const res = await app.request(`/api/collections/${col.id}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title: "Technology" }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.title).toBe("Technology");
+    });
+
+    it("returns 404 for non-existent collection", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections/9999", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title: "test" }),
+      });
+
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe("DELETE /api/collections/:id", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+
+      const res = await app.request(`/api/collections/${col.id}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("deletes a collection when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+
+      const res = await app.request(`/api/collections/${col.id}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.success).toBe(true);
+
+      const found = await services.collections.getById(col.id);
+      expect(found).toBeNull();
+    });
+
+    it("returns 404 for non-existent collection", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections/9999", {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(404);
+    });
+  });
+});

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