cmp-aws-database 1.1.106 → 1.1.107-dev.1

package/README.md

@@ -1,14 +1,232 @@
-# Welcome to your CDK TypeScript project
+# Craft My Plate Database Package
 
-This is a blank project for CDK development with TypeScript.
+A comprehensive, environment-aware database package for the Craft My Plate application ecosystem. This package provides DynamoDB-based data access with automatic environment configuration.
 
-The `cdk.json` file tells the CDK Toolkit how to execute your app.
+## 🚀 Features
 
-## Useful commands
+- **Environment-Aware Configuration**: Automatically adapts to development, staging, production, and test environments
+- **Dynamic Table Naming**: Environment-specific table prefixes (dev-, staging-, test-)
+- **Feature Flags**: Environment-specific feature toggles (parallel processing, caching, etc.)
+- **TypeScript Support**: Full TypeScript definitions and type safety
+- **AWS CDK Integration**: Infrastructure as Code for database tables
+- **Comprehensive DAO Layer**: Generic data access objects with environment-specific optimizations
 
-* `npm run build`   compile typescript to js
-* `npm run watch`   watch for changes and compile
-* `npm run test`    perform the jest unit tests
-* `npx cdk deploy`  deploy this stack to your default AWS account/region
-* `npx cdk diff`    compare deployed stack with current state
-* `npx cdk synth`   emits the synthesized CloudFormation template
+## 📦 Installation
+
+```bash
+npm install cmp-aws-database
+```
+
+## 🎯 Quick Start
+
+### Basic Usage
+
+```typescript
+import { 
+  envManager, 
+  TABLE_NAMES, 
+  UserModel, 
+  userDAO 
+} from 'cmp-aws-database';
+
+// Check current environment
+console.log('Environment:', envManager.getEnvironment());
+
+// Use environment-aware table names
+const userTableName = TABLE_NAMES.USER;
+
+// Create and save a user
+const user = new UserModel();
+user.userId = 'user123';
+user.email = 'test@example.com';
+
+const savedUser = await userDAO.save(user, { userSub: 'auth-user-123' });
+```
+
+### Environment Configuration
+
+The package automatically detects the environment based on `NODE_ENV` or `ENVIRONMENT` variables:
+
+```bash
+# Development
+export NODE_ENV=development
+
+# Staging  
+export NODE_ENV=staging
+
+# Production
+export NODE_ENV=production
+
+# Test
+export NODE_ENV=test
+```
+
+## 🌍 Environment-Specific Behavior
+
+### Development Environment
+- **Database**: Local DynamoDB (http://localhost:8000)
+- **Table Prefix**: `dev-`
+- **Features**: Sequential processing, no caching
+- **Logging**: Debug level
+
+### Staging Environment
+- **Database**: AWS DynamoDB
+- **Table Prefix**: `staging-`
+- **Features**: Parallel processing, caching enabled
+- **Logging**: Info level
+
+### Production Environment
+- **Database**: AWS DynamoDB
+- **Table Prefix**: None (empty)
+- **Features**: Parallel processing, caching enabled
+- **Logging**: Warn level
+
+### Test Environment
+- **Database**: Local DynamoDB (http://localhost:8000)
+- **Table Prefix**: `test-`
+- **Features**: Sequential processing, no caching
+- **Logging**: Error level
+
+## 📚 Available Models and DAOs
+
+### Customer User Models
+- `UserModel` / `userDAO`
+- `OrderModel` / `orderDao`
+- `CartModel` / `cartDAO`
+- `WalletModel` / `walletDao`
+- `PaymentModel` / `paymentDao`
+- And many more...
+
+### Internal User Models
+- `InternalUserModel` / `internalUserDao`
+- `ActivityLogsModel` / `activityLogsDao`
+- `QuotationsModel` / `quotationsDao`
+
+## 🔧 Advanced Usage
+
+### Environment-Specific Features
+
+```typescript
+import { envManager } from 'cmp-aws-database';
+
+const config = envManager.getConfig();
+
+// Check if parallel processing is enabled
+if (config.features.enableParallelProcessing) {
+  await userDAO.parallelBatchGet(users);
+} else {
+  await userDAO.batchGet(users);
+}
+
+// Check if caching is enabled
+if (config.features.enableCaching) {
+  // Implement caching logic
+}
+```
+
+### Custom Table Names
+
+```typescript
+import { TableNameManager } from 'cmp-aws-database';
+
+const customTableName = TableNameManager.getTableName('MyCustomTable');
+// Returns: dev-MyCustomTable, staging-MyCustomTable, or MyCustomTable
+```
+
+### Environment Override (Testing)
+
+```typescript
+import { envManager } from 'cmp-aws-database';
+
+// Override environment for testing
+envManager.setEnvironment('test');
+```
+
+## 🏗️ Infrastructure
+
+### CDK Stack Deployment
+
+```typescript
+import { CustomerAppDbStack, InternalUserDbStack } from 'cmp-aws-database';
+
+// Deploy customer app database
+const customerStack = new CustomerAppDbStack(app, 'CustomerAppDbStack');
+
+// Deploy internal user database  
+const internalStack = new InternalUserDbStack(app, 'InternalUserDbStack');
+```
+
+### Available Tables
+
+The package includes pre-configured tables for:
+- User management
+- Order processing
+- Payment handling
+- Inventory management
+- Analytics and reporting
+- And much more...
+
+## 🔍 Debugging
+
+### Environment Information
+
+```typescript
+import { envManager } from 'cmp-aws-database';
+
+console.log('Current environment:', envManager.getEnvironment());
+console.log('Database config:', envManager.getDatabaseConfig());
+console.log('Features enabled:', envManager.getConfig().features);
+```
+
+### Table Name Resolution
+
+```typescript
+import { TABLE_NAMES, BASE_TABLE_NAMES } from 'cmp-aws-database';
+
+console.log('Environment-aware table names:', TABLE_NAMES);
+console.log('Base table names:', BASE_TABLE_NAMES);
+```
+
+## 📋 Migration Guide
+
+### From Hardcoded Configuration
+
+**Before:**
+```typescript
+const tableName = 'UserTable';
+const client = new DynamoDB({ maxAttempts: 10 });
+```
+
+**After:**
+```typescript
+import { TABLE_NAMES, DatabaseFactory } from 'cmp-aws-database';
+
+const tableName = TABLE_NAMES.USER;
+const client = DatabaseFactory.getDynamoDBClient();
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Submit a pull request
+
+## 📄 License
+
+Apache-2.0
+
+## 🆘 Support
+
+- **Issues**: [GitHub Issues](https://github.com/Surajpatel24-craftmyplate/craft-my-plate-database/issues)
+- **Documentation**: [Package Documentation](https://github.com/Surajpatel24-craftmyplate/craft-my-plate-database#readme)
+
+## 🔄 Version History
+
+- **1.1.107**: Current version with environment-aware configuration
+- **Previous versions**: Legacy hardcoded configuration
+
+---
+
+**Note**: This package is designed to work seamlessly across different environments while maintaining the same API. The environment-specific behavior is handled internally, so your application code remains consistent across all environments.

package/dist/base-dao.d.ts

@@ -1,8 +1,9 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
 import { DataMapper, ParallelScanOptions, ParallelScanWorkerOptions, QueryOptions, ReadConsistency, ScanOptions } from '@nova-odm/mapper';
 import { ZeroArgumentsConstructor } from '@nova-odm/marshaller';
 import { ConditionExpression, ConditionExpressionPredicate } from '@nova-odm/expressions';
 import { BaseModel } from './base-model';
-export declare const dynamoDB: any;
+export declare const dynamoDB: DynamoDB;
 export declare const mapper: DataMapper;
 export declare class GenericDAO<T extends BaseModel> {
     batchUpdate(items: T[], batchSize?: number, authContext?: any): Promise<T[]>;

package/dist/base-dao.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericDAO = exports.mapper = exports.dynamoDB = void 0;
-const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const mapper_1 = require("@nova-odm/mapper");
-exports.dynamoDB = new client_dynamodb_1.DynamoDB({
-    maxAttempts: 10
-});
-exports.mapper = new mapper_1.DataMapper({ client: exports.dynamoDB });
+const database_factory_1 = require("./config/database-factory");
+const environment_config_1 = require("./config/environment-config");
+// Use environment-aware database instances
+exports.dynamoDB = database_factory_1.DatabaseFactory.getDynamoDBClient();
+exports.mapper = database_factory_1.DatabaseFactory.getDataMapper();
 class GenericDAO {
     async batchUpdate(items, batchSize = 100, authContext) {
         let success = 0, totalToUpdate = items.length;
@@ -132,9 +131,12 @@ class GenericDAO {
     async delete(item) {
         return await exports.mapper.delete(item, { returnValues: "ALL_OLD" });
     }
-    async get(item, readConsistency = "eventual") {
+    async get(item, readConsistency) {
+        // Use environment-specific read consistency if not provided
+        const config = environment_config_1.envManager.getDatabaseConfig();
+        const consistency = readConsistency || config.readConsistency;
         const res = await exports.mapper.get(item, {
-            readConsistency: readConsistency
+            readConsistency: consistency
         });
         return res;
     }
@@ -159,16 +161,25 @@ class GenericDAO {
         }
         return deleteItems;
     }
-    async batchGet(items, readConsistency = "eventual") {
+    async batchGet(items, readConsistency) {
+        // Use environment-specific read consistency if not provided
+        const config = environment_config_1.envManager.getDatabaseConfig();
+        const consistency = readConsistency || config.readConsistency;
         let getItems = [];
         for await (const item of exports.mapper.batchGet(items, {
-            readConsistency: readConsistency
+            readConsistency: consistency
         })) {
             getItems.push(item);
         }
         return getItems;
     }
     async parallelBatchGet(inputItems, batchSize = 1000, maxConcurrentSegments = 20, readConsistency) {
+        // Check if parallel processing is enabled for this environment
+        const config = environment_config_1.envManager.getConfig();
+        if (!config.features.enableParallelProcessing) {
+            console.warn('Parallel processing is disabled for this environment. Using sequential processing.');
+            return this.batchGet(inputItems, readConsistency);
+        }
         let startTime = Date.now();
         let items = [];
         items = items.concat(inputItems);
@@ -242,4 +253,4 @@ class GenericDAO {
     }
 }
 exports.GenericDAO = GenericDAO;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dao.js","sourceRoot":"","sources":["../src/base-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import { DynamoDB } from '@aws-sdk/client-dynamodb';\nimport {\n    DataMapper,\n    ParallelScanOptions,\n    ParallelScanWorkerOptions,\n    QueryOptions,\n    ReadConsistency,\n    ScanOptions\n} from '@nova-odm/mapper';\nimport { ZeroArgumentsConstructor } from '@nova-odm/marshaller';\nimport { ConditionExpression, ConditionExpressionPredicate } from '@nova-odm/expressions';\nimport { BaseModel } from './base-model';\n\n\nexport const dynamoDB = new DynamoDB({\n    maxAttempts: 10\n}) as any\nexport const mapper = new DataMapper({ client: dynamoDB });\n\nexport class GenericDAO<T extends BaseModel> {\n    async batchUpdate(items: T[], batchSize = 100, authContext?: any): Promise<T[]> {\n        let success = 0, totalToUpdate = items.length\n        let updateItems: T[] = []\n        while (items.length > 0) {\n            let promises = []\n            let batch = items.splice(0, batchSize)\n            promises = batch.map(item => this.update(item, authContext))\n            let results = await Promise.allSettled(promises)\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?: any): 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            item.created_user = authContext.userSub\n            return item\n        })\n        let maxSegments: T[][][] = []\n        let putItems: T[] = []\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        for (const segment of maxSegments) {\n            let startTime = Date.now()\n            let promises: Promise<T[]>[] = []\n            console.log(`batch length = ${segment.length}`)\n            for (const batch of segment) {\n                promises.push(this.batchPut(batch, authContext.userSub))\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        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 putItems: T[] = []\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        for (const segment of maxSegments) {\n            let startTime = Date.now()\n            let promises: Promise<T[]>[] = []\n            console.log(`batch length = ${segment.length}`)\n            for (const batch of segment) {\n                promises.push(this.batchDelete(batch))\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 delete ${Date.now() - startTime}`)\n        }\n        console.log(`total time for complete parallel delete ${Date.now() - startTime}`)\n        return putItems\n    }\n\n    /**\n     * This function has to be used only in the scripts.\n     * \n     * @param valueConstructor the model class\n     */\n    async parallelScan(valueConstructor: ZeroArgumentsConstructor<T>, options?: ParallelScanOptions): Promise<T[]> {\n        let items: T[] = []\n        for await (const item of mapper.parallelScan(valueConstructor, 4, options)) {\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(valueConstructor: ZeroArgumentsConstructor<T>, options?: ScanOptions | ParallelScanWorkerOptions): Promise<T[]> {\n        let items: T[] = []\n        for await (const item of mapper.scan(valueConstructor, options)) {\n            items.push(item)\n        }\n        return items\n    }\n\n    async save(item: T, authContext?: any): Promise<T> {\n        item.created_time = new Date()\n        item.created_user = authContext.userSub\n        const res = await mapper.put(item)\n        return res\n    }\n\n    async update(item: T, authContext?: any): Promise<T> {\n        item.updated_time = new Date()\n        item.updated_user = authContext.userSub\n        const res = await mapper.update(item, {\n            onMissing: \"skip\"\n        })\n        return res\n    }\n\n    async delete(item: T): Promise<T | undefined> {\n        return await mapper.delete(item, { returnValues: \"ALL_OLD\" })\n    }\n\n    async get(item: T, readConsistency: ReadConsistency = \"eventual\"): Promise<T> {\n        const res = await mapper.get(item, {\n            readConsistency: readConsistency\n        })\n        return res\n    }\n\n    async batchPut(items: T[], authContext?: any): Promise<T[]> {\n\n        let finalItems: T[] = []\n        items = items.map(item => {\n            item.created_time = new Date()\n            item.created_user = authContext.userSub\n            return item\n        })\n        // console.log( \"item:\", items )\n        for await (const item of mapper.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 mapper.batchDelete(items)) {\n            deleteItems.push(item)\n        }\n        return deleteItems\n    }\n\n    async batchGet(items: T[], readConsistency: ReadConsistency = \"eventual\"): Promise<T[]> {\n        let getItems: T[] = []\n        for await (const item of mapper.batchGet(items, {\n            readConsistency: readConsistency\n        })) {\n            getItems.push(item)\n        }\n        return getItems\n    }\n\n    async parallelBatchGet(inputItems: T[], batchSize: number = 1000, maxConcurrentSegments: number = 20, readConsistency?: ReadConsistency): 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        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        for (const segment of maxSegments) {\n            let startTime = Date.now()\n            let promises: Promise<T[]>[] = []\n            console.log(`batch length = ${segment.length}`)\n            for (const batch of segment) {\n                promises.push(this.batchGet(batch, readConsistency))\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        console.log(`total time for complete parallel get ${Date.now() - startTime}`)\n        return resultItems\n    }\n    async parallelQuery(\n        valueConstructor: ZeroArgumentsConstructor<T>,\n        keyConditions: Array<ConditionExpression | { [propertyName: string]: ConditionExpressionPredicate | any }>,\n        maxConcurrentCalls: number = 20,\n        options?: QueryOptions,\n\n    ): Promise<T[]> {\n        const startTime = Date.now()\n        const results: T[] = []\n        while (keyConditions.length > 0) {\n            const segmentConditions = keyConditions.splice(0, maxConcurrentCalls)\n            const queryPromises = segmentConditions.map((keyCondition) => {\n                return this.customQuery(valueConstructor, keyCondition, options)\n            }\n\n            )\n            const queryResults = await Promise.all(queryPromises)\n\n            for (const queryResult of queryResults) {\n                results.push(...queryResult)\n            }\n        }\n        console.log(`total time for complete parallel query ${Date.now() - startTime}`)\n        return results\n    }\n    private async customQuery(\n        valueConstructor: ZeroArgumentsConstructor<T>,\n        keyConditions: ConditionExpression | { [propertyName: string]: ConditionExpressionPredicate | any },\n        options?: QueryOptions\n    ): Promise<T[]> {\n        const startTime = Date.now()\n        const items: T[] = []\n\n        for await (const item of mapper.query(valueConstructor, keyConditions, options)) {\n            items.push(item)\n        }\n        console.log(`total time for complete query ${Date.now() - startTime}`)\n\n        return items\n    }\n    decode(continuationToken: string | 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: any): Promise<string> {\n        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString('base64')\n    }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dao.js","sourceRoot":"","sources":["../src/base-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import { DynamoDB } from '@aws-sdk/client-dynamodb';\nimport {\n    DataMapper,\n    ParallelScanOptions,\n    ParallelScanWorkerOptions,\n    QueryOptions,\n    ReadConsistency,\n    ScanOptions\n} from '@nova-odm/mapper';\nimport { ZeroArgumentsConstructor } from '@nova-odm/marshaller';\nimport { ConditionExpression, ConditionExpressionPredicate } from '@nova-odm/expressions';\nimport { BaseModel } from './base-model';\nimport { DatabaseFactory } from './config/database-factory';\nimport { envManager } from './config/environment-config';\n\n// Use environment-aware database instances\nexport const dynamoDB = DatabaseFactory.getDynamoDBClient();\nexport const mapper = DatabaseFactory.getDataMapper();\n\nexport class GenericDAO<T extends BaseModel> {\n    async batchUpdate(items: T[], batchSize = 100, authContext?: any): Promise<T[]> {\n        let success = 0, totalToUpdate = items.length\n        let updateItems: T[] = []\n        while (items.length > 0) {\n            let promises = []\n            let batch = items.splice(0, batchSize)\n            promises = batch.map(item => this.update(item, authContext))\n            let results = await Promise.allSettled(promises)\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?: any): 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            item.created_user = authContext.userSub\n            return item\n        })\n        let maxSegments: T[][][] = []\n        let putItems: T[] = []\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        for (const segment of maxSegments) {\n            let startTime = Date.now()\n            let promises: Promise<T[]>[] = []\n            console.log(`batch length = ${segment.length}`)\n            for (const batch of segment) {\n                promises.push(this.batchPut(batch, authContext.userSub))\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        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 putItems: T[] = []\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        for (const segment of maxSegments) {\n            let startTime = Date.now()\n            let promises: Promise<T[]>[] = []\n            console.log(`batch length = ${segment.length}`)\n            for (const batch of segment) {\n                promises.push(this.batchDelete(batch))\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 delete ${Date.now() - startTime}`)\n        }\n        console.log(`total time for complete parallel delete ${Date.now() - startTime}`)\n        return putItems\n    }\n\n    /**\n     * This function has to be used only in the scripts.\n     * \n     * @param valueConstructor the model class\n     */\n    async parallelScan(valueConstructor: ZeroArgumentsConstructor<T>, options?: ParallelScanOptions): Promise<T[]> {\n        let items: T[] = []\n        for await (const item of mapper.parallelScan(valueConstructor, 4, options)) {\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(valueConstructor: ZeroArgumentsConstructor<T>, options?: ScanOptions | ParallelScanWorkerOptions): Promise<T[]> {\n        let items: T[] = []\n        for await (const item of mapper.scan(valueConstructor, options)) {\n            items.push(item)\n        }\n        return items\n    }\n\n    async save(item: T, authContext?: any): Promise<T> {\n        item.created_time = new Date()\n        item.created_user = authContext.userSub\n        const res = await mapper.put(item)\n        return res\n    }\n\n    async update(item: T, authContext?: any): Promise<T> {\n        item.updated_time = new Date()\n        item.updated_user = authContext.userSub\n        const res = await mapper.update(item, {\n            onMissing: \"skip\"\n        })\n        return res\n    }\n\n    async delete(item: T): Promise<T | undefined> {\n        return await mapper.delete(item, { returnValues: \"ALL_OLD\" })\n    }\n\n    async get(item: T, readConsistency?: ReadConsistency): Promise<T> {\n        // Use environment-specific read consistency if not provided\n        const config = envManager.getDatabaseConfig();\n        const consistency = readConsistency || config.readConsistency;\n\n        const res = await mapper.get(item, {\n            readConsistency: consistency\n        })\n        return res\n    }\n\n    async batchPut(items: T[], authContext?: any): Promise<T[]> {\n\n        let finalItems: T[] = []\n        items = items.map(item => {\n            item.created_time = new Date()\n            item.created_user = authContext.userSub\n            return item\n        })\n        // console.log( \"item:\", items )\n        for await (const item of mapper.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 mapper.batchDelete(items)) {\n            deleteItems.push(item)\n        }\n        return deleteItems\n    }\n\n    async batchGet(items: T[], readConsistency?: ReadConsistency): Promise<T[]> {\n        // Use environment-specific read consistency if not provided\n        const config = envManager.getDatabaseConfig();\n        const consistency = readConsistency || config.readConsistency;\n\n        let getItems: T[] = []\n        for await (const item of mapper.batchGet(items, {\n            readConsistency: consistency\n        })) {\n            getItems.push(item)\n        }\n        return getItems\n    }\n\n    async parallelBatchGet(inputItems: T[], batchSize: number = 1000, maxConcurrentSegments: number = 20, readConsistency?: ReadConsistency): Promise<T[]> {\n        // Check if parallel processing is enabled for this environment\n        const config = envManager.getConfig();\n        if (!config.features.enableParallelProcessing) {\n            console.warn('Parallel processing is disabled for this environment. Using sequential processing.');\n            return this.batchGet(inputItems, readConsistency);\n        }\n\n        let startTime = Date.now()\n        let items: T[] = []\n        items = items.concat(inputItems)\n        let maxSegments: T[][][] = []\n        let resultItems: T[] = []\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        for (const segment of maxSegments) {\n            let startTime = Date.now()\n            let promises: Promise<T[]>[] = []\n            console.log(`batch length = ${segment.length}`)\n            for (const batch of segment) {\n                promises.push(this.batchGet(batch, readConsistency))\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        console.log(`total time for complete parallel get ${Date.now() - startTime}`)\n        return resultItems\n    }\n    async parallelQuery(\n        valueConstructor: ZeroArgumentsConstructor<T>,\n        keyConditions: Array<ConditionExpression | { [propertyName: string]: ConditionExpressionPredicate | any }>,\n        maxConcurrentCalls: number = 20,\n        options?: QueryOptions,\n\n    ): Promise<T[]> {\n        const startTime = Date.now()\n        const results: T[] = []\n        while (keyConditions.length > 0) {\n            const segmentConditions = keyConditions.splice(0, maxConcurrentCalls)\n            const queryPromises = segmentConditions.map((keyCondition) => {\n                return this.customQuery(valueConstructor, keyCondition, options)\n            }\n\n            )\n            const queryResults = await Promise.all(queryPromises)\n\n            for (const queryResult of queryResults) {\n                results.push(...queryResult)\n            }\n        }\n        console.log(`total time for complete parallel query ${Date.now() - startTime}`)\n        return results\n    }\n    private async customQuery(\n        valueConstructor: ZeroArgumentsConstructor<T>,\n        keyConditions: ConditionExpression | { [propertyName: string]: ConditionExpressionPredicate | any },\n        options?: QueryOptions\n    ): Promise<T[]> {\n        const startTime = Date.now()\n        const items: T[] = []\n\n        for await (const item of mapper.query(valueConstructor, keyConditions, options)) {\n            items.push(item)\n        }\n        console.log(`total time for complete query ${Date.now() - startTime}`)\n\n        return items\n    }\n    decode(continuationToken: string | 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: any): Promise<string> {\n        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString('base64')\n    }\n}"]}

package/dist/config/database-factory.d.ts

@@ -0,0 +1,12 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { DataMapper } from '@nova-odm/mapper';
+export declare class DatabaseFactory {
+    private static dynamoDBInstance;
+    private static mapperInstance;
+    static getDynamoDBClient(): DynamoDB;
+    static getDataMapper(): DataMapper;
+    static getTableName(baseTableName: string): string;
+    static resetInstances(): void;
+}
+export declare const dynamoDB: DynamoDB;
+export declare const mapper: DataMapper;

package/dist/config/database-factory.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapper = exports.dynamoDB = exports.DatabaseFactory = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const mapper_1 = require("@nova-odm/mapper");
+const environment_config_1 = require("./environment-config");
+class DatabaseFactory {
+    static getDynamoDBClient() {
+        if (!DatabaseFactory.dynamoDBInstance) {
+            const config = environment_config_1.envManager.getDatabaseConfig();
+            const dynamoConfig = {
+                region: config.region,
+                maxAttempts: config.maxAttempts
+            };
+            // Add endpoint for local development
+            if (config.endpoint) {
+                dynamoConfig.endpoint = config.endpoint;
+            }
+            DatabaseFactory.dynamoDBInstance = new client_dynamodb_1.DynamoDB(dynamoConfig);
+        }
+        return DatabaseFactory.dynamoDBInstance;
+    }
+    static getDataMapper() {
+        if (!DatabaseFactory.mapperInstance) {
+            const client = DatabaseFactory.getDynamoDBClient();
+            DatabaseFactory.mapperInstance = new mapper_1.DataMapper({ client });
+        }
+        return DatabaseFactory.mapperInstance;
+    }
+    static getTableName(baseTableName) {
+        const config = environment_config_1.envManager.getDatabaseConfig();
+        return `${config.tablePrefix}${baseTableName}`;
+    }
+    static resetInstances() {
+        DatabaseFactory.dynamoDBInstance = undefined;
+        DatabaseFactory.mapperInstance = undefined;
+    }
+}
+exports.DatabaseFactory = DatabaseFactory;
+// Export singleton instances for backward compatibility
+exports.dynamoDB = DatabaseFactory.getDynamoDBClient();
+exports.mapper = DatabaseFactory.getDataMapper();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWJhc2UtZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvZGF0YWJhc2UtZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw4REFBb0Q7QUFDcEQsNkNBQThDO0FBQzlDLDZEQUFrRTtBQUVsRSxNQUFhLGVBQWU7SUFJakIsTUFBTSxDQUFDLGlCQUFpQjtRQUMzQixJQUFJLENBQUMsZUFBZSxDQUFDLGdCQUFnQixFQUFFLENBQUM7WUFDcEMsTUFBTSxNQUFNLEdBQUcsK0JBQVUsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1lBRTlDLE1BQU0sWUFBWSxHQUFRO2dCQUN0QixNQUFNLEVBQUUsTUFBTSxDQUFDLE1BQU07Z0JBQ3JCLFdBQVcsRUFBRSxNQUFNLENBQUMsV0FBVzthQUNsQyxDQUFDO1lBRUYscUNBQXFDO1lBQ3JDLElBQUksTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUNsQixZQUFZLENBQUMsUUFBUSxHQUFHLE1BQU0sQ0FBQyxRQUFRLENBQUM7WUFDNUMsQ0FBQztZQUVELGVBQWUsQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLDBCQUFRLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDbEUsQ0FBQztRQUVELE9BQU8sZUFBZSxDQUFDLGdCQUFnQixDQUFDO0lBQzVDLENBQUM7SUFFTSxNQUFNLENBQUMsYUFBYTtRQUN2QixJQUFJLENBQUMsZUFBZSxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ2xDLE1BQU0sTUFBTSxHQUFHLGVBQWUsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1lBQ25ELGVBQWUsQ0FBQyxjQUFjLEdBQUcsSUFBSSxtQkFBVSxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQztRQUNoRSxDQUFDO1FBRUQsT0FBTyxlQUFlLENBQUMsY0FBYyxDQUFDO0lBQzFDLENBQUM7SUFFTSxNQUFNLENBQUMsWUFBWSxDQUFDLGFBQXFCO1FBQzVDLE1BQU0sTUFBTSxHQUFHLCtCQUFVLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztRQUM5QyxPQUFPLEdBQUcsTUFBTSxDQUFDLFdBQVcsR0FBRyxhQUFhLEVBQUUsQ0FBQztJQUNuRCxDQUFDO0lBRU0sTUFBTSxDQUFDLGNBQWM7UUFDeEIsZUFBZSxDQUFDLGdCQUFnQixHQUFHLFNBQWdCLENBQUM7UUFDcEQsZUFBZSxDQUFDLGNBQWMsR0FBRyxTQUFnQixDQUFDO0lBQ3RELENBQUM7Q0FDSjtBQTFDRCwwQ0EwQ0M7QUFFRCx3REFBd0Q7QUFDM0MsUUFBQSxRQUFRLEdBQUcsZUFBZSxDQUFDLGlCQUFpQixFQUFFLENBQUM7QUFDL0MsUUFBQSxNQUFNLEdBQUcsZUFBZSxDQUFDLGFBQWEsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRHluYW1vREIgfSBmcm9tICdAYXdzLXNkay9jbGllbnQtZHluYW1vZGInO1xuaW1wb3J0IHsgRGF0YU1hcHBlciB9IGZyb20gJ0Bub3ZhLW9kbS9tYXBwZXInO1xuaW1wb3J0IHsgZW52TWFuYWdlciwgRGF0YWJhc2VDb25maWcgfSBmcm9tICcuL2Vudmlyb25tZW50LWNvbmZpZyc7XG5cbmV4cG9ydCBjbGFzcyBEYXRhYmFzZUZhY3Rvcnkge1xuICAgIHByaXZhdGUgc3RhdGljIGR5bmFtb0RCSW5zdGFuY2U6IER5bmFtb0RCO1xuICAgIHByaXZhdGUgc3RhdGljIG1hcHBlckluc3RhbmNlOiBEYXRhTWFwcGVyO1xuXG4gICAgcHVibGljIHN0YXRpYyBnZXREeW5hbW9EQkNsaWVudCgpOiBEeW5hbW9EQiB7XG4gICAgICAgIGlmICghRGF0YWJhc2VGYWN0b3J5LmR5bmFtb0RCSW5zdGFuY2UpIHtcbiAgICAgICAgICAgIGNvbnN0IGNvbmZpZyA9IGVudk1hbmFnZXIuZ2V0RGF0YWJhc2VDb25maWcoKTtcblxuICAgICAgICAgICAgY29uc3QgZHluYW1vQ29uZmlnOiBhbnkgPSB7XG4gICAgICAgICAgICAgICAgcmVnaW9uOiBjb25maWcucmVnaW9uLFxuICAgICAgICAgICAgICAgIG1heEF0dGVtcHRzOiBjb25maWcubWF4QXR0ZW1wdHNcbiAgICAgICAgICAgIH07XG5cbiAgICAgICAgICAgIC8vIEFkZCBlbmRwb2ludCBmb3IgbG9jYWwgZGV2ZWxvcG1lbnRcbiAgICAgICAgICAgIGlmIChjb25maWcuZW5kcG9pbnQpIHtcbiAgICAgICAgICAgICAgICBkeW5hbW9Db25maWcuZW5kcG9pbnQgPSBjb25maWcuZW5kcG9pbnQ7XG4gICAgICAgICAgICB9XG5cbiAgICAgICAgICAgIERhdGFiYXNlRmFjdG9yeS5keW5hbW9EQkluc3RhbmNlID0gbmV3IER5bmFtb0RCKGR5bmFtb0NvbmZpZyk7XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gRGF0YWJhc2VGYWN0b3J5LmR5bmFtb0RCSW5zdGFuY2U7XG4gICAgfVxuXG4gICAgcHVibGljIHN0YXRpYyBnZXREYXRhTWFwcGVyKCk6IERhdGFNYXBwZXIge1xuICAgICAgICBpZiAoIURhdGFiYXNlRmFjdG9yeS5tYXBwZXJJbnN0YW5jZSkge1xuICAgICAgICAgICAgY29uc3QgY2xpZW50ID0gRGF0YWJhc2VGYWN0b3J5LmdldER5bmFtb0RCQ2xpZW50KCk7XG4gICAgICAgICAgICBEYXRhYmFzZUZhY3RvcnkubWFwcGVySW5zdGFuY2UgPSBuZXcgRGF0YU1hcHBlcih7IGNsaWVudCB9KTtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiBEYXRhYmFzZUZhY3RvcnkubWFwcGVySW5zdGFuY2U7XG4gICAgfVxuXG4gICAgcHVibGljIHN0YXRpYyBnZXRUYWJsZU5hbWUoYmFzZVRhYmxlTmFtZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAgICAgY29uc3QgY29uZmlnID0gZW52TWFuYWdlci5nZXREYXRhYmFzZUNvbmZpZygpO1xuICAgICAgICByZXR1cm4gYCR7Y29uZmlnLnRhYmxlUHJlZml4fSR7YmFzZVRhYmxlTmFtZX1gO1xuICAgIH1cblxuICAgIHB1YmxpYyBzdGF0aWMgcmVzZXRJbnN0YW5jZXMoKTogdm9pZCB7XG4gICAgICAgIERhdGFiYXNlRmFjdG9yeS5keW5hbW9EQkluc3RhbmNlID0gdW5kZWZpbmVkIGFzIGFueTtcbiAgICAgICAgRGF0YWJhc2VGYWN0b3J5Lm1hcHBlckluc3RhbmNlID0gdW5kZWZpbmVkIGFzIGFueTtcbiAgICB9XG59XG5cbi8vIEV4cG9ydCBzaW5nbGV0b24gaW5zdGFuY2VzIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5XG5leHBvcnQgY29uc3QgZHluYW1vREIgPSBEYXRhYmFzZUZhY3RvcnkuZ2V0RHluYW1vREJDbGllbnQoKTtcbmV4cG9ydCBjb25zdCBtYXBwZXIgPSBEYXRhYmFzZUZhY3RvcnkuZ2V0RGF0YU1hcHBlcigpO1xuIl19

package/dist/config/environment-config.d.ts

@@ -0,0 +1,38 @@
+export type Environment = 'DEV' | 'PRODDEBUG' | 'PROD' | 'test';
+export interface DatabaseConfig {
+    region: string;
+    endpoint?: string;
+    maxAttempts: number;
+    tablePrefix: string;
+    enableLogging: boolean;
+    readConsistency: 'eventual' | 'strong';
+}
+export interface EnvironmentConfig {
+    environment: Environment;
+    database: DatabaseConfig;
+    features: {
+        enableParallelProcessing: boolean;
+        enableBatchOperations: boolean;
+        enableCaching: boolean;
+    };
+    monitoring: {
+        enableMetrics: boolean;
+        logLevel: 'debug' | 'info' | 'warn' | 'error';
+    };
+}
+export declare class EnvironmentManager {
+    private static instance;
+    private currentConfig;
+    private constructor();
+    static getInstance(): EnvironmentManager;
+    private loadEnvironmentConfig;
+    getConfig(): EnvironmentConfig;
+    getDatabaseConfig(): DatabaseConfig;
+    getEnvironment(): Environment;
+    isDEV(): boolean;
+    isPROD(): boolean;
+    isPRODDEBUG(): boolean;
+    isTest(): boolean;
+    setEnvironment(environment: Environment): void;
+}
+export declare const envManager: EnvironmentManager;

package/dist/config/environment-config.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envManager = exports.EnvironmentManager = void 0;
+// Environment-specific configurations
+const environmentConfigs = {
+    DEV: {
+        environment: 'DEV',
+        database: {
+            region: 'us-east-1',
+            endpoint: 'http://localhost:8000', // Local DynamoDB
+            maxAttempts: 3,
+            tablePrefix: 'dev-',
+            enableLogging: true,
+            readConsistency: 'eventual'
+        },
+        features: {
+            enableParallelProcessing: false,
+            enableBatchOperations: true,
+            enableCaching: false
+        },
+        monitoring: {
+            enableMetrics: false,
+            logLevel: 'debug'
+        }
+    },
+    PRODDEBUG: {
+        environment: 'PRODDEBUG',
+        database: {
+            region: 'us-east-1',
+            maxAttempts: 5,
+            tablePrefix: 'proddebug-',
+            enableLogging: true,
+            readConsistency: 'eventual'
+        },
+        features: {
+            enableParallelProcessing: true,
+            enableBatchOperations: true,
+            enableCaching: true
+        },
+        monitoring: {
+            enableMetrics: true,
+            logLevel: 'info'
+        }
+    },
+    PROD: {
+        environment: 'PROD',
+        database: {
+            region: 'us-east-1',
+            maxAttempts: 10,
+            tablePrefix: '',
+            enableLogging: false,
+            readConsistency: 'strong'
+        },
+        features: {
+            enableParallelProcessing: true,
+            enableBatchOperations: true,
+            enableCaching: true
+        },
+        monitoring: {
+            enableMetrics: true,
+            logLevel: 'warn'
+        }
+    },
+    test: {
+        environment: 'test',
+        database: {
+            region: 'us-east-1',
+            endpoint: 'http://localhost:8000',
+            maxAttempts: 1,
+            tablePrefix: 'test-',
+            enableLogging: false,
+            readConsistency: 'eventual'
+        },
+        features: {
+            enableParallelProcessing: false,
+            enableBatchOperations: false,
+            enableCaching: false
+        },
+        monitoring: {
+            enableMetrics: false,
+            logLevel: 'error'
+        }
+    }
+};
+class EnvironmentManager {
+    constructor() {
+        this.currentConfig = this.loadEnvironmentConfig();
+    }
+    static getInstance() {
+        if (!EnvironmentManager.instance) {
+            EnvironmentManager.instance = new EnvironmentManager();
+        }
+        return EnvironmentManager.instance;
+    }
+    loadEnvironmentConfig() {
+        // Priority order: NODE_ENV -> ENVIRONMENT -> default to DEV
+        const env = (process.env.NODE_ENV || process.env.ENVIRONMENT || 'DEV');
+        if (!environmentConfigs[env]) {
+            console.warn(`Unknown environment: ${env}. Falling back to DEV.`);
+            return environmentConfigs.DEV;
+        }
+        return environmentConfigs[env];
+    }
+    getConfig() {
+        return this.currentConfig;
+    }
+    getDatabaseConfig() {
+        return this.currentConfig.database;
+    }
+    getEnvironment() {
+        return this.currentConfig.environment;
+    }
+    isDEV() {
+        return this.currentConfig.environment === 'DEV';
+    }
+    isPROD() {
+        return this.currentConfig.environment === 'PROD';
+    }
+    isPRODDEBUG() {
+        return this.currentConfig.environment === 'PRODDEBUG';
+    }
+    isTest() {
+        return this.currentConfig.environment === 'test';
+    }
+    // Method to override environment at runtime (useful for testing)
+    setEnvironment(environment) {
+        this.currentConfig = environmentConfigs[environment];
+    }
+}
+exports.EnvironmentManager = EnvironmentManager;
+// Export singleton instance
+exports.envManager = EnvironmentManager.getInstance();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-config.js","sourceRoot":"","sources":["../../src/config/environment-config.ts"],"names":[],"mappings":";;;AAyBA,sCAAsC;AACtC,MAAM,kBAAkB,GAA2C;IAC/D,GAAG,EAAE;QACD,WAAW,EAAE,KAAK;QAClB,QAAQ,EAAE;YACN,MAAM,EAAE,WAAW;YACnB,QAAQ,EAAE,uBAAuB,EAAE,iBAAiB;YACpD,WAAW,EAAE,CAAC;YACd,WAAW,EAAE,MAAM;YACnB,aAAa,EAAE,IAAI;YACnB,eAAe,EAAE,UAAU;SAC9B;QACD,QAAQ,EAAE;YACN,wBAAwB,EAAE,KAAK;YAC/B,qBAAqB,EAAE,IAAI;YAC3B,aAAa,EAAE,KAAK;SACvB;QACD,UAAU,EAAE;YACR,aAAa,EAAE,KAAK;YACpB,QAAQ,EAAE,OAAO;SACpB;KACJ;IACD,SAAS,EAAE;QACP,WAAW,EAAE,WAAW;QACxB,QAAQ,EAAE;YACN,MAAM,EAAE,WAAW;YACnB,WAAW,EAAE,CAAC;YACd,WAAW,EAAE,YAAY;YACzB,aAAa,EAAE,IAAI;YACnB,eAAe,EAAE,UAAU;SAC9B;QACD,QAAQ,EAAE;YACN,wBAAwB,EAAE,IAAI;YAC9B,qBAAqB,EAAE,IAAI;YAC3B,aAAa,EAAE,IAAI;SACtB;QACD,UAAU,EAAE;YACR,aAAa,EAAE,IAAI;YACnB,QAAQ,EAAE,MAAM;SACnB;KACJ;IACD,IAAI,EAAE;QACF,WAAW,EAAE,MAAM;QACnB,QAAQ,EAAE;YACN,MAAM,EAAE,WAAW;YACnB,WAAW,EAAE,EAAE;YACf,WAAW,EAAE,EAAE;YACf,aAAa,EAAE,KAAK;YACpB,eAAe,EAAE,QAAQ;SAC5B;QACD,QAAQ,EAAE;YACN,wBAAwB,EAAE,IAAI;YAC9B,qBAAqB,EAAE,IAAI;YAC3B,aAAa,EAAE,IAAI;SACtB;QACD,UAAU,EAAE;YACR,aAAa,EAAE,IAAI;YACnB,QAAQ,EAAE,MAAM;SACnB;KACJ;IACD,IAAI,EAAE;QACF,WAAW,EAAE,MAAM;QACnB,QAAQ,EAAE;YACN,MAAM,EAAE,WAAW;YACnB,QAAQ,EAAE,uBAAuB;YACjC,WAAW,EAAE,CAAC;YACd,WAAW,EAAE,OAAO;YACpB,aAAa,EAAE,KAAK;YACpB,eAAe,EAAE,UAAU;SAC9B;QACD,QAAQ,EAAE;YACN,wBAAwB,EAAE,KAAK;YAC/B,qBAAqB,EAAE,KAAK;YAC5B,aAAa,EAAE,KAAK;SACvB;QACD,UAAU,EAAE;YACR,aAAa,EAAE,KAAK;YACpB,QAAQ,EAAE,OAAO;SACpB;KACJ;CACJ,CAAC;AAEF,MAAa,kBAAkB;IAI3B;QACI,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACtD,CAAC;IAEM,MAAM,CAAC,WAAW;QACrB,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;YAC/B,kBAAkB,CAAC,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAC3D,CAAC;QACD,OAAO,kBAAkB,CAAC,QAAQ,CAAC;IACvC,CAAC;IAEO,qBAAqB;QACzB,4DAA4D;QAC5D,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,KAAK,CAAgB,CAAC;QAEtF,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3B,OAAO,CAAC,IAAI,CAAC,wBAAwB,GAAG,wBAAwB,CAAC,CAAC;YAClE,OAAO,kBAAkB,CAAC,GAAG,CAAC;QAClC,CAAC;QAED,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAEM,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAEM,iBAAiB;QACpB,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;IACvC,CAAC;IAEM,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC;IAC1C,CAAC;IAEM,KAAK;QACR,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,KAAK,KAAK,CAAC;IACpD,CAAC;IAEM,MAAM;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,KAAK,MAAM,CAAC;IACrD,CAAC;IAEM,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,KAAK,WAAW,CAAC;IAC1D,CAAC;IAEM,MAAM;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,KAAK,MAAM,CAAC;IACrD,CAAC;IAED,iEAAiE;IAC1D,cAAc,CAAC,WAAwB;QAC1C,IAAI,CAAC,aAAa,GAAG,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACzD,CAAC;CACJ;AA3DD,gDA2DC;AAED,4BAA4B;AACf,QAAA,UAAU,GAAG,kBAAkB,CAAC,WAAW,EAAE,CAAC","sourcesContent":["export type Environment = 'DEV' | 'PRODDEBUG' | 'PROD' | 'test';\n\nexport interface DatabaseConfig {\n    region: string;\n    endpoint?: string;\n    maxAttempts: number;\n    tablePrefix: string;\n    enableLogging: boolean;\n    readConsistency: 'eventual' | 'strong';\n}\n\nexport interface EnvironmentConfig {\n    environment: Environment;\n    database: DatabaseConfig;\n    features: {\n        enableParallelProcessing: boolean;\n        enableBatchOperations: boolean;\n        enableCaching: boolean;\n    };\n    monitoring: {\n        enableMetrics: boolean;\n        logLevel: 'debug' | 'info' | 'warn' | 'error';\n    };\n}\n\n// Environment-specific configurations\nconst environmentConfigs: Record<Environment, EnvironmentConfig> = {\n    DEV: {\n        environment: 'DEV',\n        database: {\n            region: 'us-east-1',\n            endpoint: 'http://localhost:8000', // Local DynamoDB\n            maxAttempts: 3,\n            tablePrefix: 'dev-',\n            enableLogging: true,\n            readConsistency: 'eventual'\n        },\n        features: {\n            enableParallelProcessing: false,\n            enableBatchOperations: true,\n            enableCaching: false\n        },\n        monitoring: {\n            enableMetrics: false,\n            logLevel: 'debug'\n        }\n    },\n    PRODDEBUG: {\n        environment: 'PRODDEBUG',\n        database: {\n            region: 'us-east-1',\n            maxAttempts: 5,\n            tablePrefix: 'proddebug-',\n            enableLogging: true,\n            readConsistency: 'eventual'\n        },\n        features: {\n            enableParallelProcessing: true,\n            enableBatchOperations: true,\n            enableCaching: true\n        },\n        monitoring: {\n            enableMetrics: true,\n            logLevel: 'info'\n        }\n    },\n    PROD: {\n        environment: 'PROD',\n        database: {\n            region: 'us-east-1',\n            maxAttempts: 10,\n            tablePrefix: '',\n            enableLogging: false,\n            readConsistency: 'strong'\n        },\n        features: {\n            enableParallelProcessing: true,\n            enableBatchOperations: true,\n            enableCaching: true\n        },\n        monitoring: {\n            enableMetrics: true,\n            logLevel: 'warn'\n        }\n    },\n    test: {\n        environment: 'test',\n        database: {\n            region: 'us-east-1',\n            endpoint: 'http://localhost:8000',\n            maxAttempts: 1,\n            tablePrefix: 'test-',\n            enableLogging: false,\n            readConsistency: 'eventual'\n        },\n        features: {\n            enableParallelProcessing: false,\n            enableBatchOperations: false,\n            enableCaching: false\n        },\n        monitoring: {\n            enableMetrics: false,\n            logLevel: 'error'\n        }\n    }\n};\n\nexport class EnvironmentManager {\n    private static instance: EnvironmentManager;\n    private currentConfig: EnvironmentConfig;\n\n    private constructor() {\n        this.currentConfig = this.loadEnvironmentConfig();\n    }\n\n    public static getInstance(): EnvironmentManager {\n        if (!EnvironmentManager.instance) {\n            EnvironmentManager.instance = new EnvironmentManager();\n        }\n        return EnvironmentManager.instance;\n    }\n\n    private loadEnvironmentConfig(): EnvironmentConfig {\n        // Priority order: NODE_ENV -> ENVIRONMENT -> default to DEV\n        const env = (process.env.NODE_ENV || process.env.ENVIRONMENT || 'DEV') as Environment;\n\n        if (!environmentConfigs[env]) {\n            console.warn(`Unknown environment: ${env}. Falling back to DEV.`);\n            return environmentConfigs.DEV;\n        }\n\n        return environmentConfigs[env];\n    }\n\n    public getConfig(): EnvironmentConfig {\n        return this.currentConfig;\n    }\n\n    public getDatabaseConfig(): DatabaseConfig {\n        return this.currentConfig.database;\n    }\n\n    public getEnvironment(): Environment {\n        return this.currentConfig.environment;\n    }\n\n    public isDEV(): boolean {\n        return this.currentConfig.environment === 'DEV';\n    }\n\n    public isPROD(): boolean {\n        return this.currentConfig.environment === 'PROD';\n    }\n\n    public isPRODDEBUG(): boolean {\n        return this.currentConfig.environment === 'PRODDEBUG';\n    }\n\n    public isTest(): boolean {\n        return this.currentConfig.environment === 'test';\n    }\n\n    // Method to override environment at runtime (useful for testing)\n    public setEnvironment(environment: Environment): void {\n        this.currentConfig = environmentConfigs[environment];\n    }\n}\n\n// Export singleton instance\nexport const envManager = EnvironmentManager.getInstance();\n"]}

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './environment-config';
+export * from './database-factory';
+export * from './table-names';

package/dist/config/index.js

@@ -0,0 +1,21 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Export all configuration modules
+__exportStar(require("./environment-config"), exports);
+__exportStar(require("./database-factory"), exports);
+__exportStar(require("./table-names"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxtQ0FBbUM7QUFDbkMsdURBQXFDO0FBQ3JDLHFEQUFtQztBQUNuQyxnREFBOEIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBFeHBvcnQgYWxsIGNvbmZpZ3VyYXRpb24gbW9kdWxlc1xuZXhwb3J0ICogZnJvbSAnLi9lbnZpcm9ubWVudC1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhYmFzZS1mYWN0b3J5JztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUtbmFtZXMnO1xuIl19

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

@@ -0,0 +1,100 @@
+export declare const BASE_TABLE_NAMES: {
+    readonly APP_FEEDBACK: "AppFeedbackTable";
+    readonly LSQ_CRM: "LsqCrmTable";
+    readonly CUTLERY: "CutleryTable";
+    readonly ITEM_ACCOMPANIMENTS: "ItemAccompanimentsTable";
+    readonly CUISINE: "CuisineTable";
+    readonly TIER_DETAILS: "TierDetailsTable";
+    readonly USER_ORDER_SUMMARY: "UserOrderSummaryTable";
+    readonly TIER_REFERRAL: "TierReferralTable";
+    readonly USER_ADDRESS_REQUEST: "UserAddressRequestTable";
+    readonly COMMON_FEEDBACK: "CommonFeedbackTable";
+    readonly GUEST_FEEDBACK: "GuestFeedbackTable";
+    readonly COUNTER: "CounterTable";
+    readonly REQUEST_INVOICE: "RequestInvoiceTable";
+    readonly PLATTER_SEARCH_EVENTS: "PlatterSearchEventsTable";
+    readonly ORDER_REVIEW_FEEDBACK: "OrderReviewFeedbackTable";
+    readonly CATERING_REQUEST: "CateringRequestTable";
+    readonly ORDER: "OrderTable";
+    readonly ORDER_ADDRESS: "OrderAddressTable";
+    readonly ORDER_REVIEW: "OrderReviewTable";
+    readonly PAYMENT: "PaymentTable";
+    readonly PLATE_ORDER: "PlateOrderTable";
+    readonly TRACKING: "TrackingTable";
+    readonly USER_ADDRESS: "UserAddressTable";
+    readonly ADD_ONS: "AddOnsTable";
+    readonly BANK_DETAILS: "BankDetailsTable";
+    readonly CART: "CartTable";
+    readonly CART_CATEGORIES: "CartCategoriesTable";
+    readonly CATEGORY: "CategoryTable";
+    readonly CATERING: "CateringTable";
+    readonly CONTENT: "ContentTable";
+    readonly COUPONS: "CouponsTable";
+    readonly DEFAULT_PLATTER: "DefaultPlatterTable";
+    readonly DEFAULT_PLATTER_CATEGORIES: "DefaultPlatterCategoriesTable";
+    readonly DEFAULT_PLATTER_ITEMS: "DefaultPlatterItemsTable";
+    readonly EVENT_EXECUTIVES: "EventExecutivesTable";
+    readonly ITEMS: "ItemsTable";
+    readonly LEAD: "LeadTable";
+    readonly OCCASION: "OccasionTable";
+    readonly REFERRAL_CONTENT: "ReferralContentTable";
+    readonly USER: "UserTable";
+    readonly WALLET: "WalletTable";
+    readonly WALLET_TRANSACTION: "WalletTransactionTable";
+    readonly WITHDRAWN: "WithdrawnTable";
+    readonly INTERNAL_USER: "InternalUserTable";
+    readonly ACTIVITY_LOGS: "ActivityLogsTable";
+    readonly QUOTATIONS: "QuotationsTable";
+};
+export declare class TableNameManager {
+    static getTableName(baseTableName: string): string;
+    static getAllTableNames(): Record<string, string>;
+}
+export declare const TABLE_NAMES: {
+    readonly APP_FEEDBACK: string;
+    readonly LSQ_CRM: string;
+    readonly CUTLERY: string;
+    readonly ITEM_ACCOMPANIMENTS: string;
+    readonly CUISINE: string;
+    readonly TIER_DETAILS: string;
+    readonly USER_ORDER_SUMMARY: string;
+    readonly TIER_REFERRAL: string;
+    readonly USER_ADDRESS_REQUEST: string;
+    readonly COMMON_FEEDBACK: string;
+    readonly GUEST_FEEDBACK: string;
+    readonly COUNTER: string;
+    readonly REQUEST_INVOICE: string;
+    readonly PLATTER_SEARCH_EVENTS: string;
+    readonly ORDER_REVIEW_FEEDBACK: string;
+    readonly CATERING_REQUEST: string;
+    readonly ORDER: string;
+    readonly ORDER_ADDRESS: string;
+    readonly ORDER_REVIEW: string;
+    readonly PAYMENT: string;
+    readonly PLATE_ORDER: string;
+    readonly TRACKING: string;
+    readonly USER_ADDRESS: string;
+    readonly ADD_ONS: string;
+    readonly BANK_DETAILS: string;
+    readonly CART: string;
+    readonly CART_CATEGORIES: string;
+    readonly CATEGORY: string;
+    readonly CATERING: string;
+    readonly CONTENT: string;
+    readonly COUPONS: string;
+    readonly DEFAULT_PLATTER: string;
+    readonly DEFAULT_PLATTER_CATEGORIES: string;
+    readonly DEFAULT_PLATTER_ITEMS: string;
+    readonly EVENT_EXECUTIVES: string;
+    readonly ITEMS: string;
+    readonly LEAD: string;
+    readonly OCCASION: string;
+    readonly REFERRAL_CONTENT: string;
+    readonly USER: string;
+    readonly WALLET: string;
+    readonly WALLET_TRANSACTION: string;
+    readonly WITHDRAWN: string;
+    readonly INTERNAL_USER: string;
+    readonly ACTIVITY_LOGS: string;
+    readonly QUOTATIONS: string;
+};

package/dist/config/table-names.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TABLE_NAMES = exports.TableNameManager = exports.BASE_TABLE_NAMES = void 0;
+const database_factory_1 = require("./database-factory");
+// Base table names (without environment prefix)
+exports.BASE_TABLE_NAMES = {
+    // Customer App Tables
+    APP_FEEDBACK: 'AppFeedbackTable',
+    LSQ_CRM: 'LsqCrmTable',
+    CUTLERY: 'CutleryTable',
+    ITEM_ACCOMPANIMENTS: 'ItemAccompanimentsTable',
+    CUISINE: 'CuisineTable',
+    TIER_DETAILS: 'TierDetailsTable',
+    USER_ORDER_SUMMARY: 'UserOrderSummaryTable',
+    TIER_REFERRAL: 'TierReferralTable',
+    USER_ADDRESS_REQUEST: 'UserAddressRequestTable',
+    COMMON_FEEDBACK: 'CommonFeedbackTable',
+    GUEST_FEEDBACK: 'GuestFeedbackTable',
+    COUNTER: 'CounterTable',
+    REQUEST_INVOICE: 'RequestInvoiceTable',
+    PLATTER_SEARCH_EVENTS: 'PlatterSearchEventsTable',
+    ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',
+    CATERING_REQUEST: 'CateringRequestTable',
+    // Order Module Tables
+    ORDER: 'OrderTable',
+    ORDER_ADDRESS: 'OrderAddressTable',
+    ORDER_REVIEW: 'OrderReviewTable',
+    PAYMENT: 'PaymentTable',
+    PLATE_ORDER: 'PlateOrderTable',
+    TRACKING: 'TrackingTable',
+    USER_ADDRESS: 'UserAddressTable',
+    // Other Customer Tables
+    ADD_ONS: 'AddOnsTable',
+    BANK_DETAILS: 'BankDetailsTable',
+    CART: 'CartTable',
+    CART_CATEGORIES: 'CartCategoriesTable',
+    CATEGORY: 'CategoryTable',
+    CATERING: 'CateringTable',
+    CONTENT: 'ContentTable',
+    COUPONS: 'CouponsTable',
+    DEFAULT_PLATTER: 'DefaultPlatterTable',
+    DEFAULT_PLATTER_CATEGORIES: 'DefaultPlatterCategoriesTable',
+    DEFAULT_PLATTER_ITEMS: 'DefaultPlatterItemsTable',
+    EVENT_EXECUTIVES: 'EventExecutivesTable',
+    ITEMS: 'ItemsTable',
+    LEAD: 'LeadTable',
+    OCCASION: 'OccasionTable',
+    REFERRAL_CONTENT: 'ReferralContentTable',
+    USER: 'UserTable',
+    WALLET: 'WalletTable',
+    WALLET_TRANSACTION: 'WalletTransactionTable',
+    WITHDRAWN: 'WithdrawnTable',
+    // Internal User Tables
+    INTERNAL_USER: 'InternalUserTable',
+    ACTIVITY_LOGS: 'ActivityLogsTable',
+    QUOTATIONS: 'QuotationsTable'
+};
+// Environment-aware table name getter
+class TableNameManager {
+    static getTableName(baseTableName) {
+        return database_factory_1.DatabaseFactory.getTableName(baseTableName);
+    }
+    static getAllTableNames() {
+        const tableNames = {};
+        Object.entries(exports.BASE_TABLE_NAMES).forEach(([key, value]) => {
+            tableNames[key] = this.getTableName(value);
+        });
+        return tableNames;
+    }
+}
+exports.TableNameManager = TableNameManager;
+// Export environment-aware table names
+exports.TABLE_NAMES = {
+    // Customer App Tables
+    APP_FEEDBACK: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.APP_FEEDBACK),
+    LSQ_CRM: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.LSQ_CRM),
+    CUTLERY: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CUTLERY),
+    ITEM_ACCOMPANIMENTS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ITEM_ACCOMPANIMENTS),
+    CUISINE: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CUISINE),
+    TIER_DETAILS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.TIER_DETAILS),
+    USER_ORDER_SUMMARY: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.USER_ORDER_SUMMARY),
+    TIER_REFERRAL: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.TIER_REFERRAL),
+    USER_ADDRESS_REQUEST: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.USER_ADDRESS_REQUEST),
+    COMMON_FEEDBACK: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.COMMON_FEEDBACK),
+    GUEST_FEEDBACK: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.GUEST_FEEDBACK),
+    COUNTER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.COUNTER),
+    REQUEST_INVOICE: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.REQUEST_INVOICE),
+    PLATTER_SEARCH_EVENTS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.PLATTER_SEARCH_EVENTS),
+    ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),
+    CATERING_REQUEST: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CATERING_REQUEST),
+    // Order Module Tables
+    ORDER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER),
+    ORDER_ADDRESS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER_ADDRESS),
+    ORDER_REVIEW: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER_REVIEW),
+    PAYMENT: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.PAYMENT),
+    PLATE_ORDER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.PLATE_ORDER),
+    TRACKING: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.TRACKING),
+    USER_ADDRESS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.USER_ADDRESS),
+    // Other Customer Tables
+    ADD_ONS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ADD_ONS),
+    BANK_DETAILS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.BANK_DETAILS),
+    CART: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CART),
+    CART_CATEGORIES: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CART_CATEGORIES),
+    CATEGORY: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CATEGORY),
+    CATERING: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CATERING),
+    CONTENT: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CONTENT),
+    COUPONS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.COUPONS),
+    DEFAULT_PLATTER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.DEFAULT_PLATTER),
+    DEFAULT_PLATTER_CATEGORIES: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.DEFAULT_PLATTER_CATEGORIES),
+    DEFAULT_PLATTER_ITEMS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.DEFAULT_PLATTER_ITEMS),
+    EVENT_EXECUTIVES: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.EVENT_EXECUTIVES),
+    ITEMS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ITEMS),
+    LEAD: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.LEAD),
+    OCCASION: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.OCCASION),
+    REFERRAL_CONTENT: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.REFERRAL_CONTENT),
+    USER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.USER),
+    WALLET: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.WALLET),
+    WALLET_TRANSACTION: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.WALLET_TRANSACTION),
+    WITHDRAWN: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.WITHDRAWN),
+    // Internal User Tables
+    INTERNAL_USER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.INTERNAL_USER),
+    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\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\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\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\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/tier-referral/tier-referral-model.js

@@ -22,7 +22,7 @@ __decorate([
     (0, annotations_1.attribute)()
 ], TierRefererModel.prototype, "referralName", void 0);
 __decorate([
-    (0, annotations_1.attribute)()
+    (0, annotations_1.attribute)({ indexKeyConfigurations: { "sentToIndex": "HASH" }, type: 'String' })
 ], TierRefererModel.prototype, "sentTo", void 0);
 __decorate([
     (0, annotations_1.attribute)()
@@ -36,4 +36,4 @@ __decorate([
 exports.TierRefererModel = TierRefererModel = __decorate([
     (0, annotations_1.table)("TierReferralTable")
 ], TierRefererModel);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/index.js

@@ -1,3 +1,9 @@
+// Environment Configuration
+export { envManager, EnvironmentManager } from './dist/config/environment-config';
+export { DatabaseFactory } from './dist/config/database-factory';
+export { TableNameManager, TABLE_NAMES, BASE_TABLE_NAMES } from './dist/config/table-names';
+
+// Core Database Components
 export { InternalUserModel } from './dist/internal-user/internal-user-model';
 export { internalUserDao } from './dist/internal-user/internal-user-dao';
 export { GenericDAO } from './dist/base-dao';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmp-aws-database",
-  "version": "1.1.106",
+  "version": "1.1.107-dev.1",
   "bin": {
     "craft-my-plate-database": "bin/craft-my-plate-database.js"
   },
@@ -8,7 +8,17 @@
     "build": "tsc",
     "watch": "tsc -w",
     "test": "jest",
-    "cdk": "cdk"
+    "cdk": "cdk",
+    "version:info": "node scripts/version-strategy.js info",
+    "version:increment": "node scripts/version-strategy.js increment",
+    "version:sync": "node scripts/version-strategy.js sync",
+    "deploy:dev": "./scripts/deploy-environment.sh -e DEV",
+    "deploy:proddebug": "./scripts/deploy-environment.sh -e PRODDEBUG",
+    "deploy:prod": "./scripts/deploy-environment.sh -e PROD",
+    "deploy:dev:skip-tests": "./scripts/deploy-environment.sh -e DEV --skip-tests",
+    "deploy:proddebug:skip-tests": "./scripts/deploy-environment.sh -e PRODDEBUG --skip-tests",
+    "deploy:prod:skip-tests": "./scripts/deploy-environment.sh -e PROD --skip-tests",
+    "create-branches": "./scripts/create-environment-branches.sh"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/dist/customer-user/order-module/payment/paymet-dao.d.ts

@@ -1,6 +0,0 @@
-import { GenericDAO } from "../../../base-dao";
-import { PaymentModel } from "./payment-model";
-declare class PaymentDAO extends GenericDAO<PaymentModel> {
-}
-export declare const paymentDao: PaymentDAO;
-export {};

package/dist/customer-user/order-module/payment/paymet-dao.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paymentDao = void 0;
-const base_dao_1 = require("../../../base-dao");
-class PaymentDAO extends base_dao_1.GenericDAO {
-}
-exports.paymentDao = new PaymentDAO();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bWV0LWRhby5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jdXN0b21lci11c2VyL29yZGVyLW1vZHVsZS9wYXltZW50L3BheW1ldC1kYW8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsZ0RBQStDO0FBRy9DLE1BQU0sVUFBVyxTQUFRLHFCQUF3QjtDQUVoRDtBQUVZLFFBQUEsVUFBVSxHQUFHLElBQUksVUFBVSxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBHZW5lcmljREFPIH0gZnJvbSBcIi4uLy4uLy4uL2Jhc2UtZGFvXCI7XG5pbXBvcnQgeyBQYXltZW50TW9kZWwgfSBmcm9tIFwiLi9wYXltZW50LW1vZGVsXCI7XG5cbmNsYXNzIFBheW1lbnREQU8gZXh0ZW5kcyBHZW5lcmljREFPPFBheW1lbnRNb2RlbD4ge1xuXG59XG5cbmV4cG9ydCBjb25zdCBwYXltZW50RGFvID0gbmV3IFBheW1lbnREQU8oKTsiXX0=