@unispechq/unispec-core 0.3.2 → 0.3.3

package/dist/cjs/validator/semantic-validator.js

@@ -1,328 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSemantic = validateSemantic;
-/**
- * Validate naming conventions across the UniSpec document.
- */
-function validateNamingConventions(doc, options) {
-    const errors = [];
-    if (!options.strictNaming)
-        return errors;
-    // Validate service name
-    if (doc.service.name) {
-        if (!/^[a-z][a-z0-9-]*$/.test(doc.service.name)) {
-            errors.push({
-                message: "Service name should use kebab-case starting with lowercase letter",
-                path: "/service/name",
-                code: "naming_convention",
-            });
-        }
-    }
-    // Validate REST route names
-    const restRoutes = doc.service?.protocols?.rest?.routes || [];
-    for (const route of restRoutes) {
-        if (route.name && !/^[a-z][a-zA-Z0-9]*$/.test(route.name)) {
-            errors.push({
-                message: "REST route name should use camelCase starting with lowercase letter",
-                path: `/service/protocols/rest/routes/${route.name}/name`,
-                code: "naming_convention",
-            });
-        }
-        // Validate path parameters naming
-        if (route.pathParams) {
-            for (const param of route.pathParams) {
-                if (param.name && !/^[a-z][a-zA-Z0-9]*$/.test(param.name)) {
-                    errors.push({
-                        message: "Path parameter name should use camelCase starting with lowercase letter",
-                        path: `/service/protocols/rest/routes/${route.name}/pathParams/${param.name}/name`,
-                        code: "naming_convention",
-                    });
-                }
-            }
-        }
-    }
-    // Validate GraphQL operation names
-    const graphql = doc.service?.protocols?.graphql;
-    if (graphql) {
-        const operations = [
-            ...(graphql.queries || []),
-            ...(graphql.mutations || []),
-            ...(graphql.subscriptions || []),
-        ];
-        for (const op of operations) {
-            if (op.name && !/^[A-Z][a-zA-Z]*$/.test(op.name)) {
-                errors.push({
-                    message: "GraphQL operation name should use PascalCase starting with uppercase letter",
-                    path: `/service/protocols/graphql/${op.name}/name`,
-                    code: "naming_convention",
-                });
-            }
-        }
-    }
-    // Validate WebSocket channel and message names
-    const websocket = doc.service?.protocols?.websocket;
-    if (websocket?.channels) {
-        for (const channel of websocket.channels) {
-            if (channel.name && !/^[a-z][a-zA-Z0-9]*$/.test(channel.name)) {
-                errors.push({
-                    message: "WebSocket channel name should use camelCase starting with lowercase letter",
-                    path: `/service/protocols/websocket/channels/${channel.name}/name`,
-                    code: "naming_convention",
-                });
-            }
-            if (channel.messages) {
-                for (const message of channel.messages) {
-                    if (message.name && !/^[a-z][a-zA-Z0-9]*$/.test(message.name)) {
-                        errors.push({
-                            message: "WebSocket message name should use camelCase starting with lowercase letter",
-                            path: `/service/protocols/websocket/channels/${channel.name}/messages/${message.name}/name`,
-                            code: "naming_convention",
-                        });
-                    }
-                }
-            }
-        }
-    }
-    return errors;
-}
-/**
- * Validate URL patterns and formats.
- */
-function validateUrlPatterns(doc, options) {
-    const errors = [];
-    if (!options.checkUrlPatterns)
-        return errors;
-    // Validate baseUrl
-    if (doc.service.baseUrl) {
-        try {
-            new URL(doc.service.baseUrl);
-            if (!doc.service.baseUrl.startsWith("http") &&
-                !doc.service.baseUrl.startsWith("https")) {
-                errors.push({
-                    message: "baseUrl should start with http:// or https://",
-                    path: "/service/baseUrl",
-                    code: "invalid_url",
-                });
-            }
-        }
-        catch {
-            errors.push({
-                message: "baseUrl is not a valid URL",
-                path: "/service/baseUrl",
-                code: "invalid_url",
-            });
-        }
-    }
-    // Validate REST route paths
-    const restRoutes = doc.service?.protocols?.rest?.routes || [];
-    for (const route of restRoutes) {
-        if (route.path) {
-            // Path should start with /
-            if (!route.path.startsWith("/")) {
-                errors.push({
-                    message: "REST route path should start with '/'",
-                    path: `/service/protocols/rest/routes/${route.name}/path`,
-                    code: "invalid_path",
-                });
-            }
-            // Check for path parameter consistency
-            const pathParamMatches = route.path.match(/:\w+/g) || [];
-            const declaredParams = route.pathParams?.map((p) => p.name) || [];
-            for (const param of pathParamMatches) {
-                const paramName = param.slice(1); // Remove ':'
-                if (!declaredParams.includes(paramName)) {
-                    errors.push({
-                        message: `Path parameter '${paramName}' is used in path but not declared in pathParams`,
-                        path: `/service/protocols/rest/routes/${route.name}/path`,
-                        code: "undeclared_parameter",
-                    });
-                }
-            }
-            // Check for declared parameters not used in path
-            for (const declaredParam of declaredParams) {
-                if (!pathParamMatches.some((match) => match.slice(1) === declaredParam)) {
-                    errors.push({
-                        message: `Path parameter '${declaredParam}' is declared but not used in path`,
-                        path: `/service/protocols/rest/routes/${route.name}/pathParams/${declaredParam}`,
-                        code: "unused_parameter",
-                    });
-                }
-            }
-        }
-    }
-    return errors;
-}
-/**
- * Check for name conflicts across different components.
- */
-function validateNameConflicts(doc, options) {
-    const errors = [];
-    if (!options.checkNameConflicts)
-        return errors;
-    const allNames = new Map();
-    // Collect REST route names
-    const restRoutes = doc.service?.protocols?.rest?.routes || [];
-    for (const route of restRoutes) {
-        if (route.name) {
-            const existing = allNames.get(route.name) || [];
-            existing.push(`REST route: ${route.path} ${route.method}`);
-            allNames.set(route.name, existing);
-        }
-    }
-    // Collect GraphQL operation names
-    const graphql = doc.service?.protocols?.graphql;
-    if (graphql) {
-        const operations = [
-            ...(graphql.queries || []),
-            ...(graphql.mutations || []),
-            ...(graphql.subscriptions || []),
-        ];
-        for (const op of operations) {
-            if (op.name) {
-                const existing = allNames.get(op.name) || [];
-                existing.push(`GraphQL operation`);
-                allNames.set(op.name, existing);
-            }
-        }
-    }
-    // Collect WebSocket channel names
-    const websocket = doc.service?.protocols?.websocket;
-    if (websocket?.channels) {
-        for (const channel of websocket.channels) {
-            if (channel.name) {
-                const existing = allNames.get(channel.name) || [];
-                existing.push(`WebSocket channel`);
-                allNames.set(channel.name, existing);
-            }
-        }
-    }
-    // Check for conflicts
-    for (const [name, locations] of allNames.entries()) {
-        if (locations.length > 1) {
-            errors.push({
-                message: `Name '${name}' is used in multiple locations: ${locations.join(", ")}`,
-                path: "",
-                code: "name_conflict",
-            });
-        }
-    }
-    return errors;
-}
-/**
- * Check for circular dependencies in schemas.
- */
-function validateCircularDependencies(doc, options) {
-    const errors = [];
-    if (!options.checkCircularDependencies)
-        return errors;
-    const schemas = doc.service?.schemas;
-    if (!schemas)
-        return errors;
-    // Build dependency graph
-    const dependencies = new Map();
-    for (const [schemaName, schema] of Object.entries(schemas)) {
-        const deps = new Set();
-        findSchemaReferences(schema.jsonSchema, deps);
-        dependencies.set(schemaName, deps);
-    }
-    // Check for circular dependencies
-    const visited = new Set();
-    const recursionStack = new Set();
-    function hasCycle(schemaName, path) {
-        if (recursionStack.has(schemaName)) {
-            const cycle = [...path.slice(path.indexOf(schemaName)), schemaName].join(" -> ");
-            errors.push({
-                message: `Circular dependency detected in schemas: ${cycle}`,
-                path: `/service/schemas/${schemaName}`,
-                code: "circular_dependency",
-            });
-            return true;
-        }
-        if (visited.has(schemaName))
-            return false;
-        visited.add(schemaName);
-        recursionStack.add(schemaName);
-        const deps = dependencies.get(schemaName) || new Set();
-        for (const dep of deps) {
-            if (hasCycle(dep, [...path, schemaName])) {
-                return true;
-            }
-        }
-        recursionStack.delete(schemaName);
-        return false;
-    }
-    for (const schemaName of Object.keys(schemas)) {
-        if (!visited.has(schemaName)) {
-            hasCycle(schemaName, []);
-        }
-    }
-    return errors;
-}
-/**
- * Find all schema references in a JSON Schema object.
- */
-function findSchemaReferences(schema, dependencies) {
-    if (!schema || typeof schema !== "object")
-        return;
-    const schemaRecord = schema;
-    // Check for $ref
-    if (schemaRecord.$ref && typeof schemaRecord.$ref === "string") {
-        const ref = schemaRecord.$ref;
-        if (ref.startsWith("#/service/schemas/")) {
-            const schemaName = ref.split("/").pop();
-            if (schemaName) {
-                dependencies.add(schemaName);
-            }
-        }
-    }
-    // Check for schemaRef
-    if (schemaRecord.schemaRef && typeof schemaRecord.schemaRef === "string") {
-        dependencies.add(schemaRecord.schemaRef);
-    }
-    // Recursively check all properties
-    for (const [_key, value] of Object.entries(schemaRecord)) {
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                findSchemaReferences(item, dependencies);
-            }
-        }
-        else if (typeof value === "object" && value !== null) {
-            findSchemaReferences(value, dependencies);
-        }
-    }
-}
-/**
- * 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
- */
-function validateSemantic(doc, options = {}) {
-    const errors = [];
-    const warnings = [];
-    // Default options
-    const opts = {
-        strictNaming: true,
-        checkUrlPatterns: true,
-        checkNameConflicts: true,
-        checkCircularDependencies: true,
-        ...options,
-    };
-    // Run all semantic validations
-    errors.push(...validateNamingConventions(doc, opts));
-    errors.push(...validateUrlPatterns(doc, opts));
-    errors.push(...validateNameConflicts(doc, opts));
-    errors.push(...validateCircularDependencies(doc, opts));
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-    };
-}

package/dist/cjs/validator/tests-validator.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUniSpecTests = void 0;
-const ajv_validator_1 = require("./ajv-validator.js");
-const validator_factory_1 = require("./validator-factory.js");
-/**
- * Validate a UniSpec Tests document against the UniSpec Tests JSON Schema.
- *
- * @param doc - The UniSpec Tests document to validate
- * @param options - Validation options including custom schemas
- * @returns Validation result with success status and error details
- */
-exports.validateUniSpecTests = (0, validator_factory_1.createValidator)("unispecTests", async (options) => {
-    const { validateUniSpecTestsFn } = await (0, ajv_validator_1.getValidator)(options);
-    return validateUniSpecTestsFn;
-});

package/dist/cjs/validator/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/validator/unispec-validator.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUniSpec = validateUniSpec;
-const errors_1 = require("../errors/index.js");
-const ajv_validator_1 = require("./ajv-validator.js");
-const reference_validator_1 = require("./reference-validator.js");
-const semantic_validator_1 = require("./semantic-validator.js");
-const validator_factory_1 = require("./validator-factory.js");
-/**
- * Validate a UniSpec document with optional extended validation.
- *
- * This function performs:
- * - JSON Schema validation (always)
- * - Semantic validation (optional, when enableExtendedValidation is true)
- * - Reference validation (optional, when enableExtendedValidation is true)
- *
- * @param doc - The UniSpec document to validate
- * @param options - Validation options
- * @returns Validation result with optional extended results
- */
-async function validateUniSpec(doc, options = {}) {
-    // Always perform basic JSON Schema validation
-    const basicResult = await validateUniSpecBase(doc, options);
-    // If extended validation is disabled, return basic result
-    if (!options.enableExtendedValidation) {
-        return basicResult;
-    }
-    // Perform extended validation
-    const result = {
-        valid: basicResult.valid,
-        errors: [...basicResult.errors],
-    };
-    // Perform semantic validation
-    if (options.semanticValidation) {
-        const semanticResult = (0, semantic_validator_1.validateSemantic)(doc, options.semanticValidation);
-        result.semantic = semanticResult;
-        if (!semanticResult.valid) {
-            result.valid = false;
-            result.errors.push(...semanticResult.errors);
-        }
-    }
-    // Perform reference validation
-    if (options.referenceValidation) {
-        const referenceResult = (0, reference_validator_1.validateReferences)(doc, options.referenceValidation);
-        result.references = referenceResult;
-        if (!referenceResult.valid) {
-            result.valid = false;
-            result.errors.push(...referenceResult.errors);
-        }
-    }
-    return result;
-}
-/**
- * Internal function for basic JSON Schema validation.
- */
-async function validateUniSpecBase(doc, options = {}) {
-    try {
-        const { validateUniSpecFn } = await (0, ajv_validator_1.getValidator)(options);
-        // Ensure the document has required fields for validation
-        const docForValidation = {
-            unispecVersion: doc.unispecVersion || "1.0.0",
-            service: doc.service,
-        };
-        const valid = validateUniSpecFn(docForValidation);
-        const schemaErrors = (0, validator_factory_1.mapAjvErrors)(validateUniSpecFn.errors);
-        if (valid) {
-            return {
-                valid: true,
-                errors: [],
-            };
-        }
-        return {
-            valid: false,
-            errors: schemaErrors,
-        };
-    }
-    catch (error) {
-        const validationError = errors_1.ErrorFactory.fromError(error, "validation_error");
-        return {
-            valid: false,
-            errors: [validationError.toJSON()],
-        };
-    }
-}

package/dist/cjs/validator/validator-factory.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createValidator = createValidator;
-exports.mapAjvErrors = mapAjvErrors;
-const errors_1 = require("../errors/index.js");
-/**
- * Generic validator factory to reduce code duplication.
- */
-function createValidator(documentType, getValidatorFn, customValidation) {
-    return async function validate(doc, options = {}) {
-        try {
-            const validateFn = await getValidatorFn(options);
-            if (!validateFn) {
-                return {
-                    valid: false,
-                    errors: [
-                        {
-                            message: `${documentType} validation schema is not available. Provide appropriate schema in ValidateOptions.`,
-                            path: "",
-                            code: "schema_missing",
-                        },
-                    ],
-                };
-            }
-            const valid = validateFn(doc);
-            // Run custom validation if provided
-            const customErrors = customValidation ? customValidation(doc) : [];
-            const schemaErrors = valid ? [] : mapAjvErrors(validateFn.errors);
-            const allErrors = [...schemaErrors, ...customErrors];
-            if (valid && customErrors.length === 0) {
-                return {
-                    valid: true,
-                    errors: [],
-                };
-            }
-            return {
-                valid: false,
-                errors: allErrors,
-            };
-        }
-        catch (error) {
-            const validationError = errors_1.ErrorFactory.fromError(error, `${documentType}_validation_error`);
-            return {
-                valid: false,
-                errors: [validationError.toJSON()],
-            };
-        }
-    };
-}
-/**
- * Map AJV errors to specific UniSpec validation errors.
- */
-function mapAjvErrors(errors) {
-    if (!errors)
-        return [];
-    return errors.map((error) => {
-        const message = error.message || "UniSpec validation error";
-        const path = error.instancePath || error.schemaPath;
-        const _code = error.keyword;
-        // Create specific error types based on keyword
-        switch (error.keyword) {
-            case "required":
-                return errors_1.ErrorFactory.createSchemaError(`Missing required property: ${message}`, path, { keyword: error.keyword, params: error.params });
-            case "type":
-                return errors_1.ErrorFactory.createSchemaError(`Invalid type: ${message}`, path, { keyword: error.keyword, params: error.params });
-            case "format":
-                return errors_1.ErrorFactory.createSchemaError(`Invalid format: ${message}`, path, { keyword: error.keyword, params: error.params });
-            case "additionalProperties":
-                return errors_1.ErrorFactory.createSchemaError(`Additional property not allowed: ${message}`, path, { keyword: error.keyword, params: error.params });
-            default:
-                return errors_1.ErrorFactory.createSchemaError(message, path, {
-                    keyword: error.keyword,
-                    params: error.params,
-                });
-        }
-    });
-}

package/dist/cjs/versions.js

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLatestUniSpecVersion = getLatestUniSpecVersion;
-exports.clearVersionCache = clearVersionCache;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const node_url_1 = require("node:url");
-let cachedUniSpecVersion = null;
-let cachedSchemaPackagePath = null;
-/**
- * Validate package.json content to ensure it's the correct @unispechq/unispec-schema package
- * @param content Package.json content as string
- * @returns Package info object if valid, null otherwise
- */
-function validatePackageJson(content) {
-    try {
-        const packageInfo = JSON.parse(content);
-        if (packageInfo.name === "@unispechq/unispec-schema" &&
-            packageInfo.version) {
-            return packageInfo;
-        }
-    }
-    catch {
-        // Invalid JSON
-    }
-    return null;
-}
-/**
- * Get current module directory (supports both ESM and CJS)
- * @returns Current directory path
- */
-function getCurrentDirectory() {
-    if (typeof __dirname !== "undefined") {
-        return __dirname;
-    }
-    // Try ESM import.meta.url
-    try {
-        if (typeof globalThis !== "undefined" &&
-            globalThis.import
-                ?.meta?.url) {
-            return (0, node_path_1.dirname)((0, node_url_1.fileURLToPath)(globalThis
-                .import.meta.url));
-        }
-    }
-    catch {
-        // Fallback to current working directory
-    }
-    return process.cwd();
-}
-/**
- * Find the package.json path for @unispechq/unispec-schema
- * Works in both ESM and CJS contexts with improved reliability
- * @returns Path to package.json file
- */
-function findSchemaPackagePath() {
-    // Return cached path if available
-    if (cachedSchemaPackagePath) {
-        return cachedSchemaPackagePath;
-    }
-    const currentDir = getCurrentDirectory();
-    // Define all possible paths to check
-    const candidatePaths = [
-        // Try direct package.json resolution first (most reliable for CJS)
-        () => {
-            if (typeof require !== "undefined") {
-                try {
-                    return require.resolve("@unispechq/unispec-schema/package.json");
-                }
-                catch {
-                    return null;
-                }
-            }
-            return null;
-        },
-        // Try require.resolve for main entry point
-        () => {
-            if (typeof require !== "undefined") {
-                try {
-                    const packageMainPath = require.resolve("@unispechq/unispec-schema");
-                    return (0, node_path_1.join)((0, node_path_1.dirname)(packageMainPath), "package.json");
-                }
-                catch {
-                    return null;
-                }
-            }
-            return null;
-        },
-        // Fallback paths
-        () => (0, node_path_1.join)(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "package.json"),
-        () => (0, node_path_1.join)(currentDir, "..", "node_modules", "@unispechq", "unispec-schema", "package.json"),
-        () => (0, node_path_1.join)(currentDir, "..", "..", "node_modules", "@unispechq", "unispec-schema", "package.json"),
-        () => (0, node_path_1.join)(currentDir, "..", "..", "..", "node_modules", "@unispechq", "unispec-schema", "package.json"),
-    ];
-    // Try each candidate path
-    for (const getPath of candidatePaths) {
-        try {
-            const path = getPath();
-            if (!path)
-                continue;
-            const content = (0, node_fs_1.readFileSync)(path, "utf-8");
-            const packageInfo = validatePackageJson(content);
-            if (packageInfo) {
-                cachedSchemaPackagePath = path;
-                return path;
-            }
-        }
-        catch {
-            // Continue to next path
-        }
-    }
-    throw new Error(`Could not find @unispechq/unispec-schema package.json. Searched in multiple node_modules locations.`);
-}
-/**
- * Get the latest supported UniSpec version from @unispechq/unispec-schema package
- * The version is derived from the package.json version (major.minor.0 format)
- * @returns The latest UniSpec format version (SemVer)
- */
-function getLatestUniSpecVersion() {
-    if (cachedUniSpecVersion) {
-        return cachedUniSpecVersion;
-    }
-    try {
-        // Find and read package.json from @unispechq/unispec-schema
-        const schemaPackagePath = findSchemaPackagePath();
-        const packageJson = (0, node_fs_1.readFileSync)(schemaPackagePath, "utf-8");
-        const packageInfo = JSON.parse(packageJson);
-        // Extract version and convert to major.minor.0 format
-        const version = packageInfo.version;
-        const [major, minor] = version.split(".");
-        // Create UniSpec version in major.minor.0 format
-        const unispecVersion = `${major}.${minor}.0`;
-        cachedUniSpecVersion = unispecVersion;
-        return unispecVersion;
-    }
-    catch {
-        // Fallback to default version if package.json is not available
-        cachedUniSpecVersion = "1.0.0";
-        return cachedUniSpecVersion;
-    }
-}
-/**
- * Clear the version cache (useful for testing or dynamic updates)
- */
-function clearVersionCache() {
-    cachedUniSpecVersion = null;
-    cachedSchemaPackagePath = null;
-}

package/dist/diff/annotators.d.ts

@@ -1,4 +0,0 @@
-import type { UniSpecChange } from "./types.js";
-export declare function annotateRestChange(change: UniSpecChange): UniSpecChange;
-export declare function annotateWebSocketChange(change: UniSpecChange): UniSpecChange;
-export declare function annotateGraphQLChange(change: UniSpecChange): UniSpecChange;