apf-node-common 2.0.1 → 3.0.1

package/index.js

@@ -24,6 +24,7 @@ const AWSAPIKeyGenerator = require('./utils/aws/AWSAPIKeyGenerator');
 const AESEncryptionUsingKMS = require('./utils/aws/AESEncryptionUsingKMS');
 const AccessInterceptor = require('./utils/AccessInterceptor');
 const AWSSMSUtils = require('./utils/aws/AWSSMSUtils');
+const DynamoDbService = require('./utils/aws/DynamoDbService');
 const HashIds = require('./utils/HashIds');
 const modulePath = path.resolve(__dirname, 'node_modules');
 const TimeZoneConverter = require('./utils/TimeZoneConverter');
@@ -154,7 +155,8 @@ module.exports.AWSUsagePlanAndApiKey = {
 }
 
 module.exports.AccessInterceptor = {
-    authorize: AccessInterceptor.authorize
+    // authorize: AccessInterceptor.authorize,
+    authorizeWithOpenApiJson: AccessInterceptor.authorizeWithOpenApiJson
 }
 
 module.exports.HashIds = {
@@ -185,4 +187,13 @@ module.exports.Internationalization = {
 
 module.exports.URLShorteningService = {
     shortenURL: URLShorteningService.shortenURL
+};
+
+module.exports.DynamoDbService = {
+    scanRecords: DynamoDbService.scanRecords,
+    getRecord: DynamoDbService.getRecord,
+    queryRecords: DynamoDbService.queryRecords,
+    putRecord: DynamoDbService.putRecord,
+    updateRecord: DynamoDbService.updateRecord,
+    deleteRecord: DynamoDbService.deleteRecord  
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "apf-node-common",
-    "version": "2.0.1",
+    "version": "3.0.1",
     "description": "",
     "main": "index.js",
     "scripts": {
@@ -21,9 +21,10 @@
         "moment": "^2.24.0",
         "moment-timezone": "^0.5.27",
         "path-to-regexp": "^6.1.0",
-        "swagger-jsdoc": "^3.4.0",
         "winston": "^3.2.1",
         "winston-aws-cloudwatch": "^3.0.0",
-        "winston-daily-rotate-file": "^4.5.0"
+        "winston-daily-rotate-file": "^4.5.0",
+        "@aws-sdk/client-dynamodb": "^3.1021.0",
+        "@aws-sdk/lib-dynamodb": "^3.1021.0"
     }
 }

package/utils/AccessInterceptor.js

@@ -1,28 +1,28 @@
-const { pathToRegexp } = require('path-to-regexp')
-const swaggerJSDoc = require('swagger-jsdoc');
-
-function authorize(req, res, options, httpContext, next) {
-    console.log('AccessInterceptor -> authorize');
-    /*var options = {
-        swaggerDefinition: swaggerDefinition,
-        apis: ['swagger/*.js']
-    };*/
-
-    const swaggerSpec = swaggerJSDoc(options)
-    const swaggerJson = JSON.parse(JSON.stringify(swaggerSpec))
-    try {
-        const isAllowed = validateAccess(swaggerJson, req, httpContext, res);
-        if (isAllowed === false) {
-            return isAllowed
-        }
-        return true;
-
-    } catch (error) {
-        console.log(error);
-        return error;
-    }
-    next();
-}
+const { pathToRegexp } = require('path-to-regexp');
+// const swaggerJSDoc = require('swagger-jsdoc');
+
+// function authorize(req, res, options, httpContext, next) {
+//     console.log('AccessInterceptor -> authorize');
+//     /*var options = {
+//         swaggerDefinition: swaggerDefinition,
+//         apis: ['swagger/*.js']
+//     };*/
+
+//     const swaggerSpec = swaggerJSDoc(options)
+//     const swaggerJson = JSON.parse(JSON.stringify(swaggerSpec))
+//     try {
+//         const isAllowed = validateAccess(swaggerJson, req, httpContext, res);
+//         if (isAllowed === false) {
+//             return isAllowed
+//         }
+//         return true;
+
+//     } catch (error) {
+//         console.log(error);
+//         return error;
+//     }
+//     next();
+// }
 
 /**
  * Authorize request based on swagger specification
@@ -111,5 +111,5 @@ function getReplacePath(path) {
     str = str.replace(/}/g, '');
     return str
 }
-exports.authorize = authorize;
+// exports.authorize = authorize;
 exports.authorizeWithOpenApiJson = authorizeWithOpenApiJson;

package/utils/aws/DynamoDbService.js

@@ -0,0 +1,289 @@
+const log = require('apf-node-common/Logger').getLogger();
+const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
+
+const { DynamoDBDocumentClient,
+    ScanCommand,
+    GetCommand,
+    PutCommand,
+    UpdateCommand,
+    DeleteCommand,
+    QueryCommand } = require("@aws-sdk/lib-dynamodb");
+
+const client = new DynamoDBClient({});
+const dynamoDb = DynamoDBDocumentClient.from(client);
+
+
+module.exports = {
+// ══════════════════════════════════════════════════════════════════════════
+// SCAN — fetch multiple records with optional filters
+// ══════════════════════════════════════════════════════════════════════════
+/**
+ * @param {string} tableName
+ * @param {Object} filters    - optional  e.g. { IsDeleted: false }
+ * 
+    * @example
+    * // Fetch where IsDeleted <> true OR IsDeleted missing ✅
+    const items = await DynamoDbService.scanRecords(TABLE_NAME, {
+    FilterExpression: "(#IsDeleted <> :isDeleted OR attribute_not_exists(#IsDeleted))",
+
+const records = await DynamoDbService.scanRecords("AllowedOriginUrls", {
+    FilterExpression: "#MerchantId > :minId AND (#IsDeleted <> :isDeleted OR attribute_not_exists(#IsDeleted)) AND #AllowedUrls = :url",
+    ExpressionAttributeNames:  {
+        "#MerchantId":  "MerchantId",
+        "#IsDeleted":   "IsDeleted",
+        "#AllowedUrls": "AllowedUrls"
+    },
+    ExpressionAttributeValues: {
+        ":minId":     0,
+        ":isDeleted": true,
+        ":url":       "https://dcy2no2504rgw.cloudfront.net/#/login"
+    }
+});
+    *
+    * // Fetch all records no filter
+    * const all = await scanRecords("AllowedOriginUrls");
+    */
+async scanRecords(tableName, params = {}) {
+    try {
+        const command = new ScanCommand({
+            TableName: tableName,  // ← always set
+            ...params              // ← caller provides everything else (e.g. FilterExpression, ExpressionAttributeValues)
+        });
+
+        const result = await dynamoDb.send(command);
+        log.info(`[DynamoDB] scanRecords(${tableName}) → ${result.Items.length} records`);
+        return result.Items;
+
+    } catch (error) {
+        log.error(`[DynamoDB] scanRecords failed on ${tableName}:`, error.message);
+        throw error;
+    }
+},
+
+/**
+ * Fetches a single record by primary key from DynamoDB.
+ *
+ * TABLE: AllowedOriginUrls
+ *   Attributes: MerchantId (PK), IsDeleted, AllowedUrls
+ *
+ * EXAMPLES:
+ *
+ * const record = await DynamoDbService.getRecord("AllowedOriginUrls", { MerchantId: 1277 });
+ * // → { MerchantId: 1277, IsDeleted: false, AllowedUrls: "https://shop.com" }
+ *
+ * // Fetch specific attributes only (ProjectionExpression)
+ * const record = await DynamoDbService.getRecord("AllowedOriginUrls", { MerchantId: 1277 }, {
+ *     ProjectionExpression:        "MerchantId, AllowedUrls",
+ * });
+ * // → { MerchantId: 1277, AllowedUrls: "https://shop.com" }  (IsDeleted not returned)
+ *
+ * // Returns null if record not found
+ * const record = await DynamoDbService.getRecord("AllowedOriginUrls", { MerchantId: 9999 });
+ * // → null
+ */
+async getRecord(tableName, key, params = {}) {
+    try {
+        const result = await dynamoDb.send(new GetCommand({
+            TableName:  tableName,
+            Key:        key,
+            ...params              // ← caller provides anything extra
+        }));
+
+        log.info(`[DynamoDB] getRecord(${tableName}) → ${result.Item ? "found" : "not found"}`);
+        return result.Item || null;
+
+    } catch (error) {
+        log.error(`[DynamoDB] getRecord failed on ${tableName}:`, error.message);
+        throw error;
+    }
+},
+
+
+/**
+ * Fetches multiple records by partition key — faster than scan.
+ * Use when table has sort key and you need multiple records
+ * for the same partition key.
+ * Pl note QueryCommand REQUIRES KeyConditionExpression which must include the partition key and can optionally include the sort key.
+ *  KeyConditionExpression only works on
+ *  Partition Key  → only supports = operator
+ *  Sort Key       → supports =, <, >, BETWEEN, begins_with
+ *
+ * TABLE: AllowedOriginUrls
+ *   Attributes: MerchantId (PK), IsDeleted, AllowedUrls
+ *
+ * EXAMPLES:
+ *
+ * // Fetch all records for a merchant
+ * const records = await DynamoDbService.queryRecords("AllowedOriginUrls", {
+ *     KeyConditionExpression:     "#pk = :pkVal",
+ *     ExpressionAttributeNames:   { "#pk": "MerchantId" },
+ *     ExpressionAttributeValues:  { ":pkVal": 1277 }
+ * });
+ * // → [{ MerchantId: 1277, IsDeleted: false, AllowedUrls: "https://shop.com" }]
+ *
+ * // Fetch with additional filter
+ * const records = await DynamoDbService.queryRecords("AllowedOriginUrls", {
+ *     KeyConditionExpression:     "#pk = :pkVal",
+ *     FilterExpression:           "IsDeleted <> :isDeleted",
+ *     ExpressionAttributeNames:   { "#pk": "MerchantId" },
+ *     ExpressionAttributeValues:  { ":pkVal": 1277, ":isDeleted": true }
+ * });
+ */
+async queryRecords(tableName, params = {}) {
+    try {
+        const result = await dynamoDb.send(new QueryCommand({
+            TableName: tableName,  // ← always set
+            ...params              // ← caller provides everything else (e.g. KeyConditionExpression, FilterExpression, ExpressionAttributeValues)
+        }));
+
+        log.info(`[DynamoDB] queryRecords(${tableName}) → ${result.Items.length} records`);
+        return result.Items;
+
+    } catch (error) {
+        log.error(`[DynamoDB] queryRecords failed on ${tableName}:`, error.message);
+        throw error;
+    }
+},
+
+
+/**
+ * Inserts or replaces a record in DynamoDB.
+ * If record with same key exists → replaces entire record.
+ *
+ * TABLE: AllowedOriginUrls
+ *   Attributes: MerchantId (PK), IsDeleted, AllowedUrls
+ *
+ * EXAMPLES:
+ *
+ * // Insert new record
+ * await DynamoDbService.putRecord("AllowedOriginUrls", {
+ *     MerchantId:  1277,
+ *     AllowedUrls: "https://shop.com",
+ *     IsDeleted:   false
+ * });
+ *
+ * // Insert with condition — only if record does NOT already exist
+ * await DynamoDbService.putRecord("AllowedOriginUrls", {
+ *     MerchantId:  1277,
+ *     AllowedUrls: "https://shop.com",
+ *     IsDeleted:   false
+ * }, {
+ *     ConditionExpression: "attribute_not_exists(MerchantId)"
+ * });
+ */
+async putRecord(tableName, item, params = {}) {
+    try {
+        await dynamoDb.send(new PutCommand({
+            TableName:  tableName,
+            Item:       item,
+            ...params    // ← caller provides anything extra (e.g. ConditionExpression, ExpressionAttributeValues for conditions)
+        }));
+
+        log.info(`[DynamoDB] putRecord(${tableName}) → saved successfully`);
+        return true;
+
+    } catch (error) {
+        log.error(`[DynamoDB] putRecord failed on ${tableName}:`, error.message);
+        throw error;
+    }
+},
+
+
+/**
+ * Updates specific fields of an existing record by primary key.
+ * Only provided fields are updated — rest remain unchanged.
+ *
+ * TABLE: AllowedOriginUrls
+ *   Attributes: MerchantId (PK), IsDeleted, AllowedUrls
+ *
+ * EXAMPLES:
+ *
+ * // Soft delete a record
+ * await DynamoDbService.updateRecord("AllowedOriginUrls",
+ *     { MerchantId: 1277 },
+ *     {
+ *         UpdateExpression:            "SET #IsDeleted = :val",
+ *         ExpressionAttributeNames:   { "#IsDeleted": "IsDeleted" },
+ *         ExpressionAttributeValues:  { ":val": true }
+ *     }
+ * );
+ *
+ * // Update AllowedUrls
+ * await DynamoDbService.updateRecord("AllowedOriginUrls",
+ *     { MerchantId: 1277 },
+ *     {
+ *         UpdateExpression:            "SET #AllowedUrls = :url, #IsDeleted = :isDeleted",
+ *         ExpressionAttributeNames:   { "#AllowedUrls": "AllowedUrls", "#IsDeleted": "IsDeleted" },
+ *         ExpressionAttributeValues:  { ":url": "https://newshop.com", ":isDeleted": false }
+ *     }
+ * );
+ *
+ * // Update only if record exists
+ * await DynamoDbService.updateRecord("AllowedOriginUrls",
+ *     { MerchantId: 1277 },
+ *     {
+ *         UpdateExpression:            "SET #AllowedUrls = :url",
+ *         ConditionExpression:         "attribute_exists(MerchantId)",
+ *         ExpressionAttributeNames:   { "#AllowedUrls": "AllowedUrls" },
+ *         ExpressionAttributeValues:  { ":url": "https://newshop.com" }
+ *     }
+ * );
+ */
+async updateRecord(tableName, key, params = {}) {
+    try {
+        const result = await dynamoDb.send(new UpdateCommand({
+            TableName:      tableName,
+            Key:            key,
+            ReturnValues:   "ALL_NEW",  // ← full updated item
+            ...params                   // ← caller provides UpdateExpression etc
+        }));
+
+        log.info(`[DynamoDB] updateRecord(${tableName}) → updated:`, result.Attributes);
+        return result.Attributes;
+
+    } catch (error) {
+        log.error(`[DynamoDB] updateRecord failed on ${tableName}:`, error.message);
+        throw error;
+    }
+},
+
+
+/**
+ * Deletes a record by primary key from DynamoDB.
+ *
+ * TABLE: AllowedOriginUrls
+ *   Attributes: MerchantId (PK), IsDeleted, AllowedUrls
+ *
+ * EXAMPLES:
+ *
+ * // Hard delete by partition key
+ * await DynamoDbService.deleteRecord("AllowedOriginUrls", { MerchantId: 1277 });
+ *
+ * // Delete only if IsDeleted is already true (conditional delete)
+ * await DynamoDbService.deleteRecord("AllowedOriginUrls",
+ *     { MerchantId: 1277 },
+ *     {
+ *         ConditionExpression:         "#IsDeleted = :val",
+ *         ExpressionAttributeNames:   { "#IsDeleted": "IsDeleted" },
+ *         ExpressionAttributeValues:  { ":val": true }
+ *     }
+ * );
+ */
+async deleteRecord(tableName, key, params = {}) {
+    try {
+        await dynamoDb.send(new DeleteCommand({
+            TableName:  tableName,
+            Key:        key,
+            ...params              // ← caller provides anything extra ✅
+        }));
+
+        log.info(`[DynamoDB] deleteRecord(${tableName}) → deleted successfully`);
+        return true;
+
+    } catch (error) {
+        log.error(`[DynamoDB] deleteRecord failed on ${tableName}:`, error.message);
+        throw error;
+    }
+}
+
+}