@cliangdev/flux-plugin 0.0.0-dev.cbdf207 → 0.0.0-dev.df3e9bb

package/src/server/adapters/__tests__/dependency-ops.test.ts

@@ -0,0 +1,395 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { HydratedIssue, LinearAdapter } from "../linear/adapter.js";
+import type { LinearConfig } from "../linear/types.js";
+
+/**
+ * Helper to create a mock HydratedIssue
+ */
+function createMockIssue(
+  overrides: Partial<HydratedIssue> = {},
+): HydratedIssue {
+  return {
+    id: "issue_abc123",
+    identifier: "ENG-42",
+    title: "Test Issue",
+    description: "Test description",
+    stateName: "Backlog",
+    stateType: "backlog",
+    labels: ["epic"],
+    parentIdentifier: undefined,
+    priority: 3,
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-01-01T00:00:00Z"),
+    _raw: {},
+    ...overrides,
+  };
+}
+
+describe("LinearAdapter - Dependency Operations", () => {
+  const mockConfig: LinearConfig = {
+    apiKey: "lin_api_test123",
+    teamId: "team_abc",
+    projectId: "proj_container",
+    defaultLabels: {
+      prd: "prd",
+      epic: "epic",
+      task: "task",
+    },
+  };
+
+  let adapter: LinearAdapter;
+
+  beforeEach(async () => {
+    const { LinearAdapter: LA } = await import("../linear/adapter.js");
+    adapter = new LA(mockConfig);
+  });
+
+  describe("addDependency", () => {
+    test("creates blocked relation between two epics", async () => {
+      const blockerIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        title: "Epic 1",
+        labels: ["epic"],
+        parentIdentifier: undefined,
+      });
+
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_2",
+        identifier: "ENG-43",
+        title: "Epic 2",
+        labels: ["epic"],
+        parentIdentifier: undefined,
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return blockerIssue;
+      });
+
+      const mockCreateRelation = mock(async () => ({
+        id: "relation_1",
+        type: "blocks",
+      }));
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssueRelation: mockCreateRelation,
+        },
+      };
+
+      await adapter.addDependency("ENG-43", "ENG-42");
+
+      expect(mockCreateRelation).toHaveBeenCalledWith({
+        issueId: "issue_epic_1", // blocker
+        relatedIssueId: "issue_epic_2", // blocked
+        type: "blocks",
+      });
+    });
+
+    test("creates blocked relation between two tasks", async () => {
+      const blockerTask = createMockIssue({
+        id: "issue_task_1",
+        identifier: "ENG-44",
+        title: "Task 1",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      const blockedTask = createMockIssue({
+        id: "issue_task_2",
+        identifier: "ENG-45",
+        title: "Task 2",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedTask;
+        return blockerTask;
+      });
+
+      const mockCreateRelation = mock(async () => ({
+        id: "relation_2",
+        type: "blocks",
+      }));
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          createIssueRelation: mockCreateRelation,
+        },
+      };
+
+      await adapter.addDependency("ENG-45", "ENG-44");
+
+      expect(mockCreateRelation).toHaveBeenCalledWith({
+        issueId: "issue_task_1",
+        relatedIssueId: "issue_task_2",
+        type: "blocks",
+      });
+    });
+
+    test("throws error if dependsOnRef issue not found", async () => {
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        labels: ["epic"],
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return null;
+      });
+
+      await expect(
+        adapter.addDependency("ENG-42", "INVALID-1"),
+      ).rejects.toThrow("Issue not found: INVALID-1");
+    });
+
+    test("throws error if entity types don't match (epic and task)", async () => {
+      const epicIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        parentIdentifier: undefined,
+      });
+
+      const taskIssue = createMockIssue({
+        id: "issue_task_1",
+        identifier: "ENG-43",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return epicIssue;
+        return taskIssue;
+      });
+
+      await expect(adapter.addDependency("ENG-42", "ENG-43")).rejects.toThrow(
+        "Cannot create dependency between different entity types (epic and task)",
+      );
+    });
+
+    test("throws error for self-dependency", async () => {
+      await expect(adapter.addDependency("ENG-42", "ENG-42")).rejects.toThrow(
+        "Entity cannot depend on itself",
+      );
+    });
+  });
+
+  describe("removeDependency", () => {
+    test("removes blocked relation between issues", async () => {
+      const mockDelete = mock(async () => ({ success: true }));
+      const mockRelation = {
+        id: "relation_1",
+        type: "blocks",
+        issue: { id: "issue_epic_1", identifier: "ENG-42" },
+        relatedIssue: { id: "issue_epic_2", identifier: "ENG-43" },
+        delete: mockDelete,
+      };
+
+      const blockerIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+      });
+
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_2",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [mockRelation],
+          })),
+        },
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return blockerIssue;
+      });
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await adapter.removeDependency("ENG-43", "ENG-42");
+
+      expect(mockDelete).toHaveBeenCalled();
+    });
+
+    test("throws error if dependsOnRef issue not found", async () => {
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        _raw: {
+          relations: mock(async () => ({ nodes: [] })),
+        },
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return null;
+      });
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await expect(
+        adapter.removeDependency("ENG-42", "INVALID-1"),
+      ).rejects.toThrow("Issue not found: INVALID-1");
+    });
+
+    test("throws error if relation not found", async () => {
+      const blockerIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+      });
+
+      const blockedIssue = createMockIssue({
+        id: "issue_epic_2",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [], // No relations
+          })),
+        },
+      });
+
+      let fetchCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCallCount++;
+        if (fetchCallCount === 1) return blockedIssue;
+        return blockerIssue;
+      });
+
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await expect(
+        adapter.removeDependency("ENG-43", "ENG-42"),
+      ).rejects.toThrow("Dependency not found between ENG-43 and ENG-42");
+    });
+  });
+
+  describe("getDependencies", () => {
+    test("returns list of blocking issue refs", async () => {
+      const mockIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [
+              {
+                id: "relation_1",
+                type: "blocks",
+                issue: { id: "issue_epic_2", identifier: "ENG-42" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+              {
+                id: "relation_2",
+                type: "blocks",
+                issue: { id: "issue_epic_3", identifier: "ENG-44" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const dependencies = await adapter.getDependencies("ENG-43");
+
+      expect(dependencies).toEqual(["ENG-42", "ENG-44"]);
+    });
+
+    test("returns empty array if no dependencies", async () => {
+      const mockIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const dependencies = await adapter.getDependencies("ENG-42");
+
+      expect(dependencies).toEqual([]);
+    });
+
+    test("filters out non-blocking relations", async () => {
+      const mockIssue = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-43",
+        _raw: {
+          relations: mock(async () => ({
+            nodes: [
+              {
+                id: "relation_1",
+                type: "blocks",
+                issue: { id: "issue_epic_2", identifier: "ENG-42" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+              {
+                id: "relation_2",
+                type: "duplicate",
+                issue: { id: "issue_epic_3", identifier: "ENG-44" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+              {
+                id: "relation_3",
+                type: "related",
+                issue: { id: "issue_epic_4", identifier: "ENG-45" },
+                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+              },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const dependencies = await adapter.getDependencies("ENG-43");
+
+      expect(dependencies).toEqual(["ENG-42"]);
+    });
+
+    test("throws error if issue not found", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.getDependencies("INVALID-1")).rejects.toThrow(
+        "Issue not found: INVALID-1",
+      );
+    });
+  });
+});

package/src/server/adapters/__tests__/document-ops.test.ts

@@ -0,0 +1,306 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { HydratedIssue, LinearAdapter } from "../linear/adapter.js";
+import type { LinearConfig } from "../linear/types.js";
+import type { Document } from "../types.js";
+
+/**
+ * Helper to create a mock HydratedIssue
+ */
+function createMockIssue(
+  overrides: Partial<HydratedIssue> = {},
+): HydratedIssue {
+  return {
+    id: "issue_abc123",
+    identifier: "ENG-42",
+    title: "Test Issue",
+    description: "Test description",
+    stateName: "Backlog",
+    stateType: "backlog",
+    labels: ["prd"],
+    parentIdentifier: undefined,
+    priority: 3,
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-01-01T00:00:00Z"),
+    _raw: {},
+    ...overrides,
+  };
+}
+
+describe("LinearAdapter - Document Operations", () => {
+  const mockConfig: LinearConfig = {
+    apiKey: "lin_api_test123",
+    teamId: "team_123",
+    projectId: "proj_container",
+    defaultLabels: {
+      prd: "prd",
+      epic: "epic",
+      task: "task",
+    },
+  };
+
+  let adapter: LinearAdapter;
+
+  beforeEach(async () => {
+    const { LinearAdapter: LA } = await import("../linear/adapter.js");
+    adapter = new LA(mockConfig);
+  });
+
+  describe("saveDocument", () => {
+    test("creates attachment for PRD and returns document with URL", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      const mockAttachment = {
+        id: "att_123",
+        title: "prd.md",
+        url:
+          "data:text/markdown;base64," +
+          Buffer.from(
+            "# Product Requirements Document\n\nContent here...",
+          ).toString("base64"),
+        createdAt: "2024-01-01T00:00:00Z",
+      };
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          attachmentCreate: mock(async () => ({
+            attachment: mockAttachment,
+            success: true,
+          })),
+        },
+      };
+
+      const doc: Document = {
+        prdRef: "ENG-1",
+        filename: "prd.md",
+        content: "# Product Requirements Document\n\nContent here...",
+      };
+
+      const savedDoc = await adapter.saveDocument(doc);
+
+      expect(savedDoc.prdRef).toBe("ENG-1");
+      expect(savedDoc.filename).toBe("prd.md");
+      expect(savedDoc.content).toBe(doc.content);
+      expect(savedDoc.url).toContain("data:text/markdown;base64,");
+    });
+
+    test("updates existing document if filename already exists", async () => {
+      const mockArchive = mock(async () => ({ success: true }));
+      const existingAttachment = {
+        id: "att_existing",
+        title: "prd.md",
+        url: "data:text/markdown;base64,b2xkIGNvbnRlbnQ=",
+        archive: mockArchive,
+      };
+
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [existingAttachment],
+          })),
+        },
+      });
+
+      const newAttachment = {
+        id: "att_new",
+        title: "prd.md",
+        url:
+          "data:text/markdown;base64," +
+          Buffer.from("# Updated Content").toString("base64"),
+        createdAt: "2024-01-02T00:00:00Z",
+      };
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          attachmentCreate: mock(async () => ({
+            attachment: newAttachment,
+            success: true,
+          })),
+        },
+      };
+
+      const doc: Document = {
+        prdRef: "ENG-1",
+        filename: "prd.md",
+        content: "# Updated Content",
+      };
+
+      const savedDoc = await adapter.saveDocument(doc);
+
+      expect(savedDoc.url).toContain("data:text/markdown;base64,");
+      expect(mockArchive).toHaveBeenCalled();
+    });
+
+    test("throws error when PRD does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      const doc: Document = {
+        prdRef: "ENG-999",
+        filename: "prd.md",
+        content: "Content",
+      };
+
+      await expect(adapter.saveDocument(doc)).rejects.toThrow(
+        "PRD ENG-999 not found",
+      );
+    });
+  });
+
+  describe("getDocuments", () => {
+    test("returns all documents for a PRD", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [
+              {
+                id: "att_1",
+                title: "prd.md",
+                url:
+                  "data:text/markdown;base64," +
+                  Buffer.from("# PRD Content").toString("base64"),
+              },
+              {
+                id: "att_2",
+                title: "design.md",
+                url:
+                  "data:text/markdown;base64," +
+                  Buffer.from("# Design Doc").toString("base64"),
+              },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const documents = await adapter.getDocuments("ENG-1");
+
+      expect(documents.length).toBe(2);
+      expect(documents[0].prdRef).toBe("ENG-1");
+      expect(documents[0].filename).toBe("prd.md");
+      expect(documents[0].content).toBe("# PRD Content");
+      expect(documents[0].url).toContain("data:text/markdown;base64,");
+      expect(documents[1].filename).toBe("design.md");
+      expect(documents[1].content).toBe("# Design Doc");
+    });
+
+    test("returns empty array when PRD has no documents", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const documents = await adapter.getDocuments("ENG-1");
+
+      expect(documents.length).toBe(0);
+    });
+
+    test("throws error when PRD does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.getDocuments("ENG-999")).rejects.toThrow(
+        "PRD ENG-999 not found",
+      );
+    });
+  });
+
+  describe("deleteDocument", () => {
+    test("archives attachment matching filename", async () => {
+      const mockArchive = mock(async () => ({ success: true }));
+      const mockAttachment = {
+        id: "att_123",
+        title: "prd.md",
+        url: "data:text/markdown;base64,Y29udGVudA==",
+        archive: mockArchive,
+      };
+
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [mockAttachment],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await adapter.deleteDocument("ENG-1", "prd.md");
+
+      expect(mockArchive).toHaveBeenCalled();
+    });
+
+    test("throws error when document not found", async () => {
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        labels: ["prd"],
+        _raw: {
+          attachments: mock(async () => ({
+            nodes: [],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await expect(
+        adapter.deleteDocument("ENG-1", "nonexistent.md"),
+      ).rejects.toThrow("Document nonexistent.md not found");
+    });
+
+    test("throws error when PRD does not exist", async () => {
+      (adapter as any).fetchIssue = mock(async () => null);
+
+      await expect(adapter.deleteDocument("ENG-999", "prd.md")).rejects.toThrow(
+        "PRD ENG-999 not found",
+      );
+    });
+  });
+});