@aaronshaf/plane 0.1.3 → 0.1.6

package/tests/new-schemas2.test.ts

@@ -1,205 +1,217 @@
-import { describe, expect, it } from "bun:test"
-import { Effect, Schema } from "effect"
+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)))),
-  )
+	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()
-  })
-})
+	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)
-  })
-})
+	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()
-  })
-})
+	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)
-  })
-})
+	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()
-  })
-})
+	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")
-  })
-})
+	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()
-  })
-})
+	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)
-  })
-})
+	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()
-  })
-})
+	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)
-  })
-})
+	it("decodes results", async () => {
+		const resp = await decode(CycleIssuesResponseSchema, {
+			results: [{ id: "ci1", issue: "i1" }],
+		});
+		expect(resp.results).toHaveLength(1);
+	});
+});

package/tests/output.test.ts

@@ -1,78 +1,80 @@
-import { describe, expect, it, beforeEach, afterEach } from "bun:test"
-import { toXml } from "@/output"
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import { toXml } from "@/output";
 
 describe("toXml", () => {
-  it("wraps results in <results> root element", () => {
-    const out = toXml([{ id: "1", name: "Foo" }])
-    expect(out).toStartWith("<results>")
-    expect(out).toEndWith("</results>")
-  })
+	it("wraps results in <results> root element", () => {
+		const out = toXml([{ id: "1", name: "Foo" }]);
+		expect(out).toStartWith("<results>");
+		expect(out).toEndWith("</results>");
+	});
 
-  it("renders each item as an <item> element with attributes", () => {
-    const out = toXml([{ id: "abc", name: "My Project" }])
-    expect(out).toContain('<item id="abc" name="My Project">')
-  })
+	it("renders each item as an <item> element with attributes", () => {
+		const out = toXml([{ id: "abc", name: "My Project" }]);
+		expect(out).toContain('<item id="abc" name="My Project">');
+	});
 
-  it("renders an empty <results> for empty array", () => {
-    const out = toXml([])
-    expect(out).toBe("<results>\n\n</results>")
-  })
+	it("renders an empty <results> for empty array", () => {
+		const out = toXml([]);
+		expect(out).toBe("<results>\n\n</results>");
+	});
 
-  it("renders multiple items", () => {
-    const out = toXml([
-      { id: "1", name: "A" },
-      { id: "2", name: "B" },
-    ])
-    expect(out).toContain('id="1"')
-    expect(out).toContain('id="2"')
-  })
+	it("renders multiple items", () => {
+		const out = toXml([
+			{ id: "1", name: "A" },
+			{ id: "2", name: "B" },
+		]);
+		expect(out).toContain('id="1"');
+		expect(out).toContain('id="2"');
+	});
 
-  it("escapes & in attribute values", () => {
-    const out = toXml([{ name: "Canvas & Codegen" }])
-    expect(out).toContain("Canvas &amp; Codegen")
-    expect(out).not.toContain("Canvas & Codegen")
-  })
+	it("escapes & in attribute values", () => {
+		const out = toXml([{ name: "Canvas & Codegen" }]);
+		expect(out).toContain("Canvas &amp; Codegen");
+		expect(out).not.toContain("Canvas & Codegen");
+	});
 
-  it("escapes < and > in attribute values", () => {
-    const out = toXml([{ name: "<tag>" }])
-    expect(out).toContain("&lt;tag&gt;")
-  })
+	it("escapes < and > in attribute values", () => {
+		const out = toXml([{ name: "<tag>" }]);
+		expect(out).toContain("&lt;tag&gt;");
+	});
 
-  it("escapes quotes in attribute values", () => {
-    const out = toXml([{ name: 'say "hi"' }])
-    expect(out).toContain("&quot;hi&quot;")
-  })
+	it("escapes quotes in attribute values", () => {
+		const out = toXml([{ name: 'say "hi"' }]);
+		expect(out).toContain("&quot;hi&quot;");
+	});
 
-  it("renders nested objects as child elements", () => {
-    const out = toXml([{ id: "1", state: { name: "Todo", group: "unstarted" } }])
-    expect(out).toContain("<state")
-    expect(out).toContain('name="Todo"')
-    expect(out).toContain('group="unstarted"')
-  })
+	it("renders nested objects as child elements", () => {
+		const out = toXml([
+			{ id: "1", state: { name: "Todo", group: "unstarted" } },
+		]);
+		expect(out).toContain("<state");
+		expect(out).toContain('name="Todo"');
+		expect(out).toContain('group="unstarted"');
+	});
 
-  it("renders nested arrays as child elements", () => {
-    const out = toXml([{ id: "1", tags: ["a", "b"] }])
-    expect(out).toContain("<tags>")
-    expect(out).toContain("</tags>")
-  })
+	it("renders nested arrays as child elements", () => {
+		const out = toXml([{ id: "1", tags: ["a", "b"] }]);
+		expect(out).toContain("<tags>");
+		expect(out).toContain("</tags>");
+	});
 
-  it("handles null values as empty string in attributes", () => {
-    const out = toXml([{ id: "1", color: null }])
-    expect(out).toContain('color=""')
-  })
-})
+	it("handles null values as empty string in attributes", () => {
+		const out = toXml([{ id: "1", color: null }]);
+		expect(out).toContain('color=""');
+	});
+});
 
 describe("argv stripping", () => {
-  it("removes --json from process.argv when present", async () => {
-    process.argv.push("--json-test-flag-xyz")
-    // The module is already loaded; test that toXml is a function (module loaded ok)
-    expect(typeof toXml).toBe("function")
-    process.argv.pop()
-  })
+	it("removes --json from process.argv when present", async () => {
+		process.argv.push("--json-test-flag-xyz");
+		// The module is already loaded; test that toXml is a function (module loaded ok)
+		expect(typeof toXml).toBe("function");
+		process.argv.pop();
+	});
 
-  it("jsonMode and xmlMode are booleans", async () => {
-    const { jsonMode, xmlMode } = await import("@/output")
-    expect(typeof jsonMode).toBe("boolean")
-    expect(typeof xmlMode).toBe("boolean")
-  })
-})
+	it("jsonMode and xmlMode are booleans", async () => {
+		const { jsonMode, xmlMode } = await import("@/output");
+		expect(typeof jsonMode).toBe("boolean");
+		expect(typeof xmlMode).toBe("boolean");
+	});
+});