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

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/emitAttributeTreeTargetSchemas.js

@@ -1,153 +0,0 @@
-import path from 'node:path';
-
-function _renderObjectSchema(schema) {
-  return `export default [\n  ${JSON.stringify(schema, null, 2).replace(/\n/g, '\n  ')}\n];\n`;
-}
-
-/**
- * Emits standard schemas into target service folder for attributeTree.
- *
- * @param {Object} params
- * @param {string} params.attributeTag - e.g. 'sellOfferTerm'
- * @param {string} params.targetServiceRoot - Target service root directory
- * @param {Object} [params.graphStorageResources] - Graph storage resources
- * @returns {Array<{ path: string, content: string }>} Emitted target artifacts
- */
-export function emitAttributeTreeTargetSchemas({
-  attributeTag,
-  targetServiceRoot,
-  graphStorageResources = {
-    myGraph: {
-      storageType: 'graph',
-      graphServerTag: 'GraphHandler'
-    }
-  }
-} = {}) {
-  if (!attributeTag || !targetServiceRoot) {
-    return [];
-  }
-
-  const tag = attributeTag;
-  const storageResourceTags = Object.keys(graphStorageResources);
-
-  // 1. {tag}ValueStandardPropertyLabel.js
-  const labelSchema = {
-    objectType: `${tag}ValueStandardPropertyLabel`,
-    canDelete: true,
-    generatedBy: 'user',
-    storageResources: graphStorageResources,
-    fieldNames: {
-      [`${tag}ValueStandardPropertyLabelId`]: {
-        type: 'string',
-        randomOnCreate: true,
-        canUpdate: false,
-        storageResourceTags
-      },
-      label: {
-        type: 'string',
-        requiredOnCreate: true,
-        canUpdate: true,
-        storageResourceTags
-      }
-    },
-    identifiers: [
-      {
-        type: 'identifier',
-        fieldName: `${tag}ValueStandardPropertyLabelId`
-      }
-    ]
-  };
-
-  // 2. {tag}ValueStandardPropertyValue.js
-  const valueSchema = {
-    objectType: `${tag}ValueStandardPropertyValue`,
-    canDelete: true,
-    generatedBy: 'user',
-    storageResources: graphStorageResources,
-    fieldNames: {
-      [`${tag}ValueStandardPropertyValueId`]: {
-        type: 'string',
-        randomOnCreate: true,
-        canUpdate: false,
-        storageResourceTags
-      },
-      value: {
-        type: 'string',
-        requiredOnCreate: true,
-        canUpdate: true,
-        storageResourceTags
-      }
-    },
-    identifiers: [
-      {
-        type: 'identifier',
-        fieldName: `${tag}ValueStandardPropertyValueId`
-      }
-    ]
-  };
-
-  // 3. {tag}ValueStandard.js
-  const standardValueSchema = {
-    objectType: `${tag}ValueStandard`,
-    canDelete: true,
-    generatedBy: 'user',
-    storageResources: graphStorageResources,
-    fieldNames: {
-      [`${tag}ValueStandardId`]: {
-        type: 'string',
-        randomOnCreate: true,
-        canUpdate: false,
-        storageResourceTags
-      },
-      value: {
-        type: 'string',
-        requiredOnCreate: true,
-        canUpdate: true,
-        storageResourceTags
-      }
-    },
-    identifiers: [
-      {
-        type: 'identifier',
-        fieldName: `${tag}ValueStandardId`
-      }
-    ]
-  };
-
-  const relDir = path.join(
-    'app',
-    'src',
-    'schemas',
-    'ObjectSchemas',
-    'generatedCode',
-    'attributeTree',
-    'propertyValue'
-  );
-
-  return [
-    {
-      path: path.join(
-        targetServiceRoot,
-        relDir,
-        `${tag}ValueStandardPropertyLabel.js`
-      ),
-      content: _renderObjectSchema(labelSchema)
-    },
-    {
-      path: path.join(
-        targetServiceRoot,
-        relDir,
-        `${tag}ValueStandardPropertyValue.js`
-      ),
-      content: _renderObjectSchema(valueSchema)
-    },
-    {
-      path: path.join(
-        targetServiceRoot,
-        relDir,
-        `${tag}ValueStandard.js`
-      ),
-      content: _renderObjectSchema(standardValueSchema)
-    }
-  ];
-}

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

@@ -1,111 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-/**
- * Resolves target service root path based on attributeTag and developer suffix.
- *
- * @param {Object} params
- * @param {string} params.currentServiceRoot - Root path of the current service
- * @param {string} params.attributeTag - The attribute tag, e.g. 'sellOfferTerm'
- * @param {string} [params.customOverridePath] - Optional custom path override
- * @returns {string|null} Resolved absolute path or null if not found
- */
-export function resolveTargetServicePath({
-  currentServiceRoot,
-  attributeTag,
-  customOverridePath
-} = {}) {
-  if (!currentServiceRoot || !attributeTag) {
-    return null;
-  }
-
-  if (customOverridePath) {
-    const resolvedCustom = path.resolve(
-      currentServiceRoot,
-      customOverridePath
-    );
-    if (fs.existsSync(resolvedCustom)) {
-      return resolvedCustom;
-    }
-  }
-
-  const currentFolderName = path.basename(currentServiceRoot);
-  const parentDir = path.resolve(currentServiceRoot, '..');
-
-  if (!fs.existsSync(parentDir)) {
-    return null;
-  }
-
-  let entries = [];
-  try {
-    entries = fs.readdirSync(parentDir, { withFileTypes: true });
-  } catch (err) {
-    return null;
-  }
-
-  const suffixMatch = currentFolderName.match(/-([a-zA-Z0-9]+)$/);
-  let devSuffix = '';
-  if (suffixMatch && suffixMatch[1]) {
-    devSuffix = suffixMatch[1].toLowerCase();
-  }
-
-  const normalizedTag = attributeTag.toLowerCase();
-  const kebabTag = attributeTag
-    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-    .toLowerCase();
-
-  const priority1Matches = [];
-  const priority2Matches = [];
-  const priority3Matches = [];
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-
-    if (entry.name === currentFolderName) {
-      continue;
-    }
-
-    const folderNameLower = entry.name.toLowerCase();
-    const hasTagMatch =
-      folderNameLower.includes(normalizedTag) ||
-      folderNameLower.includes(kebabTag);
-
-    if (!hasTagMatch) {
-      continue;
-    }
-
-    const fullPath = path.join(parentDir, entry.name);
-    const hasStructure =
-      fs.existsSync(path.join(fullPath, 'app', 'src')) ||
-      fs.existsSync(path.join(fullPath, 'package.json'));
-
-    if (!hasStructure) {
-      continue;
-    }
-
-    if (devSuffix !== '' && folderNameLower.endsWith('-' + devSuffix)) {
-      priority1Matches.push(fullPath);
-    } else if (
-      folderNameLower.endsWith(normalizedTag) ||
-      folderNameLower.endsWith(kebabTag)
-    ) {
-      priority2Matches.push(fullPath);
-    } else {
-      priority3Matches.push(fullPath);
-    }
-  }
-
-  if (priority1Matches.length > 0) {
-    return priority1Matches[0];
-  }
-  if (priority2Matches.length > 0) {
-    return priority2Matches[0];
-  }
-  if (priority3Matches.length > 0) {
-    return priority3Matches[0];
-  }
-
-  return null;
-}