@izara_project/izara-core-generate-service-code 1.0.47 → 1.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.47",
+  "version": "1.0.48",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {

package/src/generators/fromPlugIn/index.js

@@ -20,7 +20,8 @@ import fs from 'fs';
 import yaml from 'yaml';
 import libs from '#libs/Libs.js';
 import utils from '#libs/Utils.js';
-const { firstLetterUpperCase: upperCase, firstLetterLowerCase: lowerCase } = utils;
+const { firstLetterUpperCase: upperCase, firstLetterLowerCase: lowerCase } =
+  utils;
 import consts from '#libs/Consts.js';
 const { SOURCE_PATH, HANDLER, RESOURCE_CLASSES, SNS_RESOURCE } = consts;
 
@@ -54,7 +55,6 @@ const {
 // import handlerSendPlugIn from './afterFirstFlowStep/sendPlugIn/handler/handler.js';
 // import mainFunctionSendPlugIn from './afterFirstFlowStep/sendPlugIn/mainFunction/main.js';
 
-
 /**
  * Generates code from templates based on object schemas
  * @param {Object} _izContext
@@ -69,7 +69,7 @@ async function generatePlunIg(
   rootServicePath,
   appPath,
   allObjSchemas,
-  allLocalFlowSchemas,
+  allLocalFlowSchemas
 ) {
   const allCreateSourceParams = [];
 
@@ -79,18 +79,22 @@ async function generatePlunIg(
       ? allObjSchemas.length
       : 0;
 
-
     console.info(`[plugIn] start totalSchemas=${totalSchemas}`);
     if (totalSchemas === 0) return [];
 
-    const configPath = path.join(rootServicePath, 'config/serverless.config.yml');
+    const configPath = path.join(
+      rootServicePath,
+      'config/serverless.config.yml'
+    );
     const serverlessConfig = fs.readFileSync(configPath, 'utf8');
     const config = yaml.parse(serverlessConfig);
     const serviceTag = config.main_config.iz_serviceTag;
 
     for (const flowSchema of allLocalFlowSchemas) {
-      for (const [flowStepName, flowStepConfig] of Object.entries(flowSchema.flowSteps)) {
-        if (flowStepName === "In" || flowStepName === "Out") continue;
+      for (const [flowStepName, flowStepConfig] of Object.entries(
+        flowSchema.flowSteps
+      )) {
+        if (flowStepName === 'In' || flowStepName === 'Out') continue;
 
         const flowTag = flowSchema.flowTag;
         const roleName = upperCase(flowTag);
@@ -104,7 +108,7 @@ async function generatePlunIg(
           resourceApis,
           hookTagSetting: `${flowSchema.flowTag}FunctionSetting`,
           functionName: upperCase(flowSchema.flowTag) + upperCase(flowStepName),
-          roleName,
+          roleName
         };
 
         resolveHandlerConfig(
@@ -123,21 +127,25 @@ async function generatePlunIg(
             upperCase(flowSchema.flowTag),
             upperCase(flowStepName),
             'source/',
-            `${upperCase(flowTag)}${upperCase(flowStepName)}_${upperCase(data.handlerType)}`,
+            `${upperCase(flowTag)}${upperCase(flowStepName)}_${upperCase(data.handlerType)}`
           ),
-          functionNameConfig: upperCase(flowSchema.flowTag) +
+          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) +
-            upperCase(data.handlerType)),
-          queueName: upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(data.handlerType),
+            upperCase(data.handlerType),
           topicName: upperCase(flowSchema.flowTag) + upperCase(flowStepName)
         });
 
-
         // ── branch into the three helpers ──────────────────────────────────
         if (flowStepConfig.plugInHooks?.length) {
           for (let i = 0; i < flowStepConfig.plugInHooks.length; i++) {
@@ -169,29 +177,26 @@ async function generatePlunIg(
           allCreateSourceParams.push(...noHookResults);
         }
 
-        if (flowStepConfig.hasOwnProperty("settings")) {
-          data["handleLogic"] = flowStepConfig.settings.handleLogic;
-          data["childFlow"] = flowStepConfig.settings.flowType;
+        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)
-          )
+              upperCase(flowStepName) +
+              upperCase(data.handleLogic) +
+              upperCase(data.handlerType)
+          );
           const generateLambdaFlowStepByConfig = buildFlowStepResourceByConfig(
             _izContext,
             data,
             appPath
           );
           allCreateSourceParams.push(...generateLambdaFlowStepByConfig);
-
         }
-
       }
     }
 
-
     const uniqueSortedTargetFiles = Array.from(
       new Set(
         allCreateSourceParams
@@ -220,24 +225,22 @@ async function generatePlunIg(
 
 export default generatePlunIg;
 
-
-async function buildNoPluginHookResources(_izContext, data, flowStepConfig, appPath) {
+async function buildNoPluginHookResources(
+  _izContext,
+  data,
+  flowStepConfig,
+  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);
+  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);
   }
 
@@ -257,51 +260,52 @@ async function buildNoPluginHookResources(_izContext, data, flowStepConfig, appP
     appPath
   );
 
-  results.push(mainRes,
+  results.push(
+    mainRes,
     // snsOutRes,
     yamlRes,
-    handlerRes);
+    handlerRes
+  );
 
   return results;
 }
 
-async function buildFirstPluginHookResources(_izContext, data, flowStepConfig, appPath) {
+async function buildFirstPluginHookResources(
+  _izContext,
+  data,
+  flowStepConfig,
+  appPath
+) {
   const results = [];
 
-  const yamlRes = await yamlFlowStep(
-    _izContext,
-    data,
-    appPath);
+  const yamlRes = await yamlFlowStep(_izContext, data, appPath);
 
-  const handlerRes = await handlerFlowStep(
-    _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);
+  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 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(
+  const [objSchema, error] = await getLocalOrS3ObjectSchema(
     _izContext,
     firstHook.objType,
     path.join(appPath, './src/schemas')
   );
+  if (error) {
+    console.error('[plugIn] error:', error);
+    throw new NoRetryError(error);
+  }
 
   let mainData = { ...data, havePlugIn: false };
 
@@ -329,27 +333,29 @@ async function buildFirstPluginHookResources(_izContext, data, flowStepConfig, a
     }
   }
 
-  const mainRes = await mainFunctionFlowStep(
-    _izContext,
-    mainData,
-    appPath);
+  const mainRes = await mainFunctionFlowStep(_izContext, mainData, appPath);
 
   results.push(mainRes);
 
   return results;
 }
 
-async function buildRecievePluginHookResource(_izContext, data, appPath, allObjSchemas) {
+async function buildRecievePluginHookResource(
+  _izContext,
+  data,
+  appPath,
+  allObjSchemas
+) {
   const results = [];
 
   for (const objSchema of allObjSchemas) {
-    if (!objSchema.hasOwnProperty("recievePlugInHookTag")) continue;
+    if (!objSchema.hasOwnProperty('recievePlugInHookTag')) continue;
 
     for (const recieveConfig of Object.values(objSchema.recievePlugInHookTag)) {
       const localData = { ...data };
 
       if (recieveConfig.hasOwnProperty('flowType')) {
-        localData.recieveType = "async";
+        localData.recieveType = 'async';
         localData.flowType = recieveConfig.flowType;
       } else {
         localData.recieveType = 'sync';
@@ -358,21 +364,20 @@ async function buildRecievePluginHookResource(_izContext, data, appPath, allObjS
       const yamlRecieveRes = await yamlRecievePlugIn(
         _izContext,
         localData,
-        appPath);
+        appPath
+      );
       const handlerRecieveRes = await handlerRecievePlugIn(
         _izContext,
         localData,
-        appPath);
+        appPath
+      );
       const mainRecieveRes = await mainFunctionRecievePlugIn(
         _izContext,
         localData,
-        appPath);
-
-      results.push(
-        ...yamlRecieveRes,
-        ...handlerRecieveRes,
-        mainRecieveRes
+        appPath
       );
+
+      results.push(...yamlRecieveRes, ...handlerRecieveRes, mainRecieveRes);
     }
   }
 
@@ -380,95 +385,100 @@ async function buildRecievePluginHookResource(_izContext, data, appPath, allObjS
 }
 
 // Extracted from the original if/else chain — mutates data, additionalResourcePermission, resourceApis in place
-function resolveHandlerConfig(data, flowStepConfig, additionalResourcePermission, resourceApis, serviceTag, fallbackEvent = []) {
+function resolveHandlerConfig(
+  data,
+  flowStepConfig,
+  additionalResourcePermission,
+  resourceApis,
+  serviceTag,
+  fallbackEvent = []
+) {
   const { flowTag, flowStepName } = data;
   let handler;
   const events = flowStepConfig.event || fallbackEvent || [];
 
-  if (events.includes("ownTopic")) {
+  if (events.includes('ownTopic')) {
     data.eventFlow = 'ownTopic';
     handler = HANDLER.hdrSqs;
     additionalResourcePermission.push(
-      createSnsResource([upperCase(flowTag) +
-        upperCase(flowStepName) + "_In"]),
+      createSnsResource([upperCase(flowTag) + upperCase(flowStepName) + '_In']),
       createSqsResource([
+        upperCase(flowTag) + upperCase(flowStepName) + upperCase(handler),
         upperCase(flowTag) +
-        upperCase(flowStepName) +
-        upperCase(handler),
-        upperCase(flowTag) +
-        upperCase(flowStepName) +
-        upperCase(handler) + "DLQ",
+          upperCase(flowStepName) +
+          upperCase(handler) +
+          'DLQ'
       ])
     );
-  } else if (events.includes("extTopic")) {
+  } else if (events.includes('extTopic')) {
     data.eventFlow = 'extTopic';
     handler = HANDLER.hdrSqs;
     additionalResourcePermission.push(
       createSqsResource([
+        upperCase(flowTag) + upperCase(flowStepName) + upperCase(handler),
         upperCase(flowTag) +
-        upperCase(flowStepName) +
-        upperCase(handler),
-        upperCase(flowTag) +
-        upperCase(flowStepName) +
-        upperCase(handler) + "DLQ",
+          upperCase(flowStepName) +
+          upperCase(handler) +
+          'DLQ'
       ])
     );
-  } else if (events.includes("lambdaSyncInv")) {
+  } else if (events.includes('lambdaSyncInv')) {
     handler = HANDLER.hdrInv;
-  } else if (events.includes("lambdaSyncApi")) {
+  } else if (events.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`,
+      hookTagUser: `${upperCase(flowStepName)}${upperCase(handler)}UserLevelAuthorizer`
     });
-  } else if (events.includes("queue")) {
+  } else if (events.includes('queue')) {
     handler = HANDLER.hdrDsq;
     additionalResourcePermission.push(
       createSqsResource([
+        upperCase(flowTag) + upperCase(flowStepName) + upperCase(handler),
         upperCase(flowTag) +
-        upperCase(flowStepName) +
-        upperCase(handler),
-        upperCase(flowTag) +
-        upperCase(flowStepName) +
-        upperCase(handler) +
-        "DSQ",
+          upperCase(flowStepName) +
+          upperCase(handler) +
+          'DSQ'
       ])
     );
   }
 
-  if (flowStepConfig.hasOwnProperty("settings")) {
-    if (flowStepConfig.settings.hasOwnProperty("handleLogic")) {
+  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(createSqsResource(
-          [
+        additionalResourcePermission.push(awaitingMultipleStepsRole());
+        additionalResourcePermission.push(
+          createSqsResource([
             upperCase(flowTag) +
-            upperCase(flowStepName) +
-            upperCase(flowStepConfig.settings.handleLogic) +
-            upperCase(HANDLER.hdrSqs),
+              upperCase(flowStepName) +
+              upperCase(flowStepConfig.settings.handleLogic) +
+              upperCase(HANDLER.hdrSqs),
             upperCase(flowTag) +
-            upperCase(flowStepName) +
-            upperCase(flowStepConfig.settings.handleLogic) +
-            upperCase(HANDLER.hdrSqs) + "DLQ"
-          ]
-        ))
+              upperCase(flowStepName) +
+              upperCase(flowStepConfig.settings.handleLogic) +
+              upperCase(HANDLER.hdrSqs) +
+              'DLQ'
+          ])
+        );
       } else if (handleLogic === 'paginated') {
         handler = HANDLER.hdrSqs;
-        additionalResourcePermission.push(createSqsResource(
-          [
+        additionalResourcePermission.push(
+          createSqsResource([
             upperCase(flowTag) +
-            upperCase(flowStepName) +
-            upperCase(HANDLER.hdrDsq),
+              upperCase(flowStepName) +
+              upperCase(HANDLER.hdrDsq),
             upperCase(flowTag) +
-            upperCase(flowStepName) +
-            upperCase(HANDLER.hdrDsq) + "DLQ"
-          ]))
+              upperCase(flowStepName) +
+              upperCase(HANDLER.hdrDsq) +
+              'DLQ'
+          ])
+        );
       }
     }
   }
@@ -479,50 +489,31 @@ function buildFlowStepResourceByConfig(_izContext, data, appPath) {
   const results = [];
 
   if (data.handleLogic === 'awaitingMultipleSteps') {
-    data.handlerType = HANDLER.hdrSqs
+    data.handlerType = HANDLER.hdrSqs;
   } else if (data.handleLogic === 'paginated') {
-    data.handlerType = HANDLER.hdrDsq
+    data.handlerType = HANDLER.hdrDsq;
   }
 
-  data["functionName"] = upperCase(data.flowTag) +
+  data['functionName'] =
+    upperCase(data.flowTag) +
     upperCase(data.flowStepName) +
-    upperCase(data.handleLogic)
+    upperCase(data.handleLogic);
 
-  data["functionNameConfig"] = upperCase(data.flowTag) +
+  data['functionNameConfig'] =
+    upperCase(data.flowTag) +
     upperCase(data.flowStepName) +
     upperCase(data.handleLogic) +
-    upperCase(data.handlerType)
+    upperCase(data.handlerType);
 
-  const handler = handlerFlowConfig(
-    _izContext,
-    data,
-    appPath
-  );
+  const handler = handlerFlowConfig(_izContext, data, appPath);
 
-  const mainFunction = mainFunctionFlowConfig(
-    _izContext,
-    data,
-    appPath
-  );
+  const mainFunction = mainFunctionFlowConfig(_izContext, data, appPath);
 
-  const sqs = sqsFlowConfig(
-    _izContext,
-    data,
-    appPath
-  );
+  const sqs = sqsFlowConfig(_izContext, data, appPath);
 
-  const yaml = yamlFlowConfig(
-    _izContext,
-    data,
-    appPath
-  );
+  const yaml = yamlFlowConfig(_izContext, data, appPath);
 
-  results.push(
-    handler,
-    mainFunction,
-    sqs,
-    yaml
-  );
+  results.push(handler, mainFunction, sqs, yaml);
 
   return results;
-}
+}