@aaronshaf/plane 0.1.3 → 0.1.5

package/src/output.ts

@@ -1,39 +1,39 @@
-const jsonIdx = process.argv.indexOf("--json")
-const xmlIdx = process.argv.indexOf("--xml")
+const jsonIdx = process.argv.indexOf("--json");
+const xmlIdx = process.argv.indexOf("--xml");
 
-export const jsonMode = jsonIdx !== -1
-export const xmlMode = xmlIdx !== -1
+export const jsonMode = jsonIdx !== -1;
+export const xmlMode = xmlIdx !== -1;
 
-if (jsonIdx !== -1) process.argv.splice(jsonIdx, 1)
-if (xmlIdx !== -1) process.argv.splice(xmlIdx, 1)
+if (jsonIdx !== -1) process.argv.splice(jsonIdx, 1);
+if (xmlIdx !== -1) process.argv.splice(xmlIdx, 1);
 
 function escapeXml(val: unknown): string {
-  return String(val ?? "")
-    .replace(/&/g, "&")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
+	return String(val ?? "")
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;");
 }
 
 function toXmlItem(obj: unknown, tag = "item"): string {
-  if (obj === null || typeof obj !== "object") {
-    return `<${tag}>${escapeXml(obj)}</${tag}>`
-  }
-  const attrs = Object.entries(obj as Record<string, unknown>)
-    .filter(([, v]) => v === null || typeof v !== "object")
-    .map(([k, v]) => `${k}="${escapeXml(v)}"`)
-    .join(" ")
-  const children = Object.entries(obj as Record<string, unknown>)
-    .filter(([, v]) => v !== null && typeof v === "object")
-    .map(([k, v]) =>
-      Array.isArray(v)
-        ? `<${k}>${v.map((i) => toXmlItem(i)).join("")}</${k}>`
-        : toXmlItem(v, k),
-    )
-    .join("")
-  return `<${tag}${attrs ? " " + attrs : ""}>${children}</${tag}>`
+	if (obj === null || typeof obj !== "object") {
+		return `<${tag}>${escapeXml(obj)}</${tag}>`;
+	}
+	const attrs = Object.entries(obj as Record<string, unknown>)
+		.filter(([, v]) => v === null || typeof v !== "object")
+		.map(([k, v]) => `${k}="${escapeXml(v)}"`)
+		.join(" ");
+	const children = Object.entries(obj as Record<string, unknown>)
+		.filter(([, v]) => v !== null && typeof v === "object")
+		.map(([k, v]) =>
+			Array.isArray(v)
+				? `<${k}>${v.map((i) => toXmlItem(i)).join("")}</${k}>`
+				: toXmlItem(v, k),
+		)
+		.join("");
+	return `<${tag}${attrs ? " " + attrs : ""}>${children}</${tag}>`;
 }
 
 export function toXml(results: readonly unknown[]): string {
-  return `<results>\n${results.map((r) => "  " + toXmlItem(r)).join("\n")}\n</results>`
+	return `<results>\n${results.map((r) => "  " + toXmlItem(r)).join("\n")}\n</results>`;
 }

package/src/resolve.ts

@@ -1,76 +1,89 @@
-import { Effect } from "effect"
-import { api, decodeOrFail } from "./api.js"
-import { IssuesResponseSchema, StatesResponseSchema, ProjectsResponseSchema } from "./config.js"
+import { Effect } from "effect";
+import { api, decodeOrFail } from "./api.js";
+import {
+	IssuesResponseSchema,
+	StatesResponseSchema,
+	ProjectsResponseSchema,
+} from "./config.js";
 
 // Cache project list within a process invocation
-let _projectCache: Record<string, string> | null = null
+let _projectCache: Record<string, string> | null = null;
 
 /** Clear the project cache — for use in tests only */
 export function _clearProjectCache() {
-  _projectCache = null
+	_projectCache = null;
 }
 
 function getProjectMap(): Effect.Effect<Record<string, string>, Error> {
-  if (_projectCache) return Effect.succeed(_projectCache)
-  return Effect.gen(function* () {
-    const raw = yield* api.get("projects/")
-    const { results } = yield* decodeOrFail(ProjectsResponseSchema, raw)
-    _projectCache = Object.fromEntries(results.map((p) => [p.identifier.toUpperCase(), p.id]))
-    return _projectCache
-  })
+	if (_projectCache) return Effect.succeed(_projectCache);
+	return Effect.gen(function* () {
+		const raw = yield* api.get("projects/");
+		const { results } = yield* decodeOrFail(ProjectsResponseSchema, raw);
+		_projectCache = Object.fromEntries(
+			results.map((p) => [p.identifier.toUpperCase(), p.id]),
+		);
+		return _projectCache;
+	});
 }
 
 export function resolveProject(
-  identifier: string,
+	identifier: string,
 ): Effect.Effect<{ key: string; id: string }, Error> {
-  const key = identifier.toUpperCase()
-  return getProjectMap().pipe(
-    Effect.flatMap((map) => {
-      const id = map[key]
-      if (!id) {
-        return Effect.fail(
-          new Error(`Unknown project: ${identifier}. Known: ${Object.keys(map).join(", ")}`),
-        )
-      }
-      return Effect.succeed({ key, id })
-    }),
-  )
+	const key = identifier.toUpperCase();
+	return getProjectMap().pipe(
+		Effect.flatMap((map) => {
+			const id = map[key];
+			if (!id) {
+				return Effect.fail(
+					new Error(
+						`Unknown project: ${identifier}. Known: ${Object.keys(map).join(", ")}`,
+					),
+				);
+			}
+			return Effect.succeed({ key, id });
+		}),
+	);
 }
 
 export function parseIssueRef(
-  ref: string,
+	ref: string,
 ): Effect.Effect<{ projectId: string; projKey: string; seq: number }, Error> {
-  const parts = ref.toUpperCase().split("-")
-  if (parts.length !== 2 || !/^\d+$/.test(parts[1])) {
-    return Effect.fail(
-      new Error(`Invalid issue ref: ${ref}. Expected format like PROJ-29`),
-    )
-  }
-  const [projKey, seqStr] = parts
-  return resolveProject(projKey).pipe(
-    Effect.map(({ id }) => ({ projectId: id, projKey, seq: parseInt(seqStr, 10) })),
-  )
+	const parts = ref.toUpperCase().split("-");
+	if (parts.length !== 2 || !/^\d+$/.test(parts[1])) {
+		return Effect.fail(
+			new Error(`Invalid issue ref: ${ref}. Expected format like PROJ-29`),
+		);
+	}
+	const [projKey, seqStr] = parts;
+	return resolveProject(projKey).pipe(
+		Effect.map(({ id }) => ({
+			projectId: id,
+			projKey,
+			seq: parseInt(seqStr, 10),
+		})),
+	);
 }
 
 export function findIssueBySeq(projectId: string, seq: number) {
-  return Effect.gen(function* () {
-    const raw = yield* api.get(`projects/${projectId}/issues/`)
-    const { results } = yield* decodeOrFail(IssuesResponseSchema, raw)
-    const issue = results.find((i) => i.sequence_id === seq)
-    if (!issue) return yield* Effect.fail(new Error(`Issue #${seq} not found`))
-    return issue
-  })
+	return Effect.gen(function* () {
+		const raw = yield* api.get(`projects/${projectId}/issues/`);
+		const { results } = yield* decodeOrFail(IssuesResponseSchema, raw);
+		const issue = results.find((i) => i.sequence_id === seq);
+		if (!issue) return yield* Effect.fail(new Error(`Issue #${seq} not found`));
+		return issue;
+	});
 }
 
 export function getStateId(projectId: string, nameOrGroup: string) {
-  return Effect.gen(function* () {
-    const raw = yield* api.get(`projects/${projectId}/states/`)
-    const { results } = yield* decodeOrFail(StatesResponseSchema, raw)
-    const lower = nameOrGroup.toLowerCase()
-    const state = results.find(
-      (s) => s.group === lower || s.name.toLowerCase() === lower,
-    )
-    if (!state) return yield* Effect.fail(new Error(`State not found: ${nameOrGroup}`))
-    return state.id
-  })
+	return Effect.gen(function* () {
+		const raw = yield* api.get(`projects/${projectId}/states/`);
+		const { results } = yield* decodeOrFail(StatesResponseSchema, raw);
+		const lower = nameOrGroup.toLowerCase();
+		const state = results.find(
+			(s) => s.group === lower || s.name.toLowerCase() === lower,
+		);
+		if (!state)
+			return yield* Effect.fail(new Error(`State not found: ${nameOrGroup}`));
+		return state.id;
+	});
 }

package/tests/api.test.ts

@@ -1,169 +1,192 @@
-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 { api, decodeOrFail } from "@/api"
-import { Schema } from "effect"
-
-const BASE = "http://api-test.local"
-const WS = "testws"
-
-const server = setupServer()
-
-beforeAll(() => server.listen({ onUnhandledRequest: "error" }))
-afterAll(() => server.close())
+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 { api, decodeOrFail } from "@/api";
+import { Schema } from "effect";
+
+const BASE = "http://api-test.local";
+const WS = "testws";
+
+const server = setupServer();
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
+afterAll(() => server.close());
 
 beforeEach(() => {
-  process.env["PLANE_HOST"] = BASE
-  process.env["PLANE_WORKSPACE"] = WS
-  process.env["PLANE_API_TOKEN"] = "test-token"
-})
+	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"]
-})
+	server.resetHandlers();
+	delete process.env["PLANE_HOST"];
+	delete process.env["PLANE_WORKSPACE"];
+	delete process.env["PLANE_API_TOKEN"];
+});
 
 describe("api.get", () => {
-  it("makes a GET request and returns parsed JSON", async () => {
-    server.use(
-      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
-        HttpResponse.json({ results: [{ id: "p1", identifier: "ACME", name: "InstUI" }] }),
-      ),
-    )
-    const result = await Effect.runPromise(api.get("projects/"))
-    expect((result as any).results).toHaveLength(1)
-  })
-
-  it("strips trailing slash from PLANE_HOST", async () => {
-    process.env["PLANE_HOST"] = `${BASE}/`
-    server.use(
-      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
-        HttpResponse.json({ results: [] }),
-      ),
-    )
-    const result = await Effect.runPromise(api.get("projects/"))
-    expect((result as any).results).toHaveLength(0)
-  })
-
-  it("appends expand=state for issues/ paths", async () => {
-    let capturedUrl = ""
-    server.use(
-      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/`, ({ request }) => {
-        capturedUrl = request.url
-        return HttpResponse.json({ results: [] })
-      }),
-    )
-    await Effect.runPromise(api.get("projects/p1/issues/"))
-    expect(capturedUrl).toContain("expand=state")
-  })
-
-  it("fails on HTTP 4xx response", async () => {
-    server.use(
-      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
-        HttpResponse.json({ detail: "Not found" }, { status: 404 }),
-      ),
-    )
-    const result = await Effect.runPromise(Effect.either(api.get("projects/")))
-    expect(result._tag).toBe("Left")
-    if (result._tag === "Left") {
-      expect(result.left.message).toContain("HTTP 404")
-    }
-  })
-
-  it("fails on HTTP 401 response", async () => {
-    server.use(
-      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
-        HttpResponse.text("Unauthorized", { status: 401 }),
-      ),
-    )
-    const result = await Effect.runPromise(Effect.either(api.get("projects/")))
-    expect(result._tag).toBe("Left")
-  })
-})
+	it("makes a GET request and returns parsed JSON", async () => {
+		server.use(
+			http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+				HttpResponse.json({
+					results: [{ id: "p1", identifier: "ACME", name: "InstUI" }],
+				}),
+			),
+		);
+		const result = await Effect.runPromise(api.get("projects/"));
+		expect((result as any).results).toHaveLength(1);
+	});
+
+	it("strips trailing slash from PLANE_HOST", async () => {
+		process.env["PLANE_HOST"] = `${BASE}/`;
+		server.use(
+			http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+				HttpResponse.json({ results: [] }),
+			),
+		);
+		const result = await Effect.runPromise(api.get("projects/"));
+		expect((result as any).results).toHaveLength(0);
+	});
+
+	it("appends expand=state for issues/ paths", async () => {
+		let capturedUrl = "";
+		server.use(
+			http.get(
+				`${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/`,
+				({ request }) => {
+					capturedUrl = request.url;
+					return HttpResponse.json({ results: [] });
+				},
+			),
+		);
+		await Effect.runPromise(api.get("projects/p1/issues/"));
+		expect(capturedUrl).toContain("expand=state");
+	});
+
+	it("fails on HTTP 4xx response", async () => {
+		server.use(
+			http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+				HttpResponse.json({ detail: "Not found" }, { status: 404 }),
+			),
+		);
+		const result = await Effect.runPromise(Effect.either(api.get("projects/")));
+		expect(result._tag).toBe("Left");
+		if (result._tag === "Left") {
+			expect(result.left.message).toContain("HTTP 404");
+		}
+	});
+
+	it("fails on HTTP 401 response", async () => {
+		server.use(
+			http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+				HttpResponse.text("Unauthorized", { status: 401 }),
+			),
+		);
+		const result = await Effect.runPromise(Effect.either(api.get("projects/")));
+		expect(result._tag).toBe("Left");
+	});
+});
 
 describe("api.post", () => {
-  it("sends JSON body and returns parsed response", async () => {
-    server.use(
-      http.post(`${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/`, async ({ request }) => {
-        const body = (await request.json()) as any
-        return HttpResponse.json({
-          id: "new-issue",
-          sequence_id: 99,
-          name: body.name,
-          priority: "none",
-          state: "s1",
-        })
-      }),
-    )
-    const result = (await Effect.runPromise(
-      api.post("projects/p1/issues/", { name: "New Issue" }),
-    )) as any
-    expect(result.sequence_id).toBe(99)
-    expect(result.name).toBe("New Issue")
-  })
-})
+	it("sends JSON body and returns parsed response", async () => {
+		server.use(
+			http.post(
+				`${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/`,
+				async ({ request }) => {
+					const body = (await request.json()) as any;
+					return HttpResponse.json({
+						id: "new-issue",
+						sequence_id: 99,
+						name: body.name,
+						priority: "none",
+						state: "s1",
+					});
+				},
+			),
+		);
+		const result = (await Effect.runPromise(
+			api.post("projects/p1/issues/", { name: "New Issue" }),
+		)) as any;
+		expect(result.sequence_id).toBe(99);
+		expect(result.name).toBe("New Issue");
+	});
+});
 
 describe("api.patch", () => {
-  it("sends a PATCH and returns updated resource", async () => {
-    server.use(
-      http.patch(
-        `${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/i1/`,
-        async ({ request }) => {
-          const body = (await request.json()) as any
-          return HttpResponse.json({
-            id: "i1",
-            sequence_id: 1,
-            name: "Issue",
-            priority: body.priority ?? "low",
-            state: "s1",
-          })
-        },
-      ),
-    )
-    const result = (await Effect.runPromise(
-      api.patch("projects/p1/issues/i1/", { priority: "high" }),
-    )) as any
-    expect(result.priority).toBe("high")
-  })
-})
+	it("sends a PATCH and returns updated resource", async () => {
+		server.use(
+			http.patch(
+				`${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/i1/`,
+				async ({ request }) => {
+					const body = (await request.json()) as any;
+					return HttpResponse.json({
+						id: "i1",
+						sequence_id: 1,
+						name: "Issue",
+						priority: body.priority ?? "low",
+						state: "s1",
+					});
+				},
+			),
+		);
+		const result = (await Effect.runPromise(
+			api.patch("projects/p1/issues/i1/", { priority: "high" }),
+		)) as any;
+		expect(result.priority).toBe("high");
+	});
+});
 
 describe("api.delete", () => {
-  it("sends a DELETE request", async () => {
-    let called = false
-    server.use(
-      http.delete(`${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/i1/`, () => {
-        called = true
-        return new HttpResponse(null, { status: 204 })
-      }),
-    )
-    await Effect.runPromise(api.delete("projects/p1/issues/i1/"))
-    expect(called).toBe(true)
-  })
-})
+	it("sends a DELETE request", async () => {
+		let called = false;
+		server.use(
+			http.delete(
+				`${BASE}/api/v1/workspaces/${WS}/projects/p1/issues/i1/`,
+				() => {
+					called = true;
+					return new HttpResponse(null, { status: 204 });
+				},
+			),
+		);
+		await Effect.runPromise(api.delete("projects/p1/issues/i1/"));
+		expect(called).toBe(true);
+	});
+});
 
 describe("decodeOrFail", () => {
-  const NameSchema = Schema.Struct({ name: Schema.String })
-
-  it("decodes valid data", async () => {
-    const result = await Effect.runPromise(decodeOrFail(NameSchema, { name: "hello" }))
-    expect(result.name).toBe("hello")
-  })
-
-  it("fails with Error for invalid data", async () => {
-    const result = await Effect.runPromise(
-      Effect.either(decodeOrFail(NameSchema, { name: 42 })),
-    )
-    expect(result._tag).toBe("Left")
-    if (result._tag === "Left") {
-      expect(result.left).toBeInstanceOf(Error)
-    }
-  })
-
-  it("fails for missing required field", async () => {
-    const result = await Effect.runPromise(Effect.either(decodeOrFail(NameSchema, {})))
-    expect(result._tag).toBe("Left")
-  })
-})
+	const NameSchema = Schema.Struct({ name: Schema.String });
+
+	it("decodes valid data", async () => {
+		const result = await Effect.runPromise(
+			decodeOrFail(NameSchema, { name: "hello" }),
+		);
+		expect(result.name).toBe("hello");
+	});
+
+	it("fails with Error for invalid data", async () => {
+		const result = await Effect.runPromise(
+			Effect.either(decodeOrFail(NameSchema, { name: 42 })),
+		);
+		expect(result._tag).toBe("Left");
+		if (result._tag === "Left") {
+			expect(result.left).toBeInstanceOf(Error);
+		}
+	});
+
+	it("fails for missing required field", async () => {
+		const result = await Effect.runPromise(
+			Effect.either(decodeOrFail(NameSchema, {})),
+		);
+		expect(result._tag).toBe("Left");
+	});
+});