cmp-aws-database 2.4.1 → 2.6.0

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

@@ -0,0 +1,118 @@
+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`
+ * - `passedStrIndex` → unprocessed queue (`passedStr` + `priorityRank`)
+ * Processed rows are deleted from the table (not soft-flagged).
+ */
+declare class LsqPriorityUpdationDao extends GenericDynamooseDAO<LsqPriorityUpdation> {
+    constructor();
+    private nowIso;
+    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).
+     * - Stamps `createdAt` / `updatedAt` as ISO timestamps when omitted.
+     *
+     * @example
+     * await lsqPriorityUpdationDao.save({
+     *     opportunityId: "opp-123",
+     *     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>;
+    /**
+     * 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,200 @@
+"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`
+ * - `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.nowIso = () => new Date().toISOString();
+        this.normalizeInput = (item, existingCreatedAt) => {
+            const now = this.nowIso();
+            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 ?? (0, lsq_priority_updation_model_1.toPriorityRank)(priority),
+                createdAt: item.createdAt ?? existingCreatedAt ?? now,
+                updatedAt: item.updatedAt ?? now
+            };
+        };
+        /**
+         * 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).
+         * - Stamps `createdAt` / `updatedAt` as ISO timestamps when omitted.
+         *
+         * @example
+         * await lsqPriorityUpdationDao.save({
+         *     opportunityId: "opp-123",
+         *     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,
+                updatedAt: updates.updatedAt ?? this.nowIso(),
+                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)
+            };
+        };
+        /**
+         * 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 * - `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 nowIso = (): string => new Date().toISOString();\n\n    private normalizeInput = (\n        item: CreateLsqPriorityUpdationInput,\n        existingCreatedAt?: string\n    ): LsqPriorityUpdation => {\n        const now = this.nowIso();\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 ?? toPriorityRank(priority),\n            createdAt: item.createdAt ?? existingCreatedAt ?? now,\n            updatedAt: item.updatedAt ?? now\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     * - Stamps `createdAt` / `updatedAt` as ISO timestamps when omitted.\n     *\n     * @example\n     * await lsqPriorityUpdationDao.save({\n     *     opportunityId: \"opp-123\",\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            updatedAt: updates.updatedAt ?? this.nowIso(),\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     * 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"]}

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

@@ -0,0 +1,64 @@
+import { BaseDynamooseModel } from "../../base-dynamoose-model";
+export declare const LSQ_PRIORITY: {
+    readonly P1: "P1";
+    readonly P2: "P2";
+    readonly P3: "P3";
+    readonly P4: "P4";
+    readonly P5: "P5";
+};
+export type LsqPriority = (typeof LSQ_PRIORITY)[keyof typeof LSQ_PRIORITY];
+export declare const LSQ_PRIORITY_RANK: Record<LsqPriority, number>;
+export declare const LSQ_URGENCY: {
+    readonly U1: "U1";
+    readonly U2: "U2";
+    readonly U3: "U3";
+    readonly U4: "U4";
+};
+export type LsqUrgency = (typeof LSQ_URGENCY)[keyof typeof LSQ_URGENCY];
+export declare const LSQ_VALUE: {
+    readonly V1: "V1";
+    readonly V2: "V2";
+    readonly V3: "V3";
+    readonly V4: "V4";
+    readonly V5: "V5";
+};
+export type LsqValue = (typeof LSQ_VALUE)[keyof typeof LSQ_VALUE];
+/** GSI partition values for `passedStrIndex`. */
+export declare const LSQ_PASSED_STR: {
+    readonly FALSE: "FALSE";
+    readonly TRUE: "TRUE";
+};
+export type LsqPassedStr = (typeof LSQ_PASSED_STR)[keyof typeof LSQ_PASSED_STR];
+export interface LsqPriorityUpdation extends BaseDynamooseModel {
+    /** Table unique id (PK). */
+    lsqPriorityUpdationId: string;
+    /** LeadSquared opportunity id (GSI `opportunityIdIndex`). */
+    opportunityId: string;
+    passed: boolean;
+    /** Indexed mirror of `passed` — `"FALSE"` when queued/unassigned. */
+    passedStr: LsqPassedStr;
+    priority: LsqPriority;
+    /** Numeric sort score for GSI: P1→1 … P5→5. */
+    priorityRank: number;
+    urgency: LsqUrgency;
+    value: LsqValue;
+    /** ISO date `YYYY-MM-DD` for midnight recalculation. */
+    eventDate: string;
+    /** ISO timestamp when webhook first received the opportunity. */
+    createdAt: string;
+    /** ISO timestamp when record was last updated. */
+    updatedAt: string;
+    /** Optional raw webhook payload. */
+    payload?: Record<string, unknown>;
+}
+export type CreateLsqPriorityUpdationInput = Omit<LsqPriorityUpdation, "lsqPriorityUpdationId" | "passedStr" | "priorityRank" | "createdAt" | "updatedAt"> & {
+    lsqPriorityUpdationId?: string;
+    passedStr?: LsqPassedStr;
+    priorityRank?: number;
+    createdAt?: string;
+    updatedAt?: string;
+};
+export declare const toPassedStr: (passed: boolean) => LsqPassedStr;
+export declare const toPriorityRank: (priority: LsqPriority) => number;
+export declare const LsqPriorityUpdationModel: import("dynamoose/dist/General").ModelType<LsqPriorityUpdation>;
+export declare const convertToLsqPriorityUpdationModel: (input: CreateLsqPriorityUpdationInput | LsqPriorityUpdation) => LsqPriorityUpdation;

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

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToLsqPriorityUpdationModel = exports.LsqPriorityUpdationModel = exports.toPriorityRank = exports.toPassedStr = exports.LSQ_PASSED_STR = exports.LSQ_VALUE = exports.LSQ_URGENCY = exports.LSQ_PRIORITY_RANK = exports.LSQ_PRIORITY = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const crypto_1 = require("crypto");
+const table_names_1 = require("../../config/table-names");
+exports.LSQ_PRIORITY = {
+    P1: "P1",
+    P2: "P2",
+    P3: "P3",
+    P4: "P4",
+    P5: "P5"
+};
+exports.LSQ_PRIORITY_RANK = {
+    [exports.LSQ_PRIORITY.P1]: 1,
+    [exports.LSQ_PRIORITY.P2]: 2,
+    [exports.LSQ_PRIORITY.P3]: 3,
+    [exports.LSQ_PRIORITY.P4]: 4,
+    [exports.LSQ_PRIORITY.P5]: 5
+};
+exports.LSQ_URGENCY = {
+    U1: "U1",
+    U2: "U2",
+    U3: "U3",
+    U4: "U4"
+};
+exports.LSQ_VALUE = {
+    V1: "V1",
+    V2: "V2",
+    V3: "V3",
+    V4: "V4",
+    V5: "V5"
+};
+/** GSI partition values for `passedStrIndex`. */
+exports.LSQ_PASSED_STR = {
+    FALSE: "FALSE",
+    TRUE: "TRUE"
+};
+const toPassedStr = (passed) => passed ? exports.LSQ_PASSED_STR.TRUE : exports.LSQ_PASSED_STR.FALSE;
+exports.toPassedStr = toPassedStr;
+const toPriorityRank = (priority) => exports.LSQ_PRIORITY_RANK[priority];
+exports.toPriorityRank = toPriorityRank;
+const lsqPriorityUpdationSchema = new dynamoose_1.default.Schema({
+    lsqPriorityUpdationId: {
+        type: String,
+        hashKey: true,
+        required: true,
+        default: () => (0, crypto_1.randomUUID)()
+    },
+    opportunityId: {
+        type: String,
+        required: true,
+        index: {
+            name: "opportunityIdIndex",
+            type: "global"
+        }
+    },
+    passed: {
+        type: Boolean,
+        required: true,
+        default: false
+    },
+    passedStr: {
+        type: String,
+        required: true,
+        enum: [exports.LSQ_PASSED_STR.FALSE, exports.LSQ_PASSED_STR.TRUE],
+        default: exports.LSQ_PASSED_STR.FALSE,
+        index: {
+            name: "passedStrIndex",
+            type: "global",
+            rangeKey: "priorityRank"
+        }
+    },
+    priority: {
+        type: String,
+        required: true,
+        enum: [
+            exports.LSQ_PRIORITY.P1,
+            exports.LSQ_PRIORITY.P2,
+            exports.LSQ_PRIORITY.P3,
+            exports.LSQ_PRIORITY.P4,
+            exports.LSQ_PRIORITY.P5
+        ]
+    },
+    priorityRank: {
+        type: Number,
+    },
+    urgency: {
+        type: String,
+        enum: [exports.LSQ_URGENCY.U1, exports.LSQ_URGENCY.U2, exports.LSQ_URGENCY.U3, exports.LSQ_URGENCY.U4]
+    },
+    value: {
+        type: String,
+        enum: [exports.LSQ_VALUE.V1, exports.LSQ_VALUE.V2, exports.LSQ_VALUE.V3, exports.LSQ_VALUE.V4, exports.LSQ_VALUE.V5]
+    },
+    eventDate: {
+        type: String,
+        required: true
+    },
+    createdAt: {
+        type: String,
+        required: true
+    },
+    updatedAt: {
+        type: String,
+        required: true
+    },
+    payload: {
+        type: Object
+    }
+}, {
+    saveUnknown: ["payload.**"],
+    timestamps: false
+});
+exports.LsqPriorityUpdationModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.LSQ_PRIORITY_UPDATION, lsqPriorityUpdationSchema, { create: false, waitForActive: false });
+const convertToLsqPriorityUpdationModel = (input) => {
+    return new exports.LsqPriorityUpdationModel(input);
+};
+exports.convertToLsqPriorityUpdationModel = convertToLsqPriorityUpdationModel;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lsq-priority-updation-model.js","sourceRoot":"","sources":["../../../src/customer-user/lsq-priority-updation/lsq-priority-updation-model.ts"],"names":[],"mappings":";;;;;;AAAA,0DAAkC;AAClC,mCAAoC;AAEpC,0DAAuD;AAE1C,QAAA,YAAY,GAAG;IACxB,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;CACF,CAAC;AAIE,QAAA,iBAAiB,GAAgC;IAC1D,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,CAAC;IACpB,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,CAAC;IACpB,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,CAAC;IACpB,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,CAAC;IACpB,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,CAAC;CACvB,CAAC;AAEW,QAAA,WAAW,GAAG;IACvB,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;CACF,CAAC;AAIE,QAAA,SAAS,GAAG;IACrB,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;CACF,CAAC;AAIX,iDAAiD;AACpC,QAAA,cAAc,GAAG;IAC1B,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;CACN,CAAC;AAsCJ,MAAM,WAAW,GAAG,CAAC,MAAe,EAAgB,EAAE,CACzD,MAAM,CAAC,CAAC,CAAC,sBAAc,CAAC,IAAI,CAAC,CAAC,CAAC,sBAAc,CAAC,KAAK,CAAC;AAD3C,QAAA,WAAW,eACgC;AAEjD,MAAM,cAAc,GAAG,CAAC,QAAqB,EAAU,EAAE,CAAC,yBAAiB,CAAC,QAAQ,CAAC,CAAC;AAAhF,QAAA,cAAc,kBAAkE;AAE7F,MAAM,yBAAyB,GAAG,IAAI,mBAAS,CAAC,MAAM,CAClD;IACI,qBAAqB,EAAE;QACnB,IAAI,EAAE,MAAM;QACZ,OAAO,EAAE,IAAI;QACb,QAAQ,EAAE,IAAI;QACd,OAAO,EAAE,GAAG,EAAE,CAAC,IAAA,mBAAU,GAAE;KAC9B;IACD,aAAa,EAAE;QACX,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,IAAI;QACd,KAAK,EAAE;YACH,IAAI,EAAE,oBAAoB;YAC1B,IAAI,EAAE,QAAQ;SACjB;KACJ;IACD,MAAM,EAAE;QACJ,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,IAAI;QACd,OAAO,EAAE,KAAK;KACjB;IACD,SAAS,EAAE;QACP,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,IAAI;QACd,IAAI,EAAE,CAAC,sBAAc,CAAC,KAAK,EAAE,sBAAc,CAAC,IAAI,CAAC;QACjD,OAAO,EAAE,sBAAc,CAAC,KAAK;QAC7B,KAAK,EAAE;YACH,IAAI,EAAE,gBAAgB;YACtB,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,cAAc;SAC3B;KACJ;IACD,QAAQ,EAAE;QACN,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,IAAI;QACd,IAAI,EAAE;YACF,oBAAY,CAAC,EAAE;YACf,oBAAY,CAAC,EAAE;YACf,oBAAY,CAAC,EAAE;YACf,oBAAY,CAAC,EAAE;YACf,oBAAY,CAAC,EAAE;SAClB;KACJ;IACD,YAAY,EAAE;QACV,IAAI,EAAE,MAAM;KACf;IACD,OAAO,EAAE;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,CAAC,mBAAW,CAAC,EAAE,EAAE,mBAAW,CAAC,EAAE,EAAE,mBAAW,CAAC,EAAE,EAAE,mBAAW,CAAC,EAAE,CAAC;KACzE;IACD,KAAK,EAAE;QACH,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,CAAC,iBAAS,CAAC,EAAE,EAAE,iBAAS,CAAC,EAAE,EAAE,iBAAS,CAAC,EAAE,EAAE,iBAAS,CAAC,EAAE,EAAE,iBAAS,CAAC,EAAE,CAAC;KAC/E;IACD,SAAS,EAAE;QACP,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,IAAI;KACjB;IACD,SAAS,EAAE;QACP,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,IAAI;KACjB;IACD,SAAS,EAAE;QACP,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,IAAI;KACjB;IACD,OAAO,EAAE;QACL,IAAI,EAAE,MAAM;KACf;CACJ,EACD;IACI,WAAW,EAAE,CAAC,YAAY,CAAC;IAC3B,UAAU,EAAE,KAAK;CACpB,CACJ,CAAC;AAEW,QAAA,wBAAwB,GAAG,mBAAS,CAAC,KAAK,CACnD,yBAAW,CAAC,qBAAqB,EACjC,yBAAyB,EACzB,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,CAC1C,CAAC;AAEK,MAAM,iCAAiC,GAAG,CAC7C,KAA2D,EAC7D,EAAE;IACA,OAAO,IAAI,gCAAwB,CAAC,KAAK,CAAC,CAAC;AAC/C,CAAC,CAAC;AAJW,QAAA,iCAAiC,qCAI5C","sourcesContent":["import dynamoose from \"dynamoose\";\nimport { randomUUID } from \"crypto\";\nimport { BaseDynamooseModel } from \"../../base-dynamoose-model\";\nimport { TABLE_NAMES } from \"../../config/table-names\";\n\nexport const LSQ_PRIORITY = {\n    P1: \"P1\",\n    P2: \"P2\",\n    P3: \"P3\",\n    P4: \"P4\",\n    P5: \"P5\"\n} as const;\n\nexport type LsqPriority = (typeof LSQ_PRIORITY)[keyof typeof LSQ_PRIORITY];\n\nexport const LSQ_PRIORITY_RANK: Record<LsqPriority, number> = {\n    [LSQ_PRIORITY.P1]: 1,\n    [LSQ_PRIORITY.P2]: 2,\n    [LSQ_PRIORITY.P3]: 3,\n    [LSQ_PRIORITY.P4]: 4,\n    [LSQ_PRIORITY.P5]: 5\n};\n\nexport const LSQ_URGENCY = {\n    U1: \"U1\",\n    U2: \"U2\",\n    U3: \"U3\",\n    U4: \"U4\"\n} as const;\n\nexport type LsqUrgency = (typeof LSQ_URGENCY)[keyof typeof LSQ_URGENCY];\n\nexport const LSQ_VALUE = {\n    V1: \"V1\",\n    V2: \"V2\",\n    V3: \"V3\",\n    V4: \"V4\",\n    V5: \"V5\"\n} as const;\n\nexport type LsqValue = (typeof LSQ_VALUE)[keyof typeof LSQ_VALUE];\n\n/** GSI partition values for `passedStrIndex`. */\nexport const LSQ_PASSED_STR = {\n    FALSE: \"FALSE\",\n    TRUE: \"TRUE\"\n} as const;\n\nexport type LsqPassedStr = (typeof LSQ_PASSED_STR)[keyof typeof LSQ_PASSED_STR];\n\nexport interface LsqPriorityUpdation extends BaseDynamooseModel {\n    /** Table unique id (PK). */\n    lsqPriorityUpdationId: string;\n    /** LeadSquared opportunity id (GSI `opportunityIdIndex`). */\n    opportunityId: string;\n    passed: boolean;\n    /** Indexed mirror of `passed` — `\"FALSE\"` when queued/unassigned. */\n    passedStr: LsqPassedStr;\n    priority: LsqPriority;\n    /** Numeric sort score for GSI: P1→1 … P5→5. */\n    priorityRank: number;\n    urgency: LsqUrgency;\n    value: LsqValue;\n    /** ISO date `YYYY-MM-DD` for midnight recalculation. */\n    eventDate: string;\n    /** ISO timestamp when webhook first received the opportunity. */\n    createdAt: string;\n    /** ISO timestamp when record was last updated. */\n    updatedAt: string;\n    /** Optional raw webhook payload. */\n    payload?: Record<string, unknown>;\n}\n\nexport type CreateLsqPriorityUpdationInput = Omit<\n    LsqPriorityUpdation,\n    \"lsqPriorityUpdationId\" | \"passedStr\" | \"priorityRank\" | \"createdAt\" | \"updatedAt\"\n> & {\n    lsqPriorityUpdationId?: string;\n    passedStr?: LsqPassedStr;\n    priorityRank?: number;\n    createdAt?: string;\n    updatedAt?: string;\n};\n\nexport const toPassedStr = (passed: boolean): LsqPassedStr =>\n    passed ? LSQ_PASSED_STR.TRUE : LSQ_PASSED_STR.FALSE;\n\nexport const toPriorityRank = (priority: LsqPriority): number => LSQ_PRIORITY_RANK[priority];\n\nconst lsqPriorityUpdationSchema = new dynamoose.Schema(\n    {\n        lsqPriorityUpdationId: {\n            type: String,\n            hashKey: true,\n            required: true,\n            default: () => randomUUID()\n        },\n        opportunityId: {\n            type: String,\n            required: true,\n            index: {\n                name: \"opportunityIdIndex\",\n                type: \"global\"\n            }\n        },\n        passed: {\n            type: Boolean,\n            required: true,\n            default: false\n        },\n        passedStr: {\n            type: String,\n            required: true,\n            enum: [LSQ_PASSED_STR.FALSE, LSQ_PASSED_STR.TRUE],\n            default: LSQ_PASSED_STR.FALSE,\n            index: {\n                name: \"passedStrIndex\",\n                type: \"global\",\n                rangeKey: \"priorityRank\"\n            }\n        },\n        priority: {\n            type: String,\n            required: true,\n            enum: [\n                LSQ_PRIORITY.P1,\n                LSQ_PRIORITY.P2,\n                LSQ_PRIORITY.P3,\n                LSQ_PRIORITY.P4,\n                LSQ_PRIORITY.P5\n            ]\n        },\n        priorityRank: {\n            type: Number,\n        },\n        urgency: {\n            type: String,\n            enum: [LSQ_URGENCY.U1, LSQ_URGENCY.U2, LSQ_URGENCY.U3, LSQ_URGENCY.U4]\n        },\n        value: {\n            type: String,\n            enum: [LSQ_VALUE.V1, LSQ_VALUE.V2, LSQ_VALUE.V3, LSQ_VALUE.V4, LSQ_VALUE.V5]\n        },\n        eventDate: {\n            type: String,\n            required: true\n        },\n        createdAt: {\n            type: String,\n            required: true\n        },\n        updatedAt: {\n            type: String,\n            required: true\n        },\n        payload: {\n            type: Object\n        }\n    },\n    {\n        saveUnknown: [\"payload.**\"],\n        timestamps: false\n    }\n);\n\nexport const LsqPriorityUpdationModel = dynamoose.model<LsqPriorityUpdation>(\n    TABLE_NAMES.LSQ_PRIORITY_UPDATION,\n    lsqPriorityUpdationSchema,\n    { create: false, waitForActive: false }\n);\n\nexport const convertToLsqPriorityUpdationModel = (\n    input: CreateLsqPriorityUpdationInput | LsqPriorityUpdation\n) => {\n    return new LsqPriorityUpdationModel(input);\n};\n"]}

package/dist/customer-user/order-module/plate-order/plate-order-model.d.ts

@@ -69,8 +69,15 @@ export declare class PlateModel extends BaseModel {
     totalSkewerAddonsCost?: number;
     skewerAddons?: SkewerAddonsOnOrder[];
     defaultValue: IsDefaultValue;
-    isOnionGarlicSelected?: boolean;
-    alternatePhoneNumber?: string;
+    setPreferences?: SetPreferences;
+    bundleId?: string;
+}
+export declare class SetPreferences {
+    spicyLevel: string;
+    tellUsMore: string;
+    noOnionGarlicCharge: number;
+    isOnionGarlicSelected: boolean;
+    alternatePhoneNumber: string;
 }
 export declare class IsDefaultValue {
     isdefaultEventTime: boolean;