@talkpilot/core-db 1.3.84 → 1.3.85

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

@@ -1,85 +1,159 @@
-import { Collection, ObjectId, WithId } from "mongodb";
-import { getDb } from "../index";
-import type { ContextNote, ContextNoteEntry } from "./contextNotes.types";
-
-export const getContextNotesCollection = (): Collection<ContextNote> => {
-  return getDb().collection<ContextNote>("contextNotes");
-};
-
-/** Returns all context note documents matching a clientId and product. */
-export const getContextNotes = (
-  clientId: string,
-  product: string,
-): Promise<WithId<ContextNote>[]> => {
-  return getContextNotesCollection().find({ clientId, product }).toArray();
-};
-
-/** Returns all currently active note entries across matching documents */
-export const getActiveContextNotes = async (
-  clientId: string,
-  product: string,
-): Promise<ContextNoteEntry[]> => {
-  const docs = await getContextNotes(clientId, product);
-  const now = new Date();
-  return docs.flatMap((doc) =>
-    doc.notes.filter(
-      (note) =>
-        note.activeFrom <= now &&
-        (note.expiresAt === null || note.expiresAt > now),
-    ),
-  );
-};
-
-/** Creates a new context note document. */
-export const createContextNote = (
-  data: Omit<ContextNote, "_id">,
-): Promise<ObjectId> => {
-  return getContextNotesCollection()
-    .insertOne({ ...data, _id: new ObjectId() } as ContextNote)
-    .then((r) => r.insertedId);
-};
-
-/** Replaces the full notes array on a context note document. */
-export const setContextNoteEntries = async (
-  id: ObjectId,
-  clientId: string,
-  notes: ContextNoteEntry[],
-): Promise<boolean> => {
-  const result = await getContextNotesCollection().updateOne(
-    { _id: id, clientId },
-    { $set: { notes } },
-  );
-  return result.matchedCount > 0;
-};
-
-/** Updates the configuration fields (systemPrompt, product) on a context note document. */
-export const setContextNoteConfig = async (
-  id: ObjectId,
-  clientId: string,
-  config: { systemPrompt?: string; product?: string },
-): Promise<boolean> => {
-  const fields: Partial<ContextNote> = {};
-  if (config.systemPrompt !== undefined)
-    fields.systemPrompt = config.systemPrompt;
-  if (config.product !== undefined) fields.product = config.product;
-  if (!Object.keys(fields).length) return false;
-
-  const result = await getContextNotesCollection().updateOne(
-    { _id: id, clientId },
-    { $set: fields },
-  );
-  return result.matchedCount > 0;
-};
-
-/** Removes a single note entry from a document by its _id. */
-export const deleteContextNoteEntry = async (
-  id: ObjectId,
-  clientId: string,
-  noteId: ObjectId,
-): Promise<boolean> => {
-  const result = await getContextNotesCollection().updateOne(
-    { _id: id, clientId },
-    { $pull: { notes: { _id: noteId } as any } },
-  );
-  return result.modifiedCount > 0;
-};
+import { Collection, ObjectId, WithId } from "mongodb";
+import { getDb } from "../index";
+import type {
+  ContextNote,
+  ContextNoteEntry,
+  ContextNoteEntryWrite,
+} from "./contextNotes.types";
+
+export const getContextNotesCollection = (): Collection<ContextNote> => {
+  return getDb().collection<ContextNote>("contextNotes");
+};
+
+/** Returns all context note documents matching a clientId and product. */
+export const getContextNotes = (
+  clientId: string,
+  product: string,
+): Promise<WithId<ContextNote>[]> => {
+  return getContextNotesCollection().find({ clientId, product }).toArray();
+};
+
+/** Returns all currently active note entries across matching documents */
+export const getActiveContextNotes = async (
+  clientId: string,
+  product: string,
+): Promise<ContextNoteEntry[]> => {
+  const docs = await getContextNotes(clientId, product);
+  const now = new Date();
+  return docs.flatMap((doc) =>
+    doc.notes.filter(
+      (note) =>
+        note.activeFrom <= now &&
+        (note.expiresAt === null || note.expiresAt > now),
+    ),
+  );
+};
+
+/** Creates a new context note document. */
+export const createContextNote = (
+  data: Omit<ContextNote, "_id">,
+): Promise<ObjectId> => {
+  return getContextNotesCollection()
+    .insertOne({ ...data, _id: new ObjectId() } as ContextNote)
+    .then((r) => r.insertedId);
+};
+
+/** Replaces the full notes array on a context note document. */
+export const setContextNoteEntries = async (
+  id: ObjectId,
+  clientId: string,
+  notes: ContextNoteEntry[],
+): Promise<boolean> => {
+  const result = await getContextNotesCollection().updateOne(
+    { _id: id, clientId },
+    { $set: { notes } },
+  );
+  return result.matchedCount > 0;
+};
+
+/** Updates the configuration fields (systemPrompt, product) on a context note document. */
+export const setContextNoteConfig = async (
+  id: ObjectId,
+  clientId: string,
+  config: { systemPrompt?: string; product?: string },
+): Promise<boolean> => {
+  const fields: Partial<ContextNote> = {};
+  if (config.systemPrompt !== undefined)
+    fields.systemPrompt = config.systemPrompt;
+  if (config.product !== undefined) fields.product = config.product;
+  if (!Object.keys(fields).length) return false;
+
+  const result = await getContextNotesCollection().updateOne(
+    { _id: id, clientId },
+    { $set: fields },
+  );
+  return result.matchedCount > 0;
+};
+
+const findNoteEntryById = (
+  doc: WithId<ContextNote> | null,
+  noteId: ObjectId,
+): ContextNoteEntry | null =>
+  doc?.notes.find((note) => note._id.equals(noteId)) ?? null;
+
+/** Appends one note. 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: note } },
+    { 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,
+  clientId: string,
+  noteId: ObjectId,
+): Promise<boolean> => {
+  const result = await getContextNotesCollection().updateOne(
+    { _id: id, clientId },
+    { $pull: { notes: { _id: noteId } as any } },
+  );
+  return result.modifiedCount > 0;
+};

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

@@ -1,20 +1,27 @@
-import { ObjectId } from "mongodb";
-
-export type ContextNoteEntry = {
-  _id: ObjectId;
-  title: string;
-  content: string;
-  activeFrom: Date;
-  expiresAt: Date | null;
-  createdAt: Date;
-  updatedAt: Date;
-};
-
-export type ContextNote = {
-  _id: ObjectId;
-  clientId: string;
-  product: string;
-  notes: ContextNoteEntry[];
-  /** instructions for how the LLM should treat context info */
-  systemPrompt?: string;
-};
+import { ObjectId } from "mongodb";
+
+export type ContextNoteEntry = {
+  _id: ObjectId;
+  title: string;
+  content: string;
+  activeFrom: Date;
+  expiresAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type ContextNoteEntryWrite = {
+  title: string;
+  content: string;
+  activeFrom: Date;
+  expiresAt: Date | null;
+};
+
+export type ContextNote = {
+  _id: ObjectId;
+  clientId: string;
+  product: string;
+  notes: ContextNoteEntry[];
+  /** instructions for how the LLM should treat context info */
+  systemPrompt?: string;
+};

package/src/talkpilot/contextNotes/index.ts

@@ -1,2 +1,2 @@
-export * from "./contextNotes.types";
-export * from "./contextNotes.getters";
+export * from "./contextNotes.types";
+export * from "./contextNotes.getters";

package/src/talkpilot/flows/__tests__/flows.schema.spec.ts

@@ -1,152 +1,152 @@
-import { Document } from "mongodb";
-import { getDb } from "../../index";
-import { flowMongoSchema } from "../flows.schema";
-
-describe("flowMongoSchema", () => {
-  it("defines disableGenericPrompt as optional bool", () => {
-    const schema: any = flowMongoSchema;
-
-    expect(schema.properties).toHaveProperty("disableGenericPrompt");
-    expect(schema.properties.disableGenericPrompt.bsonType).toBe("bool");
-    expect(schema.required).not.toContain("disableGenericPrompt");
-  });
-
-  it("allows legacy flows without disableGenericPrompt", async () => {
-    const collection = await getDb().createCollection("legacy_flows", {
-      validator: { $jsonSchema: flowMongoSchema as Document },
-    });
-
-    await expect(
-      collection.insertOne({
-        flowName: "Legacy Flow",
-        systemInstructions: "Use the default instructions.",
-        initialSentence: "Hello",
-        interactions: [],
-      }),
-    ).resolves.toBeDefined();
-  });
-
-  it("defines conversationSettings as optional object or null", () => {
-    const schema: any = flowMongoSchema;
-
-    expect(schema.properties).toHaveProperty("conversationSettings");
-    expect(schema.properties.conversationSettings.bsonType).toEqual([
-      "object",
-      "null",
-    ]);
-    expect(schema.required).not.toContain("conversationSettings");
-    expect(schema.additionalProperties).toBe(false);
-  });
-
-  it("defines conversationSettings with expected nested properties", () => {
-    const schema: any = flowMongoSchema;
-    const convSettings = schema.properties.conversationSettings.properties;
-
-    expect(convSettings).toHaveProperty("interruptions");
-    expect(convSettings.interruptions.bsonType).toEqual(["object", "null"]);
-
-    const interruptions = convSettings.interruptions.properties;
-    expect(interruptions.enableInterruptionDetection.bsonType).toEqual("bool");
-    expect(interruptions.interruptionWindowSeconds.bsonType).toEqual("number");
-    expect(interruptions.interruptionThresholdSeconds.bsonType).toEqual(
-      "number",
-    );
-    expect(interruptions.interruptionInstruction.bsonType).toEqual("string");
-
-    expect(convSettings).toHaveProperty("silence");
-    expect(convSettings.silence.bsonType).toEqual(["object", "null"]);
-
-    const silence = convSettings.silence.properties;
-    expect(silence.enableSilenceDetection.bsonType).toEqual("bool");
-    expect(silence.firstWarningSilenceSeconds.bsonType).toEqual("number");
-    expect(silence.firstWarningInstruction.bsonType).toEqual("string");
-    expect(silence.secondWarningSilenceSeconds.bsonType).toEqual("number");
-    expect(silence.secondWarningInstruction.bsonType).toEqual("string");
-    expect(silence.disconnectSilenceSeconds.bsonType).toEqual("number");
-    expect(convSettings).toHaveProperty("liveTimeUpdates");
-    expect(convSettings.liveTimeUpdates.bsonType).toEqual("bool");
-  });
-
-  it("should define tools schema and return a backgroundToolType enum with allowed values", () => {
-    const schema: any = flowMongoSchema;
-
-    expect(schema.properties).toHaveProperty("tools");
-    expect(schema.properties.tools.bsonType).toEqual(["array", "null"]);
-
-    const toolItem = schema.properties.tools.items;
-    expect(toolItem.bsonType).toBe("object");
-
-    expect(toolItem.properties).toHaveProperty("runInBackground");
-    expect(toolItem.properties.runInBackground.bsonType).toBe("bool");
-
-    expect(toolItem.properties).toHaveProperty("useRedisTranscription");
-    expect(toolItem.properties.useRedisTranscription.bsonType).toBe("bool");
-
-    expect(toolItem.properties).toHaveProperty("backgroundToolType");
-    expect(toolItem.properties.backgroundToolType.bsonType).toBe("string");
-    expect(toolItem.properties.backgroundToolType.enum).toEqual([
-      "backgroundToolAlways",
-      "backgroundToolOnce",
-    ]);
-
-    expect(toolItem.properties).toHaveProperty(
-      "backgroundContinuationInstructions",
-    );
-    expect(
-      toolItem.properties.backgroundContinuationInstructions.bsonType,
-    ).toBe("string");
-  });
-
-  it("defines internalTools as an optional map of tool configs", () => {
-    const schema: any = flowMongoSchema;
-
-    expect(schema.properties).toHaveProperty("internalTools");
-    expect(schema.required).not.toContain("internalTools");
-    expect(schema.properties.internalTools.bsonType).toEqual([
-      "object",
-      "null",
-    ]);
-
-    const toolConfig = schema.properties.internalTools.additionalProperties;
-    expect(toolConfig.required).toEqual(["enabled"]);
-    expect(toolConfig.properties.enabled.bsonType).toBe("bool");
-    expect(toolConfig.properties.maxCalls.bsonType).toEqual(["number", "null"]);
-
-    const param = toolConfig.properties.params.additionalProperties;
-    expect(param.properties.value.bsonType).toEqual([
-      "string",
-      "number",
-      "bool",
-      "array",
-      "null",
-    ]);
-  });
-
-  it("defines beforeCallEvent as an optional object with url, and afterCallEvent as optional string or null", () => {
-    const schema: any = flowMongoSchema;
-
-    expect(schema.properties).toHaveProperty("beforeCallEvent");
-    expect(schema.properties.beforeCallEvent.bsonType).toEqual(["object", "null"]);
-    expect(schema.properties.beforeCallEvent.required).toEqual(["url"]);
-    expect(schema.properties.beforeCallEvent.properties).toEqual(
-      expect.objectContaining({
-        url: { bsonType: "string" },
-        timeoutMs: { bsonType: ["number", "null"] },
-        sendUserAuthToken: { bsonType: ["bool", "null"] },
-        wait: { bsonType: ["bool", "null"] },
-      })
-    );
-    expect(schema.properties.beforeCallEvent.properties.allowedKeys).toEqual({
-      bsonType: ["array", "null"],
-      items: { bsonType: "string" },
-    });
-    expect(schema.required).not.toContain("beforeCallEvent");
-
-    expect(schema.properties).toHaveProperty("afterCallEvent");
-    expect(schema.properties.afterCallEvent.bsonType).toEqual([
-      "string",
-      "null",
-    ]);
-    expect(schema.required).not.toContain("afterCallEvent");
-  });
-});
+import { Document } from "mongodb";
+import { getDb } from "../../index";
+import { flowMongoSchema } from "../flows.schema";
+
+describe("flowMongoSchema", () => {
+  it("defines disableGenericPrompt as optional bool", () => {
+    const schema: any = flowMongoSchema;
+
+    expect(schema.properties).toHaveProperty("disableGenericPrompt");
+    expect(schema.properties.disableGenericPrompt.bsonType).toBe("bool");
+    expect(schema.required).not.toContain("disableGenericPrompt");
+  });
+
+  it("allows legacy flows without disableGenericPrompt", async () => {
+    const collection = await getDb().createCollection("legacy_flows", {
+      validator: { $jsonSchema: flowMongoSchema as Document },
+    });
+
+    await expect(
+      collection.insertOne({
+        flowName: "Legacy Flow",
+        systemInstructions: "Use the default instructions.",
+        initialSentence: "Hello",
+        interactions: [],
+      }),
+    ).resolves.toBeDefined();
+  });
+
+  it("defines conversationSettings as optional object or null", () => {
+    const schema: any = flowMongoSchema;
+
+    expect(schema.properties).toHaveProperty("conversationSettings");
+    expect(schema.properties.conversationSettings.bsonType).toEqual([
+      "object",
+      "null",
+    ]);
+    expect(schema.required).not.toContain("conversationSettings");
+    expect(schema.additionalProperties).toBe(false);
+  });
+
+  it("defines conversationSettings with expected nested properties", () => {
+    const schema: any = flowMongoSchema;
+    const convSettings = schema.properties.conversationSettings.properties;
+
+    expect(convSettings).toHaveProperty("interruptions");
+    expect(convSettings.interruptions.bsonType).toEqual(["object", "null"]);
+
+    const interruptions = convSettings.interruptions.properties;
+    expect(interruptions.enableInterruptionDetection.bsonType).toEqual("bool");
+    expect(interruptions.interruptionWindowSeconds.bsonType).toEqual("number");
+    expect(interruptions.interruptionThresholdSeconds.bsonType).toEqual(
+      "number",
+    );
+    expect(interruptions.interruptionInstruction.bsonType).toEqual("string");
+
+    expect(convSettings).toHaveProperty("silence");
+    expect(convSettings.silence.bsonType).toEqual(["object", "null"]);
+
+    const silence = convSettings.silence.properties;
+    expect(silence.enableSilenceDetection.bsonType).toEqual("bool");
+    expect(silence.firstWarningSilenceSeconds.bsonType).toEqual("number");
+    expect(silence.firstWarningInstruction.bsonType).toEqual("string");
+    expect(silence.secondWarningSilenceSeconds.bsonType).toEqual("number");
+    expect(silence.secondWarningInstruction.bsonType).toEqual("string");
+    expect(silence.disconnectSilenceSeconds.bsonType).toEqual("number");
+    expect(convSettings).toHaveProperty("liveTimeUpdates");
+    expect(convSettings.liveTimeUpdates.bsonType).toEqual("bool");
+  });
+
+  it("should define tools schema and return a backgroundToolType enum with allowed values", () => {
+    const schema: any = flowMongoSchema;
+
+    expect(schema.properties).toHaveProperty("tools");
+    expect(schema.properties.tools.bsonType).toEqual(["array", "null"]);
+
+    const toolItem = schema.properties.tools.items;
+    expect(toolItem.bsonType).toBe("object");
+
+    expect(toolItem.properties).toHaveProperty("runInBackground");
+    expect(toolItem.properties.runInBackground.bsonType).toBe("bool");
+
+    expect(toolItem.properties).toHaveProperty("useRedisTranscription");
+    expect(toolItem.properties.useRedisTranscription.bsonType).toBe("bool");
+
+    expect(toolItem.properties).toHaveProperty("backgroundToolType");
+    expect(toolItem.properties.backgroundToolType.bsonType).toBe("string");
+    expect(toolItem.properties.backgroundToolType.enum).toEqual([
+      "backgroundToolAlways",
+      "backgroundToolOnce",
+    ]);
+
+    expect(toolItem.properties).toHaveProperty(
+      "backgroundContinuationInstructions",
+    );
+    expect(
+      toolItem.properties.backgroundContinuationInstructions.bsonType,
+    ).toBe("string");
+  });
+
+  it("defines internalTools as an optional map of tool configs", () => {
+    const schema: any = flowMongoSchema;
+
+    expect(schema.properties).toHaveProperty("internalTools");
+    expect(schema.required).not.toContain("internalTools");
+    expect(schema.properties.internalTools.bsonType).toEqual([
+      "object",
+      "null",
+    ]);
+
+    const toolConfig = schema.properties.internalTools.additionalProperties;
+    expect(toolConfig.required).toEqual(["enabled"]);
+    expect(toolConfig.properties.enabled.bsonType).toBe("bool");
+    expect(toolConfig.properties.maxCalls.bsonType).toEqual(["number", "null"]);
+
+    const param = toolConfig.properties.params.additionalProperties;
+    expect(param.properties.value.bsonType).toEqual([
+      "string",
+      "number",
+      "bool",
+      "array",
+      "null",
+    ]);
+  });
+
+  it("defines beforeCallEvent as an optional object with url, and afterCallEvent as optional string or null", () => {
+    const schema: any = flowMongoSchema;
+
+    expect(schema.properties).toHaveProperty("beforeCallEvent");
+    expect(schema.properties.beforeCallEvent.bsonType).toEqual(["object", "null"]);
+    expect(schema.properties.beforeCallEvent.required).toEqual(["url"]);
+    expect(schema.properties.beforeCallEvent.properties).toEqual(
+      expect.objectContaining({
+        url: { bsonType: "string" },
+        timeoutMs: { bsonType: ["number", "null"] },
+        sendUserAuthToken: { bsonType: ["bool", "null"] },
+        wait: { bsonType: ["bool", "null"] },
+      })
+    );
+    expect(schema.properties.beforeCallEvent.properties.allowedKeys).toEqual({
+      bsonType: ["array", "null"],
+      items: { bsonType: "string" },
+    });
+    expect(schema.required).not.toContain("beforeCallEvent");
+
+    expect(schema.properties).toHaveProperty("afterCallEvent");
+    expect(schema.properties.afterCallEvent.bsonType).toEqual([
+      "string",
+      "null",
+    ]);
+    expect(schema.required).not.toContain("afterCallEvent");
+  });
+});