@unispechq/unispec-core 0.3.2 → 0.3.4

package/dist/cjs/src/validator/ajv-validator.js

@@ -1,82 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValidator = getValidator;
-exports.clearValidatorCache = clearValidatorCache;
-const _2020_js_1 = __importDefault(require("ajv/dist/2020.js"));
-const generated_schemas_1 = require("../generated-schemas.js");
-let cached = null;
-/**
- * Load default schemas from generated schemas.
- */
-async function loadDefaultSchemas() {
-    // Always use generated schemas - they work in all environments
-    return {
-        unispec: generated_schemas_1.GENERATED_SCHEMAS.unispec,
-        unispecTests: generated_schemas_1.GENERATED_SCHEMAS.unispecTests,
-        unispecConfig: generated_schemas_1.GENERATED_SCHEMAS.unispecConfig,
-        subschemas: generated_schemas_1.GENERATED_SCHEMAS.subschemas,
-    };
-}
-/**
- * Create AJV instance with custom formats and options.
- */
-function createAjv(options) {
-    const ajv = new _2020_js_1.default({
-        allErrors: true,
-        strict: false, // Disabled to support discriminator keyword in new schema
-        ...(options.ajvOptions ?? {}),
-    });
-    // Add format validators
-    ajv.addFormat("uri", true);
-    ajv.addFormat("email", {
-        type: "string",
-        validate: (data) => {
-            // Basic email validation regex
-            const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-            return typeof data === "string" && emailRegex.test(data);
-        },
-    });
-    return ajv;
-}
-/**
- * Get compiled AJV validators for different document types.
- */
-async function getValidator(options = {}) {
-    if (cached &&
-        !options.schemas &&
-        !options.schemaProvider &&
-        !options.ajvOptions)
-        return cached;
-    const schemas = options.schemas ?? (await loadDefaultSchemas());
-    const ajv = createAjv(options);
-    if (schemas.subschemas?.length) {
-        ajv.addSchema(schemas.subschemas);
-    }
-    const validateUniSpecFn = ajv.compile(schemas.unispec);
-    let validateUniSpecTestsFn;
-    if (schemas.unispecTests) {
-        validateUniSpecTestsFn = ajv.compile(schemas.unispecTests);
-    }
-    let validateUniSpecConfigFn;
-    if (schemas.unispecConfig) {
-        validateUniSpecConfigFn = ajv.compile(schemas.unispecConfig);
-    }
-    const result = {
-        validateUniSpecFn,
-        validateUniSpecTestsFn,
-        validateUniSpecConfigFn,
-    };
-    if (!options.schemas && !options.schemaProvider && !options.ajvOptions) {
-        cached = result;
-    }
-    return result;
-}
-/**
- * Clear cached validators (useful for testing or when schemas change).
- */
-function clearValidatorCache() {
-    cached = null;
-}

package/dist/cjs/src/validator/config-validator-main.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUniSpecConfig = validateUniSpecConfig;
-const errors_1 = require("../errors/index.js");
-const ajv_validator_1 = require("./ajv-validator.js");
-const config_validator_1 = require("./config-validator.js");
-const validator_factory_1 = require("./validator-factory.js");
-/**
- * Validate a UniSpec Config document against the UniSpec Config JSON Schema.
- *
- * @param doc - The UniSpec Config document to validate
- * @param options - Validation options including custom schemas
- * @returns Validation result with success status and error details
- */
-async function validateUniSpecConfig(doc, options = {}) {
-    // Handle null input
-    if (doc === null || doc === undefined) {
-        const error = errors_1.ErrorFactory.fromError(new Error("Config validation error: input must be an object"), "validation_error");
-        return {
-            valid: false,
-            errors: [error.toJSON()],
-        };
-    }
-    // Use factory for the rest of validation
-    const factoryValidator = (0, validator_factory_1.createValidator)("unispecConfig", async (options) => {
-        // If custom schemas are provided but unispecConfig is missing, return undefined
-        if (options.schemas && !options.schemas.unispecConfig) {
-            return undefined; // Will trigger schema missing error
-        }
-        const { validateUniSpecConfigFn } = await (0, ajv_validator_1.getValidator)(options);
-        return validateUniSpecConfigFn;
-    }, config_validator_1.validateConfigCustomRules);
-    return await factoryValidator(doc, options);
-}

package/dist/cjs/src/validator/config-validator.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateConfigCustomRules = validateConfigCustomRules;
-const errors_1 = require("../errors/index.js");
-/**
- * Custom validation for UniSpec Config documents.
- */
-function validateConfigCustomRules(doc) {
-    const customErrors = [];
-    // Check for empty services array
-    if (doc.services &&
-        Array.isArray(doc.services) &&
-        doc.services.length === 0) {
-        customErrors.push(errors_1.ErrorFactory.createConfigError("services array must contain at least one service", "/services", { code: "minItems" }).toJSON());
-    }
-    return customErrors;
-}

package/dist/cjs/src/validator/index.js

@@ -1,23 +0,0 @@
-"use strict";
-// Export all validation functions and types
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapAjvErrors = exports.createValidator = exports.validateUniSpec = exports.validateUniSpecTests = exports.validateSemantic = exports.validateReferences = exports.validateUniSpecConfig = exports.getValidator = exports.clearValidatorCache = void 0;
-// Export AJV utilities
-var ajv_validator_1 = require("./ajv-validator.js");
-Object.defineProperty(exports, "clearValidatorCache", { enumerable: true, get: function () { return ajv_validator_1.clearValidatorCache; } });
-Object.defineProperty(exports, "getValidator", { enumerable: true, get: function () { return ajv_validator_1.getValidator; } });
-var config_validator_main_1 = require("./config-validator-main.js");
-Object.defineProperty(exports, "validateUniSpecConfig", { enumerable: true, get: function () { return config_validator_main_1.validateUniSpecConfig; } });
-var reference_validator_1 = require("./reference-validator.js");
-Object.defineProperty(exports, "validateReferences", { enumerable: true, get: function () { return reference_validator_1.validateReferences; } });
-// Re-export semantic and reference validators
-var semantic_validator_1 = require("./semantic-validator.js");
-Object.defineProperty(exports, "validateSemantic", { enumerable: true, get: function () { return semantic_validator_1.validateSemantic; } });
-var tests_validator_1 = require("./tests-validator.js");
-Object.defineProperty(exports, "validateUniSpecTests", { enumerable: true, get: function () { return tests_validator_1.validateUniSpecTests; } });
-var unispec_validator_1 = require("./unispec-validator.js");
-Object.defineProperty(exports, "validateUniSpec", { enumerable: true, get: function () { return unispec_validator_1.validateUniSpec; } });
-// Export validator factory for advanced usage
-var validator_factory_1 = require("./validator-factory.js");
-Object.defineProperty(exports, "createValidator", { enumerable: true, get: function () { return validator_factory_1.createValidator; } });
-Object.defineProperty(exports, "mapAjvErrors", { enumerable: true, get: function () { return validator_factory_1.mapAjvErrors; } });

package/dist/cjs/src/validator/object-traversal.js

@@ -1,112 +0,0 @@
-"use strict";
-/**
- * Utility functions for traversing and manipulating objects.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseObject = traverseObject;
-exports.extractValues = extractValues;
-exports.findPaths = findPaths;
-exports.extractStrings = extractStrings;
-exports.extractReferences = extractReferences;
-exports.analyzeObjectStructure = analyzeObjectStructure;
-/**
- * Traverse an object recursively and call a callback for each value.
- */
-function traverseObject(obj, callback, options = {}, context = {}) {
-    const { maxDepth = 100, includeArrays = true, pathSeparator = "." } = options;
-    const currentDepth = context.depth || 0;
-    const currentPath = context.path || "";
-    // Check depth limit
-    if (currentDepth > maxDepth) {
-        return;
-    }
-    // Call callback for current value
-    callback(obj, {
-        path: currentPath,
-        depth: currentDepth,
-        parent: context.parent,
-        key: context.key,
-    });
-    // Handle arrays
-    if (Array.isArray(obj) && includeArrays) {
-        obj.forEach((item, index) => {
-            traverseObject(item, callback, options, {
-                path: currentPath ? `${currentPath}[${index}]` : `[${index}]`,
-                depth: currentDepth + 1,
-                parent: obj,
-                key: index.toString(),
-            });
-        });
-        return;
-    }
-    // Handle objects
-    if (obj && typeof obj === "object") {
-        Object.entries(obj).forEach(([key, value]) => {
-            const newPath = currentPath
-                ? `${currentPath}${pathSeparator}${key}`
-                : key;
-            traverseObject(value, callback, options, {
-                path: newPath,
-                depth: currentDepth + 1,
-                parent: obj,
-                key,
-            });
-        });
-    }
-}
-/**
- * Extract all values matching a predicate from an object.
- */
-function extractValues(obj, predicate, options) {
-    const results = [];
-    traverseObject(obj, (value, context) => {
-        if (predicate(value, context)) {
-            results.push({ value, context });
-        }
-    }, options);
-    return results;
-}
-/**
- * Find all paths to values matching a predicate.
- */
-function findPaths(obj, predicate, options) {
-    const paths = [];
-    traverseObject(obj, (value, context) => {
-        if (predicate(value, context)) {
-            paths.push(context.path);
-        }
-    }, options);
-    return paths;
-}
-/**
- * Extract all string values from an object.
- */
-function extractStrings(obj, options) {
-    return extractValues(obj, (value) => typeof value === "string", options);
-}
-/**
- * Extract all object references (schemaRef, $ref) from an object.
- */
-function extractReferences(obj, refKeys = ["schemaRef", "$ref"], options) {
-    return extractValues(obj, (value, context) => {
-        return refKeys.includes(context.key || "") && typeof value === "string";
-    }, options);
-}
-/**
- * Count keys and depth in an object for security validation.
- */
-function analyzeObjectStructure(obj, options = {}) {
-    let keyCount = 0;
-    let maxDepth = 0;
-    const paths = [];
-    traverseObject(obj, (_value, context) => {
-        if (context.key) {
-            keyCount++;
-        }
-        maxDepth = Math.max(maxDepth, context.depth);
-        if (context.path) {
-            paths.push(context.path);
-        }
-    }, options);
-    return { keyCount, maxDepth, paths };
-}

package/dist/cjs/src/validator/reference-validator.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateReferences = validateReferences;
-const object_traversal_1 = require("./object-traversal.js");
-/**
- * Extract all schema references from a UniSpec document.
- */
-function extractSchemaReferences(doc) {
-    const references = new Map();
-    const schemaRefs = (0, object_traversal_1.extractReferences)(doc, ["schemaRef", "$ref"]);
-    for (const { value, context } of schemaRefs) {
-        const schemaName = normalizeSchemaRef(value);
-        if (schemaName) {
-            const existing = references.get(schemaName) || [];
-            existing.push(context.path);
-            references.set(schemaName, existing);
-        }
-    }
-    return references;
-}
-/**
- * Extract all security scheme references from a UniSpec document.
- */
-function extractSecuritySchemeReferences(doc) {
-    const references = new Map();
-    const securityRefs = extractValues(doc, (value, context) => {
-        return context.key === "security" && Array.isArray(value);
-    });
-    for (const { value: securityArray, context } of securityRefs) {
-        if (!Array.isArray(securityArray))
-            continue;
-        securityArray.forEach((securityRequirement, index) => {
-            if (Array.isArray(securityRequirement)) {
-                securityRequirement.forEach((schemeName) => {
-                    if (typeof schemeName === "string") {
-                        const existing = references.get(schemeName) || [];
-                        existing.push(`${context.path}[${index}]`);
-                        references.set(schemeName, existing);
-                    }
-                });
-            }
-        });
-    }
-    return references;
-}
-/**
- * Extract values using object traversal utility.
- */
-function extractValues(obj, predicate) {
-    const results = [];
-    function traverse(current, path, depth) {
-        if (depth > 100)
-            return; // Prevent infinite recursion
-        if (predicate(current, { path, depth, key: path.split(".").pop() })) {
-            results.push({
-                value: current,
-                context: { path, depth, key: path.split(".").pop() },
-            });
-        }
-        if (Array.isArray(current)) {
-            current.forEach((item, index) => {
-                traverse(item, `${path}[${index}]`, depth + 1);
-            });
-        }
-        else if (current && typeof current === "object") {
-            Object.entries(current).forEach(([key, value]) => {
-                traverse(value, path ? `${path}.${key}` : key, depth + 1);
-            });
-        }
-    }
-    traverse(obj, "", 0);
-    return results;
-}
-/**
- * Normalize schema reference to extract the schema name.
- */
-function normalizeSchemaRef(ref) {
-    const trimmed = ref.trim();
-    if (trimmed.length === 0)
-        return null;
-    // Handle JSON Pointer format: #/service/schemas/SchemaName
-    if (trimmed.startsWith("#/service/schemas/")) {
-        const parts = trimmed.split("/");
-        return parts[parts.length - 1];
-    }
-    // Handle simple name format: SchemaName
-    if (!trimmed.startsWith("#") && !trimmed.includes("/")) {
-        return trimmed;
-    }
-    // Handle hash format: #SchemaName
-    if (trimmed.startsWith("#")) {
-        const withoutHash = trimmed.slice(1);
-        const parts = withoutHash.split("/").filter(Boolean);
-        return parts.length > 0 ? parts[parts.length - 1] : withoutHash;
-    }
-    return null;
-}
-/**
- * Validate schema references.
- */
-function validateSchemaReferences(doc, options, referenceMap) {
-    const errors = [];
-    if (!options.checkSchemaReferences)
-        return errors;
-    const schemaReferences = extractSchemaReferences(doc);
-    const availableSchemas = new Set(Object.keys(doc.service?.schemas || {}));
-    for (const [schemaName, locations] of schemaReferences.entries()) {
-        const exists = availableSchemas.has(schemaName);
-        // Store reference info
-        for (const location of locations) {
-            referenceMap.set(location, {
-                type: "schema",
-                source: location,
-                target: schemaName,
-                exists,
-            });
-        }
-        if (!exists) {
-            errors.push({
-                message: `Schema '${schemaName}' is referenced but not defined`,
-                path: locations[0], // First occurrence
-                code: "undefined_schema",
-            });
-        }
-    }
-    return errors;
-}
-/**
- * Validate security scheme references.
- */
-function validateSecuritySchemeReferences(doc, options, referenceMap) {
-    const errors = [];
-    if (!options.checkSecuritySchemeReferences)
-        return errors;
-    const securityReferences = extractSecuritySchemeReferences(doc);
-    const availableSchemes = new Set(Object.keys(doc.service?.securitySchemes || {}));
-    for (const [schemeName, locations] of securityReferences.entries()) {
-        const exists = availableSchemes.has(schemeName);
-        // Store reference info
-        for (const location of locations) {
-            referenceMap.set(location, {
-                type: "securityScheme",
-                source: location,
-                target: schemeName,
-                exists,
-            });
-        }
-        if (!exists) {
-            errors.push({
-                message: `Security scheme '${schemeName}' is referenced but not defined`,
-                path: locations[0], // First occurrence
-                code: "undefined_security_scheme",
-            });
-        }
-    }
-    return errors;
-}
-/**
- * Check for unused schemas and security schemes.
- */
-function validateUnusedReferences(doc, options, referenceMap) {
-    const warnings = [];
-    if (!options.strictMode)
-        return warnings;
-    // Find all referenced schemas
-    const referencedSchemas = new Set();
-    const referencedSecuritySchemes = new Set();
-    for (const info of referenceMap.values()) {
-        if (info.type === "schema" && info.exists) {
-            referencedSchemas.add(info.target);
-        }
-        else if (info.type === "securityScheme" && info.exists) {
-            referencedSecuritySchemes.add(info.target);
-        }
-    }
-    // Check for unused schemas
-    const allSchemas = Object.keys(doc.service?.schemas || {});
-    for (const schemaName of allSchemas) {
-        if (!referencedSchemas.has(schemaName)) {
-            warnings.push({
-                message: `Schema '${schemaName}' is defined but never referenced`,
-                path: `/service/schemas/${schemaName}`,
-                code: "unused_schema",
-            });
-        }
-    }
-    // Check for unused security schemes
-    const allSecuritySchemes = Object.keys(doc.service?.securitySchemes || {});
-    for (const schemeName of allSecuritySchemes) {
-        if (!referencedSecuritySchemes.has(schemeName)) {
-            warnings.push({
-                message: `Security scheme '${schemeName}' is defined but never referenced`,
-                path: `/service/securitySchemes/${schemeName}`,
-                code: "unused_security_scheme",
-            });
-        }
-    }
-    return warnings;
-}
-/**
- * Perform comprehensive reference validation on a UniSpec document.
- *
- * This function validates:
- * - Schema references (schemaRef, $ref)
- * - Security scheme references
- * - Unused definitions (in strict mode)
- *
- * @param doc - The UniSpec document to validate
- * @param options - Validation options
- * @returns Reference validation result with detailed reference map
- */
-function validateReferences(doc, options = {}) {
-    const errors = [];
-    const warnings = [];
-    const referenceMap = new Map();
-    // Default options
-    const opts = {
-        checkSchemaReferences: true,
-        checkSecuritySchemeReferences: true,
-        strictMode: false,
-        ...options,
-    };
-    // Validate all reference types
-    errors.push(...validateSchemaReferences(doc, opts, referenceMap));
-    errors.push(...validateSecuritySchemeReferences(doc, opts, referenceMap));
-    warnings.push(...validateUnusedReferences(doc, opts, referenceMap));
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-        referenceMap,
-    };
-}

package/dist/cjs/src/validator/schema-references.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSchemaReferences = extractSchemaReferences;
-exports.findOrphanedSchemas = findOrphanedSchemas;
-exports.validateSchemaReferences = validateSchemaReferences;
-function extractSchemaReferences(doc) {
-    const references = [];
-    function extractFromPath(obj, path) {
-        if (!obj || typeof obj !== "object")
-            return;
-        for (const [key, value] of Object.entries(obj)) {
-            const currentPath = path ? `${path}.${key}` : key;
-            if (key === "schemaRef" && typeof value === "string") {
-                references.push({
-                    path: currentPath,
-                    schemaName: normalizeSchemaRef(value),
-                    context: getContextFromPath(currentPath),
-                });
-            }
-            else if (typeof value === "object" && value !== null) {
-                extractFromPath(value, currentPath);
-            }
-        }
-    }
-    extractFromPath(doc, "");
-    return references;
-}
-function normalizeSchemaRef(ref) {
-    const trimmed = ref.trim();
-    if (trimmed.length === 0)
-        return "";
-    if (trimmed.startsWith("#/service/schemas/")) {
-        const parts = trimmed.split("/");
-        return parts[parts.length - 1];
-    }
-    const withoutHash = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
-    const parts = withoutHash.split("/").filter(Boolean);
-    return parts.length > 0 ? parts[parts.length - 1] : withoutHash;
-}
-function getContextFromPath(path) {
-    if (path.includes("routes"))
-        return "REST route";
-    if (path.includes("queries"))
-        return "GraphQL query";
-    if (path.includes("mutations"))
-        return "GraphQL mutation";
-    if (path.includes("subscriptions"))
-        return "GraphQL subscription";
-    if (path.includes("channels"))
-        return "WebSocket channel";
-    if (path.includes("messages"))
-        return "WebSocket message";
-    if (path.includes("pathParams"))
-        return "REST path parameter";
-    if (path.includes("queryParams"))
-        return "REST query parameter";
-    if (path.includes("headers"))
-        return "Header parameter";
-    if (path.includes("requestBody"))
-        return "Request body";
-    if (path.includes("responses"))
-        return "Response body";
-    return "Unknown context";
-}
-function findOrphanedSchemas(doc) {
-    const references = extractSchemaReferences(doc);
-    const referencedSchemas = new Set(references.map((ref) => ref.schemaName).filter(Boolean));
-    const allSchemas = new Set(Object.keys(doc.service?.schemas || {}));
-    const orphaned = Array.from(allSchemas).filter((schema) => !referencedSchemas.has(schema));
-    return orphaned;
-}
-function validateSchemaReferences(doc) {
-    const errors = [];
-    const references = extractSchemaReferences(doc);
-    const allSchemas = new Set(Object.keys(doc.service?.schemas || {}));
-    const valid = [];
-    const invalid = [];
-    for (const ref of references) {
-        if (allSchemas.has(ref.schemaName)) {
-            valid.push(ref);
-        }
-        else {
-            invalid.push(ref);
-            errors.push({
-                message: `Schema reference "${ref.schemaName}" not found at ${ref.path}`,
-                path: ref.path,
-                code: "schema_not_found",
-            });
-        }
-    }
-    const orphaned = findOrphanedSchemas(doc);
-    for (const orphan of orphaned) {
-        errors.push({
-            message: `Schema "${orphan}" is defined but never referenced`,
-            path: `/service/schemas/${orphan}`,
-            code: "orphaned_schema",
-        });
-    }
-    const isValid = errors.length === 0;
-    return {
-        valid: isValid,
-        errors,
-        references: {
-            valid,
-            invalid,
-            orphaned,
-            circular: [],
-        },
-        statistics: {
-            totalSchemas: allSchemas.size,
-            totalReferences: references.length,
-            orphanedSchemas: orphaned.length,
-            circularDependencies: 0,
-        },
-    };
-}