@talkpilot/core-db 1.3.17 → 1.3.18

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;

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

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

@@ -1,16 +1,8 @@
 import { WithId } from "mongodb";
 
-export type ScanStatus =
-  | "CHECKING"
-  | "PREPARING"
-  | "SCANNING"
-  | "PROCESSING"
-  | "COMPLETED"
-  | "FAILED";
+import type { SCAN_STATUSES } from "./scans.constants";
 
-export type ActiveScanStatus =
-  | { isActive: true; status: ScanStatus }
-  | { isActive: false };
+export type ScanStatus = (typeof SCAN_STATUSES)[keyof typeof SCAN_STATUSES];
 
 export type SiteChromeEntry = {
   url: string;
@@ -38,7 +30,7 @@ export type SkippedEntry = {
 
 export type Scan = {
   clientId: string;
-  baseUrl: string;
+  websiteUrlId: string;
   notifyPhoneNumber?: string | null;
   status: ScanStatus;
   activeTasksCount: number;

package/src/websitalk/scans/scans.utils.ts

@@ -0,0 +1,5 @@
+import type { Scan, ScanStatus } from "./scans.types";
+import { FINISHED_SCAN_STATUSES } from "./scans.constants";
+
+export const isInProgressScan = (scan: Scan): boolean =>
+  !(FINISHED_SCAN_STATUSES as readonly ScanStatus[]).includes(scan.status);

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

@@ -0,0 +1,77 @@
+import {
+  createWebsiteUrl,
+  getWebsiteUrlsByClient,
+  getWebsiteUrlById,
+  getWebsiteUrlsCollection,
+  updateWebsiteUrl,
+  deleteWebsiteUrl,
+} from "../websiteUrls.getters";
+import { createWebsiteUrlFixture } from "../../../test-utils/factories/websitalk/websiteUrls";
+
+describe("db.websitalk.websiteUrls", () => {
+  const clientId = "test-client";
+
+  describe("createWebsiteUrl", () => {
+    it("should create a website URL configuration", async () => {
+      const id = await createWebsiteUrl({
+        clientId,
+        name: "Primary",
+        baseUrl: "https://example.com",
+      });
+
+      const saved = await getWebsiteUrlById(id.toString());
+      expect(saved).toMatchObject({
+        clientId,
+        name: "Primary",
+        baseUrl: "https://example.com",
+      });
+      expect(saved?.createdAt).toBeInstanceOf(Date);
+      expect(saved?.updatedAt).toBeInstanceOf(Date);
+    });
+  });
+
+  describe("getWebsiteUrlsByClient", () => {
+    it("should return all configurations for a client", async () => {
+      await getWebsiteUrlsCollection().insertMany([
+        createWebsiteUrlFixture({ clientId, name: "A" }),
+        createWebsiteUrlFixture({ clientId, name: "B" }),
+        createWebsiteUrlFixture({ clientId: "other-client", name: "Other" }),
+      ]);
+
+      const results = await getWebsiteUrlsByClient(clientId);
+      expect(results).toHaveLength(2);
+      expect(results.map((doc) => doc.name)).toEqual(["A", "B"]);
+    });
+  });
+
+  describe("updateWebsiteUrl", () => {
+    it("should update name and baseUrl", async () => {
+      const id = await createWebsiteUrl({
+        clientId,
+        name: "Old",
+        baseUrl: "https://old.example",
+      });
+
+      const updated = await updateWebsiteUrl(id.toString(), {
+        name: "New",
+        baseUrl: "https://new.example",
+      });
+
+      expect(updated?.name).toBe("New");
+      expect(updated?.baseUrl).toBe("https://new.example");
+    });
+  });
+
+  describe("deleteWebsiteUrl", () => {
+    it("should delete the website and return true", async () => {
+      const id = await createWebsiteUrl({
+        clientId: "delete-client",
+        name: "Gone",
+        baseUrl: "https://gone.example",
+      });
+
+      expect(await deleteWebsiteUrl(id.toString())).toBe(true);
+      expect(await getWebsiteUrlById(id.toString())).toBeNull();
+    });
+  });
+});

package/src/websitalk/websiteUrls/index.ts

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

package/src/websitalk/websiteUrls/websiteUrls.getters.ts

@@ -0,0 +1,65 @@
+import { Collection, Filter, ObjectId as MongoObjectId } from "mongodb";
+import { getDb, ObjectId } from "../index";
+import type {
+  CreateWebsiteUrlInput,
+  WebsiteUrl,
+  WebsiteUrlDoc,
+} from "./websiteUrls.types";
+
+export const getWebsiteUrlsCollection = (): Collection<WebsiteUrl> => {
+  return getDb().collection<WebsiteUrl>("websiteUrls");
+};
+
+export const getWebsiteUrlsByClient = async (
+  clientId: string,
+): Promise<WebsiteUrlDoc[]> => {
+  return getWebsiteUrlsCollection()
+    .find({ clientId })
+    .sort({ createdAt: 1 })
+    .toArray();
+};
+
+export const getWebsiteUrlById = async (
+  id: string,
+): Promise<WebsiteUrlDoc | null> => {
+  return getWebsiteUrlsCollection().findOne({ _id: new ObjectId(id) });
+};
+
+export const findWebsiteUrls = async (
+  filter: Filter<WebsiteUrl> = {},
+): Promise<WebsiteUrlDoc[]> => {
+  return getWebsiteUrlsCollection().find(filter).toArray();
+};
+
+export const createWebsiteUrl = async (
+  input: CreateWebsiteUrlInput,
+): Promise<MongoObjectId> => {
+  const now = new Date();
+  const { insertedId } = await getWebsiteUrlsCollection().insertOne({
+    clientId: input.clientId,
+    name: input.name,
+    baseUrl: input.baseUrl,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  return insertedId;
+};
+
+export const updateWebsiteUrl = async (
+  id: string,
+  updates: Partial<Pick<WebsiteUrl, "name" | "baseUrl">>,
+): Promise<WebsiteUrlDoc | null> => {
+  return getWebsiteUrlsCollection().findOneAndUpdate(
+    { _id: new ObjectId(id) },
+    { $set: { ...updates, updatedAt: new Date() } },
+    { returnDocument: "after" },
+  );
+};
+
+export const deleteWebsiteUrl = async (id: string): Promise<boolean> => {
+  const result = await getWebsiteUrlsCollection().deleteOne({
+    _id: new ObjectId(id),
+  });
+  return result.deletedCount === 1;
+};

package/src/websitalk/websiteUrls/websiteUrls.types.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">;

package/tsconfig.json

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