@izara_project/izara-core-generate-service-code 1.0.1 → 1.0.2

package/src/TemplateData/flowSchema/generateTemplateData.js

@@ -0,0 +1,808 @@
+/*
+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 required modules
+import { join } from 'path';
+
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+const { getAllLocalFlowSchemas } = getObjectSchema;
+// Core components
+import createWebSocketDynamoDb from './components/websocket/dynamoDb/WebSocketTaskData.js';
+import createUserUploadRecordTable from './components/websocket/dynamoDb/userUploadRecords.js';
+import createReservedDataMainTable from './components/websocket/dynamoDb/ReservedTableData.js';
+import createBucketS3 from './components/upload/relate/S3/data.js';
+import createWebSocketGenerateCodeLibs from './components/upload/relate/libs/data.js';
+import createWebSocketConnectYaml from './components/websocket/connect/functionYaml/data.js';
+import createWebSocketConnectHandler from './components/websocket/connect/handler/data.js';
+import createSnsTopicForUploadS3 from './components/upload/relate/sns-out/data.js';
+// CreateObject components
+import createFunctionYamlCreateObjectWebSocket from './components/upload/createObject/functionYaml/data.js';
+import createHandlerCreateObjectWebSocket from './components/upload/createObject/handler/data.js';
+import createMainFunctionCreateObjectWebSocket from './components/upload/createObject/mainFunction/data.js';
+
+// CreateObjectComplete components
+// import createWebSocketCreateObjectCompleteFunctionYaml  from './components/upload/createObjectComplete/functionYaml/data');
+// import createWebSocketCreateObjectCompleteQueue  from './components/upload/createObjectComplete/sns-sqs/data');
+// import createWebSocketCreateObjectCompleteHandler  from './components/upload/createObjectComplete/handler/data');
+// import createWebSocketCreateObjectCompleteMainFunction  from './components/upload/createObjectComplete/mainFunction/data');
+
+// PreSign URL components
+import createReservedLimitFunctionYaml from './components/upload/preSignUrl/reservedLimit/functionYaml/data.js';
+import createReservedLimitHandler from './components/upload/preSignUrl/reservedLimit/handler/data.js';
+import createReservedLimitMainFunction from './components/upload/preSignUrl/reservedLimit/mainFunction/data.js';
+import createReservedLimitQueueName from './components/upload/preSignUrl/reservedLimit/sqs/data.js';
+
+// Reserved limit components
+import createPresignUrlFunctionYaml from './components/upload/preSignUrl/createPresignUrl/functionYaml/data.js';
+import createPresignUrlHandler from './components/upload/preSignUrl/createPresignUrl/handler/data.js';
+import createPresignUrlMainFunction from './components/upload/preSignUrl/createPresignUrl/mainFunction/data.js';
+import createPresignUrlQueueName from './components/upload/preSignUrl/createPresignUrl/queue/data.js';
+// import createReservedLimitQueueName  from './components/upload/preSignUrl/reservedLimit/sqs/data');
+
+// Process uploaded file components
+import createProcessAfterUploadS3FunctionYmlS3 from './components/upload/processFile/functionYml/HdrS3/data.js';
+import createProcessAfterUploadS3Queue from './components/upload/processFile/queue/data.js';
+import createProcessAfterUploadS3HandlerS3 from './components/upload/processFile/handler/handlerS3/data.js';
+import createProcessAfterUploadS3MainFunction from './components/upload/processFile/mainFunction/data.js';
+
+// Confirm reservation components
+import createConfirmAfterUploadS3FunctionYaml from './components/upload/confirmReserved/functionYaml/data.js';
+import createConfirmAfterUploadS3Handler from './components/upload/confirmReserved/handler/data.js';
+import createConfirmAfterUploadS3MainFunction from './components/upload/confirmReserved/mainFunction/data.js';
+import createConfirmAfterUploadS3Queue from './components/upload/confirmReserved/queue/data.js';
+// flowSchema ExternalTopic components //
+import createExternalSqsFunctionYaml from './externalTopic/Process/functionYaml/data.js';
+import createExternalSqsHandler from './externalTopic/Process/handler/data.js';
+// import createExternalSqsCompleteFunctionYaml  from "./externalTopic/Complete/functionYaml/data.js";
+// import createExternalSqsCompleteHandler  from "./externalTopic/Complete/handler/data.js";
+// import createExternalSqsCompleteMainFunction  from "./externalTopic/Complete/mainFunction/data.js";
+import createExternalTopicSnsInSqs from './externalTopic/sns-in-sqs/data.js';
+import createExternalTopicSnsOut from './externalTopic/sns-out/data.js';
+
+import createFlowSchemaEndpointMainFunction from './flowSchemaMainFunction/data.js';
+
+// flowSchema OwnTopic component
+import createFlowSchemaOwnTopicMainFunction from './flowSchemaOwnTopic/FlowSchemaComponent/mainFunction/data.js';
+import createFlowSchemaOwnTopicFunctionYaml from './flowSchemaOwnTopic/FlowSchemaComponent/functionYaml/data.js';
+import createFlowSchemaOwnTopicHandler from './flowSchemaOwnTopic/FlowSchemaComponent/handler/data.js';
+
+// flowSchema OwnTopicComplete component
+import createWebSocketCompleteMainFunctionYaml from './webSocketComplete/functionYaml/data.js';
+import createWebSocketCompleteMainHandler from './webSocketComplete/handler/data.js';
+import createWebSocketCompleteMainMainFunction from './webSocketComplete/mainFunction/data.js';
+import createWebSocketCompleteMainSqs from './webSocketComplete/sqs/data.js';
+// flowSchema OwnTopicEndpoint component
+
+import createFlowSchemaOwnTopicEndpointFunctionYaml from './flowSchemaOwnTopic/EndpointComponent/functionYaml/data.js';
+import createFlowSchemaOwnTopicEndpointHandler from './flowSchemaOwnTopic/EndpointComponent/handler/data.js';
+
+// flowSchema OnwTopic flowStep component
+import createFlowSchemaFlowStepFunctionYaml from './flowStep/functionYaml/data.js';
+import createFlowSchemaFlowStepHandler from './flowStep/handler/data.js';
+import createFlowSchemaFlowStepMainFunction from './flowStep/mainFunction/data.js';
+import createFlowSchemaFlowStepSnsIn from './flowStep/sns-in/data.js';
+// flowSchema OwnTopicEndpointComplete component
+// import createFlowSchemaOwnTopicEndpointCompleteFuntionYaml  from './flowSchemaOwnTopic/EndpointComplete/functionYaml/data.js';
+// import createFlowSchemaOwnTopicEndpointCompleteHandler  from './flowSchemaOwnTopic/EndpointComplete/handler/data.js';
+// import createFlowSchemaOwnTopicEndpointCompleteMainFunction  from './flowSchemaOwnTopic/EndpointComplete/mainFunction/data.js';
+
+import createFlowSchemaOwnTopicQueue from './flowSchemaOwnTopic/sns-in/data.js';
+import createFlowSchemaOwnTopicSnsOut from './flowSchemaOwnTopic/sns-out/data.js';
+// flowSchema EventBridge components //
+import createFlowSchemaEventBridgeFunctionYaml from './eventBridge/functionYaml/data.js';
+import createFlowSchemaEventBridgeHandler from './eventBridge/handler/inv/data.js';
+import createFlowSchemaEventBridgeMainFunction from './eventBridge/mainFunction/data.js';
+
+// flowSchema lambdaSync components
+import createFlowSchemaLambdaSyncFunctionYamlInv from './lambdaSync/Inv/functionYaml/data.js';
+import createFlowSchemaLambdaSyncHandlerInv from './lambdaSync/Inv/handler/data.js';
+
+import createFlowSchemaLambdaSyncFunctionYamlApi from './lambdaSync/Api/functionYaml/data.js';
+import createFlowSchemaLambdaSyncHandlerApi from './lambdaSync/Api/handler/data.js';
+
+import createAwaitingMultipleStepDynamoDbData from './dynamoDb/data.js';
+// create record status Field Complete
+// import createCreateObjectCompleteFunctionYaml  from './CreateRecordComplete/functionYaml/data.js';
+// import createCreateObjectCompleteHandler  from './CreateRecordComplete/handler/data.js';
+// import createCreateObjectCompleteMainFunction  from './CreateRecordComplete/mainFunction/data.js';
+// import createCreateObjectCompleteQueue  from './CreateRecordComplete/queue/data.js';// flowSchema Register component //
+
+import createFlowSchemaRegisterHandlerComplete from './register/complete/handler/data.js';
+import createFlowSchemaRegisterMainCompleteFunc from './register/complete/mainFunction/data.js';
+import createFlowSchemaRegisterHandlerWbsFunc from './register/wbs/handler/data.js';
+import createFlowSchemaRegisterMainWbsFunc from './register/wbs/mainFunction/data.js';
+import createFlowSchemaRegisterMainCompleteFuncYaml from './register/complete/functionYaml/data.js';
+import createFlowSchemaRegisterMainWbsFuncYaml from './register/wbs/functionYaml/data.js';
+import createFlowSchemaRegisterSubscribeOutAll from './register/subscriptionOutAll/data.js';
+import createFlowSchemaRegisterSnsInSqs from './register/sns-in/data.js';
+import createFlowSchemaRegisterDynamoDb from './register/dynamoDB/register.js';
+
+import createProcessTriggerCacheYaml from './triggerCacheComponent/processTriggerCache/functionYaml/data.js';
+import createCheckTriggerCacheYaml from './triggerCacheComponent/checkTriggerCacheComplete/functionYaml/data.js';
+import createTriggerCacheCompleteYaml from './triggerCacheComponent/triggerCacheComplete/functionYaml/data.js';
+const createFlowSchemaTriggerCacheFunctionYaml = {
+  createProcessTriggerCacheYaml,
+  createCheckTriggerCacheYaml,
+  createTriggerCacheCompleteYaml
+};
+
+import createProcessTriggerCacheHandler from './triggerCacheComponent/processTriggerCache/handler/data.js';
+import createCheckTriggerCacheHandler from './triggerCacheComponent/checkTriggerCacheComplete/handler/data.js';
+import createTriggerCacheCompleteHandler from './triggerCacheComponent/triggerCacheComplete/handler/data.js';
+
+const createFlowSchemaTriggerCacheHandler = {
+  createProcessTriggerCacheHandler,
+  createCheckTriggerCacheHandler,
+  createTriggerCacheCompleteHandler
+};
+
+import createProcessTriggerCacheMainFunction from './triggerCacheComponent/processTriggerCache/mainFunction/data.js';
+import createCheckTriggerCacheMainFunction from './triggerCacheComponent/checkTriggerCacheComplete/mainFunction/data.js';
+import createTriggerCacheCompleteMainFunction from './triggerCacheComponent/triggerCacheComplete/mainFunction/data.js';
+
+const createFlowSchemaTriggerCacheMainFunction = {
+  createProcessTriggerCacheMainFunction,
+  createCheckTriggerCacheMainFunction,
+  createTriggerCacheCompleteMainFunction
+};
+import createFlowSchemaTriggerCacheQueue from './triggerCacheComponent/triggerCacheQueue/data.js';
+
+import createCompleteStatusFieldMainFunction from './statusFieldComponent/MainFunction/data.js';
+import createCompleteStatusFieldFunctionYaml from './statusFieldComponent/FunctionYaml/data.js';
+import createCompleteStatusFieldHandler from './statusFieldComponent/Handler/data.js';
+import createCompleteStatusFieldTopicAndQueue from './statusFieldComponent/sns/data.js';
+
+const createFlowSchemaStatusFieldComponent = {
+  createCompleteStatusFieldMainFunction,
+  createCompleteStatusFieldFunctionYaml,
+  createCompleteStatusFieldHandler,
+  createCompleteStatusFieldTopicAndQueue
+};
+
+/**
+ * Generates code with templates for different actions
+ * @param {Object} _izContext - Context object
+ * @param {string} objSchemaPath - Path to the schema
+ * @returns {Array} Array of generated code parameters
+ */
+async function generateCodeWithTemplate(_izContext, objSchemaPath) {
+  // console.log("objSchemaPath in flowSchema generateTemplateAndData", objSchemaPath);
+  try {
+    const saveFilePath = join(objSchemaPath, '../');
+    // console.log("saveFilePath in flowSchema generateTemplateAndData", saveFilePath)
+    let createSourceParams = [];
+    const allLocalFlowSchemas = await getAllLocalFlowSchemas(
+      _izContext,
+      objSchemaPath
+    );
+    // const allLocalObjectSchemas = await getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath);
+
+    // default webSocket setting
+    const webSocketTaskTable = createWebSocketDynamoDb(
+      _izContext,
+      saveFilePath
+    );
+    const webSocketConnectYaml = createWebSocketConnectYaml(
+      _izContext,
+      saveFilePath
+    );
+    const webSocketConnectHandler = createWebSocketConnectHandler(
+      _izContext,
+      saveFilePath
+    );
+
+    // flowSchema OwnTopic Complete component
+    const webSocketCompleteFunctionYaml =
+      createWebSocketCompleteMainFunctionYaml(
+        _izContext,
+        allLocalFlowSchemas,
+        saveFilePath
+      );
+    const webSocketCompleteHandler = createWebSocketCompleteMainHandler(
+      _izContext,
+      saveFilePath
+    );
+    const webSocketCompleteMainFunction =
+      createWebSocketCompleteMainMainFunction(_izContext, saveFilePath);
+    const webSocketCompleteSqs = createWebSocketCompleteMainSqs(
+      _izContext,
+      allLocalFlowSchemas,
+      saveFilePath
+    );
+    const webSocketCompleteComponent = [
+      ...webSocketCompleteFunctionYaml,
+      ...webSocketCompleteHandler,
+      ...webSocketCompleteMainFunction,
+      ...webSocketCompleteSqs
+    ];
+    const userUploadRecordTable = createUserUploadRecordTable(
+      _izContext,
+      saveFilePath
+    );
+
+    const webSocketResource = [
+      ...webSocketTaskTable,
+      ...webSocketConnectYaml,
+      ...webSocketConnectHandler
+    ];
+    if (allLocalFlowSchemas.records.length) {
+      createSourceParams.push(
+        ...webSocketResource,
+        ...webSocketCompleteComponent,
+        ...userUploadRecordTable
+      );
+    }
+
+    // get flowsteps out form all local object schemas
+
+    for (const flowSchema of allLocalFlowSchemas.records) {
+      // console.log("flowSchema in Generate TemplateData", flowSchema);
+      const webSocketGenerateCodeLibs = createWebSocketGenerateCodeLibs(
+        _izContext,
+        flowSchema,
+        saveFilePath
+      );
+      createSourceParams.push(...webSocketGenerateCodeLibs);
+      if (!flowSchema.event.includes('s3')) {
+        const flowSchemaEndpointMainFunction =
+          await createFlowSchemaEndpointMainFunction(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+        createSourceParams.push(...flowSchemaEndpointMainFunction);
+      }
+
+      // event has [s3, extTopic, ownTopic, eventBridge, lambdaSync]
+      for (const event of flowSchema.event) {
+        if (event.includes('s3')) {
+          const reservedDataTable = createReservedDataMainTable(
+            _izContext,
+            saveFilePath
+          );
+          const bucketS3 = createBucketS3(_izContext, flowSchema, saveFilePath);
+
+          const functionYamlCreateObjectWebSocket =
+            createFunctionYamlCreateObjectWebSocket(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const handlerCreateObjectWebSocket =
+            createHandlerCreateObjectWebSocket(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const mainFunctionCreateObjectWebSocket =
+            await createMainFunctionCreateObjectWebSocket(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          // const webSocketCreateObjectCompleteFunctionYaml = createWebSocketCreateObjectCompleteFunctionYaml(_izContext, flowSchema, saveFilePath);
+          // const webSocketCreateObjectCompleteQueue = createWebSocketCreateObjectCompleteQueue(_izContext, saveFilePath);
+          // const webSocketCreateObjectCompleteMainFunction = createWebSocketCreateObjectCompleteMainFunction(_izContext, flowSchema, saveFilePath)
+          // const webSocketCreateObjectCompleteHandler = createWebSocketCreateObjectCompleteHandler(_izContext, flowSchema, saveFilePath);
+
+          // const webSocketCreateObjectStordCache = createWebSocketCreateObjectStoredCache(_izContext, saveFilePath);
+
+          const reservedLimitFunctionYaml =
+            await createReservedLimitFunctionYaml(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const reservedLimitHandlerFunction = createReservedLimitHandler(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const reservedLimitMainFunction =
+            await createReservedLimitMainFunction(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const reservedLimitQueueName = createReservedLimitQueueName(
+            _izContext,
+            saveFilePath
+          );
+
+          const presignUrlFunctionYaml = createPresignUrlFunctionYaml(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const presignUrlMainFunction = createPresignUrlMainFunction(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const presignUrlHandlerFunction = createPresignUrlHandler(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const presignUrlQueueName = createPresignUrlQueueName(
+            _izContext,
+            saveFilePath
+          );
+
+          const processAfterUploadFunctionYmlS3 =
+            createProcessAfterUploadS3FunctionYmlS3(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          // const processAfterUploadFunctionYamlHdrDsq = createProcessAfterUploadS3FunctionYmlDsq(_izContext, saveFilePath);
+          // const processAfterUploadSqs = createProcessAfterUploadS3Queue(_izContext, saveFilePath);
+          const processAfterUploadHandlerS3 =
+            createProcessAfterUploadS3HandlerS3(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          // const processAfterUploadHandlerDsq = createProcessAfterUploadS3HandlerDsq(_izContext, saveFilePath);
+          const processAfterUploadMainFunction =
+            createProcessAfterUploadS3MainFunction(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+
+          const confirmReservedAfterUploadFunctionYaml =
+            createConfirmAfterUploadS3FunctionYaml(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const confirmReservedAfterUploadHandler =
+            createConfirmAfterUploadS3Handler(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const confirmReservedAfterUploadMainFunction =
+            createConfirmAfterUploadS3MainFunction(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const confirmReservedAfterUploadQueue =
+            createConfirmAfterUploadS3Queue(_izContext, saveFilePath);
+
+          const snsTopicOutFlowSchemaUploadS3 = createSnsTopicForUploadS3(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+
+          const webSocketFunctions = [
+            ...functionYamlCreateObjectWebSocket,
+            ...handlerCreateObjectWebSocket,
+            ...mainFunctionCreateObjectWebSocket
+            // ...webSocketCreateObjectCompleteFunctionYaml,
+            // ...webSocketCreateObjectCompleteQueue,
+            // ...webSocketCreateObjectCompleteMainFunction,
+            // ...webSocketCreateObjectCompleteHandler
+          ];
+
+          const getPreSignUrlResources = [
+            ...reservedLimitFunctionYaml,
+            ...reservedLimitHandlerFunction,
+            ...reservedLimitMainFunction,
+            ...reservedLimitQueueName
+          ];
+
+          const reservedLimitResources = [
+            ...presignUrlFunctionYaml,
+            ...presignUrlHandlerFunction,
+            ...presignUrlMainFunction,
+            ...presignUrlQueueName
+          ];
+
+          const processAfterUploadResources = [
+            ...processAfterUploadFunctionYmlS3,
+            // ...processAfterUploadSqs,
+            ...processAfterUploadHandlerS3,
+            ...processAfterUploadMainFunction
+            // Commented resources kept for reference
+            // ...processAfterUploadHandlerDsq,
+            // ...processAfterUploadFunctionYamlHdrDsq
+          ];
+
+          const confirmAfterUploadResources = [
+            ...confirmReservedAfterUploadFunctionYaml,
+            ...confirmReservedAfterUploadHandler,
+            ...confirmReservedAfterUploadMainFunction,
+            ...confirmReservedAfterUploadQueue
+          ];
+
+          const webSocketUploadS3Resources = [
+            ...webSocketFunctions,
+            ...reservedDataTable,
+            ...bucketS3
+          ];
+          console.log('event s3 generated');
+
+          createSourceParams.push(
+            ...webSocketUploadS3Resources,
+            ...getPreSignUrlResources,
+            ...reservedLimitResources,
+            ...processAfterUploadResources,
+            ...confirmAfterUploadResources,
+            ...snsTopicOutFlowSchemaUploadS3
+          );
+        } else if (event.includes('extTopic')) {
+          // ** External Topic ** //
+          const externalSqsFunctionYaml = await createExternalSqsFunctionYaml(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const externalSqsHandler = await createExternalSqsHandler(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          // const externalSqsMainFunction = await createExternalSqsMainFunction(_izContext, flowSchema, saveFilePath);
+          const externalTopicSnsInSqs = createExternalTopicSnsInSqs(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const externalTopicSnsOut = createExternalTopicSnsOut(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+
+          // const externalTopicCompleteFunctionYml = createExternalSqsCompleteFunctionYaml(_izContext, flowSchema, saveFilePath);
+          // const externalTopicCompleteHandler = createExternalSqsCompleteHandler(_izContext, flowSchema, saveFilePath);
+          // const externalTopicCompleteMainFunction = createExternalSqsCompleteMainFunction(_izContext, flowSchema, saveFilePath);
+          // Group related resources for better organization
+          const externalTopic = [
+            ...externalSqsFunctionYaml,
+            ...externalSqsHandler,
+            // ...externalSqsMainFunction,
+            ...externalTopicSnsInSqs,
+            ...externalTopicSnsOut
+            // ...externalTopicCompleteFunctionYml, ...externalTopicCompleteHandler, ...externalTopicCompleteMainFunction
+          ];
+
+          createSourceParams.push(...externalTopic);
+          console.log('flowSchema external topic generated');
+        } else if (event.includes('ownTopic')) {
+          // flowSchema OwnTopic components
+          const flowSchemaOwnTopicFunctionYaml =
+            createFlowSchemaOwnTopicFunctionYaml(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaOwnTopicHandler = createFlowSchemaOwnTopicHandler(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const flowSchemaOwnTopicMainFunction =
+            await createFlowSchemaOwnTopicMainFunction(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaOwnTopicComponent = [
+            ...flowSchemaOwnTopicFunctionYaml,
+            ...flowSchemaOwnTopicHandler,
+            ...flowSchemaOwnTopicMainFunction
+          ];
+
+          // flowSchemaOwnTopic Endpoint
+          const flowSchemaOwnTopicEndpointFunctionYaml =
+            await createFlowSchemaOwnTopicEndpointFunctionYaml(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaOwnTopicEndpointHandler =
+            createFlowSchemaOwnTopicEndpointHandler(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaOwnTopicEndpointComponent = [
+            ...flowSchemaOwnTopicEndpointFunctionYaml,
+            ...flowSchemaOwnTopicEndpointHandler
+          ];
+
+          // flowSchemaOwnTopic EndpointComplete
+          // const flowSchemaOwnTopicEndpointCompleteFuntionYaml = createFlowSchemaOwnTopicEndpointCompleteFuntionYaml(_izContext, flowSchema, saveFilePath);
+          // const flowSchemaOwnTopicEndpointCompleteHandler = createFlowSchemaOwnTopicEndpointCompleteHandler(_izContext, flowSchema, saveFilePath);
+          // const flowSchemaOwnTopicEndpointCompleteMainFunction = createFlowSchemaOwnTopicEndpointCompleteMainFunction(_izContext, flowSchema, saveFilePath);
+          // const flowSchemaOwnTopicEndpointCompleteComponent = [...flowSchemaOwnTopicEndpointCompleteFuntionYaml, ...flowSchemaOwnTopicEndpointCompleteHandler, ...flowSchemaOwnTopicEndpointCompleteMainFunction];
+
+          const flowSchemaOwnTopicQueue = createFlowSchemaOwnTopicQueue(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+          const flowSchemaOwnTopicSnsOut = createFlowSchemaOwnTopicSnsOut(
+            _izContext,
+            flowSchema,
+            saveFilePath
+          );
+
+          // Group the resources
+          const ownTopicResources = [
+            ...flowSchemaOwnTopicComponent,
+            ...flowSchemaOwnTopicEndpointComponent,
+            ...flowSchemaOwnTopicQueue,
+            ...flowSchemaOwnTopicSnsOut /*...flowSchemaOwnTopicEndpointCompleteComponent */
+          ];
+
+          console.log('event ownTopic generated');
+          createSourceParams.push(...ownTopicResources);
+          if (flowSchema.statusType === 'statusField') {
+            if (
+              (flowSchema.outputTopic === true &&
+                flowSchema.event.includes('ownTopic')) ||
+              flowSchema.event.includes('extTopic')
+            ) {
+              const statusFieldComponent = (
+                await Promise.all(
+                  Object.entries(createFlowSchemaStatusFieldComponent).map(
+                    ([type, functionYaml]) =>
+                      functionYaml(_izContext, flowSchema, saveFilePath)
+                  )
+                )
+              ).flat();
+              // console.log("statusFieldComponent", JSON.stringify(statusFieldComponent, null, 2))
+              createSourceParams.push(...statusFieldComponent);
+            }
+          }
+        } else if (event.includes('eventBridge')) {
+          const flowSchemaEventBridgeHandler =
+            createFlowSchemaEventBridgeHandler(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaEventBridgeMainFunction =
+            createFlowSchemaEventBridgeMainFunction(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaEventBridgeFunctionYaml =
+            createFlowSchemaEventBridgeFunctionYaml(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+
+          // Group the resources
+          const eventBridgeResources = [
+            ...flowSchemaEventBridgeHandler,
+            ...flowSchemaEventBridgeMainFunction,
+            ...flowSchemaEventBridgeFunctionYaml
+          ];
+
+          // console.log("event eventBridge generated", JSON.stringify(eventBridgeResources, null, 2))
+          console.log('event eventBridge generated');
+          createSourceParams.push(...eventBridgeResources);
+        } else if (event.includes('lambdaSyncInv')) {
+          const flowSchemaLambdaSyncFunctionYamlInv =
+            createFlowSchemaLambdaSyncFunctionYamlInv(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaLambdaSyncHandlerInv =
+            createFlowSchemaLambdaSyncHandlerInv(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          // const flowSchemaLambdaSyncMainFunctionInv = createFlowSchemaLambdaSyncMainFunctionInv(_izContext, flowSchema, saveFilePath);
+
+          // Group the resources
+          const lambdaSyncInvResources = [
+            flowSchemaLambdaSyncFunctionYamlInv,
+            flowSchemaLambdaSyncHandlerInv
+            // flowSchemaLambdaSyncMainFunctionInv,
+          ];
+
+          console.log('event lambdaSyncInv generated');
+          createSourceParams.push(...lambdaSyncInvResources);
+        } else if (event.includes('lambdaSyncApi')) {
+          const flowSchemaLambdaSyncFunctionYamlApi =
+            createFlowSchemaLambdaSyncFunctionYamlApi(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+          const flowSchemaLambdaSyncHandlerApi =
+            createFlowSchemaLambdaSyncHandlerApi(
+              _izContext,
+              flowSchema,
+              saveFilePath
+            );
+
+          const lambdaSyncApiResources = [
+            flowSchemaLambdaSyncFunctionYamlApi,
+            flowSchemaLambdaSyncHandlerApi
+          ];
+          createSourceParams.push(...lambdaSyncApiResources);
+          console.log('event lambdaSyncApi generated');
+        }
+      }
+
+      // statusType enum [storedCache, statusField]
+      // if (flowSchema.statusType === "storedCache") {
+      // const flowSchemaDynamoDb = createAwaitingMultipleStepDynamoDbData(_izContext, flowSchema, allLocalObjectSchemas, saveFilePath)
+      // console.log("generated code storedCache flowSchema")
+      // createSourceParams.push(...flowSchemaDynamoDb);
+      // } else if (flowSchema.statusType === "statusField") {
+      // wait
+
+      // if (flowSchema.statusType === "statusField") {
+      //   const createRecordCompleteFunctionYaml = createCreateObjectCompleteFuntionYaml(_izContext, flowSchema, saveFilePath);
+      //   const createRecordCompleteHandler = createCreateObjectCompleteHandler(_izContext, flowSchema, saveFilePath);
+      //   const createRecordCompleteMainFunction = createCreateObjectCompleteMainFunction(_izContext, flowSchema, saveFilePath);
+      //   const createRecordCompleteQueue = createCreateObjectCompleteQueue(_izContext, flowSchema, saveFilePath);
+
+      //   const recordCompleteResources = [
+      //     ...createRecordCompleteFunctionYaml,
+      //     ...createRecordCompleteHandler,
+      //     ...createRecordCompleteMainFunction,
+      //     ...createRecordCompleteQueue
+      //   ];
+      //   console.log("generated Code createRecordComplete")
+      //   createSourceParams.push(...recordCompleteResources);
+      // }
+      // }
+      const flowSchemaFlowStepYml = createFlowSchemaFlowStepFunctionYaml(
+        _izContext,
+        flowSchema,
+        saveFilePath
+      );
+      const flowSchemaFlowStepHandler = createFlowSchemaFlowStepHandler(
+        _izContext,
+        flowSchema,
+        saveFilePath
+      );
+      const flowSchemaFlowStepMainFunction =
+        createFlowSchemaFlowStepMainFunction(
+          _izContext,
+          flowSchema,
+          saveFilePath
+        );
+      const flowSchemaFlowStepSnsIn = createFlowSchemaFlowStepSnsIn(
+        _izContext,
+        flowSchema,
+        saveFilePath
+      );
+      const flowSchemaOwnTopicFlowStep = [
+        ...flowSchemaFlowStepYml,
+        ...flowSchemaFlowStepHandler,
+        ...flowSchemaFlowStepMainFunction,
+        ...flowSchemaFlowStepSnsIn
+      ];
+      createSourceParams.push(...flowSchemaOwnTopicFlowStep);
+
+      if (flowSchema.statusType === 'triggerCache') {
+        const functionYaml = (
+          await Promise.all(
+            Object.entries(createFlowSchemaTriggerCacheFunctionYaml).map(
+              ([type, functionYaml]) =>
+                functionYaml(_izContext, flowSchema, saveFilePath)
+            )
+          )
+        ).flat();
+        const mainFunction = Object.entries(
+          createFlowSchemaTriggerCacheMainFunction
+        ).flatMap(([type, mainFunction]) =>
+          mainFunction(_izContext, flowSchema, saveFilePath)
+        );
+        const handler = Object.entries(
+          createFlowSchemaTriggerCacheHandler
+        ).flatMap(([type, handler]) =>
+          handler(_izContext, flowSchema, saveFilePath)
+        );
+        const queue = createFlowSchemaTriggerCacheQueue(
+          _izContext,
+          flowSchema,
+          saveFilePath
+        );
+        // console.log("functionYaml", JSON.stringify(...functionYaml, null, 2))
+        createSourceParams.push(
+          ...functionYaml,
+          ...mainFunction,
+          ...handler,
+          ...queue
+        );
+        // console.log("Generate triggerCache component")
+      }
+    }
+
+    if (allLocalFlowSchemas.records.length) {
+      console.log('flowSchema Register');
+      const flowSchemaRegisterHandlerComplete =
+        createFlowSchemaRegisterHandlerComplete(_izContext, saveFilePath);
+      const flowSchemaRegisterMainComplete =
+        await createFlowSchemaRegisterMainCompleteFunc(
+          _izContext,
+          allLocalFlowSchemas,
+          saveFilePath
+        );
+      const flowSchemaRegisterHandlerWbs =
+        createFlowSchemaRegisterHandlerWbsFunc(_izContext, saveFilePath);
+      const flowSchemaRegisterMainWbs = createFlowSchemaRegisterMainWbsFunc(
+        _izContext,
+        saveFilePath
+      );
+      const flowSchemaRegisterFunctionYamlComplete =
+        createFlowSchemaRegisterMainCompleteFuncYaml(_izContext, saveFilePath);
+      const flowSchemaRegisterFunctionYamlWbs =
+        await createFlowSchemaRegisterMainWbsFuncYaml(
+          _izContext,
+          allLocalFlowSchemas,
+          saveFilePath
+        );
+      const flowSchemaRegisterSubscribeOutAll =
+        createFlowSchemaRegisterSubscribeOutAll(
+          _izContext,
+          allLocalFlowSchemas,
+          saveFilePath
+        );
+      const flowSchemaRegisterSnsInSqs = createFlowSchemaRegisterSnsInSqs(
+        _izContext,
+        saveFilePath
+      );
+
+      const flowSchemaRegisterDynamoDb = createFlowSchemaRegisterDynamoDb(
+        _izContext,
+        saveFilePath
+      );
+
+      const flowSchemaRegisters = [
+        ...flowSchemaRegisterHandlerComplete,
+        ...flowSchemaRegisterMainComplete,
+        ...flowSchemaRegisterHandlerWbs,
+        ...flowSchemaRegisterMainWbs,
+        ...flowSchemaRegisterFunctionYamlComplete,
+        ...flowSchemaRegisterFunctionYamlWbs,
+        ...flowSchemaRegisterSnsInSqs,
+        ...flowSchemaRegisterSubscribeOutAll,
+        ...flowSchemaRegisterDynamoDb
+      ];
+      createSourceParams.push(...flowSchemaRegisters);
+    }
+
+    // console.log("createSourceParams flowSchema", createSourceParams)
+    return createSourceParams;
+  } catch (error) {
+    _izContext.logger.error(
+      'Error generating code with template flowSchema:',
+      error
+    );
+    return [];
+  }
+}
+
+export default generateCodeWithTemplate;