@talkpilot/core-db 1.3.0 → 1.3.3

package/src/test-utils/db-utils.ts

@@ -1,6 +1,6 @@
 import { MongoMemoryServer } from "mongodb-memory-server";
 import { MongoClient, Db } from "mongodb";
-import { setDb, setMunicipalDataDb } from "../index";
+import { setDb, setMunicipalDataDb, setWebsitalkDb } from "../index";
 
 let mongoServer: MongoMemoryServer;
 let client: MongoClient;
@@ -13,8 +13,10 @@ export async function initTestDb(): Promise<Db> {
   await client.connect();
   const talkpilotDb = client.db();
   const municipalDb = client.db("municipal-data");
+  const websitalkDb = client.db("website-talk");
   setDb(talkpilotDb);
   setMunicipalDataDb(municipalDb);
+  setWebsitalkDb(websitalkDb);
   return talkpilotDb;
 }
 

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

@@ -10,3 +10,4 @@ export * from "./municipal/cities";
 export * from "./municipal/departmentsSubjects";
 export * from "./municipal/streets";
 export * from "./municipal/tickets";
+export * from "./websitalk/scans";

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

@@ -0,0 +1,23 @@
+import { Factory } from "fishery";
+import { faker } from "@faker-js/faker";
+import type { Scan } from "../../../websitalk";
+
+export const scanFactory = Factory.define<Scan>(() => ({
+  clientId: faker.string.uuid(),
+  baseUrl: faker.internet.url(),
+  status: "CHECKING",
+  activeTasksCount: 0,
+  pagesScanned: 0,
+  pagesSkipped: 0,
+  skipped: [],
+  siteChrome: {
+    url: faker.internet.url(),
+    sourceType: "site_chrome",
+  },
+  createdAt: new Date(),
+  updatedAt: new Date(),
+}));
+
+export function createScanFixture(overrides?: Partial<Scan>): Scan {
+  return scanFactory.build(overrides);
+}

package/src/websitalk/index.ts

@@ -0,0 +1,15 @@
+import { Db, ObjectId as MongoObjectId } from "mongodb";
+
+export * from "./scans";
+export { websitalkMongodbClient } from "./mongodb-client";
+
+let db: Db;
+export const setDb = (d: Db) => {
+  db = d;
+};
+
+export const getDb = (): Db => {
+  if (!db) throw new Error("Website Talk DB not initialised");
+  return db;
+};
+export const ObjectId = MongoObjectId;

package/src/websitalk/mongodb-client.ts

@@ -0,0 +1,61 @@
+import { MongoClient, Db } from "mongodb";
+import { setDb } from "./index";
+import { validateConfig, validateMongoUri } from "../utils/validation";
+
+class WebsitalkMongoDBClient {
+  private client: MongoClient | null = null;
+  private db: Db | null = null;
+  private readonly defaultDbName = "website-talk";
+
+  async connect(uri?: string, dbName?: string): Promise<void> {
+    if (this.client) {
+      return;
+    }
+
+    const mongodbUri = uri || process.env.MONGO_URI || process.env.MONGODB_URI;
+    validateConfig("MONGO_URI", mongodbUri);
+    validateMongoUri(mongodbUri!);
+
+    try {
+      this.client = new MongoClient(mongodbUri!);
+      await this.client.connect();
+      const targetDbName =
+        dbName || process.env.WEBSITALK_DB_NAME || this.defaultDbName;
+      this.db = this.client.db(targetDbName);
+      setDb(this.db);
+      console.info(`[core-db] Website Talk MongoDB connected: ${targetDbName}`);
+    } catch (error) {
+      console.error("[core-db] Website Talk connection failed", error);
+      throw error;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.client) {
+      try {
+        await this.client.close();
+        this.client = null;
+        this.db = null;
+        console.info("Website Talk MongoDB disconnected successfully");
+      } catch (error) {
+        console.error("[core-db] Website Talk disconnection failed", error);
+        throw error;
+      }
+    }
+  }
+
+  getDb(): Db {
+    if (!this.db) {
+      throw new Error(
+        "Website Talk database not initialized. Call connect() first.",
+      );
+    }
+    return this.db;
+  }
+
+  isConnected(): boolean {
+    return this.client !== null && this.client !== undefined;
+  }
+}
+
+export const websitalkMongodbClient = new WebsitalkMongoDBClient();

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

@@ -0,0 +1,218 @@
+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

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

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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,53 @@
+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>;

package/dist/municipal/tickets/tickets.constants.d.ts

@@ -1,7 +0,0 @@
-/** Label used when a ticket has no resolvable department/subject. */
-export declare const UNCLASSIFIED = "\u05DC\u05DC\u05D0 \u05DE\u05D7\u05DC\u05E7\u05D4";
-/** Max execution time (ms) for ticket statistics aggregations. */
-export declare const STATS_MAX_TIME_MS = 30000;
-/** Default look-back window (days) for ticket statistics date ranges. */
-export declare const DEFAULT_LOOKBACK_DAYS = 30;
-//# sourceMappingURL=tickets.constants.d.ts.map

package/dist/municipal/tickets/tickets.constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tickets.constants.d.ts","sourceRoot":"","sources":["../../../src/municipal/tickets/tickets.constants.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,eAAO,MAAM,YAAY,sDAAc,CAAC;AAExC,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,QAAS,CAAC;AAExC,yEAAyE;AACzE,eAAO,MAAM,qBAAqB,KAAK,CAAC"}

package/dist/municipal/tickets/tickets.constants.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_LOOKBACK_DAYS = exports.STATS_MAX_TIME_MS = exports.UNCLASSIFIED = void 0;
-/** Label used when a ticket has no resolvable department/subject. */
-exports.UNCLASSIFIED = "ללא מחלקה";
-/** Max execution time (ms) for ticket statistics aggregations. */
-exports.STATS_MAX_TIME_MS = 30_000;
-/** Default look-back window (days) for ticket statistics date ranges. */
-exports.DEFAULT_LOOKBACK_DAYS = 30;
-//# sourceMappingURL=tickets.constants.js.map

package/dist/municipal/tickets/tickets.constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tickets.constants.js","sourceRoot":"","sources":["../../../src/municipal/tickets/tickets.constants.ts"],"names":[],"mappings":";;;AAAA,qEAAqE;AACxD,QAAA,YAAY,GAAG,WAAW,CAAC;AAExC,kEAAkE;AACrD,QAAA,iBAAiB,GAAG,MAAM,CAAC;AAExC,yEAAyE;AAC5D,QAAA,qBAAqB,GAAG,EAAE,CAAC"}

package/dist/municipal/tickets/tickets.deprecated.getters.d.ts

@@ -1,12 +0,0 @@
-import type { SubjectStatsItem } from "./tickets.types";
-/**
- * @deprecated Use `findCallSidsWithTicketsByCity` with `ticketStatsDateScopeFromYmd` instead.
- * Will be removed in 3.0.0.
- */
-export declare function getTicketsCountByCityAndDateRange(cityName: string, startStr: string, endStr: string, timezone: string): Promise<number>;
-/**
- * @deprecated Use `findFilteredCallSids` + `findSubjectsByCallSids` instead.
- * Will be removed in 3.0.0.
- */
-export declare function getTicketsSubjectStats(cityName: string, startStr: string, endStr: string, timezone: string): Promise<SubjectStatsItem[]>;
-//# sourceMappingURL=tickets.deprecated.getters.d.ts.map

package/dist/municipal/tickets/tickets.deprecated.getters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tickets.deprecated.getters.d.ts","sourceRoot":"","sources":["../../../src/municipal/tickets/tickets.deprecated.getters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;GAGG;AACH,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAgBjB;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAoG7B"}

package/dist/municipal/tickets/tickets.deprecated.getters.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTicketsCountByCityAndDateRange = getTicketsCountByCityAndDateRange;
-exports.getTicketsSubjectStats = getTicketsSubjectStats;
-const tickets_getters_1 = require("./tickets.getters");
-/**
- * @deprecated Use `findCallSidsWithTicketsByCity` with `ticketStatsDateScopeFromYmd` instead.
- * Will be removed in 3.0.0.
- */
-async function getTicketsCountByCityAndDateRange(cityName, startStr, endStr, timezone) {
-    const doc = await (0, tickets_getters_1.getTicketsCollection)()
-        .aggregate([
-        { $match: { cityName, callSid: { $exists: true, $nin: [null, ""] } } },
-        {
-            $addFields: {
-                dateLocal: {
-                    $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
-                },
-            },
-        },
-        { $match: { dateLocal: { $gte: startStr, $lte: endStr } } },
-        { $count: "n" },
-    ])
-        .next();
-    return doc?.n ?? 0;
-}
-/**
- * @deprecated Use `findFilteredCallSids` + `findSubjectsByCallSids` instead.
- * Will be removed in 3.0.0.
- */
-async function getTicketsSubjectStats(cityName, startStr, endStr, timezone) {
-    const rows = await (0, tickets_getters_1.getTicketsCollection)()
-        .aggregate([
-        { $match: { cityName } },
-        {
-            $addFields: {
-                dateLocal: {
-                    $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
-                },
-            },
-        },
-        { $match: { dateLocal: { $gte: startStr, $lte: endStr } } },
-        {
-            $addFields: {
-                effectiveSubjectId: {
-                    $ifNull: [
-                        "$externalCallFields.event_subject_id",
-                        {
-                            $ifNull: [
-                                "$externalCallFields.event_sub_subject_id",
-                                "$externalCallFields.event_sub_subject_id2",
-                            ],
-                        },
-                    ],
-                },
-            },
-        },
-        {
-            $lookup: {
-                from: "departmentsSubjects",
-                let: { sid: "$effectiveSubjectId", c: cityName },
-                pipeline: [
-                    {
-                        $match: {
-                            $expr: {
-                                $and: [
-                                    { $eq: ["$cityName", "$$c"] },
-                                    {
-                                        $or: [
-                                            { $eq: ["$subject_id", { $ifNull: ["$$sid", ""] }] },
-                                            {
-                                                $eq: ["$sub_subject_id", { $ifNull: ["$$sid", ""] }],
-                                            },
-                                            {
-                                                $eq: ["$sub_subject_id2", { $ifNull: ["$$sid", ""] }],
-                                            },
-                                        ],
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                    { $limit: 1 },
-                ],
-                as: "subj",
-            },
-        },
-        {
-            $addFields: {
-                subject_id: {
-                    $cond: {
-                        if: { $gt: [{ $size: "$subj" }, 0] },
-                        then: {
-                            $ifNull: [{ $arrayElemAt: ["$subj.subject_id", 0] }, ""],
-                        },
-                        else: "",
-                    },
-                },
-                subject: {
-                    $cond: {
-                        if: { $gt: [{ $size: "$subj" }, 0] },
-                        then: {
-                            $ifNull: [
-                                { $arrayElemAt: ["$subj.subjectName", 0] },
-                                "Unclassified",
-                            ],
-                        },
-                        else: "Unclassified",
-                    },
-                },
-            },
-        },
-        {
-            $group: {
-                _id: "$subject_id",
-                subject: { $first: "$subject" },
-                count: { $sum: 1 },
-            },
-        },
-        { $sort: { count: -1 } },
-    ])
-        .toArray();
-    const total = rows.reduce((sum, row) => sum + row.count, 0);
-    return rows.map((row) => ({
-        subject_name: row.subject,
-        subject_id: row._id,
-        count: row.count,
-        percentage: total > 0 ? Math.round((row.count / total) * 100) : 0,
-    }));
-}
-//# sourceMappingURL=tickets.deprecated.getters.js.map