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

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';