@talkpilot/core-db 1.3.84 → 1.3.86

package/src/municipal/muniIssues/__tests__/muniIssues.setters.spec.ts

@@ -1,219 +1,219 @@
-import {
-  createMuniIssue,
-  setMuniIssueResponse,
-  updateMuniIssueStatus,
-} from "../muniIssues.setters";
-import {
-  generateMuniIssueId,
-  getMuniIssueById,
-  getMuniIssueByJiraKey,
-} from "../muniIssues.getters";
-import { createMuniIssueInput } from "../../../test-utils/factories";
-
-describe("muniIssues setters", () => {
-  describe("createMuniIssue", () => {
-    it("should insert a well-formed document with createdAt and nested content/jira", async () => {
-      const input = createMuniIssueInput();
-      const id = generateMuniIssueId();
-
-      const insertedId = await createMuniIssue(input, id);
-
-      const saved = await getMuniIssueById(insertedId.toString());
-      expect(saved).toMatchObject({
-        callSid: input.callSid,
-        clientId: input.clientId,
-        cityName: input.cityName,
-        issueContent: input.issueContent,
-        jira: input.jira,
-      });
-      expect(saved?.createdAt).toBeInstanceOf(Date);
-    });
-
-    it("should start the issue as in_review with updatedAt and no response", async () => {
-      const insertedId = await createMuniIssue(
-        createMuniIssueInput(),
-        generateMuniIssueId(),
-      );
-
-      const saved = await getMuniIssueById(insertedId.toString());
-      expect(saved?.status).toBe("in_review");
-      expect(saved?.updatedAt).toBeInstanceOf(Date);
-      expect(saved?.response).toBeUndefined();
-    });
-
-    it("should default jira.syncStatus to created when not provided", async () => {
-      const id = generateMuniIssueId();
-
-      const insertedId = await createMuniIssue(
-        createMuniIssueInput({ jira: { key: "CP-9" } }),
-        id,
-      );
-
-      const saved = await getMuniIssueById(insertedId.toString());
-      expect(saved?.jira.syncStatus).toBe("created");
-    });
-
-    it("should store long issueDescription and desiredBehavior in full", async () => {
-      const issueDescription = "a".repeat(2000);
-      const desiredBehavior = "b".repeat(2000);
-      const id = generateMuniIssueId();
-
-      const insertedId = await createMuniIssue(
-        createMuniIssueInput({
-          issueContent: {
-            issuerName: "Dana",
-            issuerRole: "Agent",
-            issueDescription,
-            desiredBehavior,
-          },
-        }),
-        id,
-      );
-
-      const saved = await getMuniIssueById(insertedId.toString());
-      expect(saved?.issueContent.issueDescription).toHaveLength(2000);
-      expect(saved?.issueContent.desiredBehavior).toBe(desiredBehavior);
-    });
-
-    it("should persist the caller-supplied _id so the Jira ticket can link back", async () => {
-      const id = generateMuniIssueId();
-
-      const insertedId = await createMuniIssue(createMuniIssueInput(), id);
-
-      expect(insertedId.toString()).toBe(id.toString());
-      expect(await getMuniIssueById(id.toString())).not.toBeNull();
-    });
-  });
-
-  describe("getMuniIssueById", () => {
-    it("should return null for an unknown or malformed id instead of throwing", async () => {
-      expect(
-        await getMuniIssueById(generateMuniIssueId().toString()),
-      ).toBeNull();
-      expect(await getMuniIssueById("not-a-valid-id")).toBeNull();
-    });
-  });
-
-  describe("getMuniIssueByJiraKey", () => {
-    it("should find the issue with the given Jira key", async () => {
-      await createMuniIssue(
-        createMuniIssueInput({ jira: { key: "CP-555" } }),
-        generateMuniIssueId(),
-      );
-
-      const found = await getMuniIssueByJiraKey("CP-555");
-
-      expect(found?.jira.key).toBe("CP-555");
-      expect(await getMuniIssueByJiraKey("CP-nope")).toBeNull();
-    });
-  });
-
-  describe("updateMuniIssueStatus", () => {
-    it("should change the status of an unanswered issue", async () => {
-      const input = createMuniIssueInput();
-      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
-
-      expect(await updateMuniIssueStatus(id, input.clientId, "in_progress")).toBe(true);
-      expect((await getMuniIssueById(id))?.status).toBe("in_progress");
-    });
-
-    it("should not touch another client's issue or a malformed id", async () => {
-      const id = (
-        await createMuniIssue(createMuniIssueInput(), generateMuniIssueId())
-      ).toString();
-
-      expect(await updateMuniIssueStatus(id, "other-client", "resolved")).toBe(false);
-      expect(await updateMuniIssueStatus("not-a-valid-id", "any", "resolved")).toBe(false);
-      expect((await getMuniIssueById(id))?.status).toBe("in_review");
-    });
-  });
-
-  describe("setMuniIssueResponse", () => {
-    it("should save the response and status", async () => {
-      const input = createMuniIssueInput();
-      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
-
-      const saved = await setMuniIssueResponse(id, input.clientId, {
-        status: "resolved",
-        text: "Fixed",
-        imageUrls: ["https://example.com/a.png", "https://example.com/b.png"],
-      });
-
-      expect(saved).toBe(true);
-      const issue = await getMuniIssueById(id);
-      expect(issue?.status).toBe("resolved");
-      expect(issue?.response).toMatchObject({
-        text: "Fixed",
-        imageUrls: ["https://example.com/a.png", "https://example.com/b.png"],
-      });
-      expect(issue?.response?.createdAt).toBeInstanceOf(Date);
-      expect(issue?.response?.updatedAt).toBeUndefined();
-    });
-
-    it("should let an answered issue be edited, keeping the first-sent date", async () => {
-      const input = createMuniIssueInput();
-      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
-      await setMuniIssueResponse(id, input.clientId, {
-        status: "in_review",
-        text: "First",
-        imageUrls: ["https://example.com/a.png"],
-      });
-      const firstSentAt = (await getMuniIssueById(id))?.response?.createdAt;
-
-      expect(
-        await setMuniIssueResponse(id, input.clientId, { status: "resolved", text: "Second" }),
-      ).toBe(true);
-      expect(await updateMuniIssueStatus(id, input.clientId, "no_issue_found")).toBe(true);
-
-      const issue = await getMuniIssueById(id);
-      expect(issue?.status).toBe("no_issue_found");
-      expect(issue?.response?.text).toBe("Second");
-      expect(issue?.response?.imageUrls).toEqual([]);
-      expect(issue?.response?.createdAt).toEqual(firstSentAt);
-      expect(issue?.response?.updatedAt).toBeInstanceOf(Date);
-    });
-
-    it("should save images without text, and keep a cleared response with its first-sent date", async () => {
-      const input = createMuniIssueInput();
-      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
-
-      await setMuniIssueResponse(id, input.clientId, {
-        status: "resolved",
-        text: "",
-        imageUrls: ["https://example.com/a.png"],
-      });
-      const issueWithImage = await getMuniIssueById(id);
-      await setMuniIssueResponse(id, input.clientId, { status: "resolved", text: "", imageUrls: [] });
-
-      const response = (await getMuniIssueById(id))?.response;
-      expect(issueWithImage?.response?.imageUrls).toEqual(["https://example.com/a.png"]);
-      expect(response?.text).toBe("");
-      expect(response?.imageUrls).toEqual([]);
-      expect(response?.createdAt).toEqual(issueWithImage?.response?.createdAt);
-      expect(response?.updatedAt).toBeInstanceOf(Date);
-    });
-
-    it("should store text starting with $ as plain text", async () => {
-      const input = createMuniIssueInput();
-      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
-
-      await setMuniIssueResponse(id, input.clientId, { status: "resolved", text: "$status" });
-
-      expect((await getMuniIssueById(id))?.response?.text).toBe("$status");
-    });
-
-    it("should not touch another client's issue or a malformed id", async () => {
-      const id = (
-        await createMuniIssue(createMuniIssueInput(), generateMuniIssueId())
-      ).toString();
-
-      expect(
-        await setMuniIssueResponse(id, "other-client", { status: "resolved", text: "X" }),
-      ).toBe(false);
-      expect(
-        await setMuniIssueResponse("not-a-valid-id", "any", { status: "resolved", text: "X" }),
-      ).toBe(false);
-      expect((await getMuniIssueById(id))?.response).toBeUndefined();
-    });
-  });
-});
+import {
+  createMuniIssue,
+  setMuniIssueResponse,
+  updateMuniIssueStatus,
+} from "../muniIssues.setters";
+import {
+  generateMuniIssueId,
+  getMuniIssueById,
+  getMuniIssueByJiraKey,
+} from "../muniIssues.getters";
+import { createMuniIssueInput } from "../../../test-utils/factories";
+
+describe("muniIssues setters", () => {
+  describe("createMuniIssue", () => {
+    it("should insert a well-formed document with createdAt and nested content/jira", async () => {
+      const input = createMuniIssueInput();
+      const id = generateMuniIssueId();
+
+      const insertedId = await createMuniIssue(input, id);
+
+      const saved = await getMuniIssueById(insertedId.toString());
+      expect(saved).toMatchObject({
+        callSid: input.callSid,
+        clientId: input.clientId,
+        cityName: input.cityName,
+        issueContent: input.issueContent,
+        jira: input.jira,
+      });
+      expect(saved?.createdAt).toBeInstanceOf(Date);
+    });
+
+    it("should start the issue as in_review with updatedAt and no response", async () => {
+      const insertedId = await createMuniIssue(
+        createMuniIssueInput(),
+        generateMuniIssueId(),
+      );
+
+      const saved = await getMuniIssueById(insertedId.toString());
+      expect(saved?.status).toBe("in_review");
+      expect(saved?.updatedAt).toBeInstanceOf(Date);
+      expect(saved?.response).toBeUndefined();
+    });
+
+    it("should default jira.syncStatus to created when not provided", async () => {
+      const id = generateMuniIssueId();
+
+      const insertedId = await createMuniIssue(
+        createMuniIssueInput({ jira: { key: "CP-9" } }),
+        id,
+      );
+
+      const saved = await getMuniIssueById(insertedId.toString());
+      expect(saved?.jira.syncStatus).toBe("created");
+    });
+
+    it("should store long issueDescription and desiredBehavior in full", async () => {
+      const issueDescription = "a".repeat(2000);
+      const desiredBehavior = "b".repeat(2000);
+      const id = generateMuniIssueId();
+
+      const insertedId = await createMuniIssue(
+        createMuniIssueInput({
+          issueContent: {
+            issuerName: "Dana",
+            issuerRole: "Agent",
+            issueDescription,
+            desiredBehavior,
+          },
+        }),
+        id,
+      );
+
+      const saved = await getMuniIssueById(insertedId.toString());
+      expect(saved?.issueContent.issueDescription).toHaveLength(2000);
+      expect(saved?.issueContent.desiredBehavior).toBe(desiredBehavior);
+    });
+
+    it("should persist the caller-supplied _id so the Jira ticket can link back", async () => {
+      const id = generateMuniIssueId();
+
+      const insertedId = await createMuniIssue(createMuniIssueInput(), id);
+
+      expect(insertedId.toString()).toBe(id.toString());
+      expect(await getMuniIssueById(id.toString())).not.toBeNull();
+    });
+  });
+
+  describe("getMuniIssueById", () => {
+    it("should return null for an unknown or malformed id instead of throwing", async () => {
+      expect(
+        await getMuniIssueById(generateMuniIssueId().toString()),
+      ).toBeNull();
+      expect(await getMuniIssueById("not-a-valid-id")).toBeNull();
+    });
+  });
+
+  describe("getMuniIssueByJiraKey", () => {
+    it("should find the issue with the given Jira key", async () => {
+      await createMuniIssue(
+        createMuniIssueInput({ jira: { key: "CP-555" } }),
+        generateMuniIssueId(),
+      );
+
+      const found = await getMuniIssueByJiraKey("CP-555");
+
+      expect(found?.jira.key).toBe("CP-555");
+      expect(await getMuniIssueByJiraKey("CP-nope")).toBeNull();
+    });
+  });
+
+  describe("updateMuniIssueStatus", () => {
+    it("should change the status of an unanswered issue", async () => {
+      const input = createMuniIssueInput();
+      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
+
+      expect(await updateMuniIssueStatus(id, input.clientId, "in_progress")).toBe(true);
+      expect((await getMuniIssueById(id))?.status).toBe("in_progress");
+    });
+
+    it("should not touch another client's issue or a malformed id", async () => {
+      const id = (
+        await createMuniIssue(createMuniIssueInput(), generateMuniIssueId())
+      ).toString();
+
+      expect(await updateMuniIssueStatus(id, "other-client", "resolved")).toBe(false);
+      expect(await updateMuniIssueStatus("not-a-valid-id", "any", "resolved")).toBe(false);
+      expect((await getMuniIssueById(id))?.status).toBe("in_review");
+    });
+  });
+
+  describe("setMuniIssueResponse", () => {
+    it("should save the response and status", async () => {
+      const input = createMuniIssueInput();
+      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
+
+      const saved = await setMuniIssueResponse(id, input.clientId, {
+        status: "resolved",
+        text: "Fixed",
+        imageUrls: ["https://example.com/a.png", "https://example.com/b.png"],
+      });
+
+      expect(saved).toBe(true);
+      const issue = await getMuniIssueById(id);
+      expect(issue?.status).toBe("resolved");
+      expect(issue?.response).toMatchObject({
+        text: "Fixed",
+        imageUrls: ["https://example.com/a.png", "https://example.com/b.png"],
+      });
+      expect(issue?.response?.createdAt).toBeInstanceOf(Date);
+      expect(issue?.response?.updatedAt).toBeUndefined();
+    });
+
+    it("should let an answered issue be edited, keeping the first-sent date", async () => {
+      const input = createMuniIssueInput();
+      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
+      await setMuniIssueResponse(id, input.clientId, {
+        status: "in_review",
+        text: "First",
+        imageUrls: ["https://example.com/a.png"],
+      });
+      const firstSentAt = (await getMuniIssueById(id))?.response?.createdAt;
+
+      expect(
+        await setMuniIssueResponse(id, input.clientId, { status: "resolved", text: "Second" }),
+      ).toBe(true);
+      expect(await updateMuniIssueStatus(id, input.clientId, "no_issue_found")).toBe(true);
+
+      const issue = await getMuniIssueById(id);
+      expect(issue?.status).toBe("no_issue_found");
+      expect(issue?.response?.text).toBe("Second");
+      expect(issue?.response?.imageUrls).toEqual([]);
+      expect(issue?.response?.createdAt).toEqual(firstSentAt);
+      expect(issue?.response?.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it("should save images without text, and keep a cleared response with its first-sent date", async () => {
+      const input = createMuniIssueInput();
+      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
+
+      await setMuniIssueResponse(id, input.clientId, {
+        status: "resolved",
+        text: "",
+        imageUrls: ["https://example.com/a.png"],
+      });
+      const issueWithImage = await getMuniIssueById(id);
+      await setMuniIssueResponse(id, input.clientId, { status: "resolved", text: "", imageUrls: [] });
+
+      const response = (await getMuniIssueById(id))?.response;
+      expect(issueWithImage?.response?.imageUrls).toEqual(["https://example.com/a.png"]);
+      expect(response?.text).toBe("");
+      expect(response?.imageUrls).toEqual([]);
+      expect(response?.createdAt).toEqual(issueWithImage?.response?.createdAt);
+      expect(response?.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it("should store text starting with $ as plain text", async () => {
+      const input = createMuniIssueInput();
+      const id = (await createMuniIssue(input, generateMuniIssueId())).toString();
+
+      await setMuniIssueResponse(id, input.clientId, { status: "resolved", text: "$status" });
+
+      expect((await getMuniIssueById(id))?.response?.text).toBe("$status");
+    });
+
+    it("should not touch another client's issue or a malformed id", async () => {
+      const id = (
+        await createMuniIssue(createMuniIssueInput(), generateMuniIssueId())
+      ).toString();
+
+      expect(
+        await setMuniIssueResponse(id, "other-client", { status: "resolved", text: "X" }),
+      ).toBe(false);
+      expect(
+        await setMuniIssueResponse("not-a-valid-id", "any", { status: "resolved", text: "X" }),
+      ).toBe(false);
+      expect((await getMuniIssueById(id))?.response).toBeUndefined();
+    });
+  });
+});

package/src/municipal/muniIssues/__tests__/muniIssues.setup.spec.ts

@@ -1,93 +1,93 @@
-import {
-  ensureMuniIssuesCollection,
-  ensureMuniIssuesCollectionOnce,
-} from "../muniIssues.setup";
-import {
-  generateMuniIssueId,
-  getMuniIssuesCollection,
-} from "../muniIssues.getters";
-import { createMuniIssue } from "../muniIssues.setters";
-import { getDb } from "../../index";
-import { MUNI_ISSUES_COLLECTION } from "../muniIssues.constants";
-import { createMuniIssueInput } from "../../../test-utils/factories";
-
-describe("muniIssues setup", () => {
-  describe("ensureMuniIssuesCollection", () => {
-    it("should create the collection with a validator and the declared indexes", async () => {
-      await ensureMuniIssuesCollection();
-
-      const [collection] = (await getDb()
-        .listCollections({ name: MUNI_ISSUES_COLLECTION })
-        .toArray()) as { options?: { validator?: unknown } }[];
-      expect(collection?.options?.validator).toHaveProperty("$jsonSchema");
-
-      const indexNames = (await getMuniIssuesCollection().indexes()).map(
-        (i) => i.name,
-      );
-      expect(indexNames).toEqual(
-        expect.arrayContaining([
-          "callSid_1",
-          "createdAt_-1",
-          "clientId_1_createdAt_-1",
-          "jira_key_unique",
-        ]),
-      );
-    });
-
-    it("should accept a valid document and reject ones that violate the schema", async () => {
-      await ensureMuniIssuesCollection();
-
-      await expect(
-        createMuniIssue(createMuniIssueInput(), generateMuniIssueId()),
-      ).resolves.toBeDefined();
-
-      // Missing required issueContent fields → DB validation rejects it.
-      await expect(
-        getMuniIssuesCollection().insertOne({
-          callSid: "CA-bad",
-          createdAt: new Date(),
-        } as never),
-      ).rejects.toThrow();
-
-      // jira.syncStatus outside the enum → DB validation rejects it.
-      await expect(
-        createMuniIssue(
-          createMuniIssueInput({
-            jira: { key: "CP-99", syncStatus: "weird" as never },
-          }),
-          generateMuniIssueId(),
-        ),
-      ).rejects.toThrow();
-    });
-
-    it("should enforce the unique jira.key index", async () => {
-      await ensureMuniIssuesCollection();
-      const input = createMuniIssueInput();
-      await createMuniIssue(input, generateMuniIssueId());
-
-      // Same jira.key on a second insert violates the unique index.
-      await expect(
-        createMuniIssue(input, generateMuniIssueId()),
-      ).rejects.toThrow();
-    });
-
-    it("should be idempotent when run twice", async () => {
-      await ensureMuniIssuesCollection();
-      await expect(ensureMuniIssuesCollection()).resolves.toBeUndefined();
-    });
-  });
-
-  describe("ensureMuniIssuesCollectionOnce", () => {
-    it("should run the provisioning work at most once per process", async () => {
-      const createSpy = jest.spyOn(getDb(), "createCollection");
-
-      await Promise.all([
-        ensureMuniIssuesCollectionOnce(),
-        ensureMuniIssuesCollectionOnce(),
-      ]);
-      await ensureMuniIssuesCollectionOnce();
-
-      expect(createSpy).toHaveBeenCalledTimes(1);
-    });
-  });
-});
+import {
+  ensureMuniIssuesCollection,
+  ensureMuniIssuesCollectionOnce,
+} from "../muniIssues.setup";
+import {
+  generateMuniIssueId,
+  getMuniIssuesCollection,
+} from "../muniIssues.getters";
+import { createMuniIssue } from "../muniIssues.setters";
+import { getDb } from "../../index";
+import { MUNI_ISSUES_COLLECTION } from "../muniIssues.constants";
+import { createMuniIssueInput } from "../../../test-utils/factories";
+
+describe("muniIssues setup", () => {
+  describe("ensureMuniIssuesCollection", () => {
+    it("should create the collection with a validator and the declared indexes", async () => {
+      await ensureMuniIssuesCollection();
+
+      const [collection] = (await getDb()
+        .listCollections({ name: MUNI_ISSUES_COLLECTION })
+        .toArray()) as { options?: { validator?: unknown } }[];
+      expect(collection?.options?.validator).toHaveProperty("$jsonSchema");
+
+      const indexNames = (await getMuniIssuesCollection().indexes()).map(
+        (i) => i.name,
+      );
+      expect(indexNames).toEqual(
+        expect.arrayContaining([
+          "callSid_1",
+          "createdAt_-1",
+          "clientId_1_createdAt_-1",
+          "jira_key_unique",
+        ]),
+      );
+    });
+
+    it("should accept a valid document and reject ones that violate the schema", async () => {
+      await ensureMuniIssuesCollection();
+
+      await expect(
+        createMuniIssue(createMuniIssueInput(), generateMuniIssueId()),
+      ).resolves.toBeDefined();
+
+      // Missing required issueContent fields → DB validation rejects it.
+      await expect(
+        getMuniIssuesCollection().insertOne({
+          callSid: "CA-bad",
+          createdAt: new Date(),
+        } as never),
+      ).rejects.toThrow();
+
+      // jira.syncStatus outside the enum → DB validation rejects it.
+      await expect(
+        createMuniIssue(
+          createMuniIssueInput({
+            jira: { key: "CP-99", syncStatus: "weird" as never },
+          }),
+          generateMuniIssueId(),
+        ),
+      ).rejects.toThrow();
+    });
+
+    it("should enforce the unique jira.key index", async () => {
+      await ensureMuniIssuesCollection();
+      const input = createMuniIssueInput();
+      await createMuniIssue(input, generateMuniIssueId());
+
+      // Same jira.key on a second insert violates the unique index.
+      await expect(
+        createMuniIssue(input, generateMuniIssueId()),
+      ).rejects.toThrow();
+    });
+
+    it("should be idempotent when run twice", async () => {
+      await ensureMuniIssuesCollection();
+      await expect(ensureMuniIssuesCollection()).resolves.toBeUndefined();
+    });
+  });
+
+  describe("ensureMuniIssuesCollectionOnce", () => {
+    it("should run the provisioning work at most once per process", async () => {
+      const createSpy = jest.spyOn(getDb(), "createCollection");
+
+      await Promise.all([
+        ensureMuniIssuesCollectionOnce(),
+        ensureMuniIssuesCollectionOnce(),
+      ]);
+      await ensureMuniIssuesCollectionOnce();
+
+      expect(createSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+});