@unispechq/unispec-core 0.3.0 → 0.3.2

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

@@ -0,0 +1,27 @@
+"use strict";
+// Export types
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./change-reports.js"), exports);
+// Export core functionality
+__exportStar(require("./core.js"), exports);
+// Export enhanced functionality
+__exportStar(require("./enhanced-diff.js"), exports);
+__exportStar(require("./impact-strategies-refactored.js"), exports);
+__exportStar(require("./metrics-calculator.js"), exports);
+__exportStar(require("./risk-calculator.js"), exports);
+__exportStar(require("./suggestion-generator.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/cjs/src/diff/metrics-calculator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCalculatorService = void 0;
+/**
+ * Service for calculating compatibility metrics from enhanced changes.
+ */
+class MetricsCalculatorService {
+    /**
+     * Calculate compatibility metrics from enhanced changes.
+     */
+    calculateMetrics(changes) {
+        const breakingChanges = this.filterBreakingChanges(changes);
+        const nonBreakingChanges = this.filterNonBreakingChanges(changes);
+        const totalChanges = changes.length;
+        const breakingScore = this.calculateBreakingScore(breakingChanges.length, totalChanges);
+        const overallCompatibility = Math.max(0, 100 - breakingScore);
+        const clientScore = this.calculateClientCompatibilityScore(changes);
+        const serverScore = this.calculateServerCompatibilityScore(changes);
+        const migrationEffort = this.determineMigrationEffort(breakingChanges, nonBreakingChanges);
+        return {
+            overallCompatibility: Math.round(overallCompatibility),
+            breakingChangesCount: breakingChanges.length,
+            nonBreakingChangesCount: nonBreakingChanges.length,
+            clientCompatibilityScore: Math.round(clientScore),
+            serverCompatibilityScore: Math.round(serverScore),
+            migrationEffort,
+        };
+    }
+    filterBreakingChanges(changes) {
+        return changes.filter((c) => c.impact.backwardCompatibility === "incompatible");
+    }
+    filterNonBreakingChanges(changes) {
+        return changes.filter((c) => c.impact.backwardCompatibility === "compatible");
+    }
+    calculateBreakingScore(breakingCount, totalChanges) {
+        return totalChanges > 0 ? (breakingCount / totalChanges) * 100 : 0;
+    }
+    calculateClientCompatibilityScore(changes) {
+        const totalChanges = changes.length;
+        if (totalChanges === 0)
+            return 100;
+        const highClientImpact = changes.filter((c) => c.impact.clientImpact === "high").length;
+        const mediumClientImpact = changes.filter((c) => c.impact.clientImpact === "medium").length;
+        return (100 - (highClientImpact * 50 + mediumClientImpact * 25) / totalChanges);
+    }
+    calculateServerCompatibilityScore(changes) {
+        const totalChanges = changes.length;
+        if (totalChanges === 0)
+            return 100;
+        const highServerImpact = changes.filter((c) => c.impact.serverImpact === "high").length;
+        const mediumServerImpact = changes.filter((c) => c.impact.serverImpact === "medium").length;
+        return (100 - (highServerImpact * 30 + mediumServerImpact * 15) / totalChanges);
+    }
+    determineMigrationEffort(breakingChanges, _nonBreakingChanges) {
+        const complexMigrations = breakingChanges.filter((c) => c.impact.migrationComplexity === "complex").length;
+        const moderateMigrations = breakingChanges.filter((c) => c.impact.migrationComplexity === "moderate").length;
+        if (complexMigrations > 0) {
+            return "major";
+        }
+        else if (moderateMigrations > 2) {
+            return "significant";
+        }
+        else if (moderateMigrations > 0 || breakingChanges.length > 3) {
+            return "moderate";
+        }
+        return "minimal";
+    }
+}
+exports.MetricsCalculatorService = MetricsCalculatorService;

package/dist/cjs/src/diff/risk-calculator.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskLevelCalculator = void 0;
+/**
+ * Calculator for determining risk levels based on change impact.
+ */
+exports.RiskLevelCalculator = {
+    /**
+     * Calculate risk level based on impact.
+     */
+    calculate(impact) {
+        // Critical: Breaking changes with high client impact
+        if (impact.backwardCompatibility === "incompatible" &&
+            impact.clientImpact === "high") {
+            return "critical";
+        }
+        // High: Any breaking change
+        if (impact.backwardCompatibility === "incompatible") {
+            return "high";
+        }
+        // Medium: Medium impact on client or server
+        if (impact.clientImpact === "medium" || impact.serverImpact === "medium") {
+            return "medium";
+        }
+        // Low: Everything else
+        return "low";
+    },
+    /**
+     * Get risk level weight for sorting.
+     */
+    getWeight(riskLevel) {
+        const weights = {
+            critical: 4,
+            high: 3,
+            medium: 2,
+            low: 1,
+        };
+        return weights[riskLevel];
+    },
+    /**
+     * Check if risk level requires immediate attention.
+     */
+    requiresImmediateAttention(riskLevel) {
+        return riskLevel === "critical" || riskLevel === "high";
+    },
+    /**
+     * Get risk level description.
+     */
+    getDescription(riskLevel) {
+        const descriptions = {
+            critical: "Critical breaking change requiring immediate action",
+            high: "Breaking change that requires attention",
+            medium: "Moderate change with some impact",
+            low: "Minor change with minimal impact",
+        };
+        return descriptions[riskLevel];
+    },
+};

package/dist/cjs/src/diff/suggestion-generator.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuggestionGeneratorService = void 0;
+/**
+ * Service for generating migration suggestions based on change impact.
+ */
+class SuggestionGeneratorService {
+    /**
+     * Generate migration suggestions based on change impact.
+     */
+    generateSuggestions(change, impact) {
+        const suggestions = [];
+        this.addBreakingChangeSuggestions(suggestions, change, impact);
+        this.addClientImpactSuggestions(suggestions, impact);
+        this.addServerImpactSuggestions(suggestions, impact);
+        this.addMigrationComplexitySuggestions(suggestions, impact);
+        return suggestions;
+    }
+    addBreakingChangeSuggestions(suggestions, change, impact) {
+        if (impact.backwardCompatibility !== "incompatible")
+            return;
+        suggestions.push("This is a breaking change that requires client updates");
+        if (change.protocol === "rest") {
+            this.addRestBreakingSuggestions(suggestions, change);
+        }
+        else if (change.protocol === "graphql") {
+            this.addGraphQLBreakingSuggestions(suggestions, change);
+        }
+        else if (change.protocol === "websocket") {
+            this.addWebSocketBreakingSuggestions(suggestions, change);
+        }
+    }
+    addRestBreakingSuggestions(suggestions, change) {
+        if (change.kind?.includes("route.removed")) {
+            suggestions.push("Consider deprecating the route before removal");
+            suggestions.push("Provide alternative endpoint if functionality is still needed");
+        }
+        if (change.path.includes("/path")) {
+            suggestions.push("Maintain backward compatibility by supporting old path");
+            suggestions.push("Document migration path for clients");
+        }
+    }
+    addGraphQLBreakingSuggestions(suggestions, change) {
+        if (change.kind?.includes("operation.removed")) {
+            suggestions.push("Mark operation as @deprecated before removal");
+            suggestions.push("Provide alternative query/mutation if possible");
+        }
+        if (change.path.includes("/returnType")) {
+            suggestions.push("Consider adding new field instead of changing return type");
+            suggestions.push("Use union types for multiple possible return types");
+        }
+    }
+    addWebSocketBreakingSuggestions(suggestions, change) {
+        if (change.kind?.includes("channel.removed")) {
+            suggestions.push("Notify clients before closing channel");
+            suggestions.push("Provide grace period for migration");
+        }
+    }
+    addClientImpactSuggestions(suggestions, impact) {
+        if (impact.clientImpact === "high") {
+            suggestions.push("Client code changes are required");
+            suggestions.push("Update client documentation");
+        }
+    }
+    addServerImpactSuggestions(suggestions, impact) {
+        if (impact.serverImpact === "medium" || impact.serverImpact === "high") {
+            suggestions.push("Server implementation changes required");
+            suggestions.push("Update server-side documentation");
+        }
+    }
+    addMigrationComplexitySuggestions(suggestions, impact) {
+        if (impact.migrationComplexity === "complex") {
+            suggestions.push("Plan migration in phases");
+            suggestions.push("Consider feature flags for gradual rollout");
+        }
+    }
+}
+exports.SuggestionGeneratorService = SuggestionGeneratorService;

package/dist/cjs/src/diff/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NAMED_COLLECTION_PATHS = void 0;
+// Default named collection paths for UniSpec
+exports.DEFAULT_NAMED_COLLECTION_PATHS = [
+    "/service/protocols/rest/routes",
+    "/service/protocols/websocket/channels",
+    "/service/protocols/graphql/queries",
+    "/service/protocols/graphql/mutations",
+    "/service/protocols/graphql/subscriptions",
+];

package/dist/cjs/src/errors/base-error.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Base validation error class for UniSpec validation.
+ * Provides better error context and handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecValidationError = void 0;
+class UniSpecValidationError extends Error {
+    constructor(message, code, path = "", severity = "error", details) {
+        super(message);
+        this.name = "UniSpecValidationError";
+        this.code = code;
+        this.path = path;
+        this.severity = severity;
+        this.details = details;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, UniSpecValidationError);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            path: this.path,
+            severity: this.severity,
+            details: this.details,
+            stack: this.stack,
+        };
+    }
+}
+exports.UniSpecValidationError = UniSpecValidationError;

package/dist/cjs/src/errors/config-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecConfigError = void 0;
+const base_error_1 = require("./base-error.js");
+class UniSpecConfigError extends base_error_1.UniSpecValidationError {
+    constructor(message, path = "", details) {
+        super(message, "config_error", path, "error", details);
+        this.name = "UniSpecConfigError";
+    }
+}
+exports.UniSpecConfigError = UniSpecConfigError;

package/dist/cjs/src/errors/error-factory.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorFactory = void 0;
+const base_error_1 = require("./base-error.js");
+const config_error_1 = require("./config-error.js");
+const loader_error_1 = require("./loader-error.js");
+const reference_error_1 = require("./reference-error.js");
+const schema_error_1 = require("./schema-error.js");
+const security_error_1 = require("./security-error.js");
+const semantic_error_1 = require("./semantic-error.js");
+/**
+ * Error factory for creating specific error types.
+ */
+exports.ErrorFactory = {
+    createSchemaError(message, path, details) {
+        return new schema_error_1.UniSpecSchemaError(message, path, details);
+    },
+    createSemanticError(message, path, details) {
+        return new semantic_error_1.UniSpecSemanticError(message, path, details);
+    },
+    createReferenceError(message, path, details) {
+        return new reference_error_1.UniSpecReferenceError(message, path, details);
+    },
+    createConfigError(message, path, details) {
+        return new config_error_1.UniSpecConfigError(message, path, details);
+    },
+    createSecurityError(message, path, details) {
+        return new security_error_1.UniSpecSecurityError(message, path, details);
+    },
+    createLoaderError(message, path, details) {
+        return new loader_error_1.UniSpecLoaderError(message, path, details);
+    },
+    /**
+     * Convert generic error to UniSpecValidationError
+     */
+    fromError(error, defaultCode = "validation_error") {
+        if (error instanceof base_error_1.UniSpecValidationError) {
+            return error;
+        }
+        if (error instanceof Error) {
+            return new base_error_1.UniSpecValidationError(error.message, defaultCode, "", "error", { originalError: error.name, stack: error.stack });
+        }
+        if (typeof error === "string") {
+            return new base_error_1.UniSpecValidationError(error, defaultCode);
+        }
+        return new base_error_1.UniSpecValidationError(`Unknown validation error: ${String(error)}`, defaultCode, "", "error", { originalError: error });
+    },
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecSemanticError = exports.UniSpecSecurityError = exports.UniSpecSchemaError = exports.UniSpecReferenceError = exports.UniSpecLoaderError = exports.ErrorFactory = exports.UniSpecConfigError = exports.UniSpecValidationError = void 0;
+var base_error_1 = require("./base-error.js");
+Object.defineProperty(exports, "UniSpecValidationError", { enumerable: true, get: function () { return base_error_1.UniSpecValidationError; } });
+var config_error_1 = require("./config-error.js");
+Object.defineProperty(exports, "UniSpecConfigError", { enumerable: true, get: function () { return config_error_1.UniSpecConfigError; } });
+var error_factory_1 = require("./error-factory.js");
+Object.defineProperty(exports, "ErrorFactory", { enumerable: true, get: function () { return error_factory_1.ErrorFactory; } });
+var loader_error_1 = require("./loader-error.js");
+Object.defineProperty(exports, "UniSpecLoaderError", { enumerable: true, get: function () { return loader_error_1.UniSpecLoaderError; } });
+var reference_error_1 = require("./reference-error.js");
+Object.defineProperty(exports, "UniSpecReferenceError", { enumerable: true, get: function () { return reference_error_1.UniSpecReferenceError; } });
+var schema_error_1 = require("./schema-error.js");
+Object.defineProperty(exports, "UniSpecSchemaError", { enumerable: true, get: function () { return schema_error_1.UniSpecSchemaError; } });
+var security_error_1 = require("./security-error.js");
+Object.defineProperty(exports, "UniSpecSecurityError", { enumerable: true, get: function () { return security_error_1.UniSpecSecurityError; } });
+var semantic_error_1 = require("./semantic-error.js");
+Object.defineProperty(exports, "UniSpecSemanticError", { enumerable: true, get: function () { return semantic_error_1.UniSpecSemanticError; } });

package/dist/cjs/src/errors/loader-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecLoaderError = void 0;
+const base_error_1 = require("./base-error.js");
+class UniSpecLoaderError extends base_error_1.UniSpecValidationError {
+    constructor(message, path = "", details) {
+        super(message, "loader_error", path, "error", details);
+        this.name = "UniSpecLoaderError";
+    }
+}
+exports.UniSpecLoaderError = UniSpecLoaderError;

package/dist/cjs/src/errors/reference-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecReferenceError = void 0;
+const base_error_1 = require("./base-error.js");
+class UniSpecReferenceError extends base_error_1.UniSpecValidationError {
+    constructor(message, path = "", details) {
+        super(message, "reference_error", path, "error", details);
+        this.name = "UniSpecReferenceError";
+    }
+}
+exports.UniSpecReferenceError = UniSpecReferenceError;

package/dist/cjs/src/errors/schema-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecSchemaError = void 0;
+const base_error_1 = require("./base-error.js");
+class UniSpecSchemaError extends base_error_1.UniSpecValidationError {
+    constructor(message, path = "", details) {
+        super(message, "schema_error", path, "error", details);
+        this.name = "UniSpecSchemaError";
+    }
+}
+exports.UniSpecSchemaError = UniSpecSchemaError;

package/dist/cjs/src/errors/security-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecSecurityError = void 0;
+const base_error_1 = require("./base-error.js");
+class UniSpecSecurityError extends base_error_1.UniSpecValidationError {
+    constructor(message, path = "", details) {
+        super(message, "security_error", path, "error", details);
+        this.name = "UniSpecSecurityError";
+    }
+}
+exports.UniSpecSecurityError = UniSpecSecurityError;

package/dist/cjs/src/errors/semantic-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniSpecSemanticError = void 0;
+const base_error_1 = require("./base-error.js");
+class UniSpecSemanticError extends base_error_1.UniSpecValidationError {
+    constructor(message, path = "", details) {
+        super(message, "semantic_error", path, "error", details);
+        this.name = "UniSpecSemanticError";
+    }
+}
+exports.UniSpecSemanticError = UniSpecSemanticError;