cmp-aws-database 2.0.0-proddebug.1 → 2.0.0-proddebug.3

package/dist/base-dynamoose-dao.d.ts

@@ -0,0 +1,83 @@
+import { BaseDynamooseModel, AuthContext } from "./base-dynamoose-model";
+type DynamoKeyValue = string | number | boolean | null;
+export type DynamoKey = Record<string, DynamoKeyValue>;
+type DynamooseModelLike = {
+    create: Function;
+    update: Function;
+    get: Function;
+    delete: Function;
+    batchPut: Function;
+    batchGet: Function;
+};
+export declare class GenericDynamooseDAO<T extends BaseDynamooseModel> {
+    protected readonly model: DynamooseModelLike;
+    protected readonly primaryKeyName: keyof T & string;
+    protected readonly sortKeyName?: (keyof T & string) | undefined;
+    /**
+     * @param model Dynamoose model instance for the target table.
+     * @param primaryKeyName Attribute name used as the table hash key.
+     */
+    constructor(model: DynamooseModelLike, primaryKeyName: keyof T & string, sortKeyName?: (keyof T & string) | undefined);
+    /**
+     * Builds a DynamoDB key object from a single primary key value.
+     */
+    protected getKeyObject(primaryKeyValue: string, sortKeyValue?: string): DynamoKey;
+    /**
+     * Extracts and validates string primary key value from an item.
+     */
+    protected getPrimaryKeyValueFromItem(item: T): string;
+    /**
+     * Extracts and validates sort key value from an item when sort key is configured.
+     */
+    protected getSortKeyValueFromItem(item: T): string | undefined;
+    /**
+     * Builds complete key object (hash + optional sort) from an item.
+     */
+    protected getItemKeyObject(item: T): DynamoKey;
+    /**
+     * Serializes key object for stable set/map comparisons.
+     */
+    protected serializeKey(key: DynamoKey): string;
+    /**
+     * Creates a new record and automatically stamps created audit fields.
+     */
+    save(item: T, authContext?: AuthContext): Promise<T>;
+    /**
+     * Updates an existing record and automatically stamps updated audit fields.
+     */
+    update(primaryKeyValue: string, updates: Partial<T>, authContext?: AuthContext, sortKeyValue?: string): Promise<T>;
+    /**
+     * Deletes one record by primary key.
+     */
+    delete(primaryKeyValue: string, sortKeyValue?: string): Promise<T | undefined>;
+    /**
+     * Fetches one record by primary key. Returns null when not found.
+     */
+    get(primaryKeyValue: string, sortKeyValue?: string): Promise<T | null>;
+    /**
+     * Writes multiple records in a batch and throws if any item is left unprocessed.
+     */
+    batchSave(items: T[], authContext?: AuthContext): Promise<T[]>;
+    /**
+     * Upserts multiple records by primary key.
+     * New keys are created (created_* fields), existing keys are updated (updated_* fields).
+     */
+    batchUpsert(items: T[], authContext?: AuthContext): Promise<T[]>;
+    /**
+     * Fetches multiple records by primary keys.
+     */
+    batchGet(primaryKeyValues: string[]): Promise<T[]>;
+    /**
+     * Fetches multiple records by key objects (supports hash + optional sort key).
+     */
+    batchGetByKeys(keys: DynamoKey[]): Promise<T[]>;
+    /**
+     * Decodes a base64 continuation token into DynamoDB last evaluated key.
+     */
+    decode(continuationToken: string | undefined): DynamoKey | undefined;
+    /**
+     * Encodes DynamoDB last evaluated key into a base64 continuation token.
+     */
+    encode(lastEvaluatedKey: DynamoKey | undefined): Promise<string | undefined>;
+}
+export {};

package/dist/base-dynamoose-dao.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericDynamooseDAO = void 0;
+class GenericDynamooseDAO {
+    /**
+     * @param model Dynamoose model instance for the target table.
+     * @param primaryKeyName Attribute name used as the table hash key.
+     */
+    constructor(model, primaryKeyName, sortKeyName) {
+        this.model = model;
+        this.primaryKeyName = primaryKeyName;
+        this.sortKeyName = sortKeyName;
+    }
+    /**
+     * Builds a DynamoDB key object from a single primary key value.
+     */
+    getKeyObject(primaryKeyValue, sortKeyValue) {
+        const keyObject = { [this.primaryKeyName]: primaryKeyValue };
+        if (this.sortKeyName) {
+            if (!sortKeyValue) {
+                throw new Error(`Missing sort key value for '${this.sortKeyName}'`);
+            }
+            keyObject[this.sortKeyName] = sortKeyValue;
+        }
+        return keyObject;
+    }
+    /**
+     * Extracts and validates string primary key value from an item.
+     */
+    getPrimaryKeyValueFromItem(item) {
+        const keyRecord = item;
+        const keyValue = keyRecord[this.primaryKeyName];
+        if (typeof keyValue !== "string" || keyValue.length === 0) {
+            throw new Error(`Missing or invalid primary key value for '${this.primaryKeyName}'`);
+        }
+        return keyValue;
+    }
+    /**
+     * Extracts and validates sort key value from an item when sort key is configured.
+     */
+    getSortKeyValueFromItem(item) {
+        if (!this.sortKeyName) {
+            return undefined;
+        }
+        const keyRecord = item;
+        const keyValue = keyRecord[this.sortKeyName];
+        if (typeof keyValue !== "string" || keyValue.length === 0) {
+            throw new Error(`Missing or invalid sort key value for '${this.sortKeyName}'`);
+        }
+        return keyValue;
+    }
+    /**
+     * Builds complete key object (hash + optional sort) from an item.
+     */
+    getItemKeyObject(item) {
+        const primaryKeyValue = this.getPrimaryKeyValueFromItem(item);
+        const sortKeyValue = this.getSortKeyValueFromItem(item);
+        return this.getKeyObject(primaryKeyValue, sortKeyValue);
+    }
+    /**
+     * Serializes key object for stable set/map comparisons.
+     */
+    serializeKey(key) {
+        if (!this.sortKeyName) {
+            return `${key[this.primaryKeyName]}`;
+        }
+        return `${key[this.primaryKeyName]}#${key[this.sortKeyName]}`;
+    }
+    /**
+     * Creates a new record and automatically stamps created audit fields.
+     */
+    async save(item, authContext) {
+        const createFn = this.model.create;
+        const created = await createFn({
+            ...item,
+            created_time: new Date(),
+            created_user: authContext?.userSub
+        });
+        return created;
+    }
+    /**
+     * Updates an existing record and automatically stamps updated audit fields.
+     */
+    async update(primaryKeyValue, updates, authContext, sortKeyValue) {
+        const updateFn = this.model.update;
+        const updated = await updateFn(this.getKeyObject(primaryKeyValue, sortKeyValue), {
+            ...updates,
+            updated_time: new Date(),
+            updated_user: authContext?.userSub
+        });
+        return updated;
+    }
+    /**
+     * Deletes one record by primary key.
+     */
+    async delete(primaryKeyValue, sortKeyValue) {
+        const deleteFn = this.model.delete;
+        const deleted = await deleteFn(this.getKeyObject(primaryKeyValue, sortKeyValue));
+        return deleted;
+    }
+    /**
+     * Fetches one record by primary key. Returns null when not found.
+     */
+    async get(primaryKeyValue, sortKeyValue) {
+        const getFn = this.model.get;
+        const item = await getFn(this.getKeyObject(primaryKeyValue, sortKeyValue));
+        return item ?? null;
+    }
+    /**
+     * Writes multiple records in a batch and throws if any item is left unprocessed.
+     */
+    async batchSave(items, authContext) {
+        const now = new Date();
+        const inputItems = items.map((item) => ({
+            ...item,
+            created_time: now,
+            created_user: authContext?.userSub
+        }));
+        const batchPutFn = this.model.batchPut;
+        const result = await batchPutFn(inputItems);
+        if (result.unprocessedItems.length > 0) {
+            throw new Error(`Batch save partially failed. Unprocessed items: ${result.unprocessedItems.length}`);
+        }
+        return inputItems;
+    }
+    /**
+     * Upserts multiple records by primary key.
+     * New keys are created (created_* fields), existing keys are updated (updated_* fields).
+     */
+    async batchUpsert(items, authContext) {
+        const now = new Date();
+        const keys = items.map((item) => this.getItemKeyObject(item));
+        const existingItems = await this.batchGetByKeys(keys);
+        const existingKeySet = new Set(existingItems.map((item) => this.serializeKey(this.getItemKeyObject(item))));
+        const upsertItems = items.map((item) => {
+            const itemKey = this.getItemKeyObject(item);
+            if (existingKeySet.has(this.serializeKey(itemKey))) {
+                return {
+                    ...item,
+                    updated_time: now,
+                    updated_user: authContext?.userSub
+                };
+            }
+            return {
+                ...item,
+                created_time: now,
+                created_user: authContext?.userSub
+            };
+        });
+        const batchPutFn = this.model.batchPut;
+        const result = await batchPutFn(upsertItems);
+        if (result.unprocessedItems.length > 0) {
+            throw new Error(`Batch upsert partially failed. Unprocessed items: ${result.unprocessedItems.length}`);
+        }
+        return upsertItems;
+    }
+    /**
+     * Fetches multiple records by primary keys.
+     */
+    async batchGet(primaryKeyValues) {
+        const keys = primaryKeyValues.map((value) => this.getKeyObject(value));
+        return this.batchGetByKeys(keys);
+    }
+    /**
+     * Fetches multiple records by key objects (supports hash + optional sort key).
+     */
+    async batchGetByKeys(keys) {
+        const batchGetFn = this.model.batchGet;
+        const items = await batchGetFn(keys);
+        return items;
+    }
+    /**
+     * Decodes a base64 continuation token into DynamoDB last evaluated key.
+     */
+    decode(continuationToken) {
+        if (!continuationToken) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(Buffer.from(continuationToken, "base64").toString("utf8"));
+        }
+        catch (error) {
+            throw new Error("Invalid continuationToken");
+        }
+    }
+    /**
+     * Encodes DynamoDB last evaluated key into a base64 continuation token.
+     */
+    async encode(lastEvaluatedKey) {
+        if (!lastEvaluatedKey) {
+            return undefined;
+        }
+        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString("base64");
+    }
+}
+exports.GenericDynamooseDAO = GenericDynamooseDAO;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dynamoose-dao.js","sourceRoot":"","sources":["../src/base-dynamoose-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseDynamooseModel, AuthContext } from \"./base-dynamoose-model\";\n\ntype DynamoKeyValue = string | number | boolean | null;\nexport type DynamoKey = Record<string, DynamoKeyValue>;\n\ntype BatchPutResponse<T> = {\n    unprocessedItems: Partial<T>[];\n};\n\ntype CreateFn<T> = (item: Partial<T>) => Promise<object>;\ntype UpdateFn<T> = (key: DynamoKey, update: Partial<T>) => Promise<object>;\ntype DeleteFn = (key: DynamoKey) => Promise<object | undefined>;\ntype GetFn = (key: DynamoKey) => Promise<object | undefined>;\ntype BatchPutFn<T> = (items: Partial<T>[]) => Promise<BatchPutResponse<T>>;\ntype BatchGetFn = (keys: DynamoKey[]) => Promise<object[]>;\n\ntype DynamooseModelLike = {\n    create: Function;\n    update: Function;\n    get: Function;\n    delete: Function;\n    batchPut: Function;\n    batchGet: Function;\n};\n\nexport class GenericDynamooseDAO<T extends BaseDynamooseModel> {\n    /**\n     * @param model Dynamoose model instance for the target table.\n     * @param primaryKeyName Attribute name used as the table hash key.\n     */\n    constructor(\n        protected readonly model: DynamooseModelLike,\n        protected readonly primaryKeyName: keyof T & string,\n        protected readonly sortKeyName?: keyof T & string\n    ) { }\n\n    /**\n     * Builds a DynamoDB key object from a single primary key value.\n     */\n    protected getKeyObject(primaryKeyValue: string, sortKeyValue?: string): DynamoKey {\n        const keyObject: DynamoKey = { [this.primaryKeyName]: primaryKeyValue };\n        if (this.sortKeyName) {\n            if (!sortKeyValue) {\n                throw new Error(`Missing sort key value for '${this.sortKeyName}'`);\n            }\n            keyObject[this.sortKeyName] = sortKeyValue;\n        }\n        return keyObject;\n    }\n\n    /**\n     * Extracts and validates string primary key value from an item.\n     */\n    protected getPrimaryKeyValueFromItem(item: T): string {\n        const keyRecord = item as unknown as Record<string, DynamoKeyValue | undefined>;\n        const keyValue = keyRecord[this.primaryKeyName];\n        if (typeof keyValue !== \"string\" || keyValue.length === 0) {\n            throw new Error(`Missing or invalid primary key value for '${this.primaryKeyName}'`);\n        }\n        return keyValue;\n    }\n\n    /**\n     * Extracts and validates sort key value from an item when sort key is configured.\n     */\n    protected getSortKeyValueFromItem(item: T): string | undefined {\n        if (!this.sortKeyName) {\n            return undefined;\n        }\n        const keyRecord = item as unknown as Record<string, DynamoKeyValue | undefined>;\n        const keyValue = keyRecord[this.sortKeyName];\n        if (typeof keyValue !== \"string\" || keyValue.length === 0) {\n            throw new Error(`Missing or invalid sort key value for '${this.sortKeyName}'`);\n        }\n        return keyValue;\n    }\n\n    /**\n     * Builds complete key object (hash + optional sort) from an item.\n     */\n    protected getItemKeyObject(item: T): DynamoKey {\n        const primaryKeyValue = this.getPrimaryKeyValueFromItem(item);\n        const sortKeyValue = this.getSortKeyValueFromItem(item);\n        return this.getKeyObject(primaryKeyValue, sortKeyValue);\n    }\n\n    /**\n     * Serializes key object for stable set/map comparisons.\n     */\n    protected serializeKey(key: DynamoKey): string {\n        if (!this.sortKeyName) {\n            return `${key[this.primaryKeyName]}`;\n        }\n        return `${key[this.primaryKeyName]}#${key[this.sortKeyName]}`;\n    }\n\n    /**\n     * Creates a new record and automatically stamps created audit fields.\n     */\n    async save(item: T, authContext?: AuthContext): Promise<T> {\n        const createFn = this.model.create as CreateFn<T>;\n        const created = await createFn({\n            ...item,\n            created_time: new Date(),\n            created_user: authContext?.userSub\n        });\n        return created as T;\n    }\n\n    /**\n     * Updates an existing record and automatically stamps updated audit fields.\n     */\n    async update(primaryKeyValue: string, updates: Partial<T>, authContext?: AuthContext, sortKeyValue?: string): Promise<T> {\n        const updateFn = this.model.update as UpdateFn<T>;\n        const updated = await updateFn(\n            this.getKeyObject(primaryKeyValue, sortKeyValue),\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            }\n        );\n        return updated as T;\n    }\n\n    /**\n     * Deletes one record by primary key.\n     */\n    async delete(primaryKeyValue: string, sortKeyValue?: string): Promise<T | undefined> {\n        const deleteFn = this.model.delete as DeleteFn;\n        const deleted = await deleteFn(this.getKeyObject(primaryKeyValue, sortKeyValue));\n        return deleted as T | undefined;\n    }\n\n    /**\n     * Fetches one record by primary key. Returns null when not found.\n     */\n    async get(primaryKeyValue: string, sortKeyValue?: string): Promise<T | null> {\n        const getFn = this.model.get as GetFn;\n        const item = await getFn(this.getKeyObject(primaryKeyValue, sortKeyValue));\n        return (item as T | undefined) ?? null;\n    }\n\n    /**\n     * Writes multiple records in a batch and throws if any item is left unprocessed.\n     */\n    async batchSave(items: T[], authContext?: AuthContext): Promise<T[]> {\n        const now = new Date();\n        const inputItems = items.map((item) => ({\n            ...item,\n            created_time: now,\n            created_user: authContext?.userSub\n        })) as T[];\n\n        const batchPutFn = this.model.batchPut as BatchPutFn<T>;\n        const result = await batchPutFn(inputItems);\n        if (result.unprocessedItems.length > 0) {\n            throw new Error(`Batch save partially failed. Unprocessed items: ${result.unprocessedItems.length}`);\n        }\n\n        return inputItems;\n    }\n\n    /**\n     * Upserts multiple records by primary key.\n     * New keys are created (created_* fields), existing keys are updated (updated_* fields).\n     */\n    async batchUpsert(items: T[], authContext?: AuthContext): Promise<T[]> {\n        const now = new Date();\n        const keys = items.map((item) => this.getItemKeyObject(item));\n        const existingItems = await this.batchGetByKeys(keys);\n\n        const existingKeySet = new Set(\n            existingItems.map((item) => this.serializeKey(this.getItemKeyObject(item)))\n        );\n\n        const upsertItems = items.map((item) => {\n            const itemKey = this.getItemKeyObject(item);\n            if (existingKeySet.has(this.serializeKey(itemKey))) {\n                return {\n                    ...item,\n                    updated_time: now,\n                    updated_user: authContext?.userSub\n                };\n            }\n\n            return {\n                ...item,\n                created_time: now,\n                created_user: authContext?.userSub\n            };\n        }) as T[];\n\n        const batchPutFn = this.model.batchPut as BatchPutFn<T>;\n        const result = await batchPutFn(upsertItems);\n        if (result.unprocessedItems.length > 0) {\n            throw new Error(`Batch upsert partially failed. Unprocessed items: ${result.unprocessedItems.length}`);\n        }\n\n        return upsertItems;\n    }\n\n    /**\n     * Fetches multiple records by primary keys.\n     */\n    async batchGet(primaryKeyValues: string[]): Promise<T[]> {\n        const keys = primaryKeyValues.map((value) => this.getKeyObject(value));\n        return this.batchGetByKeys(keys);\n    }\n\n    /**\n     * Fetches multiple records by key objects (supports hash + optional sort key).\n     */\n    async batchGetByKeys(keys: DynamoKey[]): Promise<T[]> {\n        const batchGetFn = this.model.batchGet as BatchGetFn;\n        const items = await batchGetFn(keys);\n        return items as T[];\n    }\n\n    /**\n     * Decodes a base64 continuation token into DynamoDB last evaluated key.\n     */\n    decode(continuationToken: string | undefined): DynamoKey | undefined {\n        if (!continuationToken) {\n            return undefined;\n        }\n\n        try {\n            return JSON.parse(Buffer.from(continuationToken, \"base64\").toString(\"utf8\")) as DynamoKey;\n        } catch (error) {\n            throw new Error(\"Invalid continuationToken\");\n        }\n    }\n\n    /**\n     * Encodes DynamoDB last evaluated key into a base64 continuation token.\n     */\n    async encode(lastEvaluatedKey: DynamoKey | undefined): Promise<string | undefined> {\n        if (!lastEvaluatedKey) {\n            return undefined;\n        }\n\n        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString(\"base64\");\n    }\n}\n"]}

package/dist/base-dynamoose-model.d.ts

@@ -0,0 +1,33 @@
+import { Item } from "dynamoose/dist/Item";
+/**
+ * Shared audit fields contract for Dynamoose entities.
+ * Combine with `Item` so module models satisfy Dynamoose generic constraints.
+ */
+export interface BaseDynamooseFields {
+    created_time?: Date;
+    updated_time?: Date;
+    created_user?: string;
+    updated_user?: string;
+}
+/**
+ * Base Dynamoose model that all module models should extend.
+ * Provides Dynamoose Item methods plus shared audit fields.
+ */
+export interface BaseDynamooseModel extends Item, BaseDynamooseFields {
+}
+/**
+ * Reusable runtime schema fragment for audit fields.
+ * Spread this into Dynamoose schema definitions to avoid duplication.
+ */
+export declare const BASE_DYNAMOOSE_AUDIT_SCHEMA: {
+    readonly created_time: DateConstructor;
+    readonly updated_time: DateConstructor;
+    readonly created_user: StringConstructor;
+    readonly updated_user: StringConstructor;
+};
+/**
+ * Auth payload used by DAO methods for audit stamping.
+ */
+export type AuthContext = {
+    userSub?: string;
+};

package/dist/base-dynamoose-model.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_DYNAMOOSE_AUDIT_SCHEMA = void 0;
+/**
+ * Reusable runtime schema fragment for audit fields.
+ * Spread this into Dynamoose schema definitions to avoid duplication.
+ */
+exports.BASE_DYNAMOOSE_AUDIT_SCHEMA = {
+    created_time: Date,
+    updated_time: Date,
+    created_user: String,
+    updated_user: String
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1keW5hbW9vc2UtbW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYmFzZS1keW5hbW9vc2UtbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBbUJBOzs7R0FHRztBQUNVLFFBQUEsMkJBQTJCLEdBQUc7SUFDdkMsWUFBWSxFQUFFLElBQUk7SUFDbEIsWUFBWSxFQUFFLElBQUk7SUFDbEIsWUFBWSxFQUFFLE1BQU07SUFDcEIsWUFBWSxFQUFFLE1BQU07Q0FDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSXRlbSB9IGZyb20gXCJkeW5hbW9vc2UvZGlzdC9JdGVtXCI7XG5cbi8qKlxuICogU2hhcmVkIGF1ZGl0IGZpZWxkcyBjb250cmFjdCBmb3IgRHluYW1vb3NlIGVudGl0aWVzLlxuICogQ29tYmluZSB3aXRoIGBJdGVtYCBzbyBtb2R1bGUgbW9kZWxzIHNhdGlzZnkgRHluYW1vb3NlIGdlbmVyaWMgY29uc3RyYWludHMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQmFzZUR5bmFtb29zZUZpZWxkcyB7XG4gICAgY3JlYXRlZF90aW1lPzogRGF0ZTtcbiAgICB1cGRhdGVkX3RpbWU/OiBEYXRlO1xuICAgIGNyZWF0ZWRfdXNlcj86IHN0cmluZztcbiAgICB1cGRhdGVkX3VzZXI/OiBzdHJpbmc7XG59XG5cbi8qKlxuICogQmFzZSBEeW5hbW9vc2UgbW9kZWwgdGhhdCBhbGwgbW9kdWxlIG1vZGVscyBzaG91bGQgZXh0ZW5kLlxuICogUHJvdmlkZXMgRHluYW1vb3NlIEl0ZW0gbWV0aG9kcyBwbHVzIHNoYXJlZCBhdWRpdCBmaWVsZHMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQmFzZUR5bmFtb29zZU1vZGVsIGV4dGVuZHMgSXRlbSwgQmFzZUR5bmFtb29zZUZpZWxkcyB7IH1cblxuLyoqXG4gKiBSZXVzYWJsZSBydW50aW1lIHNjaGVtYSBmcmFnbWVudCBmb3IgYXVkaXQgZmllbGRzLlxuICogU3ByZWFkIHRoaXMgaW50byBEeW5hbW9vc2Ugc2NoZW1hIGRlZmluaXRpb25zIHRvIGF2b2lkIGR1cGxpY2F0aW9uLlxuICovXG5leHBvcnQgY29uc3QgQkFTRV9EWU5BTU9PU0VfQVVESVRfU0NIRU1BID0ge1xuICAgIGNyZWF0ZWRfdGltZTogRGF0ZSxcbiAgICB1cGRhdGVkX3RpbWU6IERhdGUsXG4gICAgY3JlYXRlZF91c2VyOiBTdHJpbmcsXG4gICAgdXBkYXRlZF91c2VyOiBTdHJpbmdcbn0gYXMgY29uc3Q7XG5cbi8qKlxuICogQXV0aCBwYXlsb2FkIHVzZWQgYnkgREFPIG1ldGhvZHMgZm9yIGF1ZGl0IHN0YW1waW5nLlxuICovXG5leHBvcnQgdHlwZSBBdXRoQ29udGV4dCA9IHtcbiAgICB1c2VyU3ViPzogc3RyaW5nO1xufTtcbiJdfQ==

package/dist/config/database-factory.js

@@ -29,7 +29,7 @@ class DatabaseFactory {
     }
     static getTableName(baseTableName) {
         const config = environment_config_1.envManager.getDatabaseConfig();
-        return `${config.tablePrefix}${baseTableName}`;
+        return `${baseTableName}`;
     }
     static resetInstances() {
         DatabaseFactory.dynamoDBInstance = undefined;
@@ -40,4 +40,4 @@ exports.DatabaseFactory = DatabaseFactory;
 // Export singleton instances for backward compatibility
 exports.dynamoDB = DatabaseFactory.getDynamoDBClient();
 exports.mapper = DatabaseFactory.getDataMapper();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/config/table-names.d.ts

@@ -16,6 +16,9 @@ export declare const BASE_TABLE_NAMES: {
     readonly ORDER_REVIEW_FEEDBACK: "OrderReviewFeedbackTable";
     readonly CATERING_REQUEST: "CateringRequestTable";
     readonly FMP_REQUEST_CALLBACK: "FmpRequestCallbackTable";
+    readonly PLATTER_FIT: "PlatterFitTable";
+    readonly INFLUENCER_PROMO: "InfluencerPromoTable";
+    readonly INFLUENCER_REFERRAL: "InfluencerReferralTable";
     readonly ORDER: "OrderTable";
     readonly ORDER_ADDRESS: "OrderAddressTable";
     readonly ORDER_REVIEW: "OrderReviewTable";
@@ -71,6 +74,9 @@ export declare const TABLE_NAMES: {
     readonly ORDER_REVIEW_FEEDBACK: string;
     readonly CATERING_REQUEST: string;
     readonly FMP_REQUEST_CALLBACK: string;
+    readonly PLATTER_FIT: string;
+    readonly INFLUENCER_PROMO: string;
+    readonly INFLUENCER_REFERRAL: string;
     readonly ORDER: string;
     readonly ORDER_ADDRESS: string;
     readonly ORDER_REVIEW: string;

package/dist/config/table-names.js

@@ -22,6 +22,9 @@ exports.BASE_TABLE_NAMES = {
     ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',
     CATERING_REQUEST: 'CateringRequestTable',
     FMP_REQUEST_CALLBACK: 'FmpRequestCallbackTable',
+    PLATTER_FIT: 'PlatterFitTable',
+    INFLUENCER_PROMO: 'InfluencerPromoTable',
+    INFLUENCER_REFERRAL: 'InfluencerReferralTable',
     // Order Module Tables
     ORDER: 'OrderTable',
     ORDER_ADDRESS: 'OrderAddressTable',
@@ -92,6 +95,9 @@ exports.TABLE_NAMES = {
     ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),
     CATERING_REQUEST: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CATERING_REQUEST),
     FMP_REQUEST_CALLBACK: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.FMP_REQUEST_CALLBACK),
+    PLATTER_FIT: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.PLATTER_FIT),
+    INFLUENCER_PROMO: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.INFLUENCER_PROMO),
+    INFLUENCER_REFERRAL: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.INFLUENCER_REFERRAL),
     // Order Module Tables
     ORDER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER),
     ORDER_ADDRESS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER_ADDRESS),
@@ -128,4 +134,4 @@ exports.TABLE_NAMES = {
     ACTIVITY_LOGS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ACTIVITY_LOGS),
     QUOTATIONS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.QUOTATIONS),
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-names.js","sourceRoot":"","sources":["../../src/config/table-names.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatabaseFactory } from './database-factory';\n\n// Base table names (without environment prefix)\nexport const BASE_TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: 'AppFeedbackTable',\n    LSQ_CRM: 'LsqCrmTable',\n    CUTLERY: 'CutleryTable',\n    ITEM_ACCOMPANIMENTS: 'ItemAccompanimentsTable',\n    CUISINE: 'CuisineTable',\n    TIER_DETAILS: 'TierDetailsTable',\n    USER_ORDER_SUMMARY: 'UserOrderSummaryTable',\n    TIER_REFERRAL: 'TierReferralTable',\n    USER_ADDRESS_REQUEST: 'UserAddressRequestTable',\n    COMMON_FEEDBACK: 'CommonFeedbackTable',\n    GUEST_FEEDBACK: 'GuestFeedbackTable',\n    COUNTER: 'CounterTable',\n    REQUEST_INVOICE: 'RequestInvoiceTable',\n    PLATTER_SEARCH_EVENTS: 'PlatterSearchEventsTable',\n    ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',\n    CATERING_REQUEST: 'CateringRequestTable',\n    FMP_REQUEST_CALLBACK: 'FmpRequestCallbackTable',\n\n    // Order Module Tables\n    ORDER: 'OrderTable',\n    ORDER_ADDRESS: 'OrderAddressTable',\n    ORDER_REVIEW: 'OrderReviewTable',\n    PAYMENT: 'PaymentTable',\n    PLATE_ORDER: 'PlateOrderTable',\n    TRACKING: 'TrackingTable',\n    USER_ADDRESS: 'UserAddressTable',\n    USER_SPECIFICS: 'UserSpecificsTable',\n    BBQ_SKEWERS: 'BbqSkewersTable',\n\n    // Other Customer Tables\n    ADD_ONS: 'AddOnsTable',\n    BANK_DETAILS: 'BankDetailsTable',\n    CART: 'CartTable',\n    CART_CATEGORIES: 'CartCategoriesTable',\n    CATEGORY: 'CategoryTable',\n    CATERING: 'CateringTable',\n    CONTENT: 'ContentTable',\n    COUPONS: 'CouponsTable',\n    DEFAULT_PLATTER: 'DefaultPlatterTable',\n    DEFAULT_PLATTER_CATEGORIES: 'DefaultPlatterCategoriesTable',\n    DEFAULT_PLATTER_ITEMS: 'DefaultPlatterItemsTable',\n    EVENT_EXECUTIVES: 'EventExecutivesTable',\n    ITEMS: 'ItemsTable',\n    LEAD: 'LeadTable',\n    OCCASION: 'OccasionTable',\n    REFERRAL_CONTENT: 'ReferralContentTable',\n    USER: 'UserTable',\n    WALLET: 'WalletTable',\n    WALLET_TRANSACTION: 'WalletTransactionTable',\n    WITHDRAWN: 'WithdrawnTable',\n\n    // Internal User Tables\n    INTERNAL_USER: 'InternalUserTable',\n    ACTIVITY_LOGS: 'ActivityLogsTable',\n    QUOTATIONS: 'QuotationsTable',\n} as const;\n\n// Environment-aware table name getter\nexport class TableNameManager {\n    public static getTableName(baseTableName: string): string {\n        return DatabaseFactory.getTableName(baseTableName);\n    }\n\n    public static getAllTableNames(): Record<string, string> {\n        const tableNames: Record<string, string> = {};\n\n        Object.entries(BASE_TABLE_NAMES).forEach(([key, value]) => {\n            tableNames[key] = this.getTableName(value);\n        });\n\n        return tableNames;\n    }\n}\n\n// Export environment-aware table names\nexport const TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.APP_FEEDBACK),\n    LSQ_CRM: TableNameManager.getTableName(BASE_TABLE_NAMES.LSQ_CRM),\n    CUTLERY: TableNameManager.getTableName(BASE_TABLE_NAMES.CUTLERY),\n    ITEM_ACCOMPANIMENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEM_ACCOMPANIMENTS),\n    CUISINE: TableNameManager.getTableName(BASE_TABLE_NAMES.CUISINE),\n    TIER_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_DETAILS),\n    USER_ORDER_SUMMARY: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ORDER_SUMMARY),\n    TIER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_REFERRAL),\n    USER_ADDRESS_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS_REQUEST),\n    COMMON_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.COMMON_FEEDBACK),\n    GUEST_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.GUEST_FEEDBACK),\n    COUNTER: TableNameManager.getTableName(BASE_TABLE_NAMES.COUNTER),\n    REQUEST_INVOICE: TableNameManager.getTableName(BASE_TABLE_NAMES.REQUEST_INVOICE),\n    PLATTER_SEARCH_EVENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_SEARCH_EVENTS),\n    ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),\n    CATERING_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING_REQUEST),\n    FMP_REQUEST_CALLBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.FMP_REQUEST_CALLBACK),\n\n    // Order Module Tables\n    ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER),\n    ORDER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_ADDRESS),\n    ORDER_REVIEW: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW),\n    PAYMENT: TableNameManager.getTableName(BASE_TABLE_NAMES.PAYMENT),\n    PLATE_ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATE_ORDER),\n    TRACKING: TableNameManager.getTableName(BASE_TABLE_NAMES.TRACKING),\n    USER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS),\n    USER_SPECIFICS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_SPECIFICS),\n    BBQ_SKEWERS: TableNameManager.getTableName(BASE_TABLE_NAMES.BBQ_SKEWERS),\n\n    // Other Customer Tables\n    ADD_ONS: TableNameManager.getTableName(BASE_TABLE_NAMES.ADD_ONS),\n    BANK_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.BANK_DETAILS),\n    CART: TableNameManager.getTableName(BASE_TABLE_NAMES.CART),\n    CART_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.CART_CATEGORIES),\n    CATEGORY: TableNameManager.getTableName(BASE_TABLE_NAMES.CATEGORY),\n    CATERING: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING),\n    CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.CONTENT),\n    COUPONS: TableNameManager.getTableName(BASE_TABLE_NAMES.COUPONS),\n    DEFAULT_PLATTER: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER),\n    DEFAULT_PLATTER_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_CATEGORIES),\n    DEFAULT_PLATTER_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_ITEMS),\n    EVENT_EXECUTIVES: TableNameManager.getTableName(BASE_TABLE_NAMES.EVENT_EXECUTIVES),\n    ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEMS),\n    LEAD: TableNameManager.getTableName(BASE_TABLE_NAMES.LEAD),\n    OCCASION: TableNameManager.getTableName(BASE_TABLE_NAMES.OCCASION),\n    REFERRAL_CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.REFERRAL_CONTENT),\n    USER: TableNameManager.getTableName(BASE_TABLE_NAMES.USER),\n    WALLET: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET),\n    WALLET_TRANSACTION: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET_TRANSACTION),\n    WITHDRAWN: TableNameManager.getTableName(BASE_TABLE_NAMES.WITHDRAWN),\n\n    // Internal User Tables\n    INTERNAL_USER: TableNameManager.getTableName(BASE_TABLE_NAMES.INTERNAL_USER),\n    ACTIVITY_LOGS: TableNameManager.getTableName(BASE_TABLE_NAMES.ACTIVITY_LOGS),\n    QUOTATIONS: TableNameManager.getTableName(BASE_TABLE_NAMES.QUOTATIONS),\n} as const;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-names.js","sourceRoot":"","sources":["../../src/config/table-names.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatabaseFactory } from './database-factory';\n\n// Base table names (without environment prefix)\nexport const BASE_TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: 'AppFeedbackTable',\n    LSQ_CRM: 'LsqCrmTable',\n    CUTLERY: 'CutleryTable',\n    ITEM_ACCOMPANIMENTS: 'ItemAccompanimentsTable',\n    CUISINE: 'CuisineTable',\n    TIER_DETAILS: 'TierDetailsTable',\n    USER_ORDER_SUMMARY: 'UserOrderSummaryTable',\n    TIER_REFERRAL: 'TierReferralTable',\n    USER_ADDRESS_REQUEST: 'UserAddressRequestTable',\n    COMMON_FEEDBACK: 'CommonFeedbackTable',\n    GUEST_FEEDBACK: 'GuestFeedbackTable',\n    COUNTER: 'CounterTable',\n    REQUEST_INVOICE: 'RequestInvoiceTable',\n    PLATTER_SEARCH_EVENTS: 'PlatterSearchEventsTable',\n    ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',\n    CATERING_REQUEST: 'CateringRequestTable',\n    FMP_REQUEST_CALLBACK: 'FmpRequestCallbackTable',\n    PLATTER_FIT: 'PlatterFitTable',\n    INFLUENCER_PROMO: 'InfluencerPromoTable',\n    INFLUENCER_REFERRAL: 'InfluencerReferralTable',\n\n    // Order Module Tables\n    ORDER: 'OrderTable',\n    ORDER_ADDRESS: 'OrderAddressTable',\n    ORDER_REVIEW: 'OrderReviewTable',\n    PAYMENT: 'PaymentTable',\n    PLATE_ORDER: 'PlateOrderTable',\n    TRACKING: 'TrackingTable',\n    USER_ADDRESS: 'UserAddressTable',\n    USER_SPECIFICS: 'UserSpecificsTable',\n    BBQ_SKEWERS: 'BbqSkewersTable',\n\n    // Other Customer Tables\n    ADD_ONS: 'AddOnsTable',\n    BANK_DETAILS: 'BankDetailsTable',\n    CART: 'CartTable',\n    CART_CATEGORIES: 'CartCategoriesTable',\n    CATEGORY: 'CategoryTable',\n    CATERING: 'CateringTable',\n    CONTENT: 'ContentTable',\n    COUPONS: 'CouponsTable',\n    DEFAULT_PLATTER: 'DefaultPlatterTable',\n    DEFAULT_PLATTER_CATEGORIES: 'DefaultPlatterCategoriesTable',\n    DEFAULT_PLATTER_ITEMS: 'DefaultPlatterItemsTable',\n    EVENT_EXECUTIVES: 'EventExecutivesTable',\n    ITEMS: 'ItemsTable',\n    LEAD: 'LeadTable',\n    OCCASION: 'OccasionTable',\n    REFERRAL_CONTENT: 'ReferralContentTable',\n    USER: 'UserTable',\n    WALLET: 'WalletTable',\n    WALLET_TRANSACTION: 'WalletTransactionTable',\n    WITHDRAWN: 'WithdrawnTable',\n\n    // Internal User Tables\n    INTERNAL_USER: 'InternalUserTable',\n    ACTIVITY_LOGS: 'ActivityLogsTable',\n    QUOTATIONS: 'QuotationsTable',\n} as const;\n\n// Environment-aware table name getter\nexport class TableNameManager {\n    public static getTableName(baseTableName: string): string {\n        return DatabaseFactory.getTableName(baseTableName);\n    }\n\n    public static getAllTableNames(): Record<string, string> {\n        const tableNames: Record<string, string> = {};\n\n        Object.entries(BASE_TABLE_NAMES).forEach(([key, value]) => {\n            tableNames[key] = this.getTableName(value);\n        });\n\n        return tableNames;\n    }\n}\n\n// Export environment-aware table names\nexport const TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.APP_FEEDBACK),\n    LSQ_CRM: TableNameManager.getTableName(BASE_TABLE_NAMES.LSQ_CRM),\n    CUTLERY: TableNameManager.getTableName(BASE_TABLE_NAMES.CUTLERY),\n    ITEM_ACCOMPANIMENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEM_ACCOMPANIMENTS),\n    CUISINE: TableNameManager.getTableName(BASE_TABLE_NAMES.CUISINE),\n    TIER_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_DETAILS),\n    USER_ORDER_SUMMARY: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ORDER_SUMMARY),\n    TIER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_REFERRAL),\n    USER_ADDRESS_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS_REQUEST),\n    COMMON_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.COMMON_FEEDBACK),\n    GUEST_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.GUEST_FEEDBACK),\n    COUNTER: TableNameManager.getTableName(BASE_TABLE_NAMES.COUNTER),\n    REQUEST_INVOICE: TableNameManager.getTableName(BASE_TABLE_NAMES.REQUEST_INVOICE),\n    PLATTER_SEARCH_EVENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_SEARCH_EVENTS),\n    ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),\n    CATERING_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING_REQUEST),\n    FMP_REQUEST_CALLBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.FMP_REQUEST_CALLBACK),\n    PLATTER_FIT: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_FIT),\n    INFLUENCER_PROMO: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_PROMO),\n    INFLUENCER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_REFERRAL),\n\n    // Order Module Tables\n    ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER),\n    ORDER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_ADDRESS),\n    ORDER_REVIEW: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW),\n    PAYMENT: TableNameManager.getTableName(BASE_TABLE_NAMES.PAYMENT),\n    PLATE_ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATE_ORDER),\n    TRACKING: TableNameManager.getTableName(BASE_TABLE_NAMES.TRACKING),\n    USER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS),\n    USER_SPECIFICS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_SPECIFICS),\n    BBQ_SKEWERS: TableNameManager.getTableName(BASE_TABLE_NAMES.BBQ_SKEWERS),\n\n    // Other Customer Tables\n    ADD_ONS: TableNameManager.getTableName(BASE_TABLE_NAMES.ADD_ONS),\n    BANK_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.BANK_DETAILS),\n    CART: TableNameManager.getTableName(BASE_TABLE_NAMES.CART),\n    CART_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.CART_CATEGORIES),\n    CATEGORY: TableNameManager.getTableName(BASE_TABLE_NAMES.CATEGORY),\n    CATERING: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING),\n    CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.CONTENT),\n    COUPONS: TableNameManager.getTableName(BASE_TABLE_NAMES.COUPONS),\n    DEFAULT_PLATTER: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER),\n    DEFAULT_PLATTER_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_CATEGORIES),\n    DEFAULT_PLATTER_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_ITEMS),\n    EVENT_EXECUTIVES: TableNameManager.getTableName(BASE_TABLE_NAMES.EVENT_EXECUTIVES),\n    ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEMS),\n    LEAD: TableNameManager.getTableName(BASE_TABLE_NAMES.LEAD),\n    OCCASION: TableNameManager.getTableName(BASE_TABLE_NAMES.OCCASION),\n    REFERRAL_CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.REFERRAL_CONTENT),\n    USER: TableNameManager.getTableName(BASE_TABLE_NAMES.USER),\n    WALLET: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET),\n    WALLET_TRANSACTION: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET_TRANSACTION),\n    WITHDRAWN: TableNameManager.getTableName(BASE_TABLE_NAMES.WITHDRAWN),\n\n    // Internal User Tables\n    INTERNAL_USER: TableNameManager.getTableName(BASE_TABLE_NAMES.INTERNAL_USER),\n    ACTIVITY_LOGS: TableNameManager.getTableName(BASE_TABLE_NAMES.ACTIVITY_LOGS),\n    QUOTATIONS: TableNameManager.getTableName(BASE_TABLE_NAMES.QUOTATIONS),\n} as const;\n"]}

package/dist/customer-user/cart/cart-model.d.ts

@@ -97,6 +97,7 @@ export declare class CartModel extends BaseModel {
     baseItemCount?: number;
     liveCounterDetails?: LiveCounterDetails[];
     skewerAddons?: SkewerAddons[];
+    inprogressPlatterValue?: number;
 }
 export declare class SkewerAddons {
     itemId: string;

package/dist/customer-user/cart/cart-model.js

@@ -294,6 +294,10 @@ __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", Array)
 ], CartModel.prototype, "skewerAddons", void 0);
+__decorate([
+    (0, annotations_1.attribute)(),
+    __metadata("design:type", Number)
+], CartModel.prototype, "inprogressPlatterValue", void 0);
 exports.CartModel = CartModel = __decorate([
     (0, annotations_1.table)("CartTable")
 ], CartModel);
@@ -320,4 +324,4 @@ __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", Array)
 ], SkewerAddons.prototype, "accompaniments", void 0);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cart-model.js","sourceRoot":"","sources":["../../../src/customer-user/cart/cart-model.ts"],"names":[],"mappings":"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","sourcesContent":["import { attribute, hashKey, rangeKey, table } from \"@nova-odm/annotations\"\nimport { BaseModel } from \"../../base-model\";\n\n\nexport class GuestCount {\n    @attribute()\n    vegGuestCount: number;\n    @attribute()\n    nonVegGuestCount: number;\n    @attribute()\n    totalGuestCount?: number;\n}\n\nexport interface AddOnsDetails {\n    addOnsId: string;\n    addOnsQty: number;\n    addOnsQtyUnit: string;\n    isBonelessItem?: boolean; // V2\n    boneItemPrice?: number; // V2\n    accompaniments?: AccompanimentsDetails[];\n}\n\nexport interface AccompanimentsDetails {\n    accompanimentId: string;\n    accompanimentQty: number;\n    accompanimentQtyUnit: string;\n    isFree?: boolean; // Added New 11-11-2025\n    isBonelessItem?: boolean; // Added New 11-11-2025\n    boneItemPrice?: number; // Added New 11-11-2025\n}\n\nexport interface CutleryDetails {\n    cutleryId: string; // Added New 24-11-2025\n    cutleryQty: number; // Added New 24-11-2025\n    isServing?: boolean; // Added New 24-11-2025 // true | false\n}\n\n\n\nexport class SetPreferences {\n    @attribute()\n    pureVegGuest?: number; // In Future they should be removed.\n    @attribute()\n    spicyLevel?: string;\n    @attribute()\n    tellUsMore?: string;\n    @attribute()\n    consumeAlcohol?: string; // In Future they should be removed.\n}\n\nexport class BbqCredential {\n    @attribute()\n    isPartialGrill: boolean;\n    @attribute()\n    freeKits: number;\n    @attribute()\n    chargeableKits: number;\n    @attribute()\n    pricePerKit: number;\n}\n\nexport class LiveCounterDetails {\n    @attribute()\n    liveCounterId: string;\n    @attribute()\n    liveCounterName: string;\n    @attribute()\n    liveCounterType: string; // CHAAT_COUNTER\n    @attribute()\n    includedBatchSize: number; // 2,4,6\n    @attribute()\n    itemList: ItemList[];\n}\n\nexport class ItemList {\n    @attribute()\n    itemId: string;\n    @attribute()\n    itemName: string;\n    @attribute()\n    itemQuantity: number;\n    @attribute()\n    itemQuantityUnit: string;\n    @attribute()\n    itemType: string; // VEG, NONVEG\n    @attribute()\n    isFree: boolean;\n}\n\n@table(\"CartTable\")\nexport class CartModel extends BaseModel {\n    @hashKey({ type: 'String' })\n    userId: string;\n    @rangeKey({ type: 'String' })\n    cartId: string;\n    @attribute()\n    platterType?: string;\n    @attribute({ indexKeyConfigurations: { \"cartStatusIndex\": \"HASH\" }, type: 'String' })\n    cartStatus: string; // ACTIVE, INACTIVE, INDRAFT\n    @attribute({ indexKeyConfigurations: { \"cartStageIndex\": \"HASH\" }, type: 'String' })\n    cartStage: string; // DETAILS_NOT_FILLED, COMPLETED, ITEM_NOT_FILLED, MISSTING_DATE_TIME\n    @attribute({ indexKeyConfigurations: { \"phoneNumberIndex\": \"HASH\" }, type: 'String' })\n    phoneNumber: string;\n    @attribute()\n    occasionId?: string; // Think Again\n    @attribute()\n    cartName: string; // by default Custom Platter or Choice of Users based on their changes\n    @attribute()\n    cartImage?: string;\n    @attribute()\n    defaultPlatterId?: string;\n    @attribute()\n    cartCategoriesId?: string;\n    @attribute()\n    addressId?: string;\n    @attribute()\n    addonsId?: string[]; // Remove After This Build gone\n    @attribute()\n    couponCode?: string; // Remove After This Build gone\n    @attribute()\n    guestCount?: number; // Remove After This Build gone\n    @attribute()\n    addonsIds?: AddOnsDetails[]; // previoully they show only addonsId\n    @attribute()\n    cutleryIds?: CutleryDetails[]; // Added New 24-11-2025\n    @attribute()\n    guestCounts?: GuestCount; // previoully they show only guestCount as a number\n    @attribute()\n    selectedServiceType?: string;\n    @attribute()\n    eventDate?: string;\n    @attribute()\n    eventTime?: string;\n    @attribute()\n    minPrice?: number; // Remove After This Build gone\n    @attribute()\n    maxPrice?: number; // Remove After This Build gone\n    @attribute()\n    doorStepService: string; // Remove After This Build gone\n    @attribute()\n    deliveryService: string; // STANDARD, DOORSTEP, PREMIUM\n    @attribute()\n    setPreferences?: SetPreferences[];\n    @attribute()\n    createOwn?: boolean;\n    @attribute()\n    menuType?: string;\n    @attribute()\n    mealTime?: string; // \"BREAKFAST\", \"LUNCH\", \"DINNER\"\n    @attribute()\n    platterSubType?: string; // \"DISCOUNTED\", \"REGULAR\", \"CREATE_OWN\"\n    @attribute()\n    platterMinPrice?: number; // New Added 10-09-2025\n    @attribute()\n    addonsAccompanimentsCost?: number; // New Added 10-09-2025\n    @attribute()\n    extraQtyCost?: number; // New Added 10-09-2025\n    @attribute()\n    premiumItemsCost?: number; // New Added 10-09-2025\n    @attribute()\n    cutleryCost?: number; // New Added 10-09-2025\n    @attribute()\n    bbqCredential?: BbqCredential; // New Added 11-12-2025\n    @attribute()\n    bbqGuidelines?: boolean; // New Added 22-12-2025\n    @attribute()\n    isFMPCreated?: boolean; // New Added 06-03-2026\n\n    // catering attributes\n    @attribute()\n    helperCount?: number;\n\n    @attribute()\n    cateringServiceType?: string;\n\n    @attribute()\n    occassionList?: string[];\n\n    @attribute()\n    baseItemCount?: number;\n\n    @attribute()\n    liveCounterDetails?: LiveCounterDetails[];\n\n    @attribute()\n    skewerAddons?: SkewerAddons[];\n}\n\nexport class SkewerAddons {\n\n    @attribute()\n    itemId: string;\n\n    @attribute()\n    skewerQty: number;\n\n    @attribute()\n    skewerQtyUnit: string;\n\n    @attribute()\n    pricePerSkewer: number;\n\n    @attribute()\n    accompaniments?: AccompanimentsDetails[];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cart-model.js","sourceRoot":"","sources":["../../../src/customer-user/cart/cart-model.ts"],"names":[],"mappings":"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","sourcesContent":["import { attribute, hashKey, rangeKey, table } from \"@nova-odm/annotations\"\nimport { BaseModel } from \"../../base-model\";\n\n\nexport class GuestCount {\n    @attribute()\n    vegGuestCount: number;\n    @attribute()\n    nonVegGuestCount: number;\n    @attribute()\n    totalGuestCount?: number;\n}\n\nexport interface AddOnsDetails {\n    addOnsId: string;\n    addOnsQty: number;\n    addOnsQtyUnit: string;\n    isBonelessItem?: boolean; // V2\n    boneItemPrice?: number; // V2\n    accompaniments?: AccompanimentsDetails[];\n}\n\nexport interface AccompanimentsDetails {\n    accompanimentId: string;\n    accompanimentQty: number;\n    accompanimentQtyUnit: string;\n    isFree?: boolean; // Added New 11-11-2025\n    isBonelessItem?: boolean; // Added New 11-11-2025\n    boneItemPrice?: number; // Added New 11-11-2025\n}\n\nexport interface CutleryDetails {\n    cutleryId: string; // Added New 24-11-2025\n    cutleryQty: number; // Added New 24-11-2025\n    isServing?: boolean; // Added New 24-11-2025 // true | false\n}\n\n\n\nexport class SetPreferences {\n    @attribute()\n    pureVegGuest?: number; // In Future they should be removed.\n    @attribute()\n    spicyLevel?: string;\n    @attribute()\n    tellUsMore?: string;\n    @attribute()\n    consumeAlcohol?: string; // In Future they should be removed.\n}\n\nexport class BbqCredential {\n    @attribute()\n    isPartialGrill: boolean;\n    @attribute()\n    freeKits: number;\n    @attribute()\n    chargeableKits: number;\n    @attribute()\n    pricePerKit: number;\n}\n\nexport class LiveCounterDetails {\n    @attribute()\n    liveCounterId: string;\n    @attribute()\n    liveCounterName: string;\n    @attribute()\n    liveCounterType: string; // CHAAT_COUNTER\n    @attribute()\n    includedBatchSize: number; // 2,4,6\n    @attribute()\n    itemList: ItemList[];\n}\n\nexport class ItemList {\n    @attribute()\n    itemId: string;\n    @attribute()\n    itemName: string;\n    @attribute()\n    itemQuantity: number;\n    @attribute()\n    itemQuantityUnit: string;\n    @attribute()\n    itemType: string; // VEG, NONVEG\n    @attribute()\n    isFree: boolean;\n}\n\n@table(\"CartTable\")\nexport class CartModel extends BaseModel {\n    @hashKey({ type: 'String' })\n    userId: string;\n    @rangeKey({ type: 'String' })\n    cartId: string;\n    @attribute()\n    platterType?: string;\n    @attribute({ indexKeyConfigurations: { \"cartStatusIndex\": \"HASH\" }, type: 'String' })\n    cartStatus: string; // ACTIVE, INACTIVE, INDRAFT\n    @attribute({ indexKeyConfigurations: { \"cartStageIndex\": \"HASH\" }, type: 'String' })\n    cartStage: string; // DETAILS_NOT_FILLED, COMPLETED, ITEM_NOT_FILLED, MISSTING_DATE_TIME\n    @attribute({ indexKeyConfigurations: { \"phoneNumberIndex\": \"HASH\" }, type: 'String' })\n    phoneNumber: string;\n    @attribute()\n    occasionId?: string; // Think Again\n    @attribute()\n    cartName: string; // by default Custom Platter or Choice of Users based on their changes\n    @attribute()\n    cartImage?: string;\n    @attribute()\n    defaultPlatterId?: string;\n    @attribute()\n    cartCategoriesId?: string;\n    @attribute()\n    addressId?: string;\n    @attribute()\n    addonsId?: string[]; // Remove After This Build gone\n    @attribute()\n    couponCode?: string; // Remove After This Build gone\n    @attribute()\n    guestCount?: number; // Remove After This Build gone\n    @attribute()\n    addonsIds?: AddOnsDetails[]; // previoully they show only addonsId\n    @attribute()\n    cutleryIds?: CutleryDetails[]; // Added New 24-11-2025\n    @attribute()\n    guestCounts?: GuestCount; // previoully they show only guestCount as a number\n    @attribute()\n    selectedServiceType?: string;\n    @attribute()\n    eventDate?: string;\n    @attribute()\n    eventTime?: string;\n    @attribute()\n    minPrice?: number; // Remove After This Build gone\n    @attribute()\n    maxPrice?: number; // Remove After This Build gone\n    @attribute()\n    doorStepService: string; // Remove After This Build gone\n    @attribute()\n    deliveryService: string; // STANDARD, DOORSTEP, PREMIUM\n    @attribute()\n    setPreferences?: SetPreferences[];\n    @attribute()\n    createOwn?: boolean;\n    @attribute()\n    menuType?: string;\n    @attribute()\n    mealTime?: string; // \"BREAKFAST\", \"LUNCH\", \"DINNER\"\n    @attribute()\n    platterSubType?: string; // \"DISCOUNTED\", \"REGULAR\", \"CREATE_OWN\"\n    @attribute()\n    platterMinPrice?: number; // New Added 10-09-2025\n    @attribute()\n    addonsAccompanimentsCost?: number; // New Added 10-09-2025\n    @attribute()\n    extraQtyCost?: number; // New Added 10-09-2025\n    @attribute()\n    premiumItemsCost?: number; // New Added 10-09-2025\n    @attribute()\n    cutleryCost?: number; // New Added 10-09-2025\n    @attribute()\n    bbqCredential?: BbqCredential; // New Added 11-12-2025\n    @attribute()\n    bbqGuidelines?: boolean; // New Added 22-12-2025\n    @attribute()\n    isFMPCreated?: boolean; // New Added 06-03-2026\n\n    // catering attributes\n    @attribute()\n    helperCount?: number;\n\n    @attribute()\n    cateringServiceType?: string;\n\n    @attribute()\n    occassionList?: string[];\n\n    @attribute()\n    baseItemCount?: number;\n\n    @attribute()\n    liveCounterDetails?: LiveCounterDetails[];\n\n    @attribute()\n    skewerAddons?: SkewerAddons[];\n\n    @attribute()\n    inprogressPlatterValue?: number;\n}\n\nexport class SkewerAddons {\n\n    @attribute()\n    itemId: string;\n\n    @attribute()\n    skewerQty: number;\n\n    @attribute()\n    skewerQtyUnit: string;\n\n    @attribute()\n    pricePerSkewer: number;\n\n    @attribute()\n    accompaniments?: AccompanimentsDetails[];\n}\n"]}

package/dist/customer-user/content/content-model.d.ts

@@ -1,4 +1,11 @@
 import { BaseModel } from "../../base-model";
+/**
+ * Arbitrary metadata: any key name, values can be primitives, nested maps, or lists (including lists of objects).
+ * Example: metadata.homeBanner = [{ platterImage, platterId, ... }, ...]; metadata.tags = ["a","b"];
+ */
+export type ContentMetadataValue = string | number | boolean | null | ContentMetadataValue[] | {
+    [key: string]: ContentMetadataValue;
+};
 export declare class ContentModel extends BaseModel {
     id: string;
     category: string;
@@ -14,4 +21,5 @@ export declare class ContentModel extends BaseModel {
     contentActive: string;
     description?: string;
     content_title?: string[];
+    metadata?: Record<string, ContentMetadataValue>;
 }