cmp-aws-database 2.1.2-dev.20 → 2.1.2-dev.21

package/dist/customer-user/{brows-history/brows-history-dao.d.ts → browse-history/browse-history-dao.d.ts}

@@ -1,6 +1,6 @@
 import { GenericDynamooseDAO } from "../../base-dynamoose-dao";
 import { AuthContext } from "../../base-dynamoose-model";
-import { BrowseHistory, CreateBrowseHistoryInput } from "./brows-history-model";
+import { BrowseHistory, CreateBrowseHistoryInput } from "./browse-history-model";
 type ListResult = {
     items: BrowseHistory[];
     nextToken?: string;

package/dist/customer-user/browse-history/browse-history-dao.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browsHistoryDao = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const base_dynamoose_dao_1 = require("../../base-dynamoose-dao");
+const browse_history_model_1 = require("./browse-history-model");
+/**
+ * DAO for user platter browse history.
+ *
+ * Table keys: `browsHistoryId` (PK).
+ * User lookup: query GSI `userIdIndex` by `userId`.
+ */
+class BrowsHistoryDao extends base_dynamoose_dao_1.GenericDynamooseDAO {
+    constructor() {
+        super(browse_history_model_1.BrowseHistoryModel, "browseHistoryId");
+        /**
+         * Creates one browse-history record.
+         *
+         * Use when: user views a platter and you want to persist that browse event.
+         * - `browsHistoryId` auto-generates if omitted.
+         * - `userId` is required for later `getByUserId` / `listByUserId` lookups.
+         * - Stamps `created_time` / `created_user` automatically.
+         *
+         * @example
+         * await browsHistoryDao.save({
+         *     userId: "user-123",
+         *     platterId: "platter-abc",
+         *     platterName: "Birthday Feast",
+         *     platterType: "CATERING",
+         *     platterPrice: 4999,
+         *     totalItems: 12,
+         *     menuType: "VEG",
+         *     mealTime: "Dinner",
+         *     platterImage: "https://...",
+         *     replaceItemIds: [{ originalItemId: "item-1", replaceItemId: "item-2" }],
+         *     addonIds: [],
+         *     cutleryIds: [],
+         *     liveCounterIds: [],
+         *     skewerAddonIds: []
+         * }, { userSub: "user-123" });
+         */
+        this.save = async (item, authContext) => {
+            return super.save(item, authContext);
+        };
+        /**
+         * Updates one browse-history record by `browsHistoryId`.
+         *
+         * Use when: user re-visits same platter and you need to update selections or metadata.
+         * - Fails if the record does not exist.
+         * - Stamps `updated_time` / `updated_user` automatically.
+         *
+         * @example
+         * await browsHistoryDao.update(
+         *     "brows-history-uuid",
+         *     { addonIds: ["addon-1", "addon-2"], platterPrice: 5499 },
+         *     { userSub: "user-123" }
+         * );
+         */
+        this.update = async (browseHistoryId, updates, authContext) => {
+            const updated = await browse_history_model_1.BrowseHistoryModel.update({ browseHistoryId }, {
+                ...updates,
+                updated_time: new Date(),
+                updated_user: authContext?.userSub
+            }, {
+                condition: new dynamoose_1.default.Condition().attribute("browsHistoryId").exists()
+            });
+            return updated;
+        };
+        /**
+         * Fetches one browse-history record by primary key.
+         *
+         * Use when: detail screen already has `browsHistoryId` from a previous list response.
+         * Returns `null` when record is not found.
+         *
+         * @example
+         * const item = await browsHistoryDao.getById("brows-history-uuid");
+         */
+        this.getById = async (browseHistoryId) => this.get(browseHistoryId);
+        /**
+         * Returns browse-history for a user with optional sort and limit.
+         *
+         * Use when: showing "Recently Viewed" or full browse history on home/profile screen.
+         * - Queries all pages from GSI `userIdIndex`, then sorts in memory.
+         * - Pass `sortBy` as `"created_time"` or `"updated_time"` to order results.
+         * - Default `sortOrder` is `"desc"` (newest first).
+         * - `limit` is applied after sorting so latest N items are returned correctly.
+         *
+         * @example
+         * // Latest 10 browsed platters (most recently updated first)
+         * const recent = await browsHistoryDao.getByUserId("user-123", 10, "updated_time");
+         *
+         * @example
+         * // Oldest viewed first
+         * const oldestFirst = await browsHistoryDao.getByUserId("user-123", undefined, "created_time", "asc");
+         *
+         * @example
+         * // All history without sorting (raw DynamoDB order)
+         * const all = await browsHistoryDao.getByUserId("user-123");
+         */
+        this.getByUserId = async (userId, limit, sortBy, sortOrder = "desc") => {
+            const items = [];
+            let token;
+            do {
+                const result = await this.listByUserId(userId, undefined, token);
+                items.push(...result.items);
+                token = result.nextToken;
+            } while (token);
+            const sortedItems = this.sortBrowsHistoryItems(items, sortBy, sortOrder);
+            return typeof limit === "number" ? sortedItems.slice(0, limit) : sortedItems;
+        };
+        /**
+         * Reads timestamp from audit field used for in-memory sorting.
+         */
+        this.getBrowsHistorySortTime = (item, field) => {
+            const value = item[field];
+            if (!value) {
+                return 0;
+            }
+            return value instanceof Date ? value.getTime() : new Date(value).getTime();
+        };
+        /**
+         * Sorts browse-history items by `created_time` or `updated_time`.
+         */
+        this.sortBrowsHistoryItems = (items, sortBy, sortOrder = "desc") => {
+            if (!sortBy) {
+                return items;
+            }
+            const direction = sortOrder === "asc" ? 1 : -1;
+            return [...items].sort((a, b) => (this.getBrowsHistorySortTime(a, sortBy) - this.getBrowsHistorySortTime(b, sortBy)) * direction);
+        };
+        /**
+         * Paginated query on GSI `userIdIndex`.
+         *
+         * Use when: infinite scroll / load-more UI where you pass `nextToken` from previous response.
+         * For sorted "recent N" views prefer `getByUserId` instead.
+         *
+         * @example
+         * const page1 = await browsHistoryDao.listByUserId("user-123", 20);
+         * const page2 = await browsHistoryDao.listByUserId("user-123", 20, page1.nextToken);
+         */
+        this.listByUserId = async (userId, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = browse_history_model_1.BrowseHistoryModel.query("userId").eq(userId).using("userIdIndex");
+            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 browse-history record by primary key.
+         *
+         * Use when: user clears a single item from browse history.
+         *
+         * @example
+         * await browsHistoryDao.deleteById("brows-history-uuid");
+         */
+        this.deleteById = async (browsHistoryId) => {
+            await this.delete(browsHistoryId);
+        };
+    }
+}
+exports.browsHistoryDao = new BrowsHistoryDao();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browse-history-dao.js","sourceRoot":"","sources":["../../../src/customer-user/browse-history/browse-history-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    BrowseHistory,\n    BrowseHistoryModel,\n    CreateBrowseHistoryInput\n} from \"./browse-history-model\";\n\ntype ListResult = {\n    items: BrowseHistory[];\n    nextToken?: string;\n};\n\nexport type BrowseHistorySortField = \"created_time\" | \"updated_time\";\nexport type BrowseHistorySortOrder = \"asc\" | \"desc\";\n\n/**\n * DAO for user platter browse history.\n *\n * Table keys: `browsHistoryId` (PK).\n * User lookup: query GSI `userIdIndex` by `userId`.\n */\nclass BrowsHistoryDao extends GenericDynamooseDAO<BrowseHistory> {\n    constructor() {\n        super(BrowseHistoryModel, \"browseHistoryId\");\n    }\n\n    /**\n     * Creates one browse-history record.\n     *\n     * Use when: user views a platter and you want to persist that browse event.\n     * - `browsHistoryId` auto-generates if omitted.\n     * - `userId` is required for later `getByUserId` / `listByUserId` lookups.\n     * - Stamps `created_time` / `created_user` automatically.\n     *\n     * @example\n     * await browsHistoryDao.save({\n     *     userId: \"user-123\",\n     *     platterId: \"platter-abc\",\n     *     platterName: \"Birthday Feast\",\n     *     platterType: \"CATERING\",\n     *     platterPrice: 4999,\n     *     totalItems: 12,\n     *     menuType: \"VEG\",\n     *     mealTime: \"Dinner\",\n     *     platterImage: \"https://...\",\n     *     replaceItemIds: [{ originalItemId: \"item-1\", replaceItemId: \"item-2\" }],\n     *     addonIds: [],\n     *     cutleryIds: [],\n     *     liveCounterIds: [],\n     *     skewerAddonIds: []\n     * }, { userSub: \"user-123\" });\n     */\n    save = async (item: CreateBrowseHistoryInput, authContext?: AuthContext): Promise<BrowseHistory> => {\n        return super.save(item as BrowseHistory, authContext);\n    };\n\n    /**\n     * Updates one browse-history record by `browsHistoryId`.\n     *\n     * Use when: user re-visits same platter and you need to update selections or metadata.\n     * - Fails if the record does not exist.\n     * - Stamps `updated_time` / `updated_user` automatically.\n     *\n     * @example\n     * await browsHistoryDao.update(\n     *     \"brows-history-uuid\",\n     *     { addonIds: [\"addon-1\", \"addon-2\"], platterPrice: 5499 },\n     *     { userSub: \"user-123\" }\n     * );\n     */\n    update = async (\n        browseHistoryId: string,\n        updates: Partial<BrowseHistory>,\n        authContext?: AuthContext\n    ): Promise<BrowseHistory> => {\n        const updated = await BrowseHistoryModel.update(\n            { browseHistoryId },\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            },\n            {\n                condition: new dynamoose.Condition().attribute(\"browsHistoryId\").exists()\n            }\n        );\n        return updated as unknown as BrowseHistory;\n    };\n\n    /**\n     * Fetches one browse-history record by primary key.\n     *\n     * Use when: detail screen already has `browsHistoryId` from a previous list response.\n     * Returns `null` when record is not found.\n     *\n     * @example\n     * const item = await browsHistoryDao.getById(\"brows-history-uuid\");\n     */\n    getById = async (browseHistoryId: string): Promise<BrowseHistory | null> => this.get(browseHistoryId);\n\n    /**\n     * Returns browse-history for a user with optional sort and limit.\n     *\n     * Use when: showing \"Recently Viewed\" or full browse history on home/profile screen.\n     * - Queries all pages from GSI `userIdIndex`, then sorts in memory.\n     * - Pass `sortBy` as `\"created_time\"` or `\"updated_time\"` to order results.\n     * - Default `sortOrder` is `\"desc\"` (newest first).\n     * - `limit` is applied after sorting so latest N items are returned correctly.\n     *\n     * @example\n     * // Latest 10 browsed platters (most recently updated first)\n     * const recent = await browsHistoryDao.getByUserId(\"user-123\", 10, \"updated_time\");\n     *\n     * @example\n     * // Oldest viewed first\n     * const oldestFirst = await browsHistoryDao.getByUserId(\"user-123\", undefined, \"created_time\", \"asc\");\n     *\n     * @example\n     * // All history without sorting (raw DynamoDB order)\n     * const all = await browsHistoryDao.getByUserId(\"user-123\");\n     */\n    getByUserId = async (\n        userId: string,\n        limit?: number,\n        sortBy?: BrowseHistorySortField,\n        sortOrder: BrowseHistorySortOrder = \"desc\"\n    ): Promise<BrowseHistory[]> => {\n        const items: BrowseHistory[] = [];\n        let token: string | undefined;\n\n        do {\n            const result = await this.listByUserId(userId, undefined, token);\n            items.push(...result.items);\n            token = result.nextToken;\n        } while (token);\n\n        const sortedItems = this.sortBrowsHistoryItems(items, sortBy, sortOrder);\n        return typeof limit === \"number\" ? sortedItems.slice(0, limit) : sortedItems;\n    };\n\n    /**\n     * Reads timestamp from audit field used for in-memory sorting.\n     */\n    private getBrowsHistorySortTime = (item: BrowseHistory, field: BrowseHistorySortField): number => {\n        const value = item[field];\n        if (!value) {\n            return 0;\n        }\n        return value instanceof Date ? value.getTime() : new Date(value).getTime();\n    };\n\n    /**\n     * Sorts browse-history items by `created_time` or `updated_time`.\n     */\n    private sortBrowsHistoryItems = (\n        items: BrowseHistory[],\n        sortBy?: BrowseHistorySortField,\n        sortOrder: BrowseHistorySortOrder = \"desc\"\n    ): BrowseHistory[] => {\n        if (!sortBy) {\n            return items;\n        }\n\n        const direction = sortOrder === \"asc\" ? 1 : -1;\n        return [...items].sort(\n            (a, b) => (this.getBrowsHistorySortTime(a, sortBy) - this.getBrowsHistorySortTime(b, sortBy)) * direction\n        );\n    };\n\n    /**\n     * Paginated query on GSI `userIdIndex`.\n     *\n     * Use when: infinite scroll / load-more UI where you pass `nextToken` from previous response.\n     * For sorted \"recent N\" views prefer `getByUserId` instead.\n     *\n     * @example\n     * const page1 = await browsHistoryDao.listByUserId(\"user-123\", 20);\n     * const page2 = await browsHistoryDao.listByUserId(\"user-123\", 20, page1.nextToken);\n     */\n    listByUserId = async (userId: string, limit?: number, token?: string): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = BrowseHistoryModel.query(\"userId\").eq(userId).using(\"userIdIndex\");\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 BrowseHistory[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Deletes one browse-history record by primary key.\n     *\n     * Use when: user clears a single item from browse history.\n     *\n     * @example\n     * await browsHistoryDao.deleteById(\"brows-history-uuid\");\n     */\n    deleteById = async (browsHistoryId: string): Promise<void> => {\n        await this.delete(browsHistoryId);\n    };\n}\n\nexport const browsHistoryDao = new BrowsHistoryDao();\n"]}

package/dist/customer-user/browse-history/browse-history-model.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToBrowseHistoryModel = exports.BrowseHistoryModel = 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");
+const browseHistorySchema = new dynamoose_1.default.Schema({
+    browseHistoryId: {
+        type: String,
+        hashKey: true,
+        required: true,
+        default: () => (0, crypto_1.randomUUID)()
+    },
+    userId: {
+        type: String,
+        required: true,
+        index: {
+            name: "userIdIndex",
+            type: "global"
+        }
+    },
+    resumeJourneyId: {
+        type: String,
+        required: true
+    },
+    platterId: {
+        type: String,
+        required: true
+    },
+    platterName: {
+        type: String,
+        required: true
+    },
+    platterType: {
+        type: String,
+        required: true
+    },
+    platterSubType: String,
+    platterPrice: {
+        type: Number,
+        required: true
+    },
+    totalItems: {
+        type: Number,
+        required: true
+    },
+    menuType: {
+        type: String,
+        required: true
+    },
+    mealTime: {
+        type: String,
+        required: true
+    },
+    platterImage: {
+        type: String,
+        required: true
+    },
+    replaceItemIds: {
+        type: Array,
+        schema: [{
+                type: Object,
+                schema: {
+                    originalItemId: {
+                        type: String,
+                        required: true
+                    },
+                    replaceItemId: {
+                        type: String,
+                        required: true
+                    }
+                }
+            }],
+        default: []
+    },
+    addonIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    cutleryIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    liveCounterIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    skewerAddonIds: {
+        type: Array,
+        schema: [String],
+        default: []
+    },
+    ...base_dynamoose_model_1.BASE_DYNAMOOSE_AUDIT_SCHEMA
+}, {
+    saveUnknown: false,
+    timestamps: true
+});
+exports.BrowseHistoryModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.BROWSE_HISTORY, browseHistorySchema, { create: false, waitForActive: false });
+const convertToBrowseHistoryModel = (input) => {
+    return new exports.BrowseHistoryModel(input);
+};
+exports.convertToBrowseHistoryModel = convertToBrowseHistoryModel;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmp-aws-database",
-  "version": "2.1.2-dev.20",
+  "version": "2.1.2-dev.21",
   "bin": {
     "craft-my-plate-database": "bin/craft-my-plate-database.js"
   },

package/dist/customer-user/brows-history/brows-history-dao.js

@@ -1,173 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.browsHistoryDao = void 0;
-const dynamoose_1 = __importDefault(require("dynamoose"));
-const base_dynamoose_dao_1 = require("../../base-dynamoose-dao");
-const brows_history_model_1 = require("./brows-history-model");
-/**
- * DAO for user platter browse history.
- *
- * Table keys: `browsHistoryId` (PK).
- * User lookup: query GSI `userIdIndex` by `userId`.
- */
-class BrowsHistoryDao extends base_dynamoose_dao_1.GenericDynamooseDAO {
-    constructor() {
-        super(brows_history_model_1.BrowseHistoryModel, "browseHistoryId");
-        /**
-         * Creates one browse-history record.
-         *
-         * Use when: user views a platter and you want to persist that browse event.
-         * - `browsHistoryId` auto-generates if omitted.
-         * - `userId` is required for later `getByUserId` / `listByUserId` lookups.
-         * - Stamps `created_time` / `created_user` automatically.
-         *
-         * @example
-         * await browsHistoryDao.save({
-         *     userId: "user-123",
-         *     platterId: "platter-abc",
-         *     platterName: "Birthday Feast",
-         *     platterType: "CATERING",
-         *     platterPrice: 4999,
-         *     totalItems: 12,
-         *     menuType: "VEG",
-         *     mealTime: "Dinner",
-         *     platterImage: "https://...",
-         *     replaceItemIds: [{ originalItemId: "item-1", replaceItemId: "item-2" }],
-         *     addonIds: [],
-         *     cutleryIds: [],
-         *     liveCounterIds: [],
-         *     skewerAddonIds: []
-         * }, { userSub: "user-123" });
-         */
-        this.save = async (item, authContext) => {
-            return super.save(item, authContext);
-        };
-        /**
-         * Updates one browse-history record by `browsHistoryId`.
-         *
-         * Use when: user re-visits same platter and you need to update selections or metadata.
-         * - Fails if the record does not exist.
-         * - Stamps `updated_time` / `updated_user` automatically.
-         *
-         * @example
-         * await browsHistoryDao.update(
-         *     "brows-history-uuid",
-         *     { addonIds: ["addon-1", "addon-2"], platterPrice: 5499 },
-         *     { userSub: "user-123" }
-         * );
-         */
-        this.update = async (browseHistoryId, updates, authContext) => {
-            const updated = await brows_history_model_1.BrowseHistoryModel.update({ browseHistoryId }, {
-                ...updates,
-                updated_time: new Date(),
-                updated_user: authContext?.userSub
-            }, {
-                condition: new dynamoose_1.default.Condition().attribute("browsHistoryId").exists()
-            });
-            return updated;
-        };
-        /**
-         * Fetches one browse-history record by primary key.
-         *
-         * Use when: detail screen already has `browsHistoryId` from a previous list response.
-         * Returns `null` when record is not found.
-         *
-         * @example
-         * const item = await browsHistoryDao.getById("brows-history-uuid");
-         */
-        this.getById = async (browseHistoryId) => this.get(browseHistoryId);
-        /**
-         * Returns browse-history for a user with optional sort and limit.
-         *
-         * Use when: showing "Recently Viewed" or full browse history on home/profile screen.
-         * - Queries all pages from GSI `userIdIndex`, then sorts in memory.
-         * - Pass `sortBy` as `"created_time"` or `"updated_time"` to order results.
-         * - Default `sortOrder` is `"desc"` (newest first).
-         * - `limit` is applied after sorting so latest N items are returned correctly.
-         *
-         * @example
-         * // Latest 10 browsed platters (most recently updated first)
-         * const recent = await browsHistoryDao.getByUserId("user-123", 10, "updated_time");
-         *
-         * @example
-         * // Oldest viewed first
-         * const oldestFirst = await browsHistoryDao.getByUserId("user-123", undefined, "created_time", "asc");
-         *
-         * @example
-         * // All history without sorting (raw DynamoDB order)
-         * const all = await browsHistoryDao.getByUserId("user-123");
-         */
-        this.getByUserId = async (userId, limit, sortBy, sortOrder = "desc") => {
-            const items = [];
-            let token;
-            do {
-                const result = await this.listByUserId(userId, undefined, token);
-                items.push(...result.items);
-                token = result.nextToken;
-            } while (token);
-            const sortedItems = this.sortBrowsHistoryItems(items, sortBy, sortOrder);
-            return typeof limit === "number" ? sortedItems.slice(0, limit) : sortedItems;
-        };
-        /**
-         * Reads timestamp from audit field used for in-memory sorting.
-         */
-        this.getBrowsHistorySortTime = (item, field) => {
-            const value = item[field];
-            if (!value) {
-                return 0;
-            }
-            return value instanceof Date ? value.getTime() : new Date(value).getTime();
-        };
-        /**
-         * Sorts browse-history items by `created_time` or `updated_time`.
-         */
-        this.sortBrowsHistoryItems = (items, sortBy, sortOrder = "desc") => {
-            if (!sortBy) {
-                return items;
-            }
-            const direction = sortOrder === "asc" ? 1 : -1;
-            return [...items].sort((a, b) => (this.getBrowsHistorySortTime(a, sortBy) - this.getBrowsHistorySortTime(b, sortBy)) * direction);
-        };
-        /**
-         * Paginated query on GSI `userIdIndex`.
-         *
-         * Use when: infinite scroll / load-more UI where you pass `nextToken` from previous response.
-         * For sorted "recent N" views prefer `getByUserId` instead.
-         *
-         * @example
-         * const page1 = await browsHistoryDao.listByUserId("user-123", 20);
-         * const page2 = await browsHistoryDao.listByUserId("user-123", 20, page1.nextToken);
-         */
-        this.listByUserId = async (userId, limit, token) => {
-            const decodedToken = this.decode(token);
-            let queryBuilder = brows_history_model_1.BrowseHistoryModel.query("userId").eq(userId).using("userIdIndex");
-            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 browse-history record by primary key.
-         *
-         * Use when: user clears a single item from browse history.
-         *
-         * @example
-         * await browsHistoryDao.deleteById("brows-history-uuid");
-         */
-        this.deleteById = async (browsHistoryId) => {
-            await this.delete(browsHistoryId);
-        };
-    }
-}
-exports.browsHistoryDao = new BrowsHistoryDao();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brows-history-dao.js","sourceRoot":"","sources":["../../../src/customer-user/brows-history/brows-history-dao.ts"],"names":[],"mappings":";;;;;;AAAA,0DAAkC;AAClC,iEAA0E;AAE1E,+DAI+B;AAU/B;;;;;GAKG;AACH,MAAM,eAAgB,SAAQ,wCAAkC;IAC5D;QACI,KAAK,CAAC,wCAAkB,EAAE,iBAAiB,CAAC,CAAC;QAGjD;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;QACH,SAAI,GAAG,KAAK,EAAE,IAA8B,EAAE,WAAyB,EAA0B,EAAE;YAC/F,OAAO,KAAK,CAAC,IAAI,CAAC,IAAqB,EAAE,WAAW,CAAC,CAAC;QAC1D,CAAC,CAAC;QAEF;;;;;;;;;;;;;WAaG;QACH,WAAM,GAAG,KAAK,EACV,eAAuB,EACvB,OAA+B,EAC/B,WAAyB,EACH,EAAE;YACxB,MAAM,OAAO,GAAG,MAAM,wCAAkB,CAAC,MAAM,CAC3C,EAAE,eAAe,EAAE,EACnB;gBACI,GAAG,OAAO;gBACV,YAAY,EAAE,IAAI,IAAI,EAAE;gBACxB,YAAY,EAAE,WAAW,EAAE,OAAO;aACrC,EACD;gBACI,SAAS,EAAE,IAAI,mBAAS,CAAC,SAAS,EAAE,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,MAAM,EAAE;aAC5E,CACJ,CAAC;YACF,OAAO,OAAmC,CAAC;QAC/C,CAAC,CAAC;QAEF;;;;;;;;WAQG;QACH,YAAO,GAAG,KAAK,EAAE,eAAuB,EAAiC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAEtG;;;;;;;;;;;;;;;;;;;;WAoBG;QACH,gBAAW,GAAG,KAAK,EACf,MAAc,EACd,KAAc,EACd,MAA+B,EAC/B,YAAoC,MAAM,EAClB,EAAE;YAC1B,MAAM,KAAK,GAAoB,EAAE,CAAC;YAClC,IAAI,KAAyB,CAAC;YAE9B,GAAG,CAAC;gBACA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;gBACjE,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC5B,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC;YAC7B,CAAC,QAAQ,KAAK,EAAE;YAEhB,MAAM,WAAW,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YACzE,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QACjF,CAAC,CAAC;QAEF;;WAEG;QACK,4BAAuB,GAAG,CAAC,IAAmB,EAAE,KAA6B,EAAU,EAAE;YAC7F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1B,IAAI,CAAC,KAAK,EAAE,CAAC;gBACT,OAAO,CAAC,CAAC;YACb,CAAC;YACD,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;QAC/E,CAAC,CAAC;QAEF;;WAEG;QACK,0BAAqB,GAAG,CAC5B,KAAsB,EACtB,MAA+B,EAC/B,YAAoC,MAAM,EAC3B,EAAE;YACjB,IAAI,CAAC,MAAM,EAAE,CAAC;gBACV,OAAO,KAAK,CAAC;YACjB,CAAC;YAED,MAAM,SAAS,GAAG,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/C,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,CAClB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAC5G,CAAC;QACN,CAAC,CAAC;QAEF;;;;;;;;;WASG;QACH,iBAAY,GAAG,KAAK,EAAE,MAAc,EAAE,KAAc,EAAE,KAAc,EAAuB,EAAE;YACzF,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACxC,IAAI,YAAY,GAAG,wCAAkB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YACtF,IAAI,YAAY,EAAE,CAAC;gBACf,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YACtD,CAAC;YACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC5B,YAAY,GAAG,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7C,CAAC;YACD,MAAM,WAAW,GAAG,MAAM,YAAY,CAAC,IAAI,EAAE,CAAC;YAC9C,OAAO;gBACH,KAAK,EAAE,WAAyC;gBAChD,SAAS,EAAE,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,OAAgC,CAAC;aAC7E,CAAC;QACN,CAAC,CAAC;QAEF;;;;;;;WAOG;QACH,eAAU,GAAG,KAAK,EAAE,cAAsB,EAAiB,EAAE;YACzD,MAAM,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QACtC,CAAC,CAAC;IArLF,CAAC;CAsLJ;AAEY,QAAA,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC","sourcesContent":["import dynamoose from \"dynamoose\";\nimport { DynamoKey, GenericDynamooseDAO } from \"../../base-dynamoose-dao\";\nimport { AuthContext } from \"../../base-dynamoose-model\";\nimport {\n    BrowseHistory,\n    BrowseHistoryModel,\n    CreateBrowseHistoryInput\n} from \"./brows-history-model\";\n\ntype ListResult = {\n    items: BrowseHistory[];\n    nextToken?: string;\n};\n\nexport type BrowseHistorySortField = \"created_time\" | \"updated_time\";\nexport type BrowseHistorySortOrder = \"asc\" | \"desc\";\n\n/**\n * DAO for user platter browse history.\n *\n * Table keys: `browsHistoryId` (PK).\n * User lookup: query GSI `userIdIndex` by `userId`.\n */\nclass BrowsHistoryDao extends GenericDynamooseDAO<BrowseHistory> {\n    constructor() {\n        super(BrowseHistoryModel, \"browseHistoryId\");\n    }\n\n    /**\n     * Creates one browse-history record.\n     *\n     * Use when: user views a platter and you want to persist that browse event.\n     * - `browsHistoryId` auto-generates if omitted.\n     * - `userId` is required for later `getByUserId` / `listByUserId` lookups.\n     * - Stamps `created_time` / `created_user` automatically.\n     *\n     * @example\n     * await browsHistoryDao.save({\n     *     userId: \"user-123\",\n     *     platterId: \"platter-abc\",\n     *     platterName: \"Birthday Feast\",\n     *     platterType: \"CATERING\",\n     *     platterPrice: 4999,\n     *     totalItems: 12,\n     *     menuType: \"VEG\",\n     *     mealTime: \"Dinner\",\n     *     platterImage: \"https://...\",\n     *     replaceItemIds: [{ originalItemId: \"item-1\", replaceItemId: \"item-2\" }],\n     *     addonIds: [],\n     *     cutleryIds: [],\n     *     liveCounterIds: [],\n     *     skewerAddonIds: []\n     * }, { userSub: \"user-123\" });\n     */\n    save = async (item: CreateBrowseHistoryInput, authContext?: AuthContext): Promise<BrowseHistory> => {\n        return super.save(item as BrowseHistory, authContext);\n    };\n\n    /**\n     * Updates one browse-history record by `browsHistoryId`.\n     *\n     * Use when: user re-visits same platter and you need to update selections or metadata.\n     * - Fails if the record does not exist.\n     * - Stamps `updated_time` / `updated_user` automatically.\n     *\n     * @example\n     * await browsHistoryDao.update(\n     *     \"brows-history-uuid\",\n     *     { addonIds: [\"addon-1\", \"addon-2\"], platterPrice: 5499 },\n     *     { userSub: \"user-123\" }\n     * );\n     */\n    update = async (\n        browseHistoryId: string,\n        updates: Partial<BrowseHistory>,\n        authContext?: AuthContext\n    ): Promise<BrowseHistory> => {\n        const updated = await BrowseHistoryModel.update(\n            { browseHistoryId },\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            },\n            {\n                condition: new dynamoose.Condition().attribute(\"browsHistoryId\").exists()\n            }\n        );\n        return updated as unknown as BrowseHistory;\n    };\n\n    /**\n     * Fetches one browse-history record by primary key.\n     *\n     * Use when: detail screen already has `browsHistoryId` from a previous list response.\n     * Returns `null` when record is not found.\n     *\n     * @example\n     * const item = await browsHistoryDao.getById(\"brows-history-uuid\");\n     */\n    getById = async (browseHistoryId: string): Promise<BrowseHistory | null> => this.get(browseHistoryId);\n\n    /**\n     * Returns browse-history for a user with optional sort and limit.\n     *\n     * Use when: showing \"Recently Viewed\" or full browse history on home/profile screen.\n     * - Queries all pages from GSI `userIdIndex`, then sorts in memory.\n     * - Pass `sortBy` as `\"created_time\"` or `\"updated_time\"` to order results.\n     * - Default `sortOrder` is `\"desc\"` (newest first).\n     * - `limit` is applied after sorting so latest N items are returned correctly.\n     *\n     * @example\n     * // Latest 10 browsed platters (most recently updated first)\n     * const recent = await browsHistoryDao.getByUserId(\"user-123\", 10, \"updated_time\");\n     *\n     * @example\n     * // Oldest viewed first\n     * const oldestFirst = await browsHistoryDao.getByUserId(\"user-123\", undefined, \"created_time\", \"asc\");\n     *\n     * @example\n     * // All history without sorting (raw DynamoDB order)\n     * const all = await browsHistoryDao.getByUserId(\"user-123\");\n     */\n    getByUserId = async (\n        userId: string,\n        limit?: number,\n        sortBy?: BrowseHistorySortField,\n        sortOrder: BrowseHistorySortOrder = \"desc\"\n    ): Promise<BrowseHistory[]> => {\n        const items: BrowseHistory[] = [];\n        let token: string | undefined;\n\n        do {\n            const result = await this.listByUserId(userId, undefined, token);\n            items.push(...result.items);\n            token = result.nextToken;\n        } while (token);\n\n        const sortedItems = this.sortBrowsHistoryItems(items, sortBy, sortOrder);\n        return typeof limit === \"number\" ? sortedItems.slice(0, limit) : sortedItems;\n    };\n\n    /**\n     * Reads timestamp from audit field used for in-memory sorting.\n     */\n    private getBrowsHistorySortTime = (item: BrowseHistory, field: BrowseHistorySortField): number => {\n        const value = item[field];\n        if (!value) {\n            return 0;\n        }\n        return value instanceof Date ? value.getTime() : new Date(value).getTime();\n    };\n\n    /**\n     * Sorts browse-history items by `created_time` or `updated_time`.\n     */\n    private sortBrowsHistoryItems = (\n        items: BrowseHistory[],\n        sortBy?: BrowseHistorySortField,\n        sortOrder: BrowseHistorySortOrder = \"desc\"\n    ): BrowseHistory[] => {\n        if (!sortBy) {\n            return items;\n        }\n\n        const direction = sortOrder === \"asc\" ? 1 : -1;\n        return [...items].sort(\n            (a, b) => (this.getBrowsHistorySortTime(a, sortBy) - this.getBrowsHistorySortTime(b, sortBy)) * direction\n        );\n    };\n\n    /**\n     * Paginated query on GSI `userIdIndex`.\n     *\n     * Use when: infinite scroll / load-more UI where you pass `nextToken` from previous response.\n     * For sorted \"recent N\" views prefer `getByUserId` instead.\n     *\n     * @example\n     * const page1 = await browsHistoryDao.listByUserId(\"user-123\", 20);\n     * const page2 = await browsHistoryDao.listByUserId(\"user-123\", 20, page1.nextToken);\n     */\n    listByUserId = async (userId: string, limit?: number, token?: string): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = BrowseHistoryModel.query(\"userId\").eq(userId).using(\"userIdIndex\");\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 BrowseHistory[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Deletes one browse-history record by primary key.\n     *\n     * Use when: user clears a single item from browse history.\n     *\n     * @example\n     * await browsHistoryDao.deleteById(\"brows-history-uuid\");\n     */\n    deleteById = async (browsHistoryId: string): Promise<void> => {\n        await this.delete(browsHistoryId);\n    };\n}\n\nexport const browsHistoryDao = new BrowsHistoryDao();\n"]}

package/dist/customer-user/brows-history/brows-history-model.js

@@ -1,110 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToBrowseHistoryModel = exports.BrowseHistoryModel = 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");
-const browseHistorySchema = new dynamoose_1.default.Schema({
-    browseHistoryId: {
-        type: String,
-        hashKey: true,
-        required: true,
-        default: () => (0, crypto_1.randomUUID)()
-    },
-    userId: {
-        type: String,
-        required: true,
-        index: {
-            name: "userIdIndex",
-            type: "global"
-        }
-    },
-    resumeJourneyId: {
-        type: String,
-        required: true
-    },
-    platterId: {
-        type: String,
-        required: true
-    },
-    platterName: {
-        type: String,
-        required: true
-    },
-    platterType: {
-        type: String,
-        required: true
-    },
-    platterSubType: String,
-    platterPrice: {
-        type: Number,
-        required: true
-    },
-    totalItems: {
-        type: Number,
-        required: true
-    },
-    menuType: {
-        type: String,
-        required: true
-    },
-    mealTime: {
-        type: String,
-        required: true
-    },
-    platterImage: {
-        type: String,
-        required: true
-    },
-    replaceItemIds: {
-        type: Array,
-        schema: [{
-                type: Object,
-                schema: {
-                    originalItemId: {
-                        type: String,
-                        required: true
-                    },
-                    replaceItemId: {
-                        type: String,
-                        required: true
-                    }
-                }
-            }],
-        default: []
-    },
-    addonIds: {
-        type: Array,
-        schema: [String],
-        default: []
-    },
-    cutleryIds: {
-        type: Array,
-        schema: [String],
-        default: []
-    },
-    liveCounterIds: {
-        type: Array,
-        schema: [String],
-        default: []
-    },
-    skewerAddonIds: {
-        type: Array,
-        schema: [String],
-        default: []
-    },
-    ...base_dynamoose_model_1.BASE_DYNAMOOSE_AUDIT_SCHEMA
-}, {
-    saveUnknown: false,
-    timestamps: true
-});
-exports.BrowseHistoryModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.BROWSE_HISTORY, browseHistorySchema, { create: false, waitForActive: false });
-const convertToBrowseHistoryModel = (input) => {
-    return new exports.BrowseHistoryModel(input);
-};
-exports.convertToBrowseHistoryModel = convertToBrowseHistoryModel;
-//# sourceMappingURL=data:application/json;base64,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