@izara_project/izara-core-generate-service-code 1.0.97 → 1.0.99

package/test/unit/application/createTargetRoleHandler.test.js

@@ -36,7 +36,7 @@ test('generates RBAC own-topic WebSocket entries alongside their SQS handlers',
   const rootPath = await createProject(true);
   const result = await generateCreateTargetRoleHandler(rootPath);
 
-  assert.equal(result.files.length, 60);
+  assert.equal(result.files.length, 67);
   assert.match(
     await readFile(join(rootPath, result.files[0].path), 'utf8'),
     /CreateTargetRole/
@@ -211,6 +211,16 @@ test('generates RBAC own-topic WebSocket entries alongside their SQS handlers',
     );
     assert.match(yaml, new RegExp(`${flowTag}HdrWbs:\\n[\\s\\S]*websocket:`));
   }
+
+  const ttlExpiredFile = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowLimit/ReservedUsageTtlExpired/source/ReservedUsageTtlExpired_HdrDss.js'
+    ),
+    'utf8'
+  );
+  assert.match(ttlExpiredFile, /Auto-refunded expired reservation/);
+  assert.match(ttlExpiredFile, /RunningTotalUsage/);
 });
 
 test('removes CreateTargetRole handler when RBAC is removed', async () => {
@@ -244,6 +254,65 @@ test('removes CreateTargetRole handler when RBAC is removed', async () => {
   );
 });
 
+test('generates synchronous HdrInv and HdrApi handlers for FlowLimit flows', async () => {
+  const rootPath = await createProject(true);
+  await generateCreateTargetRoleHandler(rootPath);
+
+  const limitYaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-limits.yml'),
+    'utf8'
+  );
+
+  for (const flowTag of ['ReservedDynamicUsage', 'ConfirmUsage', 'CancelUsage']) {
+    assert.match(
+      limitYaml,
+      new RegExp(
+        `${flowTag}HdrInv:\\n\\s+handler: src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrInv\\.main`
+      )
+    );
+    assert.match(
+      limitYaml,
+      new RegExp(
+        `${flowTag}HdrApi:\\n\\s+handler: src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrApi\\.main`
+      )
+    );
+
+    const invFile = await readFile(
+      join(
+        rootPath,
+        `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrInv.js`
+      ),
+      'utf8'
+    );
+    assert.match(invFile, /export const main = middleware\.wrap/);
+    assert.match(
+      invFile,
+      new RegExp(`import ${flowTag} from '\\./${flowTag}_Main\\.js'`)
+    );
+
+    const apiFile = await readFile(
+      join(
+        rootPath,
+        `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrApi.js`
+      ),
+      'utf8'
+    );
+    assert.match(apiFile, /export const main = middleware\.wrap/);
+    assert.match(
+      apiFile,
+      new RegExp(`import ${flowTag} from '\\./${flowTag}_Main\\.js'`)
+    );
+  }
+
+  assert.match(
+    limitYaml,
+    /ReservedUsageTtlExpiredHdrDss:\n\s+handler: src\/generatedCode\/FlowLimit\/ReservedUsageTtlExpired\/source\/ReservedUsageTtlExpired_HdrDss\.main/
+  );
+  assert.match(limitYaml, /type: dynamodb/);
+  assert.match(limitYaml, /RunningTotalReservedUsageTable/);
+  assert.match(limitYaml, /eventName: \["REMOVE"\]/);
+});
+
 async function createProject(hasRbac) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-rbac-handler-')

package/test/unit/application/crudApplicationArtifacts.test.js

@@ -1119,6 +1119,10 @@ test('emits synchronous ConfirmUsage and CancelUsage invocation in CreateLogical
   assert.match(createLogicalLib, /CancelUsageHdrInv/);
   assert.match(createLogicalLib, /lambda\.invokeSync\(/);
   assert.match(createLogicalLib, /publishCompletionMessage\(/);
+  assert.match(createLogicalLib, /OBJECT_QUOTA_SERVICE_TAGS/);
+  assert.match(createLogicalLib, /"order":"UserAccount"/);
+  assert.match(createLogicalLib, /targetFunction,\s*quotaServiceTag/);
+  assert.doesNotMatch(createLogicalLib, /targetFunction,\s*['"]Rbac['"]/);
 });
 
 test('emits synchronous AfterHook invocation in Update and Delete handlers', async () => {

package/test/unit/application/customFlowApplicationArtifacts.test.js

@@ -232,6 +232,15 @@ test('emits handlers, function YAML, and IAM roles for supported custom flow eve
       join(rootPath, `app/src/generatedCode/FlowSchemas/Upload/source/${path}`)
     );
   }
+  const uploadCreateObject = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/Upload/source/UploadCreateObject_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(uploadCreateObject, /getFlowSchema\.getFlowSchemaS3WithCache/);
+  assert.doesNotMatch(uploadCreateObject, /getObjectSchema\.getFlowSchemaS3WithCache/);
   for (const path of [
     'UploadReservedLimit_Main.js',
     'UploadCreatePreSignUrl_Main.js',

package/test/unit/application/relationshipApplicationArtifacts.test.js

@@ -154,6 +154,36 @@ test('emits valid hook tags without trailing periods and with correct callingFlo
   assert.doesNotMatch(changeMain, /\/\/\(<requestParamCreateRel>\)/);
 });
 
+test('imports getRelSchema and uses getRelationshipSchemaWithCache from getRelSchema in all relationship Main files', async () => {
+  const rootPath = await createProject(true);
+  await generateRelationshipApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const actions = ['Create', 'Update', 'Delete', 'Get', 'Change', 'Move'];
+  for (const action of actions) {
+    const mainContent = await readFile(
+      join(
+        rootPath,
+        `app/src/generatedCode/FlowRelationships/${action}Relationship/source/${action}Relationship_Main.js`
+      ),
+      'utf8'
+    );
+    assert.match(
+      mainContent,
+      /import\s*\{[^}]*getRelSchema[^}]*\}\s*from\s*'@izara_project\/izara-core-library-service-schemas'/
+    );
+    assert.match(
+      mainContent,
+      /const\s*\{[^}]*getRelationshipSchemaWithCache[^}]*\}\s*=\s*getRelSchema/
+    );
+    assert.doesNotMatch(
+      mainContent,
+      /const\s*\{[^}]*getRelationshipSchemaWithCache[^}]*\}\s*=\s*getObjectSchema/
+    );
+  }
+});
+
 test('removes managed relationship artifacts after relationships are removed', async () => {
   const rootPath = await createProject(true);
   await generateRelationshipApplicationArtifacts(rootPath, {

package/test/unit/infrastructure/resourceArtifacts.test.js

@@ -167,6 +167,7 @@ test('emits queues, topics, tables, and IAM roles from schema data', async () =>
   assert.match(procFindDataRole, /dynamodb:Query/);
   assert.match(procFindDataRole, /sns:Publish/);
   assert.match(procFindDataRole, /FindData_Out/);
+  assert.match(procFindDataRole, /ProcessLogical_Out/);
   assert.doesNotMatch(
     iam,
     /s3:GetObjectVersion|sqs:DeleteMessageBatch|sqs:GetQueueUrl/
@@ -815,6 +816,58 @@ test('emits lambda:InvokeFunction in FlowObjectsRole when flow has event generat
   assert.match(role, /GenSyncHook/);
 });
 
+test('emits DynamoDB stream permissions in FlowRbacRole and multi-tenant quota topics in FlowObjectsRole', async () => {
+  const rootPath = await createProject();
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'ObjectSchemas/Order.js'),
+    "export default { objectType: 'order', generatedBy: 'user', belongTo: { serviceTag: 'SupplyNetwork', objectType: 'tenant' }, addOnDataStructure: [{ type: 'rbac' }], identifiers: [{ type: 'partitionKey', fieldName: 'orderId' }], storageResources: { main: { storageType: 'dynamoDB', tableName: 'Orders' } } };\n"
+  );
+  await generateResourceArtifacts(rootPath);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const rbacRole = roleBlock(iam, 'FlowRbacRole');
+  assert.match(rbacRole, /dynamodb:DescribeStream/);
+  assert.match(rbacRole, /RunningTotalReservedUsage\/stream\/\*/);
+
+  const flowObjectsRole = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(flowObjectsRole, /SupplyNetwork_\${self:custom\.iz_stage}_ConfirmUsage_In/);
+  assert.match(flowObjectsRole, /SupplyNetwork_\${self:custom\.iz_stage}_CancelUsage_In/);
+  assert.match(flowObjectsRole, /SupplyNetwork\${self:custom\.iz_stage}ConfirmUsageHdrInv/);
+  assert.match(flowObjectsRole, /SupplyNetwork\${self:custom\.iz_stage}CancelUsageHdrInv/);
+
+  const { createResourceState } = await import(
+    '../../../src/emit/infrastructure/resources/resourceState.js'
+  );
+  const { renderLambdaRoleConfig } = await import(
+    '../../../src/emit/infrastructure/resources/iamResourceArtifacts.js'
+  );
+  const state = createResourceState({
+    objects: [
+      {
+        objectType: 'order',
+        generatedBy: 'user',
+        belongTo: { serviceTag: 'SupplyNetwork', objectType: 'tenant' },
+        addOnDataStructure: [{ type: 'rbac' }]
+      }
+    ],
+    relationships: [],
+    flows: [
+      { flowTag: 'upload', event: ['s3'], quotaServiceTag: 'SupplyNetwork' }
+    ]
+  });
+  const lambdaRoleConfig = await renderLambdaRoleConfig(state);
+  assert.match(lambdaRoleConfig, /ConfirmUsage_In', 'SupplyNetwork'/);
+  assert.match(lambdaRoleConfig, /CancelUsage_In', 'SupplyNetwork'/);
+  assert.match(lambdaRoleConfig, /ReservedDynamicUsage_In', 'SupplyNetwork'/);
+  assert.doesNotMatch(lambdaRoleConfig, /'AccountLimits'/);
+});
 
 function roleBlock(iam, roleName) {
   const match = iam.match(

package/test/unit/output/mergeHooks.test.js

@@ -0,0 +1,405 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { mergeHooks } from '../../../src/output/mergeHooks.js';
+
+async function writeTestFile(tmpDir, relativePath, content) {
+  const fullPath = path.join(tmpDir, relativePath);
+  await mkdir(path.dirname(fullPath), { recursive: true });
+  await writeFile(fullPath, content, 'utf8');
+}
+
+test('merges single hook in JS file when source content has custom code', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/sample.js';
+    await writeTestFile(
+      tmpDir,
+      filePath,
+      '//(<customHook>)\nconst custom = true;\n//(</customHook>)\n'
+    );
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: '//(<customHook>)\n//(</customHook>)\n'
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(
+      result[0].content,
+      '//(<customHook>)\nconst custom = true;\n//(</customHook>)\n'
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('merges multiple occurrences of the same hook tag without losing occurrences', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/Flow_Main.js';
+    const diskContent = [
+      'function test() {',
+      '  //(<identifiers>)',
+      '  firstIdentifier: true',
+      '  //(</identifiers>)',
+      '',
+      '  //(<identifiers>)',
+      '  secondIdentifier: "customValue"',
+      '  //(</identifiers>)',
+      '}'
+    ].join('\n');
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const templateContent = [
+      'function test() {',
+      '  //(<identifiers>)',
+      '  //(</identifiers>)',
+      '',
+      '  //(<identifiers>)',
+      '  //(</identifiers>)',
+      '}'
+    ].join('\n');
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: templateContent
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(result[0].content, diskContent);
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('preserves second hook when the first occurrence of a duplicate hook is empty on disk', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/Flow_Main.js';
+    const diskContent = [
+      'function test() {',
+      '  //(<identifiers>)',
+      '  //(</identifiers>)',
+      '',
+      '  //(<identifiers>)',
+      '  orderId: requestParams.orderId',
+      '  //(</identifiers>)',
+      '}'
+    ].join('\n');
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const templateContent = [
+      'function test() {',
+      '  //(<identifiers>)',
+      '  //(</identifiers>)',
+      '',
+      '  //(<identifiers>)',
+      '  //(</identifiers>)',
+      '}'
+    ].join('\n');
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: templateContent
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(result[0].content, diskContent);
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('merges hooks with relaxed whitespace around comment slashes and tags', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/sample.js';
+    await writeTestFile(
+      tmpDir,
+      filePath,
+      '// (<spacedHook>)\nconst spaced = 1;\n// (</spacedHook>)\n'
+    );
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: '//(<spacedHook>)\n//(</spacedHook>)\n'
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(
+      result[0].content,
+      '// (<spacedHook>)\nconst spaced = 1;\n// (</spacedHook>)\n'
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('merges hooks with hyphens and dots in tag names', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/sample.js';
+    await writeTestFile(
+      tmpDir,
+      filePath,
+      '//(<custom-hook.name>)\nconst customName = "valid";\n//(</custom-hook.name>)\n'
+    );
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: '//(<custom-hook.name>)\n//(</custom-hook.name>)\n'
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(
+      result[0].content,
+      '//(<custom-hook.name>)\nconst customName = "valid";\n//(</custom-hook.name>)\n'
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('merges hooks in YAML files with relaxed whitespace and hyphens', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/sls_yaml/test.yml';
+    const diskContent = [
+      '# <#custom-filter-patterns#>',
+      'filterPatterns:',
+      '  - body: custom',
+      '# <#/custom-filter-patterns#>'
+    ].join('\n');
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const templateContent = [
+      '#<#custom-filter-patterns#>',
+      '#<#/custom-filter-patterns#>'
+    ].join('\n');
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: templateContent
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(result[0].content, diskContent);
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('merges hooks in .mjs and .cjs files', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const mjsPath = 'app/src/sample.mjs';
+    const cjsPath = 'app/src/sample.cjs';
+    await writeTestFile(
+      tmpDir,
+      mjsPath,
+      '//(<mjsHook>)\nexport default 1;\n//(</mjsHook>)\n'
+    );
+    await writeTestFile(
+      tmpDir,
+      cjsPath,
+      '//(<cjsHook>)\nmodule.exports = 2;\n//(</cjsHook>)\n'
+    );
+
+    const artifacts = [
+      {
+        path: mjsPath,
+        content: '//(<mjsHook>)\n//(</mjsHook>)\n'
+      },
+      {
+        path: cjsPath,
+        content: '//(<cjsHook>)\n//(</cjsHook>)\n'
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(
+      result[0].content,
+      '//(<mjsHook>)\nexport default 1;\n//(</mjsHook>)\n'
+    );
+    assert.equal(
+      result[1].content,
+      '//(<cjsHook>)\nmodule.exports = 2;\n//(</cjsHook>)\n'
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('respects writeWhenFileExist false flag by returning disk content unchanged', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/immutable.js';
+    await writeTestFile(tmpDir, filePath, '// existing disk content\n');
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: '// new template content\n',
+        writeWhenFileExist: false
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(result[0].content, '// existing disk content\n');
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('merges hook when disk content has legacy tag without closing angle bracket', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/Flow_Main.js';
+    const diskContent = [
+      '//(<rbacPublish_CreatePlugInConn)',
+      'let plugInTag = requestParams.plugInTag;',
+      '//(</rbacPublish_CreatePlugInConn)'
+    ].join('\n') + '\n';
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: [
+          '//(<rbacPublish_CreatePlugInConn>)',
+          '//(</rbacPublish_CreatePlugInConn>)'
+        ].join('\n') + '\n'
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(
+      result[0].content,
+      [
+        '//(<rbacPublish_CreatePlugInConn>)',
+        'let plugInTag = requestParams.plugInTag;',
+        '//(</rbacPublish_CreatePlugInConn>)'
+      ].join('\n') + '\n'
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('merges hook when both template and disk content omit closing angle bracket', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/Legacy_Main.js';
+    const diskContent = [
+      '//(<legacyHook)',
+      'const legacyValue = 42;',
+      '//(</legacyHook)'
+    ].join('\n') + '\n';
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: [
+          '//(<legacyHook)',
+          '//(</legacyHook)'
+        ].join('\n') + '\n'
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(
+      result[0].content,
+      [
+        '//(<legacyHook>)',
+        'const legacyValue = 42;',
+        '//(</legacyHook>)'
+      ].join('\n') + '\n'
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('throws error when source content has malformed hook tags (unclosed open tag)', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'app/src/Broken_Main.js';
+    const diskContent = [
+      '//(<openHook>)',
+      'const value = 1;',
+      '// without closing tag'
+    ].join('\n') + '\n';
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: '//(<openHook>)\n//(</openHook>)\n'
+      }
+    ];
+
+    await assert.rejects(
+      async () => {
+        await mergeHooks(tmpDir, artifacts);
+      },
+      /\[mergeHooks\] Malformed hook tags in 'app\/src\/Broken_Main\.js'/
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('warns when source content contains custom code in hook missing from template', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  const originalWarn = console.warn;
+  const warnings = [];
+  console.warn = (...args) => warnings.push(args.join(' '));
+
+  try {
+    const filePath = 'app/src/Orphaned_Main.js';
+    const diskContent = [
+      '//(<removedHook>)',
+      'const importantCustomCode = true;',
+      '//(</removedHook>)'
+    ].join('\n') + '\n';
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const artifacts = [
+      {
+        path: filePath,
+        content: '//(<newHook>)\n//(</newHook>)\n'
+      }
+    ];
+
+    const result = await mergeHooks(tmpDir, artifacts);
+    assert.equal(result[0].content, '//(<newHook>)\n//(</newHook>)\n');
+    assert.ok(
+      warnings.some((w) =>
+        w.includes("Hook 'removedHook' in 'app/src/Orphaned_Main.js' contains custom code")
+      ),
+      'Should log warning for orphaned hook with custom code'
+    );
+  } finally {
+    console.warn = originalWarn;
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+