norn-cli 2.4.0 → 2.5.0

package/out/schemaGenerator.js

@@ -1,562 +0,0 @@
-"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