@izara_project/izara-core-generate-service-code 1.0.86 → 1.0.88

package/test/crudApplicationArtifacts.test.js

@@ -42,6 +42,10 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
       'utf8'
     );
   assert.match(createMain, /CreateLogicalLib/);
+  assert.match(
+    createMain,
+    /validateFieldNames\(_izContext, requestParams, objectSchemas, errorsFound\)/
+  );
   assert.doesNotMatch(createMain, /FlowHook|beforeLogical|codeHookTag/);
   const yaml = await readFile(
     join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
@@ -239,7 +243,7 @@ test('emits a single Complete RBAC handler for Update without Graph', async () =
   );
 });
 
-test('emits RbacCallback and Complete handlers for Update with Graph', async () => {
+test('emits Complete handlers and inlines sync RBAC for Update with Graph', async () => {
   const rootPath = await createRbacProject(false, true);
   const result = await generateCrudApplicationArtifacts(rootPath, {
     serviceTag: 'orders'
@@ -248,19 +252,25 @@ test('emits RbacCallback and Complete handlers for Update with Graph', async ()
     .map((file) => file.path)
     .filter((path) => path.includes('/FlowObjects/Update/source/'));
 
-  assert.ok(updatePaths.includes(
+  assert.ok(!updatePaths.includes(
     'app/src/generatedCode/FlowObjects/Update/source/UpdateRbacCallback_Main.js'
   ));
   assert.ok(updatePaths.includes(
     'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
   ));
+  const updateMainContent = await readFile(
+    join(rootPath, 'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'),
+    'utf8'
+  );
+  assert.match(updateMainContent, /checkRbacPermission/);
+  assert.match(updateMainContent, /sync: true/);
   execFileSync(
     process.execPath,
     [
       '--check',
       join(
         rootPath,
-        'app/src/generatedCode/FlowObjects/Update/source/UpdateRbacCallback_Main.js'
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
       )
     ],
     { stdio: 'inherit' }
@@ -411,6 +421,533 @@ test('emits targetIdentifiers passed directly to checkRbacPermission options in
   assert.match(deleteMain, /checkRbacPermission\([\s\S]*targetIdentifiers,[\s\S]*rbacObjType/);
 });
 
+test('emits synchronous after-hook invocation in CreateLogicalLib when codeHookTag is after and invocationType is lambdaSyncInv', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/AuditAfterCreate.js'),
+    "export default { flowTag: 'auditAfterCreate', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'after', invocationType: 'lambdaSyncInv', objType: { objectType: 'order' } } };\n"
+  );
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    createLogicalLib,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'auditAfterCreate'\s*\)/
+  );
+  assert.match(createLogicalLib, /Hook auditAfterCreate failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+
+  assert.ok(result.files.every((f) => !f.path.includes('CreateAfterHookCallback')));
+});
+
+test('emits synchronous after-hook invocation in CreateNodeCallback_Main when object has graph and hook is sync', async () => {
+  const rootPath = await createRbacProject(false, true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/AuditAfterCreate.js'),
+    "export default { flowTag: 'auditAfterCreate', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'after', invocationType: 'lambdaSyncInv', objType: { objectType: 'order' } } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const nodeCallbackMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateNodeCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    nodeCallbackMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'auditAfterCreate'\s*\)/
+  );
+  assert.match(nodeCallbackMain, /Hook auditAfterCreate failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateNodeCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits async after-hook callback and SNS publish in CreateLogicalLib and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/NotifyAfterCreate.js'),
+    "export default { flowTag: 'notifyAfterCreate', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'after', invocationType: 'ownTopic', objType: { objectType: 'order' } } };\n"
+  );
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  assert.match(createLogicalLib, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    createLogicalLib,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'notifyAfterCreate_In'\s*\)/
+  );
+  assert.match(createLogicalLib, /CreateAfterHookCallbackHdrSqs/);
+
+  const afterHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    afterHookMain,
+    /export default async function CreateAfterHookCallbackMain/
+  );
+  assert.match(
+    afterHookMain,
+    /TOPIC_NAME_GENERATE_CODE\.outCreateNodeComplete/
+  );
+
+  const afterHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(afterHookHdrSqs, /CreateAfterHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+
+  const yaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
+    'utf8'
+  );
+  assert.match(yaml, /CreateAfterHookCallbackHdrSqs:/);
+  assert.match(yaml, /CreateAfterHookCallback_HdrSqs\.main/);
+});
+
+test('emits async before-hook callback and SNS publish in Create_Main and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeCreate.js'),
+    "export default { flowTag: 'validateBeforeCreate', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'before', invocationType: 'ownTopic' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(createMain, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    createMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'validateBeforeCreate_In'\s*\)/
+  );
+  assert.match(createMain, /CreateBeforeHookCallbackHdrSqs/);
+
+  const beforeHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    beforeHookMain,
+    /export default async function CreateBeforeHookCallbackMain/
+  );
+  assert.match(beforeHookMain, /CreateLogicalLib/);
+
+  const beforeHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(beforeHookHdrSqs, /CreateBeforeHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits sync before-hook in Create_Main with abort check', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeCreateSync.js'),
+    "export default { flowTag: 'validateBeforeCreateSync', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    createMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'validateBeforeCreateSync'\s*\)/
+  );
+  assert.match(createMain, /Hook validateBeforeCreateSync failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits async before-hook callback and SNS publish in Update_Main and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeUpdate.js'),
+    "export default { flowTag: 'validateBeforeUpdate', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'update', codeHookTag: 'before', invocationType: 'ownTopic' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const updateMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(updateMain, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    updateMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'validateBeforeUpdate_In'\s*\)/
+  );
+  assert.match(updateMain, /UpdateBeforeHookCallbackHdrSqs/);
+
+  const beforeHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    beforeHookMain,
+    /export default async function UpdateBeforeHookCallbackMain/
+  );
+  assert.match(beforeHookMain, /UpdateLogicalLib/);
+  assert.match(beforeHookMain, /handleUpdateError/);
+
+  const beforeHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(beforeHookHdrSqs, /UpdateBeforeHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits sync before-hook in Update_Main with abort check', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeUpdateSync.js'),
+    "export default { flowTag: 'validateBeforeUpdateSync', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'update', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const updateMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    updateMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'validateBeforeUpdateSync'\s*\)/
+  );
+  assert.match(updateMain, /Hook validateBeforeUpdateSync failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits async before-hook callback and SNS publish in Delete_Main and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeDelete.js'),
+    "export default { flowTag: 'validateBeforeDelete', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'delete', codeHookTag: 'before', invocationType: 'ownTopic' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const deleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(deleteMain, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    deleteMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'validateBeforeDelete_In'\s*\)/
+  );
+  assert.match(deleteMain, /DeleteBeforeHookCallbackHdrSqs/);
+
+  const beforeHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    beforeHookMain,
+    /export default async function DeleteBeforeHookCallbackMain/
+  );
+  assert.match(beforeHookMain, /DeleteLogicalLib/);
+  assert.match(beforeHookMain, /handleDeleteError/);
+
+  const beforeHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(beforeHookHdrSqs, /DeleteBeforeHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits sync before-hook in Delete_Main with abort check', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeDeleteSync.js'),
+    "export default { flowTag: 'validateBeforeDeleteSync', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'delete', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const deleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    deleteMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'validateBeforeDeleteSync'\s*\)/
+  );
+  assert.match(deleteMain, /Hook validateBeforeDeleteSync failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
 async function createProject(withCrudObject) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-application-')

package/test/customFlowApplicationArtifacts.test.js

@@ -895,7 +895,7 @@ test('registers SQS queue, SNS subscription, and SNS out topic for custom flowSc
   );
 });
 
-test('renders RBAC Validator subscriptions in InitialSetupConfig when object has belongTo to external RBAC service', async () => {
+test('uses synchronous RBAC without obsolete callback SQS subscriptions in InitialSetupConfig', async () => {
   const rootPath = await createProject();
   await writeFile(
     join(rootPath, 'app/src/schemas/ObjectSchemas/Member.js'),
@@ -920,10 +920,8 @@ test('renders RBAC Validator subscriptions in InitialSetupConfig when object has
     ),
     'utf8'
   );
-  assert.match(initialSetupConfigContent, /serviceTag: 'UserAccount'/);
-  assert.match(initialSetupConfigContent, /topicName: 'ValidatorRbac_Out'/);
-  assert.match(initialSetupConfigContent, /sqsEndpoint: 'UpdateRbacCallbackHdrSqs'/);
-  assert.match(initialSetupConfigContent, /sqsEndpoint: 'DeleteRbacCallbackHdrSqs'/);
+  assert.doesNotMatch(initialSetupConfigContent, /sqsEndpoint: 'UpdateRbacCallbackHdrSqs'/);
+  assert.doesNotMatch(initialSetupConfigContent, /sqsEndpoint: 'DeleteRbacCallbackHdrSqs'/);
 });
 
 test('deduplicates duplicate nextSteps topics across flowSteps in InitialSetupConfig', async () => {

package/test/dynamicCrudFlowSchemas.test.js

@@ -142,7 +142,7 @@ test('generates a direct Complete step for RBAC-only Update flows', async () =>
   assert.equal(update.flowSteps[1].properties.length, 0);
 });
 
-test('generates RbacCallback and Complete for Create when RBAC and Graph are present', async () => {
+test('generates CreateNodeCallback and Complete for Create when RBAC and Graph are present', async () => {
   const rootPath = await createProject({
     generatedBy: 'user',
   });
@@ -160,13 +160,12 @@ test('generates RbacCallback and Complete for Create when RBAC and Graph are pre
   const create = await readGeneratedFlow(rootPath, 'Create');
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
-    'RbacCallback',
     'CreateNodeCallback',
     'Complete'
   ]);
 });
 
-test('uses the renamed RBAC callback step when Graph storage is present', async () => {
+test('uses CreateNodeCallback step when Graph storage is present with sync RBAC', async () => {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-rbac-graph-')
   );
@@ -186,11 +185,10 @@ test('uses the renamed RBAC callback step when Graph storage is present', async
   const create = await readGeneratedFlow(rootPath, 'Create');
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
-    'RbacCallback',
     'CreateNodeCallback',
     'Complete'
   ]);
-  assert.deepEqual(create.flowSteps[2].properties, [
+  assert.deepEqual(create.flowSteps[1].properties, [
     'returnValue',
     'parentFlowId',
     'status',
@@ -199,7 +197,7 @@ test('uses the renamed RBAC callback step when Graph storage is present', async
   ]);
 });
 
-test('chains RbacCallback and Complete for Update with RBAC and Graph', async () => {
+test('chains Start and Complete for Update with RBAC and Graph', async () => {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-update-rbac-graph-')
   );
@@ -219,19 +217,9 @@ test('chains RbacCallback and Complete for Update with RBAC and Graph', async ()
   const update = await readGeneratedFlow(rootPath, 'Update');
   assert.deepEqual(update.flowSteps.map((step) => step.stepName), [
     'Start',
-    'RbacCallback',
     'Complete'
   ]);
   assert.deepEqual(update.flowSteps[0].nextSteps, [
-    { targetType: 'ownTopic', stepName: 'RbacCallback' },
-    {
-      targetType: 'extTopic',
-      serviceTag: 'Rbac',
-      topicName: 'ValidatorRbac_In',
-      toStepNames: ['RbacCallback']
-    }
-  ]);
-  assert.deepEqual(update.flowSteps[1].nextSteps, [
     { targetType: 'ownTopic', stepName: 'Complete' },
     {
       targetType: 'extTopic',
@@ -240,7 +228,7 @@ test('chains RbacCallback and Complete for Update with RBAC and Graph', async ()
       toStepNames: ['Complete']
     }
   ]);
-  assert.deepEqual(update.flowSteps[2].properties, [
+  assert.deepEqual(update.flowSteps[1].properties, [
     'returnValue',
     'parentFlowId',
     'status',

package/test/dynamicRbacFlowSchemas.test.js

@@ -24,9 +24,6 @@ const STATIC_RBAC_ACTIONS = [
 ];
 
 const STATIC_LIMIT_ACTIONS = [
-  'CreateRoleLimit',
-  'ListRoleLimits',
-  'DeleteRoleLimit',
   'ReservedDynamicUsage',
   'ConfirmUsage',
   'CancelUsage'