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

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

@@ -8,9 +8,7 @@ import {
   emitAttributeTreeObjectSchemas,
   emitAttributeTreeRelationshipSchemas,
   attributeTreeObjectSchemaManagedPaths,
-  attributeTreeRelationshipSchemaManagedPaths,
-  resolveTargetServicePath,
-  emitAttributeTreeTargetSchemas
+  attributeTreeRelationshipSchemaManagedPaths
 } from '../../../src/emit/schemas/attributeTree/emitAttributeTreeSchemas.js';
 import { generate } from '../../../src/generate.js';
 import {
@@ -25,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',
@@ -50,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/generatedAttributeTree/sellOfferTermLink.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermValue.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLabel.js'
+    '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/sellOfferTermValueStandard.js'
   ]);
 
   const valueArtifact = artifacts.find((a) =>
@@ -65,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/);
@@ -103,10 +122,10 @@ test('emitAttributeTreeRelationshipSchemas returns 4 relationship schemas per at
 
   const paths = artifacts.map((a) => a.path);
   assert.deepEqual(paths, [
-    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/hasSellOfferTermLink.js',
-    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/disabledSellOfferTermLink.js',
-    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/isSellOfferTerm.js',
-    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/isSellOfferTermLabel.js'
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/hasSellOfferTermLink.js',
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/disabledSellOfferTermLink.js',
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/isSellOfferTerm.js',
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/isSellOfferTermLabel.js'
   ]);
 
   const hasRel = artifacts.find((a) => a.path.endsWith('hasSellOfferTermLink.js'));
@@ -153,15 +172,20 @@ test('generate commits and cleans up attributeTree dynamic schemas', async () =>
   await generate(rootPath);
 
   const objectRelPath =
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLink.js';
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLink.js';
+  const valueStandardRelPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js';
   const relRelPath =
-    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/hasSellOfferTermLink.js';
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/hasSellOfferTermLink.js';
 
   const objectContent = await readProjectFile(rootPath, objectRelPath);
   assert.match(objectContent, /sellOfferTermLink/);
   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/);
@@ -173,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'
   });
@@ -244,53 +271,4 @@ async function createProjectWithAttributeTree({
   });
 }
 
-test('resolveTargetServicePath prioritizes dev suffix and matches attributeTag', async () => {
-  const tmpRoot = trackTestProject(
-    await mkdtemp(join(tmpdir(), 'izara-services-test-'))
-  );
-
-  const currentServiceDir = join(
-    tmpRoot,
-    'izara-market-products-sell-offer-manager-pong'
-  );
-  const targetWithSuffix = join(
-    tmpRoot,
-    'izara-market-products-sell-offer-term-pong'
-  );
-  const targetOtherDev = join(
-    tmpRoot,
-    'izara-market-products-sell-offer-term-alice'
-  );
-  const unrelatedService = join(
-    tmpRoot,
-    'izara-market-products-cart-pong'
-  );
-
-  await mkdir(join(currentServiceDir, 'app/src'), { recursive: true });
-  await mkdir(join(targetWithSuffix, 'app/src'), { recursive: true });
-  await mkdir(join(targetOtherDev, 'app/src'), { recursive: true });
-  await mkdir(join(unrelatedService, 'app/src'), { recursive: true });
-
-  const resolved = resolveTargetServicePath({
-    currentServiceRoot: currentServiceDir,
-    attributeTag: 'sellOfferTerm'
-  });
-
-  assert.equal(resolved, targetWithSuffix);
-});
-
-test('emitAttributeTreeTargetSchemas produces expected standard schemas', () => {
-  const targetDir = '/dummy/path/izara-market-products-sellOfferTerm';
-  const artifacts = emitAttributeTreeTargetSchemas({
-    attributeTag: 'sellOfferTerm',
-    targetServiceRoot: targetDir
-  });
-
-  assert.equal(artifacts.length, 3);
-  const paths = artifacts.map((a) => a.path);
-
-  assert.ok(paths.some((p) => p.endsWith('sellOfferTermValueStandardPropertyLabel.js')));
-  assert.ok(paths.some((p) => p.endsWith('sellOfferTermValueStandardPropertyValue.js')));
-  assert.ok(paths.some((p) => p.endsWith('sellOfferTermValueStandard.js')));
-});
 

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/ledgerSchemas.test.js

@@ -19,7 +19,7 @@ after(async () => {
   await cleanupTestProjects();
 });
 
-test('emitLedgerObjectSchemas returns 1 object schema per ledger addOn', () => {
+test('emitLedgerObjectSchemas returns 1 object schema per ledger addOn', async () => {
   const objects = [
     {
       objectType: 'unitStandard',
@@ -61,7 +61,7 @@ test('emitLedgerObjectSchemas returns 1 object schema per ledger addOn', () => {
     }
   ];
 
-  const artifacts = emitLedgerObjectSchemas({ objects });
+  const artifacts = await emitLedgerObjectSchemas({ objects });
   assert.equal(artifacts.length, 2);
 
   const paths = artifacts.map((a) => a.path);
@@ -81,7 +81,7 @@ test('emitLedgerObjectSchemas returns 1 object schema per ledger addOn', () => {
   assert.match(entryArtifact.content, /GraphHandler/);
 });
 
-test('emitLedgerRelationshipSchemas returns current, old, and is relationship schemas per ledger addOn', () => {
+test('emitLedgerRelationshipSchemas returns current, old, and is relationship schemas per ledger addOn', async () => {
   const objects = [
     {
       objectType: 'unitStandard',
@@ -113,7 +113,7 @@ test('emitLedgerRelationshipSchemas returns current, old, and is relationship sc
     }
   ];
 
-  const artifacts = emitLedgerRelationshipSchemas({
+  const artifacts = await emitLedgerRelationshipSchemas({
     objects,
     serviceTag: 'UnitStandard'
   });
@@ -156,14 +156,40 @@ test('emitLedgerRelationshipSchemas returns current, old, and is relationship sc
   assert.match(isRel.content, /"generatedBy": "systemNoUser"/);
   assert.match(isRel.content, /"supplyLocation"/);
   assert.match(isRel.content, /"unitPacking"/);
+
+  // 4. Verify requiredOnCreate is false in links
+  const _parseRel = (content) => {
+    const raw = content
+      .replace(/^export default\s+/, '')
+      .replace(/;\s*$/, '');
+    return JSON.parse(raw)[0];
+  };
+
+  const currentRelData = Object.values(_parseRel(currentRel.content))[0];
+  for (const link of currentRelData.links) {
+    assert.equal(link.from.requiredOnCreate, false);
+    assert.equal(link.to.requiredOnCreate, false);
+  }
+
+  const oldRelData = Object.values(_parseRel(oldRel.content))[0];
+  for (const link of oldRelData.links) {
+    assert.equal(link.from.requiredOnCreate, false);
+    assert.equal(link.to.requiredOnCreate, false);
+  }
+
+  const isRelData = Object.values(_parseRel(isRel.content))[0];
+  for (const link of isRelData.links) {
+    assert.equal(link.from.requiredOnCreate, false);
+    assert.equal(link.to.requiredOnCreate, false);
+  }
 });
 
-test('managed paths return empty array when no ledger is present', () => {
+test('managed paths return empty array when no ledger is present', async () => {
   const objects = [{ objectType: 'user', addOnDataStructure: [] }];
   assert.deepEqual(ledgerObjectSchemaManagedPaths(objects), []);
   assert.deepEqual(ledgerRelationshipSchemaManagedPaths(objects), []);
-  assert.deepEqual(emitLedgerObjectSchemas({ objects }), []);
-  assert.deepEqual(emitLedgerRelationshipSchemas({ objects }), []);
+  assert.deepEqual(await emitLedgerObjectSchemas({ objects }), []);
+  assert.deepEqual(await emitLedgerRelationshipSchemas({ objects }), []);
 });
 
 test('generate commits and cleans up ledger dynamic schemas', async () => {

package/test/unit/schemas/propertyValueSchemas.test.js

@@ -0,0 +1,265 @@
+import assert from 'node:assert/strict';
+import test, { after } from 'node:test';
+
+import {
+  emitPropertyValueObjectSchemas,
+  emitPropertyValueRelationshipSchemas,
+  propertyValueObjectSchemaManagedPaths,
+  propertyValueRelationshipSchemaManagedPaths
+} from '../../../src/emit/schemas/propertyValue/emitPropertyValueSchemas.js';
+import { generate } from '../../../src/generate.js';
+import {
+  createTestProject,
+  readProjectFile,
+  writeProjectFile,
+  cleanupTestProjects
+} from '../../helpers/testProject.js';
+
+after(async () => {
+  await cleanupTestProjects();
+});
+
+test('emitPropertyValueObjectSchemas returns 2 object schemas per propertyValue addOn', () => {
+  const objects = [
+    {
+      objectType: 'item',
+      serviceTag: 'ItemService',
+      storageResources: {
+        dynamoDB: {
+          storageType: 'dynamoDB',
+          tableName: 'ItemRecords'
+        },
+        myGraph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'propertyValue',
+          propertyValuePrefix: 'itemProperty'
+        }
+      ]
+    },
+    {
+      objectType: 'supplyNetwork',
+      serviceTag: 'SupplyService',
+      storageResources: {
+        myGraph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'propertyValue'
+        }
+      ]
+    }
+  ];
+
+  const artifacts = emitPropertyValueObjectSchemas({ objects });
+  assert.equal(artifacts.length, 4);
+
+  const paths = artifacts.map((a) => a.path);
+  assert.deepEqual(paths, [
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/itemPropertyPropertyLabel.js',
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/itemPropertyPropertyValue.js',
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/supplyNetworkPropertyLabel.js',
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/supplyNetworkPropertyValue.js'
+  ]);
+
+  const labelArtifact = artifacts[0];
+  assert.match(
+    labelArtifact.content,
+    /"objectType": "itemPropertyPropertyLabel"/
+  );
+  assert.match(labelArtifact.content, /"itemPropertyPropertyLabelId"/);
+  assert.match(labelArtifact.content, /"generatedBy": "user"/);
+  assert.match(labelArtifact.content, /"canDelete": true/);
+  assert.doesNotMatch(labelArtifact.content, /dynamoDB/);
+  assert.match(labelArtifact.content, /GraphHandler/);
+
+  const valueArtifact = artifacts[1];
+  assert.match(
+    valueArtifact.content,
+    /"objectType": "itemPropertyPropertyValue"/
+  );
+  assert.match(valueArtifact.content, /"itemPropertyPropertyValueId"/);
+});
+
+test('emitPropertyValueRelationshipSchemas returns 3 relationship schemas per propertyValue addOn', () => {
+  const objects = [
+    {
+      objectType: 'item',
+      serviceTag: 'ItemService',
+      storageResources: {
+        myGraph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'propertyValue',
+          propertyValuePrefix: 'item'
+        }
+      ]
+    }
+  ];
+
+  const artifacts = emitPropertyValueRelationshipSchemas({
+    objects,
+    serviceTag: 'ItemService'
+  });
+  assert.equal(artifacts.length, 3);
+
+  const paths = artifacts.map((a) => a.path);
+  assert.deepEqual(paths, [
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/hasItemPropertyValue.js',
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/disabledItemPropertyValue.js',
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/isItemPropertyLabel.js'
+  ]);
+
+  // 1. hasItemPropertyValue
+  const hasRel = artifacts[0];
+  assert.match(hasRel.content, /"hasItemPropertyValue"/);
+  assert.match(hasRel.content, /"generatedBy": "user"/);
+  assert.match(hasRel.content, /"objectType": "item"/);
+  assert.match(hasRel.content, /"objectType": "itemPropertyValue"/);
+  assert.match(hasRel.content, /"linkType": "one"/);
+  assert.match(hasRel.content, /"linkType": "many"/);
+
+  // 2. disabledItemPropertyValue
+  const disabledRel = artifacts[1];
+  assert.match(disabledRel.content, /"disabledItemPropertyValue"/);
+  assert.match(disabledRel.content, /"generatedBy": "user"/);
+
+  // 3. isItemPropertyLabel
+  const isRel = artifacts[2];
+  assert.match(isRel.content, /"isItemPropertyLabel"/);
+  assert.match(isRel.content, /"generatedBy": "systemNoUser"/);
+  assert.match(isRel.content, /"objectType": "itemPropertyLabel"/);
+});
+
+test('managed paths return empty array when no propertyValue is present', () => {
+  const objects = [{ objectType: 'user', addOnDataStructure: [] }];
+  assert.deepEqual(propertyValueObjectSchemaManagedPaths(objects), []);
+  assert.deepEqual(propertyValueRelationshipSchemaManagedPaths(objects), []);
+  assert.deepEqual(emitPropertyValueObjectSchemas({ objects }), []);
+  assert.deepEqual(emitPropertyValueRelationshipSchemas({ objects }), []);
+});
+
+test('generate commits and cleans up propertyValue dynamic schemas', async () => {
+  const rootPath = await createProjectWithPropertyValue({ hasAddOn: true });
+  await generate(rootPath);
+
+  const labelPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/itemPropertyLabel.js';
+  const valuePath =
+    'app/src/schemas/ObjectSchemas/generatedCode/propertyValue/itemPropertyValue.js';
+  const hasRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/hasItemPropertyValue.js';
+  const disabledRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/disabledItemPropertyValue.js';
+  const isRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/isItemPropertyLabel.js';
+
+  const labelContent = await readProjectFile(rootPath, labelPath);
+  assert.match(labelContent, /itemPropertyLabel/);
+  assert.match(labelContent, /GraphHandler/);
+
+  const valueContent = await readProjectFile(rootPath, valuePath);
+  assert.match(valueContent, /itemPropertyValue/);
+
+  const hasRelContent = await readProjectFile(rootPath, hasRelPath);
+  assert.match(hasRelContent, /hasItemPropertyValue/);
+
+  const disabledRelContent = await readProjectFile(rootPath, disabledRelPath);
+  assert.match(disabledRelContent, /disabledItemPropertyValue/);
+
+  const isRelContent = await readProjectFile(rootPath, isRelPath);
+  assert.match(isRelContent, /isItemPropertyLabel/);
+
+  // Re-run without addOn to verify stale file cleanup
+  await createProjectWithPropertyValue({ rootPath, hasAddOn: false });
+  await generate(rootPath);
+
+  await assert.rejects(readProjectFile(rootPath, labelPath), {
+    code: 'ENOENT'
+  });
+  await assert.rejects(readProjectFile(rootPath, valuePath), {
+    code: 'ENOENT'
+  });
+  await assert.rejects(readProjectFile(rootPath, hasRelPath), {
+    code: 'ENOENT'
+  });
+  await assert.rejects(readProjectFile(rootPath, disabledRelPath), {
+    code: 'ENOENT'
+  });
+  await assert.rejects(readProjectFile(rootPath, isRelPath), {
+    code: 'ENOENT'
+  });
+});
+
+async function createProjectWithPropertyValue({
+  rootPath: existingRoot,
+  hasAddOn = true
+} = {}) {
+  let addOnContent = '    addOnDataStructure: [],';
+  if (hasAddOn) {
+    addOnContent = `
+    addOnDataStructure: [
+      {
+        type: 'propertyValue',
+        propertyValuePrefix: 'item'
+      }
+    ],`;
+  }
+
+  const schemaContent = `export default [
+  {
+    objectType: 'item',
+    canDelete: false,
+    generatedBy: 'user',${addOnContent}
+    storageResources: {
+      graph: {
+        storageType: 'graph',
+        graphServerTag: 'GraphHandler'
+      }
+    },
+    fieldNames: {
+      itemId: {
+        type: 'string',
+        randomOnCreate: true,
+        canUpdate: false,
+        storageResourceTags: ['graph']
+      }
+    },
+    identifiers: [
+      {
+        type: 'partitionKey',
+        fieldName: 'itemId'
+      }
+    ]
+  }
+];
+`;
+
+  if (existingRoot) {
+    await writeProjectFile(
+      existingRoot,
+      'app/src/schemas/ObjectSchemas/Item.js',
+      schemaContent
+    );
+    return existingRoot;
+  }
+
+  return await createTestProject({
+    prefix: 'izara-property-value-test-',
+    serviceTag: 'ItemService',
+    schemas: {
+      'ObjectSchemas/Item.js': schemaContent
+    }
+  });
+}