@unispechq/unispec-core 0.3.0 → 0.3.2

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

@@ -0,0 +1,262 @@
+"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 - comprehensive schema examples", () => {
+    (0, node_test_1.describe)("valid spec examples", () => {
+        (0, node_test_1.it)("should handle rest-simple.json correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            // Test self-comparison
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+            // Test modifications
+            const modified = JSON.parse(JSON.stringify(doc));
+            modified.service.protocols.rest.routes.push({
+                name: "newRoute",
+                method: "DELETE",
+                path: "/users/{id}",
+                responses: { 204: { description: "No content" } },
+            });
+            const diffResult = (0, core_1.diffUniSpec)(doc, modified);
+            const newRoute = diffResult.changes.find((change) => change.path.includes("newRoute"));
+            node_assert_1.default.ok(newRoute);
+            node_assert_1.default.strictEqual(newRoute.protocol, "rest");
+            node_assert_1.default.strictEqual(newRoute.severity, "non-breaking");
+        });
+        (0, node_test_1.it)("should handle graphql-simple.json correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "graphql-simple.json"));
+            // Test self-comparison
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+            // Test schema change
+            const modified = JSON.parse(JSON.stringify(doc));
+            modified.service.protocols.graphql.schema +=
+                " type NewType { field: String! }";
+            const diffResult = (0, core_1.diffUniSpec)(doc, modified);
+            const schemaChange = diffResult.changes.find((change) => change.path.includes("schema"));
+            node_assert_1.default.ok(schemaChange);
+            node_assert_1.default.strictEqual(schemaChange.description, "Value changed");
+        });
+        (0, node_test_1.it)("should handle websocket-simple.json correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "websocket-simple.json"));
+            // Test self-comparison
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+            // Test channel addition
+            const modified = JSON.parse(JSON.stringify(doc));
+            modified.service.protocols.websocket.channels.push({
+                name: "newChannel",
+                description: "New channel",
+                messages: [],
+            });
+            const diffResult = (0, core_1.diffUniSpec)(doc, modified);
+            const newChannel = diffResult.changes.find((change) => change.path.includes("newChannel"));
+            node_assert_1.default.ok(newChannel);
+            node_assert_1.default.strictEqual(newChannel.protocol, "websocket");
+            node_assert_1.default.strictEqual(newChannel.severity, "non-breaking");
+        });
+        (0, node_test_1.it)("should handle mixed-complete.json correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "mixed-complete.json"));
+            // Test self-comparison
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+            // Test multiple protocol changes
+            const modified = JSON.parse(JSON.stringify(doc));
+            // Add REST route
+            if (modified.service.protocols.rest) {
+                modified.service.protocols.rest.routes.push({
+                    name: "mixedRoute",
+                    method: "PATCH",
+                    path: "/mixed",
+                    responses: { 200: { description: "OK" } },
+                });
+            }
+            // Add GraphQL query
+            if (modified.service.protocols.graphql?.queries) {
+                modified.service.protocols.graphql.queries.push({
+                    name: "mixedQuery",
+                    description: "Mixed query",
+                    args: [],
+                    returnType: "String",
+                });
+            }
+            const diffResult = (0, core_1.diffUniSpec)(doc, modified);
+            // Should have both REST and GraphQL changes
+            const restChanges = diffResult.changes.filter((change) => change.protocol === "rest");
+            const graphqlChanges = diffResult.changes.filter((change) => change.protocol === "graphql");
+            node_assert_1.default.ok(restChanges.length > 0);
+            node_assert_1.default.ok(graphqlChanges.length > 0);
+        });
+    });
+    (0, node_test_1.describe)("valid config examples", () => {
+        (0, node_test_1.it)("should handle complete-enterprise.json correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "config", "complete-enterprise.json"));
+            // Test self-comparison
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+            // Test modification
+            const modified = JSON.parse(JSON.stringify(doc));
+            if (Array.isArray(modified.services)) {
+                modified.services.push({
+                    name: "new-service",
+                    baseUrl: "https://new-service.example.com",
+                });
+            }
+            const diffResult = (0, core_1.diffUniSpec)(doc, modified);
+            node_assert_1.default.ok(diffResult.changes.length > 0);
+        });
+        (0, node_test_1.it)("should handle registry-based.json correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "config", "registry-based.json"));
+            // Test self-comparison
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle simple-multi-service.json correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "config", "simple-multi-service.json"));
+            // Test self-comparison
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+    });
+    (0, node_test_1.describe)("invalid spec examples", () => {
+        (0, node_test_1.it)("should handle graphql-missing-arg-type.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "graphql-missing-arg-type.json"));
+            // Should not crash on invalid documents
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+            // Should handle modifications
+            const modified = JSON.parse(JSON.stringify(doc));
+            modified.unispecVersion = "1.0.1";
+            const diffResult = (0, core_1.diffUniSpec)(doc, modified);
+            const versionChange = diffResult.changes.find((change) => change.path === "/unispecVersion");
+            node_assert_1.default.ok(versionChange);
+        });
+        (0, node_test_1.it)("should handle graphql-missing-name.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "graphql-missing-name.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle invalid-identifier.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "invalid-identifier.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle invalid-rest-method.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "invalid-rest-method.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle missing-service-name.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "missing-service-name.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle missing-unispec-version.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "missing-unispec-version.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+    });
+    (0, node_test_1.describe)("invalid config examples", () => {
+        (0, node_test_1.it)("should handle empty-services-array.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "config", "empty-services-array.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle invalid-spec-reference.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "config", "invalid-spec-reference.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle missing-services.json without crashing", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "config", "missing-services.json"));
+            const result = (0, core_1.diffUniSpec)(doc, doc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+    });
+    (0, node_test_1.describe)("cross-example comparisons", () => {
+        (0, node_test_1.it)("should handle comparing different valid specs", () => {
+            const restDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const graphqlDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "graphql-simple.json"));
+            // Should detect many differences between different specs
+            const result = (0, core_1.diffUniSpec)(restDoc, graphqlDoc);
+            node_assert_1.default.ok(result.changes.length > 0);
+            // Most changes will be structural and not protocol-specific
+            // since the documents have completely different structures
+            const structuralChanges = result.changes.filter((change) => change.protocol === undefined);
+            // Should have some structural changes
+            node_assert_1.default.ok(structuralChanges.length > 0);
+            // May have some protocol-specific changes if paths overlap
+            const restChanges = result.changes.filter((change) => change.protocol === "rest");
+            const graphqlChanges = result.changes.filter((change) => change.protocol === "graphql");
+            // At least one of them should have changes
+            node_assert_1.default.ok(restChanges.length > 0 ||
+                graphqlChanges.length > 0 ||
+                structuralChanges.length > 0);
+        });
+        (0, node_test_1.it)("should handle comparing valid and invalid specs", () => {
+            const validDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const invalidDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "missing-service-name.json"));
+            // Should handle comparisons without crashing
+            const result = (0, core_1.diffUniSpec)(validDoc, invalidDoc);
+            node_assert_1.default.ok(result.changes.length > 0);
+        });
+        (0, node_test_1.it)("should handle comparing config and spec files", () => {
+            const configDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "config", "simple-multi-service.json"));
+            const specDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            // Should handle completely different structures
+            const result = (0, core_1.diffUniSpec)(configDoc, specDoc);
+            node_assert_1.default.ok(result.changes.length > 0);
+        });
+    });
+    (0, node_test_1.describe)("edge cases with real examples", () => {
+        (0, node_test_1.it)("should handle deeply nested changes in complex examples", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "mixed-complete.json"));
+            const modified = JSON.parse(JSON.stringify(doc));
+            // Make a deep nested change - find the first route with requestBody
+            if (modified.service?.protocols?.rest?.routes) {
+                const routeWithBody = modified.service.protocols.rest.routes.find((route) => route.requestBody?.content?.["application/json"]?.schemaRef);
+                if (routeWithBody) {
+                    routeWithBody.requestBody.content["application/json"].schemaRef =
+                        "NewSchemaRef";
+                }
+            }
+            const result = (0, core_1.diffUniSpec)(doc, modified);
+            // Should have some changes
+            node_assert_1.default.ok(result.changes.length > 0);
+            // Look for any schema-related change
+            const schemaChange = result.changes.find((change) => change.path.includes("schemaRef"));
+            // If we found a route with schemaRef, it should be detected
+            if (doc.service?.protocols?.rest?.routes?.some((route) => route.requestBody?.content?.["application/json"]?.schemaRef)) {
+                node_assert_1.default.ok(schemaChange);
+                node_assert_1.default.strictEqual(schemaChange.description, "Value changed");
+            }
+            else {
+                // If no route had schemaRef, we should still have some changes
+                node_assert_1.default.ok(result.changes.length > 0);
+            }
+        });
+        (0, node_test_1.it)("should handle array operations in named collections correctly", () => {
+            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
+            const modified = JSON.parse(JSON.stringify(doc));
+            // Reorder routes array
+            if (modified.service.protocols.rest.routes.length >= 2) {
+                const temp = modified.service.protocols.rest.routes[0];
+                modified.service.protocols.rest.routes[0] =
+                    modified.service.protocols.rest.routes[1];
+                modified.service.protocols.rest.routes[1] = temp;
+            }
+            const result = (0, core_1.diffUniSpec)(doc, modified);
+            // Named collections should compare by name, not index
+            // So reordering should not produce changes
+            const routeChanges = result.changes.filter((change) => change.path.includes("/routes/"));
+            node_assert_1.default.strictEqual(routeChanges.length, 0);
+        });
+    });
+});

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

@@ -0,0 +1,235 @@
+"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 - extended tests", () => {
+    (0, node_test_1.describe)("handling of invalid examples", () => {
+        (0, node_test_1.it)("should handle empty services array without crashing", () => {
+            const invalidDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "config", "empty-services-array.json"));
+            // Should not crash when processing invalid documents
+            const result = (0, core_1.diffUniSpec)(invalidDoc, invalidDoc);
+            node_assert_1.default.strictEqual(result.changes.length, 0);
+        });
+        (0, node_test_1.it)("should handle missing service name", () => {
+            const invalidDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.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 = (0, core_1.diffUniSpec)(invalidDoc, modifiedDoc);
+            node_assert_1.default.ok(result.changes.length > 0);
+            const versionChange = result.changes.find((change) => change.path === "/version");
+            node_assert_1.default.ok(versionChange);
+            node_assert_1.default.strictEqual(versionChange.description, "Value changed");
+        });
+        (0, node_test_1.it)("should handle missing version", () => {
+            const invalidDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "config", "missing-version.json"));
+            const modifiedDoc = JSON.parse(JSON.stringify(invalidDoc));
+            modifiedDoc.service = {
+                ...modifiedDoc.service,
+                description: "Added description",
+            };
+            const result = (0, core_1.diffUniSpec)(invalidDoc, modifiedDoc);
+            node_assert_1.default.ok(result.changes.length > 0);
+        });
+    });
+    (0, node_test_1.describe)("complex scenarios with valid examples", () => {
+        (0, node_test_1.it)("should handle mixed protocol changes", () => {
+            const baseDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.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 = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const restChange = result.changes.find((change) => change.path.includes("newRoute") && change.protocol === "rest");
+            node_assert_1.default.ok(restChange);
+            node_assert_1.default.strictEqual(restChange.severity, "non-breaking");
+            if (modifiedDoc.service.protocols.graphql) {
+                const graphqlChange = result.changes.find((change) => change.path.includes("newQuery") && change.protocol === "graphql");
+                node_assert_1.default.ok(graphqlChange);
+            }
+        });
+        (0, node_test_1.it)("should detect breaking changes in REST", () => {
+            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 (breaking change)
+            modifiedDoc.service.protocols.rest.routes =
+                modifiedDoc.service.protocols.rest.routes.filter((route) => route.name !== "getUsers");
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const removedRoute = result.changes.find((change) => change.path === "/service/protocols/rest/routes/getUsers");
+            node_assert_1.default.ok(removedRoute);
+            node_assert_1.default.strictEqual(removedRoute.severity, "breaking");
+            node_assert_1.default.strictEqual(removedRoute.kind, "rest.route.removed");
+        });
+    });
+    (0, node_test_1.describe)("edge cases and boundary conditions", () => {
+        (0, node_test_1.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 = (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");
+        });
+        (0, node_test_1.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 = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const routeChange = result.changes.find((change) => change.path === "/service/protocols/rest/routes/newRoute");
+            node_assert_1.default.ok(routeChange);
+            node_assert_1.default.strictEqual(routeChange.description, "Item added");
+            node_assert_1.default.strictEqual(routeChange.protocol, "rest");
+        });
+        (0, node_test_1.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 = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const versionChange = result.changes.find((change) => change.path === "/service/metadata/tags/0/version");
+            node_assert_1.default.ok(versionChange);
+            node_assert_1.default.strictEqual(versionChange.description, "Value changed");
+            const phoneChange = result.changes.find((change) => change.path === "/service/metadata/info/contact/phone");
+            node_assert_1.default.ok(phoneChange);
+            node_assert_1.default.strictEqual(phoneChange.description, "Field added");
+        });
+    });
+    (0, node_test_1.describe)("array handling", () => {
+        (0, node_test_1.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 = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            // Should detect changes at index level for regular arrays
+            const indexChange = result.changes.find((change) => change.path === "/service/tags/1");
+            node_assert_1.default.ok(indexChange);
+            node_assert_1.default.strictEqual(indexChange.description, "Value changed");
+            const addedChange = result.changes.find((change) => change.path === "/service/tags/2");
+            node_assert_1.default.ok(addedChange);
+            node_assert_1.default.strictEqual(addedChange.description, "Item added");
+        });
+        (0, node_test_1.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 = (0, core_1.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");
+            node_assert_1.default.ok(itemChange);
+            node_assert_1.default.strictEqual(itemChange.description, "Value changed");
+        });
+    });
+    (0, node_test_1.describe)("protocol-specific behavior", () => {
+        (0, node_test_1.it)("should handle WebSocket messages correctly", () => {
+            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 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 = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const messageChange = result.changes.find((change) => change.path.includes("newMessage") && change.protocol === "websocket");
+            node_assert_1.default.ok(messageChange);
+        });
+        (0, node_test_1.it)("should handle GraphQL schema changes", () => {
+            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));
+            // Change schema string
+            modifiedDoc.service.protocols.graphql.schema = `${baseDoc.service.protocols?.graphql?.schema} type NewType { field: String! }`;
+            const result = (0, core_1.diffUniSpec)(baseDoc, modifiedDoc);
+            const schemaChange = result.changes.find((change) => change.path === "/service/protocols/graphql/schema");
+            node_assert_1.default.ok(schemaChange);
+            node_assert_1.default.strictEqual(schemaChange.description, "Value changed");
+        });
+    });
+});