@team-codeme/crud-forge 0.0.0-stage → 1.0.1

package/src/utils/merger.js

@@ -0,0 +1,115 @@
+const MARKERS = [
+  { start: /\/\/ cforge-custom-code-start(?::(\w+))?/, end: /\/\/ cforge-custom-code-end/ },
+  { start: /\/\* cforge-custom-code-start(?::(\w+))? \*\//, end: /\/\* cforge-custom-code-end \*\// },
+  { start: /<!-- cforge-custom-code-start(?::(\w+))? -->/, end: /<!-- cforge-custom-code-end -->/ }
+];
+
+/**
+ * Extracts developer custom sections from a file.
+ * @param {string} content 
+ * @returns {object} - Key-value map of zone identifier to its content.
+ */
+function extractZones(content) {
+  const zones = {};
+  if (!content) return zones;
+  
+  const lines = content.split(/\r?\n/);
+  let activeZoneKey = null;
+  let activeZoneContent = [];
+  let unnamedIndex = 0;
+  
+  for (const line of lines) {
+    if (activeZoneKey === null) {
+      let match = null;
+      for (const m of MARKERS) {
+        match = line.match(m.start);
+        if (match) break;
+      }
+      
+      if (match) {
+        const label = match[1] || `unnamed_${unnamedIndex++}`;
+        activeZoneKey = label;
+        activeZoneContent = [];
+      }
+    } else {
+      let isEnd = false;
+      for (const m of MARKERS) {
+        if (m.end.test(line)) {
+          isEnd = true;
+          break;
+        }
+      }
+      
+      if (isEnd) {
+        zones[activeZoneKey] = activeZoneContent.join('\n');
+        activeZoneKey = null;
+      } else {
+        activeZoneContent.push(line);
+      }
+    }
+  }
+  return zones;
+}
+
+/**
+ * Merges extracted custom zones from oldContent into empty templates of newContent.
+ * @param {string} oldContent - File content on disk containing developer additions.
+ * @param {string} newContent - Newly generated EJS template content.
+ * @returns {string} - Combined output.
+ */
+function mergeContent(oldContent, newContent) {
+  const oldZones = extractZones(oldContent);
+  if (Object.keys(oldZones).length === 0) {
+    return newContent; // No custom code to merge
+  }
+
+  const lines = newContent.split(/\r?\n/);
+  const result = [];
+  
+  let skippingIndex = false;
+  let unnamedIndex = 0;
+
+  for (let idx = 0; idx < lines.length; idx++) {
+    const line = lines[idx];
+
+    if (skippingIndex) {
+      let isEnd = false;
+      for (const m of MARKERS) {
+        if (m.end.test(line)) {
+          isEnd = true;
+          break;
+        }
+      }
+      if (isEnd) {
+        result.push(line);
+        skippingIndex = false;
+      }
+      continue;
+    }
+
+    let match = null;
+    for (const m of MARKERS) {
+      match = line.match(m.start);
+      if (match) break;
+    }
+
+    if (match) {
+      const label = match[1] || `unnamed_${unnamedIndex++}`;
+      result.push(line); // Push the start marker line
+
+      if (oldZones[label] !== undefined) {
+        result.push(oldZones[label]);
+        skippingIndex = true; // Skip empty EJS block content until we reach the end marker
+      }
+    } else {
+      result.push(line);
+    }
+  }
+
+  return result.join('\n');
+}
+
+module.exports = {
+  extractZones,
+  mergeContent
+};

package/src/validator/backend-diagnostics.js

@@ -0,0 +1,30 @@
+// Backend selection is metadata, never evidence that a deployed service supports a feature.
+// Keep contract checks separate from syntax/naming rules; no vendor naming conventions.
+function checkBackend(config, add) {
+  for (const [key, supported] of Object.entries({
+    endpointStyle: "kebab-plural",
+    responseType: "http-response",
+    dateLibrary: "dayjs",
+  })) {
+    if (config.api?.[key] !== undefined && config.api[key] !== supported)
+      add(
+        "unsupported-api-setting",
+        `api.${key}=${config.api[key]} is not implemented by the current service templates.`,
+        0,
+        undefined,
+        undefined,
+        `Use ${supported} or implement and test a contract adapter.`,
+      );
+  }
+  if (config.backend?.kind)
+    add(
+      "backend-unverified",
+      `The ${config.backend.kind} label does not verify a live API contract. Pagination, routing and authorization require backend integration tests.`,
+      0,
+      undefined,
+      undefined,
+      "Verify the configured API against the deployed backend.",
+      "warning",
+    );
+}
+module.exports = { checkBackend };

package/src/validator/blueprint-validator.js

@@ -0,0 +1,276 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const JDL_PRIMITIVES = new Set([
+  'String', 'Integer', 'Long', 'BigDecimal', 'Float', 'Double',
+  'Boolean', 'LocalDate', 'Instant', 'ZonedDateTime', 'TextBlob', 'UUID'
+]);
+
+const GDL_PRIMITIVES = new Set([
+  'string', 'bool', 'int', 'long', 'double', 'bigDecimal', 'date', 'datetime'
+]);
+
+const GDL_TO_JDL_TYPES = {
+  string: 'String',
+  bool: 'Boolean',
+  int: 'Integer',
+  long: 'Long',
+  double: 'Double',
+  bigDecimal: 'BigDecimal',
+  date: 'LocalDate',
+  datetime: 'Instant'
+};
+
+const RECOGNIZED_VALIDATIONS = new Set([
+  'required', 'min', 'max', 'minlength', 'maxlength', 'pattern'
+]);
+
+const RELATIONSHIP_TYPES = new Set([
+  'OneToOne', 'ManyToOne', 'OneToMany', 'ManyToMany'
+]);
+
+/**
+ * Normalizes types to JDL equivalents for checking validation rules.
+ */
+function normalizeType(type) {
+  return GDL_TO_JDL_TYPES[type] || type;
+}
+
+/**
+ * Formats a validation error message with line contents and caret pointer.
+ */
+function formatError(line, lineNum, col, message, errorType = 'Semantic Error') {
+  const linePadding = '  ';
+  const caretSpacing = ' '.repeat(col - 1);
+  return `Error at line ${lineNum}, column ${col}:
+${linePadding}${line}
+${linePadding}${caretSpacing}^
+${errorType}: ${message}`;
+}
+
+/**
+ * Validates JDL or GDL blueprint files.
+ * @param {string} content - Raw content of the schema.
+ * @param {boolean} isGdl - True if validating a GDL file.
+ * @returns {string[]} - List of formatted validation error messages.
+ */
+function validateBlueprint(content, isGdl = false) {
+  const errors = [];
+  const lines = content.split(/\r?\n/);
+  
+  // 1. Bracket balances check
+  let openBraces = 0;
+  let closeBraces = 0;
+  lines.forEach((line, index) => {
+    const cleanLine = line.replace(/\/\/.*$/, ''); // ignore comment parts
+    openBraces += (cleanLine.match(/\{/g) || []).length;
+    closeBraces += (cleanLine.match(/\}/g) || []).length;
+  });
+
+  if (openBraces !== closeBraces) {
+    errors.push(`Syntactic Error: Mismatched curly braces in blueprint file. Found ${openBraces} open braces and ${closeBraces} close braces.`);
+    return errors;
+  }
+
+  // 2. Pass 1: Parse declared entities and enums to check for duplicates and map names
+  const declaredEntities = new Set();
+  const declaredEnums = new Set();
+  
+  let currentBlockType = null; // 'entity' | 'enum' | 'relationship'
+  
+  lines.forEach((line, index) => {
+    const lineNum = index + 1;
+    const cleanLine = line.replace(/\/\/.*$/, '').trim();
+    if (!cleanLine) return;
+
+    if (currentBlockType === null) {
+      const entityMatch = cleanLine.match(/(?:@\w+\s+)*entity\s+(\w+)/);
+      const enumMatch = cleanLine.match(/enum\s+(\w+)/);
+      const relMatch = cleanLine.match(/relationship\s+(\w+)/);
+
+      if (entityMatch) {
+        const name = entityMatch[1];
+        if (declaredEntities.has(name) || declaredEnums.has(name)) {
+          const col = line.indexOf(name) + 1;
+          errors.push(formatError(line, lineNum, col, `Duplicate declaration of entity "${name}".`, 'Duplicate Error'));
+        }
+        declaredEntities.add(name);
+        if (cleanLine.includes('{')) {
+          currentBlockType = 'entity';
+        }
+      } else if (enumMatch) {
+        const name = enumMatch[1];
+        if (declaredEntities.has(name) || declaredEnums.has(name)) {
+          const col = line.indexOf(name) + 1;
+          errors.push(formatError(line, lineNum, col, `Duplicate declaration of enum "${name}".`, 'Duplicate Error'));
+        }
+        declaredEnums.add(name);
+        if (cleanLine.includes('{')) {
+          currentBlockType = 'enum';
+        }
+      } else if (relMatch) {
+        if (cleanLine.includes('{')) {
+          currentBlockType = 'relationship';
+        }
+      }
+    } else {
+      if (cleanLine.includes('}')) {
+        currentBlockType = null;
+      }
+    }
+  });
+
+  // If duplicate errors exist, terminate early
+  if (errors.length > 0) return errors;
+
+  // 3. Pass 2: Line-by-line detailed block validations
+  currentBlockType = null;
+  let currentBlockName = '';
+
+  lines.forEach((line, index) => {
+    const lineNum = index + 1;
+    const cleanLine = line.replace(/\/\/.*$/, '').trim();
+    if (!cleanLine) return;
+
+    if (currentBlockType === null) {
+      const entityMatch = line.match(/(?:@\w+\s+)*entity\s+(\w+)/);
+      const enumMatch = line.match(/enum\s+(\w+)/);
+      const relMatch = line.match(/relationship\s+(\w+)/);
+
+      if (entityMatch) {
+        currentBlockName = entityMatch[1];
+        if (line.includes('{')) {
+          currentBlockType = 'entity';
+        }
+      } else if (enumMatch) {
+        currentBlockName = enumMatch[1];
+        if (line.includes('{')) {
+          currentBlockType = 'enum';
+        }
+      } else if (relMatch) {
+        currentBlockName = relMatch[1];
+        if (!RELATIONSHIP_TYPES.has(currentBlockName)) {
+          const col = line.indexOf(currentBlockName) + 1;
+          errors.push(formatError(line, lineNum, col, `Invalid relationship type "${currentBlockName}". Allowed types: ${Array.from(RELATIONSHIP_TYPES).join(', ')}.`));
+        }
+        if (line.includes('{')) {
+          currentBlockType = 'relationship';
+        }
+      }
+    } else {
+      // We are inside a block
+      if (cleanLine.includes('}')) {
+        currentBlockType = null;
+        currentBlockName = '';
+        return;
+      }
+
+      if (currentBlockType === 'entity') {
+        // Parse fields
+        // JDL Syntax: fieldName fieldType [validations]
+        // GDL Syntax: fieldType fieldName [validations]
+        const jdlRegex = /^(\w+)\s+([\w<>]+)(.*)/;
+        const gdlRegex = /^([\w<>]+)\s+(\w+)(.*)/;
+        const regex = isGdl ? gdlRegex : jdlRegex;
+
+        const match = cleanLine.match(regex);
+        if (!match) {
+          errors.push(formatError(line, lineNum, 1, 'Malformed field definition. Expected format: "<fieldName> <fieldType> [validations]" (JDL) or "<fieldType> <fieldName> [validations]" (GDL).', 'Syntax Error'));
+          return;
+        }
+
+        const fieldName = isGdl ? match[2] : match[1];
+        const fieldType = isGdl ? match[1] : match[2];
+        const validationsStr = match[3].trim();
+
+        // Check if field type is known
+        const isPrimitive = isGdl ? GDL_PRIMITIVES.has(fieldType) : JDL_PRIMITIVES.has(fieldType);
+        const isEnum = declaredEnums.has(fieldType);
+        
+        if (!isPrimitive && !isEnum) {
+          const col = line.indexOf(fieldType) + 1;
+          if (declaredEntities.has(fieldType)) {
+            errors.push(formatError(line, lineNum, col, `Entity "${fieldType}" cannot be declared as a field type inside another entity. Entity joins must be defined in relationship blocks.`));
+          } else {
+            errors.push(formatError(line, lineNum, col, `Unknown field type "${fieldType}". Must be a primitive type or declared enum.`));
+          }
+          return;
+        }
+
+        // Validate validation constraints
+        if (validationsStr) {
+          const tokens = validationsStr.split(/\s+/);
+          for (const token of tokens) {
+            const valMatch = token.match(/^(\w+)(?:\(([^)]+)\))?$/);
+            if (!valMatch) {
+              const col = line.indexOf(token) + 1;
+              errors.push(formatError(line, lineNum, col, `Malformed validation rule syntax "${token}".`, 'Syntax Error'));
+              continue;
+            }
+
+            const ruleName = valMatch[1];
+            if (!RECOGNIZED_VALIDATIONS.has(ruleName)) {
+              const col = line.indexOf(ruleName) + 1;
+              errors.push(formatError(line, lineNum, col, `Unrecognized validation rule "${ruleName}". Allowed rules: ${Array.from(RECOGNIZED_VALIDATIONS).join(', ')}.`));
+              continue;
+            }
+
+            // Semantic checks matching validations to types
+            const normType = normalizeType(fieldType);
+            const isNumeric = ['Integer', 'Long', 'Float', 'Double', 'BigDecimal'].includes(normType);
+            const isString = ['String', 'TextBlob', 'UUID'].includes(normType);
+
+            if (isNumeric) {
+              if (['minlength', 'maxlength', 'pattern'].includes(ruleName)) {
+                const col = line.indexOf(ruleName) + 1;
+                errors.push(formatError(line, lineNum, col, `Validation rule "${ruleName}" is not applicable to numeric type "${fieldType}".`));
+              }
+            } else if (isString) {
+              if (['min', 'max'].includes(ruleName)) {
+                const col = line.indexOf(ruleName) + 1;
+                errors.push(formatError(line, lineNum, col, `Validation rule "${ruleName}" is not applicable to string type "${fieldType}".`));
+              }
+            } else {
+              // Boolean, Date types, or Enums only accept 'required'
+              if (ruleName !== 'required') {
+                const col = line.indexOf(ruleName) + 1;
+                errors.push(formatError(line, lineNum, col, `Validation rule "${ruleName}" is not applicable to type "${fieldType}". Only "required" is supported.`));
+              }
+            }
+          }
+        }
+      } else if (currentBlockType === 'relationship') {
+        // Validate relationship line
+        // JDL: SourceEntity(sourceFieldName) to TargetEntity(targetFieldName)
+        // GDL: SourceEntity{sourceFieldName} to TargetEntity{targetFieldName}
+        const jdlRelRegex = /^(\w+)(?:\((\w+)\))?\s+to\s+(\w+)(?:\((\w+)\))?/;
+        const gdlRelRegex = /^(\w+)(?:\{([\w()]+)\})?\s+to\s+(\w+)(?:\{([\w()]+)\})?/;
+        const relRegex = isGdl ? gdlRelRegex : jdlRelRegex;
+
+        const match = cleanLine.match(relRegex);
+        if (!match) {
+          errors.push(formatError(line, lineNum, 1, 'Malformed relationship line. Expected format: "SourceEntity(field) to TargetEntity(field)" (JDL) or "SourceEntity{field} to TargetEntity{field}" (GDL).', 'Syntax Error'));
+          return;
+        }
+
+        const sourceEntity = match[1];
+        const targetEntity = match[3];
+
+        if (!declaredEntities.has(sourceEntity)) {
+          const col = line.indexOf(sourceEntity) + 1;
+          errors.push(formatError(line, lineNum, col, `Source entity "${sourceEntity}" is not defined in this blueprint.`));
+        }
+        if (!declaredEntities.has(targetEntity)) {
+          const col = line.indexOf(targetEntity) + 1;
+          errors.push(formatError(line, lineNum, col, `Target entity "${targetEntity}" is not defined in this blueprint.`));
+        }
+      }
+    }
+  });
+
+  return errors;
+}
+
+module.exports = {
+  validateBlueprint
+};