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

package/test/unit/schemas/attributeTreeDirectives.test.js

@@ -0,0 +1,177 @@
+import assert from 'node:assert/strict';
+import test, { after } from 'node:test';
+
+import {
+  loadGenerateDirectives
+} from '../../../src/compile/loadSchemas.js';
+import {
+  emitAttributeTreeTargetValueStandard,
+  attributeTreeTargetValueStandardManagedPaths
+} from '../../../src/emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js';
+import { generate } from '../../../src/generate.js';
+import {
+  createTestProject,
+  readProjectFile,
+  writeProjectFile,
+  cleanupTestProjects
+} from '../../helpers/testProject.js';
+
+after(async () => {
+  await cleanupTestProjects();
+});
+
+test('loadGenerateDirectives returns empty array when directory missing', async () => {
+  const rootPath = await createTestProject({
+    prefix: 'izara-no-directives-test-',
+    serviceTag: 'TestService'
+  });
+  const project = { schemaRoot: `${rootPath}/app/src/schemas` };
+  const directives = await loadGenerateDirectives(project);
+  assert.deepEqual(directives, []);
+});
+
+test('loadGenerateDirectives loads directives from GenerateDirectives folder', async () => {
+  const rootPath = await createTestProject({
+    prefix: 'izara-directives-load-test-',
+    serviceTag: 'SellOfferTermManager',
+    schemas: {
+      'GenerateDirectives/sellOfferTermValueStandard.js': `export default {
+  type: 'attributeTreeTarget',
+  attributeTreeTag: 'sellOfferTerm'
+};
+`
+    }
+  });
+  const project = { schemaRoot: `${rootPath}/app/src/schemas` };
+  const directives = await loadGenerateDirectives(project);
+  assert.equal(directives.length, 1);
+  assert.equal(directives[0].type, 'attributeTreeTarget');
+  assert.equal(directives[0].attributeTreeTag, 'sellOfferTerm');
+});
+
+test('emitAttributeTreeTargetValueStandard emits expected schema with hook', () => {
+  const directives = [
+    {
+      type: 'attributeTreeTarget',
+      attributeTreeTag: 'sellOfferTerm'
+    }
+  ];
+
+  const managedPaths =
+    attributeTreeTargetValueStandardManagedPaths(directives);
+  assert.deepEqual(managedPaths, [
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js'
+  ]);
+
+  const artifacts = emitAttributeTreeTargetValueStandard({ directives });
+  assert.equal(artifacts.length, 1);
+
+  const artifact = artifacts[0];
+  assert.equal(
+    artifact.path,
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js'
+  );
+  assert.match(
+    artifact.content,
+    /objectType:\s*['"]sellOfferTermValueStandard['"]/
+  );
+  assert.match(artifact.content, /sellOfferTermValueStandardId/);
+  assert.match(
+    artifact.content,
+    /\/\/\(<addOnDataStructuresellOfferTermValueStandard>\)/
+  );
+  assert.match(
+    artifact.content,
+    /\/\/\(<\/addOnDataStructuresellOfferTermValueStandard>\)/
+  );
+  assert.match(artifact.content, /propertyValue/);
+  assert.match(artifact.content, /GraphHandler/);
+});
+
+test('managed paths and emitter return empty when no matching directives', () => {
+  assert.deepEqual(attributeTreeTargetValueStandardManagedPaths([]), []);
+  assert.deepEqual(
+    attributeTreeTargetValueStandardManagedPaths([{ type: 'other' }]),
+    []
+  );
+  assert.deepEqual(emitAttributeTreeTargetValueStandard({ directives: [] }), []);
+});
+
+test('generate commits and cleans up attributeTreeTarget dynamic schemas', async () => {
+  const rootPath = await createTestProject({
+    prefix: 'izara-directives-gen-test-',
+    serviceTag: 'SellOfferTermManager',
+    schemas: {
+      'GenerateDirectives/sellOfferTermValueStandard.js': `export default {
+  type: 'attributeTreeTarget',
+  attributeTreeTag: 'sellOfferTerm'
+};
+`
+    }
+  });
+
+  await generate(rootPath);
+
+  const targetRelPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js';
+  const content = await readProjectFile(rootPath, targetRelPath);
+  assert.match(content, /sellOfferTermValueStandard/);
+  assert.match(
+    content,
+    /\/\/\(<addOnDataStructuresellOfferTermValueStandard>\)/
+  );
+
+  // Regeneration preserves user changes inside the hook
+  const modifiedContent = content.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, targetRelPath, modifiedContent);
+
+  await generate(rootPath);
+
+  const regeneratedContent = await readProjectFile(rootPath, targetRelPath);
+  assert.match(
+    regeneratedContent,
+    /type:\s*'propertyValue'/
+  );
+
+  // Cascading verification: PropertyValue schemas generated in phase 2
+  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 propLabelContent = await readProjectFile(rootPath, propLabelPath);
+  assert.match(propLabelContent, /sellOfferTermValueStandardPropertyLabel/);
+
+  const propValueContent = await readProjectFile(rootPath, propValuePath);
+  assert.match(propValueContent, /sellOfferTermValueStandardPropertyValue/);
+
+  const hasPropRelContent = await readProjectFile(rootPath, hasPropRelPath);
+  assert.match(hasPropRelContent, /hasSellOfferTermValueStandardPropertyValue/);
+
+  const disPropRelContent = await readProjectFile(rootPath, disPropRelPath);
+  assert.match(disPropRelContent, /disabledSellOfferTermValueStandardPropertyValue/);
+
+  const isPropRelContent = await readProjectFile(rootPath, isPropRelPath);
+  assert.match(isPropRelContent, /isSellOfferTermValueStandardPropertyLabel/);
+
+  // When directive removed, file is cleaned up
+  await writeProjectFile(
+    rootPath,
+    'app/src/schemas/GenerateDirectives/sellOfferTermValueStandard.js',
+    'export default { type: "disabled" };\n'
+  );
+  await generate(rootPath);
+
+  await assert.rejects(readProjectFile(rootPath, targetRelPath), {
+    code: 'ENOENT'
+  });
+});

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 {
@@ -54,9 +52,9 @@ test('emitAttributeTreeObjectSchemas returns 3 object schemas per attributeTree
 
   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'
   ]);
 
   const valueArtifact = artifacts.find((a) =>
@@ -103,10 +101,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,9 +151,9 @@ 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 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/);
@@ -244,53 +242,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/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
+    }
+  });
+}