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

package/test/unit/schemas/errorSchemas.test.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { readFile, rm, writeFile, mkdir } from 'node:fs/promises';
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import test, { after } from 'node:test';
@@ -7,7 +7,10 @@ import test, { after } from 'node:test';
 import {
   emitErrorSchemas,
   errorSchemaManagedPaths,
-  ERROR_SCHEMA_PATH
+  ERROR_SCHEMA_PATH,
+  SHARED_ERROR_PACKAGE_PATH,
+  SHARED_ERROR_INDEX_PATH,
+  SHARED_ERROR_CONSTS_PATH
 } from '../../../src/emit/schemas/error/emitErrorSchemas.js';
 import { generate } from '../../../src/generate.js';
 
@@ -49,7 +52,7 @@ test('emitErrorSchemas produces expected ERROR_TYPES for graph and general error
     ]
   });
 
-  assert.equal(artifacts.length, 1);
+  assert.equal(artifacts.length, 4);
   assert.equal(artifacts[0].path, ERROR_SCHEMA_PATH);
 
   const content = artifacts[0].content;
@@ -86,6 +89,31 @@ test('emitErrorSchemas produces expected ERROR_TYPES for graph and general error
   assert.ok(customIdx < explicitIdx);
   assert.ok(explicitIdx < invalidIdx);
   assert.ok(invalidIdx < notFoundIdx);
+
+  // Shared library artifacts
+  assert.equal(artifacts[1].path, SHARED_ERROR_PACKAGE_PATH);
+  const parsedPkg = JSON.parse(artifacts[1].content);
+  assert.equal(
+    parsedPkg.name,
+    '@izara_project/izara-myservice-library-errorlib'
+  );
+
+  assert.equal(artifacts[2].path, SHARED_ERROR_INDEX_PATH);
+  assert.match(
+    artifacts[2].content,
+    /import \* as errorLib from '\.\/src\/errorConsts\.js';/
+  );
+
+  assert.equal(artifacts[3].path, SHARED_ERROR_CONSTS_PATH);
+  const sharedContent = artifacts[3].content;
+  assert.match(
+    sharedContent,
+    /\/\/ only generate error that sharedLibrary: true/
+  );
+  assert.match(sharedContent, /INVALID_GENERATED_BY:/);
+  assert.match(sharedContent, /NOT_FOUND_SCHEMA:/);
+  assert.doesNotMatch(sharedContent, /CUSTOM_INTERNAL_ERROR:/);
+  assert.doesNotMatch(sharedContent, /EXPLICIT_SERVICE_ERROR:/);
 });
 
 test('emitErrorSchemas returns empty array when no errors provided', async () => {
@@ -97,9 +125,18 @@ test('emitErrorSchemas returns empty array when no errors provided', async () =>
   assert.deepEqual(artifacts, []);
   assert.deepEqual(errorSchemaManagedPaths([]), []);
   assert.deepEqual(errorSchemaManagedPaths(['someError']), [ERROR_SCHEMA_PATH]);
+  assert.deepEqual(
+    errorSchemaManagedPaths([{ errorTag: 'E1', sharedLibrary: true }]),
+    [
+      ERROR_SCHEMA_PATH,
+      SHARED_ERROR_PACKAGE_PATH,
+      SHARED_ERROR_INDEX_PATH,
+      SHARED_ERROR_CONSTS_PATH
+    ]
+  );
 });
 
-test('generate creates errorSchema.js when ErrorSchemas directory exists', async () => {
+test('generate creates errorConsts.js and libs/errorLib when ErrorSchemas directory exists', async () => {
   const rootPath = join(
     tmpdir(),
     `error-schema-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
@@ -141,7 +178,7 @@ test('generate creates errorSchema.js when ErrorSchemas directory exists', async
 
   const targetFile = join(
     rootPath,
-    'app/src/schemas/ErrorSchemas/generateCode/errorSchema.js'
+    'app/src/schemas/ErrorSchemas/generateCode/errorConsts.js'
   );
   const content = await readFile(targetFile, 'utf8');
 
@@ -151,4 +188,46 @@ test('generate creates errorSchema.js when ErrorSchemas directory exists', async
   assert.match(content, /MISSING_USER_NODE:/);
   assert.match(content, /serviceTag:\s*'CategoryTreeStandard'/);
   assert.doesNotMatch(content, /export default/);
+
+  // Verify libs/errorLib files
+  const pkgFile = join(rootPath, 'libs/errorLib/package.json');
+  const pkgContent = JSON.parse(await readFile(pkgFile, 'utf8'));
+  assert.equal(
+    pkgContent.name,
+    '@izara_project/izara-categorytreestandard-library-errorlib'
+  );
+
+  const indexFile = join(rootPath, 'libs/errorLib/index.js');
+  const indexContent = await readFile(indexFile, 'utf8');
+  assert.match(indexContent, /export { errorLib };/);
+
+  const sharedConstsFile = join(rootPath, 'libs/errorLib/src/errorConsts.js');
+  const sharedConstsContent = await readFile(sharedConstsFile, 'utf8');
+  assert.match(
+    sharedConstsContent,
+    /\/\/ only generate error that sharedLibrary: true/
+  );
+  assert.match(sharedConstsContent, /NOT_FOUND_SCHEMA:/);
+  assert.match(sharedConstsContent, /INVALID_GENERATED_BY:/);
+  assert.match(sharedConstsContent, /MISSING_USER_NODE:/);
+});
+
+test('generate creates ErrorSchemas directory if it does not exist', async () => {
+  const rootPath = join(
+    tmpdir(),
+    `error-schema-dir-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  roots.add(rootPath);
+  await mkdir(join(rootPath, 'config'), { recursive: true });
+
+  await writeFile(
+    join(rootPath, 'config/serverless.config.yml'),
+    'main_config:\n  iz_serviceTag: TestService\n'
+  );
+
+  await generate(rootPath);
+
+  const errorSchemasDir = join(rootPath, 'app/src/schemas/ErrorSchemas');
+  const dirStat = await stat(errorSchemasDir);
+  assert.ok(dirStat.isDirectory());
 });

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