cmp-aws-database 1.2.0-dev.78 → 1.2.0-dev.79

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

@@ -0,0 +1,27 @@
+import { BaseModel } from './base-model';
+export interface AuthContext {
+    userSub: string;
+    clientId?: string;
+}
+export declare const dynamoDB: import("@aws-sdk/client-dynamodb").DynamoDB;
+export declare class GenericDAO<T extends BaseModel> {
+    protected model: any;
+    constructor(model: any);
+    batchUpdate(items: T[], batchSize?: number, authContext?: AuthContext): Promise<T[]>;
+    parallelBatchPut(inputItems: T[], batchSize?: number, maxConcurrentSegments?: number, authContext?: AuthContext): Promise<T[]>;
+    parallelBatchDelete(inputItems: T[], batchSize?: number, maxConcurrentSegments?: number): Promise<T[]>;
+    parallelScan(options?: Record<string, unknown>): Promise<T[]>;
+    scan(options?: Record<string, unknown>): Promise<T[]>;
+    save(item: T, authContext?: AuthContext): Promise<T>;
+    update(item: T, authContext?: AuthContext): Promise<T>;
+    delete(item: T): Promise<T | undefined>;
+    get(item: T): Promise<T>;
+    batchPut(items: T[], authContext?: AuthContext): Promise<T[]>;
+    batchDelete(items: T[]): Promise<T[]>;
+    batchGet(items: T[]): Promise<T[]>;
+    parallelBatchGet(inputItems: T[], batchSize?: number, maxConcurrentSegments?: number): Promise<T[]>;
+    parallelQuery(keyConditions: Record<string, unknown>[], maxConcurrentCalls?: number, options?: Record<string, unknown>): Promise<T[]>;
+    private customQuery;
+    decode(continuationToken: string | undefined): Record<string, unknown> | undefined;
+    encode(lastEvaluatedKey: Record<string, unknown>): Promise<string>;
+}

package/dist/base-dao-dynamoose.js

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericDAO = exports.dynamoDB = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+exports.dynamoDB = new dynamoose_1.default.aws.ddb.DynamoDB({
+    maxAttempts: 10
+});
+class GenericDAO {
+    constructor(model) {
+        this.model = model;
+    }
+    async batchUpdate(items, batchSize = 100, authContext) {
+        let success = 0, totalToUpdate = items.length;
+        let updateItems = [];
+        while (items.length > 0) {
+            let promises = [];
+            let batch = items.splice(0, batchSize);
+            promises = batch.map(item => this.update(item, authContext));
+            let results = await Promise.allSettled(promises);
+            results.forEach(result => {
+                if (result.status === "fulfilled") {
+                    success += 1;
+                    updateItems.push(result.value);
+                }
+            });
+            console.log(`${success}/${totalToUpdate}`);
+        }
+        return updateItems;
+    }
+    async parallelBatchPut(inputItems, batchSize = 1000, maxConcurrentSegments = 20, authContext) {
+        let startTime = Date.now();
+        let items = [];
+        items = items.concat(inputItems);
+        items = items.map(item => {
+            item.created_time = new Date();
+            if (authContext) {
+                item.created_user = authContext.userSub;
+            }
+            return item;
+        });
+        let maxSegments = [];
+        let putItems = [];
+        while (items.length > 0) {
+            let batch = items.splice(0, batchSize * maxConcurrentSegments);
+            let segment = [];
+            while (batch.length > 0) {
+                segment.push(batch.splice(0, batchSize));
+            }
+            maxSegments.push(segment);
+        }
+        for (const segment of maxSegments) {
+            let startTime = Date.now();
+            let promises = [];
+            console.log(`batch length = ${segment.length}`);
+            for (const batch of segment) {
+                promises.push(this.batchPut(batch, authContext));
+            }
+            let result = await Promise.all(promises);
+            console.log("segment complete");
+            result.forEach((res) => {
+                putItems = putItems.concat(res);
+            });
+            console.log(`time for segment put ${Date.now() - startTime}`);
+        }
+        console.log(`total time for complete parallel put ${Date.now() - startTime}`);
+        return putItems;
+    }
+    async parallelBatchDelete(inputItems, batchSize = 1000, maxConcurrentSegments = 20) {
+        let startTime = Date.now();
+        let items = [];
+        items = items.concat(inputItems);
+        let maxSegments = [];
+        let deletedItems = [];
+        while (items.length > 0) {
+            let batch = items.splice(0, batchSize * maxConcurrentSegments);
+            let segment = [];
+            while (batch.length > 0) {
+                segment.push(batch.splice(0, batchSize));
+            }
+            maxSegments.push(segment);
+        }
+        for (const segment of maxSegments) {
+            let startTime = Date.now();
+            let promises = [];
+            console.log(`batch length = ${segment.length}`);
+            for (const batch of segment) {
+                promises.push(this.batchDelete(batch));
+            }
+            let result = await Promise.all(promises);
+            console.log("segment complete");
+            result.forEach((res) => {
+                deletedItems = deletedItems.concat(res);
+            });
+            console.log(`time for segment delete ${Date.now() - startTime}`);
+        }
+        console.log(`total time for complete parallel delete ${Date.now() - startTime}`);
+        return deletedItems;
+    }
+    async parallelScan(options) {
+        let items = [];
+        const scan = this.model.scan().all();
+        for await (const item of scan) {
+            items.push(item);
+            if (items.length % 100000 === 0) {
+                console.log("read 100K");
+            }
+        }
+        return items;
+    }
+    async scan(options) {
+        let items = [];
+        const scan = this.model.scan();
+        for await (const item of scan) {
+            items.push(item);
+        }
+        return items;
+    }
+    async save(item, authContext) {
+        item.created_time = new Date();
+        if (authContext) {
+            item.created_user = authContext.userSub;
+        }
+        const res = await this.model.create(item);
+        return res;
+    }
+    async update(item, authContext) {
+        item.updated_time = new Date();
+        if (authContext) {
+            item.updated_user = authContext.userSub;
+        }
+        const res = await this.model.update(item);
+        return res;
+    }
+    async delete(item) {
+        return await this.model.delete(item);
+    }
+    async get(item) {
+        const res = await this.model.get(item);
+        return res;
+    }
+    async batchPut(items, authContext) {
+        let finalItems = [];
+        items = items.map(item => {
+            item.created_time = new Date();
+            if (authContext) {
+                item.created_user = authContext.userSub;
+            }
+            return item;
+        });
+        for await (const item of this.model.batchPut(items)) {
+            console.log(item);
+            finalItems.push(item);
+        }
+        return finalItems;
+    }
+    async batchDelete(items) {
+        let deleteItems = [];
+        for await (const item of this.model.batchDelete(items)) {
+            deleteItems.push(item);
+        }
+        return deleteItems;
+    }
+    async batchGet(items) {
+        let getItems = [];
+        for await (const item of this.model.batchGet(items)) {
+            getItems.push(item);
+        }
+        return getItems;
+    }
+    async parallelBatchGet(inputItems, batchSize = 1000, maxConcurrentSegments = 20) {
+        let startTime = Date.now();
+        let items = [];
+        items = items.concat(inputItems);
+        let maxSegments = [];
+        let resultItems = [];
+        while (items.length > 0) {
+            let batch = items.splice(0, batchSize * maxConcurrentSegments);
+            let segment = [];
+            while (batch.length > 0) {
+                segment.push(batch.splice(0, batchSize));
+            }
+            maxSegments.push(segment);
+        }
+        for (const segment of maxSegments) {
+            let startTime = Date.now();
+            let promises = [];
+            console.log(`batch length = ${segment.length}`);
+            for (const batch of segment) {
+                promises.push(this.batchGet(batch));
+            }
+            let result = await Promise.all(promises);
+            console.log("segment complete");
+            result.forEach((res) => {
+                resultItems = resultItems.concat(res);
+            });
+            console.log(`time for segment get ${Date.now() - startTime}`);
+        }
+        console.log(`total time for complete parallel get ${Date.now() - startTime}`);
+        return resultItems;
+    }
+    async parallelQuery(keyConditions, maxConcurrentCalls = 20, options) {
+        const startTime = Date.now();
+        const results = [];
+        while (keyConditions.length > 0) {
+            const segmentConditions = keyConditions.splice(0, maxConcurrentCalls);
+            const queryPromises = segmentConditions.map((keyCondition) => {
+                return this.customQuery(keyCondition, options);
+            });
+            const queryResults = await Promise.all(queryPromises);
+            for (const queryResult of queryResults) {
+                results.push(...queryResult);
+            }
+        }
+        console.log(`total time for complete parallel query ${Date.now() - startTime}`);
+        return results;
+    }
+    async customQuery(keyConditions, options) {
+        const startTime = Date.now();
+        const items = [];
+        const query = this.model.query(keyConditions);
+        if (options?.limit)
+            query.limit(options.limit);
+        for await (const item of query) {
+            items.push(item);
+        }
+        console.log(`total time for complete query ${Date.now() - startTime}`);
+        return items;
+    }
+    decode(continuationToken) {
+        if (continuationToken) {
+            try {
+                let lastEvaluatedKey = JSON.parse(Buffer.from(continuationToken, 'base64').toString('utf8'));
+                console.log("Incoming Last Evaluated Key " + lastEvaluatedKey);
+                return lastEvaluatedKey;
+            }
+            catch (error) {
+                throw new Error('Invalid continuationToken');
+            }
+        }
+        return undefined;
+    }
+    async encode(lastEvaluatedKey) {
+        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString('base64');
+    }
+}
+exports.GenericDAO = GenericDAO;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dao-dynamoose.js","sourceRoot":"","sources":["../src/base-dao-dynamoose.ts"],"names":[],"mappings":"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","sourcesContent":["import dynamoose from 'dynamoose';\nimport { BaseModel } from './base-model';\n\nexport interface AuthContext {\n    userSub: string;\n    clientId?: string;\n}\n\nexport const dynamoDB = new dynamoose.aws.ddb.DynamoDB({\n    maxAttempts: 10\n});\n\nexport class GenericDAO<T extends BaseModel> {\n    constructor(protected model: any) { }\n\n    async batchUpdate(items: T[], batchSize = 100, authContext?: AuthContext): Promise<T[]> {\n        let success = 0, totalToUpdate = items.length;\n        let updateItems: T[] = [];\n\n        while (items.length > 0) {\n            let promises: Promise<T>[] = [];\n            let batch = items.splice(0, batchSize);\n            promises = batch.map(item => this.update(item, authContext));\n            let results = await Promise.allSettled(promises);\n\n            results.forEach(result => {\n                if (result.status === \"fulfilled\") {\n                    success += 1;\n                    updateItems.push(result.value);\n                }\n            });\n            console.log(`${success}/${totalToUpdate}`);\n        }\n        return updateItems;\n    }\n\n    async parallelBatchPut(inputItems: T[], batchSize: number = 1000, maxConcurrentSegments: number = 20, authContext?: AuthContext): Promise<T[]> {\n        let startTime = Date.now();\n        let items: T[] = [];\n        items = items.concat(inputItems);\n        items = items.map(item => {\n            item.created_time = new Date();\n            if (authContext) {\n                item.created_user = authContext.userSub;\n            }\n            return item;\n        });\n\n        let maxSegments: T[][][] = [];\n        let putItems: T[] = [];\n\n        while (items.length > 0) {\n            let batch = items.splice(0, batchSize * maxConcurrentSegments);\n            let segment: T[][] = [];\n            while (batch.length > 0) {\n                segment.push(batch.splice(0, batchSize));\n            }\n            maxSegments.push(segment);\n        }\n\n        for (const segment of maxSegments) {\n            let startTime = Date.now();\n            let promises: Promise<T[]>[] = [];\n            console.log(`batch length = ${segment.length}`);\n\n            for (const batch of segment) {\n                promises.push(this.batchPut(batch, authContext));\n            }\n\n            let result = await Promise.all(promises);\n            console.log(\"segment complete\");\n            result.forEach((res) => {\n                putItems = putItems.concat(res);\n            });\n            console.log(`time for segment put ${Date.now() - startTime}`);\n        }\n\n        console.log(`total time for complete parallel put ${Date.now() - startTime}`);\n        return putItems;\n    }\n\n    async parallelBatchDelete(inputItems: T[], batchSize: number = 1000, maxConcurrentSegments: number = 20): Promise<T[]> {\n        let startTime = Date.now();\n        let items: T[] = [];\n        items = items.concat(inputItems);\n        let maxSegments: T[][][] = [];\n        let deletedItems: T[] = [];\n\n        while (items.length > 0) {\n            let batch = items.splice(0, batchSize * maxConcurrentSegments);\n            let segment: T[][] = [];\n            while (batch.length > 0) {\n                segment.push(batch.splice(0, batchSize));\n            }\n            maxSegments.push(segment);\n        }\n\n        for (const segment of maxSegments) {\n            let startTime = Date.now();\n            let promises: Promise<T[]>[] = [];\n            console.log(`batch length = ${segment.length}`);\n\n            for (const batch of segment) {\n                promises.push(this.batchDelete(batch));\n            }\n\n            let result = await Promise.all(promises);\n            console.log(\"segment complete\");\n            result.forEach((res) => {\n                deletedItems = deletedItems.concat(res);\n            });\n            console.log(`time for segment delete ${Date.now() - startTime}`);\n        }\n\n        console.log(`total time for complete parallel delete ${Date.now() - startTime}`);\n        return deletedItems;\n    }\n\n    async parallelScan(options?: Record<string, unknown>): Promise<T[]> {\n        let items: T[] = [];\n        const scan = this.model.scan().all();\n\n        for await (const item of scan) {\n            items.push(item);\n            if (items.length % 100000 === 0) {\n                console.log(\"read 100K\");\n            }\n        }\n        return items;\n    }\n\n    async scan(options?: Record<string, unknown>): Promise<T[]> {\n        let items: T[] = [];\n        const scan = this.model.scan();\n\n        for await (const item of scan) {\n            items.push(item);\n        }\n        return items;\n    }\n\n    async save(item: T, authContext?: AuthContext): Promise<T> {\n        item.created_time = new Date();\n        if (authContext) {\n            item.created_user = authContext.userSub;\n        }\n        const res = await this.model.create(item);\n        return res;\n    }\n\n    async update(item: T, authContext?: AuthContext): Promise<T> {\n        item.updated_time = new Date();\n        if (authContext) {\n            item.updated_user = authContext.userSub;\n        }\n        const res = await this.model.update(item);\n        return res;\n    }\n\n    async delete(item: T): Promise<T | undefined> {\n        return await this.model.delete(item);\n    }\n\n    async get(item: T): Promise<T> {\n        const res = await this.model.get(item);\n        return res;\n    }\n\n    async batchPut(items: T[], authContext?: AuthContext): Promise<T[]> {\n        let finalItems: T[] = [];\n        items = items.map(item => {\n            item.created_time = new Date();\n            if (authContext) {\n                item.created_user = authContext.userSub;\n            }\n            return item;\n        });\n\n        for await (const item of this.model.batchPut(items)) {\n            console.log(item);\n            finalItems.push(item);\n        }\n        return finalItems;\n    }\n\n    async batchDelete(items: T[]): Promise<T[]> {\n        let deleteItems: T[] = [];\n        for await (const item of this.model.batchDelete(items)) {\n            deleteItems.push(item);\n        }\n        return deleteItems;\n    }\n\n    async batchGet(items: T[]): Promise<T[]> {\n        let getItems: T[] = [];\n        for await (const item of this.model.batchGet(items)) {\n            getItems.push(item);\n        }\n        return getItems;\n    }\n\n    async parallelBatchGet(inputItems: T[], batchSize: number = 1000, maxConcurrentSegments: number = 20): Promise<T[]> {\n        let startTime = Date.now();\n        let items: T[] = [];\n        items = items.concat(inputItems);\n        let maxSegments: T[][][] = [];\n        let resultItems: T[] = [];\n\n        while (items.length > 0) {\n            let batch = items.splice(0, batchSize * maxConcurrentSegments);\n            let segment: T[][] = [];\n            while (batch.length > 0) {\n                segment.push(batch.splice(0, batchSize));\n            }\n            maxSegments.push(segment);\n        }\n\n        for (const segment of maxSegments) {\n            let startTime = Date.now();\n            let promises: Promise<T[]>[] = [];\n            console.log(`batch length = ${segment.length}`);\n\n            for (const batch of segment) {\n                promises.push(this.batchGet(batch));\n            }\n\n            let result = await Promise.all(promises);\n            console.log(\"segment complete\");\n            result.forEach((res) => {\n                resultItems = resultItems.concat(res);\n            });\n            console.log(`time for segment get ${Date.now() - startTime}`);\n        }\n\n        console.log(`total time for complete parallel get ${Date.now() - startTime}`);\n        return resultItems;\n    }\n\n    async parallelQuery(\n        keyConditions: Record<string, unknown>[],\n        maxConcurrentCalls: number = 20,\n        options?: Record<string, unknown>\n    ): Promise<T[]> {\n        const startTime = Date.now();\n        const results: T[] = [];\n\n        while (keyConditions.length > 0) {\n            const segmentConditions = keyConditions.splice(0, maxConcurrentCalls);\n            const queryPromises = segmentConditions.map((keyCondition) => {\n                return this.customQuery(keyCondition, options);\n            });\n\n            const queryResults = await Promise.all(queryPromises);\n            for (const queryResult of queryResults) {\n                results.push(...queryResult);\n            }\n        }\n\n        console.log(`total time for complete parallel query ${Date.now() - startTime}`);\n        return results;\n    }\n\n    private async customQuery(keyConditions: Record<string, unknown>, options?: Record<string, unknown>): Promise<T[]> {\n        const startTime = Date.now();\n        const items: T[] = [];\n\n        const query = this.model.query(keyConditions);\n        if (options?.limit) query.limit(options.limit);\n\n        for await (const item of query) {\n            items.push(item);\n        }\n\n        console.log(`total time for complete query ${Date.now() - startTime}`);\n        return items;\n    }\n\n    decode(continuationToken: string | undefined): Record<string, unknown> | undefined {\n        if (continuationToken) {\n            try {\n                let lastEvaluatedKey = JSON.parse(Buffer.from(continuationToken, 'base64').toString('utf8'));\n                console.log(\"Incoming Last Evaluated Key \" + lastEvaluatedKey);\n                return lastEvaluatedKey;\n            } catch (error) {\n                throw new Error('Invalid continuationToken');\n            }\n        }\n        return undefined;\n    }\n\n    async encode(lastEvaluatedKey: Record<string, unknown>): Promise<string> {\n        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString('base64');\n    }\n}\n"]}

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

@@ -0,0 +1,7 @@
+export declare const BaseSchema: import("dynamoose/dist/Schema").Schema;
+export declare class BaseModel {
+    created_time?: Date;
+    updated_time?: Date;
+    created_user?: string;
+    updated_user?: string;
+}

package/dist/base-model-dynamoose.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModel = exports.BaseSchema = void 0;
+const dynamoose_1 = require("dynamoose");
+exports.BaseSchema = new dynamoose_1.Schema({
+    created_time: {
+        type: Date,
+        default: () => new Date()
+    },
+    updated_time: {
+        type: Date,
+        default: () => new Date()
+    },
+    created_user: {
+        type: String
+    },
+    updated_user: {
+        type: String
+    }
+}, {
+    timestamps: {
+        createdAt: 'created_time',
+        updatedAt: 'updated_time'
+    }
+});
+class BaseModel {
+}
+exports.BaseModel = BaseModel;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1tb2RlbC1keW5hbW9vc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYmFzZS1tb2RlbC1keW5hbW9vc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEseUNBQW1DO0FBRXRCLFFBQUEsVUFBVSxHQUFHLElBQUksa0JBQU0sQ0FBQztJQUNqQyxZQUFZLEVBQUU7UUFDVixJQUFJLEVBQUUsSUFBSTtRQUNWLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJLElBQUksRUFBRTtLQUM1QjtJQUNELFlBQVksRUFBRTtRQUNWLElBQUksRUFBRSxJQUFJO1FBQ1YsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUksSUFBSSxFQUFFO0tBQzVCO0lBQ0QsWUFBWSxFQUFFO1FBQ1YsSUFBSSxFQUFFLE1BQU07S0FDZjtJQUNELFlBQVksRUFBRTtRQUNWLElBQUksRUFBRSxNQUFNO0tBQ2Y7Q0FDSixFQUFFO0lBQ0MsVUFBVSxFQUFFO1FBQ1IsU0FBUyxFQUFFLGNBQWM7UUFDekIsU0FBUyxFQUFFLGNBQWM7S0FDNUI7Q0FDSixDQUFDLENBQUM7QUFFSCxNQUFhLFNBQVM7Q0FLckI7QUFMRCw4QkFLQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNjaGVtYSB9IGZyb20gJ2R5bmFtb29zZSc7XG5cbmV4cG9ydCBjb25zdCBCYXNlU2NoZW1hID0gbmV3IFNjaGVtYSh7XG4gICAgY3JlYXRlZF90aW1lOiB7XG4gICAgICAgIHR5cGU6IERhdGUsXG4gICAgICAgIGRlZmF1bHQ6ICgpID0+IG5ldyBEYXRlKClcbiAgICB9LFxuICAgIHVwZGF0ZWRfdGltZToge1xuICAgICAgICB0eXBlOiBEYXRlLFxuICAgICAgICBkZWZhdWx0OiAoKSA9PiBuZXcgRGF0ZSgpXG4gICAgfSxcbiAgICBjcmVhdGVkX3VzZXI6IHtcbiAgICAgICAgdHlwZTogU3RyaW5nXG4gICAgfSxcbiAgICB1cGRhdGVkX3VzZXI6IHtcbiAgICAgICAgdHlwZTogU3RyaW5nXG4gICAgfVxufSwge1xuICAgIHRpbWVzdGFtcHM6IHtcbiAgICAgICAgY3JlYXRlZEF0OiAnY3JlYXRlZF90aW1lJyxcbiAgICAgICAgdXBkYXRlZEF0OiAndXBkYXRlZF90aW1lJ1xuICAgIH1cbn0pO1xuXG5leHBvcnQgY2xhc3MgQmFzZU1vZGVsIHtcbiAgICBjcmVhdGVkX3RpbWU/OiBEYXRlO1xuICAgIHVwZGF0ZWRfdGltZT86IERhdGU7XG4gICAgY3JlYXRlZF91c2VyPzogc3RyaW5nO1xuICAgIHVwZGF0ZWRfdXNlcj86IHN0cmluZztcbn1cbiJdfQ==

package/dist/customer-user/default-platter/default-platters-model.d.ts

@@ -20,4 +20,5 @@ export declare class DefaultPlatterModel extends BaseModel {
     platterCuisine: string;
     platterEventType?: string;
     plateFactorValue?: number;
+    discountPercentage?: number;
 }

package/dist/customer-user/default-platter/default-platters-model.js

@@ -96,7 +96,11 @@ __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", Number)
 ], DefaultPlatterModel.prototype, "plateFactorValue", void 0);
+__decorate([
+    (0, annotations_1.attribute)(),
+    __metadata("design:type", Number)
+], DefaultPlatterModel.prototype, "discountPercentage", void 0);
 exports.DefaultPlatterModel = DefaultPlatterModel = __decorate([
     (0, annotations_1.table)("DefaultPlattersTable")
 ], DefaultPlatterModel);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/example-dao.d.ts

@@ -0,0 +1,21 @@
+import { GenericDAO, AuthContext } from '../base-dao-dynamoose';
+import { Example } from './example-model';
+export declare class ExampleDAO extends GenericDAO<Example> {
+    constructor();
+    findByExampleStringProperty(value: string): Promise<Example[]>;
+    findByExampleNumberProperty(value: number): Promise<Example[]>;
+    findByExampleBooleanProperty(value: boolean): Promise<Example[]>;
+    findByCreatedUser(userSub: string): Promise<Example[]>;
+    createExample(exampleStringProperty: string, exampleNumberProperty: number, exampleBooleanProperty: boolean, authContext?: AuthContext): Promise<Example>;
+    updateExample(id: string, updates: Partial<Example>, authContext?: AuthContext): Promise<Example>;
+    deleteExample(id: string): Promise<void>;
+    getExampleById(id: string): Promise<Example>;
+    getAllExamples(): Promise<Example[]>;
+    batchCreateExamples(examples: Array<{
+        exampleStringProperty: string;
+        exampleNumberProperty: number;
+        exampleBooleanProperty: boolean;
+    }>, authContext?: AuthContext): Promise<Example[]>;
+    batchDeleteExamples(ids: string[]): Promise<void>;
+    batchGetExamples(ids: string[]): Promise<Example[]>;
+}

package/dist/customer-user/example-dao.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExampleDAO = void 0;
+const base_dao_dynamoose_1 = require("../base-dao-dynamoose");
+const example_model_1 = require("./example-model");
+class ExampleDAO extends base_dao_dynamoose_1.GenericDAO {
+    constructor() {
+        super(example_model_1.ExampleModel);
+    }
+    async findByExampleStringProperty(value) {
+        return await this.model.scan('exampleStringProperty').eq(value).exec();
+    }
+    async findByExampleNumberProperty(value) {
+        return await this.model.scan('exampleNumberProperty').eq(value).exec();
+    }
+    async findByExampleBooleanProperty(value) {
+        return await this.model.scan('exampleBooleanProperty').eq(value).exec();
+    }
+    async findByCreatedUser(userSub) {
+        return await this.model.scan('created_user').eq(userSub).exec();
+    }
+    async createExample(exampleStringProperty, exampleNumberProperty, exampleBooleanProperty, authContext) {
+        const example = new example_model_1.Example();
+        example.exampleStringProperty = exampleStringProperty;
+        example.exampleNumberProperty = exampleNumberProperty;
+        example.exampleBooleanProperty = exampleBooleanProperty;
+        return await this.save(example, authContext);
+    }
+    async updateExample(id, updates, authContext) {
+        const example = new example_model_1.Example();
+        example.id = id;
+        Object.assign(example, updates);
+        return await this.update(example, authContext);
+    }
+    async deleteExample(id) {
+        const example = new example_model_1.Example();
+        example.id = id;
+        await this.delete(example);
+    }
+    async getExampleById(id) {
+        const example = new example_model_1.Example();
+        example.id = id;
+        return await this.get(example);
+    }
+    async getAllExamples() {
+        return await this.scan();
+    }
+    async batchCreateExamples(examples, authContext) {
+        const exampleObjects = examples.map(ex => {
+            const example = new example_model_1.Example();
+            example.exampleStringProperty = ex.exampleStringProperty;
+            example.exampleNumberProperty = ex.exampleNumberProperty;
+            example.exampleBooleanProperty = ex.exampleBooleanProperty;
+            return example;
+        });
+        return await this.batchPut(exampleObjects, authContext);
+    }
+    async batchDeleteExamples(ids) {
+        const examples = ids.map(id => {
+            const example = new example_model_1.Example();
+            example.id = id;
+            return example;
+        });
+        await this.batchDelete(examples);
+    }
+    async batchGetExamples(ids) {
+        const examples = ids.map(id => {
+            const example = new example_model_1.Example();
+            example.id = id;
+            return example;
+        });
+        return await this.batchGet(examples);
+    }
+}
+exports.ExampleDAO = ExampleDAO;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"example-dao.js","sourceRoot":"","sources":["../../src/customer-user/example-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import { GenericDAO, AuthContext } from '../base-dao-dynamoose';\nimport { ExampleModel, Example } from './example-model';\n\nexport class ExampleDAO extends GenericDAO<Example> {\n    constructor() {\n        super(ExampleModel);\n    }\n\n    async findByExampleStringProperty(value: string): Promise<Example[]> {\n        return await this.model.scan('exampleStringProperty').eq(value).exec();\n    }\n\n    async findByExampleNumberProperty(value: number): Promise<Example[]> {\n        return await this.model.scan('exampleNumberProperty').eq(value).exec();\n    }\n\n    async findByExampleBooleanProperty(value: boolean): Promise<Example[]> {\n        return await this.model.scan('exampleBooleanProperty').eq(value).exec();\n    }\n\n    async findByCreatedUser(userSub: string): Promise<Example[]> {\n        return await this.model.scan('created_user').eq(userSub).exec();\n    }\n\n    async createExample(\n        exampleStringProperty: string,\n        exampleNumberProperty: number,\n        exampleBooleanProperty: boolean,\n        authContext?: AuthContext\n    ): Promise<Example> {\n        const example = new Example();\n        example.exampleStringProperty = exampleStringProperty;\n        example.exampleNumberProperty = exampleNumberProperty;\n        example.exampleBooleanProperty = exampleBooleanProperty;\n\n        return await this.save(example, authContext);\n    }\n\n    async updateExample(\n        id: string,\n        updates: Partial<Example>,\n        authContext?: AuthContext\n    ): Promise<Example> {\n        const example = new Example();\n        example.id = id;\n        Object.assign(example, updates);\n\n        return await this.update(example, authContext);\n    }\n\n    async deleteExample(id: string): Promise<void> {\n        const example = new Example();\n        example.id = id;\n        await this.delete(example);\n    }\n\n    async getExampleById(id: string): Promise<Example> {\n        const example = new Example();\n        example.id = id;\n        return await this.get(example);\n    }\n\n    async getAllExamples(): Promise<Example[]> {\n        return await this.scan();\n    }\n\n    async batchCreateExamples(\n        examples: Array<{\n            exampleStringProperty: string;\n            exampleNumberProperty: number;\n            exampleBooleanProperty: boolean;\n        }>,\n        authContext?: AuthContext\n    ): Promise<Example[]> {\n        const exampleObjects = examples.map(ex => {\n            const example = new Example();\n            example.exampleStringProperty = ex.exampleStringProperty;\n            example.exampleNumberProperty = ex.exampleNumberProperty;\n            example.exampleBooleanProperty = ex.exampleBooleanProperty;\n            return example;\n        });\n\n        return await this.batchPut(exampleObjects, authContext);\n    }\n\n    async batchDeleteExamples(ids: string[]): Promise<void> {\n        const examples = ids.map(id => {\n            const example = new Example();\n            example.id = id;\n            return example;\n        });\n        await this.batchDelete(examples);\n    }\n\n    async batchGetExamples(ids: string[]): Promise<Example[]> {\n        const examples = ids.map(id => {\n            const example = new Example();\n            example.id = id;\n            return example;\n        });\n        return await this.batchGet(examples);\n    }\n}\n"]}

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

@@ -1,7 +1,8 @@
-import { BaseModel } from "../base-model";
-export declare class ExampleModel extends BaseModel {
-    id: string;
+import { BaseModel } from '../base-model';
+export declare const ExampleModel: import("dynamoose/dist/General").ModelType<import("dynamoose/dist/Item").AnyItem>;
+export declare class Example extends BaseModel {
+    id?: string;
     exampleStringProperty: string;
     exampleNumberProperty: number;
-    exampleBooleanProperty: string;
+    exampleBooleanProperty: boolean;
 }

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

@@ -1,37 +1,71 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExampleModel = void 0;
-const annotations_1 = require("@nova-odm/annotations");
+exports.Example = exports.ExampleModel = void 0;
+const dynamoose_1 = __importStar(require("dynamoose"));
 const base_model_1 = require("../base-model");
-let ExampleModel = class ExampleModel extends base_model_1.BaseModel {
-};
-exports.ExampleModel = ExampleModel;
-__decorate([
-    (0, annotations_1.autoGeneratedHashKey)({ type: "String" }),
-    __metadata("design:type", String)
-], ExampleModel.prototype, "id", void 0);
-__decorate([
-    (0, annotations_1.attribute)(),
-    __metadata("design:type", String)
-], ExampleModel.prototype, "exampleStringProperty", void 0);
-__decorate([
-    (0, annotations_1.attribute)(),
-    __metadata("design:type", Number)
-], ExampleModel.prototype, "exampleNumberProperty", void 0);
-__decorate([
-    (0, annotations_1.attribute)(),
-    __metadata("design:type", String)
-], ExampleModel.prototype, "exampleBooleanProperty", void 0);
-exports.ExampleModel = ExampleModel = __decorate([
-    (0, annotations_1.table)("example")
-], ExampleModel);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhhbXBsZS1tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jdXN0b21lci11c2VyL2V4YW1wbGUtbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsdURBQXdGO0FBQ3hGLDhDQUEwQztBQUduQyxJQUFNLFlBQVksR0FBbEIsTUFBTSxZQUFhLFNBQVEsc0JBQVM7Q0FTMUMsQ0FBQTtBQVRZLG9DQUFZO0FBRXJCO0lBREMsSUFBQSxrQ0FBb0IsRUFBQyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQzs7d0NBQzlCO0FBRVg7SUFEQyxJQUFBLHVCQUFTLEdBQUU7OzJEQUNrQjtBQUU5QjtJQURDLElBQUEsdUJBQVMsR0FBRTs7MkRBQ2tCO0FBRTlCO0lBREMsSUFBQSx1QkFBUyxHQUFFOzs0REFDbUI7dUJBUnRCLFlBQVk7SUFEeEIsSUFBQSxtQkFBSyxFQUFDLFNBQVMsQ0FBQztHQUNKLFlBQVksQ0FTeEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBhdHRyaWJ1dGUsIGF1dG9HZW5lcmF0ZWRIYXNoS2V5LCBoYXNoS2V5LCB0YWJsZSB9IGZyb20gXCJAbm92YS1vZG0vYW5ub3RhdGlvbnNcIjtcbmltcG9ydCB7IEJhc2VNb2RlbCB9IGZyb20gXCIuLi9iYXNlLW1vZGVsXCI7XG5cbkB0YWJsZShcImV4YW1wbGVcIilcbmV4cG9ydCBjbGFzcyBFeGFtcGxlTW9kZWwgZXh0ZW5kcyBCYXNlTW9kZWwge1xuICAgIEBhdXRvR2VuZXJhdGVkSGFzaEtleSh7IHR5cGU6IFwiU3RyaW5nXCIgfSlcbiAgICBpZDogc3RyaW5nO1xuICAgIEBhdHRyaWJ1dGUoKVxuICAgIGV4YW1wbGVTdHJpbmdQcm9wZXJ0eTogc3RyaW5nO1xuICAgIEBhdHRyaWJ1dGUoKVxuICAgIGV4YW1wbGVOdW1iZXJQcm9wZXJ0eTogbnVtYmVyO1xuICAgIEBhdHRyaWJ1dGUoKVxuICAgIGV4YW1wbGVCb29sZWFuUHJvcGVydHk6IHN0cmluZztcbn0iXX0=
+const ExampleSchema = new dynamoose_1.Schema({
+    id: {
+        type: String,
+        hashKey: true,
+        default: () => require('crypto').randomUUID()
+    },
+    exampleStringProperty: {
+        type: String,
+        required: true
+    },
+    exampleNumberProperty: {
+        type: Number,
+        required: true
+    },
+    exampleBooleanProperty: {
+        type: Boolean,
+        required: true
+    },
+    created_time: {
+        type: Date,
+        default: () => new Date()
+    },
+    updated_time: {
+        type: Date,
+        default: () => new Date()
+    },
+    created_user: {
+        type: String
+    },
+    updated_user: {
+        type: String
+    }
+}, {
+    timestamps: {
+        createdAt: 'created_time',
+        updatedAt: 'updated_time'
+    }
+});
+exports.ExampleModel = dynamoose_1.default.model('example', ExampleSchema);
+class Example extends base_model_1.BaseModel {
+}
+exports.Example = Example;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/findmyplatter/find-my-platter-model.d.ts

@@ -18,5 +18,4 @@ export declare class FindMyPlatterModel extends BaseModel {
     hasEgg: boolean;
     hasChicken: boolean;
     hasMutton: boolean;
-    discountPercentage?: number;
 }

package/dist/customer-user/findmyplatter/find-my-platter-model.js

@@ -87,11 +87,7 @@ __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", Boolean)
 ], FindMyPlatterModel.prototype, "hasMutton", void 0);
-__decorate([
-    (0, annotations_1.attribute)(),
-    __metadata("design:type", Number)
-], FindMyPlatterModel.prototype, "discountPercentage", void 0);
 exports.FindMyPlatterModel = FindMyPlatterModel = __decorate([
     (0, annotations_1.table)("FindMyPlatterTable")
 ], FindMyPlatterModel);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmp-aws-database",
-  "version": "1.2.0-dev.78",
+  "version": "1.2.0-dev.79",
   "bin": {
     "craft-my-plate-database": "bin/craft-my-plate-database.js"
   },
@@ -33,6 +33,7 @@
     "@nova-odm/annotations": "^0.8.7",
     "aws-cdk-lib": "2.176.0",
     "constructs": "^10.0.0",
+    "dynamoose": "^4.1.5",
     "reflect-metadata": "^0.1.14"
   },
   "description": "The package \"cmp-aws-database\" is for its database, which defines global tables. These tables are designed to be imported and used across multiple applications of \"craft-my-plate.\"",