@izara_project/izara-core-generate-service-code 1.0.54 → 1.0.56

package/src/codeGenerators/resource/sls_yaml/templates/SystemDynamoDB_Yaml.ejs

@@ -136,3 +136,67 @@ Resources:
         KeyType: HASH
       - AttributeName: pendingStepId
         KeyType: RANGE
+
+  TargetRolesTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}TargetRoles
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: targetId
+        AttributeType: S
+      - AttributeName: roleIdKey
+        AttributeType: S
+      KeySchema:
+      - AttributeName: targetId
+        KeyType: HASH
+      - AttributeName: roleIdKey
+        KeyType: RANGE
+
+  RolePermissionsTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}RolePermissions
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: roleIdKey
+        AttributeType: S
+      - AttributeName: flowTypeConcat
+        AttributeType: S
+      KeySchema:
+      - AttributeName: roleIdKey
+        KeyType: HASH
+      - AttributeName: flowTypeConcat
+        KeyType: RANGE
+
+  RoleUsersTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}RoleUsers
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: roleIdKey
+        AttributeType: S
+      - AttributeName: userId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: roleIdKey
+        KeyType: HASH
+      - AttributeName: userId
+        KeyType: RANGE
+
+  UserRolesTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}UserRoles
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: userId
+        AttributeType: S
+      - AttributeName: roleIdKey
+        AttributeType: S
+      KeySchema:
+      - AttributeName: userId
+        KeyType: HASH
+      - AttributeName: roleIdKey
+        KeyType: RANGE

package/src/codeGenerators/resource/sls_yaml/templates/crud/ResourceYaml.ejs

@@ -10,30 +10,30 @@
     Type: AWS::SNS::Subscription
     Properties:
       TopicArn: !Ref In<%- queueName %>
-      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>Sqs"
+      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqs"
       Protocol: "sqs"
 
   ##===== [Queue]
-  <%- queueName %>Sqs:
+  <%- queueName %>HdrSqs:
     Type: "AWS::SQS::Queue"
     Properties:
-      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>Sqs
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqs
       RedrivePolicy:
         deadLetterTargetArn:
           Fn::GetAtt:
-            - <%- queueName %>SqsDLQ
+            - <%- queueName %>HdrSqsDLQ
             - Arn
         maxReceiveCount: 3
       VisibilityTimeout: 120
 
   ##===== [Queue DLQ]
-  <%- queueName %>SqsDLQ:
+  <%- queueName %>HdrSqsDLQ:
     Type: AWS::SQS::Queue
     Properties:
-      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>SqsDLQ
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqsDLQ
 
   ##===== [Queue Policy]
-  <%- queueName %>SqsPolicy:
+  <%- queueName %>HdrSqsPolicy:
     Type: AWS::SQS::QueuePolicy
     Properties:
       PolicyDocument:
@@ -44,11 +44,11 @@
             Principal: "*"
             Resource:
               Fn::GetAtt:
-                - <%- queueName %>Sqs
+                - <%- queueName %>HdrSqs
                 - Arn
             Action: "SQS:SendMessage"
       Queues:
-        - Ref: <%- queueName %>Sqs
+        - Ref: <%- queueName %>HdrSqs
 
   #<#<%- queueName %>QueueSetting#>
-  #<#/<%- queueName %>QueueSetting#>
+  #<#/<%- queueName %>QueueSetting#>

package/src/generate.js

@@ -52,7 +52,7 @@ async function generate(rootPath, options = {}) {
 
   // Auto-generate dynamic schemas before validation (unless skipped)
   if (!skipGenerateSchema) {
-    await generateSchema(rootPath, { outputPath });
+    await generateSchema(rootPath, { outputPath, configPath });
   }
 
   // Validate schemas before generating (unless skipped)

package/src/generateCode.js

@@ -5,17 +5,15 @@ import { parseObjectSchemas } from './parsers/objectSchemaParser.js';
 import { parseRelationshipSchemas } from './parsers/relationshipSchemaParser.js';
 import { parseFlowSchemas } from './parsers/flowSchemaParser.js';
 
-
-
 import { generateFlowEntryPoint } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowEntryPointBase.js';
 import { generateFlowMainFunction } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowMainFunctionBase.js';
 import { generateFlowSteps } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowStepBase.js';
 
-import { generateEndpointsFlow } from './codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/EndpointsGenerator.js';
+import { generateEndpointsFlow } from './codeGenerators/app/src/generatedCode/Flow/FlowObjects/EndpointsGenerator.js';
 import { generateFlowOut } from './codeGenerators/resource/sls_yaml/FlowOutGenerator.js';
 import { generateFlowResourceYaml } from './codeGenerators/resource/sls_yaml/FlowResourceYamlGenerator.js';
 import { generateRbacFlows } from './codeGenerators/app/src/generatedCode/Flow/FlowRbac/RbacFlowGenerator.js';
-import { generateRelationshipFlows } from './codeGenerators/app/src/generatedCode/Flow/FlowRelationshipEndpoints/RelationshipFlowGenerator.js';
+import { generateRelationshipFlows } from './codeGenerators/app/src/generatedCode/Flow/FlowRelationships/RelationshipFlowGenerator.js';
 import { generateWebSocket } from './codeGenerators/app/src/generatedCode/Flow/FlowSchemas/WebSocketGenerator.js';
 import { validateFlowsForGeneration } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowValidator.js';
 import { generateRegisterFlow } from './codeGenerators/app/src/generatedCode/SystemFlowSchemas/RegisterGenerator.js';
@@ -33,86 +31,107 @@ import { generateFindDataYaml } from './codeGenerators/app/sls_yaml/FindDataYaml
 import { policyRegistry } from './codeGenerators/app/sls_yaml/_policy/PolicyRegistry.js';
 import { emitManagedPolicies } from './codeGenerators/app/sls_yaml/_policy/PolicyEmitter.js';
 
-export async function generateCode(rootPath, options) {
+function createGeneratorOptions(rootPath, options = {}) {
+  return {
+    outputPath: options.outputPath || rootPath
+  };
+}
+
+export async function generateCode(rootPath, options = {}) {
   console.log(
     '[INFO] [generateCode] STATUS=STARTING | Generating code files from all schemas...'
   );
 
+  const generatorOptions = createGeneratorOptions(rootPath, options);
+  const { outputPath } = generatorOptions;
+
   // Clean workspace
-  const outputPath = options.outputPath || rootPath;
-  const generatedCodePath = path.join(outputPath, 'app', 'src', 'generatedCode');
+  const generatedCodePath = path.join(
+    outputPath,
+    'app',
+    'src',
+    'generatedCode'
+  );
 
   // Backup existing hook files to prevent them from being wiped out
- const hookBackups = [];
- const hookDirs = new Set();
- 
- function getHookTagMatchers(filePath) {
-   if (filePath.endsWith('.js')) {
-     return {
-       anyTag: /\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)/gm,
-       tagPattern: (name) => new RegExp(
-         `\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`,
-         'gm'
-       )
-     };
-   }
- 
-   if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
-     return {
-       anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
-       tagPattern: (name) => new RegExp(
-         `#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`,
-         'gm'
-       )
-     };
-   }
- 
-   return null;
- }
- 
- function mergeHookIntoSource(sourceContent, hookContent, filePath) {
-   const matchers = getHookTagMatchers(filePath);
-   if (!matchers) return hookContent;
- 
-   return sourceContent.replace(matchers.anyTag, (match, tagName) => (
-     hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
-   ));
- }
- 
- function collectHookBackups(currentDir) {
-   if (!fs.existsSync(currentDir)) return;
- 
-   const items = fs.readdirSync(currentDir, { withFileTypes: true });
-   const hasSource = items.some((item) => item.isDirectory() && item.name === 'source');
-   const hasHook = items.some((item) => item.isDirectory() && item.name === 'hook');
- 
-   if (hasSource && hasHook) {
-     const hookPath = path.join(currentDir, 'hook');
-     hookDirs.add(path.relative(outputPath, hookPath));
-     const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
- 
-     for (const hookItem of hookItems) {
-       if (!hookItem.isFile()) continue;
-       const hookFilePath = path.join(hookPath, hookItem.name);
-       hookBackups.push({
-         relativePath: path.relative(outputPath, hookPath),
-         name: hookItem.name,
-         content: fs.readFileSync(hookFilePath)
-       });
-     }
-   }
- 
-   for (const item of items) {
-     if (!item.isDirectory() || item.name === 'source' || item.name === 'hook') continue;
-     collectHookBackups(path.join(currentDir, item.name));
-   }
- }
- 
- console.log('[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...');
- collectHookBackups(outputPath);
-
-console.log(
-    '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode and resource directories...'
+  const hookBackups = [];
+  const hookDirs = new Set();
+
+  function getHookTagMatchers(filePath) {
+    if (filePath.endsWith('.js')) {
+      return {
+        anyTag: /\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)/gm,
+        tagPattern: name =>
+          new RegExp(
+            `\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`,
+            'gm'
+          )
+      };
+    }
+
+    if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+      return {
+        anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
+        tagPattern: name =>
+          new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
+      };
+    }
+
+    return null;
+  }
+
+  function mergeHookIntoSource(sourceContent, hookContent, filePath) {
+    const matchers = getHookTagMatchers(filePath);
+    if (!matchers) return hookContent;
+
+    return sourceContent.replace(
+      matchers.anyTag,
+      (match, tagName) =>
+        hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
+    );
+  }
+
+  function collectHookBackups(currentDir) {
+    if (!fs.existsSync(currentDir)) return;
+
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+    const hasSource = items.some(
+      item => item.isDirectory() && item.name === 'source'
+    );
+    const hasHook = items.some(
+      item => item.isDirectory() && item.name === 'hook'
+    );
+
+    if (hasSource && hasHook) {
+      const hookPath = path.join(currentDir, 'hook');
+      hookDirs.add(path.relative(outputPath, hookPath));
+      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
+
+      for (const hookItem of hookItems) {
+        if (!hookItem.isFile()) continue;
+        const hookFilePath = path.join(hookPath, hookItem.name);
+        hookBackups.push({
+          relativePath: path.relative(outputPath, hookPath),
+          name: hookItem.name,
+          content: fs.readFileSync(hookFilePath)
+        });
+      }
+    }
+
+    for (const item of items) {
+      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
+        continue;
+      collectHookBackups(path.join(currentDir, item.name));
+    }
+  }
+
+  console.log(
+    '[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...'
+  );
+  collectHookBackups(outputPath);
+
+  console.log(
+    '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode directories...'
   );
   await fs.promises.rm(generatedCodePath, {
     recursive: true,
@@ -122,10 +141,10 @@ console.log(
     path.join(outputPath, 'app', 'sls_yaml', 'generatedCode'),
     { recursive: true, force: true }
   );
-  await fs.promises.rm(path.join(outputPath, 'resource'), {
-    recursive: true,
-    force: true
-  });
+  await fs.promises.rm(
+    path.join(outputPath, 'resource', 'sls_yaml', 'generatedCode'),
+    { recursive: true, force: true }
+  );
 
   policyRegistry.clear();
 
@@ -150,8 +169,6 @@ console.log(
   console.log('[INFO] [generateCode] STATUS=VALIDATING | Validating Flows...');
   validateFlowsForGeneration(allSchemas.flowsForGeneration);
 
-  const generatorOptions = { outputPath: options.outputPath || rootPath };
-
   // 2. Generation Pipeline
   await generateEndpointsFlow(allSchemas, generatorOptions);
   await generateFlowMainFunction(allSchemas, generatorOptions);
@@ -161,11 +178,19 @@ console.log(
   await generateFlowResourceYaml(allSchemas, generatorOptions);
   await generateRbacFlows(allSchemas, generatorOptions);
   await generateRelationshipFlows(allSchemas, generatorOptions);
-  await generateWebSocket(allSchemas.flowsForGeneration, '', generatorOptions.outputPath);
-  await generateRegisterFlow(allSchemas.flowsForGeneration, '', generatorOptions.outputPath);
+  await generateWebSocket(
+    allSchemas.flowsForGeneration,
+    '',
+    generatorOptions.outputPath
+  );
+  await generateRegisterFlow(
+    allSchemas.flowsForGeneration,
+    '',
+    generatorOptions.outputPath
+  );
 
   // Call FunctionYamlGenerator after all Handlers have been generated
-  await generateFunctionYaml(allSchemas, options);
+  await generateFunctionYaml(allSchemas, generatorOptions);
   await generateDynamoDBTables(allSchemas, generatorOptions);
   await generateFindData(allSchemas, generatorOptions);
   await generateCodeLibs(generatorOptions);
@@ -178,69 +203,76 @@ console.log(
   await generateInitialSetup(allSchemas, generatorOptions);
 
   // 3. Hook Integration
- console.log(
-   '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
- );
- 
- function processSourceHooks(currentDir) {
-   if (!fs.existsSync(currentDir)) return;
- 
-   const items = fs.readdirSync(currentDir, { withFileTypes: true });
-   const hasSource = items.some((item) => item.isDirectory() && item.name === 'source');
-   const hasHook = items.some((item) => item.isDirectory() && item.name === 'hook');
-
-   if (hasSource && hasHook) {
-     const sourcePath = path.join(currentDir, 'source');
-     const hookPath = path.join(currentDir, 'hook');
-     const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
- 
-     for (const hookItem of hookItems) {
-       if (!hookItem.isFile()) continue;
- 
-       const hookFile = path.join(hookPath, hookItem.name);
-       const sourceFile = path.join(sourcePath, hookItem.name);
- 
-       if (!fs.existsSync(sourceFile)) {
-         fs.copyFileSync(hookFile, sourceFile);
-         console.log(
-           `[INFO] [generateCode] HOOK APPLIED: Created ${hookItem.name} from hook.`
-         );
-         continue;
-       }
- 
-       const mergedContent = mergeHookIntoSource(
-         fs.readFileSync(sourceFile, 'utf8'),
-         fs.readFileSync(hookFile, 'utf8'),
-         sourceFile
-       );
-       fs.writeFileSync(sourceFile, mergedContent);
-       console.log(
-         `[INFO] [generateCode] HOOK APPLIED: Merged ${hookItem.name} into source.`
-       );
-     }
-   } else if (hasSource) {
-     fs.mkdirSync(path.join(currentDir, 'hook'), { recursive: true });
-   }
- 
-   for (const item of items) {
-     if (!item.isDirectory() || item.name === 'source' || item.name === 'hook') continue;
-     processSourceHooks(path.join(currentDir, item.name));
-   }
- }
- 
- // Restore backed-up hooks
- if (hookDirs.size > 0 || hookBackups.length > 0) {
-   console.log(`[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`);
-   for (const relativeHookDir of hookDirs) {
-     fs.mkdirSync(path.join(outputPath, relativeHookDir), { recursive: true });
-   }
-   for (const backup of hookBackups) {
-     const hookDir = path.join(outputPath, backup.relativePath);
-     fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
-   }
- }
- 
- processSourceHooks(generatorOptions.outputPath);
+  console.log(
+    '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
+  );
+
+  function processSourceHooks(currentDir) {
+    if (!fs.existsSync(currentDir)) return;
+
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+    const hasSource = items.some(
+      item => item.isDirectory() && item.name === 'source'
+    );
+    const hasHook = items.some(
+      item => item.isDirectory() && item.name === 'hook'
+    );
+
+    if (hasSource && hasHook) {
+      const sourcePath = path.join(currentDir, 'source');
+      const hookPath = path.join(currentDir, 'hook');
+      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
+
+      for (const hookItem of hookItems) {
+        if (!hookItem.isFile()) continue;
+
+        const hookFile = path.join(hookPath, hookItem.name);
+        const sourceFile = path.join(sourcePath, hookItem.name);
+
+        if (!fs.existsSync(sourceFile)) {
+          fs.copyFileSync(hookFile, sourceFile);
+          console.log(
+            `[INFO] [generateCode] HOOK APPLIED: Created ${hookItem.name} from hook.`
+          );
+          continue;
+        }
+
+        const mergedContent = mergeHookIntoSource(
+          fs.readFileSync(sourceFile, 'utf8'),
+          fs.readFileSync(hookFile, 'utf8'),
+          sourceFile
+        );
+        fs.writeFileSync(sourceFile, mergedContent);
+        console.log(
+          `[INFO] [generateCode] HOOK APPLIED: Merged ${hookItem.name} into source.`
+        );
+      }
+    } else if (hasSource) {
+      fs.mkdirSync(path.join(currentDir, 'hook'), { recursive: true });
+    }
+
+    for (const item of items) {
+      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
+        continue;
+      processSourceHooks(path.join(currentDir, item.name));
+    }
+  }
+
+  // Restore backed-up hooks
+  if (hookDirs.size > 0 || hookBackups.length > 0) {
+    console.log(
+      `[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`
+    );
+    for (const relativeHookDir of hookDirs) {
+      fs.mkdirSync(path.join(outputPath, relativeHookDir), { recursive: true });
+    }
+    for (const backup of hookBackups) {
+      const hookDir = path.join(outputPath, backup.relativePath);
+      fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
+    }
+  }
+
+  processSourceHooks(generatorOptions.outputPath);
 
   console.log(
     '[INFO] [generateCode] STATUS=FINISHED | Code generation complete.'

package/src/generateSchema.js

@@ -21,7 +21,7 @@ export async function generateSchema(rootPath, options) {
   );
 
   // Parse service config to get serviceTag
-  const configPath = path.join(rootPath, 'config', 'serverless.config.yml');
+  const configPath = options?.configPath || path.join(rootPath, 'config', 'serverless.config.yml');
   let serviceTag = 'unknownService';
   try {
     const serviceConfigStr = fs.readFileSync(configPath, 'utf8');

package/src/schemaGenerators/app/src/schemas/FlowSchemas/FlowSchemaGenerator.js

@@ -41,7 +41,6 @@ export async function generateDynamicFlowSchemas(
     return;
   }
 
-  // Validate event types in custom flow schemas
   const validMainEvents = [
     'ownTopic',
     'extTopic',

package/src/schemaGenerators/app/src/schemas/FlowSchemas/RbacFlowSchemaGenerator.js

@@ -61,8 +61,8 @@ export async function generateRbacFlowSchemas(hydratedObjectData, options) {
 
     for (const def of rbacFlowDefinitions) {
       const flowTag = def.flowTag;
-      // Use the old naming convention: {objectType}{flowTag}Flow.js
-      const filePath = path.join(schemasOutputDir, `${objectType}${flowTag}Flow.js`);
+      // Use flowTag as filename directly
+      const filePath = path.join(schemasOutputDir, `${flowTag}.js`);
 
       const eventsArrayStr = JSON.stringify(def.eventNames).replace(/"/g, "'");
 
@@ -76,6 +76,20 @@ export async function generateRbacFlowSchemas(hydratedObjectData, options) {
       await fs.writeFile(filePath, fileContent, 'utf-8');
       generatedCount++;
     }
+
+    // Generate specific UserRbacFlow
+    const userRbacFlowTag = `${objectType.charAt(0).toUpperCase() + objectType.slice(1)}RbacFlow`;
+    const userRbacFilePath = path.join(schemasOutputDir, `${userRbacFlowTag}.js`);
+    const userRbacTemplatePath = path.join(__dirname, 'templates', 'UserRbacFlowSchemaTemplate.ejs');
+    const userRbacTemplateString = await fs.readFile(userRbacTemplatePath, 'utf-8');
+    const userRbacContent = ejs.render(userRbacTemplateString, {
+      flowTag: userRbacFlowTag,
+      serviceTag: options.serviceTag,
+      objectType: objectType
+    });
+    
+    await fs.writeFile(userRbacFilePath, userRbacContent, 'utf-8');
+    generatedCount++;
   }
 
   console.log(

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/DynamicFlowSchemaTemplate.ejs

@@ -23,7 +23,8 @@ export default {
     },
     <% if (hasBeforeLogicalStep) { %>
     {
-      stepName: 'beforeLogical',
+      stepName: 'BeforeLogical',
+      event: ['sqs'],
       properties: [],
       messageAttributes: ['userId', 'correlationId']
     },
@@ -31,6 +32,7 @@ export default {
     <% if (['Create', 'Update', 'Delete'].includes(action)) { %>
     {
       stepName: 'Complete',
+      event: ['sqs'],
       properties: [],
       messageAttributes: ['userId', 'correlationId']
     }

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/DynamicRbacFlowSchemaTemplate.ejs

@@ -5,6 +5,7 @@
  */
 export default {
   flowTag: '<%= flowTag %>',
+  fileName: 'flow-rbac',
   initiateBy: 'system',
   statusType: 'none',
   event: <%- events %>,

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/RelationshipFlowSchemaTemplate.ejs

@@ -22,11 +22,12 @@ export default {
       messageAttributes: ['userId', 'correlationId']
     }
     <% if (hasCompleteStep) { %>,
-    {
-      stepName: 'Complete',
-      properties: [],
-      messageAttributes: ['userId', 'correlationId']
-    }
+  {
+    stepName: 'Complete',
+    event: ['sqs'],
+    properties: [],
+    messageAttributes: ['userId', 'correlationId']
+  }
     <% } %>
   ]
 };

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/UserRbacFlowSchemaTemplate.ejs

@@ -0,0 +1,22 @@
+export default {
+  flowTag: '<%= flowTag %>',
+  fileName: 'flow-rbac',
+  objType: {
+    serviceTag: '<%= serviceTag %>',
+    objectType: '<%= objectType %>'
+  },
+  event: ['lambdaSyncInv'],
+  initiateBy: 'system',
+  handleObj: 'one',
+  statusType: 'none',
+  stepMessageAttributes: {
+    userId: { propertyName: 'x-correlation-base-user-id', type: 'string' },
+    correlationId: { propertyName: 'x-correlation-id', type: 'string' }
+  },
+  steps: [
+    {
+      stepName: 'InTag',
+      messageAttributes: ['userId', 'correlationId']
+    }
+  ]
+};