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

package/test/unit/schemas/attributeTreeSingleService.test.js

@@ -0,0 +1,175 @@
+import assert from 'node:assert/strict';
+import test, { after } from 'node:test';
+import { generate } from '../../../src/generate.js';
+import {
+  createTestProject,
+  readProjectFile,
+  writeProjectFile,
+  cleanupTestProjects
+} from '../../helpers/testProject.js';
+
+after(async () => {
+  await cleanupTestProjects();
+});
+
+test('single-service attributeTree generation and propertyValue cascading', async () => {
+  const initialSchema = `export default [
+  {
+    objectType: 'sellOffer',
+    canDelete: false,
+    generatedBy: 'user',
+    addOnDataStructure: [
+      {
+        type: 'attributeTree',
+        attributeTreeTag: 'sellOfferTerm'
+      }
+    ],
+    storageResources: {
+      dynamoDB: {
+        storageType: 'dynamoDB',
+        tableName: 'SellOfferRecords',
+        serviceTag: 'SellOfferManager'
+      },
+      myGraph: {
+        storageType: 'graph',
+        graphServerTag: 'GraphHandler'
+      }
+    },
+    fieldNames: {
+      sellOfferId: {
+        type: 'string',
+        randomOnCreate: true,
+        canUpdate: false,
+        storageResourceTags: ['dynamoDB', 'myGraph']
+      }
+    },
+    identifiers: [
+      {
+        type: 'partitionKey',
+        fieldName: 'sellOfferId'
+      }
+    ]
+  }
+];
+`;
+
+  const rootPath = await createTestProject({
+    prefix: 'izara-single-service-attr-tree-',
+    serviceTag: 'SellOfferManager',
+    schemas: {
+      'ObjectSchemas/SellOffer.js': initialSchema
+    }
+  });
+
+  // Phase 1: generate produces all 4 ObjectSchemas and 4 RelationshipSchemas
+  await generate(rootPath);
+
+  const linkPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLink.js';
+  const valuePath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValue.js';
+  const labelPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermLabel.js';
+  const valueStandardPath =
+    'app/src/schemas/ObjectSchemas/generatedCode/attributeTree/sellOfferTermValueStandard.js';
+
+  const linkContent = await readProjectFile(rootPath, linkPath);
+  assert.match(linkContent, /sellOfferTermLink/);
+
+  const valueContent = await readProjectFile(rootPath, valuePath);
+  assert.match(valueContent, /sellOfferTermValue/);
+
+  const labelContent = await readProjectFile(rootPath, labelPath);
+  assert.match(labelContent, /sellOfferTermLabel/);
+
+  const valueStandardContent = await readProjectFile(
+    rootPath,
+    valueStandardPath
+  );
+  assert.match(valueStandardContent, /sellOfferTermValueStandard/);
+  assert.match(
+    valueStandardContent,
+    /\/\/\(<addOnDataStructuresellOfferTermValueStandard>\)/
+  );
+
+  // Check relationship schemas
+  const hasLinkRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/hasSellOfferTermLink.js';
+  const hasLinkRel = await readProjectFile(rootPath, hasLinkRelPath);
+  assert.match(hasLinkRel, /hasSellOfferTermLink/);
+
+  // Phase 2: developer uncomments propertyValue addOn in ValueStandard
+  const modifiedValueStandard = valueStandardContent.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, valueStandardPath, modifiedValueStandard);
+
+  await generate(rootPath);
+
+  // Verify hook preservation
+  const reloadedValueStandard = await readProjectFile(
+    rootPath,
+    valueStandardPath
+  );
+  assert.match(reloadedValueStandard, /type:\s*'propertyValue'/);
+
+  // Verify cascading generation: propertyValue domain in the same repo
+  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 propLabel = await readProjectFile(rootPath, propLabelPath);
+  assert.match(propLabel, /sellOfferTermValueStandardPropertyLabel/);
+
+  const propValue = await readProjectFile(rootPath, propValuePath);
+  assert.match(propValue, /sellOfferTermValueStandardPropertyValue/);
+
+  const hasPropRel = await readProjectFile(rootPath, hasPropRelPath);
+  assert.match(hasPropRel, /hasSellOfferTermValueStandardPropertyValue/);
+
+  const disPropRel = await readProjectFile(rootPath, disPropRelPath);
+  assert.match(disPropRel, /disabledSellOfferTermValueStandardPropertyValue/);
+
+  const isPropRel = await readProjectFile(rootPath, isPropRelPath);
+  assert.match(isPropRel, /isSellOfferTermValueStandardPropertyLabel/);
+
+  // Cleanup check: remove attributeTree addOn from base schema
+  const cleanSchema = `export default [
+  {
+    objectType: 'sellOffer',
+    canDelete: false,
+    generatedBy: 'user',
+    addOnDataStructure: [],
+    storageResources: {
+      myGraph: { storageType: 'graph', graphServerTag: 'GraphHandler' }
+    },
+    fieldNames: {
+      sellOfferId: { type: 'string', storageResourceTags: ['myGraph'] }
+    },
+    identifiers: [{ type: 'partitionKey', fieldName: 'sellOfferId' }]
+  }
+];
+`;
+  await writeProjectFile(
+    rootPath,
+    'app/src/schemas/ObjectSchemas/SellOffer.js',
+    cleanSchema
+  );
+  await generate(rootPath);
+
+  // All attributeTree schemas should be removed
+  await assert.rejects(readProjectFile(rootPath, linkPath), { code: 'ENOENT' });
+  await assert.rejects(readProjectFile(rootPath, valuePath), { code: 'ENOENT' });
+  await assert.rejects(readProjectFile(rootPath, labelPath), { code: 'ENOENT' });
+  await assert.rejects(readProjectFile(rootPath, valueStandardPath), {
+    code: 'ENOENT'
+  });
+});

package/test/unit/templates/hookTagsValidation.test.js

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import test from 'node:test';
+
+async function getTemplateFiles(dir) {
+  let results = [];
+  const entries = await readdir(dir);
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const entryStat = await stat(fullPath);
+    if (entryStat.isDirectory()) {
+      const subResults = await getTemplateFiles(fullPath);
+      results = results.concat(subResults);
+    } else if (entry.endsWith('.ejs') || entry.endsWith('.js')) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+test('all template files have valid hook tag syntax and matching pairs', async () => {
+  const emitDir = join(process.cwd(), 'src/emit');
+  const templateFiles = await getTemplateFiles(emitDir);
+  assert.ok(templateFiles.length > 0, 'Should find template files in src/emit');
+
+  const syntaxErrors = [];
+
+  for (const filePath of templateFiles) {
+    const content = await readFile(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    const openTags = [];
+    const closeTags = [];
+
+    lines.forEach((line, lineIndex) => {
+      // Mask EJS expressions to avoid evaluating dynamic tags
+      const stripped = line.replace(/<%[\s\S]*?%>/g, 'DYNAMIC');
+
+      // Check for malformed hook opening/closing missing '>' before ')'
+      // e.g. //(<foo) or //(</foo) without closing angle bracket
+      const malformedMatch = stripped.match(/\/\/\s*\(\s*<\/?[^>\n]*\)/);
+      if (malformedMatch) {
+        syntaxErrors.push({
+          file: filePath,
+          line: lineIndex + 1,
+          type: 'MISSING_CLOSING_ANGLE_BRACKET',
+          snippet: line.trim()
+        });
+      }
+
+      // Collect normalized hook tags for matching
+      const openMatches = stripped.matchAll(/\/\/\s*\(<\s*([\w.-]+)\s*>\)/g);
+      for (const m of openMatches) {
+        openTags.push({ tag: m[1], line: lineIndex + 1 });
+      }
+
+      const closeMatches = stripped.matchAll(/\/\/\s*\(<\/\s*([\w.-]+)\s*>\)/g);
+      for (const m of closeMatches) {
+        closeTags.push({ tag: m[1], line: lineIndex + 1 });
+      }
+    });
+
+    // Check count of open and close tags
+    if (openTags.length !== closeTags.length) {
+      syntaxErrors.push({
+        file: filePath,
+        type: 'MISMATCHED_HOOK_PAIR_COUNT',
+        openCount: openTags.length,
+        closeCount: closeTags.length,
+        openTags: openTags.map((t) => t.tag),
+        closeTags: closeTags.map((t) => t.tag)
+      });
+    }
+  }
+
+  assert.deepEqual(
+    syntaxErrors,
+    [],
+    `Found ${syntaxErrors.length} template hook syntax error(s):\n` +
+      JSON.stringify(syntaxErrors, null, 2)
+  );
+});

package/src/emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js

@@ -1,132 +0,0 @@
-/**
- * Emits target ValueStandard ObjectSchema for attributeTreeTarget directives
- */
-
-function _extractTargetDirectives(directives = []) {
-  if (!Array.isArray(directives)) {
-    return [];
-  }
-  const results = [];
-  const seenTags = new Set();
-
-  for (const directive of directives) {
-    if (
-      directive?.type === 'attributeTreeTarget' &&
-      directive?.attributeTreeTag
-    ) {
-      const tag = directive.attributeTreeTag;
-      if (seenTags.has(tag)) {
-        continue;
-      }
-      seenTags.add(tag);
-      results.push(directive);
-    }
-  }
-
-  return results;
-}
-
-function _extractStorageResources(directive) {
-  if (directive?.storageResources) {
-    return directive.storageResources;
-  }
-  return {
-    myGraph: {
-      storageType: 'graph',
-      graphServerTag: 'GraphHandler'
-    }
-  };
-}
-
-function _renderTargetValueStandardSchema(tag, storageResources) {
-  const storageResourceTags = Object.keys(storageResources);
-  if (storageResourceTags.length === 0) {
-    storageResourceTags.push('myGraph');
-  }
-
-  const storageJson = JSON.stringify(storageResources, null, 2)
-    .replace(/\n/g, '\n    ');
-  const tagsJson = JSON.stringify(storageResourceTags);
-
-  return `export default [
-  {
-    objectType: '${tag}ValueStandard',
-    canDelete: true,
-    generatedBy: 'user',
-    storageResources: ${storageJson},
-    addOnDataStructure: [
-      //(<addOnDataStructure${tag}ValueStandard>)
-      // {
-      //   type: 'propertyValue',
-      //   propertyValuePrefix: '${tag}ValueStandard'
-      // }
-      //(</addOnDataStructure${tag}ValueStandard>)
-    ],
-    fieldNames: {
-      ${tag}ValueStandardId: {
-        type: 'string',
-        randomOnCreate: true,
-        canUpdate: false,
-        storageResourceTags: ${tagsJson}
-      },
-      label: {
-        type: 'string',
-        canUpdate: true,
-        storageResourceTags: ${tagsJson}
-      },
-      value: {
-        type: 'string',
-        requiredOnCreate: true,
-        canUpdate: true,
-        storageResourceTags: ${tagsJson}
-      }
-    },
-    identifiers: [
-      {
-        type: 'identifier',
-        fieldName: '${tag}ValueStandardId'
-      }
-    ]
-  }
-];
-`;
-}
-
-export function attributeTreeTargetValueStandardManagedPaths(directives = []) {
-  const targets = _extractTargetDirectives(directives);
-  const paths = [];
-
-  for (const directive of targets) {
-    const tag = directive.attributeTreeTag;
-    paths.push(
-      `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/` +
-        `${tag}ValueStandard.js`
-    );
-  }
-
-  return paths;
-}
-
-export function emitAttributeTreeTargetValueStandard({
-  directives = []
-} = {}) {
-  const targets = _extractTargetDirectives(directives);
-  if (targets.length === 0) {
-    return [];
-  }
-
-  const artifacts = [];
-
-  for (const directive of targets) {
-    const tag = directive.attributeTreeTag;
-    const storageResources = _extractStorageResources(directive);
-    artifacts.push({
-      path:
-        `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/` +
-        `${tag}ValueStandard.js`,
-      content: _renderTargetValueStandardSchema(tag, storageResources)
-    });
-  }
-
-  return artifacts;
-}

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

@@ -1,177 +0,0 @@
-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'
-  });
-});