@talkpilot/core-db 1.3.89 → 1.3.91

package/src/talkpilot/calls/calls.types.ts

@@ -166,55 +166,3 @@ export type DateRange = {
   since?: Date;
   until?: Date;
 };
-
-export type StatsDateRangeParams = {
-  dateFrom?: string;
-  dateTo?: string;
-  clientId?: string;
-  /** Restricts to these clients. Combined with clientId, both must match. */
-  clientIds?: string[];
-  timezone?: string;
-};
-
-export type ClientCallStatsParams = StatsDateRangeParams & {
-  skip?: number;
-  limit?: number;
-};
-
-export type ActiveCallsSummary = {
-  total: number;
-  incoming: number;
-  outgoing: number;
-  activeClientIds: string[];
-};
-
-export type TodayCallsSummary = {
-  total: number;
-  incoming: number;
-  outgoing: number;
-  completed: number;
-  failed: number;
-  busy: number;
-  noAnswer: number;
-  totalMinutes: number;
-};
-
-export type ClientCallStats = {
-  clientId: string;
-  totalCalls: number;
-  statusCounts: Record<string, number>;
-  totalMinutes: number;
-  lastCallDate: Date;
-};
-
-export type ClientCallStatsPage = {
-  rows: ClientCallStats[];
-  total: number;
-};
-
-export type SessionCallStats = {
-  sessionId: string;
-  sessionName: string;
-  totalCalls: number;
-  statusCounts: Record<string, number>;
-};

package/src/talkpilot/clients/clients.getters.ts

@@ -1,13 +1,5 @@
-import { getDb, getPhoneNumbersCollection, Client } from "../index";
-import { Collection, Filter } from "mongodb";
-import { applyQueryOptions } from "../utils/query.utils";
-import { escapeRegex } from "../../utils/regex.utils";
-import {
-  BackofficeRole,
-  ClientsPage,
-  ClientsPageParams,
-  ClientsPageRow,
-} from "./clients.types";
+import { getDb, Client } from "../index";
+import { Collection } from "mongodb";
 
 export const getClientsCollection = (): Collection<Client> => {
   return getDb().collection<Client>("clients");
@@ -23,86 +15,5 @@ export const getClientByAPIKey = async (
   return client ? client : null;
 };
 
-export const getAllClientIds = async (): Promise<string[]> => {
-  const docs = await getClientsCollection()
-    .find({}, { projection: { clientId: 1 } })
-    .toArray();
-  return docs.map((c) => c.clientId);
-};
 export const getClientByClientId = (clientId: string): Promise<Client | null> =>
   getClientsCollection().findOne({ clientId });
-
-export const getBackofficeRole = async (
-  clientId: string,
-): Promise<BackofficeRole | null> => {
-  const client = await getClientsCollection().findOne(
-    { clientId },
-    { projection: { "roles.backoffice": 1 } },
-  );
-  const flags = client?.roles?.backoffice;
-  if (flags?.admin) return "admin";
-  if (flags?.viewer) return "viewer";
-  return null;
-};
-
-export const setBackofficeRole = async (
-  clientId: string,
-  role: BackofficeRole | null,
-): Promise<boolean> => {
-  const { matchedCount } = await getClientsCollection().updateOne(
-    { clientId },
-    {
-      $set: {
-        "roles.backoffice.admin": role === "admin",
-        "roles.backoffice.viewer": role === "viewer",
-      },
-    },
-  );
-  return matchedCount > 0;
-};
-
-export const countBackofficeAdmins = (): Promise<number> =>
-  getClientsCollection().countDocuments({ "roles.backoffice.admin": true });
-
-export const findClientsPage = async ({
-  skip,
-  limit,
-  clientId,
-  clientIds,
-  excludeClientIds,
-  search,
-}: ClientsPageParams): Promise<ClientsPage> => {
-  const conditions: Filter<Client>[] = [];
-  if (clientId) {
-    conditions.push({ clientId });
-  }
-  if (clientIds) {
-    conditions.push({ clientId: { $in: clientIds } });
-  }
-  if (excludeClientIds) {
-    conditions.push({ clientId: { $nin: excludeClientIds } });
-  }
-
-  const text = search?.trim();
-  if (text) {
-    const pattern = new RegExp(escapeRegex(text), "i");
-    const clientIdsByPhone = await getPhoneNumbersCollection().distinct("client_id", {
-      phone_number: pattern,
-    });
-    conditions.push({
-      $or: [{ clientId: pattern }, { clientId: { $in: clientIdsByPhone } }],
-    });
-  }
-
-  const filter: Filter<Client> =
-    conditions.length > 0 ? { $and: conditions } : {};
-  const collection = getClientsCollection();
-  const [clients, total] = await Promise.all([
-    applyQueryOptions(
-      collection.find<ClientsPageRow>(filter, { projection: { clientId: 1, credits: 1 } }),
-      { sort: { createdAt: -1, _id: -1 }, skip, limit },
-    ).toArray(),
-    collection.countDocuments(filter),
-  ]);
-  return { clients, total };
-};

package/src/talkpilot/clients/clients.types.ts

@@ -1,21 +1,8 @@
 import { ObjectId } from "mongodb";
 import { ClientQuotaSettings } from "./clients.quota.types";
-import { BACKOFFICE_ROLES } from "./clients.constants";
 
 export type { QuotaThresholdAlert, ClientQuotaSettings, QuotaAlertInput, ClientQuotaUsage, ClientQuotaState } from "./clients.quota.types";
 
-export type BackofficeRole = (typeof BACKOFFICE_ROLES)[number];
-
-export type BackofficeRoleFlags = {
-  admin?: boolean;
-  viewer?: boolean;
-};
-
-export type ClientRoles = {
-  admin?: boolean;
-  backoffice?: BackofficeRoleFlags;
-};
-
 export type Client = {
   _id?: ObjectId;
   createdAt: Date;
@@ -26,51 +13,6 @@ export type Client = {
   credits: number;
   managedBy?: string;
   quota?: ClientQuotaSettings;
-  roles?: ClientRoles;
 };
 
 export type ClientDoc = Client & { _id: ObjectId };
-
-export type ClientsPageParams = {
-  skip: number;
-  limit: number;
-  /** Exact clientId match. */
-  clientId?: string;
-  /** Only these clients, e.g. the ones with calls in a date range. */
-  clientIds?: string[];
-  /** Every client except these, e.g. the ones that called since an inactivity cutoff. */
-  excludeClientIds?: string[];
-  /** Case-insensitive "contains" on the clientId or on any of the client's phone numbers. */
-  search?: string;
-};
-
-export type ClientsPageRow = Pick<ClientDoc, "_id" | "clientId" | "credits">;
-
-export type ClientsPage = {
-  clients: ClientsPageRow[];
-  total: number;
-};
-
-export type CollectionMatch = { collectionName: string; matched: boolean };
-
-export type CollectionDeleteResult = {
-  collectionName: string;
-  deletedCount: number;
-  success: boolean;
-  error?: string;
-};
-
-export type AuditLogResult = {
-  auditLogged: boolean;
-  auditError?: string;
-};
-
-/** Discriminated union: `deleted` tells you which shape you got without guessing. */
-export type DeleteClientDataSummary =
-  | { clientId: string; deleted: false; reason: string }
-  | ({
-      clientId: string;
-      deleted: true;
-      results: CollectionDeleteResult[];
-      allSucceeded: boolean;
-    } & AuditLogResult);

package/src/talkpilot/clients/index.ts

@@ -1,6 +1,4 @@
-export * from "./clients.constants";
 export * from "./clients.getters";
 export * from "./clients.types";
 export * from "./clients.quota.getters";
 export * from "./clients.quota.types";
-export * from "./clients.lifecycle";

package/src/talkpilot/contextNotes/__tests__/contextNotes.getters.spec.ts

@@ -6,6 +6,9 @@ import {
   setContextNoteEntries,
   setContextNoteConfig,
   deleteContextNoteEntry,
+  appendContextNoteEntry,
+  updateContextNoteEntryFields,
+  pullContextNoteEntry,
 } from "../contextNotes.getters";
 import { ObjectId } from "../../index";
 import {
@@ -203,6 +206,144 @@ describe("contextNotes getters", () => {
     expect(saved?.notes[0]._id.toString()).toBe(noteToKeep._id.toString());
   });
 
+  it("should append one note without replacing the others", async () => {
+    const kept = createContextNoteEntry({ title: "kept" });
+    const doc = buildContextNote({ notes: [kept] });
+    await createContextNote(doc);
+    const now = new Date("2026-10-18T12:00:00.000Z");
+
+    const added = await appendContextNoteEntry(
+      doc.clientId,
+      doc.product,
+      {
+        title: "added",
+        content: "new content",
+        activeFrom: now,
+        expiresAt: null,
+      },
+      now,
+    );
+
+    const saved = await getContextNotesCollection().findOne({
+      clientId: doc.clientId,
+      product: doc.product,
+    });
+    expect(saved?.notes).toHaveLength(2);
+    expect(saved?.notes[0].title).toBe("added");
+    expect(saved?.notes[1]._id.toString()).toBe(kept._id.toString());
+    expect(added._id.toString()).toBe(saved?.notes[0]._id.toString());
+    expect(added.createdAt).toEqual(now);
+  });
+
+  it("should create the document when appending the first note", async () => {
+    const clientId = new ObjectId().toString();
+    const now = new Date("2026-10-18T12:00:00.000Z");
+
+    const added = await appendContextNoteEntry(
+      clientId,
+      "Municipal",
+      {
+        title: "first",
+        content: "content",
+        activeFrom: now,
+        expiresAt: null,
+      },
+      now,
+    );
+
+    const saved = await getContextNotes(clientId, "Municipal");
+    expect(saved).toHaveLength(1);
+    expect(saved[0].notes).toHaveLength(1);
+    expect(saved[0].notes[0]._id.toString()).toBe(added._id.toString());
+  });
+
+  it("should update one note and leave the others unchanged", async () => {
+    const kept = createContextNoteEntry({ title: "kept" });
+    const target = createContextNoteEntry({ title: "before" });
+    const doc = buildContextNote({ notes: [kept, target] });
+    await createContextNote(doc);
+    const now = new Date("2026-10-18T13:00:00.000Z");
+    const activeFrom = new Date("2026-10-01T00:00:00.000Z");
+
+    const updated = await updateContextNoteEntryFields(
+      doc.clientId,
+      doc.product,
+      target._id,
+      {
+        title: "after",
+        content: "changed",
+        activeFrom,
+        expiresAt: null,
+      },
+      now,
+    );
+
+    const saved = await getContextNotesCollection().findOne({
+      clientId: doc.clientId,
+      product: doc.product,
+    });
+    expect(updated?.title).toBe("after");
+    expect(updated?.updatedAt).toEqual(now);
+    expect(saved?.notes).toHaveLength(2);
+    expect(saved?.notes[0].title).toBe("kept");
+    expect(saved?.notes[1].title).toBe("after");
+    expect(saved?.notes[1].content).toBe("changed");
+    expect(saved?.notes[1].createdAt).toEqual(target.createdAt);
+  });
+
+  it("should return null when updating a missing note", async () => {
+    const doc = buildContextNote({ notes: [createContextNoteEntry()] });
+    await createContextNote(doc);
+
+    const updated = await updateContextNoteEntryFields(
+      doc.clientId,
+      doc.product,
+      new ObjectId(),
+      {
+        title: "missing",
+        content: "missing",
+        activeFrom: new Date(),
+        expiresAt: null,
+      },
+    );
+
+    expect(updated).toBeNull();
+  });
+
+  it("should pull one note and leave the others", async () => {
+    const kept = createContextNoteEntry();
+    const removed = createContextNoteEntry();
+    const doc = buildContextNote({ notes: [kept, removed] });
+    await createContextNote(doc);
+
+    const pulled = await pullContextNoteEntry(
+      doc.clientId,
+      doc.product,
+      removed._id,
+    );
+
+    const saved = await getContextNotesCollection().findOne({
+      clientId: doc.clientId,
+      product: doc.product,
+    });
+    expect(pulled).toBe(true);
+    expect(saved?.notes).toHaveLength(1);
+    expect(saved?.notes[0]._id.toString()).toBe(kept._id.toString());
+  });
+
+  it("should return false when pulling a missing note", async () => {
+    const doc = buildContextNote({ notes: [createContextNoteEntry()] });
+    await createContextNote(doc);
+
+    const pulled = await pullContextNoteEntry(
+      doc.clientId,
+      doc.product,
+      new ObjectId(),
+    );
+
+    expect(pulled).toBe(false);
+  });
+
   it("should return false when deleteContextNoteEntry targets a non-existent note", async () => {
     const doc = buildContextNote({ notes: [] });
     const id = await createContextNote(doc);

package/src/talkpilot/contextNotes/contextNotes.getters.ts

@@ -1,6 +1,10 @@
 import { Collection, ObjectId, WithId } from "mongodb";
 import { getDb } from "../index";
-import type { ContextNote, ContextNoteEntry } from "./contextNotes.types";
+import type {
+  ContextNote,
+  ContextNoteEntry,
+  ContextNoteEntryWrite,
+} from "./contextNotes.types";
 
 export const getContextNotesCollection = (): Collection<ContextNote> => {
   return getDb().collection<ContextNote>("contextNotes");
@@ -71,6 +75,76 @@ export const setContextNoteConfig = async (
   return result.matchedCount > 0;
 };
 
+const findNoteEntryById = (
+  doc: WithId<ContextNote> | null,
+  noteId: ObjectId,
+): ContextNoteEntry | null =>
+  doc?.notes.find((note) => note._id.equals(noteId)) ?? null;
+
+/** Inserts one note at the start. Other notes on the document are left untouched. */
+export const appendContextNoteEntry = async (
+  clientId: string,
+  product: string,
+  entry: ContextNoteEntryWrite,
+  now: Date = new Date(),
+): Promise<ContextNoteEntry> => {
+  const note: ContextNoteEntry = {
+    _id: new ObjectId(),
+    title: entry.title,
+    content: entry.content,
+    activeFrom: entry.activeFrom,
+    expiresAt: entry.expiresAt,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  const saved = await getContextNotesCollection().findOneAndUpdate(
+    { clientId, product },
+    { $push: { notes: { $each: [note], $position: 0 } } },
+    { upsert: true, returnDocument: "after" },
+  );
+
+  return findNoteEntryById(saved, note._id) ?? note;
+};
+
+/** Replaces one note's fields. Other notes on the document are left untouched. */
+export const updateContextNoteEntryFields = async (
+  clientId: string,
+  product: string,
+  noteId: ObjectId,
+  entry: ContextNoteEntryWrite,
+  now: Date = new Date(),
+): Promise<ContextNoteEntry | null> => {
+  const saved = await getContextNotesCollection().findOneAndUpdate(
+    { clientId, product, "notes._id": noteId },
+    {
+      $set: {
+        "notes.$.title": entry.title,
+        "notes.$.content": entry.content,
+        "notes.$.activeFrom": entry.activeFrom,
+        "notes.$.expiresAt": entry.expiresAt,
+        "notes.$.updatedAt": now,
+      },
+    },
+    { returnDocument: "after" },
+  );
+
+  return findNoteEntryById(saved, noteId);
+};
+
+/** Removes one note by id. Other notes on the document are left untouched. */
+export const pullContextNoteEntry = async (
+  clientId: string,
+  product: string,
+  noteId: ObjectId,
+): Promise<boolean> => {
+  const result = await getContextNotesCollection().updateOne(
+    { clientId, product, "notes._id": noteId },
+    { $pull: { notes: { _id: noteId } } },
+  );
+  return result.modifiedCount > 0;
+};
+
 /** Removes a single note entry from a document by its _id. */
 export const deleteContextNoteEntry = async (
   id: ObjectId,

package/src/talkpilot/contextNotes/contextNotes.types.ts

@@ -10,6 +10,13 @@ export type ContextNoteEntry = {
   updatedAt: Date;
 };
 
+export type ContextNoteEntryWrite = {
+  title: string;
+  content: string;
+  activeFrom: Date;
+  expiresAt: Date | null;
+};
+
 export type ContextNote = {
   _id: ObjectId;
   clientId: string;

package/src/talkpilot/index.ts

@@ -2,7 +2,6 @@ import { Db, ObjectId as MongoObjectId } from "mongodb";
 
 export * from "./flows";
 export * from "./contextNotes";
-export * from "./auditLogs";
 export * from "./products";
 export * from "./results";
 export * from "./sessions";