@izara_project/izara-core-generate-service-code 1.0.96 → 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/{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,20 +8,19 @@ import {
   emitAttributeTreeObjectSchemas,
   emitAttributeTreeRelationshipSchemas,
   attributeTreeObjectSchemaManagedPaths,
-  attributeTreeRelationshipSchemaManagedPaths,
-  resolveTargetServicePath,
-  emitAttributeTreeTargetSchemas
-} from '../src/emit/attributeTree/emitAttributeTreeSchemas.js';
-import { generate } from '../src/generate.js';
-
-const projectRoots = new Set();
+  attributeTreeRelationshipSchemaManagedPaths
+} 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 3 object schemas per attributeTree tag', () => {
@@ -53,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) =>
@@ -102,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'));
@@ -149,23 +148,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/generatedCode/attributeTree/sellOfferTermLink.js';
+  const relRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/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/);
 
@@ -173,10 +168,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'
   });
 });
@@ -185,21 +180,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: [
@@ -210,9 +190,7 @@ async function createProjectWithAttributeTree({
     ],`
     : '    addOnDataStructure: [],';
 
-  await writeFile(
-    join(schemaRoot, 'ObjectSchemas/SellOffer.js'),
-    `export default [
+  const schemaContent = `export default [
   {
     objectType: 'sellOffer',
     canDelete: false,
@@ -244,58 +222,24 @@ async function createProjectWithAttributeTree({
     ]
   }
 ];
-`
-  );
-
-  return rootPath;
-}
-
-test('resolveTargetServicePath prioritizes dev suffix and matches attributeTag', async () => {
-  const tmpRoot = await mkdtemp(join(tmpdir(), 'izara-services-test-'));
-  projectRoots.add(tmpRoot);
-
-  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);
-});
+`;
+
+  if (existingRoot) {
+    await writeProjectFile(
+      existingRoot,
+      'app/src/schemas/ObjectSchemas/SellOffer.js',
+      schemaContent
+    );
+    return existingRoot;
+  }
 
-test('emitAttributeTreeTargetSchemas produces expected standard schemas', () => {
-  const targetDir = '/dummy/path/izara-market-products-sellOfferTerm';
-  const artifacts = emitAttributeTreeTargetSchemas({
-    attributeTag: 'sellOfferTerm',
-    targetServiceRoot: targetDir
+  return await createTestProject({
+    prefix: 'izara-attr-tree-test-',
+    serviceTag: 'SellOfferManager',
+    schemas: {
+      'ObjectSchemas/SellOffer.js': schemaContent
+    }
   });
+}
 
-  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(() =>