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

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowValidator.js

@@ -0,0 +1,144 @@
+const ALLOWED_MAIN_EVENTS = ['ownTopic', 'extTopic', 'lambdaSyncInv', 'lambdaSyncApi', 'eventBridge', 's3'];
+const MAIN_ASYNC_EVENTS = ['ownTopic', 'extTopic', 's3'];
+const ALLOWED_STEP_EVENTS = ['sqs', 'ownTopic', 'extTopic', 'dsq', 'lambdaSyncInv', 'lambdaSyncApi'];
+const RESERVED_SYSTEM_FLOW_TAGS = new Set([
+  'Create',
+  'Update',
+  'Delete',
+  'Get',
+  'CreateTargetRole',
+  'ListTargetRole',
+  'DeleteTargetRole',
+  'CreateRolePermissions',
+  'ListRolePermissions',
+  'DeleteRolePermissions',
+  'CreateUserRole',
+  'ListUserInRoles',
+  'DeleteUserFromRole',
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+]);
+
+function asArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function validateNamedRefs(flowTag, stepName, refs, defs, label, errors) {
+  if (refs === undefined) return;
+  if (!Array.isArray(refs)) {
+    errors.push(`Flow '${flowTag}' step '${stepName}' ${label} must be an array.`);
+    return;
+  }
+
+  for (const ref of refs) {
+    if (typeof ref === 'string') {
+      if (!defs || !defs[ref]) {
+        errors.push(`Flow '${flowTag}' step '${stepName}' references missing ${label} key '${ref}'.`);
+      }
+      continue;
+    }
+
+    if (!ref || typeof ref !== 'object') {
+      errors.push(`Flow '${flowTag}' step '${stepName}' ${label} entries must be string keys or schema objects.`);
+    }
+  }
+}
+
+export function validateFlowsForGeneration(flows) {
+  const errors = [];
+  const seenCustomFlowTags = new Set();
+
+  for (const flow of flows) {
+    const flowTag = flow?.flowTag;
+    if (!flowTag) {
+      errors.push('Flow is missing flowTag.');
+      continue;
+    }
+
+    const isSystemFlow = flow.initiateBy === 'system';
+    if (!isSystemFlow) {
+      if (seenCustomFlowTags.has(flowTag)) {
+        errors.push(`Flow '${flowTag}' is defined more than once.`);
+      }
+      seenCustomFlowTags.add(flowTag);
+
+      if (RESERVED_SYSTEM_FLOW_TAGS.has(flowTag)) {
+        errors.push(`Flow '${flowTag}' is reserved by a system flow. Please use a different flowTag.`);
+      }
+    }
+
+    const events = asArray(flow.event);
+    const invalidMainEvents = events.filter(event => !ALLOWED_MAIN_EVENTS.includes(event));
+    if (invalidMainEvents.length > 0) {
+      errors.push(`Flow '${flowTag}' uses unsupported main events: ${invalidMainEvents.join(', ')}. Allowed are: ${ALLOWED_MAIN_EVENTS.join(', ')}.`);
+    }
+
+    const mainAsyncEvents = events.filter(event => MAIN_ASYNC_EVENTS.includes(event));
+    if (mainAsyncEvents.length > 1) {
+      errors.push(`Flow '${flowTag}' multiple main async triggers: ${mainAsyncEvents.join(', ')}. Only one is allowed.`);
+    }
+
+    const flowSteps = Array.isArray(flow.flowSteps) ? flow.flowSteps : [];
+    const seenStepNames = new Set();
+    let anyStepHasPlugInHooks = false;
+    let inTagCount = 0;
+
+    for (const step of flowSteps) {
+      const stepName = step?.stepName;
+      if (!stepName) {
+        errors.push(`Flow '${flowTag}' has a step without stepName.`);
+        continue;
+      }
+
+      if (seenStepNames.has(stepName)) {
+        errors.push(`Flow '${flowTag}' has duplicate stepName '${stepName}'.`);
+      }
+      seenStepNames.add(stepName);
+
+      if (stepName === 'In') {
+        errors.push(`Flow '${flowTag}' uses legacy stepName 'In'. Use 'InTag'.`);
+      }
+      if (stepName === 'InTag') {
+        inTagCount += 1;
+      }
+
+      if (step.plugInHooks && step.plugInHooks.length > 0) {
+        anyStepHasPlugInHooks = true;
+      }
+
+      const stepEvents = asArray(step.event);
+      const invalidStepEvents = stepEvents.filter(event => !ALLOWED_STEP_EVENTS.includes(event));
+      if (invalidStepEvents.length > 0) {
+        errors.push(`Flow '${flowTag}' step '${stepName}' uses unsupported step events: ${invalidStepEvents.join(', ')}. Allowed are: ${ALLOWED_STEP_EVENTS.join(', ')}.`);
+      }
+
+      validateNamedRefs(flowTag, stepName, step.properties, flow.stepProperties, 'properties', errors);
+      validateNamedRefs(flowTag, stepName, step.messageAttributes, flow.stepMessageAttributes, 'messageAttributes', errors);
+    }
+
+    if (inTagCount > 1) {
+      errors.push(`Flow '${flowTag}' has multiple 'InTag' steps. Only one is allowed.`);
+    }
+
+    if (anyStepHasPlugInHooks && inTagCount === 0) {
+      errors.push(`Flow '${flowTag}' uses plugInHooks but does not have an 'InTag' step. If flow needs plugin-aware main lambda, it must include an 'InTag' step.`);
+    }
+
+    if (anyStepHasPlugInHooks) {
+      const forbiddenEvents = ['lambdaSyncInv', 'lambdaSyncApi', 's3', 'eventBridge'];
+      const usedForbiddenEvents = events.filter(event => forbiddenEvents.includes(event));
+      if (usedForbiddenEvents.length > 0) {
+        errors.push(`Flow '${flowTag}' uses plugInHooks with unsupported main events: ${usedForbiddenEvents.join(', ')}. plugInHooks are allowed only for async/event-driven flows.`);
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error('Flow Validation Failed:\n' + errors.map(error => `- ${error}`).join('\n'));
+  }
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/registry.js

@@ -0,0 +1,7 @@
+import { generateStatusField } from '../../FlowSchemas/StatusFieldGenerator.js';
+import { generateTriggerCache } from './triggerCacheBase.js';
+
+export const STATUS_HANDLERS = {
+    statusField: generateStatusField,
+    triggerCache: generateTriggerCache
+};

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/triggerCacheBase.js

@@ -0,0 +1,183 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { getFlowOutputSubDir } from './flowClassifier.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function upperCase(str) {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function shortNameHandler(handlerType) {
+    const map = {
+        'HdrSqs': 'Sqs',
+        'HdrApi': 'Api',
+        'HdrWbs': 'Wbs',
+        'HdrDsq': 'Dsq'
+    };
+    return map[handlerType] || handlerType;
+}
+
+export async function generateTriggerCache(flowSchema, appPath, outputBaseDir) {
+    const flowTag = flowSchema.flowTag;
+    const upperFlowTag = upperCase(flowTag);
+    const serviceTag = flowSchema.objType?.serviceTag || 'UnknownService';
+    const templateDir = path.join(__dirname, '..', '_shared', 'triggerCache');
+
+    const subDir = getFlowOutputSubDir(flowTag);
+
+    const flowOutputDir = path.join(outputBaseDir, 'app', 'src', 'generatedCode', subDir, upperFlowTag, 'source');
+    await fs.mkdir(flowOutputDir, { recursive: true });
+
+    const slsYamlDir = path.join(outputBaseDir, 'app', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(slsYamlDir, { recursive: true });
+
+    const resourceYamlDir = path.join(outputBaseDir, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    const additionalResourcePermission = [];
+
+    const templates = {
+        processMain: await fs.readFile(path.join(templateDir, 'ProcessTriggerCache_Main.ejs'), 'utf-8'),
+        processHandler: await fs.readFile(path.join(templateDir, 'ProcessTriggerCache_HdrSqs.ejs'), 'utf-8'),
+        processYaml: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+
+        checkMain: await fs.readFile(path.join(templateDir, 'CheckTriggerCache_Main.ejs'), 'utf-8'),
+        checkHandler: await fs.readFile(path.join(templateDir, 'CheckTriggerCache_HdrSqs.ejs'), 'utf-8'),
+        checkYaml: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+
+        completeMain: await fs.readFile(path.join(templateDir, 'TriggerCacheComplete_Main.ejs'), 'utf-8'),
+        completeHandlerSqs: await fs.readFile(path.join(templateDir, 'TriggerCacheComplete_HdrSqs.ejs'), 'utf-8'),
+        completeHandlerDsq: await fs.readFile(path.join(templateDir, 'TriggerCacheComplete_HdrDsq.ejs'), 'utf-8'),
+        completeYamlSqs: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+        completeYamlDsq: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+
+        queueYaml: await fs.readFile(path.join(templateDir, 'TriggerCacheQueue_Yaml.ejs'), 'utf-8')
+    };
+
+    // Helper to render and write
+    async function renderAndWrite(tplContent, outPath, data) {
+        const content = ejs.render(tplContent, data);
+        await fs.writeFile(outPath, content, 'utf-8');
+    }
+
+    async function renderAndAppend(tplContent, outPath, data) {
+        const content = ejs.render(tplContent, data);
+        await fs.appendFile(outPath, '\n' + content, 'utf-8');
+    }
+
+    // 1. ProcessTriggerCache
+    {
+        const functionName = 'ProcessTriggerCache' + upperFlowTag;
+        const handlerType = 'HdrDsq';
+        const queueName = `${serviceTag}${upperFlowTag}_Main`;
+
+        const data = {
+            functionName, handlerType, queueName,
+            upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+            upperHandlerType: upperCase(handlerType), flowType: flowTag, flowTag: flowTag,
+            resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+            handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+            handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+            roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+            functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+            additionalResourcePermission
+        };
+
+        await renderAndWrite(templates.processMain, path.join(flowOutputDir, `${functionName}_Main.js`), data);
+        await renderAndWrite(templates.processHandler, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+        await renderAndAppend(templates.processYaml, path.join(slsYamlDir, 'flow-schema.yml'), data);
+    }
+
+    // 2. CheckTriggerCacheComplete
+    {
+        const functionName = 'CheckTriggerCache' + upperFlowTag + 'Complete';
+        const handlerType = 'HdrSqs';
+        const queueName = functionName + handlerType;
+
+        const data = {
+            functionName, handlerType, queueName,
+            upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+            upperHandlerType: upperCase(handlerType), flowType: flowTag, flowTag: flowTag,
+            resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+            handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+            handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+            roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+            functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+            additionalResourcePermission
+        };
+
+        await renderAndWrite(templates.checkMain, path.join(flowOutputDir, `${functionName}_Main.js`), data);
+        await renderAndWrite(templates.checkHandler, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+        await renderAndAppend(templates.checkYaml, path.join(slsYamlDir, 'flow-schema.yml'), data);
+    }
+
+    // 3. TriggerCacheComplete
+    {
+        const functionName = 'TriggerCache' + upperFlowTag + 'Complete';
+
+        // Main
+        await renderAndWrite(templates.completeMain, path.join(flowOutputDir, `${functionName}_Main.js`), {
+            functionName, flowType: flowTag, flowTag: flowTag, upperFunctionName: upperCase(functionName)
+        });
+
+        // SQS Variant
+        {
+            const handlerType = 'HdrSqs';
+            const queueName = functionName + handlerType;
+            const data = {
+                functionName, handlerType, queueName,
+                upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+                upperHandlerType: upperCase(handlerType), flowType: flowTag,
+                resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+                handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+                handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+                roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+                functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+                additionalResourcePermission
+            };
+            await renderAndWrite(templates.completeHandlerSqs, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+            await renderAndAppend(templates.completeYamlSqs, path.join(slsYamlDir, 'flow-schema.yml'), data);
+        }
+
+        // DSQ Variant
+        {
+            const handlerType = 'HdrDsq';
+            const queueName = functionName + handlerType;
+            const data = {
+                functionName, handlerType, queueName,
+                upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+                upperHandlerType: upperCase(handlerType), flowType: flowTag,
+                resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+                handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+                handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+                roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+                functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+                additionalResourcePermission
+            };
+            await renderAndWrite(templates.completeHandlerDsq, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+            await renderAndAppend(templates.completeYamlDsq, path.join(slsYamlDir, 'flow-schema.yml'), data);
+        }
+    }
+
+    // 4. TriggerCacheQueue
+    {
+        const queueNames = [
+            `${serviceTag}${upperFlowTag}_Main`,
+            'CheckTriggerCache' + upperFlowTag + 'CompleteHdrSqs',
+            'TriggerCache' + upperFlowTag + 'CompleteHdrSqs',
+            'TriggerCache' + upperFlowTag + 'CompleteHdrDsq'
+        ];
+
+        for (const queueName of queueNames) {
+            const resourceQueueName = queueName.includes("_") ? queueName.split("_").join("") : queueName;
+            await renderAndAppend(templates.queueYaml, path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), { queueName, resourceQueueName });
+        }
+    }
+
+    console.log(`  [TriggerCacheGenerator] Generated triggerCache files for flow: ${flowTag}`);
+}

package/src/{generators/fromFlowSchema/statusTypes/triggerCache/checkTriggerCacheComplete/mainFunction/template.ejs → codeGenerators/app/src/generatedCode/Flow/_shared/triggerCache/CheckTriggerCache_Main.ejs}

@@ -16,8 +16,6 @@ along with this program. If not, see
 <http: //www.gnu.org/licenses />.
 */
 
-
-
 import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
 import { triggeredCacheSharedLibV2 } from '@izara_project/izara-core-library-trigger-cache';
 

package/src/{generators/fromObjectSchema/relationship/create/action/sns-in-sqs/sqsTemplate.ejs → codeGenerators/app/src/generatedCode/Flow/_shared/triggerCache/TriggerCacheQueue_Yaml.ejs}

@@ -1,22 +1,22 @@
 #------- queue ---------
-  <%- queueName %>:
+  <%- resourceQueueName %>:
     Type: "AWS::SQS::Queue"
     Properties:
       QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>
       RedrivePolicy:
         deadLetterTargetArn: #!GetAtt
           Fn::GetAtt:
-            - <%- queueName %>DLQ
+            - <%- resourceQueueName %>DLQ
             - Arn
         maxReceiveCount: 3
       VisibilityTimeout: 120
 
-  <%- queueName %>DLQ:
+  <%- resourceQueueName %>DLQ:
     Type: AWS::SQS::Queue
     Properties:
       QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>DLQ
 
-  <%- queueName %>Policy:
+  <%- resourceQueueName %>Policy:
     Type: AWS::SQS::QueuePolicy
     Properties:
       PolicyDocument:
@@ -27,14 +27,10 @@
             Principal: "*"
             Resource: #!GetAtt
               Fn::GetAtt:
-                - <%- queueName %>
+                - <%- resourceQueueName %>
                 - Arn
             Action: "SQS:SendMessage"
       Queues:
-        - Ref: <%- queueName %>
+        - Ref: <%- resourceQueueName %>
   #<#<%- queueName %>QueueSetting#>
   #<#/<%- queueName %>QueueSetting#>
-
-<%_ function firstLetterLowerCase(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1)
-} _%>

package/src/{generators/fromFlowSchema/statusTypes/triggerCache/triggerCacheComplete/functionYaml/sqs/template.ejs → codeGenerators/app/src/generatedCode/Flow/_shared/yaml/SharedFunctionSqs_Yaml.ejs}

@@ -9,9 +9,5 @@
         arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>
         batchSize: 10
         filterPatterns: #**** need to update serverless framework upper v.2.69.1
-          - body: {"MessageAttributes":{"callingFlow":{"Value":["${self:custom.iz_resourcePrefix}<%- functionName %>"]}}} # functionName of callingFlow
+          - body: {"MessageAttributes":{"callingFlow":{"Value":["${self:custom.iz_resourcePrefix}<%- functionNameConfig %>"]}}} # functionName of callingFlow
           - body: {"MessageAttributes":{"callingFlow":{"Value":[{"exists":false}]}}}
-
-<%_ function firstLetterLowerCase(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1)
-} _%>

package/src/codeGenerators/app/src/generatedCode/ProcessLogical/ProcessLogicalGenerator.js

@@ -0,0 +1,29 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { writeRenderedTemplate } from '../../../../../core/renderTemplateFile.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateProcessLogical(options) {
+  console.log('  [ProcessLogicalGenerator] Generating ProcessLogical flows...');
+
+  const outputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode', 'ProcessLogical', 'source');
+  const templatesDir = path.join(__dirname, 'templates');
+  const files = await fs.readdir(templatesDir);
+
+  let count = 0;
+  for (const file of files) {
+    if (!file.endsWith('.ejs')) continue;
+
+    await writeRenderedTemplate(
+      path.join(templatesDir, file),
+      path.join(outputDir, file.replace(/\.ejs$/, '.js')),
+      {}
+    );
+    count++;
+  }
+
+  console.log(`  [ProcessLogicalGenerator] Wrote ${count} ProcessLogical files.`);
+}

package/src/{generators/fromObjectSchema/processLogicalPagination/handler/sqs/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/PaginateProcessLogical_HdrSqs.ejs}

@@ -152,4 +152,4 @@ export const main = middleware.wrap(async (event, context, callback) => {
     Logger.error('Unhandled Error, PaginateProcessLogicalHdrSqs: ', err);
     throw err;
   }
-});
+});

package/src/{generators/fromObjectSchema/processLogicalPagination/mainFunction/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/PaginateProcessLogical_Main.ejs}

@@ -73,15 +73,15 @@ export default async function paginateProcessLogical(
 
     // Check/Create logicalResultsMain
     let [checkUniqueRequestProcessingStatus, logicalResultsMain] =
-      await asyncFlowSharedLib.checkUniqueRequestProcessing(
-        _izContext,
-        'LogicalResultsMain',
-        {
-          logicalResultId: logicalResultId
-        },
-        'paginateProcessLogical',
-        overwriteUniqueRequestId
-      );
+    await asyncFlowSharedLib.checkUniqueRequestProcessing(
+      _izContext,
+      'LogicalResultsMain',
+      {
+        logicalResultId: logicalResultId
+      },
+      'paginateProcessLogical',
+      overwriteUniqueRequestId
+    );
     _izContext.logger.debug('After check uniqueRequestProcessingStatus:', {
       checkUniqueRequestProcessingStatus: checkUniqueRequestProcessingStatus,
       logicalResultsMain: logicalResultsMain
@@ -265,4 +265,4 @@ export default async function paginateProcessLogical(
     _izContext.logger.error('error PaginateProcessLogicalMain: ', err);
     throw err;
   }
-}
+}

package/src/{generators/fromObjectSchema/processLogical/handler/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/ProcessLogical_HdrSqs.ejs}

@@ -128,4 +128,4 @@ export const main = middleware.wrap(async (event, context, callback) => {
     Logger.error('Unhandled Error, ProcessLogicalHdrSqs: ', err);
     throw err;
   }
-});
+});

package/src/{generators/fromObjectSchema/processLogical/mainFunction/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/ProcessLogical_Main.ejs}

@@ -73,14 +73,14 @@ export default async function processLogical(
 
     // Check/Create logicalResultsMain
     let [logicalResultsMainStatus, logicalResultId, logicalResultMain] =
-      await logicalResultsSharedLib.checkLogicalMainStatus(
-        _izContext,
-        element, // for create logicalResultId
-        objType,
-        callingFlow,
-        removeAttributes,
-        overWriteCache
-      );
+    await logicalResultsSharedLib.checkLogicalMainStatus(
+      _izContext,
+      element, // for create logicalResultId
+      objType,
+      callingFlow,
+      removeAttributes,
+      overWriteCache
+    );
     _izContext.logger.debug('After check logicalMainStatus: ', {
       logicalResultsMainStatus: logicalResultsMainStatus,
       logicalResultId: logicalResultId,
@@ -170,8 +170,8 @@ export default async function processLogical(
     const storageResources = objectSchemas.storageResources;
 
     storageResourcesLoop: for (const storageResourceTag of Object.keys(
-      storageResources
-    )) {
+        storageResources
+      )) {
       _izContext.logger.debug('check storageResourceTag: ', storageResourceTag);
 
       if (
@@ -203,7 +203,7 @@ export default async function processLogical(
             let conditionalFieldName = conditionalFieldValue.fieldName;
             let storageResourceTagsFieldName =
               objectSchemas.fieldNames[conditionalFieldName]
-                .storageResourceTags;
+              .storageResourceTags;
 
             if (storageResourceTagsFieldName.includes(storageResourceTag)) {
               continue conditionalFieldValuesLoop;
@@ -250,16 +250,16 @@ export default async function processLogical(
     // concatenate partitionKey
     let partitionKeyReqIdentifiers = {};
     for (const [fieldName, fieldNameValue] of Object.entries(
-      element.partitionKeyValues
-    )) {
+        element.partitionKeyValues
+      )) {
       partitionKeyReqIdentifiers[fieldName] = fieldNameValue.value;
     }
 
     // concatenate sortKey
     if (element.hasOwnProperty('sortKeyValues')) {
       for (const [fieldName, fieldNameValue] of Object.entries(
-        element.sortKeyValues
-      )) {
+          element.sortKeyValues
+        )) {
         partitionKeyReqIdentifiers[fieldName] = fieldNameValue.value;
       }
     }
@@ -447,4 +447,4 @@ export default async function processLogical(
     _izContext.logger.error('error ProcessLogicalMain: ', err);
     throw err;
   }
-}
+}