@unispechq/unispec-core 0.3.2 → 0.3.3

package/dist/validator/index.d.ts

@@ -1,10 +0,0 @@
-export { clearValidatorCache, getValidator } from "./ajv-validator.js";
-export { validateUniSpecConfig } from "./config-validator-main.js";
-export type { ReferenceValidationOptions, ReferenceValidationResult, } from "./reference-validator.js";
-export { validateReferences } from "./reference-validator.js";
-export type { SemanticValidationOptions, SemanticValidationResult, } from "./semantic-validator.js";
-export { validateSemantic } from "./semantic-validator.js";
-export { validateUniSpecTests } from "./tests-validator.js";
-export type { Ajv2020, AjvValidateFn, ExtendedValidationResult, SchemaProvider, ValidateOptions, ValidatorSchemas, } from "./types.js";
-export { validateUniSpec } from "./unispec-validator.js";
-export { createValidator, mapAjvErrors } from "./validator-factory.js";

package/dist/validator/index.js

@@ -1,11 +0,0 @@
-// Export all validation functions and types
-// Export AJV utilities
-export { clearValidatorCache, getValidator } from "./ajv-validator.js";
-export { validateUniSpecConfig } from "./config-validator-main.js";
-export { validateReferences } from "./reference-validator.js";
-// Re-export semantic and reference validators
-export { validateSemantic } from "./semantic-validator.js";
-export { validateUniSpecTests } from "./tests-validator.js";
-export { validateUniSpec } from "./unispec-validator.js";
-// Export validator factory for advanced usage
-export { createValidator, mapAjvErrors } from "./validator-factory.js";

package/dist/validator/object-traversal.d.ts

@@ -1,52 +0,0 @@
-/**
- * Utility functions for traversing and manipulating objects.
- */
-export interface TraversalOptions {
-    maxDepth?: number;
-    includeArrays?: boolean;
-    pathSeparator?: string;
-}
-export interface TraversalContext {
-    path: string;
-    depth: number;
-    parent?: unknown;
-    key?: string;
-}
-export type TraversalCallback = (value: unknown, context: TraversalContext) => void;
-/**
- * Traverse an object recursively and call a callback for each value.
- */
-export declare function traverseObject(obj: unknown, callback: TraversalCallback, options?: TraversalOptions, context?: Partial<TraversalContext>): void;
-/**
- * Extract all values matching a predicate from an object.
- */
-export declare function extractValues(obj: unknown, predicate: (value: unknown, context: TraversalContext) => boolean, options?: TraversalOptions): Array<{
-    value: unknown;
-    context: TraversalContext;
-}>;
-/**
- * Find all paths to values matching a predicate.
- */
-export declare function findPaths(obj: unknown, predicate: (value: unknown, context: TraversalContext) => boolean, options?: TraversalOptions): string[];
-/**
- * Extract all string values from an object.
- */
-export declare function extractStrings(obj: unknown, options?: TraversalOptions): Array<{
-    value: string;
-    context: TraversalContext;
-}>;
-/**
- * Extract all object references (schemaRef, $ref) from an object.
- */
-export declare function extractReferences(obj: unknown, refKeys?: string[], options?: TraversalOptions): Array<{
-    value: string;
-    context: TraversalContext;
-}>;
-/**
- * Count keys and depth in an object for security validation.
- */
-export declare function analyzeObjectStructure(obj: unknown, options?: TraversalOptions): {
-    keyCount: number;
-    maxDepth: number;
-    paths: string[];
-};

package/dist/validator/object-traversal.js

@@ -1,104 +0,0 @@
-/**
- * Utility functions for traversing and manipulating objects.
- */
-/**
- * Traverse an object recursively and call a callback for each value.
- */
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export function extractStrings(obj, options) {
-    return extractValues(obj, (value) => typeof value === "string", options);
-}
-/**
- * Extract all object references (schemaRef, $ref) from an object.
- */
-export 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.
- */
-export 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/validator/reference-validator.d.ts

@@ -1,31 +0,0 @@
-import type { UniSpecDocument, ValidationError } from "../types/index.js";
-export interface ReferenceValidationOptions {
-    checkSchemaReferences?: boolean;
-    checkSecuritySchemeReferences?: boolean;
-    strictMode?: boolean;
-}
-export interface ReferenceValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationError[];
-    referenceMap: Map<string, ReferenceInfo>;
-}
-export interface ReferenceInfo {
-    type: "schema" | "securityScheme";
-    source: string;
-    target: string;
-    exists: boolean;
-}
-/**
- * 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
- */
-export declare function validateReferences(doc: UniSpecDocument, options?: ReferenceValidationOptions): ReferenceValidationResult;

package/dist/validator/reference-validator.js

@@ -1,230 +0,0 @@
-import { extractReferences } from "./object-traversal.js";
-/**
- * Extract all schema references from a UniSpec document.
- */
-function extractSchemaReferences(doc) {
-    const references = new Map();
-    const schemaRefs = 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
- */
-export 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/validator/schema-references.d.ts

@@ -1,23 +0,0 @@
-import type { UniSpecDocument, ValidationResult } from "../types/index.js";
-export interface SchemaReference {
-    path: string;
-    schemaName: string;
-    context: string;
-}
-export interface SchemaValidationResult extends ValidationResult {
-    references: {
-        valid: SchemaReference[];
-        invalid: SchemaReference[];
-        orphaned: string[];
-        circular: string[][];
-    };
-    statistics: {
-        totalSchemas: number;
-        totalReferences: number;
-        orphanedSchemas: number;
-        circularDependencies: number;
-    };
-}
-export declare function extractSchemaReferences(doc: UniSpecDocument): SchemaReference[];
-export declare function findOrphanedSchemas(doc: UniSpecDocument): string[];
-export declare function validateSchemaReferences(doc: UniSpecDocument): SchemaValidationResult;

package/dist/validator/schema-references.js

@@ -1,111 +0,0 @@
-export 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";
-}
-export 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;
-}
-export 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,
-        },
-    };
-}

package/dist/validator/semantic-validator.d.ts

@@ -1,26 +0,0 @@
-import type { UniSpecDocument, ValidationError } from "../types/index.js";
-export interface SemanticValidationOptions {
-    strictNaming?: boolean;
-    checkUrlPatterns?: boolean;
-    checkNameConflicts?: boolean;
-    checkCircularDependencies?: boolean;
-}
-export interface SemanticValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationError[];
-}
-/**
- * Perform semantic validation on a UniSpec document.
- *
- * This function goes beyond JSON Schema validation to check:
- * - Naming conventions
- * - URL patterns
- * - Name conflicts
- * - Circular dependencies
- *
- * @param doc - The UniSpec document to validate
- * @param options - Validation options
- * @returns Semantic validation result
- */
-export declare function validateSemantic(doc: UniSpecDocument, options?: SemanticValidationOptions): SemanticValidationResult;