@aaronshaf/plane 0.1.2

package/tests/issue-links.test.ts

@@ -0,0 +1,206 @@
+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://links-test.local"
+const WS = "testws"
+
+const PROJECTS = [{ id: "proj-acme", identifier: "ACME", name: "Acme Project" }]
+const ISSUES = [{ id: "i1", sequence_id: 29, name: "Migrate Button", priority: "high", state: "s1" }]
+const LINKS = [
+  { id: "lnk1", title: "PR #42", url: "https://github.com/org/repo/pull/42", created_at: "2025-01-15T10:00:00Z" },
+  { id: "lnk2", title: null, url: "https://docs.example.com", created_at: "2025-01-14T10: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/issues/`, () =>
+    HttpResponse.json({ results: ISSUES }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/issue-links/`, () =>
+    HttpResponse.json({ results: LINKS }),
+  ),
+)
+
+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("issueLinkList", () => {
+  it("lists links for an issue", async () => {
+    const { issueLinkList } = await import("@/commands/issue")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise((issueLinkList as any).handler({ ref: "ACME-29" }))
+    } finally {
+      console.log = orig
+    }
+
+    const output = logs.join("\n")
+    expect(output).toContain("lnk1")
+    expect(output).toContain("PR #42")
+    expect(output).toContain("https://github.com/org/repo/pull/42")
+  })
+
+  it("shows '(no title)' for null title", async () => {
+    const { issueLinkList } = await import("@/commands/issue")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise((issueLinkList as any).handler({ ref: "ACME-29" }))
+    } finally {
+      console.log = orig
+    }
+
+    expect(logs.join("\n")).toContain("(no title)")
+  })
+
+  it("shows 'No links' when empty", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/issue-links/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+
+    const { issueLinkList } = await import("@/commands/issue")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise((issueLinkList as any).handler({ ref: "ACME-29" }))
+    } finally {
+      console.log = orig
+    }
+
+    expect(logs.join("\n")).toBe("No links")
+  })
+})
+
+describe("issueLinkAdd", () => {
+  it("adds a link without title", async () => {
+    server.use(
+      http.post(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/issue-links/`,
+        async ({ request }) => {
+          const body = (await request.json()) as any
+          return HttpResponse.json({
+            id: "lnk-new",
+            url: body.url,
+            created_at: "2025-01-15T10:00:00Z",
+          })
+        },
+      ),
+    )
+
+    const { issueLinkAdd } = await import("@/commands/issue")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (issueLinkAdd as any).handler({
+          ref: "ACME-29",
+          url: "https://example.com",
+          title: { _tag: "None" },
+        }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    const output = logs.join("\n")
+    expect(output).toContain("lnk-new")
+    expect(output).toContain("https://example.com")
+  })
+
+  it("adds a link with title", async () => {
+    server.use(
+      http.post(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/issue-links/`,
+        async ({ request }) => {
+          const body = (await request.json()) as any
+          return HttpResponse.json({
+            id: "lnk-new2",
+            title: body.title,
+            url: body.url,
+            created_at: "2025-01-15T10:00:00Z",
+          })
+        },
+      ),
+    )
+
+    const { issueLinkAdd } = await import("@/commands/issue")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (issueLinkAdd as any).handler({
+          ref: "ACME-29",
+          url: "https://docs.example.com",
+          title: { _tag: "Some", value: "Design doc" },
+        }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    expect(logs.join("\n")).toContain("lnk-new2")
+  })
+})
+
+describe("issueLinkRemove", () => {
+  it("removes a link", async () => {
+    let deleted = false
+    server.use(
+      http.delete(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/issue-links/lnk1/`,
+        () => {
+          deleted = true
+          return new HttpResponse(null, { status: 204 })
+        },
+      ),
+    )
+
+    const { issueLinkRemove } = await import("@/commands/issue")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (issueLinkRemove as any).handler({ ref: "ACME-29", linkId: "lnk1" }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    expect(deleted).toBe(true)
+    expect(logs.join("\n")).toContain("lnk1")
+  })
+})

package/tests/modules.test.ts

@@ -0,0 +1,255 @@
+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://modules-test.local"
+const WS = "testws"
+
+const PROJECTS = [{ id: "proj-acme", identifier: "ACME", name: "Acme Project" }]
+const ISSUES = [{ id: "i1", sequence_id: 29, name: "Migrate Button", priority: "high", state: "s1" }]
+const MODULES = [
+  { id: "mod1", name: "Sprint 1", status: "in_progress" },
+  { id: "mod2", name: "Sprint 2", status: "backlog" },
+]
+const MODULE_ISSUES = [
+  {
+    id: "mi1",
+    issue: "i1",
+    issue_detail: { id: "i1", sequence_id: 29, name: "Migrate Button" },
+  },
+]
+
+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/modules/`, () =>
+    HttpResponse.json({ results: MODULES }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/modules/mod1/module-issues/`, () =>
+    HttpResponse.json({ results: MODULE_ISSUES }),
+  ),
+)
+
+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("modulesList", () => {
+  it("lists modules for a project", async () => {
+    const { modulesList } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise((modulesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+
+    const output = logs.join("\n")
+    expect(output).toContain("mod1")
+    expect(output).toContain("Sprint 1")
+    expect(output).toContain("in_progress")
+    expect(output).toContain("mod2")
+    expect(output).toContain("Sprint 2")
+  })
+
+  it("shows 'No modules found' when empty", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/modules/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+
+    const { modulesList } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise((modulesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+
+    expect(logs.join("\n")).toBe("No modules found")
+  })
+
+  it("shows '?' for missing status", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/modules/`, () =>
+        HttpResponse.json({ results: [{ id: "mod3", name: "Unstarted Sprint" }] }),
+      ),
+    )
+
+    const { modulesList } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise((modulesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+
+    expect(logs.join("\n")).toContain("?")
+  })
+})
+
+describe("moduleIssuesList", () => {
+  it("lists issues in a module with detail", async () => {
+    const { moduleIssuesList } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (moduleIssuesList as any).handler({ project: "ACME", moduleId: "mod1" }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    const output = logs.join("\n")
+    expect(output).toContain("ACME-")
+    expect(output).toContain("29")
+    expect(output).toContain("Migrate Button")
+  })
+
+  it("falls back to issue UUID when no issue_detail", async () => {
+    server.use(
+      http.get(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/modules/mod1/module-issues/`,
+        () => HttpResponse.json({ results: [{ id: "mi2", issue: "bare-uuid" }] }),
+      ),
+    )
+
+    const { moduleIssuesList } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (moduleIssuesList as any).handler({ project: "ACME", moduleId: "mod1" }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    expect(logs.join("\n")).toContain("bare-uuid")
+  })
+
+  it("shows 'No issues in module' when empty", async () => {
+    server.use(
+      http.get(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/modules/mod1/module-issues/`,
+        () => HttpResponse.json({ results: [] }),
+      ),
+    )
+
+    const { moduleIssuesList } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (moduleIssuesList as any).handler({ project: "ACME", moduleId: "mod1" }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    expect(logs.join("\n")).toBe("No issues in module")
+  })
+})
+
+describe("moduleIssuesAdd", () => {
+  it("adds an issue to a module", async () => {
+    let postedBody: unknown
+    server.use(
+      http.post(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/modules/mod1/module-issues/`,
+        async ({ request }) => {
+          postedBody = await request.json()
+          return HttpResponse.json({ issues: ["i1"] }, { status: 201 })
+        },
+      ),
+    )
+
+    const { moduleIssuesAdd } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (moduleIssuesAdd as any).handler({ project: "ACME", moduleId: "mod1", ref: "ACME-29" }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    expect((postedBody as any).issues).toContain("i1")
+    expect(logs.join("\n")).toContain("ACME-29")
+    expect(logs.join("\n")).toContain("mod1")
+  })
+})
+
+describe("moduleIssuesRemove", () => {
+  it("removes a module-issue", async () => {
+    let deleted = false
+    server.use(
+      http.delete(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/modules/mod1/module-issues/mi1/`,
+        () => {
+          deleted = true
+          return new HttpResponse(null, { status: 204 })
+        },
+      ),
+    )
+
+    const { moduleIssuesRemove } = await import("@/commands/modules")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (moduleIssuesRemove as any).handler({
+          project: "ACME",
+          moduleId: "mod1",
+          moduleIssueId: "mi1",
+        }),
+      )
+    } finally {
+      console.log = orig
+    }
+
+    expect(deleted).toBe(true)
+    expect(logs.join("\n")).toContain("mi1")
+  })
+})

package/tests/new-schemas.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from "bun:test"
+import { Effect, Schema } from "effect"
+import {
+  ActivitySchema,
+  ActivitiesResponseSchema,
+  IssueLinkSchema,
+  IssueLinksResponseSchema,
+  ModuleSchema,
+  ModulesResponseSchema,
+  ModuleIssueSchema,
+  ModuleIssuesResponseSchema,
+} 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("ActivitySchema", () => {
+  it("decodes a full activity", async () => {
+    const a = await decode(ActivitySchema, {
+      id: "act1",
+      actor_detail: { display_name: "Aaron" },
+      field: "state",
+      old_value: "Backlog",
+      new_value: "In Progress",
+      verb: "updated",
+      created_at: "2025-01-15T10:30:00Z",
+    })
+    expect(a.id).toBe("act1")
+    expect(a.actor_detail?.display_name).toBe("Aaron")
+    expect(a.field).toBe("state")
+    expect(a.old_value).toBe("Backlog")
+    expect(a.new_value).toBe("In Progress")
+    expect(a.created_at).toBe("2025-01-15T10:30:00Z")
+  })
+
+  it("decodes activity with null field values", async () => {
+    const a = await decode(ActivitySchema, {
+      id: "act2",
+      field: null,
+      old_value: null,
+      new_value: null,
+      created_at: "2025-01-15T10:30:00Z",
+    })
+    expect(a.field).toBeNull()
+    expect(a.old_value).toBeNull()
+  })
+
+  it("decodes minimal activity (no optional fields)", async () => {
+    const a = await decode(ActivitySchema, {
+      id: "act3",
+      created_at: "2025-01-15T10:30:00Z",
+    })
+    expect(a.id).toBe("act3")
+  })
+
+  it("rejects missing id", async () => {
+    await expect(
+      decode(ActivitySchema, { created_at: "2025-01-15T10:30:00Z" }),
+    ).rejects.toThrow()
+  })
+})
+
+describe("ActivitiesResponseSchema", () => {
+  it("decodes results array", async () => {
+    const resp = await decode(ActivitiesResponseSchema, {
+      results: [
+        { id: "a1", created_at: "2025-01-15T10:30:00Z" },
+        { id: "a2", created_at: "2025-01-16T10:30:00Z" },
+      ],
+    })
+    expect(resp.results).toHaveLength(2)
+  })
+
+  it("decodes empty results", async () => {
+    const resp = await decode(ActivitiesResponseSchema, { results: [] })
+    expect(resp.results).toHaveLength(0)
+  })
+})
+
+describe("IssueLinkSchema", () => {
+  it("decodes a full link", async () => {
+    const l = await decode(IssueLinkSchema, {
+      id: "link1",
+      title: "PR #42",
+      url: "https://github.com/org/repo/pull/42",
+      created_at: "2025-01-15T10:30:00Z",
+    })
+    expect(l.id).toBe("link1")
+    expect(l.title).toBe("PR #42")
+    expect(l.url).toBe("https://github.com/org/repo/pull/42")
+  })
+
+  it("decodes link with null title", async () => {
+    const l = await decode(IssueLinkSchema, {
+      id: "link2",
+      title: null,
+      url: "https://example.com",
+      created_at: "2025-01-15T10:30:00Z",
+    })
+    expect(l.title).toBeNull()
+  })
+
+  it("rejects missing url", async () => {
+    await expect(
+      decode(IssueLinkSchema, { id: "link3", created_at: "2025-01-15T10:30:00Z" }),
+    ).rejects.toThrow()
+  })
+})
+
+describe("IssueLinksResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(IssueLinksResponseSchema, {
+      results: [
+        { id: "l1", url: "https://example.com/1", created_at: "2025-01-15T10:00:00Z" },
+      ],
+    })
+    expect(resp.results).toHaveLength(1)
+  })
+
+  it("decodes empty results", async () => {
+    const resp = await decode(IssueLinksResponseSchema, { results: [] })
+    expect(resp.results).toHaveLength(0)
+  })
+})
+
+describe("ModuleSchema", () => {
+  it("decodes a module", async () => {
+    const m = await decode(ModuleSchema, { id: "mod1", name: "Sprint 1" })
+    expect(m.id).toBe("mod1")
+    expect(m.name).toBe("Sprint 1")
+  })
+
+  it("accepts optional status and description", async () => {
+    const m = await decode(ModuleSchema, {
+      id: "mod1",
+      name: "Sprint 1",
+      status: "in_progress",
+      description: "Focus on migration",
+    })
+    expect(m.status).toBe("in_progress")
+    expect(m.description).toBe("Focus on migration")
+  })
+
+  it("accepts null description", async () => {
+    const m = await decode(ModuleSchema, { id: "mod1", name: "Sprint 1", description: null })
+    expect(m.description).toBeNull()
+  })
+
+  it("rejects missing name", async () => {
+    await expect(decode(ModuleSchema, { id: "mod1" })).rejects.toThrow()
+  })
+})
+
+describe("ModulesResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(ModulesResponseSchema, {
+      results: [
+        { id: "m1", name: "Sprint 1" },
+        { id: "m2", name: "Sprint 2" },
+      ],
+    })
+    expect(resp.results).toHaveLength(2)
+  })
+})
+
+describe("ModuleIssueSchema", () => {
+  it("decodes a module issue with detail", async () => {
+    const mi = await decode(ModuleIssueSchema, {
+      id: "mi1",
+      issue: "issue-uuid",
+      issue_detail: { id: "issue-uuid", sequence_id: 29, name: "Migrate Button" },
+    })
+    expect(mi.id).toBe("mi1")
+    expect(mi.issue_detail?.sequence_id).toBe(29)
+  })
+
+  it("decodes without issue_detail", async () => {
+    const mi = await decode(ModuleIssueSchema, {
+      id: "mi1",
+      issue: "issue-uuid",
+    })
+    expect(mi.issue).toBe("issue-uuid")
+    expect(mi.issue_detail).toBeUndefined()
+  })
+
+  it("rejects missing issue", async () => {
+    await expect(decode(ModuleIssueSchema, { id: "mi1" })).rejects.toThrow()
+  })
+})
+
+describe("ModuleIssuesResponseSchema", () => {
+  it("decodes results", async () => {
+    const resp = await decode(ModuleIssuesResponseSchema, {
+      results: [{ id: "mi1", issue: "uuid1" }],
+    })
+    expect(resp.results).toHaveLength(1)
+  })
+})