@izara_project/izara-core-generate-service-code 1.0.66 → 1.0.68

package/src/emit/crud/templates/FlowEndpointComplete_Main.ejs

@@ -6,70 +6,182 @@ import { sns } from '@izara_project/izara-core-library-external-request';
 import { consts } from '@izara_project/izara-core-library-service-schemas';
 import { NoRetryError } from '@izara_project/izara-core-library-core';
 
-const { TOPIC_NAME_GENERATE_CODE } = consts;
+const { TOPIC_NAME_GENERATE_CODE, PREFIX: _constPrefix } = consts;
+<%_ if (action === 'Update') { _%>
+const PREFIX = { ASYNC: _constPrefix.updateNode };
+<%_ } else { _%>
 const PREFIX = { ASYNC: '<%- action %>AsyncEndpoint' };
+<%_ } _%>
 
 function empty(value) {
-  return value == null || (typeof value === 'object' && Object.keys(value).length === 0);
+  return (
+    value == null ||
+    (typeof value === 'object' && Object.keys(value).length === 0)
+  );
 }
 
 function validateInput(returnValue, status, graphServiceTag, errorsFound) {
-  if (!returnValue?.queryResult) errorsFound.push('message is not have property queryResult, should be not happen');
-  if (!returnValue?.requestParams?.objType) errorsFound.push('message is not have property objType, should be not happen');
-  if (!returnValue?.requestParams?.objInstanceFull) errorsFound.push('message is not have property objInstance, should be not objInstance');
-  if (status === 'error' && errorsFound.length === 0) errorsFound.push('[invalid]status is error not have errorsFound form graphService');
-  if (status === 'complete' && errorsFound.length > 0) errorsFound.push('[Invalid] status is complete should be not have errorsFound');
-  if (graphServiceTag == null) errorsFound.push('[Invalid] graphServerTag is not empty string');
+  if (!returnValue?.queryResult)
+    errorsFound.push(
+      'message is not have property queryResult, should be not happen'
+    );
+  if (!returnValue?.requestParams?.objType)
+    errorsFound.push(
+      'message is not have property objType, should be not happen'
+    );
+  if (!returnValue?.requestParams?.objInstanceFull)
+    errorsFound.push(
+      'message is not have property objInstance, should be not objInstance'
+    );
+  if (status === 'error' && errorsFound.length === 0)
+    errorsFound.push(
+      '[invalid]status is error not have errorsFound form graphService'
+    );
+  if (status === 'complete' && errorsFound.length > 0)
+    errorsFound.push(
+      '[Invalid] status is complete should be not have errorsFound'
+    );
+  if (graphServiceTag == null)
+    errorsFound.push('[Invalid] graphServerTag is not empty string');
 }
 
-export default async function <%- action %>Complete(_izContext, requestParams, passBackProperties) {
+export default async function <%- action %>Complete(
+  _izContext,
+  requestParams,
+  passBackProperties
+) {
   try {
-    const { returnValue, status, errorsFound = [], graphServiceTag, parentFlowId } = requestParams;
-    if (empty(returnValue?.requestParams)) throw new NoRetryError('message not an object');
+    _izContext.logger.debug('[<%- action %>Complete] started', {
+      requestParams
+    });
+    const {
+      returnValue,
+      status,
+      errorsFound = [],
+      graphServiceTag,
+      parentFlowId
+    } = requestParams;
+    if (empty(returnValue?.requestParams))
+      throw new NoRetryError('message not an object');
     validateInput(returnValue, status, graphServiceTag, errorsFound);
     if (errorsFound.length > 0) errorsFound.push(errorsFound.join(','));
 
-    const awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(parentFlowId, PREFIX.ASYNC);
-    const pending = await asyncFlowSharedLib.findPendingStepAwaitingMultipleSteps(_izContext, awaitingStepId);
-    const result = await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
-      _izContext, pending.pendingStepId, awaitingStepId, errorsFound
+    const awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
+      parentFlowId,
+      PREFIX.ASYNC
+    );
+    const pending =
+      await asyncFlowSharedLib.findPendingStepAwaitingMultipleSteps(
+        _izContext,
+        awaitingStepId
+      );
+    _izContext.logger.debug('[<%- action %>Complete] awaiting step', {
+      awaitingStepId,
+      pending
+    });
+    if (!pending) {
+      _izContext.logger.warn(
+        `No pending step found for awaitingStepId: ${awaitingStepId}`
+      );
+      return { returnValue, status, errorsFound };
+    }
+    const result =
+      await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+        _izContext,
+        pending.pendingStepId,
+        awaitingStepId,
+        errorsFound
+      );
+    _izContext.logger.debug(
+      '[<%- action %>Complete] all awaiting steps result',
+      {
+        isComplete: result.isComplete,
+        awaitingStepId,
+        pendingStepId: pending.pendingStepId
+      }
     );
 
     if (result.isComplete) {
-      const node = returnValue.queryResult.return<%- action %>Node ?? {};
-      const existsNode = node.existsNode && Object.keys(node.existsNode).length
-        ? { objType: returnValue.requestParams.objType, objInstanceFull: node.existsNode.objInstanceFull }
-        : null;
+      const nodeResultKey = `return<%- action %>dNode`;
+      const fallbackNodeResultKey = `return<%- action %>Node`;
+      const nodeResult =
+        returnValue.queryResult[nodeResultKey] ??
+        returnValue.queryResult[fallbackNodeResultKey] ??
+        {};
+      const node = nodeResult[`<%- action.toLowerCase() %>NodeResult`] ?? nodeResult;
+      const existsNode =
+        node.existsNode && Object.keys(node.existsNode).length
+          ? {
+              objType: returnValue.requestParams.objType,
+              objInstanceFull: node.existsNode.objInstanceFull
+            }
+          : null;
       if (status === 'complete') {
-        await Promise.all((pending.listOfRecords ?? []).flatMap(records => Object.values(records).map(async record =>
-          dynamodbSharedLib.putItem(_izContext, await dynamodbSharedLib.tableName(_izContext, record.tableName, record.serviceTag), {
-            ...record.objInstanceFull.identifiers,
-            ...record.objInstanceFull.fields
-          })
-        )));
+        await Promise.all(
+          (pending.listOfRecords ?? []).flatMap((records) =>
+            Object.values(records).map(async (record) =>
+              dynamodbSharedLib.putItem(
+                _izContext,
+                await dynamodbSharedLib.tableName(
+                  _izContext,
+                  record.tableName,
+                  record.serviceTag
+                ),
+                {
+                  ...record.objInstanceFull.identifiers,
+                  ...record.objInstanceFull.fields
+                }
+              )
+            )
+          )
+        );
       }
-      const message = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, {
-        objType: returnValue.requestParams.objType,
-        objInstanceFull: node.objInstanceFull,
-        relationships: node.relationships,
-        parentFlowId: returnValue.parentFlowId,
-        existsNode,
-        status,
-        errorsFound
+      const message =
+        callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+          passBackProperties,
+          {
+            objType: returnValue.requestParams.objType,
+            objInstanceFull: node.objInstanceFull,
+            relationships: node.relationships,
+            parentFlowId: returnValue.parentFlowId,
+            existsNode,
+            status,
+            errorsFound
+          }
+        );
+      const messageAttributes =
+        callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+          passBackProperties,
+          {}
+        );
+      const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        TOPIC_NAME_GENERATE_CODE.out<%- action %>NodeComplete
+      );
+      _izContext.logger.debug('[<%- action %>Complete] publishing to SNS', {
+        TopicArn: topicArn,
+        message
       });
-      const messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {});
       await sns.publishAsync(_izContext, {
         Message: JSON.stringify(message),
-        MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-        TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.out<%- action %>NodeComplete)
+        MessageAttributes: sns.createStringMessageAttributes(
+          _izContext,
+          messageAttributes
+        ),
+        TopicArn: topicArn
       });
       //(<afterSendMessage>)
       //(</afterSendMessage>)
     }
-    await asyncFlowSharedLib.removeAwaitingMultipleStep(_izContext, awaitingStepId, pending.pendingStepId, errorsFound);
+    await asyncFlowSharedLib.removeAwaitingMultipleStep(
+      _izContext,
+      awaitingStepId,
+      pending.pendingStepId,
+      errorsFound
+    );
     return { returnValue, status, errorsFound };
   } catch (error) {
-    _izContext.logger.error('<%- action %>Complete error:', error);
+    _izContext.logger.error('[<%- action %>Complete] error:', error);
     throw error;
   }
 }

package/src/emit/crud/templates/FlowEndpoint_HdrWbs.ejs

@@ -15,13 +15,19 @@ You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-
-import { middlewareHandler as middleware, validatorSchema, consts, response } from "@izara_project/izara-middleware";
+import {
+  middlewareHandler as middleware,
+  validatorSchema,
+  consts,
+  response
+} from '@izara_project/izara-middleware';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 import { objectHash as hash } from '@izara_project/izara-shared-core';
-import { utils, getObjectSchema } from "@izara_project/izara-core-library-service-schemas";
+import {
+  utils,
+  getObjectSchema
+} from '@izara_project/izara-core-library-service-schemas';
 const { createFlowTypeConcat } = utils;
 
 import { webSocket } from '@izara_project/izara-core-library-external-request';
@@ -29,68 +35,83 @@ const { postToConnection } = webSocket;
 
 import <%- typeof functionName !== 'undefined' ? functionName : upperCaseFlowTag %> from './<%- typeof mainFileName !== 'undefined' ? mainFileName : `${upperCaseFlowTag}_Main` %>.js';
 
-export const main = middleware.wrap(async (event, context) => {
+//(<optionalRequire>)
+//(</optionalRequire>)
 
+export const main = middleware.wrap(async (event, context) => {
   event._izContext.logger.debug('Event:', event);
 
   try {
     if (event.requestContext) {
       const route = event.requestContext.routeKey;
       const connectionId = event.requestContext.connectionId;
-      let correlationId = event._izContext.correlationIds.get(consts.X_CORRELATION_ID)
+      let correlationId = event._izContext.correlationIds.get(
+        consts.X_CORRELATION_ID
+      );
 
       switch (route) {
-
         case '$default':
           console.log('Received unknown route:', route);
-          break
+          break;
         case '<%- flowTag %>':
-          console.log("event in route webSocket", event);
-          let eventParams = JSON.parse(event.body)
+          console.log('event in route webSocket', event);
+          let eventParams = JSON.parse(event.body);
 
           //(<createIdentifiersFlow>)
-          let identifiers = ""
+          let identifiers = '';
           //(</createIdentifiersFlow>)
 
           let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(
             event._izContext,
             {
-              flowTag: "<%- flowTag %>",
+              flowTag: '<%- flowTag %>',
               serviceTag: process.env.iz_serviceTag
             }
-          )
+          );
 
-          if (flowSchema.statusType === "statusField" || flowSchema.statusType === "storedCache" || flowSchema.statusType === "triggerCache") {
-            await dynamodbSharedLib.putItem(event._izContext,
-              await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
+          if (
+            flowSchema.statusType === 'statusField' ||
+            flowSchema.statusType === 'storedCache' ||
+            flowSchema.statusType === 'triggerCache'
+          ) {
+            await dynamodbSharedLib.putItem(
+              event._izContext,
+              await dynamodbSharedLib.tableName(
+                event._izContext,
+                'WebSocketTask'
+              ),
               {
-                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: "<%- flowTag %>", serviceTag: process.env.iz_serviceTag })}${identifiers}`,
+                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${identifiers}`,
                 connectionId: connectionId,
                 ttl: 600
               }
-            )
-
-          } else if (flowSchema.statusType === "none") {
+            );
+          } else if (flowSchema.statusType === 'none') {
             await dynamodbSharedLib.putItem(
               event._izContext,
-              await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
+              await dynamodbSharedLib.tableName(
+                event._izContext,
+                'WebSocketTask'
+              ),
               {
-                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: "<%- flowTag %>", serviceTag: process.env.iz_serviceTag })}${correlationId}`,
-                connectionId: connectionId,
+                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${correlationId}`,
+                connectionId: connectionId
               }
-            )
+            );
           }
 
-          let callingFlow = eventParams?.callingFlow ? eventParams.callingFlow : {};
+          let callingFlow = eventParams?.callingFlow
+            ? eventParams.callingFlow
+            : {};
           await <%- typeof functionName !== 'undefined' ? functionName : upperCaseFlowTag %>(
             event._izContext,
             eventParams,
             //(<additionalParams>)
             //(</additionalParams>)
             callingFlowSharedLib.addCallingFlowToPassOnProperties(callingFlow)
-          )
+          );
 
-          break
+          break;
       }
     } else {
       const connId = event.connId;
@@ -98,13 +119,12 @@ export const main = middleware.wrap(async (event, context) => {
       await postToConnection({ message: event.message }, connId);
     }
 
-    return (response.webSocketSuccess());
-
+    return response.webSocketSuccess();
   } catch (err) {
-    const connId = event.requestContext.connectionId
+    const connId = event.requestContext.connectionId;
     event._izContext.logger.error('Error, WebSocket: ', err);
     // await sendErrorMessage({ message: err.message }, connId);
     await postToConnection({ message: err.message }, connId);
-    return (response.failure(err));
+    return response.failure(err);
   }
 });

package/src/emit/crud/templates/FlowHandler_HdrApi.ejs

@@ -1,20 +1,23 @@
-import { middlewareHandler as middleware, response } from "@izara_project/izara-middleware";
+import {
+  middlewareHandler as middleware,
+  response
+} from '@izara_project/izara-middleware';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 
 import <%= functionName %> from './<%= mainFileName %>.js';
 
 const validatorSchema = {
-    //(<validatorSchema>)
-<% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
-    type: 'object',
-    properties: {
+  //(<validatorSchema>)
+  <% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
+  type: 'object',
+  properties: {
     <% startConfig.properties.forEach(prop => { -%>
-        <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+    <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' }
     <% }) -%>
-    },
-    required: [ <%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
-<% } -%>
-    //(</validatorSchema>)
+  },
+  required: [<%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %>]
+  <% } -%>
+  //(</validatorSchema>)
 };
 
 middleware.setValidatorSchema(validatorSchema, { noAuthorizer: true });
@@ -24,28 +27,51 @@ middleware.setValidatorSchema(validatorSchema, { noAuthorizer: true });
  * Triggered by: API Gateway
  */
 export const main = middleware.wrap(async (event, context) => {
-    event._izContext?.logger?.debug(`[${context.awsRequestId}] Received API request in <%= flowStepName %>`);
-
-    try {
-        const passOnProperties = [
-            event.body,
-            //(<additionalParams>)
-            //(</additionalParams>)
-            callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
-        ];
-
-        const lambdaFunctionResponse = await <%= functionName %>(
-            event._izContext,
-            ...passOnProperties
-        );
-
-        if (lambdaFunctionResponse instanceof Error) {
-            return response.failure(lambdaFunctionResponse);
+  event._izContext?.logger?.debug(
+    `[${context.awsRequestId}] Received API request in <%= flowStepName %>`
+  );
+
+  try {
+    let objectType;
+    if (event.routeKey) {
+      const path = event.routeKey.split(' ')[1];
+      if (path) {
+        const segments = path.split('/');
+        const serviceName = process.env.iz_serviceName;
+        const serviceIndex = segments.indexOf(serviceName);
+        if (serviceIndex !== -1 && segments.length > serviceIndex + 1) {
+          objectType = segments[serviceIndex + 1];
         }
+      }
+    }
 
-        return response.success(lambdaFunctionResponse);
-    } catch (err) {
-        event._izContext?.logger?.error('Unhandled Error in <%= flowStepName %> API:', err);
-        return response.failure(err);
+    if (objectType) {
+      event.body = event.body || {};
+      event.body.objectType = objectType;
     }
+
+    const passOnProperties = [
+      event.body,
+      //(<additionalParams>)
+      //(</additionalParams>)
+      callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
+    ];
+
+    const lambdaFunctionResponse = await <%= functionName %>(
+      event._izContext,
+      ...passOnProperties
+    );
+
+    if (lambdaFunctionResponse instanceof Error) {
+      return response.failure(lambdaFunctionResponse);
+    }
+
+    return response.success(lambdaFunctionResponse);
+  } catch (err) {
+    event._izContext?.logger?.error(
+      'Unhandled Error in <%= flowStepName %> API:',
+      err
+    );
+    return response.failure(err);
+  }
 });

package/src/emit/crud/templates/FlowHandler_HdrInv.ejs

@@ -1,20 +1,20 @@
-import { middlewareHandler as middleware } from "@izara_project/izara-middleware";
+import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 
 import <%= functionName %> from './<%= mainFileName %>.js';
 
 const validatorSchema = {
-    //(<validatorSchema>)
-<% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
-    type: 'object',
-    properties: {
+  //(<validatorSchema>)
+  <% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
+  type: 'object',
+  properties: {
     <% startConfig.properties.forEach(prop => { -%>
-        <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+    <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' }
     <% }) -%>
-    },
-    required: [ <%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
-<% } -%>
-    //(</validatorSchema>)
+  },
+  required: [<%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %>]
+  <% } -%>
+  //(</validatorSchema>)
 };
 
 middleware.setValidatorSchema(validatorSchema);
@@ -24,22 +24,24 @@ middleware.setValidatorSchema(validatorSchema);
  * Triggered by: Lambda Invocation
  */
 export const main = middleware.wrap(async (event, context) => {
-    event._izContext?.logger?.debug(`[${context.awsRequestId}] Received Invocation in <%= flowStepName %>`);
+  event._izContext?.logger?.debug(
+    `[${context.awsRequestId}] Received Invocation in <%= flowStepName %>`
+  );
 
-    try {
-        const passOnProperties = [
-            event,
-            //(<additionalParams>)
-            //(</additionalParams>)
-            callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
-        ];
+  try {
+    const passOnProperties = [
+      event,
+      //(<additionalParams>)
+      //(</additionalParams>)
+      callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
+    ];
 
-        return await <%= functionName %>(
-            event._izContext,
-            ...passOnProperties
-        );
-    } catch (err) {
-        event._izContext?.logger?.error('Unhandled Error in <%= flowStepName %> Invocation:', err);
-        throw err;
-    }
+    return await <%= functionName %>(event._izContext, ...passOnProperties);
+  } catch (err) {
+    event._izContext?.logger?.error(
+      'Unhandled Error in <%= flowStepName %> Invocation:',
+      err
+    );
+    throw err;
+  }
 });

package/src/emit/crud/templates/FlowHandler_HdrSqs.ejs

@@ -24,13 +24,16 @@ import <%= functionName %> from './<%= mainFileName %>.js';
 // validate event properties in body.Message of sqs event
 let perRecordsValidatorSchema = {
   //(<validatorSchema>)
-<% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
+  <% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
   type: 'object',
   properties: {
-<% startConfig.properties.forEach((prop, index) => { %>    <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' }<%= index < startConfig.properties.length - 1 ? ',' : '' %>
-<% }) %>  },
+    <% startConfig.properties.forEach((prop, index) => { %> <%- prop.propertyName %>: {
+      type: '<%- prop.type || 'string' %>'
+    } /*__EJS_COMMA_6__*/
+    <% }) %>
+  },
   required: [<%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %>]
-<% } -%>
+  <% } -%>
   //(</validatorSchema>)
 };
 
@@ -38,15 +41,16 @@ let perRecordsValidatorSchema = {
 let messageAttributeValidatorSchema = {
   type: 'object',
   properties: {
-<% startConfig.messageAttributes.forEach((prop, index) => { %>    '<%- prop.propertyName %>': {
+    <% startConfig.messageAttributes.forEach((prop, index) => { %> <%- prop.propertyName %>: {
       type: 'object',
       properties: {
         Type: { type: 'string' },
         Value: { type: '<%- prop.type || 'string' %>' }
       },
       required: ['Type', 'Value']
-    }<%= index < startConfig.messageAttributes.length - 1 ? ',' : '' %>
-<% }) %>  },
+    } /*__EJS_COMMA_14__*/
+    <% }) %>
+  },
   required: [<%- startConfig.messageAttributes.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %>]
 };
 <% } else { -%>
@@ -60,7 +64,7 @@ export const main = middleware.wrap(async (event, context) => {
 
     // loop each record and send to mainFunction
     await Promise.all(
-      event.Records.map(async record => {
+      event.Records.map(async (record) => {
         // promise.all for map() function
 
         let passOnProperties = [];
@@ -76,19 +80,19 @@ export const main = middleware.wrap(async (event, context) => {
 
         // add argument (to invoke lambda) to passOnProperties[]
         passOnProperties.push(record.body.Message);
-<% if (typeof usePassBack === 'undefined' ? functionName.endsWith('Complete') : usePassBack) { %>
+        <% if (typeof usePassBack === 'undefined' ? functionName.endsWith('Complete') : usePassBack) { %>
         passOnProperties.push(
           callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
             record.body.Message
           )
         );
-<% } else { %>
+        <% } else { %>
         passOnProperties.push(
           callingFlowSharedLib.addCallingFlowToPassOnProperties(
             record.body.Message
           )
         );
-<% } %>
+        <% } %>
         //(<additionalParams>)
         //(</additionalParams>)
         record._izContext.logger.debug(