@aaronshaf/plane 0.1.2

package/tests/new-schemas2.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, it } from "bun:test"
+import { Effect, Schema } from "effect"
+import {
+  WorklogSchema,
+  WorklogsResponseSchema,
+  IntakeIssueSchema,
+  IntakeIssuesResponseSchema,
+  PageSchema,
+  PagesResponseSchema,
+  CommentSchema,
+  CommentsResponseSchema,
+  CycleIssueSchema,
+  CycleIssuesResponseSchema,
+} from "@/config"
+
+async function decode<A, I>(schema: Schema.Schema<A, I>, data: unknown): Promise<A> {
+  return Effect.runPromise(
+    Schema.decodeUnknown(schema)(data).pipe(Effect.mapError((e) => new Error(String(e)))),
+  )
+}
+
+describe("WorklogSchema", () => {
+  it("decodes a full worklog", async () => {
+    const w = await decode(WorklogSchema, {
+      id: "w1",
+      description: "Code review",
+      duration: 90,
+      logged_by_detail: { display_name: "Aaron" },
+      created_at: "2025-01-15T10:00:00Z",
+    })
+    expect(w.duration).toBe(90)
+    expect(w.logged_by_detail?.display_name).toBe("Aaron")
+  })
+
+  it("decodes with null description", async () => {
+    const w = await decode(WorklogSchema, {
+      id: "w2",
+      description: null,
+      duration: 30,
+      created_at: "2025-01-15T10:00:00Z",
+    })
+    expect(w.description).toBeNull()
+  })
+
+  it("rejects missing duration", async () => {
+    await expect(
+      decode(WorklogSchema, { id: "w3", created_at: "2025-01-15T10:00:00Z" }),
+    ).rejects.toThrow()
+  })
+})
+
+describe("WorklogsResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(WorklogsResponseSchema, {
+      results: [{ id: "w1", duration: 60, created_at: "2025-01-15T10:00:00Z" }],
+    })
+    expect(resp.results).toHaveLength(1)
+  })
+
+  it("decodes empty", async () => {
+    const resp = await decode(WorklogsResponseSchema, { results: [] })
+    expect(resp.results).toHaveLength(0)
+  })
+})
+
+describe("IntakeIssueSchema", () => {
+  it("decodes a full intake issue", async () => {
+    const i = await decode(IntakeIssueSchema, {
+      id: "int1",
+      issue: "issue-uuid",
+      issue_detail: { id: "issue-uuid", sequence_id: 42, name: "Bug report", priority: "high" },
+      status: 0,
+      created_at: "2025-01-15T10:00:00Z",
+    })
+    expect(i.status).toBe(0)
+    expect(i.issue_detail?.sequence_id).toBe(42)
+  })
+
+  it("decodes minimal intake issue", async () => {
+    const i = await decode(IntakeIssueSchema, {
+      id: "int2",
+      created_at: "2025-01-15T10:00:00Z",
+    })
+    expect(i.id).toBe("int2")
+    expect(i.status).toBeUndefined()
+  })
+
+  it("rejects missing id", async () => {
+    await expect(
+      decode(IntakeIssueSchema, { created_at: "2025-01-15T10:00:00Z" }),
+    ).rejects.toThrow()
+  })
+})
+
+describe("IntakeIssuesResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(IntakeIssuesResponseSchema, {
+      results: [{ id: "int1", created_at: "2025-01-15T10:00:00Z" }],
+    })
+    expect(resp.results).toHaveLength(1)
+  })
+})
+
+describe("PageSchema", () => {
+  it("decodes a page", async () => {
+    const p = await decode(PageSchema, {
+      id: "pg1",
+      name: "Architecture Overview",
+      created_at: "2025-01-15T10:00:00Z",
+      updated_at: "2025-01-16T10:00:00Z",
+    })
+    expect(p.name).toBe("Architecture Overview")
+    expect(p.updated_at).toBe("2025-01-16T10:00:00Z")
+  })
+
+  it("accepts null description_html", async () => {
+    const p = await decode(PageSchema, {
+      id: "pg2",
+      name: "Empty page",
+      description_html: null,
+      created_at: "2025-01-15T10:00:00Z",
+    })
+    expect(p.description_html).toBeNull()
+  })
+
+  it("rejects missing name", async () => {
+    await expect(
+      decode(PageSchema, { id: "pg3", created_at: "2025-01-15T10:00:00Z" }),
+    ).rejects.toThrow()
+  })
+})
+
+describe("PagesResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(PagesResponseSchema, {
+      results: [{ id: "pg1", name: "Arch", created_at: "2025-01-15T10:00:00Z" }],
+    })
+    expect(resp.results[0].name).toBe("Arch")
+  })
+})
+
+describe("CommentSchema", () => {
+  it("decodes a comment", async () => {
+    const c = await decode(CommentSchema, {
+      id: "c1",
+      comment_html: "<p>Hello</p>",
+      actor_detail: { display_name: "Aaron" },
+      created_at: "2025-01-15T10:00:00Z",
+    })
+    expect(c.comment_html).toBe("<p>Hello</p>")
+    expect(c.actor_detail?.display_name).toBe("Aaron")
+  })
+
+  it("decodes without optional fields", async () => {
+    const c = await decode(CommentSchema, {
+      id: "c2",
+      created_at: "2025-01-15T10:00:00Z",
+    })
+    expect(c.id).toBe("c2")
+  })
+
+  it("rejects missing id", async () => {
+    await expect(
+      decode(CommentSchema, { created_at: "2025-01-15T10:00:00Z" }),
+    ).rejects.toThrow()
+  })
+})
+
+describe("CommentsResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(CommentsResponseSchema, {
+      results: [{ id: "c1", created_at: "2025-01-15T10:00:00Z" }],
+    })
+    expect(resp.results).toHaveLength(1)
+  })
+})
+
+describe("CycleIssueSchema", () => {
+  it("decodes with detail", async () => {
+    const ci = await decode(CycleIssueSchema, {
+      id: "ci1",
+      issue: "i1",
+      issue_detail: { id: "i1", sequence_id: 5, name: "Fix bug" },
+    })
+    expect(ci.issue_detail?.sequence_id).toBe(5)
+  })
+
+  it("decodes without detail", async () => {
+    const ci = await decode(CycleIssueSchema, { id: "ci2", issue: "i2" })
+    expect(ci.issue).toBe("i2")
+  })
+
+  it("rejects missing issue", async () => {
+    await expect(decode(CycleIssueSchema, { id: "ci3" })).rejects.toThrow()
+  })
+})
+
+describe("CycleIssuesResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(CycleIssuesResponseSchema, {
+      results: [{ id: "ci1", issue: "i1" }],
+    })
+    expect(resp.results).toHaveLength(1)
+  })
+})

package/tests/pages.test.ts

@@ -0,0 +1,124 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test"
+import { Effect } from "effect"
+import { http, HttpResponse } from "msw"
+import { setupServer } from "msw/node"
+import { _clearProjectCache } from "@/resolve"
+
+const BASE = "http://pages-test.local"
+const WS = "testws"
+
+const PROJECTS = [{ id: "proj-acme", identifier: "ACME", name: "Acme Project" }]
+const PAGES = [
+  {
+    id: "pg1",
+    name: "Architecture Overview",
+    description_html: "<p>Our architecture...</p>",
+    created_at: "2025-01-10T10:00:00Z",
+    updated_at: "2025-01-15T10:00:00Z",
+  },
+  {
+    id: "pg2",
+    name: "Migration Guide",
+    description_html: null,
+    created_at: "2025-01-05T10:00:00Z",
+  },
+]
+
+const server = setupServer(
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+    HttpResponse.json({ results: PROJECTS }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/`, () =>
+    HttpResponse.json({ results: PAGES }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/`, () =>
+    HttpResponse.json(PAGES[0]),
+  ),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }))
+afterAll(() => server.close())
+
+beforeEach(() => {
+  _clearProjectCache()
+  process.env["PLANE_HOST"] = BASE
+  process.env["PLANE_WORKSPACE"] = WS
+  process.env["PLANE_API_TOKEN"] = "test-token"
+})
+
+afterEach(() => {
+  server.resetHandlers()
+  delete process.env["PLANE_HOST"]
+  delete process.env["PLANE_WORKSPACE"]
+  delete process.env["PLANE_API_TOKEN"]
+})
+
+describe("pagesList", () => {
+  it("lists pages with updated date and name", async () => {
+    const { pagesList } = await import("@/commands/pages")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((pagesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    const output = logs.join("\n")
+    expect(output).toContain("pg1")
+    expect(output).toContain("2025-01-15")
+    expect(output).toContain("Architecture Overview")
+    expect(output).toContain("pg2")
+    expect(output).toContain("Migration Guide")
+  })
+
+  it("falls back to created_at when no updated_at", async () => {
+    const { pagesList } = await import("@/commands/pages")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((pagesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    // pg2 has no updated_at, should use created_at
+    expect(logs.join("\n")).toContain("2025-01-05")
+  })
+
+  it("shows 'No pages' when empty", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+    const { pagesList } = await import("@/commands/pages")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((pagesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    expect(logs.join("\n")).toBe("No pages")
+  })
+})
+
+describe("pagesGet", () => {
+  it("prints full JSON for a page", async () => {
+    const { pagesGet } = await import("@/commands/pages")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((pagesGet as any).handler({ project: "ACME", pageId: "pg1" }))
+    } finally {
+      console.log = orig
+    }
+    const parsed = JSON.parse(logs.join("\n"))
+    expect(parsed.id).toBe("pg1")
+    expect(parsed.name).toBe("Architecture Overview")
+    expect(parsed.description_html).toContain("architecture")
+  })
+})

package/tests/resolve.test.ts

@@ -0,0 +1,178 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test"
+import { Effect } from "effect"
+import { http, HttpResponse } from "msw"
+import { setupServer } from "msw/node"
+import {
+  resolveProject,
+  parseIssueRef,
+  findIssueBySeq,
+  getStateId,
+  _clearProjectCache,
+} from "@/resolve"
+
+const BASE = "http://test.local"
+const WS = "testws"
+
+const PROJECTS = [
+  { id: "proj-acme", identifier: "ACME", name: "Acme Project" },
+  { id: "proj-web", identifier: "WEB", name: "Web Project" },
+]
+
+const ISSUES = [
+  { id: "i1", sequence_id: 29, name: "Migrate Button", priority: "high", state: "s1" },
+  { id: "i2", sequence_id: 30, name: "Migrate TextInput", priority: "medium", state: "s2" },
+]
+
+const STATES = [
+  { id: "s-backlog", name: "Backlog", group: "backlog" },
+  { id: "s-todo", name: "Todo", group: "unstarted" },
+  { id: "s-progress", name: "In Progress", group: "started" },
+  { id: "s-done", name: "Done", group: "completed" },
+]
+
+const server = setupServer(
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+    HttpResponse.json({ results: PROJECTS }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/`, () =>
+    HttpResponse.json({ results: ISSUES }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/states/`, () =>
+    HttpResponse.json({ results: STATES }),
+  ),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }))
+afterAll(() => server.close())
+
+beforeEach(() => {
+  _clearProjectCache()
+  process.env["PLANE_HOST"] = BASE
+  process.env["PLANE_WORKSPACE"] = WS
+  process.env["PLANE_API_TOKEN"] = "test-token"
+})
+
+afterEach(() => {
+  server.resetHandlers()
+  delete process.env["PLANE_HOST"]
+  delete process.env["PLANE_WORKSPACE"]
+  delete process.env["PLANE_API_TOKEN"]
+})
+
+describe("resolveProject", () => {
+  it("resolves a known project identifier", async () => {
+    const result = await Effect.runPromise(resolveProject("ACME"))
+    expect(result.key).toBe("ACME")
+    expect(result.id).toBe("proj-acme")
+  })
+
+  it("is case-insensitive", async () => {
+    const result = await Effect.runPromise(resolveProject("acme"))
+    expect(result.key).toBe("ACME")
+  })
+
+  it("resolves WEB too", async () => {
+    const result = await Effect.runPromise(resolveProject("WEB"))
+    expect(result.id).toBe("proj-web")
+  })
+
+  it("fails for unknown project", async () => {
+    const result = await Effect.runPromise(Effect.either(resolveProject("NOPE")))
+    expect(result._tag).toBe("Left")
+    if (result._tag === "Left") {
+      expect(result.left.message).toContain("Unknown project")
+      expect(result.left.message).toContain("NOPE")
+    }
+  })
+
+  it("uses the cache on second call", async () => {
+    await Effect.runPromise(resolveProject("ACME"))
+    // Override with empty — cache hit should prevent re-fetching
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+    const result = await Effect.runPromise(resolveProject("WEB"))
+    expect(result.id).toBe("proj-web") // still from cache
+  })
+})
+
+describe("parseIssueRef", () => {
+  it("parses a valid ref", async () => {
+    const result = await Effect.runPromise(parseIssueRef("ACME-29"))
+    expect(result.projKey).toBe("ACME")
+    expect(result.seq).toBe(29)
+    expect(result.projectId).toBe("proj-acme")
+  })
+
+  it("is case-insensitive", async () => {
+    const result = await Effect.runPromise(parseIssueRef("acme-29"))
+    expect(result.projKey).toBe("ACME")
+    expect(result.seq).toBe(29)
+  })
+
+  it("fails on missing dash", async () => {
+    const result = await Effect.runPromise(Effect.either(parseIssueRef("ACME29")))
+    expect(result._tag).toBe("Left")
+  })
+
+  it("fails on non-numeric sequence", async () => {
+    const result = await Effect.runPromise(Effect.either(parseIssueRef("ACME-abc")))
+    expect(result._tag).toBe("Left")
+    if (result._tag === "Left") {
+      expect(result.left.message).toContain("Invalid issue ref")
+    }
+  })
+
+  it("fails on empty string", async () => {
+    const result = await Effect.runPromise(Effect.either(parseIssueRef("")))
+    expect(result._tag).toBe("Left")
+  })
+})
+
+describe("findIssueBySeq", () => {
+  it("finds issue by sequence_id", async () => {
+    const issue = await Effect.runPromise(findIssueBySeq("proj-acme", 29))
+    expect(issue.id).toBe("i1")
+    expect(issue.name).toBe("Migrate Button")
+  })
+
+  it("finds second issue", async () => {
+    const issue = await Effect.runPromise(findIssueBySeq("proj-acme", 30))
+    expect(issue.sequence_id).toBe(30)
+  })
+
+  it("fails when issue not found", async () => {
+    const result = await Effect.runPromise(Effect.either(findIssueBySeq("proj-acme", 999)))
+    expect(result._tag).toBe("Left")
+    if (result._tag === "Left") {
+      expect(result.left.message).toContain("#999 not found")
+    }
+  })
+})
+
+describe("getStateId", () => {
+  it("finds state by group name", async () => {
+    const id = await Effect.runPromise(getStateId("proj-acme", "completed"))
+    expect(id).toBe("s-done")
+  })
+
+  it("finds state by exact name (case-insensitive)", async () => {
+    const id = await Effect.runPromise(getStateId("proj-acme", "in progress"))
+    expect(id).toBe("s-progress")
+  })
+
+  it("finds backlog state", async () => {
+    const id = await Effect.runPromise(getStateId("proj-acme", "backlog"))
+    expect(id).toBe("s-backlog")
+  })
+
+  it("fails for unknown state", async () => {
+    const result = await Effect.runPromise(Effect.either(getStateId("proj-acme", "nope")))
+    expect(result._tag).toBe("Left")
+    if (result._tag === "Left") {
+      expect(result.left.message).toContain("State not found")
+    }
+  })
+})