@izara_project/izara-core-generate-service-code 1.0.52 → 1.0.54

package/src/codeGenerators/app/src/generatedCode/FindData/templates/FindData_HdrSqs.ejs

@@ -0,0 +1,87 @@
+import { middlewareHandler as middleware, validatorSchema } from '@izara_project/izara-middleware';
+import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import Logger from '@izara_project/izara-core-library-logger';
+
+import findData from './FindData_Main.js';
+
+// validate event properties in body.Message of sqs event
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+// set schema for record.body.Message
+const perRecordsValidatorSchema = {
+  type: 'object',
+  required: ['fieldName', 'objType', 'identifiers', 'overWriteCache'],
+  properties: {
+    fieldName: {
+      type: 'object'
+    },
+    objType: {
+      type: 'object',
+      required: ['serviceTag', 'objectType'],
+      properties: {
+        serviceTag: {
+          type: 'string',
+          enum: [process.env.iz_serviceTag]
+        },
+        objectType: validatorSchema.stringNotEmpty()
+      }
+    },
+    identifiers: {
+      type: 'object'
+    },
+    overWriteCache: {
+      type: 'boolean'
+    },
+    callingFlow: {
+      type: 'string',
+      default: ''
+    }
+  }
+};
+
+export const main = middleware.wrap(async (event, context) => {
+  try {
+    let recordPromises = [];
+
+    await Promise.all(
+      event.Records.map(async record => {
+        let passOnProperties = [];
+        record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
+
+        await recordHandlerSharedLib.validateRecord(
+          record,
+          'FindDataHdrSqs',
+          perRecordsValidatorSchema
+        );
+
+        passOnProperties.push(record.body.Message.fieldName);
+        passOnProperties.push(record.body.Message.objType);
+        passOnProperties.push(record.body.Message.identifiers);
+        passOnProperties.push(record.body.Message.overWriteCache);
+        passOnProperties.push(record.body.Message.callingFlow);
+        record._izContext.logger.debug('passOnProperties in handler', passOnProperties);
+
+        let recordPromise = recordHandlerSharedLib.recordHandler(
+          record,
+          findData,
+          'FindDataHdrSqs',
+          passOnProperties
+        );
+        record._izContext.logger.debug('after recordPromise in handler');
+        recordPromises.push(recordPromise);
+      })
+    );
+
+    Logger.debug('before Promise.all(recordPromises) in handler');
+    try {
+      await Promise.all(recordPromises);
+      return event.Records;
+    } catch {
+      Logger.debug('Promise.all(recordPromises) in handler threw error');
+    }
+    Logger.debug('after Promise.all(recordPromises) in handler');
+  } catch (err) {
+    Logger.error('Unhandled Error, FindDataHdrSqs: ', err);
+    throw err;
+  }
+});

package/src/codeGenerators/app/src/generatedCode/FindData/templates/FindData_Main.ejs

@@ -0,0 +1,108 @@
+import findDataSharedLib from '@izara_project/izara-core-library-find-data';
+import graphSharedLib from '@izara_project/izara-core-library-graph-service';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+
+import { serviceConfig, identifiersObject as identifierObj } from '@izara_project/izara-core-library-service-schemas';
+
+//(<additionalModule>)
+//(</additionalModule>)
+
+/**
+ * triggered from searchResult for each requiredData field per one identifiers
+ */
+async function _getValueFromDynamo(_izContext, fieldName, objType, identifiers, tableName, errorsFound, standardErrorParams, findDataSharedLib, dynamodbSharedLib, identifierObj) {
+  const identifiersBase = await identifierObj.identifiersBaseFromIdentifiers(_izContext, objType, identifiers);
+  _izContext.logger.debug('create identifiersBase from identifiers: ', identifiersBase);
+
+  const objInstanceBase = await dynamodbSharedLib.getItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, tableName),
+    identifiersBase
+  );
+  _izContext.logger.debug('objInstanceBase: ', objInstanceBase);
+
+  if (!objInstanceBase) {
+    errorsFound.push(`can't get data in dynamo by ${identifiersBase}`);
+    standardErrorParams.push(errorsFound);
+    await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+    return { _error: 'FindData cannot get data in dynamo' };
+  }
+
+  if (!objInstanceBase.hasOwnProperty(fieldName)) {
+    errorsFound.push(`data in dynamoDB have no ${fieldName}`);
+    standardErrorParams.push(errorsFound);
+    await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+    return { _error: 'Data have no fieldName' };
+  }
+
+  return { _value: objInstanceBase[fieldName] };
+}
+
+export default async function findData(
+  _izContext,
+  fieldName,
+  objType,
+  identifiers,
+  overWriteCache,
+  callingFlow,
+
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('----- findData event params -----', {
+      fieldName: fieldName,
+      objType: objType,
+      identifiers: identifiers,
+      overWriteCache: overWriteCache,
+      callingFlow: callingFlow
+    });
+
+    let removeAttributes = [];
+    //(<removeAttributes>)
+    //(</removeAttributes>)
+
+    let deleteDataTableOnExpired = [];
+
+    let [findDataMainStatus, findDataId, findDataMain] = await findDataSharedLib.checkFindDataMainStatus(
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      callingFlow,
+      removeAttributes,
+      overWriteCache
+    );
+
+    _izContext.logger.debug('result after checkFindDataMainStatus is', {
+      findDataMainStatus: findDataMainStatus,
+      findDataId: findDataId,
+      findDataMain: findDataMain
+    });
+
+    if (findDataMainStatus != 'process') {
+      _izContext.logger.debug(`findDataMainStatus status isn't process :${findDataMainStatus}`);
+      return { returnResponse: 'Function FindData not process' };
+    }
+
+    let errorsFound = [];
+    let standardErrorParams = [
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      null,
+      overWriteCache,
+      callingFlow,
+      'error'
+    ];
+
+<%- objectTypeBlocks %>
+
+    return { returnResponse: 'Function FindData Finish' };
+
+  } catch (err) {
+    _izContext.logger.error('error FindDataMain: ', err);
+    throw err;
+  }
+}

package/src/codeGenerators/app/src/generatedCode/FindData/templates/GetByStorage/getByDynamo.ejs

@@ -0,0 +1,32 @@
+//(<beforeGetItem<%- objectType %><%- fieldName.fieldName %>>)
+//(</beforeGetItem<%- objectType %><%- fieldName.fieldName %>>)
+
+const _dynamo_<%- fieldName.fieldName %> = await _getValueFromDynamo(
+  _izContext,
+  '<%- fieldName.fieldName %>',
+  objType,
+  identifiers,
+  '<%- tableName %>',
+  errorsFound,
+  standardErrorParams,
+  findDataSharedLib,
+  dynamodbSharedLib,
+  identifierObj
+);
+if (_dynamo_<%- fieldName.fieldName %>._error) return { returnResponse: _dynamo_<%- fieldName.fieldName %>._error };
+const dataValue = _dynamo_<%- fieldName.fieldName %>._value;
+_izContext.logger.debug('dataValue: ', dataValue);
+
+//(<afterGetItem<%- objectType %><%- fieldName.fieldName %>>)
+//(</afterGetItem<%- objectType %><%- fieldName.fieldName %>>)
+
+await findDataSharedLib.completeFindDataMain(
+  _izContext,
+  findDataMain.fieldName,
+  findDataMain.objType,
+  findDataMain.identifiers,
+  dataValue,
+  overWriteCache,
+  callingFlow,
+  'complete'
+);

package/src/{generators/fromObjectSchema/findData → codeGenerators/app/src/generatedCode/FindData/templates}/GetByStorage/getByGraph.ejs

@@ -78,10 +78,10 @@ await findDataSharedLib.completeFindDataMain(
 );
 
 <%_ function createNameTagBefore(objectType, fieldName){
-  return `//(<beforeGetNode${objectType}${fieldName}>)
-          //(</beforeGetNode${objectType}${fieldName}>)`
+  return `//(<beforeGetNode${objectType}${fieldName.fieldName}>)
+//(</beforeGetNode${objectType}${fieldName.fieldName}>)`
 } _%>
 <%_ function createNameTagAfter(objectType, fieldName){
-  return `//(<afterGetNode${objectType}${fieldName}>)
-          //(</afterGetNode${objectType}${fieldName}>)`
-} _%>
+  return `//(<afterGetNode${objectType}${fieldName.fieldName}>)
+//(</afterGetNode${objectType}${fieldName.fieldName}>)`
+} _%>

package/src/codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/EndpointsGenerator.js

@@ -0,0 +1,119 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { processFunctionName, processMainFileName, upperFirst } from '../_shared/shared/flowNaming.js';
+import { EVENT_HANDLERS } from '../_shared/events/registry.js';
+import { getGeneratedCodeConfigs } from '../_shared/shared/flowSelection.js';
+
+const CRUD_ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+const CRUD_ASYNC_ACTIONS = ['Create', 'Update', 'Delete'];
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateEndpointsFlow(allSchemas, options) {
+  console.log('  [EndpointsGenerator] Generating CRUD Endpoint Flows...');
+  const baseOutputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode');
+  const templateDir = path.join(__dirname, 'templates');
+
+  let generatedCount = 0;
+
+  // We only generate CRUD if there's at least one applicable object
+  const hasApplicableObject = (allSchemas.objects || []).some(
+    obj => obj.generatedBy === 'userGenerated' || obj.generatedBy === 'systemGenerated'
+  );
+  if (!hasApplicableObject) return;
+
+  const sharedTemplates = {
+    sqs: await fs.readFile(path.join(__dirname, '..', '_shared', 'handlers', 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
+    api: await fs.readFile(path.join(__dirname, '..', '_shared', 'handlers', 'FlowHandler_HdrApi.ejs'), 'utf-8'),
+    inv: await fs.readFile(path.join(__dirname, '..', '_shared', 'handlers', 'FlowHandler_HdrInv.ejs'), 'utf-8'),
+    wbsMain: await fs.readFile(path.join(__dirname, '..', 'FlowSchemas', 'templates', 'endpoint', 'FlowMain_Wbs.ejs'), 'utf-8').catch(() => ''),
+    endpointHdrWbs: await fs.readFile(path.join(__dirname, '..', 'FlowSchemas', 'templates', 'endpoint', 'FlowEndpoint_HdrWbs.ejs'), 'utf-8').catch(() => '')
+  };
+
+  // We need to pass a mock flows array to getGeneratedCodeConfigs if it expects it
+  // Since we are decoupling, we will just use allSchemas.flows for custom logic filtering
+  const customFlows = allSchemas.flows || [];
+
+  for (const action of CRUD_ACTIONS) {
+    const isAsync = CRUD_ASYNC_ACTIONS.includes(action);
+    const upperAction = upperFirst(action);
+    const flowOutputDir = path.join(baseOutputDir, 'FlowEndpoints', upperAction, 'source');
+    await fs.mkdir(flowOutputDir, { recursive: true });
+
+    const mainFileName = processMainFileName(action);
+    const processFunction = processFunctionName(action);
+
+    // Mock flow object for registry handlers if needed
+    const mockFlow = {
+      flowTag: action,
+      event: isAsync ? ['ownTopic'] : ['lambdaSyncInv', 'lambdaSyncApi']
+    };
+
+    const generateCode = getGeneratedCodeConfigs(customFlows, action, { includeFlowTag: true });
+
+    // 1. Generate Main Logic File
+    const mainTemplatePath = path.join(templateDir, 'crud', `${action}Endpoint_Main.ejs`);
+    let mainTemplateStr;
+    try {
+      mainTemplateStr = await fs.readFile(mainTemplatePath, 'utf-8');
+    } catch (err) {
+      console.warn(`  [EndpointsGenerator] Warning: Main template not found for ${action}.`);
+      continue;
+    }
+
+    const mainContent = ejs.render(mainTemplateStr, {
+      flowTag: action,
+      upperCaseFlowTag: upperAction,
+      topicArn: `${upperAction}_In`,
+      generateCode: generateCode,
+      flow: mockFlow,
+      inTagConfig: null
+    });
+    await fs.writeFile(path.join(flowOutputDir, `${mainFileName}.js`), mainContent, 'utf-8');
+    generatedCount++;
+
+    // 2. Generate BeforeLogical Main Logic File if needed
+    const beforeLogicalConfigs = generateCode.filter(c => c.codeHookTag === 'beforeLogical');
+    if (beforeLogicalConfigs.length > 0) {
+      const beforeLogicalTemplateStr = await fs.readFile(
+        path.join(templateDir, 'FlowEndpointBeforeLogical_Main.ejs'),
+        'utf-8'
+      );
+      const beforeLogicalFileName = `${upperAction}BeforeLogical_Main`;
+      const beforeLogicalContent = ejs.render(beforeLogicalTemplateStr, {
+        flowTag: action,
+        upperCaseFlowTag: upperAction,
+        generateCode: generateCode,
+        flow: mockFlow,
+        inTagConfig: null
+      });
+      await fs.writeFile(path.join(flowOutputDir, `${beforeLogicalFileName}.js`), beforeLogicalContent, 'utf-8');
+      generatedCount++;
+
+      // BeforeLogical SQS Handler
+      const sqsContent = ejs.render(sharedTemplates.sqs, {
+          flowTag: action,
+          flowStepName: '',
+          mainFileName: beforeLogicalFileName,
+          functionName: `${action}BeforeLogicalMain`,
+          queueName: `${action}BeforeLogicalHdrSqs`
+      });
+      await fs.writeFile(path.join(flowOutputDir, `${upperAction}BeforeLogical_HdrSqs.js`), sqsContent, 'utf-8');
+      generatedCount++;
+    }
+
+    // 3. Generate Handlers based on event array using Registry
+    for (const ev of mockFlow.event) {
+        const handlerGenerator = EVENT_HANDLERS[ev];
+        if (handlerGenerator) {
+            await handlerGenerator(mockFlow, '', flowOutputDir, mainFileName, sharedTemplates, generateCode);
+            generatedCount++;
+        }
+    }
+  }
+
+  console.log(`  [EndpointsGenerator] Generated ${generatedCount} files for CRUD Endpoints.`);
+}

package/src/{generators/fromObjectSchema/endpoint/main/beforeLogical/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/FlowEndpointBeforeLogical_Main.ejs}

@@ -15,7 +15,7 @@ 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 { objectHash as hash } from '@izara_project/izara-shared-core';
+import { objectHash as hash, identifierUuid } from '@izara_project/izara-shared-core';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
 import {
@@ -30,26 +30,26 @@ import {
 
 const { createObjType, firstLetterUpperCase } = utils;
 
-import { <%= action %>MainLogical } from './<%= functionName %>_Main.js';
+import { <%- flowTag %>MainLogical } from './Process<%- upperCaseFlowTag %>_Main.js';
 
 //(<optionalRequire>)
 //(</optionalRequire>)
 
 /**
- * Handles callback after beforeLogical phase — verifies awaitingStep then proceeds to createMainLogical
+ * Handles callback after beforeLogical phase — verifies awaitingStep then proceeds to <%- flowTag %>MainLogical
  * @param {Object} _izContext - Context object with logger
  * @param {Object} requestParams - { fieldNames, relationships[] }
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
- export default async function createBeforeLogicalMain(
+export default async function <%- flowTag %>BeforeLogicalMain(
   _izContext,
   requestParams,
   flowTag,
   callingFlowConfig = {}
 ) {
   try {
-    _izContext.logger.debug('<%- action %>BeforeLogicalMain:', {
+    _izContext.logger.debug('<%- flowTag %>BeforeLogicalMain:', {
       requestParams,
       flowTag,
       callingFlowConfig
@@ -62,24 +62,19 @@ import { <%= action %>MainLogical } from './<%= functionName %>_Main.js';
 
     const identifiers = {};
     for (const fieldName of objectSchemas.identifierFieldNames) {
-      <%_ if (action === 'create') { _%>
       if (requestParams.returnRequestParams.fieldNames?.hasOwnProperty(fieldName)) {
         identifiers[fieldName] = requestParams.returnRequestParams.fieldNames[fieldName];
       }
-      <%_ } else if (action === 'update') { _%>
-      if (requestParams.returnRequestParams.objInstanceFull?.identifiers?.hasOwnProperty(fieldName)) {
-        identifiers[fieldName] = requestParams.returnRequestParams.objInstanceFull.identifiers[fieldName];
-      }
-      <%_ } else if (action === 'delete') { _%>
-      if (requestParams.returnRequestParams.identifiers?.hasOwnProperty(fieldName)) {
-        identifiers[fieldName] = requestParams.returnRequestParams.identifiers[fieldName];
-      }
-      <%_ } _%>
     }
     _izContext.logger.debug('identifiers:::: ', identifiers);
+    
     // build parentFlowId
+    <%_ if (flowTag === 'Create') { _%>
     const parentFlowId = identifierUuid();
-    
+    <%_ } else { _%>
+    const parentFlowId = hash(identifiers);
+    <%_ } _%>
+
     // ── Verify + remove awaitingStep ──────────────────────────────────────────
     const awaitingStepId = asyncFlowSharedLib.createAwaitingStepId(
       parentFlowId,

package/src/{generators/fromObjectSchema/endpoint/main/create/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/CreateEndpoint_Main.ejs}

@@ -55,7 +55,7 @@ const PREFIX = {
  * @param {Object} beforeLogicalResults - Results from beforeLogical
  * @returns {Promise<Object>} Result with objType, objInstanceFull, relationships, status, errorsFound
  */
-export async function createMainLogical(
+export async function <%- flowTag %>MainLogical(
   _izContext,
   requestParams,
   callingFlowConfig = {},
@@ -398,7 +398,7 @@ export async function createMainLogical(
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
-export default async function createMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}
@@ -484,7 +484,7 @@ export default async function createMain(
     _izContext.logger.debug('errorsFound::', errorsFound);
 
     if (errorsFound.length > 0)
-      return await createMainLogical(
+      return await <%- flowTag %>MainLogical(
         _izContext,
         requestParams,
         callingFlowConfig,
@@ -517,7 +517,7 @@ export default async function createMain(
 
     // ── beforeLogical phase check ─────────────────────────────────────────────
     <%_
-    const groupedByObjType = generatedCodeConfig
+    const groupedByObjType = generateCode
       .filter(c => c.codeHookTag === 'beforeLogical')
       .reduce((acc, config) => {
         const key = config.objType.objectType;
@@ -648,7 +648,7 @@ export default async function createMain(
         return acc;
       }, {});
 
-      return await createMainLogical(
+      return await <%- flowTag %>MainLogical(
         _izContext,
         requestParams,
         callingFlowConfig,
@@ -662,7 +662,7 @@ export default async function createMain(
     //(</beforeCreateMainLogical>)
 
     // ── No beforeLogical → proceed directly to logical ────────────────────────
-    return await createMainLogical(
+    return await <%- flowTag %>MainLogical(
       _izContext,
       requestParams,
       callingFlowConfig

package/src/{generators/fromObjectSchema/endpoint/main/delete/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/DeleteEndpoint_Main.ejs}

@@ -45,7 +45,7 @@ const { TOPIC_NAME_GENERATE_CODE } = consts;
  * @param {Object} beforeLogicalResults - Results from beforeLogical phase
  * @returns {Promise<Object>}
  */
-export async function deleteMainLogical(
+export async function <%- flowTag %>MainLogical(
   _izContext,
   requestParams,
   callingFlowConfig = {},
@@ -149,7 +149,7 @@ export async function deleteMainLogical(
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
-export default async function deleteMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}
@@ -193,7 +193,7 @@ export default async function deleteMain(
 
     // ── beforeLogical phase check ─────────────────────────────────────────────
     <%_
-    const groupedByObjType = generatedCodeConfig
+    const groupedByObjType = generateCode
       .filter(c => c.codeHookTag === 'beforeLogical')
       .reduce((acc, config) => {
         const key = config.objType.objectType;
@@ -323,7 +323,7 @@ export default async function deleteMain(
           return acc;
         }, {});
 
-        return await deleteMainLogical(
+        return await <%- flowTag %>MainLogical(
           _izContext,
           requestParams,
           callingFlowConfig,
@@ -337,7 +337,7 @@ export default async function deleteMain(
     //(</beforeDeleteMainLogical>)
 
     // ── No beforeLogical → proceed directly to logical ────────────────────────
-    return await deleteMainLogical(
+    return await <%- flowTag %>MainLogical(
       _izContext,
       requestParams,
       callingFlowConfig

package/src/{generators/fromObjectSchema/endpoint/main/get/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/GetEndpoint_Main.ejs}

@@ -55,7 +55,7 @@ import { sns } from '@izara_project/izara-core-library-external-request';
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>} Collected get result
  */
-export default async function getMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}

package/src/{generators/fromObjectSchema/endpoint/main/update/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/UpdateEndpoint_Main.ejs}

@@ -49,7 +49,7 @@ import { sns, lambda } from '@izara_project/izara-core-library-external-request'
  * @param {Object} beforeLogicalResults - Results from beforeLogical phase
  * @returns {Promise<Object>}
  */
-export async function updateMainLogical(
+export async function <%- flowTag %>MainLogical(
   _izContext,
   requestParams,
   callingFlowConfig = {},
@@ -327,7 +327,7 @@ export async function updateMainLogical(
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
-export default async function updateMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}
@@ -354,7 +354,7 @@ export default async function updateMain(
 
     // ── beforeLogical phase check ─────────────────────────────────────────────
     <%_
-    const groupedByObjType = generatedCodeConfig
+    const groupedByObjType = generateCode
       .filter(c => c.codeHookTag === 'beforeLogical')
       .reduce((acc, config) => {
         const key = config.objType.objectType;
@@ -484,7 +484,7 @@ export default async function updateMain(
           return acc;
         }, {});
 
-        return await updateMainLogical(
+        return await <%- flowTag %>MainLogical(
           _izContext,
           requestParams,
           callingFlowConfig,
@@ -498,7 +498,7 @@ export default async function updateMain(
     //(</beforeUpdateMainLogical>)
 
     // ── No beforeLogical → proceed directly to logical ────────────────────────
-    return await updateMainLogical(
+    return await <%- flowTag %>MainLogical(
       _izContext,
       requestParams,
       callingFlowConfig