@izara_project/izara-market-library-service-schemas 1.0.34 → 1.0.36

package/src/reStructure/TemplateData/flowSchema/createRecordByStatusType/wbs/mainFunction/template.ejs

@@ -0,0 +1,222 @@
+/*
+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 />.
+*/
+
+'use strict';
+
+const hash = require("object-hash");
+const { getObjectSchema } = require('@izara_project/izara-core-library-service-schemas');
+
+const dynamodbSharedLib = require('@izara_project/izara-core-library-dynamodb');
+const snsSharedLib = require('@izara_project/izara-core-library-sns');
+const asyncFlowSharedLib = require('@izara_project/izara-core-library-asynchronous-flow');
+const callingFlowSharedLib = require('@izara_project/izara-core-library-calling-flow');
+const lambdaSharedLib = require('@izara_project/izara-core-library-lambda');
+
+const externalRequest = require('@izara_project/izara-core-library-external-request');
+const sns = externalRequest.sns
+
+const utils = require('@izara_project/izara-market-library-service-schemas/src/MainLibs/src/Utils')
+const NoRetryError = require('@izara_project/izara-core-library-core').NoRetryError
+const { v4: uuidv4 } = require('uuid')
+const consts = require('@izara_project/izara-middleware/src/MiddlewareCore/Consts')
+const { TOPIC_NAME_GENERATE_CODE } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts')
+/**
+ *
+ *
+ * description of function.
+ * @param {Object} _izContext
+ * @param {CorrelationIds} _izContext.correlationIds - property of _izContext
+ * @param {Logger} _izContext.logger - property of _izContext
+ * @param {Object} requestParams - request params
+ * @param {Object} requestParams.identifiers - identifiers for get data
+ * @param {Object} requestParams.additionalRequest - additionalRequest
+ *
+ *
+ * @returns {object} description of return value
+ */
+
+module.exports.<%- functionMain%> = async (
+  _izContext,
+  requestParams,
+  callingFlowConfig = {},
+  //(<additionalParams>)
+  //(</additionalParams>)
+) => {
+  try {
+    //param {
+    //  "action":register
+    //  flowTag:"xxx"
+    //  identifierTask:"xxxx",
+    // ...something
+    //}
+
+    // receive flowTag and identifiers
+    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
+      flowTag: requestParams.flowTag,
+      serviceTag: process.env.iz_serviceTag,
+    })
+
+    _izContext.logger.debug("flowSchema", flowSchema)
+    if (!flowSchema) {
+      throw new NoRetryError(`flowTag not found ${requestParams.flowTag}`)
+    }
+
+    // get data from dynamoDB of objectType of flowSchema
+    const getStoredCache = async (objectType) => {
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+        _izContext,
+        {
+          objectType: objectType,
+          serviceTag: process.env.iz_serviceTag,
+        })
+
+      _izContext.logger.debug("==> objectSchema", objectSchema)
+
+      // this returns the table name of the first storage resource with storageType "dynamoDB"
+      const tableName = Object.values(objectSchema.storageResources).find(
+        (storageResource) => storageResource.storageType === "dynamoDB"
+      )?.tableName
+      _izContext.logger.debug("==> tableName", tableName)
+
+      // const identifierPK = objectSchema[identifierPK].find(
+      //   (identifier) => identifier.type === "partitionKey"
+      // )?.fieldName
+
+      // const identifierSK = objectSchema[identifierSK].find(
+      //   (identifier) => identifier.type === "sortKey"
+      // )?.fieldName
+
+      let identifierPK = null
+      let identifierSK = null
+      objectSchema.identifiers.map((identifier) => {
+        if (identifier.type === "partitionKey") {
+          identifierPK = identifier.fieldName
+        } else if (identifier.type === "sortKey") {
+          identifierSK = identifier.fieldName
+        }
+      })
+
+      _izContext.logger.debug("==> identifierPK", identifierPK)
+      _izContext.logger.debug("==> identifierSK", identifierSK)
+
+      const payloadGetStoredCache = {
+        [identifierPK]: requestParams.identifiers[identifierPK],
+      }
+      if (identifierSK) {
+        payloadGetStoredCache[identifierSK] = requestParams.identifiers[identifierSK]
+      }
+
+      _izContext.logger.debug("==> payloadGetStoredCache", payloadGetStoredCache)
+
+      // const getStoredCache = await dynamodbSharedLib.getItem(
+      //   _izContext,
+      //   await dynamodbSharedLib.tableName(_izContext, tableName),
+      //   payloadGetStoredCache
+      // )
+
+      const getStoredCache = await dynamodbSharedLib.query(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, tableName),
+        payloadGetStoredCache
+      )
+      _izContext.logger.debug("==> getStoredCache:::", getStoredCache)
+      return ({
+        data: getStoredCache.Items[0],
+        identifierPK: identifierPK,
+      })
+    }
+
+    // Initialize storedCacheData variable that will be used in multiple switch cases
+    let storedCacheData = null;
+    switch (flowSchema.statusType) {
+      case "statusField":
+        const payload = {
+          identifiers: requestParams.identifiers,
+          objectType: flowSchema.objType.objectType
+        }
+        const result = await externalRequest.lambda.invokeSync(
+          _izContext,
+          await lambdaSharedLib.lambdaFunctionName(_izContext, "GetHdrInv", flowSchema.objType.serviceTag),
+          payload
+        )
+        if (!result) {
+          throw new NoRetryError(`statusField not found ${requestParams.identifiers}`)
+        }
+        return result
+
+
+      case "storedCache":
+        // if statusType=storedCache then query storedCache > post message to client -> remove connectionId if status = error || complete
+
+        storedCacheData = await getStoredCache(flowSchema.objType.objectType)
+        _izContext.logger.debug("==> storedCacheData", storedCacheData)
+
+        if (!storedCacheData) {
+          throw new NoRetryError(`storedCache not found ${requestParams.identifiers} ${requestParams.sortKey}`)
+        }
+        let payloadPostMessage = {
+          identifierTask: requestParams.identifiers[storedCacheData.identifierPK],
+          connectionId: _izContext.correlationIds.get(consts.CONNECTION_ID),
+          flowType: {
+            flowTag: flowSchema.flowTag,
+            serviceTag: process.env.iz_serviceTag,
+          }
+        }
+
+        _izContext.logger.debug('==> payloadPostMessage', payloadPostMessage)
+        if (storedCacheData.data.cacheStatus !== "error" && storedCacheData.data.cacheStatus != "complete") {
+          await dynamodbSharedLib.putItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(_izContext, "FlowTagRegisterRecords"),
+            payloadPostMessage
+          )
+
+          return payloadPostMessage;
+        } else {
+          await dynamodbSharedLib.deleteItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(_izContext, "FlowTagRegisterRecords"),
+            {
+              identifierTask: requestParams.identifiers[storedCacheData.identifierPK],
+              connectionId: _izContext.correlationIds.get(consts.CONNECTION_ID)
+            }
+          )
+        }
+
+        return storedCacheData;
+
+      case "none":
+        // if statusType=none -> post message to client ---- not remove connectionId when post message, can remove connectionId when cannot use connectionId only(user disconnect)
+        storedCacheData = await getStoredCache(flowSchema.objType.objectType)
+
+        _izContext.logger.debug("==> objectSchema", storedCacheData)
+        if (!storedCacheData) {
+          throw new NoRetryError(`none not found ${requestParams.identifiers}`)
+        }
+        return storedCacheData
+
+      default:
+        throw new NoRetryError(`statusType not found ${flowSchema.statusType}`)
+    }
+
+    // post result to connectionId
+  } catch (err) {
+    _izContext.logger.error('error WebSocketInvoke: ', err)
+    throw (err)
+  }
+}

package/src/reStructure/TemplateData/flowSchema/dynamoDb/data.js

@@ -19,18 +19,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 const path = require("path")
 
-
-// const {
-//   HANDLER,
-// STORAGE_TYPES
-// } = require('@izara_project/izara-core-library-service-schemas/src/Consts');
-
-const STORAGE_TYPES = {
-  dynamoDB: "dynamoDB",
-  graph: "graph"
-}
 const templatePath = path.join(__dirname, '../../resourceYaml/dynamodb/template.ejs')
-const { SOURCE_PATH, SAVE_FILE_NAME } = require('../../../../MainLibs/src/Consts.js')
+const { SOURCE_PATH, SAVE_FILE_NAME, defaultIamRolePerAction, createIamRole, DYNAMO_RESOURCE, resourceNames, RESOURCE_CLASSES, FUNCTION_NAME, SOURCE_GENERATE_IAM_ROLE } = require('../../../../MainLibs/src/Consts.js')
 
 /**
  * create param of crateSouce for FindData And processLogical
@@ -39,43 +29,92 @@ const { SOURCE_PATH, SAVE_FILE_NAME } = require('../../../../MainLibs/src/Consts
  * @param {String} srcPath
  * @returns {Object[]}
  */
-const createAwaitingMultipleStepDynamoDbData = (_izContext, flowSchema, srcPath) => {
+const createAwaitingMultipleStepDynamoDbData = (_izContext, flowSchema, allLocalObjectSchemas, srcPath) => {
+  if (!flowSchema.event.includes("ownTopic")) {
+    return [];
+  }
 
-  let resultsForCreateSource = [];
-  const defaultDynamoDataLists = [];
+  const objectSchema = allLocalObjectSchemas.records.find(schema =>
+    schema.objectType === flowSchema.objType.objectType);
 
-  if (flowSchema.statusType === "storedCache") {
-    defaultDynamoDataLists.push(
-      {
-        tableName: flowSchema.flowTag + "Main",
-        resourceName: flowSchema.flowTag + "Main",
-        attributes: [
-          {
-            keyType: "partitionKey",
-            AttributeName: flowSchema.flowTag + "Id",
-            AttributeType: "S"
-          }
-        ]
-      }
-    )
+  if (!objectSchema) {
+    return [];
+  }
+
+  if (!objectSchema.storageResources) {
+    return [];
+  }
+
+  // ex.
+  // storageResources: {
+  //   cacheTable: {
+  //     storageType: "dynamoDB",
+  //     tableName: "TranslateIdsCacheMain"
+  //   }
+  // }
+
+  // Check if there's exactly one DynamoDB storage resource
+  const dynamoDbEntries = Object.entries(objectSchema.storageResources)
+    .filter(([_, value]) => value.storageType === "dynamoDB");
+
+  console.debug(`DynamoDB entries: ${JSON.stringify(dynamoDbEntries)}`);
+
+  if (dynamoDbEntries.length !== 1) {
+    console.warn(`Object schema ${objectSchema.objectType} for ${flowSchema.flowTag} needs to have exactly one DynamoDB storage resource.`);
+    return []; // Either no DynamoDB storage or more than one found
   }
 
-  for (let defaultDynamoData of defaultDynamoDataLists) {
-    resultsForCreateSource.push({
-      templatePath: templatePath,
-      templateData: defaultDynamoData,
-      setting: {
-        initialData: 'Resources:\n',
-        savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
-        saveFileName: SAVE_FILE_NAME.dynamoDbYaml,
-        fileExtension: '.yml',
-        isAppend: true
-      }
-    });
+  const storageResourceEntry = dynamoDbEntries[0];
+
+  if (!storageResourceEntry) {
+    return [];
   }
-  // console.log("resultsForCreateSource default dynamo", resultsForCreateSource)
 
-  return resultsForCreateSource;
-}
+  const [_, storageResource] = storageResourceEntry;
+  const tableName = storageResource.tableName;
+
+  const attributes = objectSchema.identifiers
+    .map(identifier => ({
+      keyType: identifier.type,
+      AttributeName: identifier.fieldName,
+      AttributeType: "S"
+    }));
+
+  let additionalResourcePermission = defaultIamRolePerAction();
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.dynamoDbTable]: [
+          DYNAMO_RESOURCE.putItem,
+          DYNAMO_RESOURCE.getItem,
+          DYNAMO_RESOURCE.query,
+          DYNAMO_RESOURCE.deleteItem,
+          DYNAMO_RESOURCE.updateItem
+        ]
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.dynamoDbTable, tableName)
+      ]
+    )
+  );
+
+  return [{
+    templatePath,
+    templateData: {
+      tableName,
+      resourceName: tableName,
+      attributes,
+      additionalResourcePermission,
+      roleName: SOURCE_GENERATE_IAM_ROLE.RegisterRole,
+    },
+    setting: {
+      initialData: 'Resources:\n',
+      savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
+      saveFileName: SAVE_FILE_NAME.dynamoDbYaml,
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  }];
+};
 
-module.exports = createAwaitingMultipleStepDynamoDbData
+module.exports = createAwaitingMultipleStepDynamoDbData;

package/src/reStructure/TemplateData/flowSchema/eventBridge/functionYaml/data.js

@@ -51,9 +51,9 @@ function data(_izContext, flowSchema, srcPath) {
 }
 
 function createSourceParams(_izContext, flowSchema, srcPath) {
-  const functionName = upperCase(flowSchema.flowTag);
-  const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
-  const functionNameConfig = upperCase(flowSchema.flowTag) + SOURCE_GENERATE_IAM_ROLE.EventBridge;
+  const functionName = upperCase(FUNCTION_NAME.flowSchemaEventBridge);
+  // const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
+  const functionNameConfig = upperCase(SOURCE_GENERATE_IAM_ROLE.EventBridge);
   const handlerType = HANDLER.hdrInv;
   const schedules = flowSchema.schedules;
 
@@ -85,25 +85,28 @@ function createSourceParams(_izContext, flowSchema, srcPath) {
 
   // Validate rate format for each schedule
   for (const schedule of schedules) {
-    const rate = schedule.rate;
-    if (rate.startsWith('rate')) {
-      // Validate rate expression format: rate(value unit)
-      if (!/^rate\(\d+\s+(minute|minutes|hour|hours|day|days)\)$/.test(rate)) {
-        console.error(`Invalid rate format: ${rate}. Should be like 'rate(5 minutes)' or 'rate(1 day)'`);
-        return;
-      }
-    } else if (rate.startsWith('cron')) {
-      // Extract the cron components for more detailed validation
-      const cronMatch = rate.match(/^cron\((.*)\)$/);
-      if (!cronMatch) {
-        console.error(`Invalid cron format: ${rate}. Should be like 'cron(0 10 * * ? *)'`);
-        return;
-      }
+    if (Array.isArray(schedule.rate) && schedule.rate.length <= 1) {
+      const rate = schedule.rate[0];
+
+      if (rate.startsWith('rate')) {
+        // Validate rate expression format: rate(value unit)
+        if (!/^rate\(\d+\s+(minute|minutes|hour|hours|day|days)\)$/.test(rate)) {
+          console.error(`Invalid rate format: ${rate}. Should be like 'rate(5 minutes)' or 'rate(1 day)'`);
+          return;
+        }
+      } else if (rate.startsWith('cron')) {
+        // Extract the cron components for more detailed validation
+        const cronMatch = rate.match(/^cron\((.*)\)$/);
+        if (!cronMatch) {
+          console.error(`Invalid cron format: ${rate}. Should be like 'cron(0 10 * * ? *)'`);
+          return;
+        }
 
-      const cronParts = cronMatch[1].split(/\s+/);
-      if (cronParts.length !== 6) {
-        console.error(`Invalid cron expression: ${rate}. Must contain 6 components: minutes hours day-of-month month day-of-week year`);
-        return;
+        const cronParts = cronMatch[1].split(/\s+/);
+        if (cronParts.length !== 6) {
+          console.error(`Invalid cron expression: ${rate}. Must contain 6 components: minutes hours day-of-month month day-of-week year`);
+          return;
+        }
       }
 
     } else {
@@ -115,16 +118,6 @@ function createSourceParams(_izContext, flowSchema, srcPath) {
 
   let additionalResourcePermission = defaultIamRolePerAction();
   additionalResourcePermission.push(
-    createIamRole(
-      {
-        [RESOURCE_CLASSES.sns]: [
-          SNS_RESOURCE.publish
-        ]
-      },
-      [
-        resourceNames(RESOURCE_CLASSES.sns, "InImportBatchMainCreate")
-      ]
-    ),
     createIamRole(
       {
         [RESOURCE_CLASSES.dynamoDbTable]: [
@@ -151,39 +144,13 @@ function createSourceParams(_izContext, flowSchema, srcPath) {
     )
   )
 
-  if (flowSchema?.hook) {
-    for (const [hookName, hookProperties] of Object.entries(flowSchema.hook)) {
-      if (hookName === FLOW_SCHEMA_HOOK_STATE.beforeCreate) {
-        for (const hookFunction of hookProperties.functionList) {
-          if ((hookFunction.event.hasOwnProperty("initialEvent") && (hookFunction.event.initialEvent === true))) {
-            if (hookFunction?.permission) {
-              for (const permission of hookFunction.permission) {
-                additionalResourcePermission.push(
-                  createIamRole(
-                    permission.action,
-                    permission.resource.map(resource =>
-                      externalResourceYaml(
-                        resource.resource,
-                        resource.resourceName,
-                        resource.serviceTag),
-                      permission.effect
-                    )
-                  )
-                )
-              }
-            }
-          }
-        }
-      }
-    }
-  }
   // console.log("additionalResourcePermission in createObjectS3", JSON.stringify(additionalResourcePermission))
   return {
     templatePath: templatePath,
     templateData: {
-      resourceLocation: SOURCE_PATH.resourceLocationFlowSchemaEventBridge,
+      resourceLocation: path.join(SOURCE_PATH.resourceLocationFlowSchemaEventBridge, flowSchema.flowTag, "source/"),
       functionName,
-      action,
+      // action,
       functionNameConfig: functionNameConfig,
       additionalResourcePermission,
       roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,

package/src/reStructure/TemplateData/flowSchema/eventBridge/functionYaml/template.ejs

@@ -1,6 +1,6 @@
 <%_ const join = require('path').join; _%>
 <%- firstLetterUpperCase(functionNameConfig) %>:
-  handler: <%- join(resourceLocation, `${functionName}${action}_${firstLetterUpperCase(handlerType)}.main`)%>
+  handler: <%- join(resourceLocation, `${functionName}_${firstLetterUpperCase(handlerType)}.main`)%>
   name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionNameConfig) %>
   events:
     <%_ schedules.forEach((schedule) => { _%>
@@ -11,8 +11,8 @@
         input: <%- JSON.stringify(schedule.input) %>
     <%_ }) _%>
   role: <%- roleName %>Role
-  #<#<%- functionName %><%- action %>IamRole#>
-  #<#/<%- functionName %><%- action %>IamRole#>
+  #<#<%- functionName %>IamRole#>
+  #<#/<%- functionName %>IamRole#>
 <%_ function firstLetterUpperCase(text){
   return text.charAt(0).toUpperCase() + text.slice(1)
 } _%>

package/src/reStructure/TemplateData/flowSchema/eventBridge/handler/inv/data.js

@@ -51,22 +51,22 @@ const templatePath = path.join(__dirname, "./template.ejs")
 function data(_izContext, flowSchema, srcPath) {
   const handler = HANDLER.hdrInv;
   const flowTag = flowSchema.flowTag;
-  const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
-  const functionName = flowTag + action;
-  const fileName = `${upperCase(flowTag)}${upperCase(action)}_${upperCase(handler)}`;
+  // const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
+  const functionName = "EventBridge" + upperCase(handler);
+  // const fileName = `${upperCase(flowTag)}${upperCase(action)}_${upperCase(handler)}`;
   return [{
     templatePath: templatePath,
     templateData: {
       functionName: functionName,
       flowTag: flowTag,
-      action: action,
+      // action: action,
       handler,
-      roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,
-      firstLetterUpperCase: upperCase,
+      // roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,
+      // firstLetterUpperCase: upperCase,
     },
     setting: {
-      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaEventBridge),
-      saveFileName: fileName,
+      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaEventBridge, flowSchema.flowTag, "source/"),
+      saveFileName: `EventBridge_${upperCase(handler)}`,
       fileExtension: '.js',
       isAppend: false
     }

package/src/reStructure/TemplateData/flowSchema/eventBridge/mainFunction/data.js

@@ -32,7 +32,9 @@ const {
   consts: {
     DEFAULT_HANDLER_PER_ACTION,
     SOURCE_PATH,
-    SOURCE_GENERATE_IAM_ROLE
+    SOURCE_GENERATE_IAM_ROLE,
+    SAVE_FILE_NAME,
+    FUNCTION_NAME
   }
 } = require("../../../../../MainLibs");
 
@@ -46,23 +48,23 @@ const templatePath = path.join(__dirname, "./template.ejs")
  * @return {{ templatePath, templateData, setting } }
  */
 function data(_izContext, flowSchema, srcPath) {
-  const handler = HANDLER.hdrInv;
+  // const handler = HANDLER.hdrInv;
   const flowTag = flowSchema.flowTag;
-  const functionName = flowTag + upperCase(handler);
-  const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
-  const fileName = `${upperCase(flowTag)}${upperCase(action)}_Main`;
+  // const functionName = "EventBridge" + upperCase(handler);
+  // const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
+  // const fileName = `${upperCase(flowTag)}${upperCase(action)}_Main`;
   return [{
     templatePath: templatePath,
     templateData: {
-      functionName: functionName,
+      functionName: "EventBridge",
       flowTag: flowTag,
       roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,
-      action: action,
+      // action: action,
       firstLetterUpperCase: upperCase,
     },
     setting: {
-      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaEventBridge),
-      saveFileName: fileName,
+      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaEventBridge, flowSchema.flowTag, "source/"),
+      saveFileName: "EventBridge_Main",
       fileExtension: '.js',
       isAppend: false
     }

package/src/reStructure/TemplateData/flowSchema/eventBridge/mainFunction/template.ejs

@@ -78,9 +78,9 @@ module.exports.<%- functionName %>Main = async (
   _izContext.logger.debug('<%- functionName %> requestParams: ', requestParams);
   _izContext.logger.debug('<%- functionName %> callingFlowConfig: ', callingFlowConfig);
 
-    //(<additionalParams>)
-    //(</additionalParams>)
-    
+    //(<eventBridgeHook>)
+    //(</eventBridgeHook>)
+
   } catch (err) {
   _izContext.logger.error('error <%- firstLetterUpperCase(functionName) %>Main: ', err)
     throw (err)

package/src/reStructure/TemplateData/flowSchema/externalTopic/sns-in-sqs/data.js

@@ -32,6 +32,7 @@ const {
   FUNCTION_NAME,
   SAVE_FILE_NAME,
   SOURCE_GENERATE_IAM_ROLE,
+  HANDLER,
 } = require("../../../../../MainLibs/src/Consts");
 
 /**
@@ -45,20 +46,15 @@ const {
  */
 
 function data(_izContext, flowSchema, srcPath) {
-  const flowStepSplitKey = Object.keys(flowSchema.flowSteps)[0].split("_");
-  let queueName;
-  let queueNameSubscription;
-  if (Object.keys(flowSchema.flowSteps).length > 3) {
-    queueName = flowStepSplitKey[3] + 'Out';
-    queueNameSubscription = flowStepSplitKey[3]
-  }
-
+  const flowStepSplitKeyOut = Object.keys(flowSchema.flowSteps)[1].split("_");
+  // console.log({ flowStepSplitKey })
+  let queueName = upperCase(flowSchema.flowTag) + "ExternalTopicOut" + upperCase(HANDLER.hdrSqs)
   return [{
     templatePath,
     templateData: {
       queueName: upperCase(queueName),
-      queueNameSubscription: upperCase(queueNameSubscription),
       roleName: SOURCE_GENERATE_IAM_ROLE.ExternalTopicRole,
+      firstLetterUpperCase: upperCase
     },
     setting: {
       initialData: "Resource\n",

package/src/reStructure/TemplateData/flowSchema/externalTopic/sns-in-sqs/template.ejs

@@ -1,10 +1,4 @@
-##===== SNS Subscription
-  SubscriptionOut<%- queueNameSubscription %>:
-    Type: AWS::SNS::Subscription
-    Properties:
-      TopicArn: !Ref Out<%- queueNameSubscription %>
-      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueNameSubscription %>Out"
-      Protocol: "sqs"
+##===== ExternalTopic
 ##===== [Queue]
   <%- queueName %>:
     Type: "AWS::SQS::Queue"

package/src/reStructure/TemplateData/flowSchema/externalTopic/sns-out/data.js

@@ -33,7 +33,7 @@ const {
   SOURCE_GENERATE_IAM_ROLE
 } = require("../../../../../MainLibs/src/Consts");
 
-const templatePath = path.join(__dirname, "../../../../TemplateData/resourceYaml/sns-out/template.ejs");
+const templatePath = path.join(__dirname, "./template.ejs");
 // /ResourceYaml/sns-out/template.ejs
 // /OutPerActionComplete/OutUpdateComplete/sns-out/data.js
 
@@ -52,8 +52,7 @@ function data(_izContext, flowSchema, srcPath) {
 }
 
 function createParamsForCreateSource(_izContext, flowSchema, srcPath) {
-  const flowStepSplitKey = Object.keys(flowSchema.flowSteps)[1].split('_');
-  const queueName = flowStepSplitKey[3]
+  const queueName = upperCase(flowSchema.flowTag)
   return [
     {
       templatePath: templatePath,

package/src/reStructure/TemplateData/flowSchema/externalTopic/sns-out/template.ejs

@@ -3,8 +3,6 @@
     Type: AWS::SNS::Topic
     Properties:
       DisplayName: "SNS Message out"
-      TopicName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_<%- firstLetterUpperCase(queueName) %>_Out
+      TopicName: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(queueName) %>
 
-  <%_ function firstLetterUpperCase(text) {
-    return text.charAt(0).toUpperCase() + text.slice(1)
-  } _%>
+      <%_ function firstLetterUpperCase(text) { return text.charAt(0).toUpperCase() + text.slice(1) } _%>