heicat 0.1.2

package/packages/core/src/validation-engine.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { Contract, RequestContract, ResponseContract } from './types/contract';
+import { Violation, ValidationResult } from './types/violation';
+
+export class ValidationEngine {
+  private createSchema(obj: Record<string, any>): z.ZodTypeAny {
+    if (!obj || typeof obj !== 'object') {
+      return z.any();
+    }
+
+    const shape: Record<string, z.ZodTypeAny> = {};
+
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === 'object' && value !== null) {
+        if (value.type) {
+          // Handle type-based schema
+          shape[key] = this.createTypeSchema(value);
+        } else {
+          // Handle nested object
+          shape[key] = this.createSchema(value);
+        }
+      } else if (typeof value === 'string') {
+        // Simple string type
+        shape[key] = z.string();
+      } else {
+        shape[key] = z.any();
+      }
+    }
+
+    return z.object(shape);
+  }
+
+  private createTypeSchema(config: any): z.ZodTypeAny {
+    let schema: z.ZodTypeAny;
+
+    switch (config.type) {
+      case 'string':
+        schema = z.string();
+        if (config.minLength) schema = (schema as z.ZodString).min(config.minLength);
+        if (config.maxLength) schema = (schema as z.ZodString).max(config.maxLength);
+        break;
+      case 'number':
+        schema = z.number();
+        if (config.minimum) schema = (schema as z.ZodNumber).min(config.minimum);
+        if (config.maximum) schema = (schema as z.ZodNumber).max(config.maximum);
+        break;
+      case 'boolean':
+        schema = z.boolean();
+        break;
+      case 'array':
+        schema = z.array(this.createTypeSchema(config.items || {}));
+        break;
+      default:
+        schema = z.any();
+    }
+
+    if (config.required === false) {
+      schema = schema.optional();
+    }
+
+    return schema;
+  }
+
+  validateRequest(
+    contract: Contract,
+    req: any
+  ): ValidationResult {
+    const violations: Violation[] = [];
+
+    if (contract.request?.body) {
+      const bodySchema = this.createSchema(contract.request.body);
+      const result = bodySchema.safeParse(req.body);
+      if (!result.success) {
+        violations.push({
+          id: `req-${Date.now()}-${Math.random()}`,
+          timestamp: new Date(),
+          type: 'request',
+          contractPath: contract.path,
+          endpoint: { method: contract.method, path: contract.path },
+          expected: contract.request.body,
+          actual: req.body,
+          message: `Request body validation failed: ${result.error.message}`,
+          severity: 'error'
+        });
+      }
+    }
+
+    // TODO: Add query, params, headers validation
+
+    return {
+      isValid: violations.length === 0,
+      violations
+    };
+  }
+
+  validateResponse(
+    contract: Contract,
+    statusCode: number,
+    body: any
+  ): ValidationResult {
+    const violations: Violation[] = [];
+
+    if (contract.response && contract.response[statusCode]) {
+      const responseSchema = this.createSchema(contract.response[statusCode]);
+      const result = responseSchema.safeParse(body);
+      if (!result.success) {
+        violations.push({
+          id: `res-${Date.now()}-${Math.random()}`,
+          timestamp: new Date(),
+          type: 'response',
+          contractPath: contract.path,
+          endpoint: { method: contract.method, path: contract.path },
+          expected: contract.response[statusCode],
+          actual: body,
+          message: `Response validation failed for status ${statusCode}: ${result.error.message}`,
+          severity: 'warning' // In dev mode, responses are warnings
+        });
+      }
+    }
+
+    return {
+      isValid: violations.length === 0,
+      violations
+    };
+  }
+
+  validateError(
+    contract: Contract,
+    statusCode: number,
+    body: any
+  ): ValidationResult {
+    const violations: Violation[] = [];
+
+    if (contract.errors && contract.errors[statusCode]) {
+      const errorSchema = this.createSchema(contract.errors[statusCode]);
+      const result = errorSchema.safeParse(body);
+      if (!result.success) {
+        violations.push({
+          id: `err-${Date.now()}-${Math.random()}`,
+          timestamp: new Date(),
+          type: 'error',
+          contractPath: contract.path,
+          endpoint: { method: contract.method, path: contract.path },
+          expected: contract.errors[statusCode],
+          actual: body,
+          message: `Error validation failed for status ${statusCode}: ${result.error.message}`,
+          severity: 'warning'
+        });
+      }
+    }
+
+    return {
+      isValid: violations.length === 0,
+      violations
+    };
+  }
+}

package/packages/core/src/violation-store.ts

@@ -0,0 +1,46 @@
+import { Violation } from './types/violation';
+
+export class ViolationStore {
+  private violations: Violation[] = [];
+  private maxViolations = 1000;
+
+  add(violation: Violation): void {
+    this.violations.unshift(violation);
+    if (this.violations.length > this.maxViolations) {
+      this.violations = this.violations.slice(0, this.maxViolations);
+    }
+  }
+
+  getAll(): Violation[] {
+    return [...this.violations];
+  }
+
+  getByEndpoint(method: string, path: string): Violation[] {
+    return this.violations.filter(v =>
+      v.endpoint.method === method && v.endpoint.path === path
+    );
+  }
+
+  getByType(type: Violation['type']): Violation[] {
+    return this.violations.filter(v => v.type === type);
+  }
+
+  clear(): void {
+    this.violations = [];
+  }
+
+  getStats() {
+    const total = this.violations.length;
+    const byType = this.violations.reduce((acc, v) => {
+      acc[v.type] = (acc[v.type] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    const bySeverity = this.violations.reduce((acc, v) => {
+      acc[v.severity] = (acc[v.severity] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    return { total, byType, bySeverity };
+  }
+}

package/packages/core/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}