@talkpilot/core-db 1.3.3 → 1.3.4

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

@@ -1,218 +0,0 @@
-import {
-  getScansCollection,
-  getScansByClientAndDateRange,
-  getScanFieldsByClientAndDateRange,
-  findScansByQuery,
-  countScans,
-  createScanDoc,
-  updateScanDoc,
-  getActiveScanStatus,
-} from "../scans.getters";
-import { createScanFixture } from "../../../test-utils/factories";
-import { ObjectId } from "mongodb";
-
-describe("db.websitalk.scans", () => {
-  describe("getScansByClientAndDateRange()", () => {
-    it("should return full scan documents within the date range", async () => {
-      const clientId = "dateRangeClient";
-      const startDate = new Date("2023-05-01");
-      const endDate = new Date("2023-05-31");
-
-      const scanInside = createScanFixture({ clientId, status: "COMPLETED" });
-      const scanBefore = createScanFixture({ clientId });
-      const scanAfter = createScanFixture({ clientId });
-
-      await getScansCollection().insertMany([
-        { ...scanInside, createdAt: new Date("2023-05-15") },
-        { ...scanBefore, createdAt: new Date("2023-04-30") },
-        { ...scanAfter, createdAt: new Date("2023-06-01") },
-      ]);
-
-      const result = await getScansByClientAndDateRange(
-        clientId,
-        startDate,
-        endDate,
-      );
-
-      expect(result.length).toBe(1);
-      expect(result[0]).toMatchObject({
-        clientId,
-        baseUrl: scanInside.baseUrl,
-        status: "COMPLETED",
-      });
-      expect(result[0]).toHaveProperty("siteChrome");
-      expect(result[0]).toHaveProperty("skipped");
-    });
-
-    it("should respect the date range boundaries (inclusive)", async () => {
-      const clientId = "boundaryClient";
-      const onStart = createScanFixture({ clientId });
-      const onEnd = createScanFixture({ clientId });
-
-      await getScansCollection().insertMany([
-        { ...onStart, createdAt: new Date("2023-05-01") },
-        { ...onEnd, createdAt: new Date("2023-05-31") },
-      ]);
-
-      const result = await getScansByClientAndDateRange(
-        clientId,
-        new Date("2023-05-01"),
-        new Date("2023-05-31"),
-      );
-
-      expect(result.length).toBe(2);
-    });
-  });
-
-  describe("getScanFieldsByClientAndDateRange()", () => {
-    it("should return only the requested fields (plus _id)", async () => {
-      const clientId = "projectionClient";
-      const scan = createScanFixture({
-        clientId,
-        status: "COMPLETED",
-        siteChrome: { url: "https://example.com", sourceType: "site_chrome" },
-        skipped: [{ path: "/broken", reason: "HTTP 500" }],
-      });
-
-      await getScansCollection().insertOne({
-        ...scan,
-        createdAt: new Date("2023-05-15"),
-      });
-
-      const [result] = await getScanFieldsByClientAndDateRange(
-        clientId,
-        new Date("2023-05-01"),
-        new Date("2023-05-31"),
-        ["clientId", "baseUrl", "status"],
-      );
-
-      expect(result).toMatchObject({
-        clientId,
-        baseUrl: scan.baseUrl,
-        status: "COMPLETED",
-      });
-      expect(result).toHaveProperty("_id");
-      expect(result).not.toHaveProperty("siteChrome");
-      expect(result).not.toHaveProperty("skipped");
-      expect(result).not.toHaveProperty("createdAt");
-    });
-  });
-
-  describe("findScansByQuery() / countScans()", () => {
-    it("should find scans matching a raw filter and count them", async () => {
-      const clientId = "queryClient";
-      const completed = createScanFixture({ clientId, status: "COMPLETED" });
-      const scanning = createScanFixture({ clientId, status: "SCANNING" });
-
-      await getScansCollection().insertMany([completed, scanning]);
-
-      const result = await findScansByQuery({ clientId, status: "COMPLETED" });
-      const count = await countScans({ clientId });
-
-      expect(result.length).toBe(1);
-      expect(result[0].baseUrl).toBe(completed.baseUrl);
-      expect(count).toBe(2);
-    });
-  });
-
-  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 { insertedId } = await createScanDoc({ clientId, baseUrl });
-
-      const result = await getScansCollection().findOne({ _id: insertedId });
-
-      expect(result).toMatchObject({
-        clientId,
-        baseUrl,
-        status: "CHECKING",
-        activeTasksCount: 0,
-        pagesScanned: 0,
-        pagesSkipped: 0,
-        skipped: [],
-        siteChrome: {},
-      });
-      expect(result?.createdAt).toBeInstanceOf(Date);
-      expect(result?.updatedAt).toBeInstanceOf(Date);
-    });
-  });
-
-  describe("updateScanDoc()", () => {
-    it("should update the given fields and bump updatedAt", async () => {
-      const scan = createScanFixture({ status: "SCANNING", pagesScanned: 0 });
-      const { insertedId } = await getScansCollection().insertOne(scan);
-
-      const result = await updateScanDoc(insertedId, {
-        status: "COMPLETED",
-        pagesScanned: 10,
-      });
-
-      expect(result).toMatchObject({
-        _id: insertedId,
-        status: "COMPLETED",
-        pagesScanned: 10,
-      });
-      expect(result?.updatedAt.getTime()).toBeGreaterThan(
-        scan.updatedAt.getTime(),
-      );
-    });
-
-    it("should return null when the scan does not exist", async () => {
-      const result = await updateScanDoc(new ObjectId(), { status: "FAILED" });
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("getActiveScanStatus()", () => {
-    it("should return isActive: true with the status when the latest scan is still in progress", async () => {
-      const clientId = "activeClient";
-
-      await getScansCollection().insertMany([
-        createScanFixture({
-          clientId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-01"),
-        }),
-        createScanFixture({
-          clientId,
-          status: "SCANNING",
-          createdAt: new Date("2023-05-15"),
-        }),
-      ]);
-
-      const result = await getActiveScanStatus(clientId);
-
-      expect(result).toEqual({ isActive: true, status: "SCANNING" });
-    });
-
-    it("should return isActive: false when the latest scan finished (COMPLETED / FAILED)", async () => {
-      const clientId = "finishedClient";
-
-      await getScansCollection().insertMany([
-        createScanFixture({
-          clientId,
-          status: "SCANNING",
-          createdAt: new Date("2023-05-01"),
-        }),
-        createScanFixture({
-          clientId,
-          status: "FAILED",
-          createdAt: new Date("2023-05-15"),
-        }),
-      ]);
-
-      const result = await getActiveScanStatus(clientId);
-
-      expect(result).toEqual({ isActive: false });
-    });
-
-    it("should return isActive: false when the client has no scans", async () => {
-      const result = await getActiveScanStatus("noScansClient");
-
-      expect(result).toEqual({ isActive: false });
-    });
-  });
-});

package/src/websitalk/scans/index.ts

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

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

@@ -1,113 +0,0 @@
-import { Collection, Filter, ObjectId } from "mongodb";
-import { getDb } from "../index";
-import {
-  applyQueryOptions,
-  QueryOptions,
-} from "../../talkpilot/utils/query.utils";
-import type {
-  ActiveScanStatus,
-  Scan,
-  ScanDoc,
-  ScanStatus,
-} from "./scans.types";
-
-export const getScansCollection = (): Collection<Scan> => {
-  return getDb().collection<Scan>("scans");
-};
-
-export const getScansByClientAndDateRange = (
-  clientId: string,
-  startDate: Date,
-  endDate: Date,
-): Promise<ScanDoc[]> => {
-  return getScansCollection()
-    .find({
-      clientId,
-      createdAt: {
-        $gte: startDate,
-        $lte: endDate,
-      },
-    })
-    .toArray();
-};
-
-export const getScanFieldsByClientAndDateRange = <K extends keyof Scan>(
-  clientId: string,
-  startDate: Date,
-  endDate: Date,
-  fields: K[],
-): Promise<Pick<ScanDoc, "_id" | K>[]> => {
-  const projection = fields.reduce<Record<string, 1>>((acc, field) => {
-    acc[field as string] = 1;
-    return acc;
-  }, {});
-
-  return getScansCollection()
-    .find(
-      {
-        clientId,
-        createdAt: {
-          $gte: startDate,
-          $lte: endDate,
-        },
-      },
-      { projection },
-    )
-    .toArray() as Promise<Pick<ScanDoc, "_id" | K>[]>;
-};
-
-export const createScanDoc = (
-  scan: Pick<Scan, "clientId" | "baseUrl" | "notifyPhoneNumber">,
-) => {
-  return getScansCollection().insertOne({
-    ...scan,
-    status: "CHECKING",
-    activeTasksCount: 0,
-    pagesScanned: 0,
-    pagesSkipped: 0,
-    skipped: [],
-    siteChrome: {} as Scan["siteChrome"],
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  });
-};
-
-const FINISHED_SCAN_STATUSES: ScanStatus[] = ["COMPLETED", "FAILED"];
-
-export const getActiveScanStatus = async (
-  clientId: string,
-): Promise<ActiveScanStatus> => {
-  const latestScan = await getScansCollection().findOne(
-    { clientId },
-    { sort: { createdAt: -1 } },
-  );
-
-  if (!latestScan || FINISHED_SCAN_STATUSES.includes(latestScan.status)) {
-    return { isActive: false };
-  }
-
-  return { isActive: true, status: latestScan.status };
-};
-
-export const updateScanDoc = async (
-  scanId: ObjectId,
-  updates: Partial<Omit<Scan, "clientId" | "createdAt">>,
-): Promise<ScanDoc | null> => {
-  return await getScansCollection().findOneAndUpdate(
-    { _id: scanId },
-    { $set: { ...updates, updatedAt: new Date() } },
-    { returnDocument: "after" },
-  );
-};
-
-export const findScansByQuery = async (
-  query: Filter<Scan>,
-  options?: QueryOptions,
-): Promise<ScanDoc[]> => {
-  const cursor = getScansCollection().find(query);
-  return await applyQueryOptions(cursor, options).toArray();
-};
-
-export const countScans = async (query: Filter<Scan>): Promise<number> => {
-  return getScansCollection().countDocuments(query);
-};

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

@@ -1,53 +0,0 @@
-import { WithId } from "mongodb";
-
-export type ScanStatus =
-  | "CHECKING"
-  | "PREPARING"
-  | "SCANNING"
-  | "PROCESSING"
-  | "COMPLETED"
-  | "FAILED";
-
-export type ActiveScanStatus =
-  | { isActive: true; status: ScanStatus }
-  | { isActive: false };
-
-export type SiteChromeEntry = {
-  url: string;
-  urlCanonical?: string | null;
-  title?: string | null;
-  h1?: string | null;
-  language?: string | null;
-  sourceType?: string | null;
-  status?: string | null;
-  context?: string | null;
-  contentHash?: string | null;
-  errorMessage?: string | null;
-  breadcrumbs?: unknown;
-  description?: string | null;
-  sourceUrl?: string | null;
-  fetchedAt?: Date | null;
-  createdAt?: Date;
-  updatedAt?: Date;
-};
-
-export type SkippedEntry = {
-  path: string;
-  reason: string;
-};
-
-export type Scan = {
-  clientId: string;
-  baseUrl: string;
-  notifyPhoneNumber?: string | null;
-  status: ScanStatus;
-  activeTasksCount: number;
-  pagesScanned: number;
-  pagesSkipped: number;
-  skipped: SkippedEntry[];
-  siteChrome: SiteChromeEntry;
-  createdAt: Date;
-  updatedAt: Date;
-};
-
-export type ScanDoc = WithId<Scan>;