@unispechq/unispec-core 0.3.2 → 0.3.4

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

@@ -1,230 +0,0 @@
-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

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

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

@@ -1,184 +0,0 @@
-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

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

package/dist/tests/diff/utils.js

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,168 +0,0 @@
-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

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