@ikonintegration/ikapi 2.5.4 → 2.6.0-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikonintegration/ikapi",
-  "version": "2.5.4",
+  "version": "2.6.0-beta",
   "description": "",
   "main": "index.js",
   "module": "main.js",
@@ -10,20 +10,21 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@aws/dynamodb-auto-marshaller": "0.7.1",
-    "abind": "1.0.5",
-    "aws-sdk": "^2.951.0",
-    "bluebird": "3.7.2",
-    "email-templates": "^8.0.7",
-    "esm": "3.2.25",
-    "is-email": "^1.0.1",
-    "is-uuid": "1.0.2",
-    "json-stringify-safe": "5.0.1",
-    "ksuid": "2.0.0",
-    "libphonenumber-js": "^1.9.22",
-    "nodemailer": "^6.6.3",
-    "path-to-regexp": "6.2.0",
-    "pg": "^8.6.0",
+    "@aws/dynamodb-auto-marshaller": "^0.7.1",
+    "abind": "^1.0.5",
+    "aws-sdk": "^2.1034.0",
+    "bluebird": "^3.7.2",
+    "email-templates": "^8.0.8",
+    "esm": "^3.2.25",
+    "is-email": "^1.0.2",
+    "is-uuid": "^1.0.2",
+    "json-stringify-safe": "^5.0.1",
+    "ksuid": "^3.0.0",
+    "libphonenumber-js": "^1.9.43",
+    "nodemailer": "^6.7.1",
+    "path-to-regexp": "^6.2.0",
+    "pg": "^8.7.1",
+    "sha1": "^1.1.1",
     "stack-trace": "0.0.10",
     "superstruct": "0.8.4"
   }

package/src/API/IKResponse.js

@@ -5,9 +5,11 @@ export default class IKResponse {
     this._statusCode = statusCode;
     this._body = body;
     //
-    this._streamingOut = false;
-    this._isStream = false;
+    this._streamingOut = false; //internal -- flag to indicate streaming out has started and avoid double stream call
+    //indeally it should be moved to initialization method as we dont' want them to be changed on the go and also give the false impression of getters with the current naming pattern
+    this._isStream = false; //
     this._contextRawBody = false;
+    this._throwOnErrors = false;
     //
     this._headers = {
       "Access-Control-Allow-Origin": "*",
@@ -19,7 +21,7 @@ export default class IKResponse {
   getBody() { return this._body; }
   appendIntoBody(key, value) { this._body[key] = value; }
   appendHeader(key, value) { this._headers[key] = value; }
-  build(context, requestID, onQueue, transaction) {
+  build(context, requestID, isBatch, transaction) {
     //Stream support
     if (this._streamingOut) return;
     if (this._isStream) return this._pipe(context, requestID);
@@ -36,7 +38,7 @@ export default class IKResponse {
     };
     //log response and respond to context
     transaction.logger.debug(b)
-    if (!onQueue) context.succeed(b);
+    if (!isBatch) context.succeed(b);
   }
   _pipe(context, requestID) {
     //Check if not streaming
@@ -60,11 +62,12 @@ export default class IKResponse {
       //
       function CustomError(body) {
         this.name = body && body.error ? body.error : 'UnknownError';
-        this.message = body;
+        this.message = body && body.message ? body.message : 'Unknown error!';
       }
       CustomError.prototype = new Error();
       //
-      context.fail(new CustomError(this._body));
+      if (!this._throwOnErrors) context.fail(new CustomError(this._body));
+      else throw (new CustomError(this._body));
     }
   }
 }
@@ -108,5 +111,6 @@ export function IKSuccessStreamResponse(stream, contentType) {
 export function IKStepFunctionResponse(body, optionalCode) {
   const resp = new IKResponse(optionalCode || 200, body);
   resp._contextRawBody = true;
+  resp._throwOnErrors = true;
   return resp;
 }

package/src/BaseEvent/IKTransaction.js

@@ -16,14 +16,16 @@ import IKResponse, { IKBadRequestResponseWithRollback } from '../API/IKResponse'
 
 //
 export default class IKTransaction {
-  constructor(event, context, config, _isQueue) {
+  constructor(event, context, config, _isBatch, _retrowErrors) {
     this._event = event;
     this._context = context;
     this._config = config;
     //queue support
-    this._onQueue = _isQueue;
+    this._isBatch = _isBatch;
     this._resp = null;
     //
+    this._retrowErrors = _retrowErrors;
+    //
     this.logger = new IKLogger({/*COFIG S3/SQS HERE*/}, Utils.logLevel(), (context.awsRequestId ? context.awsRequestId : (event.requestContext ? event.requestContext.requestId : 'unknown')));
     this.request = new IKRequest(this._event, this._context, this);
     this.publisher = new IKPublisher(config.publisher);
@@ -39,7 +41,7 @@ export default class IKTransaction {
         return await this._execute(executionFunc);
       });
     });
-    if (this._onQueue) return this._resp;
+    if (this._isBatch) return this._resp;
   }
   //Executions
   async _execute(executionFunc) {
@@ -50,19 +52,22 @@ export default class IKTransaction {
       this._resp = await executionFunc(this);
       //Answer client
       if (this._resp && this._resp instanceof IKResponse) {
-        this._resp.build(this._context, this.request.getRequestID(), this._onQueue, this);
+        this._resp.build(this._context, this.request.getRequestID(), this._isBatch, this);
         executionFailed = !!(this._resp.getBody() && this._resp.getBody().rollback);
       } else {
         this._resp = this._getErrorResponse(IKGlobals.ErrorResponseInvalidServerResponse, IKGlobals.ErrorCode_APIError)
-        this._resp.build(this._context, this.request.getRequestID(), this._onQueue, this);
+        this._resp.build(this._context, this.request.getRequestID(), this._isBatch, this);
         this.logger.error("Invalid response object from main request code.");
       }
     } catch (e) { /*EXECUTION FAIL*/
       this.logger.error('Exception when executing main request code.');
       this.logger.exception(e);
+      //retrow?
+      if (this._retrowErrors) throw e;
+      //envelope exception?
       if (executionFailed) {
         this._resp = this._getErrorResponse(IKGlobals.ErrorResponseUnhandledError, IKGlobals.ErrorCode_APIError);
-        this._resp.build(this._context, this.request.getRequestID(), this._onQueue, this);
+        this._resp.build(this._context, this.request.getRequestID(), this._isBatch, this);
       }
     } return executionFailed;
   }
@@ -86,6 +91,8 @@ export default class IKTransaction {
     } catch (e) {
       this.logger.error('Exception when executing DB transactions.');
       this.logger.log(e);
+      //retrow?
+      if (this._retrowErrors) throw e;
     }
   }
   async _executeLoggerFlush(safeExecution) {
@@ -95,6 +102,8 @@ export default class IKTransaction {
     } catch (e) {
       this.logger.error('Exception when flushing logs.');
       this.logger.exception(e);
+      //retrow?
+      if (this._retrowErrors) throw e;
     } finally {
       this.logger.debug("Transaction ended");
     }

package/src/Database/DDB/IKDB.js

@@ -4,6 +4,9 @@ import Utils from "./../../API/IKUtils";
 //
 import IKGlobals from './../../IKGlobals';
 import IKDB from './../Prototype/IKDB';
+//reusable connection
+var DDB_CONN = null;
+var DDB_CONN_HASH = null;
 //
 export default class IKDB_DDB extends IKDB {
   constructor(config, transaction) {
@@ -15,6 +18,10 @@ export default class IKDB_DDB extends IKDB {
     if (config && this.tableName) { localConsole.debug(`Using table: ${this.tableName} on region: ${this.region}`); }
   }
 
+  async _getConnection() {
+    if (!DDB_CONN && !DDB_CONN_HASH && DDB_CONN_HASH != sha1(this.region)) DDB_CONN = await this._newConnection(this.config);
+    return DDB_CONN;
+  }
   async connect() {
     const localConsole = (this.transaction ? this.transaction.logger : console);
     //setup db
@@ -29,6 +36,9 @@ export default class IKDB_DDB extends IKDB {
       //initialize connection
       AWS.config.update({httpOptions: sslAgent, region: this.region});
       this.connection = new AWS.DynamoDB();
+      //Reusable logic
+      DDB_CONN = this.connection;
+      DDB_CONN_HASH = sha1(this.region);
     }
   }
 }

package/src/IKDynamoStream.js

@@ -17,7 +17,7 @@ export default class IKDynamoStream {
   async _processRawEvent(execution) {
     if (this.event.Records && this.event.Records.length > 0) { //safe check for empty events?
       //init transaction for all records
-      return await (new IKTransaction(this.event, this.context, this.apiConfig, true /*on queue*/)).execute(async (transaction) => {
+      return await (new IKTransaction(this.event, this.context, this.apiConfig, true /*batch processing*/)).execute(async (transaction) => {
         //for each available event
         for (let eventRecord of this.event.Records) {
           //Prepare parsed record

package/src/IKEventProcessor.js

@@ -17,7 +17,7 @@ export default class IKEventProcessor {
   async _processRawEvent(execution, doNotDecodeMessage) {
     if (this.event.Records && this.event.Records.length > 0) { //safe check for empty events?
       //init transaction for all records
-      return await (new IKTransaction(this.event, this.context, this.apiConfig, true /*on queue*/)).execute(async (transaction) => {
+      return await (new IKTransaction(this.event, this.context, this.apiConfig, true /*batch processing*/)).execute(async (transaction) => {
         //Map records with decoded message when required
         const decodedRecords = this.event.Records.map((eventRecord) => (doNotDecodeMessage ? eventRecord.body : JSON.parse(eventRecord.body)));
         //If is batch, return execution 

package/src/IKStepTransaction.js

@@ -4,10 +4,11 @@ import { IKStepFunctionResponse } from './API/IKResponse';
 //
 export default class IKStepTransaction extends IKTransaction {
   constructor(event, context, config) {
-    super(event, context, config, false);
+    super(event, context, config, false, true /* retrowErrors */);
   }
   /* Response support */
   _getErrorResponse(error, code) {
     return IKStepFunctionResponse({ err: error, errCode: code }, 400);
   }
 }
+

package/src/Publisher/IKPublisher.js

@@ -1,6 +1,9 @@
 import AWS from "aws-sdk";
 //
 import Utils from "./../API/IKUtils";
+//reusable client
+var PUBLISHER_CONN = null;
+var PUBLISHER_CONN_HASH = null;
 //
 export default class IKPublisher {
   constructor(config) {
@@ -9,25 +12,33 @@ export default class IKPublisher {
       console.debug(`Using region: ${this.region}`);
     }
   }
-
+  /* Public */
   async publishOnTopic(messageObject, topic, additionalProps) {
     let resp = null;
     try {
-      //Configure when sending!
-      let configObj = { region: this.region };
-      if (Utils.isOffline()) configObj = { ...configObj, accessKeyId: process.env.AWS_ACCESS_KEY_ID, secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY };
-      AWS.config.update(configObj);
+      this._connect();
       //Send to SNS
       const params = {
         Message: JSON.stringify(messageObject),
         TopicArn: topic,
         ...(additionalProps ? additionalProps : {}),
       };
-      resp = await (new AWS.SNS({ apiVersion: '2010-03-31' })).publish(params).promise();
+      resp = await PUBLISHER_CONN.publish(params).promise();
     } catch (e) {
       console.error(`Error while publishing into topic ${topic} with error: ${e}`);
     }
     console.debug('Publisher resp', resp);
     return resp;
   }
+  /* Private */
+  _connect() {
+    if (!PUBLISHER_CONN && !PUBLISHER_CONN_HASH && PUBLISHER_CONN_HASH != sha1(this.regiond)) {
+      //Configure when sending!
+      let configObj = { region: this.region };
+      if (Utils.isOffline()) configObj = { ...configObj, accessKeyId: process.env.AWS_ACCESS_KEY_ID, secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY };
+      AWS.config.update(configObj);
+      PUBLISHER_CONN = (new AWS.SNS({ apiVersion: '2010-03-31' }));
+      PUBLISHER_CONN_HASH = sha1(this.region);
+    }
+  }
 }