Fix SDK drift against kan.bn API: paths, mandatory fields, renamed inputs

Author: MeritonAliu

FUNCTIONS.md

@@ -1,6 +1,6 @@
 {
   "name": "@centrolabs/kan-sdk",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Unofficial SDK for kan.bn API",
   "author": "centrolabs",
   "homepage": "https://github.com/centrolabs/kan-sdk",

package.json

@@ -185,12 +185,12 @@ describe("KanClient", () => {
     test("JSON-stringifies PATCH body", async () => {
       const mock = createMockFetch();
       const restore = withMock(mock);
-      mock.registerPatch("/workspaces/ws_1", { publicId: "ws_1", name: "Updated", slug: "ws", createdAt: "", updatedAt: "" });
+      mock.registerPatch("/checklists/items/item_1", { publicId: "item_1", checklistPublicId: "chk_1", title: "Done", completed: true, index: 0, createdAt: "", updatedAt: "" });
 
       const kan = createKan({ apiKey: "kan_test" });
-      await kan.workspaces.update("ws_1", { name: "Updated", description: "New desc" });
+      await kan.cards.updateChecklistItem("item_1", { title: "Done", completed: true });
 
-      expect(mock.calls[0].body).toEqual({ name: "Updated", description: "New desc" });
+      expect(mock.calls[0].body).toEqual({ title: "Done", completed: true });
       restore();
     });
 

src/client.test.ts

@@ -24,27 +24,39 @@ describe("BoardsConcern", () => {
     restore();
   });
 
-  test("getBySlug calls /boards/slug/:slug", async () => {
+  test("getBySlug calls /workspaces/:workspaceSlug/boards/:boardSlug", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
-    mock.registerGet("/boards/slug/my-board", { publicId: "brd_1", name: "Board", slug: "my-board", workspacePublicId: "ws_1", type: "regular", createdAt: "", updatedAt: "" });
+    mock.registerGet("/workspaces/my-ws/boards/my-board", { publicId: "brd_1", name: "Board", slug: "my-board", workspacePublicId: "ws_1", type: "regular", createdAt: "", updatedAt: "" });
 
     const kan = createKan({ apiKey: "kan_test" });
-    await kan.boards.getBySlug("my-board");
+    await kan.boards.getBySlug({ workspaceSlug: "my-ws", boardSlug: "my-board" });
 
-    expect(mock.calls[0].url).toContain("/boards/slug/my-board");
+    expect(mock.calls[0].url).toContain("/workspaces/my-ws/boards/my-board");
     restore();
   });
 
-  test("create posts correct body", async () => {
+  test("create posts to /workspaces/:id/boards with mandatory lists/labels", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
-    mock.registerPost("/boards", { publicId: "brd_new", name: "New Board", slug: "new-board", workspacePublicId: "ws_1", type: "regular", createdAt: "", updatedAt: "" });
+    mock.registerPost("/workspaces/ws_1/boards", { publicId: "brd_new", name: "New Board", slug: "new-board", workspacePublicId: "ws_1", type: "regular", createdAt: "", updatedAt: "" });
 
     const kan = createKan({ apiKey: "kan_test" });
-    await kan.boards.create({ name: "New Board", workspacePublicId: "ws_1", type: "template", description: "A board" });
-
-    expect(mock.calls[0].body).toEqual({ name: "New Board", workspacePublicId: "ws_1", type: "template", description: "A board" });
+    await kan.boards.create({
+      name: "New Board",
+      workspacePublicId: "ws_1",
+      lists: ["To Do", "Done"],
+      labels: ["urgent"],
+      type: "template",
+    });
+
+    expect(mock.calls[0].url).toContain("/workspaces/ws_1/boards");
+    expect(mock.calls[0].body).toEqual({
+      name: "New Board",
+      lists: ["To Do", "Done"],
+      labels: ["urgent"],
+      type: "template",
+    });
     restore();
   });
 
@@ -54,9 +66,9 @@ describe("BoardsConcern", () => {
     mock.registerPut("/boards/brd_1", { publicId: "brd_1", name: "Renamed", slug: "board", workspacePublicId: "ws_1", type: "regular", createdAt: "", updatedAt: "" });
 
     const kan = createKan({ apiKey: "kan_test" });
-    await kan.boards.update("brd_1", { name: "Renamed", description: "New desc" });
+    await kan.boards.update("brd_1", { name: "Renamed", visibility: "private", favorite: true });
 
-    expect(mock.calls[0].body).toEqual({ name: "Renamed", description: "New desc" });
+    expect(mock.calls[0].body).toEqual({ name: "Renamed", visibility: "private", favorite: true });
     expect(mock.calls[0].method).toBe("PUT");
     restore();
   });
@@ -74,15 +86,17 @@ describe("BoardsConcern", () => {
     restore();
   });
 
-  test("checkSlugAvailable calls /boards/:slug/available", async () => {
+  test("checkSlugAvailable calls /boards/:id/check-slug-availability with boardSlug", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
-    mock.registerGet("/boards/my-slug/available", { available: false });
+    mock.registerGet("/boards/brd_1/check-slug-availability", { isReserved: false });
 
     const kan = createKan({ apiKey: "kan_test" });
-    const result = await kan.boards.checkSlugAvailable("my-slug");
+    const result = await kan.boards.checkSlugAvailable("brd_1", "my-slug");
 
-    expect(result).toEqual({ available: false });
+    expect(mock.calls[0].url).toContain("/boards/brd_1/check-slug-availability");
+    expect(mock.calls[0].url).toContain("boardSlug=my-slug");
+    expect(result).toEqual({ isReserved: false });
     restore();
   });
 });

src/concerns/boards.test.ts

@@ -4,64 +4,61 @@ import type { KanClient } from "../client";
 export interface CreateBoardInput {
   name: string;
   workspacePublicId: string;
-  description?: string;
+  lists: string[];
+  labels: string[];
   type?: "regular" | "template";
+  sourceBoardPublicId?: string;
 }
 
 export interface UpdateBoardInput {
   name?: string;
-  description?: string;
+  slug?: string;
+  visibility?: "public" | "private";
+  favorite?: boolean;
+  isArchived?: boolean;
+}
+
+export interface GetBoardBySlugInput {
+  workspaceSlug: string;
+  boardSlug: string;
 }
 
 export class BoardsConcern {
   constructor(private client: KanClient) {}
 
-  /**
-   * Retrieves a board by its public ID.
-   * @param boardPublicId - The public ID of the board
-   */
   async getByPublicId(boardPublicId: string): Promise<Board> {
     return this.client.get<Board>(`/boards/${boardPublicId}`);
   }
 
-  /**
-   * Retrieves a board by its slug.
-   * @param slug - The slug of the board
-   */
-  async getBySlug(slug: string): Promise<Board> {
-    return this.client.get<Board>(`/boards/slug/${slug}`);
+  async getBySlug(input: GetBoardBySlugInput): Promise<Board> {
+    return this.client.get<Board>(
+      `/workspaces/${input.workspaceSlug}/boards/${input.boardSlug}`
+    );
   }
 
-  /**
-   * Creates a new board.
-   * @param input - The board creation input
-   */
   async create(input: CreateBoardInput): Promise<Board> {
-    return this.client.post<Board>("/boards", input);
+    const { workspacePublicId, ...body } = input;
+    return this.client.post<Board>(
+      `/workspaces/${workspacePublicId}/boards`,
+      body
+    );
   }
 
-  /**
-   * Updates an existing board.
-   * @param boardPublicId - The public ID of the board to update
-   * @param input - The fields to update
-   */
   async update(boardPublicId: string, input: UpdateBoardInput): Promise<Board> {
     return this.client.put<Board>(`/boards/${boardPublicId}`, input);
   }
 
-  /**
-   * Deletes a board.
-   * @param boardPublicId - The public ID of the board to delete
-   */
   async delete(boardPublicId: string): Promise<void> {
     await this.client.delete<void>(`/boards/${boardPublicId}`);
   }
 
-  /**
-   * Checks whether a board slug is available.
-   * @param slug - The slug to check
-   */
-  async checkSlugAvailable(slug: string): Promise<{ available: boolean }> {
-    return this.client.get<{ available: boolean }>(`/boards/${slug}/available`);
+  async checkSlugAvailable(
+    boardPublicId: string,
+    boardSlug: string
+  ): Promise<{ isReserved: boolean }> {
+    return this.client.get<{ isReserved: boolean }>(
+      `/boards/${boardPublicId}/check-slug-availability`,
+      { boardSlug }
+    );
   }
 }

src/concerns/boards.ts

@@ -60,12 +60,12 @@ describe("CardsConcern", () => {
   test("update puts with partial body", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
-    mock.registerPut("/cards/card_1", { publicId: "card_1", title: "Updated", listPublicId: "lst_1", boardPublicId: "brd_1", position: 1, createdAt: "", updatedAt: "" });
+    mock.registerPut("/cards/card_1", { publicId: "card_1", title: "Updated", listPublicId: "lst_1", boardPublicId: "brd_1", index: 1, createdAt: "", updatedAt: "" });
 
     const kan = createKan({ apiKey: "kan_test" });
-    await kan.cards.update("card_1", { title: "Updated", position: 1 });
+    await kan.cards.update("card_1", { title: "Updated", index: 1 });
 
-    expect(mock.calls[0].body).toEqual({ title: "Updated", position: 1 });
+    expect(mock.calls[0].body).toEqual({ title: "Updated", index: 1 });
     expect(mock.calls[0].method).toBe("PUT");
     restore();
   });
@@ -155,28 +155,67 @@ describe("CardsConcern", () => {
     restore();
   });
 
-  test("updateChecklistItem patches nested item path", async () => {
+  test("updateChecklist puts /checklists/:id", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
-    mock.registerPatch("/cards/card_1/checklists/chk_1/items/item_1", { publicId: "item_1", checklistPublicId: "chk_1", text: "Done", isChecked: true, position: 0, createdAt: "", updatedAt: "" });
+    mock.registerPut("/checklists/chk_1", { publicId: "chk_1", cardPublicId: "card_1", name: "Renamed", createdAt: "", updatedAt: "" });
 
     const kan = createKan({ apiKey: "kan_test" });
-    await kan.cards.updateChecklistItem("card_1", "chk_1", "item_1", { text: "Done", isChecked: true });
+    await kan.cards.updateChecklist("chk_1", { name: "Renamed" });
 
-    expect(mock.calls[0].url).toContain("/cards/card_1/checklists/chk_1/items/item_1");
-    expect(mock.calls[0].body).toEqual({ text: "Done", isChecked: true });
+    expect(mock.calls[0].url).toContain("/checklists/chk_1");
+    expect(mock.calls[0].body).toEqual({ name: "Renamed" });
     restore();
   });
 
-  test("deleteChecklistItem calls DELETE on nested item path", async () => {
+  test("deleteChecklist calls DELETE /checklists/:id", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
-    mock.registerDelete("/cards/card_1/checklists/chk_1/items/item_1", undefined, 204);
+    mock.registerDelete("/checklists/chk_1", undefined, 204);
 
     const kan = createKan({ apiKey: "kan_test" });
-    await expect(kan.cards.deleteChecklistItem("card_1", "chk_1", "item_1")).resolves.toBeUndefined();
+    await expect(kan.cards.deleteChecklist("chk_1")).resolves.toBeUndefined();
 
-    expect(mock.calls[0].url).toContain("/cards/card_1/checklists/chk_1/items/item_1");
+    expect(mock.calls[0].url).toContain("/checklists/chk_1");
+    expect(mock.calls[0].method).toBe("DELETE");
+    restore();
+  });
+
+  test("addChecklistItem posts to /checklists/:id/items", async () => {
+    const mock = createMockFetch();
+    const restore = withMock(mock);
+    mock.registerPost("/checklists/chk_1/items", { publicId: "item_1", checklistPublicId: "chk_1", title: "Do", completed: false, index: 0, createdAt: "", updatedAt: "" });
+
+    const kan = createKan({ apiKey: "kan_test" });
+    await kan.cards.addChecklistItem("chk_1", { title: "Do" });
+
+    expect(mock.calls[0].url).toContain("/checklists/chk_1/items");
+    expect(mock.calls[0].body).toEqual({ title: "Do" });
+    restore();
+  });
+
+  test("updateChecklistItem patches /checklists/items/:id", async () => {
+    const mock = createMockFetch();
+    const restore = withMock(mock);
+    mock.registerPatch("/checklists/items/item_1", { publicId: "item_1", checklistPublicId: "chk_1", title: "Done", completed: true, index: 0, createdAt: "", updatedAt: "" });
+
+    const kan = createKan({ apiKey: "kan_test" });
+    await kan.cards.updateChecklistItem("item_1", { title: "Done", completed: true });
+
+    expect(mock.calls[0].url).toContain("/checklists/items/item_1");
+    expect(mock.calls[0].body).toEqual({ title: "Done", completed: true });
+    restore();
+  });
+
+  test("deleteChecklistItem calls DELETE /checklists/items/:id", async () => {
+    const mock = createMockFetch();
+    const restore = withMock(mock);
+    mock.registerDelete("/checklists/items/item_1", undefined, 204);
+
+    const kan = createKan({ apiKey: "kan_test" });
+    await expect(kan.cards.deleteChecklistItem("item_1")).resolves.toBeUndefined();
+
+    expect(mock.calls[0].url).toContain("/checklists/items/item_1");
     expect(mock.calls[0].method).toBe("DELETE");
     restore();
   });
@@ -257,38 +296,40 @@ describe("CardsConcern", () => {
     restore();
   });
 
-  test("confirmAttachment posts key, filename, contentType, size", async () => {
+  test("confirmAttachment posts s3Key, filenames, contentType, size", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
     mock.registerPost("/cards/card_1/attachments/confirm", {});
 
     const kan = createKan({ apiKey: "kan_test" });
     await kan.cards.confirmAttachment("card_1", {
-      key: "uploads/file.pdf",
+      s3Key: "ws_1/card_1/abc-file.pdf",
       filename: "file.pdf",
+      originalFilename: "original-file.pdf",
       contentType: "application/pdf",
       size: 1024,
     });
 
     expect(mock.calls[0].url).toContain("/cards/card_1/attachments/confirm");
     expect(mock.calls[0].body).toEqual({
-      key: "uploads/file.pdf",
+      s3Key: "ws_1/card_1/abc-file.pdf",
       filename: "file.pdf",
+      originalFilename: "original-file.pdf",
       contentType: "application/pdf",
       size: 1024,
     });
     restore();
   });
 
-  test("deleteAttachment calls DELETE /cards/:id/attachments/:attId", async () => {
+  test("deleteAttachment calls DELETE /attachments/:attId", async () => {
     const mock = createMockFetch();
     const restore = withMock(mock);
-    mock.registerDelete("/cards/card_1/attachments/att_1", undefined, 204);
+    mock.registerDelete("/attachments/att_1", undefined, 204);
 
     const kan = createKan({ apiKey: "kan_test" });
-    await expect(kan.cards.deleteAttachment("card_1", "att_1")).resolves.toBeUndefined();
+    await expect(kan.cards.deleteAttachment("att_1")).resolves.toBeUndefined();
 
-    expect(mock.calls[0].url).toContain("/cards/card_1/attachments/att_1");
+    expect(mock.calls[0].url).toContain("/attachments/att_1");
     expect(mock.calls[0].method).toBe("DELETE");
     restore();
   });