@izara_project/izara-core-generate-service-code 1.0.78 → 1.0.79

package/test/customFlowApplicationArtifacts.test.js

@@ -13,6 +13,7 @@ import { dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import test, { after } from 'node:test';
 
+import { generate } from '../src/generate.js';
 import { generateCustomFlowApplicationArtifacts } from '../src/emit/custom/generateCustomFlowApplicationArtifacts.js';
 import { generateResourceArtifacts } from '../src/emit/resource/generateResourceArtifacts.js';
 import { renderEventBridgeFunctionYaml } from '../src/emit/function/functionYamlArtifact.js';
@@ -107,16 +108,15 @@ test('emits handlers, function YAML, and IAM roles for supported custom flow eve
     ),
     /Own_Main/
   );
-  assert.match(
-    await readFile(
-      join(
-        rootPath,
-        'app/src/generatedCode/FlowSchemas/Own/source/Own_Main.js'
-      ),
-      'utf8'
+  const ownMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/Own/source/Own_Main.js'
     ),
-    /asyncFlowSharedLib/
+    'utf8'
   );
+  assert.match(ownMain, /asyncFlowSharedLib/);
+  assert.match(ownMain, /callingFlowConfig = {},\s*\/\/\(<additionalParams>\)/);
   assert.match(
     await readFile(
       join(
@@ -302,15 +302,17 @@ test('emits and removes ext-topic handlers declared by custom flow steps', async
         'app/src/generatedCode/FlowSchemas/DsqStep/source/DsqStepRetryDsq_HdrDsq.js'
     )
   );
-  assert.match(
-    await readFile(
-      join(
-        rootPath,
-        'app/src/generatedCode/FlowSchemas/Stepped/source/SteppedComplete_Main.js'
-      ),
-      'utf8'
+  const steppedCompleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/Stepped/source/SteppedComplete_Main.js'
     ),
-    /identifierUuid/
+    'utf8'
+  );
+  assert.match(steppedCompleteMain, /identifierUuid/);
+  assert.match(
+    steppedCompleteMain,
+    /callingFlowConfig = {},\s*\/\/\(<additionalParams>\)/
   );
   assert.match(
     await readFile(
@@ -819,3 +821,293 @@ test('renders nextSteps IAM permissions in InitialSetupConfig', async () => {
   );
 });
 
+test('registers SQS queue, SNS subscription, and SNS out topic for custom flowSchema with outputTopic set to true', async () => {
+  const { generate } = await import('../src/generate.js');
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-outputtopic-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+
+  await writeFile(
+    join(schemaRoot, 'MyCustomFlow.js'),
+    `export default [
+      {
+        flowTag: 'MyCustomFlow',
+        initiateBy: 'user',
+        handleObj: 'one',
+        statusType: 'none',
+        objType: {
+          objectType: 'myObj',
+          serviceTag: 'TST'
+        },
+        event: ['ownTopic'],
+        outputTopic: true
+      }
+    ];\n`
+  );
+
+  const result = await generate(rootPath, {
+    serviceTag: 'TestService'
+  });
+  assert.ok(result);
+
+  const snsInSqs = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'
+    ),
+    'utf8'
+  );
+  assert.match(snsInSqs, /^  MyCustomFlowCompleteHdrSqs:/m);
+
+  const snsOut = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-out.yml'
+    ),
+    'utf8'
+  );
+  assert.match(snsOut, /^\s*OutMyCustomFlow:/m);
+  assert.match(snsOut, /MyCustomFlow_Out/);
+
+  const initialSetupConfigContent = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/CoreFunctions/InitialSetupConfig.js'
+    ),
+    'utf8'
+  );
+  assert.match(initialSetupConfigContent, /serviceTag: 'TST'/);
+  assert.match(initialSetupConfigContent, /topicName: 'MyCustomFlow_Out'/);
+  assert.match(
+    initialSetupConfigContent,
+    /sqsEndpoint: 'MyCustomFlowCompleteHdrSqs'/
+  );
+});
+
+test('renders RBAC Validator subscriptions in InitialSetupConfig when object has belongTo to external RBAC service', async () => {
+  const rootPath = await createProject();
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Member.js'),
+    `export default {
+      objectType: 'member',
+      belongTo: {
+        objectType: 'user',
+        serviceTag: 'UserAccount'
+      }
+    };\n`
+  );
+
+  const result = await generate(rootPath, {
+    serviceTag: 'MembershipService'
+  });
+  assert.ok(result);
+
+  const initialSetupConfigContent = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/CoreFunctions/InitialSetupConfig.js'
+    ),
+    'utf8'
+  );
+  assert.match(initialSetupConfigContent, /serviceTag: 'UserAccount'/);
+  assert.match(initialSetupConfigContent, /topicName: 'ValidatorRbac_Out'/);
+  assert.match(initialSetupConfigContent, /sqsEndpoint: 'CreateCompleteHdrSqs'/);
+  assert.match(initialSetupConfigContent, /sqsEndpoint: 'UpdateCompleteHdrSqs'/);
+  assert.match(initialSetupConfigContent, /sqsEndpoint: 'DeleteCompleteHdrSqs'/);
+});
+
+test('deduplicates duplicate nextSteps topics across flowSteps in InitialSetupConfig', async () => {
+  const { generate } = await import('../src/generate.js');
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-dedupe-nextsteps-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+
+  await writeFile(
+    join(schemaRoot, 'DuplicateTopicFlow.js'),
+    `export default {
+      flowTag: 'DuplicateTopicFlow',
+      event: ['ownTopic'],
+      flowSteps: [
+        {
+          stepName: 'StepOne',
+          nextSteps: [
+            {
+              targetType: 'extTopic',
+              serviceTag: 'GraphHandler',
+              topic: 'GetDeepPathSearch_In'
+            },
+            {
+              targetType: 'lambdaSyncInv',
+              serviceTag: 'SharedService',
+              functionName: 'ValidateSomething'
+            }
+          ]
+        },
+        {
+          stepName: 'StepTwo',
+          event: ['extTopic'],
+          nextSteps: [
+            {
+              targetType: 'extTopic',
+              serviceTag: 'GraphHandler',
+              topic: 'GetDeepPathSearch_In'
+            },
+            {
+              targetType: 'lambdaSyncInv',
+              serviceTag: 'SharedService',
+              functionName: 'ValidateSomething'
+            }
+          ]
+        }
+      ]
+    };\n`
+  );
+
+  const result = await generate(rootPath, {
+    serviceTag: 'DuplicateTestService'
+  });
+  assert.ok(result);
+
+  const initialSetupConfigContent = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/CoreFunctions/InitialSetupConfig.js'
+    ),
+    'utf8'
+  );
+
+  const snsMatches = initialSetupConfigContent.match(
+    /GetDeepPathSearch_In/g
+  );
+  assert.equal(
+    snsMatches?.length,
+    1,
+    'SNS topic GetDeepPathSearch_In should appear exactly once in externalLambdaRole'
+  );
+
+  const lambdaMatches = initialSetupConfigContent.match(
+    /ValidateSomething/g
+  );
+  assert.equal(
+    lambdaMatches?.length,
+    1,
+    'Lambda function ValidateSomething should appear exactly once in externalLambdaRole'
+  );
+
+  assert.doesNotMatch(
+    initialSetupConfigContent,
+    /<#|#>/,
+    'InitialSetupConfig.js should not contain invalid <#...#> hook tags'
+  );
+  assert.match(
+    initialSetupConfigContent,
+    /\/\/\(<InitialSetupConfig_ExternalServices>\)/
+  );
+  assert.match(
+    initialSetupConfigContent,
+    /\/\/\(<\/InitialSetupConfig_ExternalServices>\)/
+  );
+  assert.match(
+    initialSetupConfigContent,
+    /\/\/\(<InitialSetupConfig_Prod_Config_TableConfig>\)/
+  );
+  assert.match(
+    initialSetupConfigContent,
+    /\/\/\(<InitialSetupConfig_Test_Config_TableConfig>\)/
+  );
+});
+
+test('renders multi-type array for mixed property and messageAttribute type in handler validator schema', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-mixed-type-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+
+  await writeFile(
+    join(schemaRoot, 'MixedFlow.js'),
+    `export default {
+      flowTag: 'MixedFlow',
+      event: ['ownTopic', 'lambdaSyncApi', 'lambdaSyncInv', 'dsq'],
+      stepProperties: {
+        payload: { propertyName: 'payload', type: 'mixed' }
+      },
+      stepMessageAttributes: {
+        attr: { propertyName: 'attr', type: 'mixed' }
+      },
+      flowSteps: [
+        {
+          stepName: 'Start',
+          properties: ['payload'],
+          messageAttributes: ['attr']
+        }
+      ]
+    };\n`
+  );
+
+  const result = await generateCustomFlowApplicationArtifacts(rootPath);
+  assert.ok(result);
+
+  const sqsHdr = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/MixedFlow/source/MixedFlow_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    sqsHdr,
+    /payload:\s*\{\s*type:\s*\['string',\s*'number',\s*'integer',\s*'boolean',\s*'null',\s*'object',\s*'array'\]/
+  );
+  assert.match(
+    sqsHdr,
+    /Value:\s*\{\s*type:\s*\['string',\s*'number',\s*'integer',\s*'boolean',\s*'null',\s*'object',\s*'array'\]/
+  );
+
+  const apiHdr = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/MixedFlow/source/MixedFlow_HdrApi.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    apiHdr,
+    /payload:\s*\{\s*type:\s*\['string',\s*'number',\s*'integer',\s*'boolean',\s*'null',\s*'object',\s*'array'\]/
+  );
+
+  const invHdr = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/MixedFlow/source/MixedFlow_HdrInv.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    invHdr,
+    /payload:\s*\{\s*type:\s*\['string',\s*'number',\s*'integer',\s*'boolean',\s*'null',\s*'object',\s*'array'\]/
+  );
+
+  const dsqHdr = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/MixedFlow/source/MixedFlow_HdrDsq.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    dsqHdr,
+    /payload:\s*\{\s*type:\s*\['string',\s*'number',\s*'integer',\s*'boolean',\s*'null',\s*'object',\s*'array'\]/
+  );
+  assert.match(
+    dsqHdr,
+    /Value:\s*\{\s*type:\s*\['string',\s*'number',\s*'integer',\s*'boolean',\s*'null',\s*'object',\s*'array'\]/
+  );
+});

package/test/dynamicCrudFlowSchemas.test.js

@@ -9,8 +9,7 @@ import { generateDynamicCrudFlowSchemas } from '../src/emit/crud/generateDynamic
 
 test('generates dynamic CRUD schemas from local schema modules', async () => {
   const rootPath = await createProject({
-    generatedBy: 'userGenerated',
-    flow: createHookFlow(['ownTopic'])
+    generatedBy: 'userGenerated'
   });
 
   const result = await generateDynamicCrudFlowSchemas(rootPath);
@@ -29,7 +28,7 @@ test('generates dynamic CRUD schemas from local schema modules', async () => {
   assert.deepEqual(create.event, ['ownTopic']);
   assert.deepEqual(
     create.flowSteps.map((step) => step.stepName),
-    ['start', 'BeforeLogical', 'Complete']
+    ['Start', 'Complete']
   );
   assert.deepEqual(create.flowSteps[0].returnValues.messageAttributes, [
     'userId',
@@ -43,7 +42,6 @@ test('generates dynamic CRUD schemas from local schema modules', async () => {
 test('accepts singleton object exports used by existing schema files', async () => {
   const rootPath = await createProject({
     generatedBy: 'userGenerated',
-    flow: createHookFlow(['ownTopic']),
     singletonExports: true
   });
 
@@ -54,7 +52,7 @@ test('accepts singleton object exports used by existing schema files', async ()
     (await readGeneratedFlow(rootPath, 'Create')).flowSteps.map(
       (step) => step.stepName
     ),
-    ['start', 'BeforeLogical', 'Complete']
+    ['Start', 'Complete']
   );
 });
 
@@ -101,25 +99,163 @@ test('rejects source modules that do not default-export schema objects or arrays
   );
 });
 
-test('reloads changed local flow schemas instead of reusing module cache', async () => {
+test('rejects deprecated FlowHook schemas before generating CRUD schemas', async () => {
   const rootPath = await createProject({
     generatedBy: 'systemGenerated',
     flow: createHookFlow(['ownTopic'])
   });
-  const flowPath = join(rootPath, 'app/src/schemas/FlowSchemas/CreateHook.js');
+
+  await assert.rejects(
+    generateDynamicCrudFlowSchemas(rootPath),
+    /generatedCodeConfig\.codeHookTag is no longer supported/
+  );
+});
+
+test('generates a direct Complete step for RBAC-only Update flows', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-crud-rbac-')
+  );
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(
+    join(objectDirectory, 'Order.js'),
+    `export default [{
+      objectType: 'order',
+      generatedBy: 'userGenerated',
+      belongTo: { serviceTag: 'UserAccount', objectType: 'user' }
+    }];\n`
+  );
 
   await generateDynamicCrudFlowSchemas(rootPath);
-  assert.match(await readGeneratedFile(rootPath, 'Create'), /BeforeLogical/);
+  const update = await readGeneratedFlow(rootPath, 'Update');
+  assert.deepEqual(
+    update.flowSteps.map((step) => step.stepName),
+    ['Start', 'Complete']
+  );
+  assert.deepEqual(update.flowSteps[0].nextSteps, [
+    { targetType: 'ownTopic', stepName: 'Complete' }
+  ]);
+  assert.deepEqual(update.flowSteps[1].previousSteps, [
+    { sourceType: 'ownTopic', stepName: 'Start' }
+  ]);
+  assert.equal(update.flowSteps[1].properties.length, 0);
+});
 
+test('ignores RBAC for Create even when Graph storage is present', async () => {
+  const rootPath = await createProject({
+    generatedBy: 'userGenerated',
+  });
   await writeFile(
-    flowPath,
-    `export default [${JSON.stringify(createHookFlow([]))}];\n`
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'),
+    `export default [{
+      objectType: 'order',
+      generatedBy: 'userGenerated',
+      belongTo: { serviceTag: 'UserAccount', objectType: 'user' }
+      , storageResources: { graph: { storageType: 'graph' } }
+    }];\n`
   );
+
   await generateDynamicCrudFlowSchemas(rootPath);
-  assert.doesNotMatch(
-    await readGeneratedFile(rootPath, 'Create'),
-    /BeforeLogical/
+  const create = await readGeneratedFlow(rootPath, 'Create');
+  assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
+    'Start',
+    'Complete'
+  ]);
+});
+
+test('uses the renamed RBAC callback step when Graph storage is present', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-crud-rbac-graph-')
+  );
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(
+    join(objectDirectory, 'Order.js'),
+    `export default [{
+      objectType: 'order',
+      generatedBy: 'userGenerated',
+      belongTo: { serviceTag: 'UserAccount', objectType: 'user' },
+      storageResources: { graph: { storageType: 'graph' } }
+    }];\n`
+  );
+
+  await generateDynamicCrudFlowSchemas(rootPath);
+  const create = await readGeneratedFlow(rootPath, 'Create');
+  assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
+    'Start',
+    'Complete'
+  ]);
+  assert.deepEqual(create.flowSteps[1].properties, [
+    'returnValue',
+    'parentFlowId',
+    'status',
+    'errorsFound',
+    'graphServiceTag'
+  ]);
+});
+
+test('chains RbacCallback and Complete for Update with RBAC and Graph', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-crud-update-rbac-graph-')
+  );
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(
+    join(objectDirectory, 'Order.js'),
+    `export default [{
+      objectType: 'order',
+      generatedBy: 'userGenerated',
+      belongTo: { serviceTag: 'UserAccount', objectType: 'user' },
+      storageResources: { graph: { storageType: 'graph' } }
+    }];\n`
+  );
+
+  await generateDynamicCrudFlowSchemas(rootPath);
+  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' }
+  ]);
+  assert.deepEqual(update.flowSteps[1].nextSteps, [
+    { targetType: 'ownTopic', stepName: 'Complete' }
+  ]);
+  assert.deepEqual(update.flowSteps[2].properties, [
+    'returnValue',
+    'parentFlowId',
+    'status',
+    'errorsFound',
+    'graphServiceTag'
+  ]);
+});
+
+test('omits Complete step when no graph storage resources exist', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-crud-no-graph-')
+  );
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(
+    join(objectDirectory, 'Order.js'),
+    `export default [{
+      objectType: 'order',
+      generatedBy: 'userGenerated',
+      storageResources: {
+        myTable: { storageType: 'dynamoDB', tableName: 'OrderTable' }
+      }
+    }];\n`
+  );
+
+  await generateDynamicCrudFlowSchemas(rootPath);
+  const create = await readGeneratedFlow(rootPath, 'Create');
+  assert.deepEqual(
+    create.flowSteps.map((step) => step.stepName),
+    ['Start']
   );
+  assert.equal(create.flowSteps[0].nextSteps, undefined);
 });
 
 async function createProject({ generatedBy, flow, singletonExports = false }) {
@@ -134,7 +270,7 @@ async function createProject({ generatedBy, flow, singletonExports = false }) {
   await mkdir(join(rootPath, 'app/src/schemas/FlowSchemas'), {
     recursive: true
   });
-  const object = `{ objectType: 'order', generatedBy: '${generatedBy}' }`;
+  const object = `{ objectType: 'order', generatedBy: '${generatedBy}', storageResources: { graph: { storageType: 'graph' } } }`;
   await writeFile(
     objectPath,
     `export default ${singletonExports ? object : `[${object}]`};\n`

package/test/dynamicRbacFlowSchemas.test.js

@@ -42,14 +42,14 @@ test('generates shared and object-specific RBAC flow schemas', async () => {
         (action) =>
           `app/src/schemas/FlowSchemas/generateCode/FlowRbac/${action}.js`
       ),
-      'app/src/schemas/FlowSchemas/generateCode/FlowRbac/UserRbacFlow.js'
+      'app/src/schemas/FlowSchemas/generateCode/FlowRbac/ValidatorRbac.js'
     ]
   );
   const createTargetRole = await readGeneratedFlow(
     rootPath,
     'CreateTargetRole'
   );
-  const user = await readGeneratedFlow(rootPath, 'UserRbacFlow');
+  const user = await readGeneratedFlow(rootPath, 'ValidatorRbac');
   assert.deepEqual(createTargetRole.flowSteps[0].returnValues, {
     properties: ['returnResult'],
     messageAttributes: []

package/test/dynamicRelationshipFlowSchemas.test.js

@@ -54,7 +54,7 @@ test('generates dynamic relationship schemas when declared relationships exist',
   assert.deepEqual(create.event, ['ownTopic']);
   assert.deepEqual(
     create.flowSteps.map((step) => step.stepName),
-    ['start', 'Complete']
+    ['Start', 'Complete']
   );
   assert.deepEqual(create.flowSteps[0].returnValues.messageAttributes, [
     'userId',