norn-cli 1.6.1 → 1.6.2

package/out/schemaGenerator.js

@@ -1,393 +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.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 });
-/**
- * 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) {
-    const 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`;
-            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}"`;
-            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
-    };
-}
-/**
- * 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;
-}
-/**
- * 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)) {
-            return {
-                valid: false,
-                errors: [{
-                        instancePath: '(root)',
-                        schemaPath: '',
-                        keyword: 'file',
-                        message: `Schema file not found: ${schemaPath}`,
-                        params: { path: schemaPath },
-                        severity: 'error'
-                    }],
-                errorStrings: [`Schema file not found: ${schemaPath}`],
-                resolvedSchemaPath: resolvedPath
-            };
-        }
-        // Load and parse schema
-        const schemaContent = fs.readFileSync(resolvedPath, 'utf-8');
-        let schema;
-        try {
-            schema = JSON.parse(schemaContent);
-        }
-        catch (e) {
-            return {
-                valid: false,
-                errors: [{
-                        instancePath: '(root)',
-                        schemaPath: '',
-                        keyword: 'parse',
-                        message: `Invalid JSON in schema file: ${schemaPath}`,
-                        params: { path: schemaPath },
-                        severity: 'error'
-                    }],
-                errorStrings: [`Invalid JSON in schema file: ${schemaPath}`],
-                resolvedSchemaPath: resolvedPath
-            };
-        }
-        // 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
-            };
-        }
-        return {
-            valid: true,
-            resolvedSchemaPath: resolvedPath,
-            schema
-        };
-    }
-    catch (e) {
-        const error = e instanceof Error ? e.message : String(e);
-        return {
-            valid: false,
-            errors: [{
-                    instancePath: '(root)',
-                    schemaPath: '',
-                    keyword: 'exception',
-                    message: `Schema validation error: ${error}`,
-                    params: {},
-                    severity: 'error'
-                }],
-            errorStrings: [`Schema validation error: ${error}`]
-        };
-    }
-}
-/**
- * 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