norn-cli 2.2.2 → 2.4.0

package/out/schemaGenerator.js

@@ -0,0 +1,562 @@
+"use strict";
+/**
+ * Schema Generator - Generates JSON Schema from response bodies
+ * and validates data against JSON Schema
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchemaPath = resolveSchemaPath;
+exports.generateJsonSchema = generateJsonSchema;
+exports.validateAgainstSchemaDetailed = validateAgainstSchemaDetailed;
+exports.validateAgainstSchemaObjectDetailed = validateAgainstSchemaObjectDetailed;
+exports.validateAgainstSchema = validateAgainstSchema;
+exports.generateSchemaFileName = generateSchemaFileName;
+exports.saveSchema = saveSchema;
+const ajv_1 = __importDefault(require("ajv"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ajv = new ajv_1.default({ allErrors: true, strict: false });
+for (const formatName of ['int32', 'int64', 'float', 'double']) {
+    ajv.addFormat(formatName, {
+        type: 'number',
+        validate: () => true
+    });
+}
+/**
+ * Path alias prefix - @/ resolves to contracts/ folder
+ */
+const PATH_ALIAS_PREFIX = '@/';
+const DEFAULT_CONTRACTS_FOLDER = 'contracts';
+/**
+ * Resolve a schema path, handling the @/ alias for contracts folder
+ * @param schemaPath The original schema path (may have @/ prefix)
+ * @param basePath Base path for relative paths (usually the source file's directory)
+ * @param workspaceRoot Optional workspace root for @/ alias resolution
+ * @returns Resolved absolute path
+ */
+function resolveSchemaPath(schemaPath, basePath, workspaceRoot) {
+    // Handle @/ alias
+    if (schemaPath.startsWith(PATH_ALIAS_PREFIX)) {
+        const relativePath = schemaPath.slice(PATH_ALIAS_PREFIX.length);
+        // First try workspace root, then fall back to basePath traversal
+        if (workspaceRoot) {
+            return path.resolve(workspaceRoot, DEFAULT_CONTRACTS_FOLDER, relativePath);
+        }
+        // If no workspace root, try to find contracts folder by walking up
+        if (basePath) {
+            let currentDir = basePath;
+            let attempts = 0;
+            while (attempts < 10) {
+                const contractsPath = path.join(currentDir, DEFAULT_CONTRACTS_FOLDER, relativePath);
+                if (fs.existsSync(path.dirname(contractsPath))) {
+                    return contractsPath;
+                }
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir) {
+                    break;
+                }
+                currentDir = parentDir;
+                attempts++;
+            }
+        }
+        // Fallback: just use contracts/ relative to basePath
+        if (basePath) {
+            return path.resolve(basePath, DEFAULT_CONTRACTS_FOLDER, relativePath);
+        }
+        return schemaPath; // Can't resolve
+    }
+    // Regular relative/absolute path handling
+    if (path.isAbsolute(schemaPath)) {
+        return schemaPath;
+    }
+    if (basePath) {
+        return path.resolve(basePath, schemaPath);
+    }
+    return schemaPath;
+}
+/**
+ * Generate a JSON Schema (draft-07) from a sample value
+ */
+function generateJsonSchema(value, title) {
+    const schema = {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+    };
+    if (title) {
+        schema.title = title;
+    }
+    const typeSchema = inferType(value);
+    Object.assign(schema, typeSchema);
+    return schema;
+}
+/**
+ * Infer JSON Schema type information from a value
+ */
+function inferType(value) {
+    if (value === null) {
+        return { type: 'null' };
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return { type: 'array', items: {} };
+        }
+        // Infer from first item (could be enhanced to merge schemas)
+        return {
+            type: 'array',
+            items: inferType(value[0])
+        };
+    }
+    if (typeof value === 'object') {
+        const properties = {};
+        const required = [];
+        for (const key of Object.keys(value)) {
+            properties[key] = inferType(value[key]);
+            // Mark all properties as required by default
+            required.push(key);
+        }
+        return {
+            type: 'object',
+            properties,
+            required: required.length > 0 ? required : undefined,
+            additionalProperties: true
+        };
+    }
+    if (typeof value === 'string') {
+        return { type: 'string' };
+    }
+    if (typeof value === 'number') {
+        return Number.isInteger(value) ? { type: 'integer' } : { type: 'number' };
+    }
+    if (typeof value === 'boolean') {
+        return { type: 'boolean' };
+    }
+    return {};
+}
+/**
+ * Convert Ajv ErrorObject to rich SchemaValidationError
+ */
+function convertAjvError(err, value) {
+    let instancePath = err.instancePath || '(root)';
+    // Determine expected value based on keyword
+    let expected;
+    let actual = undefined;
+    switch (err.keyword) {
+        case 'type':
+            expected = err.params.type;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        case 'required':
+            expected = `property "${err.params.missingProperty}" to exist`;
+            if (typeof err.params.missingProperty === 'string') {
+                instancePath = appendJsonPointerPath(instancePath, err.params.missingProperty);
+            }
+            break;
+        case 'enum':
+            expected = `one of: ${err.params.allowedValues?.join(', ')}`;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        case 'pattern':
+            expected = `to match pattern "${err.params.pattern}"`;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        case 'minLength':
+            expected = `length >= ${err.params.limit}`;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        case 'maxLength':
+            expected = `length <= ${err.params.limit}`;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        case 'minimum':
+        case 'exclusiveMinimum':
+            expected = `>= ${err.params.limit}`;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        case 'maximum':
+        case 'exclusiveMaximum':
+            expected = `<= ${err.params.limit}`;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        case 'additionalProperties':
+            expected = `no additional property "${err.params.additionalProperty}"`;
+            if (typeof err.params.additionalProperty === 'string') {
+                instancePath = appendJsonPointerPath(instancePath, err.params.additionalProperty);
+                actual = getValueAtPath(value, instancePath);
+            }
+            break;
+        case 'format':
+            expected = `format "${err.params.format}"`;
+            actual = getValueAtPath(value, instancePath);
+            break;
+        default:
+            if (err.params) {
+                expected = JSON.stringify(err.params);
+            }
+            actual = getValueAtPath(value, instancePath);
+    }
+    // Determine severity based on keyword
+    let severity = 'error';
+    if (err.keyword === 'additionalProperties') {
+        severity = 'warning'; // Extra properties are often okay
+    }
+    return {
+        instancePath,
+        schemaPath: err.schemaPath,
+        keyword: err.keyword,
+        message: err.message || 'Validation failed',
+        params: err.params,
+        expected,
+        actual,
+        severity
+    };
+}
+function appendJsonPointerPath(basePath, propertyName) {
+    const normalizedBasePath = !basePath || basePath === '(root)' ? '' : basePath;
+    const escapedPropertyName = propertyName.replace(/~/g, '~0').replace(/\//g, '~1');
+    return `${normalizedBasePath}/${escapedPropertyName}`;
+}
+/**
+ * Get value at a JSON pointer path
+ */
+function getValueAtPath(obj, jsonPointer) {
+    if (jsonPointer === '(root)' || jsonPointer === '' || jsonPointer === '/') {
+        return obj;
+    }
+    // Remove leading slash and split
+    const parts = jsonPointer.replace(/^\//, '').split('/');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        // Decode JSON Pointer escapes
+        const key = part.replace(/~1/g, '/').replace(/~0/g, '~');
+        current = current[key];
+    }
+    return current;
+}
+const SCHEMA_RULE_KEYWORDS = new Set([
+    'type',
+    'enum',
+    'const',
+    'multipleOf',
+    'maximum',
+    'exclusiveMaximum',
+    'minimum',
+    'exclusiveMinimum',
+    'maxLength',
+    'minLength',
+    'pattern',
+    'format',
+    'maxItems',
+    'minItems',
+    'uniqueItems',
+    'maxContains',
+    'minContains',
+    'maxProperties',
+    'minProperties',
+    'propertyNames',
+    'dependentRequired',
+]);
+const SCHEMA_MAP_KEYWORDS = new Set([
+    'properties',
+    'patternProperties',
+    'dependentSchemas',
+    '$defs',
+    'definitions',
+]);
+const SCHEMA_ARRAY_KEYWORDS = new Set(['allOf', 'anyOf', 'oneOf']);
+const SCHEMA_NESTED_SCHEMA_KEYWORDS = new Set(['items', 'prefixItems', 'additionalItems', 'contains', 'not', 'if', 'then', 'else']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function countSchemaRules(schema) {
+    if (Array.isArray(schema)) {
+        return schema.reduce((sum, item) => sum + countSchemaRules(item), 0);
+    }
+    if (!isRecord(schema)) {
+        return 0;
+    }
+    let count = 0;
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'required' && Array.isArray(value)) {
+            count += value.length;
+            continue;
+        }
+        if (SCHEMA_MAP_KEYWORDS.has(key)) {
+            if (isRecord(value)) {
+                for (const childSchema of Object.values(value)) {
+                    count += countSchemaRules(childSchema);
+                }
+            }
+            continue;
+        }
+        if (SCHEMA_ARRAY_KEYWORDS.has(key)) {
+            count += 1;
+            count += countSchemaRules(value);
+            continue;
+        }
+        if (key === 'additionalProperties' || key === 'unevaluatedProperties') {
+            if (value !== true) {
+                count += 1;
+            }
+            if (isRecord(value)) {
+                count += countSchemaRules(value);
+            }
+            continue;
+        }
+        if (SCHEMA_NESTED_SCHEMA_KEYWORDS.has(key)) {
+            if (key !== 'items' && key !== 'prefixItems') {
+                count += 1;
+            }
+            count += countSchemaRules(value);
+            continue;
+        }
+        if (SCHEMA_RULE_KEYWORDS.has(key)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function buildValidationSummary(schema, errors, valid) {
+    const issueCount = errors?.length || 0;
+    const errorCount = errors?.filter(error => error.severity === 'error').length || 0;
+    const warningCount = errors?.filter(error => error.severity === 'warning').length || 0;
+    const totalRules = Math.max(schema ? countSchemaRules(schema) : 0, issueCount);
+    const failedRules = valid ? 0 : issueCount;
+    return {
+        totalRules,
+        passedRules: Math.max(totalRules - failedRules, 0),
+        failedRules,
+        issueCount,
+        errorCount,
+        warningCount
+    };
+}
+/**
+ * Validate a value against a JSON Schema file with detailed error information
+ * @param value The value to validate
+ * @param schemaPath Absolute or relative path to the schema file (supports @/ alias for contracts/)
+ * @param basePath Base path for resolving relative schema paths
+ * @param workspaceRoot Optional workspace root for @/ alias resolution
+ * @returns Detailed result with rich error objects for Contract View
+ */
+function validateAgainstSchemaDetailed(value, schemaPath, basePath, workspaceRoot) {
+    try {
+        // Resolve schema path (handles @/ alias for contracts folder)
+        const resolvedPath = resolveSchemaPath(schemaPath, basePath, workspaceRoot);
+        // Check if file exists
+        if (!fs.existsSync(resolvedPath)) {
+            const errors = [{
+                    instancePath: '(root)',
+                    schemaPath: '',
+                    keyword: 'file',
+                    message: `Schema file not found: ${schemaPath}`,
+                    params: { path: schemaPath },
+                    severity: 'error'
+                }];
+            return {
+                valid: false,
+                errors,
+                errorStrings: [`Schema file not found: ${schemaPath}`],
+                resolvedSchemaPath: resolvedPath,
+                summary: buildValidationSummary(undefined, errors, false)
+            };
+        }
+        // Load and parse schema
+        const schemaContent = fs.readFileSync(resolvedPath, 'utf-8');
+        let schema;
+        try {
+            schema = JSON.parse(schemaContent);
+        }
+        catch (e) {
+            const errors = [{
+                    instancePath: '(root)',
+                    schemaPath: '',
+                    keyword: 'parse',
+                    message: `Invalid JSON in schema file: ${schemaPath}`,
+                    params: { path: schemaPath },
+                    severity: 'error'
+                }];
+            return {
+                valid: false,
+                errors,
+                errorStrings: [`Invalid JSON in schema file: ${schemaPath}`],
+                resolvedSchemaPath: resolvedPath,
+                summary: buildValidationSummary(undefined, errors, false)
+            };
+        }
+        // Validate
+        const validate = ajv.compile(schema);
+        const valid = validate(value);
+        if (!valid && validate.errors) {
+            const errors = validate.errors.map(err => convertAjvError(err, value));
+            const errorStrings = validate.errors.map(err => {
+                const path = err.instancePath || '(root)';
+                return `${path}: ${err.message}`;
+            });
+            return {
+                valid: false,
+                errors,
+                errorStrings,
+                resolvedSchemaPath: resolvedPath,
+                schema,
+                summary: buildValidationSummary(schema, errors, false)
+            };
+        }
+        return {
+            valid: true,
+            resolvedSchemaPath: resolvedPath,
+            schema,
+            summary: buildValidationSummary(schema, undefined, true)
+        };
+    }
+    catch (e) {
+        const error = e instanceof Error ? e.message : String(e);
+        const errors = [{
+                instancePath: '(root)',
+                schemaPath: '',
+                keyword: 'exception',
+                message: `Schema validation error: ${error}`,
+                params: {},
+                severity: 'error'
+            }];
+        return {
+            valid: false,
+            errors,
+            errorStrings: [`Schema validation error: ${error}`],
+            summary: buildValidationSummary(undefined, errors, false)
+        };
+    }
+}
+function validateAgainstSchemaObjectDetailed(value, schema) {
+    try {
+        const validate = ajv.compile(schema);
+        const valid = validate(value);
+        if (!valid && validate.errors) {
+            const errors = validate.errors.map(err => convertAjvError(err, value));
+            const errorStrings = validate.errors.map(err => {
+                const path = err.instancePath || '(root)';
+                return `${path}: ${err.message}`;
+            });
+            return {
+                valid: false,
+                errors,
+                errorStrings,
+                schema,
+                summary: buildValidationSummary(schema, errors, false)
+            };
+        }
+        return {
+            valid: true,
+            schema,
+            summary: buildValidationSummary(schema, undefined, true)
+        };
+    }
+    catch (e) {
+        const error = e instanceof Error ? e.message : String(e);
+        const errors = [{
+                instancePath: '(root)',
+                schemaPath: '',
+                keyword: 'exception',
+                message: `Schema validation error: ${error}`,
+                params: {},
+                severity: 'error'
+            }];
+        return {
+            valid: false,
+            errors,
+            errorStrings: [`Schema validation error: ${error}`],
+            schema,
+            summary: buildValidationSummary(schema, errors, false)
+        };
+    }
+}
+/**
+ * Validate a value against a JSON Schema file
+ * @param value The value to validate
+ * @param schemaPath Absolute or relative path to the schema file
+ * @param basePath Base path for resolving relative schema paths
+ * @returns Object with valid flag and optional errors (backward compatible)
+ */
+function validateAgainstSchema(value, schemaPath, basePath) {
+    const result = validateAgainstSchemaDetailed(value, schemaPath, basePath);
+    return {
+        valid: result.valid,
+        errors: result.errorStrings
+    };
+}
+/**
+ * Generate a schema file name from an endpoint URL
+ * Example: "GET /api/users/{id}" => "GET-api-users-id"
+ */
+function generateSchemaFileName(method, url) {
+    // Extract path from URL (remove protocol, host, query string)
+    let urlPath = url;
+    try {
+        const parsed = new URL(url);
+        urlPath = parsed.pathname;
+    }
+    catch {
+        // URL might be a relative path, try to extract just the path part
+        const queryIndex = url.indexOf('?');
+        if (queryIndex > -1) {
+            urlPath = url.substring(0, queryIndex);
+        }
+    }
+    // Clean up the path
+    const cleanPath = urlPath
+        .replace(/^\/+|\/+$/g, '') // Remove leading/trailing slashes
+        .replace(/\{[^}]+\}/g, 'param') // {id} => param
+        .replace(/[^a-zA-Z0-9-]/g, '-') // Replace non-alphanumeric with dash
+        .replace(/-+/g, '-') // Collapse multiple dashes
+        .replace(/^-|-$/g, ''); // Remove leading/trailing dashes
+    return `${method.toUpperCase()}-${cleanPath || 'root'}.schema.json`;
+}
+/**
+ * Save a schema to a file
+ * @param schema The JSON Schema object
+ * @param filePath Absolute path to save the schema
+ */
+function saveSchema(schema, filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(schema, null, 2), 'utf-8');
+}
+//# sourceMappingURL=schemaGenerator.js.map