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

package/src/generators/fromPlugIn/index.js

@@ -0,0 +1,528 @@
+/*
+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 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;
+import consts from '#libs/Consts.js';
+const { SOURCE_PATH, HANDLER, RESOURCE_CLASSES, SNS_RESOURCE } = consts;
+
+import yamlFlowStep from './firstFlowStep/yaml/yaml.js';
+import handlerFlowStep from './firstFlowStep/handler/handler.js';
+import mainFunctionFlowStep from './firstFlowStep/mainFunction/main.js';
+import sqsFlowStep from './firstFlowStep/queueNtopic/queueNtopic.js';
+import snsOut from './firstFlowStep/topicOut/topicOut.js';
+
+import yamlRecievePlugIn from './afterFirstFlowStep/recievePlugIn/yaml/yaml.js';
+import handlerRecievePlugIn from './afterFirstFlowStep/recievePlugIn/handler/handler.js';
+import mainFunctionRecievePlugIn from './afterFirstFlowStep/recievePlugIn/mainFunction/main.js';
+
+import handlerFlowConfig from './byConfig/handler/handler.js';
+import mainFunctionFlowConfig from './byConfig/mainFunction/main.js';
+import sqsFlowConfig from './byConfig/sns-sqs/snsSqs.js';
+import yamlFlowConfig from './byConfig/yaml/yaml.js';
+
+const {
+  createSnsResource,
+  createSqsResource,
+  defaultIamRolePerAction,
+  getLocalOrS3ObjectSchema,
+  resourceNames,
+  awaitingMultipleStepsRole,
+  createIamRole,
+  externalResourceYaml
+} = libs;
+
+// import yamlSendPlugIn from './afterFirstFlowStep/sendPlugIn/yaml/yaml.js';
+// 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
+ * @param {string} appPath
+ * @param {Array} allObjSchemas
+ * @param {Array} allRelationshipSchemas
+ * @param {Object} settings
+ * @returns {Promise<Array>}
+ */
+async function generatePlunIg(
+  _izContext,
+  rootServicePath,
+  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(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;
+
+        const flowTag = flowSchema.flowTag;
+        const roleName = upperCase(flowTag);
+        const resourceApis = [];
+        const additionalResourcePermission = defaultIamRolePerAction();
+
+        const data = {
+          additionalResourcePermission,
+          flowStepName,
+          flowTag,
+          resourceApis,
+          hookTagSetting: `${flowSchema.flowTag}FunctionSetting`,
+          functionName: upperCase(flowSchema.flowTag) + upperCase(flowStepName),
+          roleName,
+        };
+
+        resolveHandlerConfig(
+          data,
+          flowStepConfig,
+          additionalResourcePermission,
+          resourceApis,
+          serviceTag,
+          flowSchema.event
+        );
+
+        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) + 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++) {
+            if (i === 0) {
+              const firstResults = await buildFirstPluginHookResources(
+                _izContext,
+                data,
+                flowStepConfig,
+                appPath
+              );
+              allCreateSourceParams.push(...firstResults);
+            }
+
+            const afterResults = await buildRecievePluginHookResource(
+              _izContext,
+              data,
+              appPath,
+              allObjSchemas
+            );
+            allCreateSourceParams.push(...afterResults);
+          }
+        } else {
+          const noHookResults = await buildNoPluginHookResources(
+            _izContext,
+            data,
+            flowStepConfig,
+            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(
+      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;
+
+
+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);
+    results.push(sqsRes);
+  }
+
+  // const snsOutRes = await snsOut(
+  //   _izContext,
+  //   data,
+  //   appPath
+  // );
+
+  const mainRes = await mainFunctionFlowStep(
+    _izContext,
+    {
+      ...data,
+      havePlugIn: false,
+      handleLogic: flowStepConfig.settings?.handleLogic || 'none'
+    },
+    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,
+        handleLogic: flowStepConfig.settings?.handleLogic || 'none'
+      };
+    }
+  }
+
+  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, fallbackEvent = []) {
+  const { flowTag, flowStepName } = data;
+  let handler;
+  const events = flowStepConfig.event || fallbackEvent || [];
+
+  if (events.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 (events.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 (events.includes("lambdaSyncInv")) {
+    handler = HANDLER.hdrInv;
+  } 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`,
+    });
+  } else if (events.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(createSqsResource(
+          [
+            upperCase(flowTag) +
+            upperCase(flowStepName) +
+            upperCase(flowStepConfig.settings.handleLogic) +
+            upperCase(HANDLER.hdrSqs),
+            upperCase(flowTag) +
+            upperCase(flowStepName) +
+            upperCase(flowStepConfig.settings.handleLogic) +
+            upperCase(HANDLER.hdrSqs) + "DLQ"
+          ]
+        ))
+      } 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/generators/other/index.js

@@ -0,0 +1,41 @@
+/*
+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 generateAuth from './generateAuthYml/yaml.js';
+
+// Import code libs generator
+// const createGenerateCodeLibs = require('./libs/data');
+
+/**
+ * Generates code from templates based on object schemas
+ * @param {Object} _izContext - Context object
+ * @param {string} appPath - Path to object schema
+ * @returns {Promise<Array>} - Array of parameter objects for code generation
+ */
+async function generateCodeWithTemplate(_izContext, appPath) {
+  try {
+    console.info('[Other] generating auth yaml...');
+    const authYamlFile = generateAuth(_izContext, appPath);
+    console.info(`[Other] completed generated=${authYamlFile.length}`);
+    return [...authYamlFile];
+  } catch (error) {
+    console.error('[Other] error:', error);
+    return [];
+  }
+}
+
+export default generateCodeWithTemplate;

package/src/generators/resourceYamlComponent/dynamodb/template.ejs

@@ -0,0 +1,23 @@
+  <%- resourceName %>Table:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}<%- tableName %>
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      <%_ attributes.forEach(attribute => { -%>
+      - AttributeName: <%- attribute['AttributeName'] %>
+        AttributeType: <%- attribute['AttributeType'] %>
+      <%_ }) _%>
+      KeySchema:
+      <%_ attributes.forEach(attribute => { -%>
+      <%_ if (attribute.keyType === 'partitionKey' || attribute.keyType === "identifier") { -%>
+      - AttributeName: <%- attribute["AttributeName"] %>
+        KeyType: HASH
+        <%_ } -%>
+      <%_ if(attribute.keyType === "sortKey") { -%>
+      - AttributeName: <%- attribute["AttributeName"] %>
+        KeyType: RANGE
+        <%_ } -%>
+      <%_ }) _%>
+        #<#<%- tableName %>DynamoDbSetting#>
+        #<#/<%- tableName %>DynamoDbSetting#>

package/src/generators/resourceYamlComponent/index.js

@@ -0,0 +1,96 @@
+/*
+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 { join } from 'path';
+
+import createSourceDataDynamoDB from './dynamodb/mainResourcePerObjectSchemaData.js';
+import createDefaultDynamoDb from './dynamodb/defaultDynamoDbTable.js';
+import createDynamoPerRelationshipLink from './dynamodb/generateDynamoPerLink.js';
+// import createSourceSnsAndSqs from './sns-in-sqs/snsAndSqsPerActionData.js';
+import createFindDataAndProcessLogicalDefaultSnsInSqs from './sns-in-sqs/defaultSnsInSqsForFindDataAndProcessLogical.js';
+import createDataForCreateSourceSnsOut from './sns-out/snsOut.js';
+import createDefaultSnsOutForFindDataAndProcessLogical from './sns-out/defaultSnsOutForFindDataAndProcessLogical.js';
+import filterCreateResourceYaml from './filterGenerateResource/filter.js';
+
+import libs from '#libs/Utils.js';
+
+const { checkValidTableYaml } = libs;
+
+async function resourceYamlComponent(
+  _izContext,
+  appPath,
+  allObjSchemas,
+  allLocalRelationshipSchema
+) {
+  try {
+    const objSchemaPath = join(appPath, '/src/schemas');
+
+    const { params: dynamoSchemaParams } = allObjSchemas.reduce(
+      ({ params, tableYaml }, objectSchema) => {
+        try {
+          const [resources, updatedTableYaml] = checkValidTableYaml(
+            _izContext,
+            createSourceDataDynamoDB(_izContext, objectSchema, appPath),
+            tableYaml
+          );
+          _izContext.logger.debug('dynamoResources: ', resources);
+          return {
+            params: [...params, ...resources],
+            tableYaml: updatedTableYaml
+          };
+        } catch (error) {
+          _izContext.logger.error(
+            `Error processing schema: ${objectSchema?.name || 'unknown'}`,
+            error
+          );
+          return { params, tableYaml };
+        }
+      },
+      { params: [], tableYaml: {} }
+    );
+
+    const createSourceParams = [
+      ...dynamoSchemaParams,
+      ...createDefaultDynamoDb(_izContext, appPath),
+      ...createFindDataAndProcessLogicalDefaultSnsInSqs(_izContext, appPath),
+      ...createDefaultSnsOutForFindDataAndProcessLogical(_izContext, appPath),
+      // ...createSourceSnsAndSqs(_izContext, appPath),
+      ...createDataForCreateSourceSnsOut(_izContext, appPath),
+      ...(allLocalRelationshipSchema.length
+        ? createDynamoPerRelationshipLink(
+            _izContext,
+            allLocalRelationshipSchema,
+            appPath
+          )
+        : [])
+    ];
+
+    return await filterCreateResourceYaml(
+      _izContext,
+      createSourceParams,
+      objSchemaPath
+    );
+  } catch (error) {
+    _izContext.logger.error(
+      'Error generating code with template resourceYaml: ',
+      error
+    );
+    return [];
+  }
+}
+
+export default resourceYamlComponent;