@izara_project/izara-core-generate-service-code 1.0.33 → 1.0.35

package/src/generateCode/generateFlowStepWithPlugIn/firstFlowStep/yaml/template.ejs

@@ -0,0 +1,28 @@
+<%- functionNameConfig %>:
+  handler: <%- handlerPath %>
+  name: ${self:custom.iz_resourcePrefix}<%- functionName %>
+  role: <%- roleName %>Role
+  #<#<%- hookTagSetting %>#>
+  #<#/<%- hookTagSetting %>#>
+<%_ if (handlerType === 'hdrDsq' || handlerType === 'hdrSqs') { _%>
+  events:
+    - sqs:
+        arn: <%- event %>
+        batchSize: 10
+<%_ } else if (handlerType === 'hdrApi' && resourceApis.length > 0) { _%>
+  events:
+<%_ resourceApis.forEach(api => { _%>
+    - httpApi:
+        path: <%- api.path %>
+        method: <%- api.method %>
+        #<#<%- api.hookTagApp %>#>
+        # authorizer: authorizerServiceSchema
+        #<#/<%- api.hookTagApp %>#>
+    - httpApi:
+        path: <%- api.pathWithUser %>
+        method: <%- api.method %>
+        #<#<%- api.hookTagUser %>#>
+        # authorizer: authorizerIdentifiers
+        #<#/<%- api.hookTagUser %>#>
+<%_ }) _%>
+<%_ } _%>

package/src/generateCode/generateFlowStepWithPlugIn/index.js

@@ -0,0 +1,259 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+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 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;
+
+import yamlFlowStep from './firstFlowStep/yaml/data.js';
+import handlerFlowStep from './firstFlowStep/handler/data.js';
+import mainFunctionFlowStep from './firstFlowStep/mainFunction/data.js';
+import sqsFlowStep from './firstFlowStep/queueNtopic/data.js';
+import snsOut from './firstFlowStep/topicOut/data.js';
+
+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 yamlSendPlugIn from './afterFirstFlowStep/sendPlugIn/yaml/data.js';
+// import handlerSendPlugIn from './afterFirstFlowStep/sendPlugIn/handler/data.js';
+// import mainFunctionSendPlugIn from './afterFirstFlowStep/sendPlugIn/mainFunction/data.js';
+
+
+/**
+ * Generates code from templates based on object schemas
+ * @param {Object} _izContext
+ * @param {string} appPath
+ * @param {Array} allObjSchemas
+ * @param {Array} allRelationshipSchemas
+ * @param {Object} settings
+ * @returns {Promise<Array>}
+ */
+async function generatePlunIg(
+  _izContext,
+  appPath,
+  allObjSchemas,
+  allLocalFlowSchemas,
+) {
+  const allCreateSourceParams = [];
+
+  try {
+    const startAllMs = Date.now();
+    const totalSchemas = Array.isArray(allObjSchemas)
+      ? allObjSchemas.length
+      : 0;
+
+
+    console.info(`[plugIn] start totalSchemas=${totalSchemas}`);
+    if (totalSchemas === 0) return [];
+
+    const configPath = path.join(appPath, '../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;
+        } else {
+          const flowTag = flowSchema.flowTag;
+          const roleName = upperCase(flowTag);
+          const resourceApis = [];
+          let handler;
+          const additionalResourcePremission = defaultIamRolePerAction();
+
+          const data = {
+            additionalResourcePremission: additionalResourcePremission,
+            flowStepName: flowStepName,
+            flowTag: flowTag,
+            resourceApis: resourceApis,
+            hookTagSetting: `${flowSchema.flowTag}FunctionSetting`,
+            functionName: upperCase(flowSchema.flowTag) + upperCase(flowStepName),
+            roleName: roleName,
+          };
+
+          if (flowStepConfig.event.includes("ownTopic")) {
+            data['eventFlow'] = 'ownTopic'
+            handler = HANDLER.hdrSqs;
+            additionalResourcePremission.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;
+            additionalResourcePremission.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;
+            additionalResourcePremission.push(
+              createSqsResource(
+                [
+                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler),
+                  upperCase(flowSchema.flowTag) + upperCase(flowStepName) + upperCase(handler) + "DSQ"
+                ]
+              )
+            );
+          };
+
+          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) + upperCase(handler),
+          })
+
+          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 snsOutResult = await snsOut(_izContext, data, appPath);
+          allCreateSourceParams.push(snsOutResult);
+
+          let mainResult;
+          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);
+                };
+
+                if (objSchema.hasOwnProperty('recievePlugInHookTag')) {
+                  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);
+                  }
+                }
+              }
+            }
+          } else {
+            mainResult = await mainFunctionFlowStep(_izContext, { ...data, havePlugIn: false }, appPath);
+            allCreateSourceParams.push(mainResult);
+          }
+        }
+      }
+    };
+
+    const uniqueSortedTargetFiles = Array.from(
+      new Set(
+        allCreateSourceParams
+          .filter(
+            item => item?.setting?.savePath && item?.setting?.saveFileName
+          )
+          .map(
+            item =>
+              `${item.setting.savePath.replace(/\/+$/, '')}/${item.setting.saveFileName}${item.setting.fileExtension || ''}`
+          )
+      )
+    ).sort();
+
+    console.info(
+      `[plugIn] completed total=${allCreateSourceParams.length} uniqueFiles=${uniqueSortedTargetFiles.length} elapsedMs=${Date.now() - startAllMs}`
+    );
+    if (uniqueSortedTargetFiles.length > 0 && _izContext.logger?.debug)
+      console.log('[plugIn] targetFiles=', uniqueSortedTargetFiles);
+
+    return allCreateSourceParams;
+  } catch (error) {
+    console.error('[plugIn] error:', error);
+    return [];
+  }
+}
+
+export default generatePlunIg;

package/src/generateCode/generateSchema/generateTextTag/systemText/data.js

@@ -49,67 +49,84 @@ function createSourceSystemText(
   schemaPath
 ) {
   const createSourceArray = [];
-  // console.log("params objSchema", JSON.stringify(allObjectSchema, null, 2));
-  for (const objectSchema of allObjectSchema) {
-    const fieldNames = [...Object.keys(objectSchema.fieldNames)];
-    if (objectSchema.hasOwnProperty("addOnDataStructure")) {
-      for (const addOn of objectSchema.addOnDataStructure) {
-        if (addOn.type === "versionedData") {
-          fieldNames.push(...Object.keys(addOn.fieldNames))
+
+  if (allObjectSchema.length > 0) {
+    for (const objectSchema of allObjectSchema) {
+      const fieldNames = [...Object.keys(objectSchema.fieldNames)];
+      if (objectSchema.hasOwnProperty("addOnDataStructure")) {
+        for (const addOn of objectSchema.addOnDataStructure) {
+          if (addOn.type === "versionedData") {
+            fieldNames.push(...Object.keys(addOn.fieldNames))
+          }
         }
+      };
+
+      for (const fieldName of fieldNames) {
+        const objType = {
+          objectType: objectSchema.objectType,
+          serviceTag: getLocalConfig('iz_serviceTag')
+        };
+        const systemTextObjectSchemas = {
+          nameSpace: `${coreUtils.createObjTypeConcat(_izContext, objType)}_description`, // for each objectType
+          systemTextTag: `${fieldName}_${coreUtils.createObjTypeConcat(_izContext, objType)}`, // for each fieldName
+          openHook: `//(<${coreUtils.createObjTypeConcat(_izContext, objType)}${fieldName}Hook>)`,
+          closeHook: `//(</${coreUtils.createObjTypeConcat(_izContext, objType)}${fieldName}Hook>)`
+        };
+        createSourceArray.push(systemTextObjectSchemas);
       }
-    };
+    }
+  }
 
-    for (const fieldName of fieldNames) {
-      const objType = {
-        objectType: objectSchema.objectType,
+  if (allFlowSchemas.length > 0) {
+    for (const flowSchema of allFlowSchemas) {
+      const flowType = {
+        flowTag: flowSchema.flowTag,
         serviceTag: getLocalConfig('iz_serviceTag')
       };
-      const systemTextObjectSchemas = {
-        nameSpace: `${coreUtils.createObjTypeConcat(_izContext, objType)}_description`, // for each objectType
-        systemTextTag: `${fieldName}_${coreUtils.createObjTypeConcat(_izContext, objType)}` // for each fieldName
+      const systemTextFlowSchemas = {
+        nameSpace: `${coreUtils.createFlowTypeConcat(_izContext, flowType)}`, // for each flowType
+        systemTextTag: `errors_${coreUtils.createFlowTypeConcat(_izContext, flowType)}`,
+        openHook: `//(<${coreUtils.createFlowTypeConcat(_izContext, flowType)}Hook>)`,
+        closeHook: `//(</${coreUtils.createFlowTypeConcat(_izContext, flowType)}Hook>)`
       };
-      createSourceArray.push(systemTextObjectSchemas);
+      createSourceArray.push(systemTextFlowSchemas);
     }
   }
 
-  for (const flowSchema of allFlowSchemas) {
-    const flowType = {
-      flowTag: flowSchema.flowTag,
-      serviceTag: getLocalConfig('iz_serviceTag')
-    };
-    const systemTextFlowSchemas = {
-      nameSpace: `${coreUtils.createFlowTypeConcat(_izContext, flowType)}`, // for each flowType
-      systemTextTag: `errors_${coreUtils.createFlowTypeConcat(_izContext, flowType)}`
-    };
-    createSourceArray.push(systemTextFlowSchemas);
-  }
+  if (allRelSchema.length > 0) {
+    for (const relSchema of allRelSchema) {
+      const relTag = Object.keys(relSchema)[0]
+      const relType = {
+        serviceTag: getLocalConfig('iz_serviceTag'),
+        relationshipTag: relTag
+      };
 
-  for (const relSchema of allRelSchema) {
-    const relTag = Object.keys(relSchema)[0]
-    const relType = {
-      serviceTag: getLocalConfig('iz_serviceTag'),
-      relationshipTag: relTag
-    };
-
-    for (const fieldName of Object.keys(relSchema[relTag].fieldNames)) {
-      const systemTextRelSchemas = {
-        nameSpace: `${coreUtils.createRelTypeConcat(_izContext, relType)}_description`,
-        systemTextTag: `${fieldName}_${coreUtils.createRelTypeConcat(_izContext, relType)}`
+      if (relSchema[relTag].hasOwnProperty('fieldNames') && Object.keys(relSchema[relTag].fieldNames).length > 0) {
+        for (const fieldName of Object.keys(relSchema[relTag].fieldNames)) {
+          const systemTextRelSchemas = {
+            nameSpace: `${coreUtils.createRelTypeConcat(_izContext, relType)}_description`,
+            systemTextTag: `${fieldName}_${coreUtils.createRelTypeConcat(_izContext, relType)}`,
+            openHook: `//(<${coreUtils.createRelTypeConcat(_izContext, relType)}${fieldName}Hook>)`,
+            closeHook: `//(</${coreUtils.createRelTypeConcat(_izContext, relType)}${fieldName}Hook>)`
+          }
+          createSourceArray.push(systemTextRelSchemas);
+        }
       }
-      createSourceArray.push(systemTextRelSchemas);
     }
   }
-  console.log("notificationSchemas", notificationSchemas);
-  for (const notification of notificationSchemas) {
-    const notificationSystemText = {
-      nameSpace: `sysNotification_${notification.notificationGrouping}`,
-      systemTextTag: notification.notificationTag
+
+  if (notificationSchemas.length > 0) {
+    for (const notification of notificationSchemas) {
+      const notificationSystemText = {
+        nameSpace: `sysNotification_${notification.notificationGrouping}`,
+        systemTextTag: notification.notificationTag,
+        openHook: `//(<${notification.notificationTag}Hook>)`,
+        closeHook: `//(</${notification.notificationTag}Hook>)`
+      }
+      createSourceArray.push(notificationSystemText)
     }
-    createSourceArray.push(notificationSystemText)
   }
-  // console.log("schemaPath", schemaPath)
-  // console.log("createSourceArray", createSourceArray)
+
   return {
     templatePath: templatePath,
     templateData: { datas: createSourceArray },
@@ -118,7 +135,11 @@ function createSourceSystemText(
       saveFileName: SAVE_FILE_NAME.systemTextSchema,
       fileExtension: '.js',
       isAppend: true,
-      generateHookFile: false
+      hookPath: path.join(
+        schemaPath,
+        '../schemaHook/'
+      ),
+      // generateHookFile: false
     }
   };
 }

package/src/generateCode/generateSchema/generateTextTag/systemText/template.ejs

@@ -1,5 +1,10 @@
 export default [
 <% datas.forEach((data, index) => { -%>
-  <%- JSON.stringify(data,null,2) %><%= index < datas.length - 1 ? ',' : '' %>
+  {
+    nameSpace: "<%- data.nameSpace %>",
+    systemTextTag: "<%- data.systemTextTag %>",
+    <%- data.openHook %>
+    <%- data.closeHook %>
+  }<%= index < datas.length - 1 ? ',' : '' %>
 <% }); -%>
 ];

package/src/generateCode/resourceYamlComponent/sns-out/template.ejs

@@ -1,5 +1,9 @@
 ##--------- [Create Topic Out]
+<% if (queueName.includes("_")) { %>
+  Out<%- (queueName.split("_")).join("") %>:
+<% } else { -%>
   Out<%- queueName %>:
+<% } -%>
     Type: AWS::SNS::Topic
     Properties:
       DisplayName: "SNS Message out"

package/src/generateCode.js

@@ -38,6 +38,8 @@ import generateTemplateDataOther from './generateCode/generateOther/generateCode
 
 import generateTemplateDataRole from './generateCode/generateRole/generateCodeRole.js';
 
+import generatePlugIn from './generateCode/generateFlowStepWithPlugIn/index.js';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
@@ -97,37 +99,43 @@ async function generateCodeWithTemplate(
     console.info('[INFO] [generateCode] STATUS=GENERATING| template data...');
     _izContext.logger.info('[generateCode] generating template data...');
     const genStartTime = Date.now();
-    const [flowSchemaResult, schemaResult, initialSetupResult, otherResult] =
-      await Promise.all([
-        generateTemplateDataFromFlowSchema(
-          _izContext,
-          appPath,
-          allLocalFlowSchemas.records,
-          settings
-        ),
-        generateTemplateDataFromSchema(
-          _izContext,
-          appPath,
-          allObjSchemas,
-          allLocalRelationshipSchemas,
-          allLocalFlowSchemas.records,
-          allLocalNotificationSystem,
-          settings
-        ).catch(error => {
-          console.error('[generateCode] schemaResult error:', error);
-          _izContext.logger.error('[generateCode] schemaResult error:', error);
-          return [];
-        }),
-        generateTemplateDataInitialSetup(
-          _izContext,
-          appPath,
-          allObjSchemas.records,
-          allLocalRelationshipSchemas,
-          allLocalFlowSchemas.records,
-          settings
-        ),
-        generateTemplateDataOther(_izContext, appPath)
-      ]);
+    const [
+      flowSchemaResult,
+      schemaResult,
+      initialSetupResult,
+      otherResult,
+      generatePlugInResult
+    ] = await Promise.all([
+      generateTemplateDataFromFlowSchema(
+        _izContext,
+        appPath,
+        allLocalFlowSchemas.records,
+        settings
+      ),
+      generateTemplateDataFromSchema(
+        _izContext,
+        appPath,
+        allObjSchemas,
+        allLocalRelationshipSchemas,
+        allLocalFlowSchemas.records,
+        allLocalNotificationSystem,
+        settings
+      ).catch(error => {
+        console.error('[generateCode] schemaResult error:', error);
+        _izContext.logger.error('[generateCode] schemaResult error:', error);
+        return [];
+      }),
+      generateTemplateDataInitialSetup(
+        _izContext,
+        appPath,
+        allObjSchemas.records,
+        allLocalRelationshipSchemas,
+        allLocalFlowSchemas.records,
+        settings
+      ),
+      generateTemplateDataOther(_izContext, appPath),
+      generatePlugIn(_izContext, appPath, allObjSchemas.records, allLocalFlowSchemas.records)
+    ]);
 
     const genDuration = Date.now() - genStartTime;
     const genStr = `flow=${flowSchemaResult.length} sch=${schemaResult.length} setup=${initialSetupResult.length} other=${otherResult.length}`;
@@ -139,7 +147,8 @@ async function generateCodeWithTemplate(
       ...flowSchemaResult,
       ...schemaResult,
       ...initialSetupResult,
-      ...otherResult
+      ...otherResult,
+      ...generatePlugInResult
     ];
 
     // ── 3. Generate role configs ─────────────────────────────────────────────