code-auditor-mcp 3.4.12 → 3.4.13

package/dist/analyzers/cross-language/SchemaValidator.js

@@ -2,8 +2,15 @@
  * Cross-Language Schema Validator
  * Validates schema consistency across language boundaries
  */
+/**
+ * Schema validator.
+ */
 export class SchemaValidator {
     options;
+    /**
+     * Constructor.
+     * @param options
+     */
     constructor(options = {}) {
         this.options = {
             strictTypeChecking: true,
@@ -16,11 +23,13 @@ export class SchemaValidator {
     }
     /**
      * Validate schema consistency across multiple languages
+     * @param schemas
+     * @returns
      */
     async validateSchemas(schemas) {
         const violations = [];
         // Group schemas by name (different language implementations of same schema)
-        const schemaGroups = this.groupSchemasByName(schemas);
+        const schemaGroups = groupSchemasByName(schemas);
         for (const [schemaName, groupSchemas] of schemaGroups) {
             if (groupSchemas.length > 1) {
                 violations.push(...await this.validateSchemaGroup(schemaName, groupSchemas));
@@ -32,45 +41,6 @@ export class SchemaValidator {
         }
         return violations;
     }
-    /**
-     * Extract schema definitions from entities
-     */
-    static extractSchemas(entities) {
-        const schemas = [];
-        for (const entity of entities) {
-            // TypeScript interfaces
-            if (entity.language === 'typescript' && entity.type === 'interface') {
-                const schema = this.extractTypeScriptInterface(entity);
-                if (schema)
-                    schemas.push(schema);
-            }
-            // Go structs
-            if (entity.language === 'go' && entity.type === 'struct') {
-                const schema = this.extractGoStruct(entity);
-                if (schema)
-                    schemas.push(schema);
-            }
-            // Protocol buffer definitions
-            if (entity.file.endsWith('.proto')) {
-                const schema = this.extractProtobufMessage(entity);
-                if (schema)
-                    schemas.push(schema);
-            }
-            // GraphQL types
-            if (entity.file.endsWith('.graphql') || entity.file.endsWith('.gql')) {
-                const schema = this.extractGraphQLType(entity);
-                if (schema)
-                    schemas.push(schema);
-            }
-            // JSON Schema
-            if (entity.file.endsWith('.json') && entity.name.toLowerCase().includes('schema')) {
-                const schema = this.extractJSONSchema(entity);
-                if (schema)
-                    schemas.push(schema);
-            }
-        }
-        return schemas;
-    }
     /**
      * Validate a group of schemas that should be equivalent
      */
@@ -98,54 +68,75 @@ export class SchemaValidator {
         // Create field maps for easier comparison
         const refFields = new Map(reference.fields.map(f => [f.name, f]));
         const curFields = new Map(current.fields.map(f => [f.name, f]));
-        // Check for missing required fields
+        violations.push(...this.checkMissingFields(refFields, curFields, reference, current));
+        violations.push(...this.checkExtraFields(refFields, curFields, reference, current));
+        violations.push(...this.checkFieldTypes(refFields, curFields, reference, current));
+        return violations;
+    }
+    /**
+     * Check for required fields missing from the current schema.
+     */
+    checkMissingFields(refFields, curFields, reference, current) {
+        const violations = [];
         for (const [fieldName, refField] of refFields) {
-            if (refField.required && !curFields.has(fieldName)) {
-                violations.push({
-                    file: current.file,
-                    line: current.line,
-                    severity: 'warning',
-                    message: `Missing required field '${fieldName}' in ${current.type} ${current.name}`,
-                    rule: "missing-field",
-                    violationType: 'missing-field',
-                    schemas: [reference, current],
-                    fieldName,
-                    suggestion: `Add field '${fieldName}: ${refField.type}' to ${current.name}`,
-                    analyzer: 'schema-validator',
-                    category: 'cross-language-schema'
-                });
-            }
+            if (!refField.required || curFields.has(fieldName))
+                continue;
+            violations.push({
+                file: current.file,
+                line: current.line,
+                severity: 'warning',
+                message: `Missing required field '${fieldName}' in ${current.type} ${current.name}`,
+                rule: "missing-field",
+                violationType: 'missing-field',
+                schemas: [reference, current],
+                fieldName,
+                suggestion: `Add field '${fieldName}: ${refField.type}' to ${current.name}`,
+                analyzer: 'schema-validator',
+                category: 'cross-language-schema'
+            });
         }
-        // Check for extra fields (if not allowed)
-        if (!this.options.allowAdditionalFields) {
-            for (const [fieldName, curField] of curFields) {
-                if (!refFields.has(fieldName)) {
-                    violations.push({
-                        file: current.file,
-                        line: current.line,
-                        severity: 'warning',
-                        message: `Extra field '${fieldName}' in ${current.type} ${current.name}`,
-                        rule: 'extra-field',
-                        violationType: 'extra-field',
-                        schemas: [reference, current],
-                        fieldName,
-                        suggestion: `Remove field '${fieldName}' or add it to the reference schema`,
-                        analyzer: 'schema-validator',
-                        category: 'cross-language-schema'
-                    });
-                }
-            }
+        return violations;
+    }
+    /**
+     * Check for fields present in the current schema but missing from the reference.
+     */
+    checkExtraFields(refFields, curFields, reference, current) {
+        const violations = [];
+        if (this.options.allowAdditionalFields)
+            return violations;
+        for (const [fieldName] of curFields) {
+            if (refFields.has(fieldName))
+                continue;
+            violations.push({
+                file: current.file,
+                line: current.line,
+                severity: 'warning',
+                message: `Extra field '${fieldName}' in ${current.type} ${current.name}`,
+                rule: 'extra-field',
+                violationType: 'extra-field',
+                schemas: [reference, current],
+                fieldName,
+                suggestion: `Remove field '${fieldName}' or add it to the reference schema`,
+                analyzer: 'schema-validator',
+                category: 'cross-language-schema'
+            });
         }
-        // Check field type compatibility
+        return violations;
+    }
+    /**
+     * Check type/constraint compatibility for fields present in both schemas.
+     */
+    checkFieldTypes(refFields, curFields, reference, current) {
+        const violations = [];
         for (const [fieldName, refField] of refFields) {
             const curField = curFields.get(fieldName);
-            if (curField) {
-                const typeViolation = this.compareFieldTypes(fieldName, refField, curField, reference, current);
-                if (typeViolation)
-                    violations.push(typeViolation);
-                const constraintViolations = this.compareFieldConstraints(fieldName, refField, curField, reference, current);
-                violations.push(...constraintViolations);
-            }
+            if (!curField)
+                continue;
+            const cmp = { fieldName, refField, curField, reference, current };
+            const typeViolation = this.compareFieldTypes(cmp);
+            if (typeViolation)
+                violations.push(typeViolation);
+            violations.push(...this.compareFieldConstraints(cmp));
         }
         return violations;
     }
@@ -183,8 +174,8 @@ export class SchemaValidator {
     checkVersionCompatibility(reference, current) {
         if (!reference.version || !current.version)
             return null;
-        const refVersion = this.parseVersion(reference.version);
-        const curVersion = this.parseVersion(current.version);
+        const refVersion = parseVersion(reference.version);
+        const curVersion = parseVersion(current.version);
         const compatible = this.areVersionsCompatible(refVersion, curVersion);
         if (!compatible) {
             return {
@@ -205,9 +196,10 @@ export class SchemaValidator {
     /**
      * Compare field types between schemas
      */
-    compareFieldTypes(fieldName, refField, curField, refSchema, curSchema) {
-        const normalizedRefType = this.normalizeType(refField.type, refSchema.language);
-        const normalizedCurType = this.normalizeType(curField.type, curSchema.language);
+    compareFieldTypes(cmp) {
+        const { fieldName, refField, curField, reference: refSchema, current: curSchema } = cmp;
+        const normalizedRefType = normalizeType(refField.type, refSchema.language);
+        const normalizedCurType = normalizeType(curField.type, curSchema.language);
         if (this.options.strictTypeChecking) {
             if (normalizedRefType !== normalizedCurType) {
                 return {
@@ -229,7 +221,7 @@ export class SchemaValidator {
         }
         else {
             // Loose type checking - check for compatibility
-            if (!this.areTypesCompatible(normalizedRefType, normalizedCurType)) {
+            if (!areTypesCompatible(normalizedRefType, normalizedCurType)) {
                 return {
                     file: curSchema.file,
                     line: curSchema.line,
@@ -252,7 +244,8 @@ export class SchemaValidator {
     /**
      * Compare field constraints
      */
-    compareFieldConstraints(fieldName, refField, curField, refSchema, curSchema) {
+    compareFieldConstraints(cmp) {
+        const { fieldName, refField, curField, reference: refSchema, current: curSchema } = cmp;
         const violations = [];
         if (!refField.constraints || !curField.constraints)
             return violations;
@@ -301,7 +294,7 @@ export class SchemaValidator {
         const violations = [];
         for (const field of schema.fields) {
             // Check for consistent naming convention
-            if (!this.isConsistentNaming(field.name, schema.language)) {
+            if (!isConsistentNaming(field.name, schema.language)) {
                 violations.push({
                     file: schema.file,
                     line: schema.line,
@@ -311,7 +304,7 @@ export class SchemaValidator {
                     violationType: 'field-mismatch',
                     schemas: [schema],
                     fieldName: field.name,
-                    suggestion: `Use ${this.getRecommendedNaming(field.name, schema.language)} naming convention`,
+                    suggestion: `Use ${getRecommendedNaming(field.name, schema.language)} naming convention`,
                     analyzer: 'schema-validator',
                     category: 'cross-language-schema'
                 });
@@ -319,90 +312,6 @@ export class SchemaValidator {
         }
         return violations;
     }
-    /**
-     * Group schemas by name
-     */
-    groupSchemasByName(schemas) {
-        const groups = new Map();
-        for (const schema of schemas) {
-            const normalizedName = this.normalizeSchemaName(schema.name);
-            if (!groups.has(normalizedName)) {
-                groups.set(normalizedName, []);
-            }
-            groups.get(normalizedName).push(schema);
-        }
-        return groups;
-    }
-    /**
-     * Normalize schema name for comparison
-     */
-    normalizeSchemaName(name) {
-        return name.toLowerCase()
-            .replace(/[-_]/g, '')
-            .replace(/request|response|dto|model/g, '');
-    }
-    /**
-     * Normalize type names across languages
-     */
-    normalizeType(type, language) {
-        const typeMap = {
-            'typescript': {
-                'string': 'string',
-                'number': 'number',
-                'boolean': 'boolean',
-                'Date': 'datetime',
-                'any': 'any'
-            },
-            'go': {
-                'string': 'string',
-                'int': 'number',
-                'int32': 'number',
-                'int64': 'number',
-                'float32': 'number',
-                'float64': 'number',
-                'bool': 'boolean',
-                'time.Time': 'datetime'
-            },
-            'python': {
-                'str': 'string',
-                'int': 'number',
-                'float': 'number',
-                'bool': 'boolean',
-                'datetime': 'datetime'
-            }
-        };
-        return typeMap[language]?.[type] || type;
-    }
-    /**
-     * Check if types are compatible across languages
-     */
-    areTypesCompatible(type1, type2) {
-        // Allow some common compatible types
-        const compatibilityMatrix = {
-            'string': ['string'],
-            'number': ['number', 'integer', 'float'],
-            'boolean': ['boolean', 'bool'],
-            'datetime': ['datetime', 'timestamp', 'date'],
-            'any': ['any', 'object', 'interface{}']
-        };
-        for (const [baseType, compatibleTypes] of Object.entries(compatibilityMatrix)) {
-            if (compatibleTypes.includes(type1) && compatibleTypes.includes(type2)) {
-                return true;
-            }
-        }
-        return type1 === type2;
-    }
-    /**
-     * Parse version string
-     */
-    parseVersion(version) {
-        const parts = version.replace(/^v/, '').split('.').map(Number);
-        return {
-            major: parts[0] || 0,
-            minor: parts[1] || 0,
-            patch: parts[2] || 0
-        };
-    }
     /**
      * Check if versions are compatible
      */
@@ -418,111 +327,241 @@ export class SchemaValidator {
                 return true;
         }
     }
-    /**
-     * Check if field name follows language conventions
-     */
-    isConsistentNaming(fieldName, language) {
-        switch (language) {
-            case 'typescript':
-            case 'javascript':
-                return /^[a-z][a-zA-Z0-9]*$/.test(fieldName); // camelCase
-            case 'go':
-                return /^[A-Z][a-zA-Z0-9]*$/.test(fieldName); // PascalCase for exported
-            case 'python':
-                return /^[a-z][a-z0-9_]*$/.test(fieldName); // snake_case
-            default:
-                return true;
+}
+// ---------------------------------------------------------------------------
+// Stateless utilities (pure functions — no validator state)
+// ---------------------------------------------------------------------------
+/**
+ * Group schemas by name
+ */
+function groupSchemasByName(schemas) {
+    const groups = new Map();
+    for (const schema of schemas) {
+        const normalizedName = normalizeSchemaName(schema.name);
+        if (!groups.has(normalizedName)) {
+            groups.set(normalizedName, []);
         }
+        groups.get(normalizedName).push(schema);
     }
-    /**
-     * Get recommended naming convention
-     */
-    getRecommendedNaming(fieldName, language) {
-        switch (language) {
-            case 'typescript':
-            case 'javascript':
-                return 'camelCase';
-            case 'go':
-                return 'PascalCase';
-            case 'python':
-                return 'snake_case';
-            default:
-                return 'consistent';
+    return groups;
+}
+/**
+ * Normalize schema name for comparison
+ */
+function normalizeSchemaName(name) {
+    return name.toLowerCase()
+        .replace(/[-_]/g, '')
+        .replace(/request|response|dto|model/g, '');
+}
+/**
+ * Normalize type names across languages
+ */
+function normalizeType(type, language) {
+    const typeMap = {
+        'typescript': {
+            'string': 'string',
+            'number': 'number',
+            'boolean': 'boolean',
+            'Date': 'datetime',
+            'any': 'any'
+        },
+        'go': {
+            'string': 'string',
+            'int': 'number',
+            'int32': 'number',
+            'int64': 'number',
+            'float32': 'number',
+            'float64': 'number',
+            'bool': 'boolean',
+            'time.Time': 'datetime'
+        },
+        'python': {
+            'str': 'string',
+            'int': 'number',
+            'float': 'number',
+            'bool': 'boolean',
+            'datetime': 'datetime'
+        }
+    };
+    return typeMap[language]?.[type] || type;
+}
+/**
+ * Check if types are compatible across languages
+ */
+function areTypesCompatible(type1, type2) {
+    // Allow some common compatible types
+    const compatibilityMatrix = {
+        'string': ['string'],
+        'number': ['number', 'integer', 'float'],
+        'boolean': ['boolean', 'bool'],
+        'datetime': ['datetime', 'timestamp', 'date'],
+        'any': ['any', 'object', 'interface{}']
+    };
+    for (const [baseType, compatibleTypes] of Object.entries(compatibilityMatrix)) {
+        if (compatibleTypes.includes(type1) && compatibleTypes.includes(type2)) {
+            return true;
         }
     }
-    // Static methods for extracting schemas from different sources
-    static extractTypeScriptInterface(entity) {
-        if (entity.type !== 'interface')
-            return null;
-        return {
-            id: entity.id,
-            name: entity.name,
-            type: 'typescript-interface',
-            language: 'typescript',
-            file: entity.file,
-            line: entity.startLine || 0,
-            fields: entity.parameters?.map(param => ({
-                name: param.name,
-                type: param.type || 'any',
-                required: !param.optional,
-                description: param.description
-            })) || []
-        };
-    }
-    static extractGoStruct(entity) {
-        if (entity.type !== 'struct')
-            return null;
-        const fields = entity.metadata?.fields?.map((field) => ({
-            name: field.name,
-            type: field.type,
-            required: field.isExported, // Simplified assumption
-            description: field.tag
-        })) || [];
-        return {
-            id: entity.id,
-            name: entity.name,
-            type: 'go-struct',
-            language: 'go',
-            file: entity.file,
-            line: entity.startLine || 0,
-            fields
-        };
-    }
-    static extractProtobufMessage(entity) {
-        // Simplified protobuf extraction
-        return {
-            id: entity.id,
-            name: entity.name,
-            type: 'protobuf',
-            language: 'protobuf',
-            file: entity.file,
-            line: entity.startLine || 0,
-            fields: [] // Would parse .proto file in real implementation
-        };
+    return type1 === type2;
+}
+/**
+ * Parse version string
+ */
+function parseVersion(version) {
+    const parts = version.replace(/^v/, '').split('.').map(Number);
+    return {
+        major: parts[0] || 0,
+        minor: parts[1] || 0,
+        patch: parts[2] || 0
+    };
+}
+/**
+ * Check if field name follows language conventions
+ */
+function isConsistentNaming(fieldName, language) {
+    switch (language) {
+        case 'typescript':
+        case 'javascript':
+            return /^[a-z][a-zA-Z0-9]*$/.test(fieldName); // camelCase
+        case 'go':
+            return /^[A-Z][a-zA-Z0-9]*$/.test(fieldName); // PascalCase for exported
+        case 'python':
+            return /^[a-z][a-z0-9_]*$/.test(fieldName); // snake_case
+        default:
+            return true;
     }
-    static extractGraphQLType(entity) {
-        // Simplified GraphQL extraction
-        return {
-            id: entity.id,
-            name: entity.name,
-            type: 'graphql',
-            language: 'graphql',
-            file: entity.file,
-            line: entity.startLine || 0,
-            fields: [] // Would parse .graphql file in real implementation
-        };
+}
+/**
+ * Get recommended naming convention
+ */
+function getRecommendedNaming(fieldName, language) {
+    switch (language) {
+        case 'typescript':
+        case 'javascript':
+            return 'camelCase';
+        case 'go':
+            return 'PascalCase';
+        case 'python':
+            return 'snake_case';
+        default:
+            return 'consistent';
     }
-    static extractJSONSchema(entity) {
-        // Simplified JSON Schema extraction
-        return {
-            id: entity.id,
-            name: entity.name,
-            type: 'json-schema',
-            language: 'json',
-            file: entity.file,
-            line: entity.startLine || 0,
-            fields: [] // Would parse JSON schema in real implementation
-        };
+}
+// ---------------------------------------------------------------------------
+// Schema extraction (pure functions — no validator state)
+// ---------------------------------------------------------------------------
+/**
+ * Extract schema definitions from entities
+ * @param entities
+ * @returns
+ */
+export function extractSchemas(entities) {
+    const schemas = [];
+    for (const entity of entities) {
+        // TypeScript interfaces
+        if (entity.language === 'typescript' && entity.type === 'interface') {
+            const schema = extractTypeScriptInterface(entity);
+            if (schema)
+                schemas.push(schema);
+        }
+        // Go structs
+        if (entity.language === 'go' && entity.type === 'struct') {
+            const schema = extractGoStruct(entity);
+            if (schema)
+                schemas.push(schema);
+        }
+        // Protocol buffer definitions
+        if (entity.file.endsWith('.proto')) {
+            const schema = extractProtobufMessage(entity);
+            if (schema)
+                schemas.push(schema);
+        }
+        // GraphQL types
+        if (entity.file.endsWith('.graphql') || entity.file.endsWith('.gql')) {
+            const schema = extractGraphQLType(entity);
+            if (schema)
+                schemas.push(schema);
+        }
+        // JSON Schema
+        if (entity.file.endsWith('.json') && entity.name.toLowerCase().includes('schema')) {
+            const schema = extractJSONSchema(entity);
+            if (schema)
+                schemas.push(schema);
+        }
     }
+    return schemas;
+}
+function extractTypeScriptInterface(entity) {
+    if (entity.type !== 'interface')
+        return null;
+    return {
+        id: entity.id,
+        name: entity.name,
+        type: 'typescript-interface',
+        language: 'typescript',
+        file: entity.file,
+        line: entity.startLine || 0,
+        fields: entity.parameters?.map(param => ({
+            name: param.name,
+            type: param.type || 'any',
+            required: !param.optional,
+            description: param.description
+        })) || []
+    };
+}
+function extractGoStruct(entity) {
+    if (entity.type !== 'struct')
+        return null;
+    const fields = entity.metadata?.fields?.map((field) => ({
+        name: field.name,
+        type: field.type,
+        required: field.isExported, // Simplified assumption
+        description: field.tag
+    })) || [];
+    return {
+        id: entity.id,
+        name: entity.name,
+        type: 'go-struct',
+        language: 'go',
+        file: entity.file,
+        line: entity.startLine || 0,
+        fields
+    };
+}
+function extractProtobufMessage(entity) {
+    // Simplified protobuf extraction
+    return {
+        id: entity.id,
+        name: entity.name,
+        type: 'protobuf',
+        language: 'protobuf',
+        file: entity.file,
+        line: entity.startLine || 0,
+        fields: [] // Would parse .proto file in real implementation
+    };
+}
+function extractGraphQLType(entity) {
+    // Simplified GraphQL extraction
+    return {
+        id: entity.id,
+        name: entity.name,
+        type: 'graphql',
+        language: 'graphql',
+        file: entity.file,
+        line: entity.startLine || 0,
+        fields: [] // Would parse .graphql file in real implementation
+    };
+}
+function extractJSONSchema(entity) {
+    // Simplified JSON Schema extraction
+    return {
+        id: entity.id,
+        name: entity.name,
+        type: 'json-schema',
+        language: 'json',
+        file: entity.file,
+        line: entity.startLine || 0,
+        fields: [] // Would parse JSON schema in real implementation
+    };
 }
 //# sourceMappingURL=SchemaValidator.js.map