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

package/test/{attributeTreeSchemas.test.js → unit/schemas/attributeTreeSchemas.test.js}

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test, { after } from 'node:test';
@@ -8,21 +8,24 @@ import {
   emitAttributeTreeObjectSchemas,
   emitAttributeTreeRelationshipSchemas,
   attributeTreeObjectSchemaManagedPaths,
-  attributeTreeRelationshipSchemaManagedPaths
-} from '../src/emit/attributeTree/emitAttributeTreeSchemas.js';
-import { generate } from '../src/generate.js';
-
-const projectRoots = new Set();
+  attributeTreeRelationshipSchemaManagedPaths,
+  resolveTargetServicePath,
+  emitAttributeTreeTargetSchemas
+} from '../../../src/emit/schemas/attributeTree/emitAttributeTreeSchemas.js';
+import { generate } from '../../../src/generate.js';
+import {
+  createTestProject,
+  readProjectFile,
+  writeProjectFile,
+  cleanupTestProjects,
+  trackTestProject
+} from '../../helpers/testProject.js';
 
 after(async () => {
-  await Promise.all(
-    [...projectRoots].map((rootPath) =>
-      rm(rootPath, { recursive: true, force: true })
-    )
-  );
+  await cleanupTestProjects();
 });
 
-test('emitAttributeTreeObjectSchemas returns 4 object schemas per attributeTree tag', () => {
+test('emitAttributeTreeObjectSchemas returns 3 object schemas per attributeTree tag', () => {
   const objects = [
     {
       objectType: 'sellOffer',
@@ -47,16 +50,21 @@ test('emitAttributeTreeObjectSchemas returns 4 object schemas per attributeTree
   ];
 
   const artifacts = emitAttributeTreeObjectSchemas({ objects });
-  assert.equal(artifacts.length, 4);
+  assert.equal(artifacts.length, 3);
 
   const paths = artifacts.map((a) => a.path);
   assert.deepEqual(paths, [
     'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLink.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/attributeSellOfferTermValue.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLabel.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermValueStandard.js'
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermValue.js',
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLabel.js'
   ]);
 
+  const valueArtifact = artifacts.find((a) =>
+    a.path.endsWith('sellOfferTermValue.js')
+  );
+  assert.match(valueArtifact.content, /"objectType": "sellOfferTermValue"/);
+  assert.match(valueArtifact.content, /"sellOfferTermValueId"/);
+
   for (const artifact of artifacts) {
     assert.doesNotMatch(artifact.content, /dynamoDB/);
     assert.match(artifact.content, /GraphHandler/);
@@ -101,6 +109,31 @@ test('emitAttributeTreeRelationshipSchemas returns 4 relationship schemas per at
     'app/src/schemas/RelationshipSchemas/generatedAttributeTree/isSellOfferTermLabel.js'
   ]);
 
+  const hasRel = artifacts.find((a) => a.path.endsWith('hasSellOfferTermLink.js'));
+  assert.match(hasRel.content, /"generatedBy": "user"/);
+  assert.match(hasRel.content, /"requiredOnCreate": true/);
+
+  const disabledRel = artifacts.find((a) =>
+    a.path.endsWith('disabledSellOfferTermLink.js')
+  );
+  assert.match(disabledRel.content, /"generatedBy": "user"/);
+
+  const isRel = artifacts.find((a) => a.path.endsWith('isSellOfferTerm.js'));
+  assert.match(isRel.content, /"generatedBy": "systemNoUser"/);
+  assert.match(isRel.content, /"objectType": "sellOfferTermValue"/);
+  assert.match(isRel.content, /"requiredOnCreate": true/);
+
+  const isLabelRel = artifacts.find((a) =>
+    a.path.endsWith('isSellOfferTermLabel.js')
+  );
+  assert.match(isLabelRel.content, /"generatedBy": "systemNoUser"/);
+  assert.match(isLabelRel.content, /"requiredOnCreate": true/);
+  // from objType should be sellOfferTermValue
+  assert.match(
+    isLabelRel.content,
+    /"from":\s*\{\s*"objType":\s*\{[^}]*"objectType": "sellOfferTermValue"/
+  );
+
   for (const artifact of artifacts) {
     assert.doesNotMatch(artifact.content, /dynamoDB/);
     assert.match(artifact.content, /GraphHandler/);
@@ -117,23 +150,19 @@ test('managed paths return empty array when no attributeTree is present', () =>
 
 test('generate commits and cleans up attributeTree dynamic schemas', async () => {
   const rootPath = await createProjectWithAttributeTree({ hasAddOn: true });
-  const result = await generate(rootPath);
+  await generate(rootPath);
 
-  const expectedObjectPath = join(
-    rootPath,
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLink.js'
-  );
-  const expectedRelPath = join(
-    rootPath,
-    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/hasSellOfferTermLink.js'
-  );
+  const objectRelPath =
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLink.js';
+  const relRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/hasSellOfferTermLink.js';
 
-  const objectContent = await readFile(expectedObjectPath, 'utf8');
+  const objectContent = await readProjectFile(rootPath, objectRelPath);
   assert.match(objectContent, /sellOfferTermLink/);
   assert.match(objectContent, /GraphHandler/);
   assert.doesNotMatch(objectContent, /dynamoDB/);
 
-  const relContent = await readFile(expectedRelPath, 'utf8');
+  const relContent = await readProjectFile(rootPath, relRelPath);
   assert.match(relContent, /hasSellOfferTermLink/);
   assert.match(relContent, /sellOfferTermLink/);
 
@@ -141,10 +170,10 @@ test('generate commits and cleans up attributeTree dynamic schemas', async () =>
   await createProjectWithAttributeTree({ rootPath, hasAddOn: false });
   await generate(rootPath);
 
-  await assert.rejects(readFile(expectedObjectPath, 'utf8'), {
+  await assert.rejects(readProjectFile(rootPath, objectRelPath), {
     code: 'ENOENT'
   });
-  await assert.rejects(readFile(expectedRelPath, 'utf8'), {
+  await assert.rejects(readProjectFile(rootPath, relRelPath), {
     code: 'ENOENT'
   });
 });
@@ -153,21 +182,6 @@ async function createProjectWithAttributeTree({
   rootPath: existingRoot,
   hasAddOn = true
 } = {}) {
-  const rootPath =
-    existingRoot || (await mkdtemp(join(tmpdir(), 'izara-attr-tree-test-')));
-  projectRoots.add(rootPath);
-
-  const schemaRoot = join(rootPath, 'app/src/schemas');
-  await mkdir(join(schemaRoot, 'ObjectSchemas'), { recursive: true });
-  await mkdir(join(schemaRoot, 'RelationshipSchemas'), { recursive: true });
-  await mkdir(join(schemaRoot, 'FlowSchemas'), { recursive: true });
-  await mkdir(join(rootPath, 'config'), { recursive: true });
-
-  await writeFile(
-    join(rootPath, 'config/serverless.config.yml'),
-    'service: SellOfferManager\ncustom:\n  serviceTag: SellOfferManager\n'
-  );
-
   const addOnContent = hasAddOn
     ? `
     addOnDataStructure: [
@@ -178,9 +192,7 @@ async function createProjectWithAttributeTree({
     ],`
     : '    addOnDataStructure: [],';
 
-  await writeFile(
-    join(schemaRoot, 'ObjectSchemas/SellOffer.js'),
-    `export default [
+  const schemaContent = `export default [
   {
     objectType: 'sellOffer',
     canDelete: false,
@@ -212,8 +224,73 @@ async function createProjectWithAttributeTree({
     ]
   }
 ];
-`
-  );
+`;
+
+  if (existingRoot) {
+    await writeProjectFile(
+      existingRoot,
+      'app/src/schemas/ObjectSchemas/SellOffer.js',
+      schemaContent
+    );
+    return existingRoot;
+  }
 
-  return rootPath;
+  return await createTestProject({
+    prefix: 'izara-attr-tree-test-',
+    serviceTag: 'SellOfferManager',
+    schemas: {
+      'ObjectSchemas/SellOffer.js': schemaContent
+    }
+  });
 }
+
+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/{dynamicCrudFlowSchemas.test.js → unit/schemas/dynamicCrudFlowSchemas.test.js}

@@ -5,8 +5,8 @@ import { join } from 'node:path';
 import test from 'node:test';
 import { pathToFileURL } from 'node:url';
 
-import { generateDynamicCrudFlowSchemas } from '../src/emit/crud/generateDynamicCrudFlowSchemas.js';
-import { createCrudActionPlans } from '../src/emit/crud/crudActionPlan.js';
+import { generateDynamicCrudFlowSchemas } from '../../../src/emit/application/crud/generateDynamicCrudFlowSchemas.js';
+import { createCrudActionPlans } from '../../../src/emit/application/crud/crudActionPlan.js';
 
 test('generates dynamic CRUD schemas from local schema modules', async () => {
   const rootPath = await createProject({

package/test/{dynamicRbacFlowSchemas.test.js → unit/schemas/dynamicRbacFlowSchemas.test.js}

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import test, { after } from 'node:test';
 import { pathToFileURL } from 'node:url';
 
-import { generateDynamicRbacFlowSchemas } from '../src/emit/rbac/generateDynamicRbacFlowSchemas.js';
+import { generateDynamicRbacFlowSchemas } from '../../../src/emit/application/rbac/generateDynamicRbacFlowSchemas.js';
 
 const projectRoots = new Set();
 const STATIC_RBAC_ACTIONS = [

package/test/{dynamicRelationshipFlowSchemas.test.js → unit/schemas/dynamicRelationshipFlowSchemas.test.js}

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import test, { after } from 'node:test';
 import { pathToFileURL } from 'node:url';
 
-import { generateDynamicRelationshipFlowSchemas } from '../src/emit/relationship/generateDynamicRelationshipFlowSchemas.js';
+import { generateDynamicRelationshipFlowSchemas } from '../../../src/emit/application/relationship/generateDynamicRelationshipFlowSchemas.js';
 
 const RELATIONSHIP_ACTIONS = [
   'CreateRelationship',
@@ -60,6 +60,16 @@ test('generates dynamic relationship schemas when declared relationships exist',
     'userId',
     'correlationId'
   ]);
+  const completeStep = create.flowSteps.find(
+    (step) => step.stepName === 'Complete'
+  );
+  assert.deepEqual(completeStep.properties, [
+    'returnValue',
+    'parentFlowId',
+    'status',
+    'foundErrors',
+    'graphServiceTag'
+  ]);
   assert.deepEqual(get.event, [
     'lambdaSyncInv',
     'lambdaSyncApi',

package/test/{errorSchemas.test.js → unit/schemas/errorSchemas.test.js}

@@ -8,8 +8,8 @@ import {
   emitErrorSchemas,
   errorSchemaManagedPaths,
   ERROR_SCHEMA_PATH
-} from '../src/emit/error/emitErrorSchemas.js';
-import { generate } from '../src/generate.js';
+} from '../../../src/emit/schemas/error/emitErrorSchemas.js';
+import { generate } from '../../../src/generate.js';
 
 const roots = new Set();
 after(() =>

package/test/unit/schemas/ledgerSchemas.test.js

@@ -0,0 +1,263 @@
+import assert from 'node:assert/strict';
+import test, { after } from 'node:test';
+
+import {
+  emitLedgerObjectSchemas,
+  emitLedgerRelationshipSchemas,
+  ledgerObjectSchemaManagedPaths,
+  ledgerRelationshipSchemaManagedPaths
+} from '../../../src/emit/schemas/ledger/emitLedgerSchemas.js';
+import { generate } from '../../../src/generate.js';
+import {
+  createTestProject,
+  readProjectFile,
+  writeProjectFile,
+  cleanupTestProjects
+} from '../../helpers/testProject.js';
+
+after(async () => {
+  await cleanupTestProjects();
+});
+
+test('emitLedgerObjectSchemas returns 1 object schema per ledger addOn', () => {
+  const objects = [
+    {
+      objectType: 'unitStandard',
+      serviceTag: 'UnitStandard',
+      storageResources: {
+        graph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'ledger',
+          prefix: 'unitStandardSupplyLocation',
+          storageResourceTag: 'graph',
+          ledgerType: 'movable',
+          targetObjType: {
+            serviceTag: 'SupplyLocationStandard',
+            objectType: 'supplyLocation'
+          },
+          moveToTargetObjTypes: [
+            {
+              serviceTag: 'UnitPacking',
+              objectType: 'unitPacking'
+            }
+          ]
+        },
+        {
+          type: 'ledger',
+          prefix: 'unitStandardUnitPacking',
+          storageResourceTag: 'graph',
+          ledgerType: 'movable',
+          targetObjType: {
+            serviceTag: 'SupplyLocationStandard',
+            objectType: 'supplyLocation'
+          }
+        }
+      ]
+    }
+  ];
+
+  const artifacts = emitLedgerObjectSchemas({ objects });
+  assert.equal(artifacts.length, 2);
+
+  const paths = artifacts.map((a) => a.path);
+  assert.deepEqual(paths, [
+    'app/src/schemas/ObjectSchemas/generatedLedger/unitStandardSupplyLocationEntry.js',
+    'app/src/schemas/ObjectSchemas/generatedLedger/unitStandardUnitPackingEntry.js'
+  ]);
+
+  const entryArtifact = artifacts[0];
+  assert.match(
+    entryArtifact.content,
+    /"objectType": "unitStandardSupplyLocationEntry"/
+  );
+  assert.match(entryArtifact.content, /"unitStandardSupplyLocationEntryId"/);
+  assert.match(entryArtifact.content, /"generatedBy": "systemNoUser"/);
+  assert.match(entryArtifact.content, /"canDelete": false/);
+  assert.match(entryArtifact.content, /GraphHandler/);
+});
+
+test('emitLedgerRelationshipSchemas returns current, old, and is relationship schemas per ledger addOn', () => {
+  const objects = [
+    {
+      objectType: 'unitStandard',
+      serviceTag: 'UnitStandard',
+      storageResources: {
+        graph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'ledger',
+          prefix: 'unitStandardSupplyLocation',
+          storageResourceTag: 'graph',
+          ledgerType: 'movable',
+          targetObjType: {
+            serviceTag: 'SupplyLocationStandard',
+            objectType: 'supplyLocation'
+          },
+          moveToTargetObjTypes: [
+            {
+              serviceTag: 'UnitPacking',
+              objectType: 'unitPacking'
+            }
+          ]
+        }
+      ]
+    }
+  ];
+
+  const artifacts = emitLedgerRelationshipSchemas({
+    objects,
+    serviceTag: 'UnitStandard'
+  });
+  assert.equal(artifacts.length, 3);
+
+  const paths = artifacts.map((a) => a.path);
+  assert.deepEqual(paths, [
+    'app/src/schemas/RelationshipSchemas/generatedLedger/currentUnitStandardSupplyLocation.js',
+    'app/src/schemas/RelationshipSchemas/generatedLedger/oldUnitStandardSupplyLocation.js',
+    'app/src/schemas/RelationshipSchemas/generatedLedger/isUnitStandardSupplyLocationEntry.js'
+  ]);
+
+  // 1. Current relationship
+  const currentRel = artifacts.find((a) =>
+    a.path.endsWith('currentUnitStandardSupplyLocation.js')
+  );
+  assert.match(currentRel.content, /"currentUnitStandardSupplyLocation"/);
+  assert.match(currentRel.content, /"generatedBy": "user"/);
+  assert.match(currentRel.content, /"fromTimestamp"/);
+  assert.match(
+    currentRel.content,
+    /"relationshipTag": "oldUnitStandardSupplyLocation"/
+  );
+  assert.match(currentRel.content, /"belongTo": true/);
+
+  // 2. Old relationship
+  const oldRel = artifacts.find((a) =>
+    a.path.endsWith('oldUnitStandardSupplyLocation.js')
+  );
+  assert.match(oldRel.content, /"oldUnitStandardSupplyLocation"/);
+  assert.match(oldRel.content, /"generatedBy": "systemWithUser"/);
+  assert.match(oldRel.content, /"fromTimestamp"/);
+  assert.match(oldRel.content, /"toTimestamp"/);
+
+  // 3. IsEntry relationship
+  const isRel = artifacts.find((a) =>
+    a.path.endsWith('isUnitStandardSupplyLocationEntry.js')
+  );
+  assert.match(isRel.content, /"isUnitStandardSupplyLocationEntry"/);
+  assert.match(isRel.content, /"generatedBy": "systemNoUser"/);
+  assert.match(isRel.content, /"supplyLocation"/);
+  assert.match(isRel.content, /"unitPacking"/);
+});
+
+test('managed paths return empty array when no ledger is present', () => {
+  const objects = [{ objectType: 'user', addOnDataStructure: [] }];
+  assert.deepEqual(ledgerObjectSchemaManagedPaths(objects), []);
+  assert.deepEqual(ledgerRelationshipSchemaManagedPaths(objects), []);
+  assert.deepEqual(emitLedgerObjectSchemas({ objects }), []);
+  assert.deepEqual(emitLedgerRelationshipSchemas({ objects }), []);
+});
+
+test('generate commits and cleans up ledger dynamic schemas', async () => {
+  const rootPath = await createProjectWithLedger({ hasAddOn: true });
+  await generate(rootPath);
+
+  const objectRelPath =
+    'app/src/schemas/ObjectSchemas/generatedLedger/unitStandardSupplyLocationEntry.js';
+  const relRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedLedger/currentUnitStandardSupplyLocation.js';
+
+  const objectContent = await readProjectFile(rootPath, objectRelPath);
+  assert.match(objectContent, /unitStandardSupplyLocationEntry/);
+  assert.match(objectContent, /GraphHandler/);
+
+  const relContent = await readProjectFile(rootPath, relRelPath);
+  assert.match(relContent, /currentUnitStandardSupplyLocation/);
+  assert.match(relContent, /oldUnitStandardSupplyLocation/);
+
+  // Re-run without addOn to verify stale file cleanup
+  await createProjectWithLedger({ rootPath, hasAddOn: false });
+  await generate(rootPath);
+
+  await assert.rejects(readProjectFile(rootPath, objectRelPath), {
+    code: 'ENOENT'
+  });
+  await assert.rejects(readProjectFile(rootPath, relRelPath), {
+    code: 'ENOENT'
+  });
+});
+
+async function createProjectWithLedger({
+  rootPath: existingRoot,
+  hasAddOn = true
+} = {}) {
+  const addOnContent = hasAddOn
+    ? `
+    addOnDataStructure: [
+      {
+        type: 'ledger',
+        prefix: 'unitStandardSupplyLocation',
+        storageResourceTag: 'graph',
+        ledgerType: 'movable',
+        targetObjType: {
+          serviceTag: 'SupplyLocationStandard',
+          objectType: 'supplyLocation'
+        }
+      }
+    ],`
+    : '    addOnDataStructure: [],';
+
+  const schemaContent = `export default [
+  {
+    objectType: 'unitStandard',
+    canDelete: false,
+    generatedBy: 'user',${addOnContent}
+    storageResources: {
+      graph: {
+        storageType: 'graph',
+        graphServerTag: 'GraphHandler'
+      }
+    },
+    fieldNames: {
+      unitId: {
+        type: 'string',
+        randomOnCreate: true,
+        canUpdate: false,
+        storageResourceTags: ['graph']
+      }
+    },
+    identifiers: [
+      {
+        type: 'partitionKey',
+        fieldName: 'unitId'
+      }
+    ]
+  }
+];
+`;
+
+  if (existingRoot) {
+    await writeProjectFile(
+      existingRoot,
+      'app/src/schemas/ObjectSchemas/UnitStandard.js',
+      schemaContent
+    );
+    return existingRoot;
+  }
+
+  return await createTestProject({
+    prefix: 'izara-ledger-test-',
+    serviceTag: 'UnitStandard',
+    schemas: {
+      'ObjectSchemas/UnitStandard.js': schemaContent
+    }
+  });
+}

package/test/{systemTextSchemas.test.js → unit/schemas/systemTextSchemas.test.js}

@@ -1,21 +1,21 @@
 import assert from 'node:assert/strict';
-import { readFile, rm, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
 import test, { after } from 'node:test';
 
 import {
   emitSystemTextSchemas,
   systemTextSchemaManagedPaths
-} from '../src/emit/systemText/emitSystemTextSchemas.js';
-import { generate } from '../src/generate.js';
-
-const roots = new Set();
-after(() =>
-  Promise.all(
-    [...roots].map((root) => rm(root, { recursive: true, force: true }))
-  )
-);
+} from '../../../src/emit/schemas/systemText/emitSystemTextSchemas.js';
+import { generate } from '../../../src/generate.js';
+import {
+  createTestProject,
+  readProjectFile,
+  writeProjectFile,
+  cleanupTestProjects
+} from '../../helpers/testProject.js';
+
+after(async () => {
+  await cleanupTestProjects();
+});
 
 test('emitSystemTextSchemas produces expected structure for objects, flows, relationships, and notifications', async () => {
   const artifacts = await emitSystemTextSchemas({
@@ -107,33 +107,21 @@ test('emitSystemTextSchemas returns empty array when no inputs provided', async
 });
 
 test('generate preserves user hooks inside SystemTextSchemas.js across regeneration', async () => {
-  const rootPath = join(
-    tmpdir(),
-    `system-text-hook-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
-  );
-  roots.add(rootPath);
-  await mkdir(join(rootPath, 'app/src/schemas/ObjectSchemas'), {
-    recursive: true
+  const rootPath = await createTestProject({
+    prefix: 'system-text-hook-test-',
+    serverlessConfig: 'main_config:\n  iz_serviceTag: TestService\n',
+    schemas: {
+      'ObjectSchemas/Item.js':
+        "export default { objectType: 'item', fieldNames: { itemId: { type: 'string' } }, generatedBy: 'user' };\n"
+    }
   });
-  await mkdir(join(rootPath, 'config'), { recursive: true });
-
-  await writeFile(
-    join(rootPath, 'config/serverless.config.yml'),
-    'main_config:\n  iz_serviceTag: TestService\n'
-  );
-  await writeFile(
-    join(rootPath, 'app/src/schemas/ObjectSchemas/Item.js'),
-    "export default { objectType: 'item', fieldNames: { itemId: { type: 'string' } }, generatedBy: 'user' };\n"
-  );
 
   // First generate
   await generate(rootPath);
 
-  const targetFile = join(
-    rootPath,
-    'app/src/schemas/SystemTextSchemas/generatedCode/SystemTextSchemas.js'
-  );
-  const initialContent = await readFile(targetFile, 'utf8');
+  const targetRelPath =
+    'app/src/schemas/SystemTextSchemas/generatedCode/SystemTextSchemas.js';
+  const initialContent = await readProjectFile(rootPath, targetRelPath);
   assert.match(initialContent, /\/\/\(<item_TestServiceitemIdHook>\)/);
 
   // User edits inside hook
@@ -141,12 +129,12 @@ test('generate preserves user hooks inside SystemTextSchemas.js across regenerat
     '//(<item_TestServiceitemIdHook>)\n    //(</item_TestServiceitemIdHook>)',
     '//(<item_TestServiceitemIdHook>)\n    customTranslation: "Item ID Value",\n    //(</item_TestServiceitemIdHook>)'
   );
-  await writeFile(targetFile, modifiedContent);
+  await writeProjectFile(rootPath, targetRelPath, modifiedContent);
 
   // Second generate (regeneration)
   await generate(rootPath);
 
-  const regeneratedContent = await readFile(targetFile, 'utf8');
+  const regeneratedContent = await readProjectFile(rootPath, targetRelPath);
   assert.match(
     regeneratedContent,
     /customTranslation:\s*"Item ID Value"/

package/src/emit/crud/loadLocalSchemaArrays.js

@@ -1,4 +0,0 @@
-/**
- * @deprecated Use `loadLocalSchemaArrays` from `../../compile/loadSchemas.js` instead.
- */
-export { loadLocalSchemaArrays } from '../../compile/loadSchemas.js';