@ikonintegration/ikapi 2.5.3 → 2.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikonintegration/ikapi",
-  "version": "2.5.3",
+  "version": "2.5.7",
   "description": "",
   "main": "index.js",
   "module": "main.js",

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 = JSON.stringify(body);
       }
       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/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);
   }
 }
+