@talkpilot/core-db 1.3.14 → 1.3.16

package/dist/websitalk/websiteUrls/websiteUrls.setters.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteWebsiteUrl = exports.updateWebsiteUrl = exports.createWebsiteUrl = void 0;
+const index_1 = require("../index");
+const websiteUrls_getters_1 = require("./websiteUrls.getters");
+const createWebsiteUrl = async (input) => {
+    const now = new Date();
+    const { insertedId } = await (0, websiteUrls_getters_1.getWebsiteUrlsCollection)().insertOne({
+        clientId: input.clientId,
+        name: input.name,
+        baseUrl: input.baseUrl,
+        createdAt: now,
+        updatedAt: now,
+    });
+    return insertedId;
+};
+exports.createWebsiteUrl = createWebsiteUrl;
+const updateWebsiteUrl = async (id, updates) => {
+    return (0, websiteUrls_getters_1.getWebsiteUrlsCollection)().findOneAndUpdate({ _id: new index_1.ObjectId(id) }, { $set: { ...updates, updatedAt: new Date() } }, { returnDocument: "after" });
+};
+exports.updateWebsiteUrl = updateWebsiteUrl;
+const deleteWebsiteUrl = async (id) => {
+    const result = await (0, websiteUrls_getters_1.getWebsiteUrlsCollection)().deleteOne({
+        _id: new index_1.ObjectId(id),
+    });
+    return result.deletedCount > 0;
+};
+exports.deleteWebsiteUrl = deleteWebsiteUrl;
+//# sourceMappingURL=websiteUrls.setters.js.map

package/dist/websitalk/websiteUrls/websiteUrls.setters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websiteUrls.setters.js","sourceRoot":"","sources":["../../../src/websitalk/websiteUrls/websiteUrls.setters.ts"],"names":[],"mappings":";;;AACA,oCAAoC;AACpC,+DAAoF;AAQ7E,MAAM,gBAAgB,GAAG,KAAK,EACnC,KAA4B,EACJ,EAAE;IAC1B,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IACvB,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,IAAA,8CAAwB,GAAE,CAAC,SAAS,CAAC;QAChE,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,SAAS,EAAE,GAAG;QACd,SAAS,EAAE,GAAG;KACf,CAAC,CAAC;IAEH,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAbW,QAAA,gBAAgB,oBAa3B;AAEK,MAAM,gBAAgB,GAAG,KAAK,EACnC,EAAU,EACV,OAAsD,EACvB,EAAE;IACjC,OAAO,IAAA,8CAAwB,GAAE,CAAC,gBAAgB,CAChD,EAAE,GAAG,EAAE,IAAI,gBAAQ,CAAC,EAAE,CAAC,EAAE,EACzB,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAC/C,EAAE,cAAc,EAAE,OAAO,EAAE,CAC5B,CAAC;AACJ,CAAC,CAAC;AATW,QAAA,gBAAgB,oBAS3B;AAEK,MAAM,gBAAgB,GAAG,KAAK,EAAE,EAAU,EAAoB,EAAE;IACrE,MAAM,MAAM,GAAG,MAAM,IAAA,8CAAwB,GAAE,CAAC,SAAS,CAAC;QACxD,GAAG,EAAE,IAAI,gBAAQ,CAAC,EAAE,CAAC;KACtB,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC,YAAY,GAAG,CAAC,CAAC;AACjC,CAAC,CAAC;AANW,QAAA,gBAAgB,oBAM3B"}

package/dist/websitalk/websiteUrls/websiteUrls.types.d.ts

@@ -0,0 +1,13 @@
+import { ObjectId } from "mongodb";
+export type WebsiteUrl = {
+    clientId: string;
+    name: string;
+    baseUrl: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type WebsiteUrlDoc = WebsiteUrl & {
+    _id: ObjectId;
+};
+export type CreateWebsiteUrlInput = Omit<WebsiteUrl, "createdAt" | "updatedAt">;
+//# sourceMappingURL=websiteUrls.types.d.ts.map

package/dist/websitalk/websiteUrls/websiteUrls.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websiteUrls.types.d.ts","sourceRoot":"","sources":["../../../src/websitalk/websiteUrls/websiteUrls.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG;IAAE,GAAG,EAAE,QAAQ,CAAA;CAAE,CAAC;AAE3D,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC,CAAC"}

package/dist/websitalk/websiteUrls/websiteUrls.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=websiteUrls.types.js.map

package/dist/websitalk/websiteUrls/websiteUrls.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websiteUrls.types.js","sourceRoot":"","sources":["../../../src/websitalk/websiteUrls/websiteUrls.types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talkpilot/core-db",
-  "version": "1.3.14",
+  "version": "1.3.16",
   "description": "Core database package for centralized connections and ORM integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -24,3 +24,4 @@ export {
 } from "./websitalk";
 export * from "./websitalk/scans/scans.getters";
 export type * from "./websitalk/scans/scans.types";
+export * from "./websitalk/websiteUrls";

package/src/municipal/index.ts

@@ -7,7 +7,7 @@ export * from "./tickets";
 export * from "./systemInstructions";
 export * from "./muniIssues";
 export * from "./utils/types";
-export { CityName } from "./utils/types";
+export type { CityName } from "./utils/types";
 export { municipalDataMongodbClient } from "./mongodb-client";
 
 let db: Db;

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

@@ -1,6 +1,9 @@
 import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
 import {
   getClientsConfigCollection,
+  getActiveScanId,
+  updateActiveScanId,
+  clearActiveScanId,
   updateProductConfig,
 } from "../clientsConfig.getters";
 
@@ -23,8 +26,6 @@ describe("updateProductConfig", () => {
         websiteTalk: {
           language: "English",
           companyName: "OldCorp",
-          defaultBaseUrl: "https://old-url.com",
-          logoUrl: "",
           timezone: "UTC",
         },
       },
@@ -38,9 +39,7 @@ describe("updateProductConfig", () => {
     expect(updatedDoc).toBeDefined();
     expect(updatedDoc?.products.websiteTalk?.language).toBe("Hebrew");
     expect(updatedDoc?.products.websiteTalk?.companyName).toBe("TestCorp");
-    expect(updatedDoc?.products.websiteTalk?.defaultBaseUrl).toBe(
-      "https://old-url.com",
-    );
+    expect(updatedDoc?.products.websiteTalk?.timezone).toBe("UTC");
   });
 
   it("should throw an error if no client config is found", async () => {
@@ -51,3 +50,56 @@ describe("updateProductConfig", () => {
     ).rejects.toThrow("No client config found for clientId: invalid-client");
   });
 });
+
+describe("activeScanId", () => {
+  beforeEach(async () => {
+    await getClientsConfigCollection().deleteMany({});
+  });
+
+  afterEach(async () => {
+    await getClientsConfigCollection().deleteMany({});
+  });
+
+  it("should return undefined when activeScanId is not set", async () => {
+    const clientId = "client-active";
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      products: {
+        websiteTalk: { companyName: "X", timezone: "UTC", language: "he" },
+      },
+    } as any);
+
+    expect(await getActiveScanId(clientId)).toBeUndefined();
+  });
+
+  it("should persist activeScanId and return it from getActiveScanId", async () => {
+    const clientId = "client-active-2";
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      products: {
+        websiteTalk: { companyName: "X", timezone: "UTC", language: "he" },
+      },
+    } as any);
+
+    await updateActiveScanId(clientId, "scan-abc");
+    expect(await getActiveScanId(clientId)).toBe("scan-abc");
+  });
+
+  it("should clear activeScanId and return undefined from getActiveScanId", async () => {
+    const clientId = "client-active-3";
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      products: {
+        websiteTalk: {
+          companyName: "X",
+          timezone: "UTC",
+          language: "he",
+          activeScanId: "scan-old",
+        },
+      },
+    } as any);
+
+    await clearActiveScanId(clientId);
+    expect(await getActiveScanId(clientId)).toBeUndefined();
+  });
+});

package/src/talkpilot/clientsConfig/__tests__/clientsConfig.spec.ts

@@ -31,11 +31,9 @@ describe("db.clientsConfig", () => {
         clientId,
         products: {
           websiteTalk: {
-            logoUrl: "https://cdn.example.com/branding/acme/logo.png",
             companyName: "Acme Ltd",
             timezone: "Asia/Jerusalem",
             language: "he",
-            defaultBaseUrl: "https://acme.example",
           },
         },
       });
@@ -48,11 +46,9 @@ describe("db.clientsConfig", () => {
         clientId,
         products: {
           websiteTalk: {
-            logoUrl: "https://cdn.example.com/branding/acme/logo.png",
             companyName: "Acme Ltd",
             timezone: "Asia/Jerusalem",
             language: "he",
-            defaultBaseUrl: "https://acme.example",
           },
         },
       });

package/src/talkpilot/clientsConfig/clientsConfig.getters.ts

@@ -53,3 +53,27 @@ export async function updateProductConfig<K extends KnownProductKey>(
     throw new Error(`No client config found for clientId: ${clientId}`);
   }
 }
+
+export const getActiveScanId = async (
+  clientId: string,
+): Promise<string | undefined> => {
+  const cfg = await getClientConfig(clientId);
+  return cfg?.products?.websiteTalk?.activeScanId;
+};
+
+export const updateActiveScanId = async (
+  clientId: string,
+  scanId: string,
+): Promise<void> => {
+  await updateProductConfig(clientId, "websiteTalk", { activeScanId: scanId });
+};
+
+export const clearActiveScanId = async (clientId: string): Promise<void> => {
+  const result = await getClientsConfigCollection().updateOne(
+    { clientId },
+    { $unset: { "products.websiteTalk.activeScanId": "" } },
+  );
+  if (result.matchedCount === 0) {
+    throw new Error(`No client config found for clientId: ${clientId}`);
+  }
+};

package/src/talkpilot/clientsConfig/clientsConfig.types.ts

@@ -58,11 +58,10 @@ export type WebsiteTalkScheduler = {
 
 /** Product config for the websiteTalk */
 export type WebsiteTalkProduct = {
-  logoUrl: string;
   companyName: string;
   timezone: string;
   language: string;
-  defaultBaseUrl: string;
+  activeScanId?: string;
 };
 
 // ---------------------------------------------------------------------------

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

@@ -79,9 +79,6 @@ describe("flowMongoSchema", () => {
     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([

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

@@ -138,7 +138,6 @@ export const flowMongoSchema = {
           parameters: { bsonType: "object" },
           bodyFormat: { bsonType: "string", enum: ["json", "form-data"] },
           preventAudioDuringTool: { bsonType: "bool" },
-          useRedisTranscription: { bsonType: "bool" },
           sendUserAuthToken: { bsonType: "bool" },
           runInBackground: { bsonType: "bool" },
           backgroundToolType: {

package/src/talkpilot/flows/flows.types.ts

@@ -71,8 +71,6 @@ export type FlowTool = {
   parameters: Record<string, unknown>;
   bodyFormat?: "json" | "form-data";
   preventAudioDuringTool?: boolean;
-  /** When true, prefer cached transcription from Redis (default: false). */
-  useRedisTranscription?: boolean;
   sendUserAuthToken?: boolean;
   runInBackground?: boolean;
   backgroundToolType?: "backgroundToolAlways" | "backgroundToolOnce";

package/src/test-utils/factories/index.ts

@@ -13,3 +13,4 @@ export * from "./municipal/muniIssues";
 export * from "./municipal/streets";
 export * from "./municipal/tickets";
 export * from "./websitalk/scans";
+export * from "./websitalk/websiteUrls";

package/src/test-utils/factories/websitalk/scans.ts

@@ -1,10 +1,11 @@
 import { Factory } from "fishery";
 import { faker } from "@faker-js/faker";
+import { ObjectId } from "mongodb";
 import type { Scan } from "../../../websitalk";
 
 export const scanFactory = Factory.define<Scan>(() => ({
   clientId: faker.string.uuid(),
-  baseUrl: faker.internet.url(),
+  websiteUrlId: new ObjectId().toString(),
   status: "CHECKING",
   activeTasksCount: 0,
   pagesScanned: 0,

package/src/test-utils/factories/websitalk/websiteUrls.ts

@@ -0,0 +1,17 @@
+import { Factory } from "fishery";
+import { faker } from "@faker-js/faker";
+import type { WebsiteUrl } from "../../../websitalk/websiteUrls";
+
+export const websiteUrlFactory = Factory.define<WebsiteUrl>(() => ({
+  clientId: faker.string.uuid(),
+  name: faker.company.name(),
+  baseUrl: faker.internet.url(),
+  createdAt: new Date(),
+  updatedAt: new Date(),
+}));
+
+export function createWebsiteUrlFixture(
+  overrides?: Partial<WebsiteUrl>,
+): WebsiteUrl {
+  return websiteUrlFactory.build(overrides);
+}

package/src/websitalk/index.ts

@@ -1,6 +1,7 @@
 import { Db, ObjectId as MongoObjectId } from "mongodb";
 
 export * from "./scans";
+export * from "./websiteUrls";
 export { websitalkMongodbClient } from "./mongodb-client";
 
 let db: Db;

package/src/websitalk/scans/__tests__/scans.spec.ts

@@ -6,7 +6,12 @@ import {
   countScans,
   createScanDoc,
   updateScanDoc,
-  getActiveScanStatus,
+  findInProgressScansByClient,
+  getScansByWebsiteUrl,
+  getLatestScanByWebsiteUrl,
+  getInProgressScanByWebsiteUrl,
+  getLatestCompletedScanByWebsiteUrl,
+  deleteScansByWebsiteUrl,
 } from "../scans.getters";
 import { createScanFixture } from "../../../test-utils/factories";
 import { ObjectId } from "mongodb";
@@ -37,7 +42,7 @@ describe("db.websitalk.scans", () => {
       expect(result.length).toBe(1);
       expect(result[0]).toMatchObject({
         clientId,
-        baseUrl: scanInside.baseUrl,
+        websiteUrlId: scanInside.websiteUrlId,
         status: "COMPLETED",
       });
       expect(result[0]).toHaveProperty("siteChrome");
@@ -83,12 +88,12 @@ describe("db.websitalk.scans", () => {
         clientId,
         new Date("2023-05-01"),
         new Date("2023-05-31"),
-        ["clientId", "baseUrl", "status"],
+        ["clientId", "websiteUrlId", "status"],
       );
 
       expect(result).toMatchObject({
         clientId,
-        baseUrl: scan.baseUrl,
+        websiteUrlId: scan.websiteUrlId,
         status: "COMPLETED",
       });
       expect(result).toHaveProperty("_id");
@@ -110,7 +115,7 @@ describe("db.websitalk.scans", () => {
       const count = await countScans({ clientId });
 
       expect(result.length).toBe(1);
-      expect(result[0].baseUrl).toBe(completed.baseUrl);
+      expect(result[0].websiteUrlId).toBe(completed.websiteUrlId);
       expect(count).toBe(2);
     });
   });
@@ -118,15 +123,15 @@ describe("db.websitalk.scans", () => {
   describe("createScanDoc()", () => {
     it("should insert a scan with default values for the rest of the fields", async () => {
       const clientId = "createClient";
-      const baseUrl = "https://example.com";
+      const websiteUrlId = new ObjectId().toString();
 
-      const { insertedId } = await createScanDoc({ clientId, baseUrl });
+      const { insertedId } = await createScanDoc({ clientId, websiteUrlId });
 
       const result = await getScansCollection().findOne({ _id: insertedId });
 
       expect(result).toMatchObject({
         clientId,
-        baseUrl,
+        websiteUrlId,
         status: "CHECKING",
         activeTasksCount: 0,
         pagesScanned: 0,
@@ -166,53 +171,143 @@ describe("db.websitalk.scans", () => {
     });
   });
 
-  describe("getActiveScanStatus()", () => {
-    it("should return isActive: true with the status when the latest scan is still in progress", async () => {
-      const clientId = "activeClient";
+  describe("in-progress scan helpers", () => {
+    const websiteUrlId = "website-123";
 
+    it("should return website scan history newest first", async () => {
       await getScansCollection().insertMany([
         createScanFixture({
-          clientId,
+          websiteUrlId,
           status: "COMPLETED",
           createdAt: new Date("2023-05-01"),
         }),
         createScanFixture({
-          clientId,
-          status: "SCANNING",
+          websiteUrlId,
+          status: "COMPLETED",
           createdAt: new Date("2023-05-15"),
         }),
       ]);
 
-      const result = await getActiveScanStatus(clientId);
+      const scans = await getScansByWebsiteUrl(websiteUrlId);
+      expect(scans).toHaveLength(2);
+      expect(scans[0].createdAt.getTime()).toBeGreaterThan(
+        scans[1].createdAt.getTime(),
+      );
+    });
+
+    it("should return the newest scan for a website", async () => {
+      await getScansCollection().insertMany([
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-01"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "FAILED",
+          createdAt: new Date("2023-05-15"),
+        }),
+      ]);
 
-      expect(result).toEqual({ isActive: true, status: "SCANNING" });
+      const latest = await getLatestScanByWebsiteUrl(websiteUrlId);
+      expect(latest?.status).toBe("FAILED");
     });
 
-    it("should return isActive: false when the latest scan finished (COMPLETED / FAILED)", async () => {
-      const clientId = "finishedClient";
+    it("should return in-progress scan and return null when only completed exists", async () => {
+      await getScansCollection().insertMany([
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-01"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "SCANNING",
+          createdAt: new Date("2023-05-15"),
+        }),
+      ]);
 
+      const inProgressScan = await getInProgressScanByWebsiteUrl(websiteUrlId);
+      expect(inProgressScan?.status).toBe("SCANNING");
+
+      await getScansCollection().deleteMany({ websiteUrlId });
+      await getScansCollection().insertOne(
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-20"),
+        }),
+      );
+
+      expect(await getInProgressScanByWebsiteUrl(websiteUrlId)).toBeNull();
+    });
+
+    it("should return all in-progress scans across websites for a client", async () => {
+      const clientId = "multiScanClient";
       await getScansCollection().insertMany([
         createScanFixture({
           clientId,
+          websiteUrlId: "website-a",
           status: "SCANNING",
-          createdAt: new Date("2023-05-01"),
         }),
         createScanFixture({
           clientId,
-          status: "FAILED",
-          createdAt: new Date("2023-05-15"),
+          websiteUrlId: "website-b",
+          status: "PROCESSING",
+        }),
+        createScanFixture({
+          clientId,
+          websiteUrlId: "website-c",
+          status: "COMPLETED",
         }),
       ]);
 
-      const result = await getActiveScanStatus(clientId);
+      const scans = await findInProgressScansByClient(clientId);
+      expect(scans).toHaveLength(2);
+      expect(scans.map((s) => s.websiteUrlId).sort()).toEqual([
+        "website-a",
+        "website-b",
+      ]);
+    });
+  });
 
-      expect(result).toEqual({ isActive: false });
+  describe("website delete helpers", () => {
+    it("should return the newest completed scan only", async () => {
+      const websiteUrlId = new ObjectId().toString();
+      await getScansCollection().insertMany([
+        createScanFixture({
+          websiteUrlId,
+          status: "FAILED",
+          createdAt: new Date("2023-05-25"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-20"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-22"),
+        }),
+      ]);
+
+      const latest = await getLatestCompletedScanByWebsiteUrl(websiteUrlId);
+      expect(latest?.status).toBe("COMPLETED");
+      expect(latest?.createdAt).toEqual(new Date("2023-05-22"));
     });
 
-    it("should return isActive: false when the client has no scans", async () => {
-      const result = await getActiveScanStatus("noScansClient");
+    it("should delete all scans for the website and return count", async () => {
+      const websiteUrlId = new ObjectId().toString();
+      await getScansCollection().insertMany([
+        createScanFixture({ websiteUrlId }),
+        createScanFixture({ websiteUrlId }),
+        createScanFixture({ websiteUrlId: new ObjectId().toString() }),
+      ]);
 
-      expect(result).toEqual({ isActive: false });
+      const deleted = await deleteScansByWebsiteUrl(websiteUrlId);
+      expect(deleted).toBe(2);
+      expect(await countScans({ websiteUrlId })).toBe(0);
     });
   });
 });

package/src/websitalk/scans/index.ts

@@ -1,2 +1,4 @@
+export * from "./scans.constants";
 export * from "./scans.getters";
 export * from "./scans.types";
+export * from "./scans.utils";

package/src/websitalk/scans/scans.constants.ts

@@ -0,0 +1,15 @@
+export const SCAN_STATUSES = {
+  CHECKING: "CHECKING",
+  PREPARING: "PREPARING",
+  SCANNING: "SCANNING",
+  PROCESSING: "PROCESSING",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  OVERWRITTEN: "OVERWRITTEN",
+} as const;
+
+export const FINISHED_SCAN_STATUSES = [
+  SCAN_STATUSES.COMPLETED,
+  SCAN_STATUSES.FAILED,
+  SCAN_STATUSES.OVERWRITTEN,
+] as const;