cmp-aws-database 2.1.2-dev.6 → 2.1.2-dev.60

package/dist/customer-user/items-bundle/items-bundle-dao.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.itemsBundleDao = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const base_dynamoose_dao_1 = require("../../base-dynamoose-dao");
+const items_bundle_model_1 = require("./items-bundle-model");
+/**
+ * DAO for item bundles (add-on / replacement groupings).
+ *
+ * Table keys: `bundleId` (PK).
+ * Lookups:
+ * - `usageTypeIndex` → bundles by ADDON / REPLACEMENT
+ * - `bundleTypeIndex` → bundles by `bundleType`
+ */
+class ItemsBundleDao extends base_dynamoose_dao_1.GenericDynamooseDAO {
+    constructor() {
+        super(items_bundle_model_1.ItemsBundleModel, "bundleId");
+        /**
+         * Creates one item-bundle record.
+         *
+         * Use when: admin defines a new ADDON or REPLACEMENT bundle.
+         * - `bundleId` auto-generates if omitted.
+         * - `usageType` must be `"ADDON"` or `"REPLACEMENT"`.
+         *
+         * @example
+         * await itemsBundleDao.save({
+         *     bundleType: "STARTERS",
+         *     bundleName: "Premium Starters Pack",
+         *     usageType: "ADDON"
+         * });
+         */
+        this.save = async (item, authContext) => {
+            return super.save(item, authContext);
+        };
+        /**
+         * Updates one item-bundle by `bundleId`.
+         *
+         * Use when: renaming a bundle or changing ADDON ↔ REPLACEMENT usage.
+         *
+         * @example
+         * await itemsBundleDao.update("bundle-uuid", { usageType: "REPLACEMENT" });
+         */
+        this.update = async (bundleId, updates, authContext) => {
+            const updated = await items_bundle_model_1.ItemsBundleModel.update({ bundleId }, {
+                ...updates,
+                updated_time: new Date(),
+                updated_user: authContext?.userSub
+            }, {
+                condition: new dynamoose_1.default.Condition().attribute("bundleId").exists()
+            });
+            return updated;
+        };
+        /**
+         * Fetches one item-bundle by primary key.
+         *
+         * @example
+         * const bundle = await itemsBundleDao.getById("bundle-uuid");
+         */
+        this.getById = async (bundleId) => this.get(bundleId);
+        /**
+         * Lists bundles by usage type — ADDON or REPLACEMENT (GSI `usageTypeIndex`).
+         *
+         * Use when: showing only add-on packs or only replacement packs in UI.
+         *
+         * @example
+         * const addons = await itemsBundleDao.listByUsageType("ADDON", 20);
+         * const replacements = await itemsBundleDao.listByUsageType("REPLACEMENT", 20);
+         */
+        this.listByUsageType = async (usageType, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = items_bundle_model_1.ItemsBundleModel.query("usageType").eq(usageType).using("usageTypeIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Lists bundles by `bundleType` (GSI `bundleTypeIndex`).
+         *
+         * @example
+         * const starters = await itemsBundleDao.listByBundleType("STARTERS", 20);
+         */
+        this.listByBundleType = async (bundleType, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = items_bundle_model_1.ItemsBundleModel.query("bundleType").eq(bundleType).using("bundleTypeIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Deletes one item-bundle by primary key.
+         */
+        this.deleteById = async (bundleId) => {
+            await this.delete(bundleId);
+        };
+    }
+}
+exports.itemsBundleDao = new ItemsBundleDao();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"items-bundle-dao.js","sourceRoot":"","sources":["../../../src/customer-user/items-bundle/items-bundle-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import dynamoose from \"dynamoose\";\nimport { DynamoKey, GenericDynamooseDAO } from \"../../base-dynamoose-dao\";\nimport { AuthContext } from \"../../base-dynamoose-model\";\nimport {\n    CreateItemsBundleInput,\n    ItemBundleUsageType,\n    ItemsBundle,\n    ItemsBundleModel\n} from \"./items-bundle-model\";\n\ntype ListResult = {\n    items: ItemsBundle[];\n    nextToken?: string;\n};\n\n/**\n * DAO for item bundles (add-on / replacement groupings).\n *\n * Table keys: `bundleId` (PK).\n * Lookups:\n * - `usageTypeIndex` → bundles by ADDON / REPLACEMENT\n * - `bundleTypeIndex` → bundles by `bundleType`\n */\nclass ItemsBundleDao extends GenericDynamooseDAO<ItemsBundle> {\n    constructor() {\n        super(ItemsBundleModel, \"bundleId\");\n    }\n\n    /**\n     * Creates one item-bundle record.\n     *\n     * Use when: admin defines a new ADDON or REPLACEMENT bundle.\n     * - `bundleId` auto-generates if omitted.\n     * - `usageType` must be `\"ADDON\"` or `\"REPLACEMENT\"`.\n     *\n     * @example\n     * await itemsBundleDao.save({\n     *     bundleType: \"STARTERS\",\n     *     bundleName: \"Premium Starters Pack\",\n     *     usageType: \"ADDON\"\n     * });\n     */\n    save = async (item: CreateItemsBundleInput, authContext?: AuthContext): Promise<ItemsBundle> => {\n        return super.save(item as ItemsBundle, authContext);\n    };\n\n    /**\n     * Updates one item-bundle by `bundleId`.\n     *\n     * Use when: renaming a bundle or changing ADDON ↔ REPLACEMENT usage.\n     *\n     * @example\n     * await itemsBundleDao.update(\"bundle-uuid\", { usageType: \"REPLACEMENT\" });\n     */\n    update = async (\n        bundleId: string,\n        updates: Partial<ItemsBundle>,\n        authContext?: AuthContext\n    ): Promise<ItemsBundle> => {\n        const updated = await ItemsBundleModel.update(\n            { bundleId },\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            },\n            {\n                condition: new dynamoose.Condition().attribute(\"bundleId\").exists()\n            }\n        );\n        return updated as unknown as ItemsBundle;\n    };\n\n    /**\n     * Fetches one item-bundle by primary key.\n     *\n     * @example\n     * const bundle = await itemsBundleDao.getById(\"bundle-uuid\");\n     */\n    getById = async (bundleId: string): Promise<ItemsBundle | null> => this.get(bundleId);\n\n    /**\n     * Lists bundles by usage type — ADDON or REPLACEMENT (GSI `usageTypeIndex`).\n     *\n     * Use when: showing only add-on packs or only replacement packs in UI.\n     *\n     * @example\n     * const addons = await itemsBundleDao.listByUsageType(\"ADDON\", 20);\n     * const replacements = await itemsBundleDao.listByUsageType(\"REPLACEMENT\", 20);\n     */\n    listByUsageType = async (\n        usageType: ItemBundleUsageType,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = ItemsBundleModel.query(\"usageType\").eq(usageType).using(\"usageTypeIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as ItemsBundle[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Lists bundles by `bundleType` (GSI `bundleTypeIndex`).\n     *\n     * @example\n     * const starters = await itemsBundleDao.listByBundleType(\"STARTERS\", 20);\n     */\n    listByBundleType = async (\n        bundleType: string,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = ItemsBundleModel.query(\"bundleType\").eq(bundleType).using(\"bundleTypeIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as ItemsBundle[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Deletes one item-bundle by primary key.\n     */\n    deleteById = async (bundleId: string): Promise<void> => {\n        await this.delete(bundleId);\n    };\n}\n\nexport const itemsBundleDao = new ItemsBundleDao();\n"]}

package/dist/customer-user/items-bundle/items-bundle-model.d.ts

@@ -0,0 +1,23 @@
+import { BaseDynamooseModel } from "../../base-dynamoose-model";
+/**
+ * Decides how the bundle is applied on a platter item.
+ * - ADDON → extra items added on top of the platter
+ * - REPLACEMENT → swaps an existing platter item
+ */
+export declare const ITEM_BUNDLE_USAGE_TYPE: {
+    readonly ADDON: "ADDON";
+    readonly REPLACEMENT: "REPLACEMENT";
+};
+export type ItemBundleUsageType = (typeof ITEM_BUNDLE_USAGE_TYPE)[keyof typeof ITEM_BUNDLE_USAGE_TYPE];
+export interface ItemsBundle extends BaseDynamooseModel {
+    bundleId: string;
+    bundleType: string;
+    bundleName: string;
+    usageType: ItemBundleUsageType;
+    bundleOrder?: number;
+}
+export type CreateItemsBundleInput = Omit<ItemsBundle, "bundleId"> & {
+    bundleId?: string;
+};
+export declare const ItemsBundleModel: import("dynamoose/dist/General").ModelType<ItemsBundle>;
+export declare const convertToItemsBundleModel: (input: CreateItemsBundleInput | ItemsBundle) => ItemsBundle;

package/dist/customer-user/items-bundle/items-bundle-model.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToItemsBundleModel = exports.ItemsBundleModel = exports.ITEM_BUNDLE_USAGE_TYPE = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const crypto_1 = require("crypto");
+const base_dynamoose_model_1 = require("../../base-dynamoose-model");
+const table_names_1 = require("../../config/table-names");
+/**
+ * Decides how the bundle is applied on a platter item.
+ * - ADDON → extra items added on top of the platter
+ * - REPLACEMENT → swaps an existing platter item
+ */
+exports.ITEM_BUNDLE_USAGE_TYPE = {
+    ADDON: "ADDON",
+    REPLACEMENT: "REPLACEMENT"
+};
+const itemsBundleSchema = new dynamoose_1.default.Schema({
+    bundleId: {
+        type: String,
+        hashKey: true,
+        required: true,
+        default: () => (0, crypto_1.randomUUID)()
+    },
+    bundleType: {
+        type: String,
+        required: true,
+        index: {
+            name: "bundleTypeIndex",
+            type: "global"
+        }
+    },
+    bundleName: {
+        type: String,
+        required: true
+    },
+    bundleOrder: {
+        type: Number,
+        required: false
+    },
+    usageType: {
+        type: String,
+        required: true,
+        enum: [exports.ITEM_BUNDLE_USAGE_TYPE.ADDON, exports.ITEM_BUNDLE_USAGE_TYPE.REPLACEMENT],
+        index: {
+            name: "usageTypeIndex",
+            type: "global"
+        }
+    },
+    ...base_dynamoose_model_1.BASE_DYNAMOOSE_AUDIT_SCHEMA
+}, {
+    saveUnknown: false,
+    timestamps: true
+});
+exports.ItemsBundleModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.ITEMS_BUNDLE, itemsBundleSchema, { create: false, waitForActive: false });
+const convertToItemsBundleModel = (input) => {
+    return new exports.ItemsBundleModel(input);
+};
+exports.convertToItemsBundleModel = convertToItemsBundleModel;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/lsq-priority-updation/lsq-priority-updation-dao.d.ts

@@ -0,0 +1,140 @@
+import { GenericDynamooseDAO } from "../../base-dynamoose-dao";
+import { AuthContext } from "../../base-dynamoose-model";
+import { CreateLsqPriorityUpdationInput, LsqPassedStr, LsqPriorityUpdation } from "./lsq-priority-updation-model";
+type ListResult = {
+    items: LsqPriorityUpdation[];
+    nextToken?: string;
+};
+/**
+ * DAO for LeadSquared priority-updation queue.
+ *
+ * Table keys: `lsqPriorityUpdationId` (PK).
+ * Lookups:
+ * - `opportunityIdIndex` → by LeadSquared `opportunityId`
+ * - `leadNumberIndex` → by lead phone/number
+ * - `statusIndex` → by record `status`
+ * - `passedStrIndex` → unprocessed queue (`passedStr` + `priorityRank`)
+ * Processed rows are deleted from the table (not soft-flagged).
+ */
+declare class LsqPriorityUpdationDao extends GenericDynamooseDAO<LsqPriorityUpdation> {
+    constructor();
+    private normalizeInput;
+    /**
+     * Creates / queues one opportunity for priority updation.
+     *
+     * Use when: LeadSquared webhook receives a new/updated opportunity.
+     * - `lsqPriorityUpdationId` auto-generates if omitted.
+     * - Auto-fills `passedStr` from `passed` (`false` → `"FALSE"`).
+     * - Auto-fills `priorityRank` from `priority` (P1→1 … P5→5).
+     *
+     * @example
+     * await lsqPriorityUpdationDao.save({
+     *     opportunityId: "opp-123",
+     *     leadNumber: "9876543210",
+     *     passed: false,
+     *     priority: "P1",
+     *     urgency: "U2",
+     *     value: "V3",
+     *     eventDate: "2026-07-30",
+     *     payload: { raw: "webhook-body" }
+     * });
+     */
+    save: (item: CreateLsqPriorityUpdationInput, authContext?: AuthContext) => Promise<LsqPriorityUpdation>;
+    /**
+     * Updates an existing queued record by `lsqPriorityUpdationId`.
+     *
+     * Use when: recalculating priority/urgency/value (e.g. midnight job) or
+     * refreshing webhook payload fields.
+     * - Re-syncs `passedStr` / `priorityRank` when `passed` / `priority` change.
+     * - Always refreshes `updatedAt`.
+     *
+     * @example
+     * await lsqPriorityUpdationDao.update("lsq-uuid", {
+     *     priority: "P2",
+     *     urgency: "U1",
+     *     value: "V2"
+     * });
+     */
+    update: (lsqPriorityUpdationId: string, updates: Partial<LsqPriorityUpdation>, authContext?: AuthContext) => Promise<LsqPriorityUpdation>;
+    /**
+     * Fetches one queue record by table primary key.
+     *
+     * @example
+     * const row = await lsqPriorityUpdationDao.getById("lsq-uuid");
+     */
+    getById: (lsqPriorityUpdationId: string) => Promise<LsqPriorityUpdation | null>;
+    /**
+     * Fetches one queue record by LeadSquared `opportunityId` (GSI `opportunityIdIndex`).
+     *
+     * @example
+     * const row = await lsqPriorityUpdationDao.getByOpportunityId("opp-123");
+     */
+    getByOpportunityId: (opportunityId: string) => Promise<LsqPriorityUpdation | null>;
+    /**
+     * Lists queue records by LeadSquared `opportunityId` (GSI `opportunityIdIndex`).
+     *
+     * @example
+     * const { items } = await lsqPriorityUpdationDao.listByOpportunityId("opp-123");
+     */
+    listByOpportunityId: (opportunityId: string, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Fetches one queue record by `leadNumber` (GSI `leadNumberIndex`).
+     *
+     * @example
+     * const row = await lsqPriorityUpdationDao.getByLeadNumber("9876543210");
+     */
+    getByLeadNumber: (leadNumber: string) => Promise<LsqPriorityUpdation | null>;
+    /**
+     * Lists queue records by `leadNumber` (GSI `leadNumberIndex`).
+     *
+     * @example
+     * const { items } = await lsqPriorityUpdationDao.listByLeadNumber("9876543210");
+     */
+    listByLeadNumber: (leadNumber: string, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Lists queue records by `status` (GSI `statusIndex`).
+     *
+     * @example
+     * const { items } = await lsqPriorityUpdationDao.listByStatus("PENDING", 25);
+     */
+    listByStatus: (status: string, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Lists queued (unprocessed) opportunities sorted by `priorityRank` ascending.
+     *
+     * Use when: worker pulls next batch of unassigned LSQ priority updates.
+     * Queries GSI `passedStrIndex` with `passedStr = "FALSE"`.
+     *
+     * @example
+     * const { items, nextToken } = await lsqPriorityUpdationDao.listUnprocessed(25);
+     */
+    listUnprocessed: (limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Lists opportunities by `passedStr` (GSI `passedStrIndex`), sorted by `priorityRank`.
+     *
+     * @example
+     * const queued = await lsqPriorityUpdationDao.listByPassedStr("FALSE", 25);
+     */
+    listByPassedStr: (passedStr: LsqPassedStr, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Marks a queue row as processed by deleting it via primary key.
+     *
+     * Use when: worker successfully applied priority update in LeadSquared.
+     *
+     * @example
+     * await lsqPriorityUpdationDao.markProcessed("lsq-uuid");
+     */
+    markProcessed: (lsqPriorityUpdationId: string) => Promise<void>;
+    /**
+     * Marks processed by LeadSquared `opportunityId` (lookup GSI, then delete by PK).
+     *
+     * @example
+     * await lsqPriorityUpdationDao.markProcessedByOpportunityId("opp-123");
+     */
+    markProcessedByOpportunityId: (opportunityId: string) => Promise<boolean>;
+    /**
+     * Deletes one queue record by primary key.
+     */
+    deleteById: (lsqPriorityUpdationId: string) => Promise<void>;
+}
+export declare const lsqPriorityUpdationDao: LsqPriorityUpdationDao;
+export {};

package/dist/customer-user/lsq-priority-updation/lsq-priority-updation-dao.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lsqPriorityUpdationDao = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const base_dynamoose_dao_1 = require("../../base-dynamoose-dao");
+const lsq_priority_updation_model_1 = require("./lsq-priority-updation-model");
+/**
+ * DAO for LeadSquared priority-updation queue.
+ *
+ * Table keys: `lsqPriorityUpdationId` (PK).
+ * Lookups:
+ * - `opportunityIdIndex` → by LeadSquared `opportunityId`
+ * - `leadNumberIndex` → by lead phone/number
+ * - `statusIndex` → by record `status`
+ * - `passedStrIndex` → unprocessed queue (`passedStr` + `priorityRank`)
+ * Processed rows are deleted from the table (not soft-flagged).
+ */
+class LsqPriorityUpdationDao extends base_dynamoose_dao_1.GenericDynamooseDAO {
+    constructor() {
+        super(lsq_priority_updation_model_1.LsqPriorityUpdationModel, "lsqPriorityUpdationId");
+        this.normalizeInput = (item) => {
+            const passed = item.passed ?? false;
+            const priority = item.priority;
+            return {
+                ...item,
+                passed,
+                passedStr: item.passedStr ?? (0, lsq_priority_updation_model_1.toPassedStr)(passed),
+                priorityRank: item.priorityRank ?? (priority ? (0, lsq_priority_updation_model_1.toPriorityRank)(priority) : undefined)
+            };
+        };
+        /**
+         * Creates / queues one opportunity for priority updation.
+         *
+         * Use when: LeadSquared webhook receives a new/updated opportunity.
+         * - `lsqPriorityUpdationId` auto-generates if omitted.
+         * - Auto-fills `passedStr` from `passed` (`false` → `"FALSE"`).
+         * - Auto-fills `priorityRank` from `priority` (P1→1 … P5→5).
+         *
+         * @example
+         * await lsqPriorityUpdationDao.save({
+         *     opportunityId: "opp-123",
+         *     leadNumber: "9876543210",
+         *     passed: false,
+         *     priority: "P1",
+         *     urgency: "U2",
+         *     value: "V3",
+         *     eventDate: "2026-07-30",
+         *     payload: { raw: "webhook-body" }
+         * });
+         */
+        this.save = async (item, authContext) => {
+            return super.save(this.normalizeInput(item), authContext);
+        };
+        /**
+         * Updates an existing queued record by `lsqPriorityUpdationId`.
+         *
+         * Use when: recalculating priority/urgency/value (e.g. midnight job) or
+         * refreshing webhook payload fields.
+         * - Re-syncs `passedStr` / `priorityRank` when `passed` / `priority` change.
+         * - Always refreshes `updatedAt`.
+         *
+         * @example
+         * await lsqPriorityUpdationDao.update("lsq-uuid", {
+         *     priority: "P2",
+         *     urgency: "U1",
+         *     value: "V2"
+         * });
+         */
+        this.update = async (lsqPriorityUpdationId, updates, authContext) => {
+            const nextUpdates = {
+                ...updates,
+                updated_time: new Date(),
+                updated_user: authContext?.userSub
+            };
+            if (typeof updates.passed === "boolean") {
+                nextUpdates.passedStr = updates.passedStr ?? (0, lsq_priority_updation_model_1.toPassedStr)(updates.passed);
+            }
+            if (updates.priority) {
+                nextUpdates.priorityRank = updates.priorityRank ?? (0, lsq_priority_updation_model_1.toPriorityRank)(updates.priority);
+            }
+            const updated = await lsq_priority_updation_model_1.LsqPriorityUpdationModel.update({ lsqPriorityUpdationId }, nextUpdates, {
+                condition: new dynamoose_1.default.Condition().attribute("lsqPriorityUpdationId").exists()
+            });
+            return updated;
+        };
+        /**
+         * Fetches one queue record by table primary key.
+         *
+         * @example
+         * const row = await lsqPriorityUpdationDao.getById("lsq-uuid");
+         */
+        this.getById = async (lsqPriorityUpdationId) => this.get(lsqPriorityUpdationId);
+        /**
+         * Fetches one queue record by LeadSquared `opportunityId` (GSI `opportunityIdIndex`).
+         *
+         * @example
+         * const row = await lsqPriorityUpdationDao.getByOpportunityId("opp-123");
+         */
+        this.getByOpportunityId = async (opportunityId) => {
+            const result = await this.listByOpportunityId(opportunityId, 1);
+            return result.items[0] ?? null;
+        };
+        /**
+         * Lists queue records by LeadSquared `opportunityId` (GSI `opportunityIdIndex`).
+         *
+         * @example
+         * const { items } = await lsqPriorityUpdationDao.listByOpportunityId("opp-123");
+         */
+        this.listByOpportunityId = async (opportunityId, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = lsq_priority_updation_model_1.LsqPriorityUpdationModel.query("opportunityId")
+                .eq(opportunityId)
+                .using("opportunityIdIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Fetches one queue record by `leadNumber` (GSI `leadNumberIndex`).
+         *
+         * @example
+         * const row = await lsqPriorityUpdationDao.getByLeadNumber("9876543210");
+         */
+        this.getByLeadNumber = async (leadNumber) => {
+            const result = await this.listByLeadNumber(leadNumber, 1);
+            return result.items[0] ?? null;
+        };
+        /**
+         * Lists queue records by `leadNumber` (GSI `leadNumberIndex`).
+         *
+         * @example
+         * const { items } = await lsqPriorityUpdationDao.listByLeadNumber("9876543210");
+         */
+        this.listByLeadNumber = async (leadNumber, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = lsq_priority_updation_model_1.LsqPriorityUpdationModel.query("leadNumber")
+                .eq(leadNumber)
+                .using("leadNumberIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Lists queue records by `status` (GSI `statusIndex`).
+         *
+         * @example
+         * const { items } = await lsqPriorityUpdationDao.listByStatus("PENDING", 25);
+         */
+        this.listByStatus = async (status, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = lsq_priority_updation_model_1.LsqPriorityUpdationModel.query("status")
+                .eq(status)
+                .using("statusIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Lists queued (unprocessed) opportunities sorted by `priorityRank` ascending.
+         *
+         * Use when: worker pulls next batch of unassigned LSQ priority updates.
+         * Queries GSI `passedStrIndex` with `passedStr = "FALSE"`.
+         *
+         * @example
+         * const { items, nextToken } = await lsqPriorityUpdationDao.listUnprocessed(25);
+         */
+        this.listUnprocessed = async (limit, token) => this.listByPassedStr(lsq_priority_updation_model_1.LSQ_PASSED_STR.FALSE, limit, token);
+        /**
+         * Lists opportunities by `passedStr` (GSI `passedStrIndex`), sorted by `priorityRank`.
+         *
+         * @example
+         * const queued = await lsqPriorityUpdationDao.listByPassedStr("FALSE", 25);
+         */
+        this.listByPassedStr = async (passedStr, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = lsq_priority_updation_model_1.LsqPriorityUpdationModel.query("passedStr")
+                .eq(passedStr)
+                .using("passedStrIndex")
+                .sort("ascending");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Marks a queue row as processed by deleting it via primary key.
+         *
+         * Use when: worker successfully applied priority update in LeadSquared.
+         *
+         * @example
+         * await lsqPriorityUpdationDao.markProcessed("lsq-uuid");
+         */
+        this.markProcessed = async (lsqPriorityUpdationId) => {
+            await this.delete(lsqPriorityUpdationId);
+        };
+        /**
+         * Marks processed by LeadSquared `opportunityId` (lookup GSI, then delete by PK).
+         *
+         * @example
+         * await lsqPriorityUpdationDao.markProcessedByOpportunityId("opp-123");
+         */
+        this.markProcessedByOpportunityId = async (opportunityId) => {
+            const row = await this.getByOpportunityId(opportunityId);
+            if (!row) {
+                return false;
+            }
+            await this.delete(row.lsqPriorityUpdationId);
+            return true;
+        };
+        /**
+         * Deletes one queue record by primary key.
+         */
+        this.deleteById = async (lsqPriorityUpdationId) => {
+            await this.delete(lsqPriorityUpdationId);
+        };
+    }
+}
+exports.lsqPriorityUpdationDao = new LsqPriorityUpdationDao();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lsq-priority-updation-dao.js","sourceRoot":"","sources":["../../../src/customer-user/lsq-priority-updation/lsq-priority-updation-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import dynamoose from \"dynamoose\";\nimport { DynamoKey, GenericDynamooseDAO } from \"../../base-dynamoose-dao\";\nimport { AuthContext } from \"../../base-dynamoose-model\";\nimport {\n    CreateLsqPriorityUpdationInput,\n    LSQ_PASSED_STR,\n    LsqPassedStr,\n    LsqPriority,\n    LsqPriorityUpdation,\n    LsqPriorityUpdationModel,\n    toPassedStr,\n    toPriorityRank\n} from \"./lsq-priority-updation-model\";\n\ntype ListResult = {\n    items: LsqPriorityUpdation[];\n    nextToken?: string;\n};\n\n/**\n * DAO for LeadSquared priority-updation queue.\n *\n * Table keys: `lsqPriorityUpdationId` (PK).\n * Lookups:\n * - `opportunityIdIndex` → by LeadSquared `opportunityId`\n * - `leadNumberIndex` → by lead phone/number\n * - `statusIndex` → by record `status`\n * - `passedStrIndex` → unprocessed queue (`passedStr` + `priorityRank`)\n * Processed rows are deleted from the table (not soft-flagged).\n */\nclass LsqPriorityUpdationDao extends GenericDynamooseDAO<LsqPriorityUpdation> {\n    constructor() {\n        super(LsqPriorityUpdationModel, \"lsqPriorityUpdationId\");\n    }\n\n    private normalizeInput = (item: CreateLsqPriorityUpdationInput): LsqPriorityUpdation => {\n        const passed = item.passed ?? false;\n        const priority = item.priority as LsqPriority;\n\n        return {\n            ...item,\n            passed,\n            passedStr: item.passedStr ?? toPassedStr(passed),\n            priorityRank: item.priorityRank ?? (priority ? toPriorityRank(priority) : undefined)\n        } as LsqPriorityUpdation;\n    };\n\n    /**\n     * Creates / queues one opportunity for priority updation.\n     *\n     * Use when: LeadSquared webhook receives a new/updated opportunity.\n     * - `lsqPriorityUpdationId` auto-generates if omitted.\n     * - Auto-fills `passedStr` from `passed` (`false` → `\"FALSE\"`).\n     * - Auto-fills `priorityRank` from `priority` (P1→1 … P5→5).\n     *\n     * @example\n     * await lsqPriorityUpdationDao.save({\n     *     opportunityId: \"opp-123\",\n     *     leadNumber: \"9876543210\",\n     *     passed: false,\n     *     priority: \"P1\",\n     *     urgency: \"U2\",\n     *     value: \"V3\",\n     *     eventDate: \"2026-07-30\",\n     *     payload: { raw: \"webhook-body\" }\n     * });\n     */\n    save = async (\n        item: CreateLsqPriorityUpdationInput,\n        authContext?: AuthContext\n    ): Promise<LsqPriorityUpdation> => {\n        return super.save(this.normalizeInput(item), authContext);\n    };\n\n    /**\n     * Updates an existing queued record by `lsqPriorityUpdationId`.\n     *\n     * Use when: recalculating priority/urgency/value (e.g. midnight job) or\n     * refreshing webhook payload fields.\n     * - Re-syncs `passedStr` / `priorityRank` when `passed` / `priority` change.\n     * - Always refreshes `updatedAt`.\n     *\n     * @example\n     * await lsqPriorityUpdationDao.update(\"lsq-uuid\", {\n     *     priority: \"P2\",\n     *     urgency: \"U1\",\n     *     value: \"V2\"\n     * });\n     */\n    update = async (\n        lsqPriorityUpdationId: string,\n        updates: Partial<LsqPriorityUpdation>,\n        authContext?: AuthContext\n    ): Promise<LsqPriorityUpdation> => {\n        const nextUpdates: Partial<LsqPriorityUpdation> = {\n            ...updates,\n            updated_time: new Date(),\n            updated_user: authContext?.userSub\n        };\n\n        if (typeof updates.passed === \"boolean\") {\n            nextUpdates.passedStr = updates.passedStr ?? toPassedStr(updates.passed);\n        }\n        if (updates.priority) {\n            nextUpdates.priorityRank = updates.priorityRank ?? toPriorityRank(updates.priority);\n        }\n\n        const updated = await LsqPriorityUpdationModel.update(\n            { lsqPriorityUpdationId },\n            nextUpdates,\n            {\n                condition: new dynamoose.Condition().attribute(\"lsqPriorityUpdationId\").exists()\n            }\n        );\n        return updated as unknown as LsqPriorityUpdation;\n    };\n\n    /**\n     * Fetches one queue record by table primary key.\n     *\n     * @example\n     * const row = await lsqPriorityUpdationDao.getById(\"lsq-uuid\");\n     */\n    getById = async (lsqPriorityUpdationId: string): Promise<LsqPriorityUpdation | null> =>\n        this.get(lsqPriorityUpdationId);\n\n    /**\n     * Fetches one queue record by LeadSquared `opportunityId` (GSI `opportunityIdIndex`).\n     *\n     * @example\n     * const row = await lsqPriorityUpdationDao.getByOpportunityId(\"opp-123\");\n     */\n    getByOpportunityId = async (opportunityId: string): Promise<LsqPriorityUpdation | null> => {\n        const result = await this.listByOpportunityId(opportunityId, 1);\n        return result.items[0] ?? null;\n    };\n\n    /**\n     * Lists queue records by LeadSquared `opportunityId` (GSI `opportunityIdIndex`).\n     *\n     * @example\n     * const { items } = await lsqPriorityUpdationDao.listByOpportunityId(\"opp-123\");\n     */\n    listByOpportunityId = async (\n        opportunityId: string,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = LsqPriorityUpdationModel.query(\"opportunityId\")\n            .eq(opportunityId)\n            .using(\"opportunityIdIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as LsqPriorityUpdation[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Fetches one queue record by `leadNumber` (GSI `leadNumberIndex`).\n     *\n     * @example\n     * const row = await lsqPriorityUpdationDao.getByLeadNumber(\"9876543210\");\n     */\n    getByLeadNumber = async (leadNumber: string): Promise<LsqPriorityUpdation | null> => {\n        const result = await this.listByLeadNumber(leadNumber, 1);\n        return result.items[0] ?? null;\n    };\n\n    /**\n     * Lists queue records by `leadNumber` (GSI `leadNumberIndex`).\n     *\n     * @example\n     * const { items } = await lsqPriorityUpdationDao.listByLeadNumber(\"9876543210\");\n     */\n    listByLeadNumber = async (\n        leadNumber: string,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = LsqPriorityUpdationModel.query(\"leadNumber\")\n            .eq(leadNumber)\n            .using(\"leadNumberIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as LsqPriorityUpdation[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Lists queue records by `status` (GSI `statusIndex`).\n     *\n     * @example\n     * const { items } = await lsqPriorityUpdationDao.listByStatus(\"PENDING\", 25);\n     */\n    listByStatus = async (\n        status: string,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = LsqPriorityUpdationModel.query(\"status\")\n            .eq(status)\n            .using(\"statusIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as LsqPriorityUpdation[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Lists queued (unprocessed) opportunities sorted by `priorityRank` ascending.\n     *\n     * Use when: worker pulls next batch of unassigned LSQ priority updates.\n     * Queries GSI `passedStrIndex` with `passedStr = \"FALSE\"`.\n     *\n     * @example\n     * const { items, nextToken } = await lsqPriorityUpdationDao.listUnprocessed(25);\n     */\n    listUnprocessed = async (limit?: number, token?: string): Promise<ListResult> =>\n        this.listByPassedStr(LSQ_PASSED_STR.FALSE, limit, token);\n\n    /**\n     * Lists opportunities by `passedStr` (GSI `passedStrIndex`), sorted by `priorityRank`.\n     *\n     * @example\n     * const queued = await lsqPriorityUpdationDao.listByPassedStr(\"FALSE\", 25);\n     */\n    listByPassedStr = async (\n        passedStr: LsqPassedStr,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = LsqPriorityUpdationModel.query(\"passedStr\")\n            .eq(passedStr)\n            .using(\"passedStrIndex\")\n            .sort(\"ascending\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as LsqPriorityUpdation[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Marks a queue row as processed by deleting it via primary key.\n     *\n     * Use when: worker successfully applied priority update in LeadSquared.\n     *\n     * @example\n     * await lsqPriorityUpdationDao.markProcessed(\"lsq-uuid\");\n     */\n    markProcessed = async (lsqPriorityUpdationId: string): Promise<void> => {\n        await this.delete(lsqPriorityUpdationId);\n    };\n\n    /**\n     * Marks processed by LeadSquared `opportunityId` (lookup GSI, then delete by PK).\n     *\n     * @example\n     * await lsqPriorityUpdationDao.markProcessedByOpportunityId(\"opp-123\");\n     */\n    markProcessedByOpportunityId = async (opportunityId: string): Promise<boolean> => {\n        const row = await this.getByOpportunityId(opportunityId);\n        if (!row) {\n            return false;\n        }\n        await this.delete(row.lsqPriorityUpdationId);\n        return true;\n    };\n\n    /**\n     * Deletes one queue record by primary key.\n     */\n    deleteById = async (lsqPriorityUpdationId: string): Promise<void> => {\n        await this.delete(lsqPriorityUpdationId);\n    };\n}\n\nexport const lsqPriorityUpdationDao = new LsqPriorityUpdationDao();\n"]}