@talkpilot/core-db 1.3.14 → 1.3.16

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"]

package/dist/talkpilot/subscriptions/subscriptions.utils.d.ts

@@ -1,4 +0,0 @@
-import { Filter } from 'mongodb';
-import { Subscription, SimpleSubscriptionFilter } from '../index';
-export declare const buildSimpleQuery: (filter: SimpleSubscriptionFilter) => Filter<Subscription>;
-//# sourceMappingURL=subscriptions.utils.d.ts.map

package/dist/talkpilot/subscriptions/subscriptions.utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscriptions.utils.d.ts","sourceRoot":"","sources":["../../../src/talkpilot/subscriptions/subscriptions.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,wBAAwB,EAA6B,MAAM,UAAU,CAAC;AAE7F,eAAO,MAAM,gBAAgB,GAAI,QAAQ,wBAAwB,KAAG,MAAM,CAAC,YAAY,CAetF,CAAC"}

package/dist/talkpilot/subscriptions/subscriptions.utils.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSimpleQuery = void 0;
-const mongodb_1 = require("mongodb");
-const index_1 = require("../index");
-const buildSimpleQuery = (filter) => {
-    const query = {};
-    if (filter._id) {
-        query._id = new mongodb_1.ObjectId(filter._id);
-    }
-    index_1.simpleFields.forEach((field) => {
-        const val = filter[field];
-        if (val !== undefined) {
-            query[field] = val;
-        }
-    });
-    return query;
-};
-exports.buildSimpleQuery = buildSimpleQuery;
-//# sourceMappingURL=subscriptions.utils.js.map

package/dist/talkpilot/subscriptions/subscriptions.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscriptions.utils.js","sourceRoot":"","sources":["../../../src/talkpilot/subscriptions/subscriptions.utils.ts"],"names":[],"mappings":";;;AAAA,qCAA2C;AAC3C,oCAA6F;AAEtF,MAAM,gBAAgB,GAAG,CAAC,MAAgC,EAAwB,EAAE;IACzF,MAAM,KAAK,GAAyB,EAAE,CAAC;IAEvC,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;QACf,KAAK,CAAC,GAAG,GAAG,IAAI,kBAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACvC,CAAC;IAED,oBAAY,CAAC,OAAO,CAAC,CAAC,KAAkB,EAAE,EAAE;QAC1C,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,KAAK,CAAC,KAAK,CAAC,GAAG,GAAU,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAfW,QAAA,gBAAgB,oBAe3B"}