@izara_project/izara-core-generate-service-code 1.0.32 → 1.0.34

package/src/generateCode/generateFlowStepWithPlugIn/index.js

@@ -0,0 +1,256 @@
+/*
+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);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+
+    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,76 @@ 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
+        };
+        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)}`
       };
-      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)}`
+          }
+          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
+      }
+      createSourceArray.push(notificationSystemText)
     }
-    createSourceArray.push(notificationSystemText)
   }
-  // console.log("schemaPath", schemaPath)
-  // console.log("createSourceArray", createSourceArray)
+
   return {
     templatePath: templatePath,
     templateData: { datas: createSourceArray },

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);
 
@@ -72,19 +74,23 @@ async function generateCodeWithTemplate(
     // ── 1. Fetch all schemas ─────────────────────────────────────────────────
     console.info('[INFO] [generateCode] STATUS=FETCHING  | schemas...');
     const fetchStartTime = Date.now();
-    const [allLocalFlowSchemas, allObjSchemas, allLocalRelationshipSchemas, allLocalNotificationSystem] =
-      await Promise.all([
-        getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath),
-        getObjectSchema.getAllLocalObjectSchemasWithHierarchy(
-          _izContext,
-          schemasPath
-        ),
-        getObjectSchema.getAllLocalRelationshipSchema(_izContext, schemasPath),
-        getObjectSchema.getLocalNotificationSystemSchemas(_izContext, schemasPath)
-      ]);
+    const [
+      allLocalFlowSchemas,
+      allObjSchemas,
+      allLocalRelationshipSchemas,
+      allLocalNotificationSystem
+    ] = await Promise.all([
+      getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath),
+      getObjectSchema.getAllLocalObjectSchemasWithHierarchy(
+        _izContext,
+        schemasPath
+      ),
+      getObjectSchema.getAllLocalRelationshipSchema(_izContext, schemasPath),
+      getObjectSchema.getLocalNotificationSystemSchemas(_izContext, schemasPath)
+    ]);
 
     const fetchDuration = Date.now() - fetchStartTime;
-    const fetchStr = `flow=${allLocalFlowSchemas.records?.length ?? 0} obj=${allObjSchemas.records?.length ?? 0} rel=${allLocalRelationshipSchemas.records?.length ?? 0}`;
+    const fetchStr = `flow=${allLocalFlowSchemas.records?.length ?? 0} obj=${allObjSchemas.records?.length ?? 0} rel=${allLocalRelationshipSchemas.length ?? 0}`;
     console.info(
       `[INFO] [generateCode] STATUS=FETCHED   | ${fetchStr.padEnd(40)} | elapsedMs=${fetchDuration}`
     );
@@ -98,6 +104,7 @@ async function generateCodeWithTemplate(
       schemaResult,
       initialSetupResult,
       otherResult,
+      generatePlugInResult
     ] = await Promise.all([
       generateTemplateDataFromFlowSchema(
         _izContext,
@@ -126,7 +133,8 @@ async function generateCodeWithTemplate(
         allLocalFlowSchemas.records,
         settings
       ),
-      generateTemplateDataOther(_izContext, appPath)
+      generateTemplateDataOther(_izContext, appPath),
+      generatePlugIn(_izContext, appPath, allObjSchemas.records, allLocalFlowSchemas.records)
     ]);
 
     const genDuration = Date.now() - genStartTime;
@@ -140,6 +148,7 @@ async function generateCodeWithTemplate(
       ...schemaResult,
       ...initialSetupResult,
       ...otherResult,
+      ...generatePlugInResult
     ];
 
     // ── 3. Generate role configs ─────────────────────────────────────────────

package/src/libs/Libs.js

@@ -15,11 +15,13 @@ 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 { serviceConfig } from '@izara_project/izara-core-library-service-schemas';
+import { serviceConfig, getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
 import consts from './Consts.js';
 const {
   STORAGE_TYPES,
   RESOURCE_CLASSES,
+  SQS_RESOURCE,
+  SNS_RESOURCE,
   DYNAMO_RESOURCE,
   S3_RESOURCE,
   FIELD_NAME_TYPE
@@ -52,21 +54,21 @@ function resourceNames(resourceClass, resourceName) {
     [RESOURCE_CLASSES.webSocket]:
       'arn:aws:execute-api:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_webSocketHostId}/${self:custom.iz_stage}/POST/@connections/{connectionId}',
     [RESOURCE_CLASSES.s3]:
-      'arn:aws:s3:::${self:custom.iz_serviceSchemaBucketName}/' + resourceName,
+      'arn:aws:s3:::${self:custom.iz_serviceSchemaBucketName}/' + resourceName
   }[resourceClass];
 }
 
 /**
  *
- * @param {string} action
- * @param {string} resource
+ * @param {object} action - key:resourceClass value:actionValue
+ * @param {array} resource
  * @param {string} effect - optional default Allow
  * @returns {{ effect, action, resource}}
  */
 function createIamRole(action, resource = [], effect = 'Allow') {
   if (!Array.isArray(resource)) {
     resource = [resource];
-  };
+  }
 
   if (Array.isArray(action)) {
     const actionObj = {};
@@ -187,24 +189,15 @@ function defaultIamRolePerAction() {
         ]
       },
       [
-        resourceNames(
-          RESOURCE_CLASSES.s3,
-          '${self:custom.iz_serviceSchemaBucketName}/perServiceSchemas/*'
-        ),
-        resourceNames(
-          RESOURCE_CLASSES.s3,
-          '${self:custom.iz_serviceSchemaBucketName}/serviceConfig/GraphServerTags.json'
-        )
+        resourceNames(RESOURCE_CLASSES.s3, 'perServiceSchemas/*'),
+        resourceNames(RESOURCE_CLASSES.s3, 'serviceConfig/GraphServerTags.json')
       ]
     )
   );
 
   defaultIamRole.push(
     createIamRole({ [RESOURCE_CLASSES.s3]: [S3_RESOURCE.listBucket] }, [
-      resourceNames(
-        RESOURCE_CLASSES.s3,
-        '${self:custom.iz_serviceSchemaBucketName}'
-      )
+      resourceNames(RESOURCE_CLASSES.s3, '*')
     ])
   );
 
@@ -458,11 +451,13 @@ function tableRoleForFlowSchema(objectSchema) {
   return resourcePermission;
 }
 
-const toFilePath = item =>
-  `${item.setting.savePath.replace(/\/+$/, '')}/${item.setting.saveFileName}${item.setting.fileExtension || ''}`;
+function toFilePath(item) {
+  return `${item.setting.savePath.replace(/\/+$/, '')}/${item.setting.saveFileName}${item.setting.fileExtension || ''}`;
 
-const toUniqueFilePaths = items =>
-  Array.from(
+}
+
+function toUniqueFilePaths(items) {
+  return Array.from(
     new Set(
       items
         .flat(5)
@@ -470,6 +465,96 @@ const toUniqueFilePaths = items =>
         .map(toFilePath)
     )
   ).sort();
+}
+
+function createSqsResource(queueNames) {
+  if (!Array.isArray(queueNames)) {
+    queueNames = [queueNames];
+  };
+
+  return createIamRole(
+    {
+      [RESOURCE_CLASSES.sqs]: Object.values(SQS_RESOURCE)
+    },
+    queueNames.map(queueName =>
+      resourceNames(RESOURCE_CLASSES.sqs, queueName))
+  );
+}
+
+function createSnsResource(topicNames) {
+  if (!Array.isArray(topicNames)) {
+    topicNames = [topicNames];
+  };
+
+  return createIamRole(
+    {
+      [RESOURCE_CLASSES.sns]: Object.values(SNS_RESOURCE)
+    },
+    topicNames.map(topicName =>
+      resourceNames(RESOURCE_CLASSES.sns, topicName))
+  );
+}
+async function getLocalOrS3ObjectSchema(_izContext, objType, schemasPath) {
+  console.log("objType, schemasPath", objType, schemasPath)
+  const iz_serviceTag = getLocalConfig('iz_serviceTag');
+  const iz_serviceSchemaBucketName = getLocalConfig('iz_serviceSchemaBucketName');
+  let objSchema;
+  let errorMessage;
+  if (objType.serviceTag === iz_serviceTag) {
+    objSchema = await getObjectSchema
+      .getLocalObjectSchemasWithHierarchy(
+        _izContext,
+        objType.objectType,
+        schemasPath
+      )
+      .then(res => {
+        return res.records[0];
+      });
+
+    if (!objSchema) {
+      errorMessage = 'local not exists';
+    }
+  } else {
+    objSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      _izContext,
+      objType,
+      iz_serviceSchemaBucketName
+    );
+    errorMessage = 's3 not exists';
+  }
+  return [objSchema, errorMessage];
+}
+
+async function getLocalOrS3FlowSchema(_izContext, flowType, schemasPath) {
+  const iz_serviceTag = getLocalConfig('iz_serviceTag');
+  const iz_serviceSchemaBucketName = getLocalConfig('iz_serviceSchemaBucketName');
+
+  let flowSchema;
+  let errorMessage;
+  if (flowType.serviceTag === iz_serviceTag) {
+    flowSchema = await getObjectSchema
+      .getLocalFlowSchemas(
+        _izContext,
+        flowType.flowTag,
+        schemasPath
+      )
+      .then(res => {
+        return res.records[0];
+      });
+
+    if (!flowSchema) {
+      errorMessage = 'local not exists';
+    }
+  } else {
+    flowSchema = await getObjectSchema.getFlowSchemaS3(
+      _izContext,
+      flowType,
+      iz_serviceSchemaBucketName
+    );
+    errorMessage = 's3 not exists';
+  }
+  return [flowSchema, errorMessage];
+}
 
 export default {
   resourceNames,
@@ -487,5 +572,9 @@ export default {
   getStorageResourceFromObjectSchemas,
   getExternalTopicComponentFromAllObjectSchemas,
   tableRoleForFlowSchema,
-  toUniqueFilePaths
+  toUniqueFilePaths,
+  getLocalOrS3ObjectSchema,
+  getLocalOrS3FlowSchema,
+  createSqsResource,
+  createSnsResource
 };