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

package/src/generateCode/generateFlowStepWithPlugIn/index(old).js

@@ -0,0 +1,290 @@
+/*
+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 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 (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"
+                ]
+              )
+            );
+          };
+
+          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 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
+                    );
+                  }
+                };
+              }
+            }
+          } 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
+              );
+            }
+          }
+        }
+      }
+    };
+
+
+
+    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;