@talkpilot/core-db 1.3.15 → 1.3.17

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

@@ -21,7 +21,7 @@ export type DashboardSummaryMetrics = {
   avgDurationSeconds: number;
   timeSavedMinutes: number;
   completedCount: number;
-  busyCount: number;
+  inCallCount: number;
 };
 
 export type DashboardVisualData = {
@@ -42,7 +42,7 @@ export type DashboardReportResponse = {
 };
 type RawKpiResult = {
   completedCount: number;
-  busyCount: number;
+  inCallCount: number;
   answeredDuration: number | null;
 };
 

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

@@ -1,9 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
 import {
   getClientsConfigCollection,
-  getActiveScanId,
-  updateActiveScanId,
-  clearActiveScanId,
   updateProductConfig,
 } from "../clientsConfig.getters";
 
@@ -26,6 +23,8 @@ describe("updateProductConfig", () => {
         websiteTalk: {
           language: "English",
           companyName: "OldCorp",
+          defaultBaseUrl: "https://old-url.com",
+          logoUrl: "",
           timezone: "UTC",
         },
       },
@@ -39,7 +38,9 @@ describe("updateProductConfig", () => {
     expect(updatedDoc).toBeDefined();
     expect(updatedDoc?.products.websiteTalk?.language).toBe("Hebrew");
     expect(updatedDoc?.products.websiteTalk?.companyName).toBe("TestCorp");
-    expect(updatedDoc?.products.websiteTalk?.timezone).toBe("UTC");
+    expect(updatedDoc?.products.websiteTalk?.defaultBaseUrl).toBe(
+      "https://old-url.com",
+    );
   });
 
   it("should throw an error if no client config is found", async () => {
@@ -50,56 +51,3 @@ 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,9 +31,11 @@ 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",
           },
         },
       });
@@ -46,9 +48,11 @@ 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,27 +53,3 @@ 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,10 +58,11 @@ export type WebsiteTalkScheduler = {
 
 /** Product config for the websiteTalk */
 export type WebsiteTalkProduct = {
+  logoUrl: string;
   companyName: string;
   timezone: string;
   language: string;
-  activeScanId?: string;
+  defaultBaseUrl: string;
 };
 
 // ---------------------------------------------------------------------------

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

@@ -13,4 +13,3 @@ 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,11 +1,10 @@
 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(),
-  websiteUrlId: new ObjectId().toString(),
+  baseUrl: faker.internet.url(),
   status: "CHECKING",
   activeTasksCount: 0,
   pagesScanned: 0,

package/src/websitalk/index.ts

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

package/src/websitalk/scans/index.ts

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

package/src/websitalk/scans/scans.getters.ts

@@ -4,12 +4,12 @@ import {
   applyQueryOptions,
   QueryOptions,
 } from "../../talkpilot/utils/query.utils";
-import type { Scan, ScanDoc } from "./scans.types";
-import {
-  FINISHED_SCAN_STATUSES,
-  INITIAL_SCAN_STATUS,
-  isInProgressScan,
-} from "./scans.constants";
+import type {
+  ActiveScanStatus,
+  Scan,
+  ScanDoc,
+  ScanStatus,
+} from "./scans.types";
 
 export const getScansCollection = (): Collection<Scan> => {
   return getDb().collection<Scan>("scans");
@@ -57,12 +57,11 @@ export const getScanFieldsByClientAndDateRange = <K extends keyof Scan>(
 };
 
 export const createScanDoc = (
-  scan: Pick<Scan, "clientId" | "websiteUrlId"> &
-    Partial<Pick<Scan, "notifyPhoneNumber">>,
+  scan: Pick<Scan, "clientId" | "baseUrl" | "notifyPhoneNumber">,
 ) => {
   return getScansCollection().insertOne({
     ...scan,
-    status: INITIAL_SCAN_STATUS,
+    status: "CHECKING",
     activeTasksCount: 0,
     pagesScanned: 0,
     pagesSkipped: 0,
@@ -73,48 +72,21 @@ export const createScanDoc = (
   });
 };
 
-export const getScanById = async (id: string): Promise<ScanDoc | null> => {
-  return getScansCollection().findOne({ _id: new ObjectId(id) });
-};
-
-export const getScansByWebsiteUrl = async (
-  websiteUrlId: string,
-): Promise<ScanDoc[]> => {
-  return getScansCollection()
-    .find({ websiteUrlId })
-    .sort({ createdAt: -1 })
-    .toArray();
-};
+const FINISHED_SCAN_STATUSES: ScanStatus[] = ["COMPLETED", "FAILED"];
 
-export const getLatestScanByWebsiteUrl = async (
-  websiteUrlId: string,
-): Promise<ScanDoc | null> => {
-  return getScansCollection().findOne(
-    { websiteUrlId },
+export const getActiveScanStatus = async (
+  clientId: string,
+): Promise<ActiveScanStatus> => {
+  const latestScan = await getScansCollection().findOne(
+    { clientId },
     { sort: { createdAt: -1 } },
   );
-};
 
-export const getInProgressScanByWebsiteUrl = async (
-  websiteUrlId: string,
-): Promise<ScanDoc | null> => {
-  const latestScan = await getLatestScanByWebsiteUrl(websiteUrlId);
-  if (!latestScan || !isInProgressScan(latestScan)) {
-    return null;
+  if (!latestScan || FINISHED_SCAN_STATUSES.includes(latestScan.status)) {
+    return { isActive: false };
   }
-  return latestScan;
-};
 
-export const findInProgressScansByClient = async (
-  clientId: string,
-): Promise<ScanDoc[]> => {
-  return getScansCollection()
-    .find({
-      clientId,
-      status: { $nin: FINISHED_SCAN_STATUSES },
-    })
-    .sort({ createdAt: -1 })
-    .toArray();
+  return { isActive: true, status: latestScan.status };
 };
 
 export const updateScanDoc = async (
@@ -139,25 +111,3 @@ export const findScansByQuery = async (
 export const countScans = async (query: Filter<Scan>): Promise<number> => {
   return getScansCollection().countDocuments(query);
 };
-
-export const hasScansForWebsiteUrl = async (
-  websiteUrlId: string,
-): Promise<boolean> => {
-  return (await countScans({ websiteUrlId })) > 0;
-};
-
-export const getLatestCompletedScanByWebsiteUrl = async (
-  websiteUrlId: string,
-): Promise<ScanDoc | null> => {
-  return getScansCollection().findOne(
-    { websiteUrlId, status: "COMPLETED" },
-    { sort: { createdAt: -1 } },
-  );
-};
-
-export const deleteScansByWebsiteUrl = async (
-  websiteUrlId: string,
-): Promise<number> => {
-  const result = await getScansCollection().deleteMany({ websiteUrlId });
-  return result.deletedCount;
-};

package/src/websitalk/scans/scans.types.ts

@@ -6,8 +6,11 @@ export type ScanStatus =
   | "SCANNING"
   | "PROCESSING"
   | "COMPLETED"
-  | "FAILED"
-  | "OVERWRITTEN";
+  | "FAILED";
+
+export type ActiveScanStatus =
+  | { isActive: true; status: ScanStatus }
+  | { isActive: false };
 
 export type SiteChromeEntry = {
   url: string;
@@ -35,7 +38,7 @@ export type SkippedEntry = {
 
 export type Scan = {
   clientId: string;
-  websiteUrlId: string;
+  baseUrl: string;
   notifyPhoneNumber?: string | null;
   status: ScanStatus;
   activeTasksCount: number;

package/tsconfig.json

@@ -1,9 +1,8 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "node16",
-    "isolatedModules": true,
+    "module": "CommonJS",
+    "moduleResolution": "node",
     "lib": ["ES2022"],
     "declaration": true,
     "declarationMap": true,
@@ -16,7 +15,8 @@
     "skipLibCheck": true,
     "resolveJsonModule": true,
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "emitDecoratorMetadata": true,
+    "baseUrl": "."
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "test", "**/*.test.ts", "**/__tests__/*", "**/*.spec.ts"]

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

@@ -1,17 +0,0 @@
-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/scans/scans.constants.ts

@@ -1,12 +0,0 @@
-import type { Scan, ScanStatus } from "./scans.types";
-
-export const INITIAL_SCAN_STATUS = "CHECKING" as const satisfies ScanStatus;
-
-export const FINISHED_SCAN_STATUSES: ScanStatus[] = [
-  "COMPLETED",
-  "FAILED",
-  "OVERWRITTEN",
-];
-
-export const isInProgressScan = (scan: Scan): boolean =>
-  !FINISHED_SCAN_STATUSES.includes(scan.status);