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

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

@@ -0,0 +1,72 @@
+import { GenericDynamooseDAO } from "../../base-dynamoose-dao";
+import { AuthContext } from "../../base-dynamoose-model";
+import { CreateItemsBundleInput, ItemBundleUsageType, ItemsBundle } from "./items-bundle-model";
+type ListResult = {
+    items: ItemsBundle[];
+    nextToken?: string;
+};
+/**
+ * DAO for item bundles (add-on / replacement groupings).
+ *
+ * Table keys: `bundleId` (PK).
+ * Lookups:
+ * - `usageTypeIndex` → bundles by ADDON / REPLACEMENT
+ * - `bundleTypeIndex` → bundles by `bundleType`
+ */
+declare class ItemsBundleDao extends GenericDynamooseDAO<ItemsBundle> {
+    constructor();
+    /**
+     * 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"
+     * });
+     */
+    save: (item: CreateItemsBundleInput, authContext?: AuthContext) => Promise<ItemsBundle>;
+    /**
+     * Updates one item-bundle by `bundleId`.
+     *
+     * Use when: renaming a bundle or changing ADDON ↔ REPLACEMENT usage.
+     *
+     * @example
+     * await itemsBundleDao.update("bundle-uuid", { usageType: "REPLACEMENT" });
+     */
+    update: (bundleId: string, updates: Partial<ItemsBundle>, authContext?: AuthContext) => Promise<ItemsBundle>;
+    /**
+     * Fetches one item-bundle by primary key.
+     *
+     * @example
+     * const bundle = await itemsBundleDao.getById("bundle-uuid");
+     */
+    getById: (bundleId: string) => Promise<ItemsBundle | null>;
+    /**
+     * 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);
+     */
+    listByUsageType: (usageType: ItemBundleUsageType, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Lists bundles by `bundleType` (GSI `bundleTypeIndex`).
+     *
+     * @example
+     * const starters = await itemsBundleDao.listByBundleType("STARTERS", 20);
+     */
+    listByBundleType: (bundleType: string, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Deletes one item-bundle by primary key.
+     */
+    deleteById: (bundleId: string) => Promise<void>;
+}
+export declare const itemsBundleDao: ItemsBundleDao;
+export {};

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXRlbXMtYnVuZGxlLW1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2N1c3RvbWVyLXVzZXIvaXRlbXMtYnVuZGxlL2l0ZW1zLWJ1bmRsZS1tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSwwREFBa0M7QUFDbEMsbUNBQW9DO0FBQ3BDLHFFQUE2RjtBQUM3RiwwREFBdUQ7QUFFdkQ7Ozs7R0FJRztBQUNVLFFBQUEsc0JBQXNCLEdBQUc7SUFDbEMsS0FBSyxFQUFFLE9BQU87SUFDZCxXQUFXLEVBQUUsYUFBYTtDQUNwQixDQUFDO0FBaUJYLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxtQkFBUyxDQUFDLE1BQU0sQ0FDMUM7SUFDSSxRQUFRLEVBQUU7UUFDTixJQUFJLEVBQUUsTUFBTTtRQUNaLE9BQU8sRUFBRSxJQUFJO1FBQ2IsUUFBUSxFQUFFLElBQUk7UUFDZCxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBQSxtQkFBVSxHQUFFO0tBQzlCO0lBQ0QsVUFBVSxFQUFFO1FBQ1IsSUFBSSxFQUFFLE1BQU07UUFDWixRQUFRLEVBQUUsSUFBSTtRQUNkLEtBQUssRUFBRTtZQUNILElBQUksRUFBRSxpQkFBaUI7WUFDdkIsSUFBSSxFQUFFLFFBQVE7U0FDakI7S0FDSjtJQUNELFVBQVUsRUFBRTtRQUNSLElBQUksRUFBRSxNQUFNO1FBQ1osUUFBUSxFQUFFLElBQUk7S0FDakI7SUFDRCxXQUFXLEVBQUU7UUFDVCxJQUFJLEVBQUUsTUFBTTtRQUNaLFFBQVEsRUFBRSxLQUFLO0tBQ2xCO0lBQ0QsU0FBUyxFQUFFO1FBQ1AsSUFBSSxFQUFFLE1BQU07UUFDWixRQUFRLEVBQUUsSUFBSTtRQUNkLElBQUksRUFBRSxDQUFDLDhCQUFzQixDQUFDLEtBQUssRUFBRSw4QkFBc0IsQ0FBQyxXQUFXLENBQUM7UUFDeEUsS0FBSyxFQUFFO1lBQ0gsSUFBSSxFQUFFLGdCQUFnQjtZQUN0QixJQUFJLEVBQUUsUUFBUTtTQUNqQjtLQUNKO0lBQ0QsR0FBRyxrREFBMkI7Q0FDakMsRUFDRDtJQUNJLFdBQVcsRUFBRSxLQUFLO0lBQ2xCLFVBQVUsRUFBRSxJQUFJO0NBQ25CLENBQ0osQ0FBQztBQUVXLFFBQUEsZ0JBQWdCLEdBQUcsbUJBQVMsQ0FBQyxLQUFLLENBQzNDLHlCQUFXLENBQUMsWUFBWSxFQUN4QixpQkFBaUIsRUFDakIsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLGFBQWEsRUFBRSxLQUFLLEVBQUUsQ0FDMUMsQ0FBQztBQUVLLE1BQU0seUJBQXlCLEdBQUcsQ0FBQyxLQUEyQyxFQUFFLEVBQUU7SUFDckYsT0FBTyxJQUFJLHdCQUFnQixDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ3ZDLENBQUMsQ0FBQztBQUZXLFFBQUEseUJBQXlCLDZCQUVwQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBkeW5hbW9vc2UgZnJvbSBcImR5bmFtb29zZVwiO1xuaW1wb3J0IHsgcmFuZG9tVVVJRCB9IGZyb20gXCJjcnlwdG9cIjtcbmltcG9ydCB7IEJBU0VfRFlOQU1PT1NFX0FVRElUX1NDSEVNQSwgQmFzZUR5bmFtb29zZU1vZGVsIH0gZnJvbSBcIi4uLy4uL2Jhc2UtZHluYW1vb3NlLW1vZGVsXCI7XG5pbXBvcnQgeyBUQUJMRV9OQU1FUyB9IGZyb20gXCIuLi8uLi9jb25maWcvdGFibGUtbmFtZXNcIjtcblxuLyoqXG4gKiBEZWNpZGVzIGhvdyB0aGUgYnVuZGxlIGlzIGFwcGxpZWQgb24gYSBwbGF0dGVyIGl0ZW0uXG4gKiAtIEFERE9OIOKGkiBleHRyYSBpdGVtcyBhZGRlZCBvbiB0b3Agb2YgdGhlIHBsYXR0ZXJcbiAqIC0gUkVQTEFDRU1FTlQg4oaSIHN3YXBzIGFuIGV4aXN0aW5nIHBsYXR0ZXIgaXRlbVxuICovXG5leHBvcnQgY29uc3QgSVRFTV9CVU5ETEVfVVNBR0VfVFlQRSA9IHtcbiAgICBBRERPTjogXCJBRERPTlwiLFxuICAgIFJFUExBQ0VNRU5UOiBcIlJFUExBQ0VNRU5UXCJcbn0gYXMgY29uc3Q7XG5cbmV4cG9ydCB0eXBlIEl0ZW1CdW5kbGVVc2FnZVR5cGUgPVxuICAgICh0eXBlb2YgSVRFTV9CVU5ETEVfVVNBR0VfVFlQRSlba2V5b2YgdHlwZW9mIElURU1fQlVORExFX1VTQUdFX1RZUEVdO1xuXG5leHBvcnQgaW50ZXJmYWNlIEl0ZW1zQnVuZGxlIGV4dGVuZHMgQmFzZUR5bmFtb29zZU1vZGVsIHtcbiAgICBidW5kbGVJZDogc3RyaW5nO1xuICAgIGJ1bmRsZVR5cGU6IHN0cmluZztcbiAgICBidW5kbGVOYW1lOiBzdHJpbmc7XG4gICAgdXNhZ2VUeXBlOiBJdGVtQnVuZGxlVXNhZ2VUeXBlO1xuICAgIGJ1bmRsZU9yZGVyPzogbnVtYmVyO1xufVxuXG5leHBvcnQgdHlwZSBDcmVhdGVJdGVtc0J1bmRsZUlucHV0ID0gT21pdDxJdGVtc0J1bmRsZSwgXCJidW5kbGVJZFwiPiAmIHtcbiAgICBidW5kbGVJZD86IHN0cmluZztcbn07XG5cbmNvbnN0IGl0ZW1zQnVuZGxlU2NoZW1hID0gbmV3IGR5bmFtb29zZS5TY2hlbWEoXG4gICAge1xuICAgICAgICBidW5kbGVJZDoge1xuICAgICAgICAgICAgdHlwZTogU3RyaW5nLFxuICAgICAgICAgICAgaGFzaEtleTogdHJ1ZSxcbiAgICAgICAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgICAgICAgICAgZGVmYXVsdDogKCkgPT4gcmFuZG9tVVVJRCgpXG4gICAgICAgIH0sXG4gICAgICAgIGJ1bmRsZVR5cGU6IHtcbiAgICAgICAgICAgIHR5cGU6IFN0cmluZyxcbiAgICAgICAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgICAgICAgICAgaW5kZXg6IHtcbiAgICAgICAgICAgICAgICBuYW1lOiBcImJ1bmRsZVR5cGVJbmRleFwiLFxuICAgICAgICAgICAgICAgIHR5cGU6IFwiZ2xvYmFsXCJcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSxcbiAgICAgICAgYnVuZGxlTmFtZToge1xuICAgICAgICAgICAgdHlwZTogU3RyaW5nLFxuICAgICAgICAgICAgcmVxdWlyZWQ6IHRydWVcbiAgICAgICAgfSxcbiAgICAgICAgYnVuZGxlT3JkZXI6IHtcbiAgICAgICAgICAgIHR5cGU6IE51bWJlcixcbiAgICAgICAgICAgIHJlcXVpcmVkOiBmYWxzZVxuICAgICAgICB9LFxuICAgICAgICB1c2FnZVR5cGU6IHtcbiAgICAgICAgICAgIHR5cGU6IFN0cmluZyxcbiAgICAgICAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgICAgICAgICAgZW51bTogW0lURU1fQlVORExFX1VTQUdFX1RZUEUuQURET04sIElURU1fQlVORExFX1VTQUdFX1RZUEUuUkVQTEFDRU1FTlRdLFxuICAgICAgICAgICAgaW5kZXg6IHtcbiAgICAgICAgICAgICAgICBuYW1lOiBcInVzYWdlVHlwZUluZGV4XCIsXG4gICAgICAgICAgICAgICAgdHlwZTogXCJnbG9iYWxcIlxuICAgICAgICAgICAgfVxuICAgICAgICB9LFxuICAgICAgICAuLi5CQVNFX0RZTkFNT09TRV9BVURJVF9TQ0hFTUFcbiAgICB9LFxuICAgIHtcbiAgICAgICAgc2F2ZVVua25vd246IGZhbHNlLFxuICAgICAgICB0aW1lc3RhbXBzOiB0cnVlXG4gICAgfVxuKTtcblxuZXhwb3J0IGNvbnN0IEl0ZW1zQnVuZGxlTW9kZWwgPSBkeW5hbW9vc2UubW9kZWw8SXRlbXNCdW5kbGU+KFxuICAgIFRBQkxFX05BTUVTLklURU1TX0JVTkRMRSxcbiAgICBpdGVtc0J1bmRsZVNjaGVtYSxcbiAgICB7IGNyZWF0ZTogZmFsc2UsIHdhaXRGb3JBY3RpdmU6IGZhbHNlIH1cbik7XG5cbmV4cG9ydCBjb25zdCBjb252ZXJ0VG9JdGVtc0J1bmRsZU1vZGVsID0gKGlucHV0OiBDcmVhdGVJdGVtc0J1bmRsZUlucHV0IHwgSXRlbXNCdW5kbGUpID0+IHtcbiAgICByZXR1cm4gbmV3IEl0ZW1zQnVuZGxlTW9kZWwoaW5wdXQpO1xufTtcbiJdfQ==

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 {};