@jant/core 0.3.26 → 0.3.28

package/src/routes/__tests__/compose.test.ts

@@ -18,7 +18,7 @@ describe("Compose Routes", () => {
       expect(res.headers.get("Location")).toBe("/signin");
     });
 
-    it("creates a note post and returns redirect", async () => {
+    it("creates a note post and returns timeline card via SSE", async () => {
       const { app, services } = createTestApp({ authenticated: true });
       app.route("/compose", composeRoutes);
 
@@ -29,7 +29,13 @@ describe("Compose Routes", () => {
       });
 
       expect(res.status).toBe(200);
-      expect(res.headers.get("Content-Type")).toBe("text/html");
+      expect(res.headers.get("Content-Type")).toBe("text/event-stream");
+
+      const text = await res.text();
+      // SSE prepends the card to the timeline
+      expect(text).toContain("datastar-patch-elements");
+      expect(text).toContain('data-format="note"');
+      expect(text).toContain("selector #timeline-items");
 
       // Verify post was created
       const posts = await services.posts.list();
@@ -54,6 +60,10 @@ describe("Compose Routes", () => {
       });
 
       expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toBe("text/event-stream");
+
+      const text = await res.text();
+      expect(text).toContain('data-format="link"');
 
       const posts = await services.posts.list();
       expect(posts).toHaveLength(1);
@@ -77,6 +87,10 @@ describe("Compose Routes", () => {
       });
 
       expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toBe("text/event-stream");
+
+      const text = await res.text();
+      expect(text).toContain('data-format="quote"');
 
       const posts = await services.posts.list();
       expect(posts).toHaveLength(1);
@@ -84,7 +98,7 @@ describe("Compose Routes", () => {
       expect(posts[0].quoteText).toBe("The original quote");
     });
 
-    it("creates a draft when status is draft", async () => {
+    it("creates a draft and closes dialog with toast", async () => {
       const { app, services } = createTestApp({ authenticated: true });
       app.route("/compose", composeRoutes);
 
@@ -99,6 +113,13 @@ describe("Compose Routes", () => {
       });
 
       expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toBe("text/event-stream");
+
+      const text = await res.text();
+      // Should close dialog and show toast, not prepend to timeline
+      expect(text).toContain("compose-dialog");
+      expect(text).toContain("Draft saved");
+      expect(text).not.toContain("selector #timeline-items");
 
       const posts = await services.posts.list({ includeDrafts: true });
       expect(posts).toHaveLength(1);
@@ -158,27 +179,20 @@ describe("Compose Routes", () => {
       expect(attachments[0].id).toBe(media.id);
     });
 
-    it("sets featured and pinned flags", async () => {
-      const { app, services } = createTestApp({ authenticated: true });
+    it("resets compose signals after publishing", async () => {
+      const { app } = createTestApp({ authenticated: true });
       app.route("/compose", composeRoutes);
 
       const res = await app.request("/compose", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          format: "note",
-          body: "Featured and pinned",
-          featured: true,
-          pinned: true,
-        }),
+        body: JSON.stringify({ format: "note", body: "Hello" }),
       });
 
-      expect(res.status).toBe(200);
-
-      const posts = await services.posts.list();
-      expect(posts).toHaveLength(1);
-      expect(posts[0].featured).toBe(1);
-      expect(posts[0].pinned).toBe(1);
+      const text = await res.text();
+      // SSE should include signal reset
+      expect(text).toContain("datastar-patch-signals");
+      expect(text).toContain('"_composeLoading":false');
     });
 
     it("returns error when format is missing", async () => {
@@ -196,4 +210,77 @@ describe("Compose Routes", () => {
       expect(text).toContain("toast-error");
     });
   });
+
+  describe("POST /compose (JSON mode)", () => {
+    it("returns JSON for published note", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+        body: JSON.stringify({ format: "note", body: "Hello JSON" }),
+      });
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toContain("application/json");
+
+      const data = await res.json();
+      expect(data.status).toBe("published");
+      expect(data.cardHtml).toContain('data-format="note"');
+
+      const posts = await services.posts.list();
+      expect(posts).toHaveLength(1);
+      expect(posts[0].body).toBe("Hello JSON");
+    });
+
+    it("returns JSON for draft", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+        body: JSON.stringify({
+          format: "note",
+          body: "Draft JSON",
+          status: "draft",
+        }),
+      });
+
+      expect(res.status).toBe(200);
+      const data = await res.json();
+      expect(data.status).toBe("draft");
+      expect(data.toast).toBe("Draft saved.");
+
+      const posts = await services.posts.list({ includeDrafts: true });
+      expect(posts).toHaveLength(1);
+      expect(posts[0].status).toBe("draft");
+    });
+
+    it("returns JSON error for invalid input", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+        body: JSON.stringify({ format: "invalid", body: "Hello" }),
+      });
+
+      expect(res.status).toBe(422);
+      const data = await res.json();
+      expect(data.status).toBe("error");
+      expect(data.error).toBeDefined();
+    });
+  });
 });

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

@@ -23,11 +23,11 @@ describe("Collections API Routes", () => {
         slug: "tech",
         title: "Tech",
       });
-      await services.posts.create({
+      const post = await services.posts.create({
         format: "note",
         body: "tech post",
-        collectionId: col.id,
       });
+      await services.collections.addPost(col.id, post.id);
 
       const res = await app.request("/api/collections");
       const body = await res.json();
@@ -246,4 +246,95 @@ describe("Collections API Routes", () => {
       expect(res.status).toBe(404);
     });
   });
+
+  describe("POST /api/collections/:id/posts", () => {
+    it("adds a post to a collection", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+      const post = await services.posts.create({
+        format: "note",
+        body: "test",
+      });
+
+      const res = await app.request(`/api/collections/${col.id}/posts`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ postId: post.id }),
+      });
+
+      expect(res.status).toBe(201);
+
+      const postIds = await services.collections.getPostIds(col.id);
+      expect(postIds).toContain(post.id);
+    });
+
+    it("returns 404 for non-existent collection", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const post = await services.posts.create({
+        format: "note",
+        body: "test",
+      });
+
+      const res = await app.request("/api/collections/9999/posts", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ postId: post.id }),
+      });
+
+      expect(res.status).toBe(404);
+    });
+
+    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}/posts`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ postId: 1 }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+  });
+
+  describe("DELETE /api/collections/:id/posts/:postId", () => {
+    it("removes a post from a collection", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+      const post = await services.posts.create({
+        format: "note",
+        body: "test",
+      });
+
+      await services.collections.addPost(col.id, post.id);
+
+      const res = await app.request(
+        `/api/collections/${col.id}/posts/${post.id}`,
+        { method: "DELETE" },
+      );
+
+      expect(res.status).toBe(200);
+
+      const postIds = await services.collections.getPostIds(col.id);
+      expect(postIds).not.toContain(post.id);
+    });
+  });
 });

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

@@ -275,7 +275,8 @@ describe("Posts API Routes", () => {
 
       expect(res.status).toBe(400);
       const body = await res.json();
-      expect(body.error).toBe("Validation failed");
+      expect(body.error).toContain("Invalid");
+      expect(body.code).toBe("VALIDATION_ERROR");
     });
 
     it("returns 400 for missing required fields", async () => {

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

@@ -94,7 +94,7 @@ describe("Settings API Routes", () => {
 
       expect(res.status).toBe(400);
       const body = await res.json();
-      expect(body.rejectedKeys).toContain("AUTH_SECRET");
+      expect(body.details.rejectedKeys).toContain("AUTH_SECRET");
     });
 
     it("partially applies when mixing editable and env-only keys", async () => {

package/src/routes/api/collections.ts

@@ -3,40 +3,37 @@
  */
 
 import { Hono } from "hono";
+import { z } from "zod";
 import type { Bindings, SortOrder } from "../../types.js";
-import type { AppVariables } from "../../app.js";
+import type { AppVariables } from "../../types/app-context.js";
 import { requireAuthApi } from "../../middleware/auth.js";
-import { z } from "zod";
-import { SORT_ORDERS } from "../../types.js";
+import {
+  CreateCollectionSchema,
+  SortOrderSchema,
+  parseValidated,
+} from "../../lib/schemas.js";
+import { assertFound, parseIntParam, NotFoundError } from "../../lib/errors.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(),
+// API update schema extends shared schema with nullable fields for explicit clearing
+const UpdateCollectionSchema = CreateCollectionSchema.partial().extend({
   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()),
+// Route-specific schemas (not shared domain schemas)
+const CollectionReorderSchema = z.object({
+  ids: z.array(z.number().int().positive()).optional(),
+  items: z.array(z.string().regex(/^[cd]-\d+$/)).optional(),
+});
+
+const PostAssignSchema = z.object({
+  postId: z.number().int().positive(),
 });
 
 // List collections (includes post counts)
@@ -54,45 +51,30 @@ collectionsApiRoutes.get("/", async (c) => {
 
 // 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);
-
+  const id = parseIntParam(c.req.param("id"));
+  const collection = assertFound(
+    await c.var.services.collections.getById(id),
+    "Collection",
+  );
   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,
-    );
-  }
+  const body = parseValidated(CollectionReorderSchema, await c.req.json());
 
-  await c.var.services.collections.reorder(parseResult.data.ids);
+  if (body.items) {
+    await c.var.services.collections.reorderAll(body.items);
+  } else if (body.ids) {
+    await c.var.services.collections.reorder(body.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 body = parseValidated(CreateCollectionSchema, await c.req.json());
 
   const collection = await c.var.services.collections.create({
     slug: body.slug,
@@ -101,7 +83,6 @@ collectionsApiRoutes.post("/", requireAuthApi(), async (c) => {
     icon: body.icon,
     sortOrder: body.sortOrder as SortOrder | undefined,
     position: body.position,
-    showDivider: body.showDivider,
   });
 
   return c.json(collection, 201);
@@ -109,35 +90,50 @@ collectionsApiRoutes.post("/", requireAuthApi(), async (c) => {
 
 // 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 id = parseIntParam(c.req.param("id"));
+  const body = parseValidated(UpdateCollectionSchema, await c.req.json());
 
-  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,
+  const collection = assertFound(
+    await c.var.services.collections.update(id, body),
+    "Collection",
   );
-  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 id = parseIntParam(c.req.param("id"));
 
   const success = await c.var.services.collections.delete(id);
-  if (!success) return c.json({ error: "Not found" }, 404);
+  if (!success) throw new NotFoundError("Collection");
 
   return c.json({ success: true });
 });
+
+// Add a post to a collection (requires auth)
+collectionsApiRoutes.post("/:id/posts", requireAuthApi(), async (c) => {
+  const id = parseIntParam(c.req.param("id"));
+  assertFound(await c.var.services.collections.getById(id), "Collection");
+
+  const body = parseValidated(PostAssignSchema, await c.req.json());
+  assertFound(await c.var.services.posts.getById(body.postId), "Post");
+
+  await c.var.services.collections.addPost(id, body.postId);
+
+  return c.json({ success: true }, 201);
+});
+
+// Remove a post from a collection (requires auth)
+collectionsApiRoutes.delete(
+  "/:id/posts/:postId",
+  requireAuthApi(),
+  async (c) => {
+    const id = parseIntParam(c.req.param("id"));
+    const postId = parseIntParam(c.req.param("postId"));
+
+    await c.var.services.collections.removePost(id, postId);
+
+    return c.json({ success: true });
+  },
+);

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

@@ -3,35 +3,24 @@
  */
 
 import { Hono } from "hono";
+import { z } from "zod";
 import type { Bindings, NavItemType } from "../../types.js";
-import type { AppVariables } from "../../app.js";
+import type { AppVariables } from "../../types/app-context.js";
 import { requireAuthApi } from "../../middleware/auth.js";
-import { z } from "zod";
+import {
+  CreateNavItemSchema,
+  ReorderSchema,
+  parseValidated,
+} from "../../lib/schemas.js";
+import { assertFound, parseIntParam, NotFoundError } from "../../lib/errors.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const navItemsApiRoutes = new Hono<Env>();
 
-const NavItemTypeSchema = z.enum(["link", "page"]);
-
-const CreateNavItemSchema = z.object({
-  type: NavItemTypeSchema,
-  label: z.string().min(1),
-  url: z.string().min(1),
-  pageId: z.number().int().positive().optional(),
-  position: z.number().int().min(0).optional(),
-});
-
-const UpdateNavItemSchema = z.object({
-  type: NavItemTypeSchema.optional(),
-  label: z.string().min(1).optional(),
-  url: z.string().min(1).optional(),
+// API update schema extends shared schema with nullable pageId for explicit clearing
+const UpdateNavItemSchema = CreateNavItemSchema.partial().extend({
   pageId: z.number().int().positive().nullable().optional(),
-  position: z.number().int().min(0).optional(),
-});
-
-const ReorderSchema = z.object({
-  ids: z.array(z.number().int().positive()),
 });
 
 // List nav items
@@ -42,34 +31,16 @@ navItemsApiRoutes.get("/", async (c) => {
 
 // Reorder nav items (requires auth) — must be before /:id
 navItemsApiRoutes.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,
-    );
-  }
+  const body = parseValidated(ReorderSchema, await c.req.json());
 
-  await c.var.services.navItems.reorder(parseResult.data.ids);
+  await c.var.services.navItems.reorder(body.ids);
   const items = await c.var.services.navItems.list();
   return c.json({ navItems: items });
 });
 
 // Create nav item (requires auth)
 navItemsApiRoutes.post("/", requireAuthApi(), async (c) => {
-  const rawBody = await c.req.json();
-
-  const parseResult = CreateNavItemSchema.safeParse(rawBody);
-  if (!parseResult.success) {
-    return c.json(
-      { error: "Validation failed", details: parseResult.error.flatten() },
-      400,
-    );
-  }
-
-  const body = parseResult.data;
+  const body = parseValidated(CreateNavItemSchema, await c.req.json());
 
   const item = await c.var.services.navItems.create({
     type: body.type as NavItemType,
@@ -84,32 +55,23 @@ navItemsApiRoutes.post("/", requireAuthApi(), async (c) => {
 
 // Update nav item (requires auth)
 navItemsApiRoutes.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 = UpdateNavItemSchema.safeParse(rawBody);
-  if (!parseResult.success) {
-    return c.json(
-      { error: "Validation failed", details: parseResult.error.flatten() },
-      400,
-    );
-  }
+  const id = parseIntParam(c.req.param("id"));
+  const body = parseValidated(UpdateNavItemSchema, await c.req.json());
 
-  const item = await c.var.services.navItems.update(id, parseResult.data);
-  if (!item) return c.json({ error: "Not found" }, 404);
+  const item = assertFound(
+    await c.var.services.navItems.update(id, body),
+    "Nav item",
+  );
 
   return c.json(item);
 });
 
 // Delete nav item (requires auth)
 navItemsApiRoutes.delete("/:id", requireAuthApi(), async (c) => {
-  const id = parseInt(c.req.param("id"), 10);
-  if (isNaN(id)) return c.json({ error: "Invalid ID" }, 400);
+  const id = parseIntParam(c.req.param("id"));
 
   const success = await c.var.services.navItems.delete(id);
-  if (!success) return c.json({ error: "Not found" }, 404);
+  if (!success) throw new NotFoundError("Nav item");
 
   return c.json({ success: true });
 });