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

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

@@ -0,0 +1,289 @@
+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', async () => {
+  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 = await 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', async () => {
+  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 = await 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"/);
+
+  // 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', async () => {
+  const objects = [{ objectType: 'user', addOnDataStructure: [] }];
+  assert.deepEqual(ledgerObjectSchemaManagedPaths(objects), []);
+  assert.deepEqual(ledgerRelationshipSchemaManagedPaths(objects), []);
+  assert.deepEqual(await emitLedgerObjectSchemas({ objects }), []);
+  assert.deepEqual(await 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/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
+    }
+  });
+}

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"/