@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/tests/diff/diff-extended.test.js

@@ -0,0 +1,230 @@
+import assert from "node:assert";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { examplesDir, loadExample } from "../../tests/utils.js";
+import { diffUniSpec } from "../../src/diff/core.js";
+describe("diff module - extended tests", () => {
+    describe("handling of invalid examples", () => {
+        it("should handle empty services array without crashing", () => {
+            const invalidDoc = loadExample(path.join(examplesDir, "invalid", "config", "empty-services-array.json"));
+            // Should not crash when processing invalid documents
+            const result = diffUniSpec(invalidDoc, invalidDoc);
+            assert.strictEqual(result.changes.length, 0);
+        });
+        it("should handle missing service name", () => {
+            const invalidDoc = loadExample(path.join(examplesDir, "invalid", "config", "missing-service-name.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(invalidDoc));
+            // This is a config file, not a spec, so it has different structure
+            modifiedDoc.version = 2;
+            const result = diffUniSpec(invalidDoc, modifiedDoc);
+            assert.ok(result.changes.length > 0);
+            const versionChange = result.changes.find((change) => change.path === "/version");
+            assert.ok(versionChange);
+            assert.strictEqual(versionChange.description, "Value changed");
+        });
+        it("should handle missing version", () => {
+            const invalidDoc = loadExample(path.join(examplesDir, "invalid", "config", "missing-version.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(invalidDoc));
+            modifiedDoc.service = {
+                ...modifiedDoc.service,
+                description: "Added description",
+            };
+            const result = diffUniSpec(invalidDoc, modifiedDoc);
+            assert.ok(result.changes.length > 0);
+        });
+    });
+    describe("complex scenarios with valid examples", () => {
+        it("should handle mixed protocol changes", () => {
+            const baseDoc = loadExample(path.join(examplesDir, "valid", "spec", "mixed-complete.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Add REST route
+            modifiedDoc.service.protocols.rest.routes.push({
+                name: "newRoute",
+                summary: "New route",
+                path: "/new",
+                method: "GET",
+                responses: { 200: { description: "Success" } },
+            });
+            // Add GraphQL query
+            if (modifiedDoc.service.protocols.graphql) {
+                modifiedDoc.service.protocols.graphql.queries.push({
+                    name: "newQuery",
+                    description: "New query",
+                    args: [],
+                    returnType: "String",
+                });
+            }
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const restChange = result.changes.find((change) => change.path.includes("newRoute") && change.protocol === "rest");
+            assert.ok(restChange);
+            assert.strictEqual(restChange.severity, "non-breaking");
+            if (modifiedDoc.service.protocols.graphql) {
+                const graphqlChange = result.changes.find((change) => change.path.includes("newQuery") && change.protocol === "graphql");
+                assert.ok(graphqlChange);
+            }
+        });
+        it("should detect breaking changes in REST", () => {
+            const baseDoc = loadExample(path.join(examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Remove a route (breaking change)
+            modifiedDoc.service.protocols.rest.routes =
+                modifiedDoc.service.protocols.rest.routes.filter((route) => route.name !== "getUsers");
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const removedRoute = result.changes.find((change) => change.path === "/service/protocols/rest/routes/getUsers");
+            assert.ok(removedRoute);
+            assert.strictEqual(removedRoute.severity, "breaking");
+            assert.strictEqual(removedRoute.kind, "rest.route.removed");
+        });
+    });
+    describe("edge cases and boundary conditions", () => {
+        it("should handle null vs undefined values", () => {
+            const baseDoc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    description: undefined,
+                },
+            };
+            const modifiedDoc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    description: "A description",
+                },
+            };
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const descriptionChange = result.changes.find((change) => change.path === "/service/description");
+            assert.ok(descriptionChange);
+            assert.strictEqual(descriptionChange.description, "Value changed");
+        });
+        it("should handle empty objects and arrays", () => {
+            const baseDoc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    protocols: {
+                        rest: {
+                            routes: [],
+                        },
+                    },
+                },
+            };
+            const modifiedDoc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    protocols: {
+                        rest: {
+                            routes: [
+                                {
+                                    name: "newRoute",
+                                    method: "GET",
+                                    path: "/test",
+                                    responses: { 200: { description: "OK" } },
+                                },
+                            ],
+                        },
+                    },
+                },
+            };
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const routeChange = result.changes.find((change) => change.path === "/service/protocols/rest/routes/newRoute");
+            assert.ok(routeChange);
+            assert.strictEqual(routeChange.description, "Item added");
+            assert.strictEqual(routeChange.protocol, "rest");
+        });
+        it("should handle deeply nested structures", () => {
+            const baseDoc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    metadata: {
+                        tags: [{ name: "api", version: "1.0" }],
+                        info: {
+                            contact: {
+                                email: "test@example.com",
+                            },
+                        },
+                    },
+                },
+            };
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            modifiedDoc.service.metadata.tags[0].version = "2.0";
+            modifiedDoc.service.metadata.info.contact.phone = "+1234567890";
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const versionChange = result.changes.find((change) => change.path === "/service/metadata/tags/0/version");
+            assert.ok(versionChange);
+            assert.strictEqual(versionChange.description, "Value changed");
+            const phoneChange = result.changes.find((change) => change.path === "/service/metadata/info/contact/phone");
+            assert.ok(phoneChange);
+            assert.strictEqual(phoneChange.description, "Field added");
+        });
+    });
+    describe("array handling", () => {
+        it("should handle regular arrays (non-named collections)", () => {
+            const baseDoc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    tags: ["api", "v1"],
+                },
+            };
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            modifiedDoc.service.tags = ["api", "v2", "production"];
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            // Should detect changes at index level for regular arrays
+            const indexChange = result.changes.find((change) => change.path === "/service/tags/1");
+            assert.ok(indexChange);
+            assert.strictEqual(indexChange.description, "Value changed");
+            const addedChange = result.changes.find((change) => change.path === "/service/tags/2");
+            assert.ok(addedChange);
+            assert.strictEqual(addedChange.description, "Item added");
+        });
+        it("should handle arrays without name property", () => {
+            const baseDoc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    items: [
+                        { id: 1, value: "first" },
+                        { id: 2, value: "second" },
+                    ],
+                },
+            };
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            modifiedDoc.service.items[0].value = "updated";
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            // Should use index-based comparison for arrays without name property
+            const itemChange = result.changes.find((change) => change.path === "/service/items/0/value");
+            assert.ok(itemChange);
+            assert.strictEqual(itemChange.description, "Value changed");
+        });
+    });
+    describe("protocol-specific behavior", () => {
+        it("should handle WebSocket messages correctly", () => {
+            const baseDoc = loadExample(path.join(examplesDir, "valid", "spec", "websocket-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Add message to existing channel
+            if (modifiedDoc.service.protocols.websocket.channels[0]) {
+                modifiedDoc.service.protocols.websocket.channels[0].messages.push({
+                    name: "newMessage",
+                    description: "New message type",
+                    direction: "publish",
+                });
+            }
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const messageChange = result.changes.find((change) => change.path.includes("newMessage") && change.protocol === "websocket");
+            assert.ok(messageChange);
+        });
+        it("should handle GraphQL schema changes", () => {
+            const baseDoc = loadExample(path.join(examplesDir, "valid", "spec", "graphql-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Change schema string
+            modifiedDoc.service.protocols.graphql.schema = `${baseDoc.service.protocols?.graphql?.schema} type NewType { field: String! }`;
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const schemaChange = result.changes.find((change) => change.path === "/service/protocols/graphql/schema");
+            assert.ok(schemaChange);
+            assert.strictEqual(schemaChange.description, "Value changed");
+        });
+    });
+});

package/dist/tests/diff/diff.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,184 @@
+import assert from "node:assert";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { examplesDir, loadExample } from "../../tests/utils.js";
+import { diffUniSpec } from "../../src/diff/core.js";
+describe("diff module", () => {
+    describe("diffUniSpec", () => {
+        it("should detect no changes in identical documents", () => {
+            const doc = loadExample(path.join(examplesDir, "valid", "spec", "rest-simple.json"));
+            const result = diffUniSpec(doc, doc);
+            assert.strictEqual(result.changes.length, 0);
+        });
+        it("should detect added fields", () => {
+            const baseDoc = loadExample(path.join(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 = diffUniSpec(baseDoc, modifiedDoc);
+            const contactChange = result.changes.find((change) => change.path === "/service/contact");
+            assert.ok(contactChange);
+            assert.strictEqual(contactChange.description, "Field added");
+            assert.strictEqual(contactChange.severity, "unknown");
+        });
+        it("should detect removed fields", () => {
+            const baseDoc = loadExample(path.join(examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Remove a field
+            delete modifiedDoc.service.description;
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const descriptionChange = result.changes.find((change) => change.path === "/service/description");
+            assert.ok(descriptionChange);
+            assert.strictEqual(descriptionChange.description, "Field removed");
+            assert.strictEqual(descriptionChange.severity, "unknown");
+        });
+        it("should detect changed values", () => {
+            const baseDoc = loadExample(path.join(examplesDir, "valid", "spec", "rest-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Change a value
+            modifiedDoc.service.description = "Updated description";
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const descriptionChange = result.changes.find((change) => change.path === "/service/description");
+            assert.ok(descriptionChange);
+            assert.strictEqual(descriptionChange.description, "Value changed");
+            assert.strictEqual(descriptionChange.severity, "unknown");
+        });
+    });
+    describe("named collections handling", () => {
+        it("should detect added routes by name", () => {
+            const baseDoc = loadExample(path.join(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 = diffUniSpec(baseDoc, modifiedDoc);
+            const routeChange = result.changes.find((change) => change.path === "/service/protocols/rest/routes/updateUser");
+            assert.ok(routeChange);
+            assert.strictEqual(routeChange.description, "Item added");
+            assert.strictEqual(routeChange.severity, "non-breaking");
+            assert.strictEqual(routeChange.protocol, "rest");
+            assert.strictEqual(routeChange.kind, "rest.route.added");
+        });
+        it("should detect removed routes by name", () => {
+            const baseDoc = loadExample(path.join(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 = diffUniSpec(baseDoc, modifiedDoc);
+            const routeChange = result.changes.find((change) => change.path === "/service/protocols/rest/routes/createUser");
+            assert.ok(routeChange);
+            assert.strictEqual(routeChange.description, "Item removed");
+            assert.strictEqual(routeChange.severity, "breaking");
+            assert.strictEqual(routeChange.protocol, "rest");
+            assert.strictEqual(routeChange.kind, "rest.route.removed");
+        });
+    });
+    describe("GraphQL protocol handling", () => {
+        it("should detect added queries", () => {
+            const baseDoc = loadExample(path.join(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 = diffUniSpec(baseDoc, modifiedDoc);
+            const queryChange = result.changes.find((change) => change.path === "/service/protocols/graphql/queries/posts");
+            assert.ok(queryChange);
+            assert.strictEqual(queryChange.description, "Item added");
+            assert.strictEqual(queryChange.protocol, "graphql");
+        });
+        it("should detect removed mutations", () => {
+            const baseDoc = loadExample(path.join(examplesDir, "valid", "spec", "graphql-simple.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(baseDoc));
+            // Remove a mutation
+            modifiedDoc.service.protocols.graphql.mutations = [];
+            const result = diffUniSpec(baseDoc, modifiedDoc);
+            const mutationChange = result.changes.find((change) => change.path === "/service/protocols/graphql/mutations/createPost");
+            assert.ok(mutationChange);
+            assert.strictEqual(mutationChange.description, "Item removed");
+            assert.strictEqual(mutationChange.protocol, "graphql");
+        });
+    });
+    describe("WebSocket protocol handling", () => {
+        it("should detect added channels", () => {
+            const baseDoc = loadExample(path.join(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 = diffUniSpec(baseDoc, modifiedDoc);
+            const channelChange = result.changes.find((change) => change.path === "/service/protocols/websocket/channels/notifications");
+            assert.ok(channelChange);
+            assert.strictEqual(channelChange.description, "Item added");
+            assert.strictEqual(channelChange.protocol, "websocket");
+        });
+    });
+    describe("deep comparison options", () => {
+        it("should respect deepComparison: false option", () => {
+            const baseDoc = loadExample(path.join(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 = 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
+            assert.strictEqual(result.changes.length, 0);
+        });
+        it("should perform deep comparison by default", () => {
+            const baseDoc = loadExample(path.join(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 = 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");
+            assert.ok(summaryChange);
+            assert.strictEqual(summaryChange.description, "Value changed");
+        });
+    });
+    describe("custom named collection paths", () => {
+        it("should respect custom namedCollectionPaths", () => {
+            const baseDoc = loadExample(path.join(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 = diffUniSpec(baseDoc, modifiedDoc, {
+                namedCollectionPaths: ["/service/customItems"],
+            });
+            // Should detect the customItems field as added
+            const customItemsChange = result.changes.find((change) => change.path === "/service/customItems");
+            assert.ok(customItemsChange);
+            assert.strictEqual(customItemsChange.description, "Field added");
+        });
+    });
+});

package/dist/tests/diff/utils.d.ts

@@ -0,0 +1,2 @@
+import { createTestChange, examplesDir, getExamplePath, loadExample } from "../../tests/utils.js";
+export { createTestChange, examplesDir, getExamplePath, loadExample };

package/dist/tests/diff/utils.js

@@ -0,0 +1,3 @@
+import { createTestChange, examplesDir, getExamplePath, loadExample, } from "../../tests/utils.js";
+// Re-export commonly used functions from tests/utils
+export { createTestChange, examplesDir, getExamplePath, loadExample };

package/dist/tests/errors/errors-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,168 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { ErrorFactory } from "../../src/errors/index.js";
+import { validateUniSpec } from "../../src/validator/index.js";
+import { getExamplePath, loadExample, loadInvalidExample } from "./utils.js";
+describe("errors module integration", () => {
+    describe("with validator module", () => {
+        it("should handle validation errors from valid specs", async () => {
+            const validDoc = loadExample(getExamplePath("valid", "spec", "rest-simple.json"));
+            const result = await validateUniSpec(validDoc);
+            assert.ok(result.valid);
+            assert.strictEqual(result.errors.length, 0);
+        });
+        it("should create appropriate errors for invalid specs", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "missing-service-name.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.ok(!result.valid);
+            assert.ok(result.errors.length > 0);
+            // Check that errors have proper structure
+            for (const error of result.errors) {
+                assert.ok(error.message);
+                assert.ok(error.code);
+                assert.ok(error.path);
+            }
+        });
+        it("should handle schema validation errors", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "missing-unispec-version.json"));
+            const _result = await validateUniSpec(invalidDoc);
+            // Note: This document might be considered valid without unispecVersion
+            // Let's test with a document that actually has schema errors
+            const invalidDoc2 = loadInvalidExample(getExamplePath("invalid", "spec", "missing-service-name.json"));
+            const result2 = await validateUniSpec(invalidDoc2);
+            assert.ok(!result2.valid);
+            // Should have schema errors
+            const schemaErrors = result2.errors.filter((e) => e.code === "schema_error");
+            assert.ok(schemaErrors.length > 0);
+            // Verify error structure
+            const schemaError = schemaErrors[0];
+            assert.strictEqual(schemaError.code, "schema_error");
+            assert.ok(schemaError.path);
+            assert.ok(schemaError.message);
+        });
+        it("should handle semantic validation errors", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "invalid-rest-method.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.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");
+            assert.ok(schemaErrors.length > 0);
+            // Verify error structure
+            const schemaError = schemaErrors[0];
+            assert.strictEqual(schemaError.code, "schema_error");
+            assert.ok(schemaError.path?.includes("method"));
+            assert.ok(schemaError.message);
+        });
+        it("should handle config validation errors", async () => {
+            const invalidConfig = loadInvalidExample(getExamplePath("invalid", "config", "missing-version.json"));
+            const result = await validateUniSpec(invalidConfig);
+            assert.ok(!result.valid);
+            // Should have schema errors for config validation
+            const configErrors = result.errors.filter((e) => e.code === "schema_error");
+            assert.ok(configErrors.length > 0);
+            // Verify error structure
+            const configError = configErrors[0];
+            assert.strictEqual(configError.code, "schema_error");
+            assert.ok(configError.path);
+            assert.ok(configError.message);
+        });
+    });
+    describe("error conversion and handling", () => {
+        it("should convert AJV errors to UniSpecValidationErrors", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "missing-service-name.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.ok(!result.valid);
+            // All errors should be ValidationError type
+            for (const error of result.errors) {
+                assert.ok(error.message);
+                assert.ok(error.code);
+            }
+        });
+        it("should handle error factory with validation context", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "invalid-identifier.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.ok(!result.valid);
+            // Create custom error based on validation result
+            if (result.errors.length > 0) {
+                const customError = ErrorFactory.createSemanticError("Custom semantic error based on validation", result.errors[0].path || "", { originalErrors: result.errors.map((e) => e.message) });
+                assert.ok(customError instanceof Error);
+                assert.strictEqual(customError.code, "semantic_error");
+                assert.ok(customError.details?.originalErrors);
+            }
+        });
+        it("should preserve error details through validation chain", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "graphql-missing-arg-type.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.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
+                assert.ok(error.message);
+                assert.ok(error.code);
+                assert.ok(error.path);
+            }
+        });
+    });
+    describe("error severity levels", () => {
+        it("should handle different severity levels in validation", async () => {
+            // Test with a document that might have different severity levels
+            const validDoc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+            const result = await 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) {
+                    assert.ok(error.message);
+                    assert.ok(error.code);
+                    assert.ok(typeof error.path === "string");
+                }
+            }
+        });
+        it("should properly classify error types", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "missing-service-name.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.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));
+            assert.ok(hasExpectedCode, `Expected one of ${expectedCodes}, got ${errorCodes}`);
+        });
+    });
+    describe("complex error scenarios", () => {
+        it("should handle multiple errors in single document", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "missing-service-name.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.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
+                assert.ok(uniquePaths.size > 0 || uniqueCodes.size > 0);
+            }
+        });
+        it("should handle nested error paths", async () => {
+            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "invalid-rest-method.json"));
+            const result = await validateUniSpec(invalidDoc);
+            assert.ok(!result.valid);
+            // Should have errors with nested paths
+            const nestedErrors = result.errors.filter((e) => e.path?.includes("/"));
+            assert.ok(nestedErrors.length > 0);
+            // Paths should be properly formatted
+            for (const error of nestedErrors) {
+                assert.ok(error.path?.includes("/service/"));
+                assert.ok(!error.path?.endsWith("."));
+            }
+        });
+    });
+});

package/dist/tests/errors/errors.test.d.ts

@@ -0,0 +1 @@
+export {};