@izara_project/izara-core-generate-service-code 1.0.98 → 1.0.100

package/test/unit/infrastructure/functionYamlArtifact.test.js

@@ -83,14 +83,16 @@ test('filters all SQS functions by their calling flow', () => {
     /#<#CreateCompleteHdrSqsFilterPatterns#>[\s\S]*filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateCompleteHdrSqs/
   );
   assert.match(completion, /#<#\/CreateCompleteHdrSqsFilterPatterns#>/);
-  assert.match(completion, /callingFlow:\s*\n\s*- exists: false/);
-  assert.match(completion, /MessageAttributes:\s*\n\s*- exists: false/);
+  assert.match(completion, /callingFlow:\s*\n\s*StringValue:/);
+  assert.doesNotMatch(completion, /callingFlow:\s*\n\s*- exists: false/);
+  assert.doesNotMatch(completion, /MessageAttributes:\s*\n\s*- exists: false/);
   assert.match(
     ordinary,
     /#<#CreateHdrSqsFilterPatterns#>[\s\S]*filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateHdrSqs/
   );
   assert.match(ordinary, /#<#\/CreateHdrSqsFilterPatterns#>/);
-  assert.match(ordinary, /callingFlow:\s*\n\s*- exists: false/);
-  assert.match(ordinary, /MessageAttributes:\s*\n\s*- exists: false/);
+  assert.match(ordinary, /callingFlow:\s*\n\s*StringValue:/);
+  assert.doesNotMatch(ordinary, /callingFlow:\s*\n\s*- exists: false/);
+  assert.doesNotMatch(ordinary, /MessageAttributes:\s*\n\s*- exists: false/);
 });
 

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

@@ -7,6 +7,10 @@ import test, { after } from 'node:test';
 process.env.NODE_ENV = 'test';
 
 import { generateResourceArtifacts } from '../../../src/emit/infrastructure/resources/generateResourceArtifacts.js';
+import {
+  renderS3,
+  toAlphanumericPascalCase
+} from '../../../src/emit/infrastructure/resources/s3ResourceArtifacts.js';
 
 const roots = new Set();
 after(() =>
@@ -816,6 +820,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(
@@ -857,3 +913,50 @@ async function createProject() {
   );
   return rootPath;
 }
+
+test('toAlphanumericPascalCase converts non-alphanumeric strings to PascalCase', () => {
+  assert.equal(
+    toAlphanumericPascalCase('video-record-temp-test'),
+    'VideoRecordTempTest'
+  );
+  assert.equal(
+    toAlphanumericPascalCase('video.record_temp-test'),
+    'VideoRecordTempTest'
+  );
+  assert.equal(toAlphanumericPascalCase('AlreadyPascal'), 'AlreadyPascal');
+  assert.equal(toAlphanumericPascalCase(''), '');
+});
+
+test('renderS3 generates alphanumeric PascalCase Logical ID for CloudFormation', async () => {
+  const yaml = await renderS3({
+    s3Buckets: ['video-record-temp-test']
+  });
+  assert.ok(
+    yaml.includes('VideoRecordTempTestS3Bucket:'),
+    'Logical ID must be alphanumeric PascalCase without hyphens'
+  );
+  assert.ok(
+    !yaml.includes('video-record-temp-testS3Bucket:'),
+    'Logical ID must not contain hyphens'
+  );
+  assert.ok(
+    yaml.includes('BucketName: video-record-temp-test'),
+    'BucketName property must preserve original bucket name'
+  );
+});
+
+test('roleStatements emits s3:GetObject for custom S3 flow bucket', async () => {
+  const rootPath = await createProject();
+  await generateResourceArtifacts(rootPath);
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const uploadRole = roleBlock(iam, 'UploadRole');
+  assert.match(uploadRole, /s3:GetObject/);
+  assert.match(uploadRole, /arn:aws:s3:::UploadBucket\/\*/);
+});
+

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

@@ -266,3 +266,140 @@ test('respects writeWhenFileExist false flag by returning disk content unchanged
     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 });
+  }
+});
+
+

package/test/unit/schemas/attributeTreeSchemas.test.js

@@ -23,7 +23,7 @@ after(async () => {
   await cleanupTestProjects();
 });
 
-test('emitAttributeTreeObjectSchemas returns 3 object schemas per attributeTree tag', () => {
+test('emitAttributeTreeObjectSchemas returns 4 object schemas per attributeTree tag', () => {
   const objects = [
     {
       objectType: 'sellOffer',
@@ -48,13 +48,14 @@ test('emitAttributeTreeObjectSchemas returns 3 object schemas per attributeTree
   ];
 
   const artifacts = emitAttributeTreeObjectSchemas({ objects });
-  assert.equal(artifacts.length, 3);
+  assert.equal(artifacts.length, 4);
 
   const paths = artifacts.map((a) => a.path);
   assert.deepEqual(paths, [
     'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLink.js',
     'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValue.js',
-    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLabel.js'
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLabel.js',
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js'
   ]);
 
   const valueArtifact = artifacts.find((a) =>
@@ -63,6 +64,26 @@ test('emitAttributeTreeObjectSchemas returns 3 object schemas per attributeTree
   assert.match(valueArtifact.content, /"objectType": "sellOfferTermValue"/);
   assert.match(valueArtifact.content, /"sellOfferTermValueId"/);
 
+  const valueStandardArtifact = artifacts.find((a) =>
+    a.path.endsWith('sellOfferTermValueStandard.js')
+  );
+  assert.match(
+    valueStandardArtifact.content,
+    /objectType:\s*['"]sellOfferTermValueStandard['"]/
+  );
+  assert.match(
+    valueStandardArtifact.content,
+    /sellOfferTermValueStandardId/
+  );
+  assert.match(
+    valueStandardArtifact.content,
+    /\/\/\(<addOnDataStructuresellOfferTermValueStandard>\)/
+  );
+
+  const managedPaths = attributeTreeObjectSchemaManagedPaths(objects);
+  assert.equal(managedPaths.length, 4);
+  assert.deepEqual(managedPaths, paths);
+
   for (const artifact of artifacts) {
     assert.doesNotMatch(artifact.content, /dynamoDB/);
     assert.match(artifact.content, /GraphHandler/);
@@ -152,6 +173,8 @@ test('generate commits and cleans up attributeTree dynamic schemas', async () =>
 
   const objectRelPath =
     'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLink.js';
+  const valueStandardRelPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js';
   const relRelPath =
     'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/hasSellOfferTermLink.js';
 
@@ -160,6 +183,9 @@ test('generate commits and cleans up attributeTree dynamic schemas', async () =>
   assert.match(objectContent, /GraphHandler/);
   assert.doesNotMatch(objectContent, /dynamoDB/);
 
+  const valueStandardContent = await readProjectFile(rootPath, valueStandardRelPath);
+  assert.match(valueStandardContent, /sellOfferTermValueStandard/);
+
   const relContent = await readProjectFile(rootPath, relRelPath);
   assert.match(relContent, /hasSellOfferTermLink/);
   assert.match(relContent, /sellOfferTermLink/);
@@ -171,6 +197,9 @@ test('generate commits and cleans up attributeTree dynamic schemas', async () =>
   await assert.rejects(readProjectFile(rootPath, objectRelPath), {
     code: 'ENOENT'
   });
+  await assert.rejects(readProjectFile(rootPath, valueStandardRelPath), {
+    code: 'ENOENT'
+  });
   await assert.rejects(readProjectFile(rootPath, relRelPath), {
     code: 'ENOENT'
   });

package/test/unit/schemas/attributeTreeSingleService.test.js

@@ -0,0 +1,175 @@
+import assert from 'node:assert/strict';
+import test, { after } from 'node:test';
+import { generate } from '../../../src/generate.js';
+import {
+  createTestProject,
+  readProjectFile,
+  writeProjectFile,
+  cleanupTestProjects
+} from '../../helpers/testProject.js';
+
+after(async () => {
+  await cleanupTestProjects();
+});
+
+test('single-service attributeTree generation and propertyValue cascading', async () => {
+  const initialSchema = `export default [
+  {
+    objectType: 'sellOffer',
+    canDelete: false,
+    generatedBy: 'user',
+    addOnDataStructure: [
+      {
+        type: 'attributeTree',
+        attributeTreeTag: 'sellOfferTerm'
+      }
+    ],
+    storageResources: {
+      dynamoDB: {
+        storageType: 'dynamoDB',
+        tableName: 'SellOfferRecords',
+        serviceTag: 'SellOfferManager'
+      },
+      myGraph: {
+        storageType: 'graph',
+        graphServerTag: 'GraphHandler'
+      }
+    },
+    fieldNames: {
+      sellOfferId: {
+        type: 'string',
+        randomOnCreate: true,
+        canUpdate: false,
+        storageResourceTags: ['dynamoDB', 'myGraph']
+      }
+    },
+    identifiers: [
+      {
+        type: 'partitionKey',
+        fieldName: 'sellOfferId'
+      }
+    ]
+  }
+];
+`;
+
+  const rootPath = await createTestProject({
+    prefix: 'izara-single-service-attr-tree-',
+    serviceTag: 'SellOfferManager',
+    schemas: {
+      'ObjectSchemas/SellOffer.js': initialSchema
+    }
+  });
+
+  // Phase 1: generate produces all 4 ObjectSchemas and 4 RelationshipSchemas
+  await generate(rootPath);
+
+  const linkPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLink.js';
+  const valuePath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValue.js';
+  const labelPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLabel.js';
+  const valueStandardPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js';
+
+  const linkContent = await readProjectFile(rootPath, linkPath);
+  assert.match(linkContent, /sellOfferTermLink/);
+
+  const valueContent = await readProjectFile(rootPath, valuePath);
+  assert.match(valueContent, /sellOfferTermValue/);
+
+  const labelContent = await readProjectFile(rootPath, labelPath);
+  assert.match(labelContent, /sellOfferTermLabel/);
+
+  const valueStandardContent = await readProjectFile(
+    rootPath,
+    valueStandardPath
+  );
+  assert.match(valueStandardContent, /sellOfferTermValueStandard/);
+  assert.match(
+    valueStandardContent,
+    /\/\/\(<addOnDataStructuresellOfferTermValueStandard>\)/
+  );
+
+  // Check relationship schemas
+  const hasLinkRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/hasSellOfferTermLink.js';
+  const hasLinkRel = await readProjectFile(rootPath, hasLinkRelPath);
+  assert.match(hasLinkRel, /hasSellOfferTermLink/);
+
+  // Phase 2: developer uncomments propertyValue addOn in ValueStandard
+  const modifiedValueStandard = valueStandardContent.replace(
+    '//(<addOnDataStructuresellOfferTermValueStandard>)\n      // {\n      //   type: \'propertyValue\',\n      //   propertyValuePrefix: \'sellOfferTermValueStandard\'\n      // }\n      //(</addOnDataStructuresellOfferTermValueStandard>)',
+    '//(<addOnDataStructuresellOfferTermValueStandard>)\n      {\n        type: \'propertyValue\',\n        propertyValuePrefix: \'sellOfferTermValueStandard\'\n      }\n      //(</addOnDataStructuresellOfferTermValueStandard>)'
+  );
+  await writeProjectFile(rootPath, valueStandardPath, modifiedValueStandard);
+
+  await generate(rootPath);
+
+  // Verify hook preservation
+  const reloadedValueStandard = await readProjectFile(
+    rootPath,
+    valueStandardPath
+  );
+  assert.match(reloadedValueStandard, /type:\s*'propertyValue'/);
+
+  // Verify cascading generation: propertyValue domain in the same repo
+  const propLabelPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/sellOfferTermValueStandardPropertyLabel.js';
+  const propValuePath =
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/sellOfferTermValueStandardPropertyValue.js';
+  const hasPropRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/hasSellOfferTermValueStandardPropertyValue.js';
+  const disPropRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/disabledSellOfferTermValueStandardPropertyValue.js';
+  const isPropRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/isSellOfferTermValueStandardPropertyLabel.js';
+
+  const propLabel = await readProjectFile(rootPath, propLabelPath);
+  assert.match(propLabel, /sellOfferTermValueStandardPropertyLabel/);
+
+  const propValue = await readProjectFile(rootPath, propValuePath);
+  assert.match(propValue, /sellOfferTermValueStandardPropertyValue/);
+
+  const hasPropRel = await readProjectFile(rootPath, hasPropRelPath);
+  assert.match(hasPropRel, /hasSellOfferTermValueStandardPropertyValue/);
+
+  const disPropRel = await readProjectFile(rootPath, disPropRelPath);
+  assert.match(disPropRel, /disabledSellOfferTermValueStandardPropertyValue/);
+
+  const isPropRel = await readProjectFile(rootPath, isPropRelPath);
+  assert.match(isPropRel, /isSellOfferTermValueStandardPropertyLabel/);
+
+  // Cleanup check: remove attributeTree addOn from base schema
+  const cleanSchema = `export default [
+  {
+    objectType: 'sellOffer',
+    canDelete: false,
+    generatedBy: 'user',
+    addOnDataStructure: [],
+    storageResources: {
+      myGraph: { storageType: 'graph', graphServerTag: 'GraphHandler' }
+    },
+    fieldNames: {
+      sellOfferId: { type: 'string', storageResourceTags: ['myGraph'] }
+    },
+    identifiers: [{ type: 'partitionKey', fieldName: 'sellOfferId' }]
+  }
+];
+`;
+  await writeProjectFile(
+    rootPath,
+    'app/src/schemas/ObjectSchemas/SellOffer.js',
+    cleanSchema
+  );
+  await generate(rootPath);
+
+  // All attributeTree schemas should be removed
+  await assert.rejects(readProjectFile(rootPath, linkPath), { code: 'ENOENT' });
+  await assert.rejects(readProjectFile(rootPath, valuePath), { code: 'ENOENT' });
+  await assert.rejects(readProjectFile(rootPath, labelPath), { code: 'ENOENT' });
+  await assert.rejects(readProjectFile(rootPath, valueStandardPath), {
+    code: 'ENOENT'
+  });
+});

package/test/unit/schemas/dynamicRbacFlowSchemas.test.js

@@ -26,7 +26,8 @@ const STATIC_RBAC_ACTIONS = [
 const STATIC_LIMIT_ACTIONS = [
   'ReservedDynamicUsage',
   'ConfirmUsage',
-  'CancelUsage'
+  'CancelUsage',
+  'ReservedUsageTtlExpired'
 ];
 
 after(async () => {
@@ -113,11 +114,12 @@ test('generates shared and object-specific RBAC flow schemas', async () => {
     'lambdaSyncInv',
     'lambdaSyncApi'
   ]);
-  assert.deepEqual(cancelUsage.event, [
-    'ownTopic',
-    'lambdaSyncInv',
-    'lambdaSyncApi'
-  ]);
+  const reservedUsageTtlExpired = await readGeneratedFlow(
+    rootPath,
+    'ReservedUsageTtlExpired',
+    'FlowLimit'
+  );
+  assert.deepEqual(reservedUsageTtlExpired.event, ['dss']);
 });
 
 test('removes RBAC schemas when the last RBAC object is removed', async () => {

package/test/unit/schemas/dynamicRelationshipFlowSchemas.test.js

@@ -6,6 +6,7 @@ import test, { after } from 'node:test';
 import { pathToFileURL } from 'node:url';
 
 import { generateDynamicRelationshipFlowSchemas } from '../../../src/emit/application/relationship/generateDynamicRelationshipFlowSchemas.js';
+import { loadLocalSchemaDirectory } from '../../../src/compile/loadSchemas.js';
 
 const RELATIONSHIP_ACTIONS = [
   'CreateRelationship',
@@ -136,6 +137,56 @@ test('does not allow options to override the rootPath argument', async () => {
   );
 });
 
+test('validates relationship schemas with systemNoUser and systemWithUser generatedBy', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-rel-val-')
+  );
+  projectRoots.add(rootPath);
+  const relationshipDirectory = join(
+    rootPath,
+    'app/src/schemas/RelationshipSchemas'
+  );
+  await mkdir(relationshipDirectory, { recursive: true });
+  const relSchema = [
+    {
+      isItemLabel: {
+        fieldNames: {},
+        storageResources: {
+          myGraph: { storageType: 'graph', graphServerTag: 'GraphHandler' }
+        },
+        generatedBy: 'systemNoUser',
+        links: [
+          {
+            storageResourceTags: ['myGraph'],
+            from: {
+              objType: { serviceTag: 'ItemSvc', objectType: 'itemValue' },
+              linkType: 'many',
+              requiredOnCreate: true
+            },
+            to: {
+              objType: { serviceTag: 'ItemSvc', objectType: 'itemLabel' },
+              linkType: 'one'
+            }
+          }
+        ]
+      }
+    }
+  ];
+  await writeFile(
+    join(relationshipDirectory, 'isItemLabel.js'),
+    `export default ${JSON.stringify(relSchema, null, 2)};\n`
+  );
+
+  const schemas = await loadLocalSchemaDirectory(
+    { schemaRoot: join(rootPath, 'app/src/schemas') },
+    'RelationshipSchemas',
+    { validateSchemas: true }
+  );
+
+  assert.equal(schemas.length, 1);
+  assert.equal(schemas[0].isItemLabel.generatedBy, 'systemNoUser');
+});
+
 async function createProject({ singletonExport = false } = {}) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-relationship-')