@agentic-qe/v3 3.0.0-alpha.3

package/dist/domains/contract-testing/services/schema-validator.js

@@ -0,0 +1,860 @@
+/**
+ * Agentic QE v3 - Schema Validation Service
+ * Implements ISchemaValidationService for schema validation (JSON Schema, OpenAPI, GraphQL)
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { ok, err } from '../../../shared/types/index.js';
+const DEFAULT_CONFIG = {
+    strictMode: false,
+    allowAdditionalProperties: true,
+    maxRecursionDepth: 10,
+    inferenceMinSamples: 3,
+};
+/**
+ * Schema Validation Service Implementation
+ * Validates data against various schema formats
+ */
+export class SchemaValidatorService {
+    memory;
+    config;
+    constructor(memory, config = {}) {
+        this.memory = memory;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Validate JSON Schema
+     */
+    async validateJsonSchema(data, schema) {
+        try {
+            const errors = [];
+            this.validateValue(data, schema, '', errors, 0);
+            const result = {
+                isValid: errors.length === 0,
+                errors,
+            };
+            return ok(result);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Validate GraphQL schema
+     */
+    async validateGraphQLSchema(schema) {
+        try {
+            const errors = [];
+            let typeCount = 0;
+            let queryCount = 0;
+            let mutationCount = 0;
+            // GraphQL schema parsing and validation using line-based analysis
+            const lines = schema.split('\n');
+            let inType = false;
+            let inQuery = false;
+            let inMutation = false;
+            let braceDepth = 0;
+            for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+                const line = lines[lineNum].trim();
+                // Skip comments and empty lines
+                if (line.startsWith('#') || line === '')
+                    continue;
+                // Detect type definitions
+                if (line.startsWith('type ')) {
+                    const typeName = line.split(/\s+/)[1]?.replace(/{.*/, '').trim();
+                    if (typeName === 'Query') {
+                        inQuery = true;
+                    }
+                    else if (typeName === 'Mutation') {
+                        inMutation = true;
+                    }
+                    else {
+                        typeCount++;
+                    }
+                    inType = true;
+                }
+                // Track brace depth
+                braceDepth += (line.match(/{/g) || []).length;
+                braceDepth -= (line.match(/}/g) || []).length;
+                // Count fields in Query/Mutation
+                if (inQuery && line.includes(':') && !line.startsWith('type')) {
+                    queryCount++;
+                }
+                if (inMutation && line.includes(':') && !line.startsWith('type')) {
+                    mutationCount++;
+                }
+                // Reset when type ends
+                if (braceDepth === 0 && inType) {
+                    inType = false;
+                    inQuery = false;
+                    inMutation = false;
+                }
+                // Basic syntax validation
+                if (line.includes('::')) {
+                    errors.push({
+                        message: 'Invalid double colon in type definition',
+                        locations: [{ line: lineNum + 1, column: line.indexOf('::') + 1 }],
+                    });
+                }
+            }
+            // Check for unbalanced braces
+            if (braceDepth !== 0) {
+                errors.push({
+                    message: 'Unbalanced braces in schema',
+                    locations: [{ line: lines.length, column: 1 }],
+                });
+            }
+            // Check for required types
+            if (!schema.includes('type Query') && !schema.includes('schema {')) {
+                errors.push({
+                    message: 'GraphQL schema must have a Query type or schema definition',
+                    locations: [{ line: 1, column: 1 }],
+                });
+            }
+            return ok({
+                isValid: errors.length === 0,
+                errors,
+                typeCount,
+                queryCount,
+                mutationCount,
+            });
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Compare schemas for compatibility
+     */
+    async compareSchemas(oldSchema, newSchema) {
+        try {
+            const additions = [];
+            const removals = [];
+            const modifications = [];
+            // Only compare same type schemas
+            if (oldSchema.type !== newSchema.type) {
+                return ok({
+                    isCompatible: false,
+                    additions: [],
+                    removals: [],
+                    modifications: [
+                        {
+                            path: 'type',
+                            oldType: oldSchema.type,
+                            newType: newSchema.type,
+                            isBreaking: true,
+                        },
+                    ],
+                });
+            }
+            switch (oldSchema.type) {
+                case 'json-schema':
+                case 'openapi':
+                    this.compareJsonSchemas(oldSchema.content, newSchema.content, additions, removals, modifications);
+                    break;
+                case 'graphql':
+                    this.compareGraphQLSchemas(oldSchema.content, newSchema.content, additions, removals, modifications);
+                    break;
+                case 'protobuf':
+                    this.compareProtobufSchemas(oldSchema.content, newSchema.content, additions, removals, modifications);
+                    break;
+                case 'avro':
+                    this.compareAvroSchemas(oldSchema.content, newSchema.content, additions, removals, modifications);
+                    break;
+            }
+            const hasBreakingChanges = modifications.some((m) => m.isBreaking) || removals.length > 0;
+            // Store comparison result
+            await this.storeComparisonResult(oldSchema, newSchema, {
+                isCompatible: !hasBreakingChanges,
+                additions,
+                removals,
+                modifications,
+            });
+            return ok({
+                isCompatible: !hasBreakingChanges,
+                additions,
+                removals,
+                modifications,
+            });
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Generate schema from sample data
+     */
+    async inferSchema(samples) {
+        try {
+            if (samples.length === 0) {
+                return err(new Error('At least one sample is required for schema inference'));
+            }
+            if (samples.length < this.config.inferenceMinSamples) {
+                // Warning: fewer samples may lead to incomplete schema
+            }
+            const inferredSchema = this.inferFromSamples(samples);
+            const schemaDefinition = {
+                id: `inferred-${uuidv4().slice(0, 8)}`,
+                name: 'InferredSchema',
+                type: 'json-schema',
+                content: JSON.stringify(inferredSchema, null, 2),
+            };
+            // Store inferred schema
+            await this.memory.set(`contract-testing:schema:${schemaDefinition.id}`, schemaDefinition, { namespace: 'contract-testing' });
+            return ok(schemaDefinition);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    // ============================================================================
+    // Private Validation Methods
+    // ============================================================================
+    validateValue(value, schema, path, errors, depth) {
+        if (depth > this.config.maxRecursionDepth) {
+            errors.push({
+                path,
+                keyword: 'maxDepth',
+                message: 'Maximum recursion depth exceeded',
+                params: { maxDepth: this.config.maxRecursionDepth },
+            });
+            return;
+        }
+        // Handle nullable
+        if (value === null) {
+            if (schema.nullable === true || schema.type === 'null') {
+                return;
+            }
+            if (this.config.strictMode) {
+                errors.push({
+                    path,
+                    keyword: 'type',
+                    message: 'Value cannot be null',
+                    params: {},
+                });
+            }
+            return;
+        }
+        const schemaType = schema.type;
+        // Handle oneOf, anyOf, allOf
+        if (schema.oneOf) {
+            this.validateOneOf(value, schema.oneOf, path, errors, depth);
+            return;
+        }
+        if (schema.anyOf) {
+            this.validateAnyOf(value, schema.anyOf, path, errors, depth);
+            return;
+        }
+        if (schema.allOf) {
+            this.validateAllOf(value, schema.allOf, path, errors, depth);
+            return;
+        }
+        // Validate type
+        if (schemaType) {
+            const types = Array.isArray(schemaType) ? schemaType : [schemaType];
+            const actualType = this.getJsonType(value);
+            if (!types.some((t) => this.typesMatch(actualType, t))) {
+                errors.push({
+                    path,
+                    keyword: 'type',
+                    message: `Expected type '${types.join(' | ')}' but got '${actualType}'`,
+                    params: { expectedType: types, actualType },
+                });
+                return;
+            }
+        }
+        // Type-specific validation
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            this.validateObject(value, schema, path, errors, depth);
+        }
+        else if (Array.isArray(value)) {
+            this.validateArray(value, schema, path, errors, depth);
+        }
+        else if (typeof value === 'string') {
+            this.validateString(value, schema, path, errors);
+        }
+        else if (typeof value === 'number') {
+            this.validateNumber(value, schema, path, errors);
+        }
+        // Validate enum
+        if (schema.enum) {
+            const enumValues = schema.enum;
+            if (!enumValues.includes(value)) {
+                errors.push({
+                    path,
+                    keyword: 'enum',
+                    message: `Value must be one of: ${enumValues.map((v) => JSON.stringify(v)).join(', ')}`,
+                    params: { allowedValues: enumValues },
+                });
+            }
+        }
+        // Validate const
+        if ('const' in schema) {
+            if (value !== schema.const) {
+                errors.push({
+                    path,
+                    keyword: 'const',
+                    message: `Value must be ${JSON.stringify(schema.const)}`,
+                    params: { expected: schema.const },
+                });
+            }
+        }
+    }
+    validateObject(value, schema, path, errors, depth) {
+        const properties = schema.properties || {};
+        const required = schema.required || [];
+        const additionalProperties = schema.additionalProperties;
+        // Check required properties
+        for (const prop of required) {
+            if (!(prop in value)) {
+                errors.push({
+                    path: path ? `${path}.${prop}` : prop,
+                    keyword: 'required',
+                    message: `Required property '${prop}' is missing`,
+                    params: { missingProperty: prop },
+                });
+            }
+        }
+        // Validate each property
+        for (const [prop, propValue] of Object.entries(value)) {
+            const propPath = path ? `${path}.${prop}` : prop;
+            if (prop in properties) {
+                this.validateValue(propValue, properties[prop], propPath, errors, depth + 1);
+            }
+            else if (this.config.strictMode && additionalProperties === false) {
+                errors.push({
+                    path: propPath,
+                    keyword: 'additionalProperties',
+                    message: `Property '${prop}' is not allowed`,
+                    params: { additionalProperty: prop },
+                });
+            }
+            else if (typeof additionalProperties === 'object') {
+                this.validateValue(propValue, additionalProperties, propPath, errors, depth + 1);
+            }
+        }
+        // Validate minProperties / maxProperties
+        const propCount = Object.keys(value).length;
+        if (typeof schema.minProperties === 'number' && propCount < schema.minProperties) {
+            errors.push({
+                path,
+                keyword: 'minProperties',
+                message: `Object must have at least ${schema.minProperties} properties`,
+                params: { limit: schema.minProperties, actual: propCount },
+            });
+        }
+        if (typeof schema.maxProperties === 'number' && propCount > schema.maxProperties) {
+            errors.push({
+                path,
+                keyword: 'maxProperties',
+                message: `Object must have at most ${schema.maxProperties} properties`,
+                params: { limit: schema.maxProperties, actual: propCount },
+            });
+        }
+    }
+    validateArray(value, schema, path, errors, depth) {
+        const items = schema.items;
+        // Validate items
+        if (items) {
+            for (let i = 0; i < value.length; i++) {
+                this.validateValue(value[i], items, `${path}[${i}]`, errors, depth + 1);
+            }
+        }
+        // Validate minItems / maxItems
+        if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
+            errors.push({
+                path,
+                keyword: 'minItems',
+                message: `Array must have at least ${schema.minItems} items`,
+                params: { limit: schema.minItems, actual: value.length },
+            });
+        }
+        if (typeof schema.maxItems === 'number' && value.length > schema.maxItems) {
+            errors.push({
+                path,
+                keyword: 'maxItems',
+                message: `Array must have at most ${schema.maxItems} items`,
+                params: { limit: schema.maxItems, actual: value.length },
+            });
+        }
+        // Validate uniqueItems
+        if (schema.uniqueItems === true) {
+            const seen = new Set();
+            for (let i = 0; i < value.length; i++) {
+                const serialized = JSON.stringify(value[i]);
+                if (seen.has(serialized)) {
+                    errors.push({
+                        path: `${path}[${i}]`,
+                        keyword: 'uniqueItems',
+                        message: 'Array items must be unique',
+                        params: { duplicateIndex: i },
+                    });
+                }
+                seen.add(serialized);
+            }
+        }
+    }
+    validateString(value, schema, path, errors) {
+        if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
+            errors.push({
+                path,
+                keyword: 'minLength',
+                message: `String must be at least ${schema.minLength} characters`,
+                params: { limit: schema.minLength, actual: value.length },
+            });
+        }
+        if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
+            errors.push({
+                path,
+                keyword: 'maxLength',
+                message: `String must be at most ${schema.maxLength} characters`,
+                params: { limit: schema.maxLength, actual: value.length },
+            });
+        }
+        if (typeof schema.pattern === 'string') {
+            const regex = new RegExp(schema.pattern);
+            if (!regex.test(value)) {
+                errors.push({
+                    path,
+                    keyword: 'pattern',
+                    message: `String must match pattern '${schema.pattern}'`,
+                    params: { pattern: schema.pattern },
+                });
+            }
+        }
+        // Validate format
+        if (typeof schema.format === 'string') {
+            this.validateFormat(value, schema.format, path, errors);
+        }
+    }
+    validateNumber(value, schema, path, errors) {
+        if (typeof schema.minimum === 'number') {
+            if (schema.exclusiveMinimum === true) {
+                if (value <= schema.minimum) {
+                    errors.push({
+                        path,
+                        keyword: 'exclusiveMinimum',
+                        message: `Number must be greater than ${schema.minimum}`,
+                        params: { limit: schema.minimum, actual: value },
+                    });
+                }
+            }
+            else if (value < schema.minimum) {
+                errors.push({
+                    path,
+                    keyword: 'minimum',
+                    message: `Number must be at least ${schema.minimum}`,
+                    params: { limit: schema.minimum, actual: value },
+                });
+            }
+        }
+        if (typeof schema.maximum === 'number') {
+            if (schema.exclusiveMaximum === true) {
+                if (value >= schema.maximum) {
+                    errors.push({
+                        path,
+                        keyword: 'exclusiveMaximum',
+                        message: `Number must be less than ${schema.maximum}`,
+                        params: { limit: schema.maximum, actual: value },
+                    });
+                }
+            }
+            else if (value > schema.maximum) {
+                errors.push({
+                    path,
+                    keyword: 'maximum',
+                    message: `Number must be at most ${schema.maximum}`,
+                    params: { limit: schema.maximum, actual: value },
+                });
+            }
+        }
+        if (typeof schema.multipleOf === 'number') {
+            const remainder = value % schema.multipleOf;
+            if (Math.abs(remainder) > 1e-10) {
+                errors.push({
+                    path,
+                    keyword: 'multipleOf',
+                    message: `Number must be a multiple of ${schema.multipleOf}`,
+                    params: { multipleOf: schema.multipleOf, actual: value },
+                });
+            }
+        }
+    }
+    validateFormat(value, format, path, errors) {
+        let isValid = true;
+        switch (format) {
+            case 'email':
+                isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+                break;
+            case 'uri':
+            case 'url':
+                try {
+                    new URL(value);
+                }
+                catch {
+                    isValid = false;
+                }
+                break;
+            case 'uuid':
+                isValid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+                break;
+            case 'date':
+                isValid = !isNaN(Date.parse(value)) && /^\d{4}-\d{2}-\d{2}$/.test(value);
+                break;
+            case 'date-time':
+                isValid = !isNaN(Date.parse(value));
+                break;
+            case 'time':
+                isValid = /^\d{2}:\d{2}(:\d{2})?/.test(value);
+                break;
+            case 'ipv4':
+                isValid = /^(\d{1,3}\.){3}\d{1,3}$/.test(value);
+                break;
+            case 'ipv6':
+                isValid = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/.test(value);
+                break;
+            default:
+                // Unknown format, skip validation
+                return;
+        }
+        if (!isValid) {
+            errors.push({
+                path,
+                keyword: 'format',
+                message: `String must be a valid ${format}`,
+                params: { format },
+            });
+        }
+    }
+    validateOneOf(value, schemas, path, errors, depth) {
+        const validCount = schemas.reduce((count, schema) => {
+            const subErrors = [];
+            this.validateValue(value, schema, path, subErrors, depth + 1);
+            return count + (subErrors.length === 0 ? 1 : 0);
+        }, 0);
+        if (validCount !== 1) {
+            errors.push({
+                path,
+                keyword: 'oneOf',
+                message: `Value must match exactly one schema (matched ${validCount})`,
+                params: { matched: validCount },
+            });
+        }
+    }
+    validateAnyOf(value, schemas, path, errors, depth) {
+        const hasValid = schemas.some((schema) => {
+            const subErrors = [];
+            this.validateValue(value, schema, path, subErrors, depth + 1);
+            return subErrors.length === 0;
+        });
+        if (!hasValid) {
+            errors.push({
+                path,
+                keyword: 'anyOf',
+                message: 'Value must match at least one schema',
+                params: {},
+            });
+        }
+    }
+    validateAllOf(value, schemas, path, errors, depth) {
+        for (const schema of schemas) {
+            this.validateValue(value, schema, path, errors, depth + 1);
+        }
+    }
+    getJsonType(value) {
+        if (value === null)
+            return 'null';
+        if (Array.isArray(value))
+            return 'array';
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? 'integer' : 'number';
+        }
+        return typeof value;
+    }
+    typesMatch(actual, expected) {
+        if (actual === expected)
+            return true;
+        if (expected === 'number' && actual === 'integer')
+            return true;
+        return false;
+    }
+    // ============================================================================
+    // Schema Comparison Methods
+    // ============================================================================
+    compareJsonSchemas(oldContent, newContent, additions, removals, modifications) {
+        try {
+            const oldSchema = JSON.parse(oldContent);
+            const newSchema = JSON.parse(newContent);
+            this.compareSchemaObjects(oldSchema, newSchema, '', additions, removals, modifications);
+        }
+        catch {
+            modifications.push({
+                path: '',
+                oldType: 'unparseable',
+                newType: 'unparseable',
+                isBreaking: true,
+            });
+        }
+    }
+    compareSchemaObjects(oldSchema, newSchema, path, additions, removals, modifications) {
+        const oldProps = oldSchema.properties || {};
+        const newProps = newSchema.properties || {};
+        const oldRequired = new Set(oldSchema.required || []);
+        const newRequired = new Set(newSchema.required || []);
+        // Check for removed properties
+        for (const prop of Object.keys(oldProps)) {
+            if (!(prop in newProps)) {
+                const propPath = path ? `${path}.${prop}` : prop;
+                removals.push(propPath);
+            }
+        }
+        // Check for added properties
+        for (const prop of Object.keys(newProps)) {
+            if (!(prop in oldProps)) {
+                const propPath = path ? `${path}.${prop}` : prop;
+                additions.push(propPath);
+                // New required property is breaking
+                if (newRequired.has(prop)) {
+                    modifications.push({
+                        path: propPath,
+                        oldType: 'undefined',
+                        newType: 'required',
+                        isBreaking: true,
+                    });
+                }
+            }
+        }
+        // Check for type changes
+        if (oldSchema.type !== newSchema.type) {
+            modifications.push({
+                path: path || 'root',
+                oldType: String(oldSchema.type || 'any'),
+                newType: String(newSchema.type || 'any'),
+                isBreaking: true,
+            });
+        }
+        // Check for required changes
+        const newRequiredArray = Array.from(newRequired);
+        for (const prop of newRequiredArray) {
+            if (!oldRequired.has(prop) && prop in oldProps) {
+                const propPath = path ? `${path}.${prop}` : prop;
+                modifications.push({
+                    path: propPath,
+                    oldType: 'optional',
+                    newType: 'required',
+                    isBreaking: true,
+                });
+            }
+        }
+    }
+    compareGraphQLSchemas(oldContent, newContent, additions, removals, _modifications) {
+        // Extract types from both schemas (simplified)
+        const oldTypes = this.extractGraphQLTypes(oldContent);
+        const newTypes = this.extractGraphQLTypes(newContent);
+        for (const typeName of oldTypes) {
+            if (!newTypes.includes(typeName)) {
+                removals.push(`type:${typeName}`);
+            }
+        }
+        for (const typeName of newTypes) {
+            if (!oldTypes.includes(typeName)) {
+                additions.push(`type:${typeName}`);
+            }
+        }
+    }
+    extractGraphQLTypes(schema) {
+        const types = [];
+        const typeRegex = /type\s+(\w+)/g;
+        let match;
+        while ((match = typeRegex.exec(schema)) !== null) {
+            types.push(match[1]);
+        }
+        return types;
+    }
+    compareProtobufSchemas(oldContent, newContent, additions, removals, _modifications) {
+        // Extract messages from both schemas
+        const oldMessages = this.extractProtobufMessages(oldContent);
+        const newMessages = this.extractProtobufMessages(newContent);
+        for (const msg of oldMessages) {
+            if (!newMessages.includes(msg)) {
+                removals.push(`message:${msg}`);
+            }
+        }
+        for (const msg of newMessages) {
+            if (!oldMessages.includes(msg)) {
+                additions.push(`message:${msg}`);
+            }
+        }
+    }
+    extractProtobufMessages(schema) {
+        const messages = [];
+        const msgRegex = /message\s+(\w+)/g;
+        let match;
+        while ((match = msgRegex.exec(schema)) !== null) {
+            messages.push(match[1]);
+        }
+        return messages;
+    }
+    compareAvroSchemas(oldContent, newContent, _additions, _removals, modifications) {
+        try {
+            const oldSchema = JSON.parse(oldContent);
+            const newSchema = JSON.parse(newContent);
+            // Compare type
+            if (oldSchema.type !== newSchema.type) {
+                modifications.push({
+                    path: 'type',
+                    oldType: String(oldSchema.type),
+                    newType: String(newSchema.type),
+                    isBreaking: true,
+                });
+            }
+            // Compare name
+            if (oldSchema.name !== newSchema.name) {
+                modifications.push({
+                    path: 'name',
+                    oldType: String(oldSchema.name),
+                    newType: String(newSchema.name),
+                    isBreaking: true,
+                });
+            }
+        }
+        catch {
+            modifications.push({
+                path: '',
+                oldType: 'unparseable',
+                newType: 'unparseable',
+                isBreaking: true,
+            });
+        }
+    }
+    // ============================================================================
+    // Schema Inference
+    // ============================================================================
+    inferFromSamples(samples) {
+        if (samples.length === 0) {
+            return { type: 'null' };
+        }
+        // Merge inferred types from all samples
+        const types = samples.map((s) => this.inferType(s));
+        return this.mergeTypes(types);
+    }
+    inferType(value) {
+        if (value === null) {
+            return { type: 'null' };
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                return { type: 'array', items: {} };
+            }
+            const itemTypes = value.map((item) => this.inferType(item));
+            return { type: 'array', items: this.mergeTypes(itemTypes) };
+        }
+        if (typeof value === 'object') {
+            const properties = {};
+            const required = [];
+            for (const [key, val] of Object.entries(value)) {
+                properties[key] = this.inferType(val);
+                if (val !== undefined) {
+                    required.push(key);
+                }
+            }
+            return { type: 'object', properties, required };
+        }
+        if (typeof value === 'string') {
+            const format = this.inferStringFormat(value);
+            return format ? { type: 'string', format } : { type: 'string' };
+        }
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? { type: 'integer' } : { type: 'number' };
+        }
+        if (typeof value === 'boolean') {
+            return { type: 'boolean' };
+        }
+        return {};
+    }
+    inferStringFormat(value) {
+        if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return 'email';
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value))
+            return 'uuid';
+        if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value))
+            return 'date-time';
+        if (/^\d{4}-\d{2}-\d{2}$/.test(value))
+            return 'date';
+        try {
+            new URL(value);
+            return 'uri';
+        }
+        catch {
+            return null;
+        }
+    }
+    mergeTypes(types) {
+        if (types.length === 0)
+            return {};
+        if (types.length === 1)
+            return types[0];
+        // Get unique types
+        const typeSet = new Set(types.map((t) => t.type));
+        if (typeSet.size === 1) {
+            // All same type, merge properties if object
+            const baseType = types[0].type;
+            if (baseType === 'object') {
+                const allProperties = new Map();
+                const allRequired = new Set();
+                for (const type of types) {
+                    const props = type.properties || {};
+                    const req = type.required || [];
+                    for (const [key, val] of Object.entries(props)) {
+                        if (!allProperties.has(key)) {
+                            allProperties.set(key, []);
+                        }
+                        allProperties.get(key).push(val);
+                    }
+                    for (const r of req) {
+                        allRequired.add(r);
+                    }
+                }
+                const mergedProps = {};
+                const allPropertiesEntries = Array.from(allProperties.entries());
+                for (const [key, vals] of allPropertiesEntries) {
+                    mergedProps[key] = this.mergeTypes(vals);
+                }
+                // Only required if in all samples
+                const allRequiredArray = Array.from(allRequired);
+                const commonRequired = allRequiredArray.filter((r) => types.every((t) => (t.required || []).includes(r)));
+                return {
+                    type: 'object',
+                    properties: mergedProps,
+                    required: commonRequired,
+                };
+            }
+            if (baseType === 'array') {
+                const itemTypes = types
+                    .map((t) => t.items)
+                    .filter((i) => i && Object.keys(i).length > 0);
+                return {
+                    type: 'array',
+                    items: itemTypes.length > 0 ? this.mergeTypes(itemTypes) : {},
+                };
+            }
+            return types[0];
+        }
+        // Multiple types - use anyOf
+        return {
+            anyOf: types,
+        };
+    }
+    async storeComparisonResult(oldSchema, newSchema, result) {
+        const key = `contract-testing:schema-comparison:${oldSchema.id}:${newSchema.id}:${Date.now()}`;
+        await this.memory.set(key, {
+            oldSchemaId: oldSchema.id,
+            newSchemaId: newSchema.id,
+            isCompatible: result.isCompatible,
+            timestamp: new Date().toISOString(),
+        }, {
+            namespace: 'contract-testing',
+            ttl: 86400 * 30, // 30 days
+        });
+    }
+}
+//# sourceMappingURL=schema-validator.js.map