@jant/core 0.3.23 → 0.3.25

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

@@ -22,16 +22,15 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       await services.posts.create({
-        type: "note",
-        content: "Hello world",
-        visibility: "featured",
+        format: "note",
+        body: "Hello world",
       });
 
       const res = await app.request("/api/posts");
       const body = await res.json();
 
       expect(body.posts).toHaveLength(1);
-      expect(body.posts[0].content).toBe("Hello world");
+      expect(body.posts[0].body).toBe("Hello world");
       expect(body.posts[0].sqid).toBeTruthy();
     });
 
@@ -40,9 +39,8 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "with media",
-        visibility: "featured",
+        format: "note",
+        body: "with media",
       });
 
       const media = await services.media.create({
@@ -68,26 +66,25 @@ describe("Posts API Routes", () => {
       expect(body.posts[0].mediaAttachments[0].position).toBe(0);
     });
 
-    it("filters by visibility", async () => {
+    it("filters by status", async () => {
       const { app, services } = createTestApp();
       app.route("/api/posts", postsApiRoutes);
 
       await services.posts.create({
-        type: "note",
-        content: "featured",
-        visibility: "featured",
+        format: "note",
+        body: "published post",
       });
       await services.posts.create({
-        type: "note",
-        content: "draft",
-        visibility: "draft",
+        format: "note",
+        body: "draft post",
+        status: "draft",
       });
 
-      const res = await app.request("/api/posts?visibility=draft");
+      const res = await app.request("/api/posts?status=draft");
       const body = await res.json();
 
       expect(body.posts).toHaveLength(1);
-      expect(body.posts[0].visibility).toBe("draft");
+      expect(body.posts[0].status).toBe("draft");
     });
 
     it("supports limit parameter", async () => {
@@ -96,9 +93,8 @@ describe("Posts API Routes", () => {
 
       for (let i = 0; i < 5; i++) {
         await services.posts.create({
-          type: "note",
-          content: `post ${i}`,
-          visibility: "featured",
+          format: "note",
+          body: `post ${i}`,
         });
       }
 
@@ -116,9 +112,8 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "test post",
-        visibility: "featured",
+        format: "note",
+        body: "test post",
       });
       const id = sqid.encode(post.id);
 
@@ -126,7 +121,7 @@ describe("Posts API Routes", () => {
       expect(res.status).toBe(200);
 
       const body = await res.json();
-      expect(body.content).toBe("test post");
+      expect(body.body).toBe("test post");
       expect(body.sqid).toBe(id);
     });
 
@@ -135,9 +130,8 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "with media",
-        visibility: "featured",
+        format: "note",
+        body: "with media",
       });
 
       const media = await services.media.create({
@@ -183,9 +177,8 @@ describe("Posts API Routes", () => {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          type: "note",
-          content: "test",
-          visibility: "quiet",
+          format: "note",
+          body: "test",
         }),
       });
 
@@ -200,16 +193,15 @@ describe("Posts API Routes", () => {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          type: "note",
-          content: "Hello from API",
-          visibility: "quiet",
+          format: "note",
+          body: "Hello from API",
         }),
       });
 
       expect(res.status).toBe(201);
 
       const body = await res.json();
-      expect(body.content).toBe("Hello from API");
+      expect(body.body).toBe("Hello from API");
       expect(body.sqid).toBeTruthy();
       expect(body.mediaAttachments).toEqual([]);
     });
@@ -237,9 +229,8 @@ describe("Posts API Routes", () => {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          type: "note",
-          content: "with images",
-          visibility: "quiet",
+          format: "note",
+          body: "with images",
           mediaIds: [m1.id, m2.id],
         }),
       });
@@ -253,54 +244,6 @@ describe("Posts API Routes", () => {
       expect(body.mediaAttachments[1].position).toBe(1);
     });
 
-    it("returns 400 for image type without media", async () => {
-      const { app } = createTestApp({ authenticated: true });
-      app.route("/api/posts", postsApiRoutes);
-
-      const res = await app.request("/api/posts", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          type: "image",
-          content: "should fail",
-          visibility: "quiet",
-          mediaIds: [],
-        }),
-      });
-
-      expect(res.status).toBe(400);
-      const body = await res.json();
-      expect(body.error).toContain("image posts require at least 1");
-    });
-
-    it("returns 400 for page type with media", async () => {
-      const { app, services } = createTestApp({ authenticated: true });
-      app.route("/api/posts", postsApiRoutes);
-
-      const m1 = await services.media.create({
-        filename: "a.jpg",
-        originalName: "a.jpg",
-        mimeType: "image/jpeg",
-        size: 1024,
-        storageKey: "media/2025/01/a.jpg",
-      });
-
-      const res = await app.request("/api/posts", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          type: "page",
-          content: "test",
-          visibility: "quiet",
-          mediaIds: [m1.id],
-        }),
-      });
-
-      expect(res.status).toBe(400);
-      const body = await res.json();
-      expect(body.error).toContain("page posts do not allow");
-    });
-
     it("returns 400 for invalid media IDs", async () => {
       const { app } = createTestApp({ authenticated: true });
       app.route("/api/posts", postsApiRoutes);
@@ -309,9 +252,8 @@ describe("Posts API Routes", () => {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          type: "note",
-          content: "test",
-          visibility: "quiet",
+          format: "note",
+          body: "test",
           mediaIds: ["nonexistent-id"],
         }),
       });
@@ -328,7 +270,7 @@ describe("Posts API Routes", () => {
       const res = await app.request("/api/posts", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ type: "invalid-type" }),
+        body: JSON.stringify({ format: "invalid-type" }),
       });
 
       expect(res.status).toBe(400);
@@ -356,14 +298,14 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "original",
+        format: "note",
+        body: "original",
       });
 
       const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ content: "updated" }),
+        body: JSON.stringify({ body: "updated" }),
       });
 
       expect(res.status).toBe(401);
@@ -374,19 +316,19 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "original",
+        format: "note",
+        body: "original",
       });
 
       const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ content: "updated" }),
+        body: JSON.stringify({ body: "updated" }),
       });
 
       expect(res.status).toBe(200);
       const body = await res.json();
-      expect(body.content).toBe("updated");
+      expect(body.body).toBe("updated");
       expect(body.mediaAttachments).toEqual([]);
     });
 
@@ -395,8 +337,8 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
 
       const m1 = await services.media.create({
@@ -434,8 +376,8 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
 
       const m1 = await services.media.create({
@@ -451,7 +393,7 @@ describe("Posts API Routes", () => {
       const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ content: "updated content" }),
+        body: JSON.stringify({ body: "updated content" }),
       });
 
       expect(res.status).toBe(200);
@@ -467,7 +409,7 @@ describe("Posts API Routes", () => {
       const res = await app.request(`/api/posts/${sqid.encode(9999)}`, {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ content: "test" }),
+        body: JSON.stringify({ body: "test" }),
       });
 
       expect(res.status).toBe(404);
@@ -478,14 +420,14 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
 
       const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ type: "invalid-type" }),
+        body: JSON.stringify({ format: "invalid-type" }),
       });
 
       expect(res.status).toBe(400);
@@ -498,8 +440,8 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
 
       const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
@@ -514,8 +456,8 @@ describe("Posts API Routes", () => {
       app.route("/api/posts", postsApiRoutes);
 
       const post = await services.posts.create({
-        type: "note",
-        content: "to be deleted",
+        format: "note",
+        body: "to be deleted",
       });
 
       const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {

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

@@ -39,9 +39,8 @@ describe("Search API Routes", () => {
     app.route("/api/search", searchApiRoutes);
 
     await services.posts.create({
-      type: "note",
-      content: "Testing search functionality in jant",
-      visibility: "featured",
+      format: "note",
+      body: "Testing search functionality in jant",
     });
 
     const res = await app.request("/api/search?q=jant");

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

package/src/routes/api/collections.ts

@@ -0,0 +1,143 @@
+/**
+ * Collections API Routes
+ */
+
+import { Hono } from "hono";
+import type { Bindings, SortOrder } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { requireAuthApi } from "../../middleware/auth.js";
+import { z } from "zod";
+import { SORT_ORDERS } from "../../types.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const collectionsApiRoutes = new Hono<Env>();
+
+const SortOrderSchema = z.enum(SORT_ORDERS);
+
+const CreateCollectionSchema = z.object({
+  slug: z.string().min(1),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  sortOrder: SortOrderSchema.optional(),
+  position: z.number().int().min(0).optional(),
+  showDivider: z.boolean().optional(),
+});
+
+const UpdateCollectionSchema = z.object({
+  slug: z.string().min(1).optional(),
+  title: z.string().min(1).optional(),
+  description: z.string().nullable().optional(),
+  icon: z.string().nullable().optional(),
+  sortOrder: SortOrderSchema.optional(),
+  position: z.number().int().min(0).optional(),
+  showDivider: z.boolean().optional(),
+});
+
+const ReorderSchema = z.object({
+  ids: z.array(z.number().int().positive()),
+});
+
+// List collections (includes post counts)
+collectionsApiRoutes.get("/", async (c) => {
+  const collections = await c.var.services.collections.list();
+  const postCounts = await c.var.services.collections.getPostCounts();
+
+  return c.json({
+    collections: collections.map((col) => ({
+      ...col,
+      postCount: postCounts.get(col.id) ?? 0,
+    })),
+  });
+});
+
+// Get single collection
+collectionsApiRoutes.get("/:id", async (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  if (isNaN(id)) return c.json({ error: "Invalid ID" }, 400);
+
+  const collection = await c.var.services.collections.getById(id);
+  if (!collection) return c.json({ error: "Not found" }, 404);
+
+  return c.json(collection);
+});
+
+// Reorder collections (requires auth) — must be before /:id
+collectionsApiRoutes.put("/reorder", requireAuthApi(), async (c) => {
+  const rawBody = await c.req.json();
+
+  const parseResult = ReorderSchema.safeParse(rawBody);
+  if (!parseResult.success) {
+    return c.json(
+      { error: "Validation failed", details: parseResult.error.flatten() },
+      400,
+    );
+  }
+
+  await c.var.services.collections.reorder(parseResult.data.ids);
+  const collections = await c.var.services.collections.list();
+  return c.json({ collections });
+});
+
+// Create collection (requires auth)
+collectionsApiRoutes.post("/", requireAuthApi(), async (c) => {
+  const rawBody = await c.req.json();
+
+  const parseResult = CreateCollectionSchema.safeParse(rawBody);
+  if (!parseResult.success) {
+    return c.json(
+      { error: "Validation failed", details: parseResult.error.flatten() },
+      400,
+    );
+  }
+
+  const body = parseResult.data;
+
+  const collection = await c.var.services.collections.create({
+    slug: body.slug,
+    title: body.title,
+    description: body.description,
+    icon: body.icon,
+    sortOrder: body.sortOrder as SortOrder | undefined,
+    position: body.position,
+    showDivider: body.showDivider,
+  });
+
+  return c.json(collection, 201);
+});
+
+// Update collection (requires auth)
+collectionsApiRoutes.put("/:id", requireAuthApi(), async (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  if (isNaN(id)) return c.json({ error: "Invalid ID" }, 400);
+
+  const rawBody = await c.req.json();
+
+  const parseResult = UpdateCollectionSchema.safeParse(rawBody);
+  if (!parseResult.success) {
+    return c.json(
+      { error: "Validation failed", details: parseResult.error.flatten() },
+      400,
+    );
+  }
+
+  const collection = await c.var.services.collections.update(
+    id,
+    parseResult.data,
+  );
+  if (!collection) return c.json({ error: "Not found" }, 404);
+
+  return c.json(collection);
+});
+
+// Delete collection (requires auth)
+collectionsApiRoutes.delete("/:id", requireAuthApi(), async (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  if (isNaN(id)) return c.json({ error: "Invalid ID" }, 400);
+
+  const success = await c.var.services.collections.delete(id);
+  if (!success) return c.json({ error: "Not found" }, 404);
+
+  return c.json({ success: true });
+});