@talkpilot/core-db 1.3.74 → 1.3.76

package/src/municipal/streets/streets.getters.ts

@@ -1,140 +1,140 @@
-import { CityName, getDb, ObjectId, Street } from "../index";
-import type { StreetHint } from "./streets.types";
-import {
-  AnyBulkWriteOperation,
-  BulkWriteOptions,
-  BulkWriteResult,
-  Collection,
-  Filter,
-  ObjectId as MongoObjectId,
-} from "mongodb";
-
-export const getStreetsCollection = (): Collection<Street> => {
-  return getDb().collection<Street>("streets");
-};
-
-export const bulkWriteStreets = async (
-  operations: AnyBulkWriteOperation<Street>[],
-  options?: BulkWriteOptions,
-): Promise<BulkWriteResult> => {
-  return getStreetsCollection().bulkWrite(operations, options);
-};
-
-export const findStreets = async (
-  filter: Filter<Street> = {},
-): Promise<Street[]> => {
-  return await getStreetsCollection().find(filter).toArray();
-};
-
-export const getStreetById = async (
-  streetId: string,
-): Promise<Street | null> => {
-  const street = await getStreetsCollection().findOne({
-    _id: new ObjectId(streetId),
-  });
-  return street ? street : null;
-};
-
-export const getStreetsByCityName = async (
-  cityName: CityName,
-): Promise<Street[]> => {
-  return await getStreetsCollection()
-    .find({ cityName })
-    .sort({ name: 1 })
-    .toArray();
-};
-
-export const getStreetByStreetId = async (
-  streetId: string,
-): Promise<Street | null> => {
-  const street = await getStreetsCollection().findOne({ id: streetId });
-  return street ? street : null;
-};
-
-/** Get street by business id and city. Use this when the client's city is known so the same id in another city is not returned. */
-export const getStreetByStreetIdAndCity = async (
-  streetId: string,
-  cityName: CityName,
-): Promise<Street | null> => {
-  const street = await getStreetsCollection().findOne({
-    id: streetId,
-    cityName,
-  });
-  return street ? street : null;
-};
-
-export const createStreet = async (
-  streetData: Omit<Street, "_id" | "createdAt" | "updatedAt">,
-): Promise<MongoObjectId> => {
-  const street: Omit<Street, "_id"> = {
-    ...streetData,
-    isActive: streetData.isActive ?? true,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  };
-  const { insertedId } = await getStreetsCollection().insertOne(
-    street as Street,
-  );
-  return insertedId;
-};
-
-export const updateStreet = async (
-  streetId: string,
-  data: Partial<Omit<Street, "_id" | "createdAt" | "updatedAt">>,
-): Promise<Street | null> => {
-  const result = await getStreetsCollection().findOneAndUpdate(
-    { _id: new ObjectId(streetId) },
-    { $set: { ...data, updatedAt: new Date() } },
-    { returnDocument: "after" },
-  );
-  return result || null;
-};
-
-/**
- * Add or update a street hint on an already-fetched street.
- * Only place that creates a new hint id (Date.getTime().toString()). Returns null if hint.id provided but not found, or text empty.
- */
-export const upsertStreetHintOnStreet = async (
-  street: Street,
-  hint: Partial<StreetHint> & Pick<StreetHint, "text">,
-): Promise<Street | null> => {
-  const text = hint.text.trim();
-  if (!text) return null;
-
-  const hints = street.hints || [];
-  let updatedHints: StreetHint[];
-
-  if (hint.id != null && hint.id !== "") {
-    const hintIndex = hints.findIndex((h) => String(h.id) === String(hint.id));
-    if (hintIndex === -1) return null;
-    updatedHints = [...hints];
-    updatedHints[hintIndex] = { id: String(hint.id), text };
-  } else {
-    updatedHints = [...hints, { id: new Date().getTime().toString(), text }];
-  }
-
-  return updateStreet(street._id.toString(), { hints: updatedHints });
-};
-
-/** Remove a hint from a street. streetId is the street business id (e.g. "703"). Updates document updatedAt. */
-export const deleteStreetHint = async (
-  streetId: string,
-  hintId: string,
-): Promise<Street | null> => {
-  const result = await getStreetsCollection().findOneAndUpdate(
-    { id: streetId },
-    { $pull: { hints: { id: hintId } }, $set: { updatedAt: new Date() } },
-    { returnDocument: "after" },
-  );
-  if (result) {
-    console.info("Street hint deleted", { streetId, hintId });
-  }
-  return result || null;
-};
-
-export const deleteStreet = async (streetId: string): Promise<boolean> => {
-  const result = await getStreetsCollection().deleteOne({
-    _id: new ObjectId(streetId),
-  });
-  return result.deletedCount > 0;
-};
+import { CityName, getDb, ObjectId, Street } from "../index";
+import type { StreetHint } from "./streets.types";
+import {
+  AnyBulkWriteOperation,
+  BulkWriteOptions,
+  BulkWriteResult,
+  Collection,
+  Filter,
+  ObjectId as MongoObjectId,
+} from "mongodb";
+
+export const getStreetsCollection = (): Collection<Street> => {
+  return getDb().collection<Street>("streets");
+};
+
+export const bulkWriteStreets = async (
+  operations: AnyBulkWriteOperation<Street>[],
+  options?: BulkWriteOptions,
+): Promise<BulkWriteResult> => {
+  return getStreetsCollection().bulkWrite(operations, options);
+};
+
+export const findStreets = async (
+  filter: Filter<Street> = {},
+): Promise<Street[]> => {
+  return await getStreetsCollection().find(filter).toArray();
+};
+
+export const getStreetById = async (
+  streetId: string,
+): Promise<Street | null> => {
+  const street = await getStreetsCollection().findOne({
+    _id: new ObjectId(streetId),
+  });
+  return street ? street : null;
+};
+
+export const getStreetsByCityName = async (
+  cityName: CityName,
+): Promise<Street[]> => {
+  return await getStreetsCollection()
+    .find({ cityName })
+    .sort({ name: 1 })
+    .toArray();
+};
+
+export const getStreetByStreetId = async (
+  streetId: string,
+): Promise<Street | null> => {
+  const street = await getStreetsCollection().findOne({ id: streetId });
+  return street ? street : null;
+};
+
+/** Get street by business id and city. Use this when the client's city is known so the same id in another city is not returned. */
+export const getStreetByStreetIdAndCity = async (
+  streetId: string,
+  cityName: CityName,
+): Promise<Street | null> => {
+  const street = await getStreetsCollection().findOne({
+    id: streetId,
+    cityName,
+  });
+  return street ? street : null;
+};
+
+export const createStreet = async (
+  streetData: Omit<Street, "_id" | "createdAt" | "updatedAt">,
+): Promise<MongoObjectId> => {
+  const street: Omit<Street, "_id"> = {
+    ...streetData,
+    isActive: streetData.isActive ?? true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+  const { insertedId } = await getStreetsCollection().insertOne(
+    street as Street,
+  );
+  return insertedId;
+};
+
+export const updateStreet = async (
+  streetId: string,
+  data: Partial<Omit<Street, "_id" | "createdAt" | "updatedAt">>,
+): Promise<Street | null> => {
+  const result = await getStreetsCollection().findOneAndUpdate(
+    { _id: new ObjectId(streetId) },
+    { $set: { ...data, updatedAt: new Date() } },
+    { returnDocument: "after" },
+  );
+  return result || null;
+};
+
+/**
+ * Add or update a street hint on an already-fetched street.
+ * Only place that creates a new hint id (Date.getTime().toString()). Returns null if hint.id provided but not found, or text empty.
+ */
+export const upsertStreetHintOnStreet = async (
+  street: Street,
+  hint: Partial<StreetHint> & Pick<StreetHint, "text">,
+): Promise<Street | null> => {
+  const text = hint.text.trim();
+  if (!text) return null;
+
+  const hints = street.hints || [];
+  let updatedHints: StreetHint[];
+
+  if (hint.id != null && hint.id !== "") {
+    const hintIndex = hints.findIndex((h) => String(h.id) === String(hint.id));
+    if (hintIndex === -1) return null;
+    updatedHints = [...hints];
+    updatedHints[hintIndex] = { id: String(hint.id), text };
+  } else {
+    updatedHints = [...hints, { id: new Date().getTime().toString(), text }];
+  }
+
+  return updateStreet(street._id.toString(), { hints: updatedHints });
+};
+
+/** Remove a hint from a street. streetId is the street business id (e.g. "703"). Updates document updatedAt. */
+export const deleteStreetHint = async (
+  streetId: string,
+  hintId: string,
+): Promise<Street | null> => {
+  const result = await getStreetsCollection().findOneAndUpdate(
+    { id: streetId },
+    { $pull: { hints: { id: hintId } }, $set: { updatedAt: new Date() } },
+    { returnDocument: "after" },
+  );
+  if (result) {
+    console.info("Street hint deleted", { streetId, hintId });
+  }
+  return result || null;
+};
+
+export const deleteStreet = async (streetId: string): Promise<boolean> => {
+  const result = await getStreetsCollection().deleteOne({
+    _id: new ObjectId(streetId),
+  });
+  return result.deletedCount > 0;
+};

package/src/municipal/streets/streets.types.ts

@@ -1,19 +1,19 @@
-import { ObjectId, WithId } from "mongodb";
-
-export type StreetHint = {
-  id: string;
-  text: string;
-};
-
-export type Street = {
-  _id: ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  id: string;
-  name: string;
-  cityName: string;
-  hints?: StreetHint[];
-  isActive?: boolean;
-};
-
-export type StreetDoc = WithId<Street>;
+import { ObjectId, WithId } from "mongodb";
+
+export type StreetHint = {
+  id: string;
+  text: string;
+};
+
+export type Street = {
+  _id: ObjectId;
+  createdAt: Date;
+  updatedAt: Date;
+  id: string;
+  name: string;
+  cityName: string;
+  hints?: StreetHint[];
+  isActive?: boolean;
+};
+
+export type StreetDoc = WithId<Street>;

package/src/municipal/systemInstructions/__tests__/getters.spec.ts

@@ -1,113 +1,113 @@
-import { createSystemInstruction } from "../instructions.setters";
-import {
-  getSystemInstructionById,
-  getActiveSystemInstructionsByCity,
-  getSystemInstructionsByToolAndCity,
-  findSystemInstructions,
-} from "../instructions.getters";
-import { ObjectId } from "mongodb";
-import { MIS_TOOLS, QUERY_TYPES } from "../instructions.types";
-
-describe("System Instructions Getter Tests", () => {
-  const testCity = "Ashdod";
-  const otherCity = "Tel Aviv";
-
-  describe("getters", () => {
-    let instructionId: string;
-
-    beforeEach(async () => {
-      const id = await createSystemInstruction({
-        cityName: testCity,
-        instruction: "Find Me",
-        isActive: true,
-        tool: MIS_TOOLS.findSubject,
-        queryType: QUERY_TYPES.any,
-        tags: ["important", "urgent"],
-      });
-      instructionId = id.toString();
-
-      // for filtering tests
-      await createSystemInstruction({
-        cityName: testCity,
-        instruction: "Inactive One",
-        isActive: false,
-        tool: MIS_TOOLS.findSubject,
-        queryType: QUERY_TYPES.any,
-      });
-
-      await createSystemInstruction({
-        cityName: otherCity,
-        instruction: "Other City Instruction",
-        isActive: true,
-        tool: MIS_TOOLS.findStreet,
-        queryType: QUERY_TYPES.exactlyOne,
-      });
-    });
-
-    describe("getSystemInstructionById", () => {
-      it("given existing id when fetched then return the document", async () => {
-        const result = await getSystemInstructionById(instructionId);
-        expect(result?._id.toString()).toBe(instructionId);
-      });
-
-      it("given non-existent id when fetched then return null", async () => {
-        const result = await getSystemInstructionById(
-          new ObjectId().toHexString(),
-        );
-        expect(result).toBeNull();
-      });
-    });
-
-    describe("getActiveSystemInstructionsByCity", () => {
-      it("given city with active instructions when fetched then return only active documents for that city", async () => {
-        const result = await getActiveSystemInstructionsByCity(testCity);
-        expect(result.length).toBe(1);
-        expect(result[0].instruction).toBe("Find Me");
-      });
-
-      it("given city with no instructions when fetched then return empty array", async () => {
-        const result =
-          await getActiveSystemInstructionsByCity("NonExistentCity");
-        expect(result).toEqual([]);
-      });
-    });
-
-    describe("getSystemInstructionsByToolAndCity", () => {
-      it("given valid city and tool when fetched then return matching instructions", async () => {
-        const result = await getSystemInstructionsByToolAndCity(
-          testCity,
-          MIS_TOOLS.findSubject,
-        );
-        expect(result.length).toBe(2); // One active, one inactive
-        expect(
-          result.every(
-            (r) => r.cityName === testCity && r.tool === MIS_TOOLS.findSubject,
-          ),
-        ).toBe(true);
-      });
-
-      it("given valid city but wrong tool when fetched then return empty array", async () => {
-        const result = await getSystemInstructionsByToolAndCity(
-          testCity,
-          MIS_TOOLS.findStreet,
-        );
-        expect(result).toEqual([]);
-      });
-    });
-
-    describe("findSystemInstructions", () => {
-      it("given filter by tags when searched then return matching documents", async () => {
-        const result = await findSystemInstructions({
-          tags: { $in: ["important"] },
-        });
-        expect(result.length).toBe(1);
-        expect(result[0].instruction).toBe("Find Me");
-      });
-
-      it("given empty filter when searched then return all documents", async () => {
-        const result = await findSystemInstructions({});
-        expect(result.length).toBe(3);
-      });
-    });
-  });
-});
+import { createSystemInstruction } from "../instructions.setters";
+import {
+  getSystemInstructionById,
+  getActiveSystemInstructionsByCity,
+  getSystemInstructionsByToolAndCity,
+  findSystemInstructions,
+} from "../instructions.getters";
+import { ObjectId } from "mongodb";
+import { MIS_TOOLS, QUERY_TYPES } from "../instructions.types";
+
+describe("System Instructions Getter Tests", () => {
+  const testCity = "Ashdod";
+  const otherCity = "Tel Aviv";
+
+  describe("getters", () => {
+    let instructionId: string;
+
+    beforeEach(async () => {
+      const id = await createSystemInstruction({
+        cityName: testCity,
+        instruction: "Find Me",
+        isActive: true,
+        tool: MIS_TOOLS.findSubject,
+        queryType: QUERY_TYPES.any,
+        tags: ["important", "urgent"],
+      });
+      instructionId = id.toString();
+
+      // for filtering tests
+      await createSystemInstruction({
+        cityName: testCity,
+        instruction: "Inactive One",
+        isActive: false,
+        tool: MIS_TOOLS.findSubject,
+        queryType: QUERY_TYPES.any,
+      });
+
+      await createSystemInstruction({
+        cityName: otherCity,
+        instruction: "Other City Instruction",
+        isActive: true,
+        tool: MIS_TOOLS.findStreet,
+        queryType: QUERY_TYPES.exactlyOne,
+      });
+    });
+
+    describe("getSystemInstructionById", () => {
+      it("given existing id when fetched then return the document", async () => {
+        const result = await getSystemInstructionById(instructionId);
+        expect(result?._id.toString()).toBe(instructionId);
+      });
+
+      it("given non-existent id when fetched then return null", async () => {
+        const result = await getSystemInstructionById(
+          new ObjectId().toHexString(),
+        );
+        expect(result).toBeNull();
+      });
+    });
+
+    describe("getActiveSystemInstructionsByCity", () => {
+      it("given city with active instructions when fetched then return only active documents for that city", async () => {
+        const result = await getActiveSystemInstructionsByCity(testCity);
+        expect(result.length).toBe(1);
+        expect(result[0].instruction).toBe("Find Me");
+      });
+
+      it("given city with no instructions when fetched then return empty array", async () => {
+        const result =
+          await getActiveSystemInstructionsByCity("NonExistentCity");
+        expect(result).toEqual([]);
+      });
+    });
+
+    describe("getSystemInstructionsByToolAndCity", () => {
+      it("given valid city and tool when fetched then return matching instructions", async () => {
+        const result = await getSystemInstructionsByToolAndCity(
+          testCity,
+          MIS_TOOLS.findSubject,
+        );
+        expect(result.length).toBe(2); // One active, one inactive
+        expect(
+          result.every(
+            (r) => r.cityName === testCity && r.tool === MIS_TOOLS.findSubject,
+          ),
+        ).toBe(true);
+      });
+
+      it("given valid city but wrong tool when fetched then return empty array", async () => {
+        const result = await getSystemInstructionsByToolAndCity(
+          testCity,
+          MIS_TOOLS.findStreet,
+        );
+        expect(result).toEqual([]);
+      });
+    });
+
+    describe("findSystemInstructions", () => {
+      it("given filter by tags when searched then return matching documents", async () => {
+        const result = await findSystemInstructions({
+          tags: { $in: ["important"] },
+        });
+        expect(result.length).toBe(1);
+        expect(result[0].instruction).toBe("Find Me");
+      });
+
+      it("given empty filter when searched then return all documents", async () => {
+        const result = await findSystemInstructions({});
+        expect(result.length).toBe(3);
+      });
+    });
+  });
+});