@talkpilot/core-db 1.3.77 → 1.3.78

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

@@ -1,65 +1,65 @@
-import { Db, Document, MongoServerError } from "mongodb";
-import { getDb } from "../index";
-import {
-  MUNI_ISSUES_COLLECTION,
-  NAMESPACE_EXISTS,
-  VALIDATION_LEVEL,
-  VALIDATION_ACTION,
-} from "./muniIssues.constants";
-import { muniIssuesIndexes, muniIssuesJsonSchema } from "./muniIssues.schema";
-
-const applyValidator = (db: Db, validator: Document): Promise<unknown> =>
-  db.command({
-    collMod: MUNI_ISSUES_COLLECTION,
-    validator,
-    validationLevel: VALIDATION_LEVEL,
-    validationAction: VALIDATION_ACTION,
-  });
-
-// Provisions validator and indexes: createCollection first, collMod if already exists.
-export const ensureMuniIssuesCollection = async (): Promise<void> => {
-  const db = getDb();
-  const validator = { $jsonSchema: muniIssuesJsonSchema };
-
-  const existing = await db
-    .listCollections({ name: MUNI_ISSUES_COLLECTION })
-    .toArray();
-
-  if (existing.length === 0) {
-    try {
-      await db.createCollection(MUNI_ISSUES_COLLECTION, {
-        validator,
-        validationLevel: VALIDATION_LEVEL,
-        validationAction: VALIDATION_ACTION,
-      });
-    } catch (err) {
-      // NamespaceExists race: collection exists — apply validator via collMod.
-      if (err instanceof MongoServerError && err.code === NAMESPACE_EXISTS) {
-        await applyValidator(db, validator);
-      } else {
-        throw err;
-      }
-    }
-  } else {
-    await applyValidator(db, validator);
-  }
-
-  await db.collection(MUNI_ISSUES_COLLECTION).createIndexes(muniIssuesIndexes);
-};
-
-// Per-Db cache so each test's in-memory Db re-provisions.
-const provisioningByDb = new WeakMap<Db, Promise<void>>();
-
-// Once per Db; evicts failed run so the next call retries.
-export const ensureMuniIssuesCollectionOnce = (): Promise<void> => {
-  const db = getDb();
-  let provisioning = provisioningByDb.get(db);
-  if (!provisioning) {
-    provisioning = ensureMuniIssuesCollection().catch((err) => {
-      provisioningByDb.delete(db);
-      throw err;
-    });
-    provisioningByDb.set(db, provisioning);
-  }
-  return provisioning;
-};
+import { Db, Document, MongoServerError } from "mongodb";
+import { getDb } from "../index";
+import {
+  MUNI_ISSUES_COLLECTION,
+  NAMESPACE_EXISTS,
+  VALIDATION_LEVEL,
+  VALIDATION_ACTION,
+} from "./muniIssues.constants";
+import { muniIssuesIndexes, muniIssuesJsonSchema } from "./muniIssues.schema";
+
+const applyValidator = (db: Db, validator: Document): Promise<unknown> =>
+  db.command({
+    collMod: MUNI_ISSUES_COLLECTION,
+    validator,
+    validationLevel: VALIDATION_LEVEL,
+    validationAction: VALIDATION_ACTION,
+  });
+
+// Provisions validator and indexes: createCollection first, collMod if already exists.
+export const ensureMuniIssuesCollection = async (): Promise<void> => {
+  const db = getDb();
+  const validator = { $jsonSchema: muniIssuesJsonSchema };
+
+  const existing = await db
+    .listCollections({ name: MUNI_ISSUES_COLLECTION })
+    .toArray();
+
+  if (existing.length === 0) {
+    try {
+      await db.createCollection(MUNI_ISSUES_COLLECTION, {
+        validator,
+        validationLevel: VALIDATION_LEVEL,
+        validationAction: VALIDATION_ACTION,
+      });
+    } catch (err) {
+      // NamespaceExists race: collection exists — apply validator via collMod.
+      if (err instanceof MongoServerError && err.code === NAMESPACE_EXISTS) {
+        await applyValidator(db, validator);
+      } else {
+        throw err;
+      }
+    }
+  } else {
+    await applyValidator(db, validator);
+  }
+
+  await db.collection(MUNI_ISSUES_COLLECTION).createIndexes(muniIssuesIndexes);
+};
+
+// Per-Db cache so each test's in-memory Db re-provisions.
+const provisioningByDb = new WeakMap<Db, Promise<void>>();
+
+// Once per Db; evicts failed run so the next call retries.
+export const ensureMuniIssuesCollectionOnce = (): Promise<void> => {
+  const db = getDb();
+  let provisioning = provisioningByDb.get(db);
+  if (!provisioning) {
+    provisioning = ensureMuniIssuesCollection().catch((err) => {
+      provisioningByDb.delete(db);
+      throw err;
+    });
+    provisioningByDb.set(db, provisioning);
+  }
+  return provisioning;
+};

package/src/municipal/muniIssues/muniIssues.types.ts

@@ -1,68 +1,37 @@
-import { ObjectId } from "mongodb";
-
-import { CityName } from "../utils/types";
-import {
-  MUNI_ISSUE_STATUSES,
-  MUNI_ISSUE_SYNC_STATUSES,
-} from "./muniIssues.constants";
-
-export type MuniIssueSyncStatus = (typeof MUNI_ISSUE_SYNC_STATUSES)[number];
-
-export type MuniIssueStatus = (typeof MUNI_ISSUE_STATUSES)[number];
-
-/** The single TalkPilot response; once set, the complaint is locked. */
-export type MuniIssueResponse = {
-  text: string;
-  imageUrl?: string;
-  createdAt: Date;
-};
-
-export type MuniIssueContent = {
-  issuerName: string;
-  issuerRole: string;
-  issueDescription: string;
-  desiredBehavior: string;
-};
-
-export type MuniIssueJira = {
-  key: string;
-  syncStatus: MuniIssueSyncStatus;
-};
-
-export type MuniIssue = {
-  _id: ObjectId;
-  callSid: string;
-  clientId: string;
-  cityName: CityName;
-  issueContent: MuniIssueContent;
-  jira: MuniIssueJira;
-  createdAt: Date;
-  // Complaint tracking (CP-1888). Optional: issues created before it have none
-  // of these, which is how they are kept out of tracking.
-  status?: MuniIssueStatus;
-  response?: MuniIssueResponse;
-  updatedAt?: Date;
-};
-
-// _id/createdAt/status/updatedAt are set on insert, response only later (setMuniIssueResponse);
-// jira.syncStatus defaults to "created" because the issue is only stored after its Jira
-// ticket exists (CP-1115).
-export type CreateMuniIssueInput = Omit<
-  MuniIssue,
-  "_id" | "createdAt" | "jira" | "status" | "response" | "updatedAt"
-> & {
-  jira: { key: string; syncStatus?: MuniIssueSyncStatus };
-};
-
-export type SetMuniIssueResponseInput = {
-  status: MuniIssueStatus;
-  text: string;
-  imageUrl?: string;
-};
-
-/** `answered` filters by whether a TalkPilot response exists; omit it for all issues. */
-export type FindMuniIssuesOptions = {
-  answered?: boolean;
-  skip?: number;
-  limit?: number;
-};
+import { ObjectId } from "mongodb";
+
+import { CityName } from "../utils/types";
+import { MUNI_ISSUE_SYNC_STATUSES } from "./muniIssues.constants";
+
+export type MuniIssueSyncStatus = (typeof MUNI_ISSUE_SYNC_STATUSES)[number];
+
+export type MuniIssueContent = {
+  issuerName: string;
+  issuerRole: string;
+  issueDescription: string;
+  desiredBehavior: string;
+};
+
+export type MuniIssueJira = {
+  key: string;
+  syncStatus: MuniIssueSyncStatus;
+};
+
+export type MuniIssue = {
+  _id: ObjectId;
+  callSid: string;
+  clientId: string;
+  cityName: CityName;
+  issueContent: MuniIssueContent;
+  jira: MuniIssueJira;
+  createdAt: Date;
+};
+
+// _id/createdAt are set on insert; jira.syncStatus defaults to "created"
+// because the issue is only stored after its Jira ticket exists (CP-1115).
+export type CreateMuniIssueInput = Omit<
+  MuniIssue,
+  "_id" | "createdAt" | "jira"
+> & {
+  jira: { key: string; syncStatus?: MuniIssueSyncStatus };
+};

package/src/municipal/residents/__tests__/residents.spec.ts

@@ -0,0 +1,92 @@
+import { ObjectId } from "mongodb";
+import {
+  findResidentsByCityAndPhone,
+  getResidentByCityAndIdNumber,
+  getResidentByCityPhoneAndIdNumber,
+  getResidentById,
+  getResidentsCollection,
+} from "../residents.getters";
+import { createResident } from "../../../test-utils/factories/municipal/residents";
+
+const CITY = "tests" as const;
+const OTHER_CITY = "eilat" as const;
+
+describe("residents getters", () => {
+  it("getResidentById returns the document, or null for a missing / invalid id", async () => {
+    const resident = createResident({ cityName: CITY });
+    await getResidentsCollection().insertOne(resident);
+
+    const found = await getResidentById(resident._id.toHexString());
+    expect(found?._id.equals(resident._id)).toBe(true);
+    expect(found?.idNumber).toBe(resident.idNumber);
+
+    expect(await getResidentById("not-an-id")).toBeNull();
+    expect(await getResidentById(new ObjectId().toHexString())).toBeNull();
+  });
+
+  it("findResidentsByCityAndPhone returns only matching city + phone", async () => {
+    const phone = "+972501111111";
+    const match = createResident({ cityName: CITY, phoneNumber: phone });
+    const samePhoneOtherCity = createResident({
+      cityName: OTHER_CITY,
+      phoneNumber: phone,
+    });
+    const sameCityOtherPhone = createResident({
+      cityName: CITY,
+      phoneNumber: "+972502222222",
+    });
+    await getResidentsCollection().insertMany([
+      match,
+      samePhoneOtherCity,
+      sameCityOtherPhone,
+    ]);
+
+    const found = await findResidentsByCityAndPhone(CITY, phone);
+    expect(found).toHaveLength(1);
+    expect(found[0]._id.equals(match._id)).toBe(true);
+  });
+
+  it("allows a document with only _id", async () => {
+    const resident = { _id: new ObjectId() };
+    await getResidentsCollection().insertOne(resident);
+
+    const found = await getResidentById(resident._id.toHexString());
+    expect(found?._id.equals(resident._id)).toBe(true);
+    expect(found?.firstName).toBeUndefined();
+  });
+
+  it("getResidentByCityAndIdNumber is scoped to the city", async () => {
+    const idNumber = "123456789";
+    const match = createResident({ cityName: CITY, idNumber });
+    const otherCity = createResident({ cityName: OTHER_CITY, idNumber: "987654321" });
+    await getResidentsCollection().insertMany([match, otherCity]);
+
+    const found = await getResidentByCityAndIdNumber(CITY, idNumber);
+    expect(found?._id.equals(match._id)).toBe(true);
+
+    expect(await getResidentByCityAndIdNumber(OTHER_CITY, idNumber)).toBeNull();
+    expect(await getResidentByCityAndIdNumber(CITY, "000000000")).toBeNull();
+  });
+
+  it("getResidentByCityPhoneAndIdNumber requires both phone and id in that city", async () => {
+    const phone = "+972501111111";
+    const idNumber = "201111111";
+    const match = createResident({ cityName: CITY, phoneNumber: phone, idNumber });
+    const samePhoneWrongId = createResident({
+      cityName: CITY,
+      phoneNumber: phone,
+      idNumber: "209999999",
+    });
+    await getResidentsCollection().insertMany([match, samePhoneWrongId]);
+
+    const found = await getResidentByCityPhoneAndIdNumber(CITY, phone, idNumber);
+    expect(found?._id.equals(match._id)).toBe(true);
+
+    expect(
+      await getResidentByCityPhoneAndIdNumber(CITY, phone, "000000000"),
+    ).toBeNull();
+    expect(
+      await getResidentByCityPhoneAndIdNumber(OTHER_CITY, phone, idNumber),
+    ).toBeNull();
+  });
+});

package/src/municipal/residents/index.ts

@@ -0,0 +1,4 @@
+export * from "./residents.getters";
+export { RESIDENTS_COLLECTION } from "./residents.constants";
+export { residentsJsonSchema, residentsIndexes } from "./residents.schema";
+export type { Resident, ResidentDoc } from "./residents.types";

package/src/municipal/residents/residents.constants.ts

@@ -0,0 +1,2 @@
+/** Mongo collection name for municipal resident records. */
+export const RESIDENTS_COLLECTION = "residents";

package/src/municipal/residents/residents.getters.ts

@@ -0,0 +1,42 @@
+import { Collection, Filter } from "mongodb";
+import { CityName, getDb, ObjectId, Resident } from "../index";
+import { RESIDENTS_COLLECTION } from "./residents.constants";
+
+export const getResidentsCollection = (): Collection<Resident> => {
+  return getDb().collection<Resident>(RESIDENTS_COLLECTION);
+};
+
+export const findResidents = async (
+  filter: Filter<Resident> = {},
+): Promise<Resident[]> => {
+  return getResidentsCollection().find(filter).toArray();
+};
+
+export const getResidentById = async (
+  residentId: string,
+): Promise<Resident | null> => {
+  if (!ObjectId.isValid(residentId)) return null;
+  return getResidentsCollection().findOne({ _id: new ObjectId(residentId) });
+};
+
+export const findResidentsByCityAndPhone = async (
+  cityName: CityName,
+  phoneNumber: string,
+): Promise<Resident[]> => {
+  return getResidentsCollection().find({ cityName, phoneNumber }).toArray();
+};
+
+export const getResidentByCityAndIdNumber = async (
+  cityName: CityName,
+  idNumber: string,
+): Promise<Resident | null> => {
+  return getResidentsCollection().findOne({ cityName, idNumber });
+};
+
+export const getResidentByCityPhoneAndIdNumber = async (
+  cityName: CityName,
+  phoneNumber: string,
+  idNumber: string,
+): Promise<Resident | null> => {
+  return getResidentsCollection().findOne({ cityName, phoneNumber, idNumber });
+};

package/src/municipal/residents/residents.schema.ts

@@ -0,0 +1,28 @@
+import type { Document, IndexDescription } from "mongodb";
+
+export const residentsJsonSchema: Document = {
+  bsonType: "object",
+  properties: {
+    cityName: { bsonType: "string" },
+    firstName: { bsonType: "string" },
+    lastName: { bsonType: "string" },
+    idNumber: { bsonType: "string" },
+    phoneNumber: { bsonType: "string" },
+    address: { bsonType: "string" },
+    createdAt: { bsonType: "date" },
+    updatedAt: { bsonType: "date" },
+  },
+};
+
+export const residentsIndexes: IndexDescription[] = [
+  { key: { cityName: 1, phoneNumber: 1 }, name: "cityName_1_phoneNumber_1" },
+  {
+    key: { cityName: 1, idNumber: 1 },
+    name: "cityName_1_idNumber_unique",
+    unique: true,
+    partialFilterExpression: {
+      cityName: { $type: "string" },
+      idNumber: { $type: "string" },
+    },
+  },
+];

package/src/municipal/residents/residents.types.ts

@@ -0,0 +1,17 @@
+import { ObjectId, WithId } from "mongodb";
+
+import { CityName } from "../utils/types";
+
+export type Resident = {
+  _id: ObjectId;
+  createdAt?: Date;
+  updatedAt?: Date;
+  cityName?: CityName;
+  firstName?: string;
+  lastName?: string;
+  idNumber?: string;
+  phoneNumber?: string;
+  address?: string;
+};
+
+export type ResidentDoc = WithId<Resident>;