@izara_project/izara-core-generate-service-code 1.0.87 → 1.0.89

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 CreateNodeCallback and Complete for Create when RBAC and Graph are present', async () => {
+test('generates CreateNodeCallback for Create when RBAC and Graph are present', async () => {
   const rootPath = await createProject({
     generatedBy: 'user',
   });
@@ -160,8 +160,14 @@ test('generates CreateNodeCallback and Complete for Create when RBAC and Graph a
   const create = await readGeneratedFlow(rootPath, 'Create');
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
-    'CreateNodeCallback',
-    'Complete'
+    'CreateNodeCallback'
+  ]);
+  assert.deepEqual(create.flowSteps[1].nextSteps, [
+    {
+      targetType: 'lambdaSyncInv',
+      serviceTag: 'Rbac',
+      functionName: 'ConfirmUsageHdrInv'
+    }
   ]);
 });
 
@@ -185,8 +191,7 @@ test('uses CreateNodeCallback step when Graph storage is present with sync RBAC'
   const create = await readGeneratedFlow(rootPath, 'Create');
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
-    'CreateNodeCallback',
-    'Complete'
+    'CreateNodeCallback'
   ]);
   assert.deepEqual(create.flowSteps[1].properties, [
     'returnValue',

package/test/dynamicRbacFlowSchemas.test.js

@@ -69,6 +69,27 @@ test('generates shared and object-specific RBAC flow schemas', async () => {
   });
   assert.deepEqual(user.event, ['ownTopic']);
   assert.equal(user.steps, undefined);
+
+  const confirmUsage = await readGeneratedFlow(
+    rootPath,
+    'ConfirmUsage',
+    'FlowLimit'
+  );
+  const cancelUsage = await readGeneratedFlow(
+    rootPath,
+    'CancelUsage',
+    'FlowLimit'
+  );
+  assert.deepEqual(confirmUsage.event, [
+    'ownTopic',
+    'lambdaSyncInv',
+    'lambdaSyncApi'
+  ]);
+  assert.deepEqual(cancelUsage.event, [
+    'ownTopic',
+    'lambdaSyncInv',
+    'lambdaSyncApi'
+  ]);
 });
 
 test('removes RBAC schemas when the last RBAC object is removed', async () => {
@@ -144,10 +165,11 @@ async function createProject({ hasRbac = false } = {}) {
   return rootPath;
 }
 
-async function readGeneratedFlow(rootPath, flowTag) {
+async function readGeneratedFlow(rootPath, flowTag, folder = 'FlowRbac') {
   const filePath = join(
     rootPath,
-    'app/src/schemas/FlowSchemas/generateCode/FlowRbac',
+    'app/src/schemas/FlowSchemas/generateCode',
+    folder,
     `${flowTag}.js`
   );
   const module = await import(

package/test/graphDrivenFlowSchema.test.js

@@ -255,3 +255,39 @@ test('validateFlowSchema rejects lambdaSyncInv nextSteps missing functionName',
     /lambdaSyncInv target requires non-empty 'functionName'/
   );
 });
+
+test('validateFlowSchema passes for mixed sync and async events with single Start step', () => {
+  const mixedSingleStepSchema = {
+    flowTag: 'ConfirmUsage',
+    event: ['ownTopic', 'lambdaSyncInv', 'lambdaSyncApi'],
+    flowSteps: [
+      {
+        stepName: 'Start'
+      }
+    ]
+  };
+
+  assert.equal(validateFlowSchema(mixedSingleStepSchema), true);
+});
+
+test('validateFlowSchema rejects flow with synchronous events having multiple flowSteps', () => {
+  const mixedMultiStepSchema = {
+    flowTag: 'ConfirmUsage',
+    event: ['ownTopic', 'lambdaSyncInv'],
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [{ targetType: 'ownTopic', stepName: 'StepTwo' }]
+      },
+      {
+        stepName: 'StepTwo',
+        previousSteps: [{ sourceType: 'ownTopic', stepName: 'Start' }]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(mixedMultiStepSchema),
+    /Flow 'ConfirmUsage' with synchronous events .* must only define a single entry step 'Start'/
+  );
+});

package/test/resourceArtifacts.test.js

@@ -76,11 +76,23 @@ test('emits queues, topics, tables, and IAM roles from schema data', async () =>
   assert.match(dynamoYaml, /OrdersTable:/);
   assert.match(dynamoYaml, /#<#OrdersTableSetting#>/);
   assert.match(dynamoYaml, /#<#\/OrdersTableSetting#>/);
-  assert.match(dynamoYaml, /RolesTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+TableName: \${self:custom\.iz_resourcePrefix}Roles/);
-  assert.match(dynamoYaml, /TargetRolesTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+AttributeName: identifiersConcat/);
+  assert.match(
+    dynamoYaml,
+    /RolesTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+TableName: \${self:custom\.iz_resourcePrefix}Roles/
+  );
+  assert.match(
+    dynamoYaml,
+    /TargetRolesTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+AttributeName: identifiersConcat/
+  );
   assert.doesNotMatch(dynamoYaml, /RoleLimitTable:/);
-  assert.match(dynamoYaml, /RunningTotalUsageTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+TableName: \${self:custom\.iz_resourcePrefix}RunningTotalUsage/);
-  assert.match(dynamoYaml, /RunningTotalReservedUsageTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+TableName: \${self:custom\.iz_resourcePrefix}RunningTotalReservedUsage/);
+  assert.match(
+    dynamoYaml,
+    /RunningTotalUsageTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+TableName: \${self:custom\.iz_resourcePrefix}RunningTotalUsage/
+  );
+  assert.match(
+    dynamoYaml,
+    /RunningTotalReservedUsageTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+TableName: \${self:custom\.iz_resourcePrefix}RunningTotalReservedUsage/
+  );
   const iam = await readFile(
     join(
       rootPath,
@@ -151,6 +163,7 @@ test('emits queues, topics, tables, and IAM roles from schema data', async () =>
   const procFindDataRole = roleBlock(iam, 'ProcFindDataRole');
   assert.match(procFindDataRole, /dynamodb:UpdateItem/);
   assert.match(procFindDataRole, /dynamodb:GetItem/);
+  assert.match(procFindDataRole, /dynamodb:PutItem/);
   assert.match(procFindDataRole, /dynamodb:Query/);
   assert.match(procFindDataRole, /sns:Publish/);
   assert.match(procFindDataRole, /FindData_Out/);
@@ -191,6 +204,38 @@ test('rejects deprecated FlowHook schemas', async () => {
   );
 });
 
+test('rejects invalid generateCodeTag configuration', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'InvalidTag.js'),
+    "export default { flowTag: 'invalidHook', event: ['ownTopic'], " +
+      "generatedCodeConfig: { generateCodeTag: ['invalidAction'], " +
+      "codeHookTag: 'before' } };\n"
+  );
+
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /generatedCodeConfig\.generateCodeTag contains invalid tag 'invalidAction'/
+  );
+});
+
+test('rejects empty generateCodeTag array configuration', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'EmptyTag.js'),
+    "export default { flowTag: 'emptyHook', event: ['ownTopic'], " +
+      "generatedCodeConfig: { generateCodeTag: [], " +
+      "codeHookTag: 'before' } };\n"
+  );
+
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /generatedCodeConfig\.generateCodeTag array must not be empty/
+  );
+});
+
 test('emits the shared WebSocket completion queue and output-topic subscriptions', async () => {
   const rootPath = await createProject();
   await generateResourceArtifacts(rootPath);
@@ -290,21 +335,21 @@ test('emits DynamoDB table with number sortKey attribute type when field type is
   const rootPath = await createProject();
   await writeFile(
     join(rootPath, 'app/src/schemas/ObjectSchemas/CartOrder.js'),
-    "export default { " +
+    'export default { ' +
       "objectType: 'cartOrder', " +
       "generatedBy: 'user', " +
-      "fieldNames: { " +
+      'fieldNames: { ' +
       "  cartId: { type: 'string' }, " +
       "  sortId: { type: 'number' } " +
-      "}, " +
-      "identifiers: [ " +
+      '}, ' +
+      'identifiers: [ ' +
       "  { type: 'partitionKey', fieldName: 'cartId' }, " +
       "  { type: 'sortKey', fieldName: 'sortId' } " +
-      "], " +
-      "storageResources: { " +
+      '], ' +
+      'storageResources: { ' +
       "  main: { storageType: 'dynamoDB', tableName: 'CartOrders' } " +
-      "} " +
-      "};\n"
+      '} ' +
+      '};\n'
   );
 
   await generateResourceArtifacts(rootPath);
@@ -369,6 +414,220 @@ test('emits CreateNodeCallbackHdrSqs in FlowObjectsRole when object has graph an
   assert.match(role, /RolePermissions/);
   assert.match(role, /ValidatorRbac_In/);
   assert.match(role, /Rbac_\$\{self:custom\.iz_stage\}_ValidatorRbac_In/);
+  assert.match(role, /ConfirmUsageHdrInv/);
+  assert.match(role, /CancelUsageHdrInv/);
+});
+
+test('emits CreateAfterHookCallbackHdrSqs in SQS resources and FlowObjectsRole when flow has after hook with ownTopic', async () => {
+  const rootPath = await createProject();
+  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"
+  );
+  await generateResourceArtifacts(rootPath);
+
+  const crudResources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-crud.yml'
+    ),
+    'utf8'
+  );
+  assert.match(crudResources, /^  CreateAfterHookCallbackHdrSqs:/m);
+  assert.match(crudResources, /^  CreateAfterHookCallbackHdrSqsDLQ:/m);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /CreateAfterHookCallbackHdrSqs/);
+  assert.match(role, /CreateAfterHookCallbackHdrSqsDLQ/);
+  assert.match(role, /NotifyAfterCreate_In/);
+});
+
+test('emits CreateBeforeHookCallbackHdrSqs in SQS resources and FlowObjectsRole when flow has before hook with ownTopic', async () => {
+  const rootPath = await createProject();
+  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 generateResourceArtifacts(rootPath);
+
+  const crudResources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-crud.yml'
+    ),
+    'utf8'
+  );
+  assert.match(crudResources, /^  CreateBeforeHookCallbackHdrSqs:/m);
+  assert.match(crudResources, /^  CreateBeforeHookCallbackHdrSqsDLQ:/m);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /CreateBeforeHookCallbackHdrSqs/);
+  assert.match(role, /CreateBeforeHookCallbackHdrSqsDLQ/);
+  assert.match(role, /ValidateBeforeCreate_In/);
+});
+
+test('emits UpdateBeforeHookCallbackHdrSqs in SQS resources and FlowObjectsRole when flow has before hook with ownTopic', async () => {
+  const rootPath = await createProject();
+  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 generateResourceArtifacts(rootPath);
+
+  const crudResources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-crud.yml'
+    ),
+    'utf8'
+  );
+  assert.match(crudResources, /^  UpdateBeforeHookCallbackHdrSqs:/m);
+  assert.match(crudResources, /^  UpdateBeforeHookCallbackHdrSqsDLQ:/m);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /UpdateBeforeHookCallbackHdrSqs/);
+  assert.match(role, /UpdateBeforeHookCallbackHdrSqsDLQ/);
+  assert.match(role, /ValidateBeforeUpdate_In/);
+});
+
+test('emits DeleteBeforeHookCallbackHdrSqs in SQS resources and FlowObjectsRole when flow has before hook with ownTopic', async () => {
+  const rootPath = await createProject();
+  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 generateResourceArtifacts(rootPath);
+
+  const crudResources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-crud.yml'
+    ),
+    'utf8'
+  );
+  assert.match(crudResources, /^  DeleteBeforeHookCallbackHdrSqs:/m);
+  assert.match(crudResources, /^  DeleteBeforeHookCallbackHdrSqsDLQ:/m);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /DeleteBeforeHookCallbackHdrSqs/);
+  assert.match(role, /DeleteBeforeHookCallbackHdrSqsDLQ/);
+  assert.match(role, /ValidateBeforeDelete_In/);
+});
+
+test('emits lambda:InvokeFunction in FlowObjectsRole when flow has before hook with lambdaSyncInv for update and delete', async () => {
+  const rootPath = await createProject();
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/CheckBeforeUpdate.js'),
+    "export default { flowTag: 'checkBeforeUpdate', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'update', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await writeFile(
+    join(schemas, 'FlowSchemas/CheckBeforeDelete.js'),
+    "export default { flowTag: 'checkBeforeDelete', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'delete', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateResourceArtifacts(rootPath);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /lambda:InvokeFunction/);
+  assert.match(role, /CheckBeforeUpdate/);
+  assert.match(role, /CheckBeforeDelete/);
+});
+
+test('emits lambda:InvokeFunction in FlowObjectsRole when flow has after hook with lambdaSyncInv', async () => {
+  const rootPath = await createProject();
+  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 generateResourceArtifacts(rootPath);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /lambda:InvokeFunction/);
+  assert.match(role, /AuditAfterCreate/);
+});
+
+test('emits SQS queues and deduplicated IAM policies when generateCodeTag is an array for multiple actions', async () => {
+  const rootPath = await createProject();
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/NotifyMultiAfter.js'),
+    "export default { flowTag: 'notifyMultiAfter', event: ['ownTopic'], " +
+      "generatedCodeConfig: { generateCodeTag: ['create', 'update'], " +
+      "codeHookTag: 'after', invocationType: 'ownTopic', " +
+      "objType: { objectType: 'order' } } };\n"
+  );
+  await generateResourceArtifacts(rootPath);
+
+  const crudResources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-crud.yml'
+    ),
+    'utf8'
+  );
+  assert.match(crudResources, /^  CreateAfterHookCallbackHdrSqs:/m);
+  assert.match(crudResources, /^  UpdateAfterHookCallbackHdrSqs:/m);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /CreateAfterHookCallbackHdrSqs/);
+  assert.match(role, /UpdateAfterHookCallbackHdrSqs/);
+
+  const notifyTopicMatches = role.match(/NotifyMultiAfter_In/g);
+  assert.strictEqual(notifyTopicMatches?.length, 1);
 });
 
 function roleBlock(iam, roleName) {