@ikonintegration/ikapi 3.1.33 → 3.1.35

package/package.json

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

package/src/BaseEvent/IKTransaction.js

@@ -59,7 +59,7 @@ export default class IKTransaction {
       if (this._resp && this._resp instanceof IKResponse) {
         await this._resp.build(this._context, this, this._syncReturn);
         executionFailed = !!(this._resp.getBody() && this._resp.getBody().rollback);
-      } else {
+      } else if (!this._syncReturn) { //sync return can return other than ikresponse
         this._resp = this._getErrorResponse(IKGlobals.ErrorResponseInvalidServerResponse, IKGlobals.ErrorCode_APIError)
         await this._resp.build(this._context, this, this._syncReturn);
         this.logger.error("Invalid response object from main request code.");

package/src/IKEventProcessor.js

@@ -3,15 +3,15 @@ import IKResponse, { IKBadRequestResponse, IKSuccessResponse } from './API/IKRes
 import IKGlobals from './IKGlobals';
 //
 export default class IKEventProcessor {
-  constructor(event, context, config, isBatch) {
+  constructor(event, context, config, respondWithFailures) {
     this.event = event;
     this.context = context;
     this.apiConfig = config;
-    this._syncReturn = isBatch;
+    this._respondWithFailures = respondWithFailures;
   }
   async processEvent(execution, doNotDecodeMessage) {
     const resp = await this._processRawEvent(execution, doNotDecodeMessage);
-    if (resp && !(resp.getCode() >= 200 && resp.getCode() < 300)) throw new Error(JSON.stringify(resp.getBody()));
+    if (!this._respondWithFailures && resp && !(resp.getCode() >= 200 && resp.getCode() < 300)) throw new Error(JSON.stringify(resp.getBody()));
     else if (resp) return resp;
   }
   async _processRawEvent(execution, doNotDecodeMessage) {
@@ -20,17 +20,21 @@ export default class IKEventProcessor {
       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 
-        if (this._syncReturn) return await execution(transaction, decodedRecords);
+        
         //for each available event
+        const failureIDs = [];
         for (let eventRecord of decodedRecords) {
           //Call execution
           let resp = await execution(transaction, eventRecord);
-          if (!(resp.getCode() >= 200 && resp.getCode() < 300)) { //if execution failed, respond and mark as answered
-            return resp;
+          //check for failure
+          if (!(resp.getCode() >= 200 && resp.getCode() < 300)) {
+            //response with failures or fail hard at first
+            if (this._respondWithFailures) failureIDs.push(eventRecord.messageId);
+            else return resp;
           }
         }
-        //not errored and loop ended - succeeded
+        //not errored and loop ended - succeeded (might have failures)
+        if (this._respondWithFailures) return { batchItemFailures: failureIDs.map((id) => ({ itemIdentifier: id })) };
         return IKSuccessResponse();
       });
     } else return IKBadRequestResponse(IKGlobals.ErrorResponseNoRecords, IKGlobals.ErrorCode_NoRecords); //no event to be processed?