@jant/core 0.3.2 → 0.3.4

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

@@ -0,0 +1,306 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { postsApiRoutes } from "../posts.js";
+import * as sqid from "../../../lib/sqid.js";
+
+describe("Posts API Routes", () => {
+  describe("GET /api/posts", () => {
+    it("returns empty list when no posts exist", async () => {
+      const { app } = createTestApp();
+      app.route("/api/posts", postsApiRoutes);
+
+      const res = await app.request("/api/posts");
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.posts).toEqual([]);
+      expect(body.nextCursor).toBeNull();
+    });
+
+    it("returns posts with sqids", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/posts", postsApiRoutes);
+
+      await services.posts.create({
+        type: "note",
+        content: "Hello world",
+        visibility: "featured",
+      });
+
+      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].sqid).toBeTruthy();
+    });
+
+    it("filters by visibility", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/posts", postsApiRoutes);
+
+      await services.posts.create({
+        type: "note",
+        content: "featured",
+        visibility: "featured",
+      });
+      await services.posts.create({
+        type: "note",
+        content: "draft",
+        visibility: "draft",
+      });
+
+      const res = await app.request("/api/posts?visibility=draft");
+      const body = await res.json();
+
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].visibility).toBe("draft");
+    });
+
+    it("supports limit parameter", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/posts", postsApiRoutes);
+
+      for (let i = 0; i < 5; i++) {
+        await services.posts.create({
+          type: "note",
+          content: `post ${i}`,
+          visibility: "featured",
+        });
+      }
+
+      const res = await app.request("/api/posts?limit=2");
+      const body = await res.json();
+
+      expect(body.posts).toHaveLength(2);
+      expect(body.nextCursor).toBeTruthy();
+    });
+  });
+
+  describe("GET /api/posts/:id", () => {
+    it("returns a post by sqid", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/posts", postsApiRoutes);
+
+      const post = await services.posts.create({
+        type: "note",
+        content: "test post",
+        visibility: "featured",
+      });
+      const id = sqid.encode(post.id);
+
+      const res = await app.request(`/api/posts/${id}`);
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.content).toBe("test post");
+      expect(body.sqid).toBe(id);
+    });
+
+    it("returns 400 for invalid sqid", async () => {
+      const { app } = createTestApp();
+      app.route("/api/posts", postsApiRoutes);
+
+      const res = await app.request("/api/posts/!!invalid!!");
+      expect(res.status).toBe(400);
+    });
+
+    it("returns 404 for non-existent post", async () => {
+      const { app } = createTestApp();
+      app.route("/api/posts", postsApiRoutes);
+
+      const res = await app.request(`/api/posts/${sqid.encode(9999)}`);
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe("POST /api/posts", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/posts", postsApiRoutes);
+
+      const res = await app.request("/api/posts", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          type: "note",
+          content: "test",
+          visibility: "quiet",
+        }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("creates a post when authenticated", 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: "note",
+          content: "Hello from API",
+          visibility: "quiet",
+        }),
+      });
+
+      expect(res.status).toBe(201);
+
+      const body = await res.json();
+      expect(body.content).toBe("Hello from API");
+      expect(body.sqid).toBeTruthy();
+    });
+
+    it("returns 400 for invalid body", 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: "invalid-type" }),
+      });
+
+      expect(res.status).toBe(400);
+      const body = await res.json();
+      expect(body.error).toBe("Validation failed");
+    });
+
+    it("returns 400 for missing required fields", 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({}),
+      });
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe("PUT /api/posts/:id", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/posts", postsApiRoutes);
+
+      const post = await services.posts.create({
+        type: "note",
+        content: "original",
+      });
+
+      const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content: "updated" }),
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("updates a post when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/posts", postsApiRoutes);
+
+      const post = await services.posts.create({
+        type: "note",
+        content: "original",
+      });
+
+      const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content: "updated" }),
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.content).toBe("updated");
+    });
+
+    it("returns 404 for non-existent post", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/posts", postsApiRoutes);
+
+      const res = await app.request(`/api/posts/${sqid.encode(9999)}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content: "test" }),
+      });
+
+      expect(res.status).toBe(404);
+    });
+
+    it("returns 400 for invalid update data", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/posts", postsApiRoutes);
+
+      const post = await services.posts.create({
+        type: "note",
+        content: "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" }),
+      });
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe("DELETE /api/posts/:id", () => {
+    it("returns 401 when not authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/posts", postsApiRoutes);
+
+      const post = await services.posts.create({
+        type: "note",
+        content: "test",
+      });
+
+      const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(401);
+    });
+
+    it("deletes a post when authenticated", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/posts", postsApiRoutes);
+
+      const post = await services.posts.create({
+        type: "note",
+        content: "to be deleted",
+      });
+
+      const res = await app.request(`/api/posts/${sqid.encode(post.id)}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.success).toBe(true);
+
+      // Verify post is deleted
+      const found = await services.posts.getById(post.id);
+      expect(found).toBeNull();
+    });
+
+    it("returns 404 for non-existent post", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/posts", postsApiRoutes);
+
+      const res = await app.request(`/api/posts/${sqid.encode(9999)}`, {
+        method: "DELETE",
+      });
+
+      expect(res.status).toBe(404);
+    });
+  });
+});

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

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { searchApiRoutes } from "../search.js";
+
+describe("Search API Routes", () => {
+  it("returns 400 when query is missing", async () => {
+    const { app } = createTestApp({ fts: true });
+    app.route("/api/search", searchApiRoutes);
+
+    const res = await app.request("/api/search");
+    expect(res.status).toBe(400);
+
+    const body = await res.json();
+    expect(body.error).toContain("'q' is required");
+  });
+
+  it("returns 400 for empty query", async () => {
+    const { app } = createTestApp({ fts: true });
+    app.route("/api/search", searchApiRoutes);
+
+    const res = await app.request("/api/search?q=");
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 400 for query over 200 characters", async () => {
+    const { app } = createTestApp({ fts: true });
+    app.route("/api/search", searchApiRoutes);
+
+    const longQuery = "a".repeat(201);
+    const res = await app.request(`/api/search?q=${longQuery}`);
+    expect(res.status).toBe(400);
+
+    const body = await res.json();
+    expect(body.error).toBe("Query too long");
+  });
+
+  it("returns search results for valid query", async () => {
+    const { app, services } = createTestApp({ fts: true });
+    app.route("/api/search", searchApiRoutes);
+
+    await services.posts.create({
+      type: "note",
+      content: "Testing search functionality in jant",
+      visibility: "featured",
+    });
+
+    const res = await app.request("/api/search?q=jant");
+    expect(res.status).toBe(200);
+
+    const body = await res.json();
+    expect(body.query).toBe("jant");
+    expect(body.results.length).toBeGreaterThanOrEqual(1);
+    expect(body.count).toBeGreaterThanOrEqual(1);
+    expect(body.results[0].url).toMatch(/^\/p\//);
+  });
+
+  it("returns empty results for non-matching query", async () => {
+    const { app } = createTestApp({ fts: true });
+    app.route("/api/search", searchApiRoutes);
+
+    const res = await app.request("/api/search?q=zznonexistentzzz");
+    expect(res.status).toBe(200);
+
+    const body = await res.json();
+    expect(body.results).toEqual([]);
+    expect(body.count).toBe(0);
+  });
+
+  it("does not require authentication", async () => {
+    const { app } = createTestApp({ authenticated: false, fts: true });
+    app.route("/api/search", searchApiRoutes);
+
+    const res = await app.request("/api/search?q=test");
+    // Should not return 401
+    expect(res.status).not.toBe(401);
+  });
+});

package/src/routes/api/posts.ts

@@ -34,7 +34,9 @@ postsApiRoutes.get("/", async (c) => {
     })),
 
     nextCursor:
-      posts.length === limit ? sqid.encode(posts[posts.length - 1]!.id) : null,
+      posts.length === limit
+        ? sqid.encode(posts[posts.length - 1]?.id ?? 0)
+        : null,
   });
 });
 

package/src/services/__tests__/collection.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createCollectionService } from "../collection.js";
+import { createPostService } from "../post.js";
+import type { Database } from "../../db/index.js";
+
+describe("CollectionService", () => {
+  let db: Database;
+  let collectionService: ReturnType<typeof createCollectionService>;
+  let postService: ReturnType<typeof createPostService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    collectionService = createCollectionService(db);
+    postService = createPostService(db);
+  });
+
+  describe("create", () => {
+    it("creates a collection with required fields", async () => {
+      const collection = await collectionService.create({
+        title: "My Collection",
+      });
+
+      expect(collection.id).toBe(1);
+      expect(collection.title).toBe("My Collection");
+      expect(collection.path).toBeNull();
+      expect(collection.description).toBeNull();
+    });
+
+    it("creates a collection with all fields", async () => {
+      const collection = await collectionService.create({
+        title: "Tech Posts",
+        path: "tech",
+        description: "Posts about technology",
+      });
+
+      expect(collection.title).toBe("Tech Posts");
+      expect(collection.path).toBe("tech");
+      expect(collection.description).toBe("Posts about technology");
+    });
+
+    it("sets timestamps", async () => {
+      const collection = await collectionService.create({
+        title: "Test",
+      });
+
+      expect(collection.createdAt).toBeGreaterThan(0);
+      expect(collection.updatedAt).toBeGreaterThan(0);
+    });
+  });
+
+  describe("getById", () => {
+    it("returns a collection by ID", async () => {
+      const created = await collectionService.create({ title: "Test" });
+
+      const found = await collectionService.getById(created.id);
+      expect(found).not.toBeNull();
+      expect(found?.title).toBe("Test");
+    });
+
+    it("returns null for non-existent ID", async () => {
+      const found = await collectionService.getById(9999);
+      expect(found).toBeNull();
+    });
+  });
+
+  describe("getByPath", () => {
+    it("returns a collection by path", async () => {
+      await collectionService.create({ title: "Tech", path: "tech" });
+
+      const found = await collectionService.getByPath("tech");
+      expect(found).not.toBeNull();
+      expect(found?.title).toBe("Tech");
+    });
+
+    it("returns null for non-existent path", async () => {
+      const found = await collectionService.getByPath("nonexistent");
+      expect(found).toBeNull();
+    });
+  });
+
+  describe("list", () => {
+    it("returns empty array when no collections exist", async () => {
+      const list = await collectionService.list();
+      expect(list).toEqual([]);
+    });
+
+    it("returns all collections", async () => {
+      await collectionService.create({ title: "First" });
+      await collectionService.create({ title: "Second" });
+      await collectionService.create({ title: "Third" });
+
+      const list = await collectionService.list();
+      expect(list).toHaveLength(3);
+    });
+  });
+
+  describe("update", () => {
+    it("updates collection title", async () => {
+      const collection = await collectionService.create({ title: "Old" });
+
+      const updated = await collectionService.update(collection.id, {
+        title: "New",
+      });
+
+      expect(updated?.title).toBe("New");
+    });
+
+    it("updates collection path", async () => {
+      const collection = await collectionService.create({
+        title: "Test",
+        path: "old-path",
+      });
+
+      const updated = await collectionService.update(collection.id, {
+        path: "new-path",
+      });
+
+      expect(updated?.path).toBe("new-path");
+    });
+
+    it("returns null for non-existent collection", async () => {
+      const result = await collectionService.update(9999, { title: "X" });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("delete", () => {
+    it("deletes a collection", async () => {
+      const collection = await collectionService.create({ title: "Test" });
+
+      const result = await collectionService.delete(collection.id);
+      expect(result).toBe(true);
+
+      const found = await collectionService.getById(collection.id);
+      expect(found).toBeNull();
+    });
+
+    it("deletes associated post-collection relationships", async () => {
+      const collection = await collectionService.create({ title: "Test" });
+      const post = await postService.create({
+        type: "note",
+        content: "test",
+      });
+
+      await collectionService.addPost(collection.id, post.id);
+      await collectionService.delete(collection.id);
+
+      // Post itself should still exist
+      expect(await postService.getById(post.id)).not.toBeNull();
+    });
+
+    it("returns false for non-existent collection", async () => {
+      const result = await collectionService.delete(9999);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("post relationships", () => {
+    it("adds a post to a collection", async () => {
+      const collection = await collectionService.create({ title: "Test" });
+      const post = await postService.create({
+        type: "note",
+        content: "test",
+      });
+
+      await collectionService.addPost(collection.id, post.id);
+
+      const posts = await collectionService.getPosts(collection.id);
+      expect(posts).toHaveLength(1);
+      expect(posts[0]?.id).toBe(post.id);
+    });
+
+    it("adding same post twice is idempotent", async () => {
+      const collection = await collectionService.create({ title: "Test" });
+      const post = await postService.create({
+        type: "note",
+        content: "test",
+      });
+
+      await collectionService.addPost(collection.id, post.id);
+      await collectionService.addPost(collection.id, post.id);
+
+      const posts = await collectionService.getPosts(collection.id);
+      expect(posts).toHaveLength(1);
+    });
+
+    it("removes a post from a collection", async () => {
+      const collection = await collectionService.create({ title: "Test" });
+      const post = await postService.create({
+        type: "note",
+        content: "test",
+      });
+
+      await collectionService.addPost(collection.id, post.id);
+      await collectionService.removePost(collection.id, post.id);
+
+      const posts = await collectionService.getPosts(collection.id);
+      expect(posts).toHaveLength(0);
+    });
+
+    it("returns collections for a post", async () => {
+      const col1 = await collectionService.create({ title: "Col 1" });
+      const col2 = await collectionService.create({ title: "Col 2" });
+      const post = await postService.create({
+        type: "note",
+        content: "test",
+      });
+
+      await collectionService.addPost(col1.id, post.id);
+      await collectionService.addPost(col2.id, post.id);
+
+      const collections = await collectionService.getCollectionsForPost(
+        post.id,
+      );
+      expect(collections).toHaveLength(2);
+    });
+
+    it("getPosts returns empty array for empty collection", async () => {
+      const collection = await collectionService.create({ title: "Empty" });
+      const posts = await collectionService.getPosts(collection.id);
+      expect(posts).toEqual([]);
+    });
+  });
+});