@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/cjs/tests/diff/diff.test.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const utils_1 = require("../../tests/utils.js");
+const core_1 = require("../../src/diff/core.js");
+(0, node_test_1.describe)("diff module", () => {
+    (0, node_test_1.describe)("diffUniSpec", () => {
+        (0, node_test_1.it)("should detect no changes in identical documents", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should detect added fields", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Add a new field that doesn't exist
+            modifiedDoc.service.contact = {
+                name: "API Support",
+                email: "support@example.com",
+            };
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const contactChange = result.changes.find((change) => change.path === "/service/contact");
+            node_assert_1.default.ok(contactChange);
+            node_assert_1.default.strictEqual(contactChange.description, "Field added");
+            node_assert_1.default.strictEqual(contactChange.severity, "unknown");
+        });
+        (0, node_test_1.it)("should detect removed fields", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Remove a field
+            delete modifiedDoc.service.description;
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const descriptionChange = result.changes.find((change) => change.path === "/service/description");
+            node_assert_1.default.ok(descriptionChange);
+            node_assert_1.default.strictEqual(descriptionChange.description, "Field removed");
+            node_assert_1.default.strictEqual(descriptionChange.severity, "unknown");
+        });
+        (0, node_test_1.it)("should detect changed values", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Change a value
+            modifiedDoc.service.description = "Updated description";
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const descriptionChange = result.changes.find((change) => change.path === "/service/description");
+            node_assert_1.default.ok(descriptionChange);
+            node_assert_1.default.strictEqual(descriptionChange.description, "Value changed");
+            node_assert_1.default.strictEqual(descriptionChange.severity, "unknown");
+        });
+    });
+    (0, node_test_1.describe)("named collections handling", () => {
+        (0, node_test_1.it)("should detect added routes by name", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Add a new route
+            modifiedDoc.service.protocols.rest.routes.push({
+                name: "updateUser",
+                summary: "Update user",
+                path: "/users/{id}",
+                method: "PUT",
+                responses: {
+                    200: {
+                        description: "User updated successfully",
+                    },
+                },
+            });
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const routeChange = result.changes.find((change) => change.path === "/service/protocols/rest/routes/updateUser");
+            node_assert_1.default.ok(routeChange);
+            node_assert_1.default.strictEqual(routeChange.description, "Item added");
+            node_assert_1.default.strictEqual(routeChange.severity, "non-breaking");
+            node_assert_1.default.strictEqual(routeChange.protocol, "rest");
+            node_assert_1.default.strictEqual(routeChange.kind, "rest.route.added");
+        });
+        (0, node_test_1.it)("should detect removed routes by name", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Remove a route
+            modifiedDoc.service.protocols.rest.routes =
+                modifiedDoc.service.protocols.rest.routes.filter((route) => route.name !== "createUser");
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const routeChange = result.changes.find((change) => change.path === "/service/protocols/rest/routes/createUser");
+            node_assert_1.default.ok(routeChange);
+            node_assert_1.default.strictEqual(routeChange.description, "Item removed");
+            node_assert_1.default.strictEqual(routeChange.severity, "breaking");
+            node_assert_1.default.strictEqual(routeChange.protocol, "rest");
+            node_assert_1.default.strictEqual(routeChange.kind, "rest.route.removed");
+        });
+    });
+    (0, node_test_1.describe)("GraphQL protocol handling", () => {
+        (0, node_test_1.it)("should detect added queries", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "graphql-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Add a new query
+            modifiedDoc.service.protocols.graphql.queries.push({
+                name: "posts",
+                description: "Get all posts",
+                args: [],
+                returnType: "[Post!]!",
+            });
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const queryChange = result.changes.find((change) => change.path === "/service/protocols/graphql/queries/posts");
+            node_assert_1.default.ok(queryChange);
+            node_assert_1.default.strictEqual(queryChange.description, "Item added");
+            node_assert_1.default.strictEqual(queryChange.protocol, "graphql");
+        });
+        (0, node_test_1.it)("should detect removed mutations", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "graphql-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Remove a mutation
+            modifiedDoc.service.protocols.graphql.mutations = [];
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const mutationChange = result.changes.find((change) => change.path === "/service/protocols/graphql/mutations/createPost");
+            node_assert_1.default.ok(mutationChange);
+            node_assert_1.default.strictEqual(mutationChange.description, "Item removed");
+            node_assert_1.default.strictEqual(mutationChange.protocol, "graphql");
+        });
+    });
+    (0, node_test_1.describe)("WebSocket protocol handling", () => {
+        (0, node_test_1.it)("should detect added channels", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "websocket-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Add a new channel
+            modifiedDoc.service.protocols.websocket.channels.push({
+                name: "notifications",
+                description: "Real-time notifications",
+                messages: [
+                    {
+                        name: "notification",
+                        description: "Notification message",
+                        direction: "subscribe",
+                    },
+                ],
+            });
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const channelChange = result.changes.find((change) => change.path === "/service/protocols/websocket/channels/notifications");
+            node_assert_1.default.ok(channelChange);
+            node_assert_1.default.strictEqual(channelChange.description, "Item added");
+            node_assert_1.default.strictEqual(channelChange.protocol, "websocket");
+        });
+    });
+    (0, node_test_1.describe)("deep comparison options", () => {
+        (0, node_test_1.it)("should respect deepComparison: false option", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Change nested value in a named collection (route)
+            modifiedDoc.service.protocols.rest.routes[0].summary = "Updated summary";
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc, {
+                deepComparison: false,
+            });
+            // With deepComparison: false, named collections don't do deep comparison
+            // Since the route name stays the same, no changes are detected
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should perform deep comparison by default", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Change nested value
+            modifiedDoc.service.protocols.rest.routes[0].summary = "Updated summary";
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            // With deep comparison, the specific field should be marked as changed
+            const summaryChange = result.changes.find((change) => change.path === "/service/protocols/rest/routes/getUsers/summary");
+            node_assert_1.default.ok(summaryChange);
+            node_assert_1.default.strictEqual(summaryChange.description, "Value changed");
+        });
+    });
+    (0, node_test_1.describe)("custom named collection paths", () => {
+        (0, node_test_1.it)("should respect custom namedCollectionPaths", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Add custom data to test
+            modifiedDoc.service.customItems = [
+                { name: "item1", value: "value1" },
+                { name: "item2", value: "value2" },
+            ];
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc, {
+                namedCollectionPaths: ["/service/customItems"],
+            });
+            // Should detect the customItems field as added
+            const customItemsChange = result.changes.find((change) => change.path === "/service/customItems");
+            node_assert_1.default.ok(customItemsChange);
+            node_assert_1.default.strictEqual(customItemsChange.description, "Field added");
+        });
+    });
+});

package/dist/cjs/tests/diff/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadExample = exports.getExamplePath = exports.examplesDir = exports.createTestChange = void 0;
+const utils_1 = require("../../tests/utils.js");
+Object.defineProperty(exports, "createTestChange", { enumerable: true, get: function () { return utils_1.createTestChange; } });
+Object.defineProperty(exports, "examplesDir", { enumerable: true, get: function () { return utils_1.examplesDir; } });
+Object.defineProperty(exports, "getExamplePath", { enumerable: true, get: function () { return utils_1.getExamplePath; } });
+Object.defineProperty(exports, "loadExample", { enumerable: true, get: function () { return utils_1.loadExample; } });

package/dist/cjs/tests/errors/errors-integration.test.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const errors_1 = require("../../src/errors/index.js");
+const validator_1 = require("../../src/validator/index.js");
+const utils_1 = require("./utils.js");
+(0, node_test_1.describe)("errors module integration", () => {
+    (0, node_test_1.describe)("with validator module", () => {
+        (0, node_test_1.it)("should handle validation errors from valid specs", async () => {
+            const validDoc = (0, utils_1.loadExample)((0, utils_1.getExamplePath)("valid", "spec", "rest-simple.json"));
+            const result = await (0, validator_1.validateUniSpec)(validDoc);
+            node_assert_1.default.ok(result.valid);
+            node_assert_1.default.strictEqual(result.errors.length, 0);
+        });
+        (0, node_test_1.it)("should create appropriate errors for invalid specs", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "missing-service-name.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            node_assert_1.default.ok(result.errors.length > 0);
+            // Check that errors have proper structure
+            for (const error of result.errors) {
+                node_assert_1.default.ok(error.message);
+                node_assert_1.default.ok(error.code);
+                node_assert_1.default.ok(error.path);
+            }
+        });
+        (0, node_test_1.it)("should handle schema validation errors", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "missing-unispec-version.json"));
+            const _result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            // Note: This document might be considered valid without unispecVersion
+            // Let's test with a document that actually has schema errors
+            const invalidDoc2 = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "missing-service-name.json"));
+            const result2 = await (0, validator_1.validateUniSpec)(invalidDoc2);
+            node_assert_1.default.ok(!result2.valid);
+            // Should have schema errors
+            const schemaErrors = result2.errors.filter((e) => e.code === "schema_error");
+            node_assert_1.default.ok(schemaErrors.length > 0);
+            // Verify error structure
+            const schemaError = schemaErrors[0];
+            node_assert_1.default.strictEqual(schemaError.code, "schema_error");
+            node_assert_1.default.ok(schemaError.path);
+            node_assert_1.default.ok(schemaError.message);
+        });
+        (0, node_test_1.it)("should handle semantic validation errors", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "invalid-rest-method.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            // Should have schema errors (invalid REST method is caught by schema validation)
+            const schemaErrors = result.errors.filter((e) => e.code === "schema_error");
+            node_assert_1.default.ok(schemaErrors.length > 0);
+            // Verify error structure
+            const schemaError = schemaErrors[0];
+            node_assert_1.default.strictEqual(schemaError.code, "schema_error");
+            node_assert_1.default.ok(schemaError.path?.includes("method"));
+            node_assert_1.default.ok(schemaError.message);
+        });
+        (0, node_test_1.it)("should handle config validation errors", async () => {
+            const invalidConfig = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "config", "missing-version.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidConfig);
+            node_assert_1.default.ok(!result.valid);
+            // Should have schema errors for config validation
+            const configErrors = result.errors.filter((e) => e.code === "schema_error");
+            node_assert_1.default.ok(configErrors.length > 0);
+            // Verify error structure
+            const configError = configErrors[0];
+            node_assert_1.default.strictEqual(configError.code, "schema_error");
+            node_assert_1.default.ok(configError.path);
+            node_assert_1.default.ok(configError.message);
+        });
+    });
+    (0, node_test_1.describe)("error conversion and handling", () => {
+        (0, node_test_1.it)("should convert AJV errors to UniSpecValidationErrors", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "missing-service-name.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            // All errors should be ValidationError type
+            for (const error of result.errors) {
+                node_assert_1.default.ok(error.message);
+                node_assert_1.default.ok(error.code);
+            }
+        });
+        (0, node_test_1.it)("should handle error factory with validation context", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "invalid-identifier.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            // Create custom error based on validation result
+            if (result.errors.length > 0) {
+                const customError = errors_1.ErrorFactory.createSemanticError("Custom semantic error based on validation", result.errors[0].path || "", { originalErrors: result.errors.map((e) => e.message) });
+                node_assert_1.default.ok(customError instanceof Error);
+                node_assert_1.default.strictEqual(customError.code, "semantic_error");
+                node_assert_1.default.ok(customError.details?.originalErrors);
+            }
+        });
+        (0, node_test_1.it)("should preserve error details through validation chain", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "graphql-missing-arg-type.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            // Find GraphQL-related errors
+            const graphqlErrors = result.errors.filter((e) => e.path?.includes("graphql") ||
+                e.message.toLowerCase().includes("graphql"));
+            if (graphqlErrors.length > 0) {
+                const error = graphqlErrors[0];
+                // Error should have proper structure
+                node_assert_1.default.ok(error.message);
+                node_assert_1.default.ok(error.code);
+                node_assert_1.default.ok(error.path);
+            }
+        });
+    });
+    (0, node_test_1.describe)("error severity levels", () => {
+        (0, node_test_1.it)("should handle different severity levels in validation", async () => {
+            // Test with a document that might have different severity levels
+            const validDoc = (0, utils_1.loadExample)((0, utils_1.getExamplePath)("valid", "spec", "mixed-complete.json"));
+            const result = await (0, validator_1.validateUniSpec)(validDoc);
+            // Valid document should have no errors
+            if (result.errors.length > 0) {
+                // All errors should have proper structure
+                for (const error of result.errors) {
+                    node_assert_1.default.ok(error.message);
+                    node_assert_1.default.ok(error.code);
+                    node_assert_1.default.ok(typeof error.path === "string");
+                }
+            }
+        });
+        (0, node_test_1.it)("should properly classify error types", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "missing-service-name.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            // Check that errors are properly classified
+            const errorCodes = result.errors.map((e) => e.code);
+            const expectedCodes = [
+                "schema_error",
+                "semantic_error",
+                "reference_error",
+            ];
+            // At least one of the expected error codes should be present
+            const hasExpectedCode = expectedCodes.some((code) => errorCodes.includes(code));
+            node_assert_1.default.ok(hasExpectedCode, `Expected one of ${expectedCodes}, got ${errorCodes}`);
+        });
+    });
+    (0, node_test_1.describe)("complex error scenarios", () => {
+        (0, node_test_1.it)("should handle multiple errors in single document", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "missing-service-name.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            // Should potentially have multiple errors
+            if (result.errors.length > 1) {
+                // Check that each error has unique path or code
+                const uniquePaths = new Set(result.errors.map((e) => e.path));
+                const uniqueCodes = new Set(result.errors.map((e) => e.code));
+                // Should have some diversity in errors
+                node_assert_1.default.ok(uniquePaths.size > 0 || uniqueCodes.size > 0);
+            }
+        });
+        (0, node_test_1.it)("should handle nested error paths", async () => {
+            const invalidDoc = (0, utils_1.loadInvalidExample)((0, utils_1.getExamplePath)("invalid", "spec", "invalid-rest-method.json"));
+            const result = await (0, validator_1.validateUniSpec)(invalidDoc);
+            node_assert_1.default.ok(!result.valid);
+            // Should have errors with nested paths
+            const nestedErrors = result.errors.filter((e) => e.path?.includes("/"));
+            node_assert_1.default.ok(nestedErrors.length > 0);
+            // Paths should be properly formatted
+            for (const error of nestedErrors) {
+                node_assert_1.default.ok(error.path?.includes("/service/"));
+                node_assert_1.default.ok(!error.path?.endsWith("."));
+            }
+        });
+    });
+});