@izara_project/izara-core-generate-service-code 1.0.39 → 1.0.40

package/src/generateCode/generateFlowStepWithPlugIn/index.js

@@ -17,13 +17,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import path from 'path'
 import yaml from 'yaml';
-import { consts as coreConsts } from '@izara_project/izara-core-library-service-schemas';
 import libs from '#libs/Libs.js';
-const { createSnsResource, createSqsResource, defaultIamRolePerAction, getLocalOrS3ObjectSchema, getLocalOrS3FlowSchema, resourceNames } = libs;
 import utils from '#libs/Utils.js';
 const { firstLetterUpperCase: upperCase, firstLetterLowerCase: lowerCase } = utils;
 import consts from '#libs/Consts.js';
-const { SOURCE_PATH, HANDLER, RESOURCE_CLASSES } = consts;
+const { SOURCE_PATH, HANDLER, RESOURCE_CLASSES, SNS_RESOURCE } = consts;
 
 import yamlFlowStep from './firstFlowStep/yaml/data.js';
 import handlerFlowStep from './firstFlowStep/handler/data.js';
@@ -35,6 +33,22 @@ import yamlRecievePlugIn from './afterFirstFlowStep/recievePlugIn/yaml/data.js';
 import handlerRecievePlugIn from './afterFirstFlowStep/recievePlugIn/handler/data.js';
 import mainFunctionRecievePlugIn from './afterFirstFlowStep/recievePlugIn/mainFunction/data.js';
 
+import handlerFlowConfig from './byConfig/handler/data.js';
+import mainFunctionFlowConfig from './byConfig/mainFunction/data.js';
+import sqsFlowConfig from './byConfig/sns-sqs/data.js';
+import yamlFlowConfig from './byConfig/yaml/data.js';
+
+const {
+  createSnsResource,
+  createSqsResource,
+  defaultIamRolePerAction,
+  getLocalOrS3ObjectSchema,
+  resourceNames,
+  awaitingMultipleStepsRole,
+  createIamRole,
+  externalResourceYaml
+} = libs;
+
 // import yamlSendPlugIn from './afterFirstFlowStep/sendPlugIn/yaml/data.js';
 // import handlerSendPlugIn from './afterFirstFlowStep/sendPlugIn/handler/data.js';
 // import mainFunctionSendPlugIn from './afterFirstFlowStep/sendPlugIn/mainFunction/data.js';
@@ -74,167 +88,111 @@ async function generatePlunIg(
 
     for (const flowSchema of allLocalFlowSchemas) {
       for (const [flowStepName, flowStepConfig] of Object.entries(flowSchema.flowSteps)) {
-        if (flowStepName === "In" || flowStepName === "Out") {
-          continue;
-        } else {
-          const flowTag = flowSchema.flowTag;
-          const roleName = upperCase(flowTag);
-          const resourceApis = [];
-          let handler;
-          const additionalResourcePermission = defaultIamRolePerAction();
-
-          const data = {
-            additionalResourcePermission: additionalResourcePermission,
-            flowStepName: flowStepName,
-            flowTag: flowTag,
-            resourceApis: resourceApis,
-            hookTagSetting: `${flowSchema.flowTag}FunctionSetting`,
-            functionName: upperCase(flowSchema.flowTag) + upperCase(flowStepName),
-            roleName: roleName,
-          };
+        if (flowStepName === "In" || flowStepName === "Out") continue;
 
-          if (flowStepConfig.event.includes("ownTopic")) {
-            data['eventFlow'] = 'ownTopic'
-            handler = HANDLER.hdrSqs;
-            additionalResourcePermission.push(
-              createSnsResource(
-                [
-                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + "_In"
-                ]
-              ),
-              createSqsResource(
-                [
-                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler),
-                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler) + "DSQ"
-                ]
-              )
-            );
-          } else if (flowStepConfig.event.includes("extTopic")) {
-            data['eventFlow'] = 'extTopic'
-            handler = HANDLER.hdrSqs;
-            additionalResourcePermission.push(
-              createSqsResource(
-                [
-                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler),
-                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler) + "DSQ"
-                ]
-              )
-            );
-          } else if (flowStepConfig.event.includes("lambdaSyncInv")) {
-            handler = HANDLER.hdrInv;
-          } else if (flowStepConfig.event.includes("lambdaSyncApi")) {
-            handler = HANDLER.hdrApi;
-            resourceApis.push({
-              path: `${serviceTag}/${lowerCase(flowTag)}${lowerCase(flowStepName)}`,
-              pathWithUser: `${serviceTag}/${lowerCase(flowTag)}${lowerCase(flowStepName)}/{targetUserId}`,
-              method: 'post',
-              hookTagApp: `${upperCase(flowStepName)}${upperCase(handler)}AppLevelAuthorizer`,
-              hookTagUser: `${upperCase(flowStepName)}${upperCase(handler)}UserLevelAuthorizer`
-            })
-          } else if (flowStepConfig.event.includes("queue")) {
-            handler = HANDLER.hdrDsq;
-            additionalResourcePermission.push(
-              createSqsResource(
-                [
-                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler),
-                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler) + "DSQ"
-                ]
-              )
-            );
-          };
+        const flowTag = flowSchema.flowTag;
+        const roleName = upperCase(flowTag);
+        const resourceApis = [];
+        const additionalResourcePermission = defaultIamRolePerAction();
 
-          Object.assign(data, {
-            handlerType: handler,
-            handlerPath: path.join(
-              SOURCE_PATH.resourceLocationFlowSchema,
-              upperCase(flowSchema.flowTag),
-              upperCase(flowStepName),
-              'source/',
-              `${upperCase(flowTag)}${upperCase(flowStepName)}_${upperCase(handler)}`,
-            ),
-            functionNameConfig: upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler),
-            event: resourceNames(RESOURCE_CLASSES.sqs, upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler)),
-            queueName: upperCase(flowSchema.flowTag) + upperCase(flowStepName),
-          })
-
-          const yamlFlowStepRes = await yamlFlowStep(_izContext, data, appPath);
-          const handlerResult = await handlerFlowStep(_izContext, data, appPath);
-          allCreateSourceParams.push(yamlFlowStepRes, handlerResult);
-
-          if (handler === HANDLER.hdrSqs || handler === HANDLER.hdrDsq) {
-            const sqsResult = await sqsFlowStep(_izContext, data, appPath);
-            allCreateSourceParams.push(sqsResult);
-          }
+        const data = {
+          additionalResourcePermission,
+          flowStepName,
+          flowTag,
+          resourceApis,
+          hookTagSetting: `${flowSchema.flowTag}FunctionSetting`,
+          functionName: upperCase(flowSchema.flowTag) + upperCase(flowStepName),
+          roleName,
+        };
 
-          const snsOutResult = await snsOut(_izContext, data, appPath);
-          allCreateSourceParams.push(snsOutResult);
+        resolveHandlerConfig(
+          data,
+          flowStepConfig,
+          additionalResourcePermission,
+          resourceApis,
+          serviceTag);
+
+        Object.assign(data, {
+          handlerType: data.handlerType,
+          handlerPath: path.join(
+            SOURCE_PATH.resourceLocationFlowSchema,
+            upperCase(flowSchema.flowTag),
+            upperCase(flowStepName),
+            'source/',
+            `${upperCase(flowTag)}${upperCase(flowStepName)}_${upperCase(data.handlerType)}`,
+          ),
+          functionNameConfig: upperCase(flowSchema.flowTag) +
+            upperCase(flowStepName) +
+            upperCase(data.handlerType),
+          event: resourceNames(
+            RESOURCE_CLASSES.sqs,
+            upperCase(flowSchema.flowTag) +
+            upperCase(flowStepName) +
+            upperCase(data.handlerType)),
+          queueName: upperCase(flowSchema.flowTag) + upperCase(flowStepName),
+        });
 
-          let mainResult;
-          if (flowStepConfig.hasOwnProperty("handleLogic")) {
-            
-          }
-          if (flowStepConfig.hasOwnProperty("plugInHooks")) {
-            // for (const plugInHookFlow of flowStepConfig.plugInHooks) {
-            for (let i = 0; i < flowStepConfig.plugInHooks.length; i++) {
-              if (i === 0) { // create main function for first flowStep
-                const [objSchema] = await getLocalOrS3ObjectSchema(_izContext, flowStepConfig.plugInHooks[i].objType, path.join(appPath, './src/schemas'));
-                let targetPlugIn = null;
-                if (objSchema.hasOwnProperty('plugIns')) {
-                  for (const plugInConfig of Object.values(objSchema.plugIns)) {
-                    targetPlugIn = plugInConfig.plugInHooks.find(h => h.plugInHookTagType.plugInHookTag === flowStepConfig.plugInHooks[i].plugInHookTag);
-                    if (targetPlugIn) {
-                      break;
-                    }
-                  };
-
-                  if (targetPlugIn) {
-                    let targetUrl = targetPlugIn.plugInHookTagType.targetUrl;
-                    if (targetPlugIn.invocationType === 'sync') {
-                      targetUrl += '/recievePlugInRequestSync'
-                    }
-                    mainResult = await mainFunctionFlowStep(
-                      _izContext,
-                      {
-                        ...data,
-                        invokeType: targetPlugIn.invocationType, // Ensure this matches "sync" or "async"
-                        havePlugIn: true,
-                        targetUrl: targetUrl
-                      },
-                      appPath
-                    );
-                  } else {
-                    mainResult = await mainFunctionFlowStep(_izContext, { ...data, havePlugIn: false }, appPath);
-                  }
-                  allCreateSourceParams.push(mainResult);
-                };
-              }
-            }
-          } else {
-            mainResult = await mainFunctionFlowStep(_izContext, { ...data, havePlugIn: false }, appPath);
-            allCreateSourceParams.push(mainResult);
-          };
 
-          for (const objSchema of allObjSchemas) {
-            if (!objSchema.hasOwnProperty("recievePlugInHookTag"))
-              continue;
-            for (const recieveConfig of Object.values(objSchema.recievePlugInHookTag)) {
-              if (recieveConfig.hasOwnProperty('flowType')) {
-                data['recieveType'] = "async",
-                  data['flowType'] = recieveConfig.flowType
-              } else {
-                data['recieveType'] = 'sync'
-              }
-              const yamlRecievePlugInResult = await yamlRecievePlugIn(_izContext, data, appPath);
-              const handlerRecievePlugInResult = await handlerRecievePlugIn(_izContext, data, appPath);
-              const mainFunctionRecievePlugInResult = await mainFunctionRecievePlugIn(_izContext, data, appPath);
-              // console.log("mainFunctionRecievePlugInResult", mainFunctionRecievePlugInResult)
-              allCreateSourceParams.push(...yamlRecievePlugInResult, ...handlerRecievePlugInResult, mainFunctionRecievePlugInResult);
+        // ── branch into the three helpers ──────────────────────────────────
+        if (flowStepConfig.plugInHooks?.length) {
+          for (let i = 0; i < flowStepConfig.plugInHooks.length; i++) {
+            if (i === 0) {
+              if (flowStepConfig.hasOwnProperty("settings")) {
+                data["handleLogic"] = flowStepConfig.settings.handleLogic;
+                data["childFlow"] = flowStepConfig.settings.flowType;
+              };
+              const firstResults = await buildFirstPluginHookResources(
+                _izContext,
+                data,
+                flowStepConfig,
+                appPath
+              );
+              allCreateSourceParams.push(...firstResults);
             }
+
+            const afterResults = await buildRecievePluginHookResource(
+              _izContext,
+              data,
+              appPath,
+              allObjSchemas
+            );
+            allCreateSourceParams.push(...afterResults);
           }
+        } else {
+          if (flowStepConfig.hasOwnProperty("settings")) {
+            data["handleLogic"] = flowStepConfig.settings.handleLogic;
+            data["childFlow"] = flowStepConfig.settings.flowType;
+          };
+
+          const noHookResults = await buildNoPluginHookResources(
+            _izContext,
+            data,
+            appPath
+          );
+          allCreateSourceParams.push(...noHookResults);
         }
-      }
-    };
 
+        if (flowStepConfig.hasOwnProperty("settings")) {
+          data["handleLogic"] = flowStepConfig.settings.handleLogic;
+          data["childFlow"] = flowStepConfig.settings.flowType;
+          data.event = resourceNames(
+            RESOURCE_CLASSES.sqs,
+            upperCase(flowSchema.flowTag) +
+            upperCase(flowStepName) +
+            upperCase(data.handleLogic) +
+            upperCase(data.handlerType)
+          )
+          const generateLambdaFlowStepByConfig = buildFlowStepResourceByConfig(
+            _izContext,
+            data,
+            appPath
+          );
+          allCreateSourceParams.push(...generateLambdaFlowStepByConfig);
+
+        }
+
+      }
+    }
 
 
     const uniqueSortedTargetFiles = Array.from(
@@ -264,3 +222,301 @@ async function generatePlunIg(
 }
 
 export default generatePlunIg;
+
+
+async function buildNoPluginHookResources(_izContext, data, appPath) {
+  const results = [];
+
+
+  const yamlRes = await yamlFlowStep(
+    _izContext,
+    data,
+    appPath);
+  const handlerRes = await handlerFlowStep(
+    _izContext,
+    data,
+    appPath);
+
+  if (data.handlerType === HANDLER.hdrSqs || data.handlerType === HANDLER.hdrDsq) {
+    const sqsRes = await sqsFlowStep(
+      _izContext,
+      data,
+      appPath);
+    results.push(sqsRes);
+  }
+
+  // const snsOutRes = await snsOut(
+  //   _izContext,
+  //   data,
+  //   appPath
+  // );
+
+  const mainRes = await mainFunctionFlowStep(
+    _izContext,
+    { ...data, havePlugIn: false }, appPath);
+
+  results.push(mainRes,
+    // snsOutRes,
+    yamlRes,
+    handlerRes);
+
+  return results;
+}
+
+async function buildFirstPluginHookResources(_izContext, data, flowStepConfig, appPath) {
+  const results = [];
+
+  const yamlRes = await yamlFlowStep(
+    _izContext,
+    data,
+    appPath);
+
+  const handlerRes = await handlerFlowStep(
+    _izContext,
+    data,
+    appPath);
+
+  results.push(yamlRes, handlerRes);
+
+  if (data.handlerType === HANDLER.hdrSqs ||
+    data.handlerType === HANDLER.hdrDsq) {
+    const sqsRes = await sqsFlowStep(
+      _izContext,
+      data,
+      appPath);
+    results.push(sqsRes);
+  }
+
+  const snsOutRes = await snsOut(
+    _izContext,
+    data,
+    appPath);
+  results.push(snsOutRes);
+
+  // Original: only the first plugInHook (index 0) creates the main function
+  const firstHook = flowStepConfig.plugInHooks[0];
+  const [objSchema] = await getLocalOrS3ObjectSchema(
+    _izContext,
+    firstHook.objType,
+    path.join(appPath, './src/schemas')
+  );
+
+  let mainData = { ...data, havePlugIn: false };
+
+  if (objSchema.hasOwnProperty('plugIns')) {
+    let targetPlugIn = null;
+    for (const plugInConfig of Object.values(objSchema.plugIns)) {
+      targetPlugIn = plugInConfig.plugInHooks.find(
+        h => h.plugInHookTagType.plugInHookTag === firstHook.plugInHookTag
+      );
+      if (targetPlugIn) break;
+    }
+
+    if (targetPlugIn) {
+      let targetUrl = targetPlugIn.plugInHookTagType.targetUrl;
+      if (targetPlugIn.invocationType === 'sync') {
+        targetUrl += '/recievePlugInRequestSync';
+      }
+      mainData = {
+        ...data,
+        havePlugIn: true,
+        invokeType: targetPlugIn.invocationType,
+        targetUrl,
+      };
+    }
+  }
+
+  const mainRes = await mainFunctionFlowStep(
+    _izContext,
+    mainData,
+    appPath);
+
+  results.push(mainRes);
+
+  return results;
+}
+
+async function buildRecievePluginHookResource(_izContext, data, appPath, allObjSchemas) {
+  const results = [];
+
+  for (const objSchema of allObjSchemas) {
+    if (!objSchema.hasOwnProperty("recievePlugInHookTag")) continue;
+
+    for (const recieveConfig of Object.values(objSchema.recievePlugInHookTag)) {
+      const localData = { ...data };
+
+      if (recieveConfig.hasOwnProperty('flowType')) {
+        localData.recieveType = "async";
+        localData.flowType = recieveConfig.flowType;
+      } else {
+        localData.recieveType = 'sync';
+      }
+
+      const yamlRecieveRes = await yamlRecievePlugIn(
+        _izContext,
+        localData,
+        appPath);
+      const handlerRecieveRes = await handlerRecievePlugIn(
+        _izContext,
+        localData,
+        appPath);
+      const mainRecieveRes = await mainFunctionRecievePlugIn(
+        _izContext,
+        localData,
+        appPath);
+
+      results.push(
+        ...yamlRecieveRes,
+        ...handlerRecieveRes,
+        mainRecieveRes
+      );
+    }
+  }
+
+  return results;
+}
+
+// Extracted from the original if/else chain — mutates data, additionalResourcePermission, resourceApis in place
+function resolveHandlerConfig(data, flowStepConfig, additionalResourcePermission, resourceApis, serviceTag) {
+  const { flowTag, flowStepName } = data;
+  let handler;
+
+  if (flowStepConfig.event.includes("ownTopic")) {
+    data.eventFlow = 'ownTopic';
+    handler = HANDLER.hdrSqs;
+    additionalResourcePermission.push(
+      createSnsResource([upperCase(flowTag) +
+        upperCase(flowStepName) + "_In"]),
+      createSqsResource([
+        upperCase(flowTag) +
+        upperCase(flowStepName) +
+        upperCase(handler),
+        upperCase(flowTag) +
+        upperCase(flowStepName) +
+        upperCase(handler) + "DLQ",
+      ])
+    );
+  } else if (flowStepConfig.event.includes("extTopic")) {
+    data.eventFlow = 'extTopic';
+    handler = HANDLER.hdrSqs;
+    additionalResourcePermission.push(
+      createSqsResource([
+        upperCase(flowTag) +
+        upperCase(flowStepName) +
+        upperCase(handler),
+        upperCase(flowTag) +
+        upperCase(flowStepName) +
+        upperCase(handler) + "DLQ",
+      ])
+    );
+  } else if (flowStepConfig.event.includes("lambdaSyncInv")) {
+    handler = HANDLER.hdrInv;
+  } else if (flowStepConfig.event.includes("lambdaSyncApi")) {
+    handler = HANDLER.hdrApi;
+    resourceApis.push({
+      path: `${serviceTag}/${lowerCase(flowTag)}${lowerCase(flowStepName)}`,
+      pathWithUser: `${serviceTag}/${lowerCase(flowTag)}${lowerCase(flowStepName)}/{targetUserId}`,
+      method: 'post',
+      hookTagApp: `${upperCase(flowStepName)}${upperCase(handler)}AppLevelAuthorizer`,
+      hookTagUser: `${upperCase(flowStepName)}${upperCase(handler)}UserLevelAuthorizer`,
+    });
+  } else if (flowStepConfig.event.includes("queue")) {
+    handler = HANDLER.hdrDsq;
+    additionalResourcePermission.push(
+      createSqsResource([
+        upperCase(flowTag) +
+        upperCase(flowStepName) +
+        upperCase(handler),
+        upperCase(flowTag) +
+        upperCase(flowStepName) +
+        upperCase(handler) +
+        "DSQ",
+      ])
+    );
+  }
+
+  if (flowStepConfig.hasOwnProperty("settings")) {
+    if (flowStepConfig.settings.hasOwnProperty("handleLogic")) {
+      const handleLogic = flowStepConfig.settings.handleLogic;
+      const childFlow = flowStepConfig.settings.flowType;
+      if (handleLogic === 'awaitingMultipleSteps') {
+        handler = HANDLER.hdrSqs;
+        additionalResourcePermission.push(awaitingMultipleStepsRole())
+        additionalResourcePermission.push(createIamRole({
+          [RESOURCE_CLASSES.sns]: Object.values(SNS_RESOURCE)
+        },
+          [
+            externalResourceYaml(
+              RESOURCE_CLASSES.sns,
+              `${childFlow.flowTag}_In`,
+              childFlow.serviceTag)
+          ]
+        ))
+      } else if (handleLogic === 'paginated') {
+        handler = HANDLER.hdrSqs;
+        additionalResourcePermission.push(createSqsResource(
+          [
+            upperCase(flowTag) +
+            upperCase(flowStepName) +
+            upperCase(HANDLER.hdrDsq),
+            upperCase(flowTag) +
+            upperCase(flowStepName) +
+            upperCase(HANDLER.hdrDsq) + "DLQ"
+          ]))
+      }
+    }
+  }
+  data.handlerType = handler;
+}
+
+function buildFlowStepResourceByConfig(_izContext, data, appPath) {
+  const results = [];
+
+  if (data.handleLogic === 'awaitingMultipleSteps') {
+    data.handlerType = HANDLER.hdrSqs
+  } else if (data.handleLogic === 'paginated') {
+    data.handlerType = HANDLER.hdrDsq
+  }
+
+  data["functionName"] = upperCase(data.flowTag) +
+    upperCase(data.flowStepName) +
+    upperCase(data.handleLogic)
+
+  data["functionNameConfig"] = upperCase(data.flowTag) +
+    upperCase(data.flowStepName) +
+    upperCase(data.handleLogic) +
+    upperCase(data.handlerType)
+
+  const handler = handlerFlowConfig(
+    _izContext,
+    data,
+    appPath
+  );
+
+  const mainFunction = mainFunctionFlowConfig(
+    _izContext,
+    data,
+    appPath
+  );
+
+  const sqs = sqsFlowConfig(
+    _izContext,
+    data,
+    appPath
+  );
+
+  const yaml = yamlFlowConfig(
+    _izContext,
+    data,
+    appPath
+  );
+
+  results.push(
+    handler,
+    mainFunction,
+    sqs,
+    yaml
+  );
+
+  return results;
+}

package/src/generateCode/generateInitialSetup/externalServiceComponent/lambdaRole/data.js

@@ -212,6 +212,28 @@ async function createExternalLambdaRole(
           });
         }
       }
+
+      for (const flowStepConfig of Object.values(localFlowSchema.flowSteps)) {
+        if (flowStepConfig.hasOwnProperty("settings")) {
+          if (flowStepConfig.settings.hasOwnProperty('flowType')) {
+            roleArray.push({
+              objectType: localFlowSchema.flowTag,
+              additionalResourcePermission: [
+                role(
+                  sns,
+                  SNS_RESOURCE.publish,
+                  [
+                    extRes(
+                      sns,
+                      `${flowStepConfig.settings.flowType.flowTag}_In`,
+                      flowStepConfig.settings.flowType.serviceTag)
+                  ]
+                )
+              ]
+            });
+          }
+        }
+      }
     }
   }
 

package/src/generateCode/generateInitialSetup/externalServiceComponent/snsTopicSubscriptions/data.js

@@ -122,6 +122,22 @@ async function createExternalSnsSubscriptions(
         }
       );
     }
+
+    for (const localFlowSchema of allLocalFlowSchemas) {
+      for (const [flowStepName, flowStepConfig] of Object.entries(localFlowSchema.flowSteps)) {
+        if (flowStepConfig.hasOwnProperty('settings') && flowStepConfig.settings.hasOwnProperty('flowType')) {
+          if (flowStepConfig.settings.flowType) {
+            snsServiceConfigArray.push({
+              serviceTag: [flowStepConfig.settings.flowType.serviceTag],
+              topicName: `${flowStepConfig.settings.flowType.flowTag}_Out`,
+              sqsEndpoint: upperCase(localFlowSchema.flowTag) +
+                upperCase(flowStepName) +
+                upperCase(flowStepConfig.settings.handleLogic)
+            })
+          }
+        }
+      }
+    }
   }
 
   return {