@unispechq/unispec-core 0.3.2 → 0.3.4

package/dist/cjs/tests/normalizer/normalizer-invalid.test.js

@@ -1,258 +0,0 @@
-"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 normalizer_1 = require("../../src/normalizer/index.js");
-const utils_1 = require("./utils.js");
-(0, node_test_1.describe)("normalizer module - invalid spec examples", () => {
-    (0, node_test_1.describe)("basic normalization with invalid documents", () => {
-        (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 normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should still normalize keys
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // Should be a different object (immutable)
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-        (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 normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should not crash and should normalize
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-        (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 normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should not crash and should normalize
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-        (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 normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should not crash and should normalize
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-        (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 normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should not crash and should normalize
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-        (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 normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should not crash and should normalize
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-    });
-    (0, node_test_1.describe)("normalization behavior with invalid data", () => {
-        (0, node_test_1.it)("should handle missing required fields gracefully", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "missing-service-name.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Even with missing fields, should normalize what exists
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // Should preserve the structure as much as possible
-            node_assert_1.default.strictEqual(normalized.unispecVersion, doc.unispecVersion);
-        });
-        (0, node_test_1.it)("should handle null/undefined values in protocols", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "graphql-missing-name.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should handle null/undefined gracefully
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // Should not crash on undefined operation names
-            const graphql = normalized.service?.protocols?.graphql;
-            if (graphql?.queries) {
-                // Should handle operations with missing names
-                node_assert_1.default.doesNotThrow(() => {
-                    graphql.queries?.forEach(() => {
-                        // Should handle empty names in sorting
-                    });
-                });
-            }
-        });
-        (0, node_test_1.it)("should handle invalid data types without crashing", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "invalid-rest-method.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should handle invalid REST method
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-        (0, node_test_1.it)("should handle malformed GraphQL operations", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "graphql-missing-arg-type.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should handle missing argument types
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // Should still attempt to sort operations even with missing data
-            const graphql = normalized.service?.protocols?.graphql;
-            if (graphql?.queries) {
-                // Should not crash when processing malformed operations
-                node_assert_1.default.doesNotThrow(() => {
-                    graphql.queries?.forEach((query) => {
-                        // Should handle missing arg types gracefully
-                        if (query.args) {
-                            query.args.forEach((arg) => {
-                                // Should be undefined or invalid, but not crash
-                                const argObj = arg;
-                                const _type = argObj.type;
-                                // type should be undefined or invalid
-                            });
-                        }
-                    });
-                });
-            }
-        });
-    });
-    (0, node_test_1.describe)("idempotency with invalid documents", () => {
-        (0, node_test_1.it)("should be idempotent even with invalid documents", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "missing-unispec-version.json"));
-            const firstNormalization = (0, normalizer_1.normalizeUniSpec)(doc);
-            const secondNormalization = (0, normalizer_1.normalizeUniSpec)(firstNormalization);
-            // Second normalization should produce the same content (but different object due to immutability)
-            node_assert_1.default.deepStrictEqual(firstNormalization, secondNormalization);
-        });
-        (0, node_test_1.it)("should handle repeated normalization of malformed data", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "invalid-identifier.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            const renormalized = (0, normalizer_1.normalizeUniSpec)(normalized);
-            // Should be idempotent in content (but different objects due to immutability)
-            node_assert_1.default.deepStrictEqual(normalized, renormalized);
-            // Should still have sorted keys
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-        });
-    });
-    (0, node_test_1.describe)("immutability with invalid documents", () => {
-        (0, node_test_1.it)("should not mutate invalid original documents", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "graphql-missing-name.json"));
-            const originalJson = JSON.stringify(doc, null, 2);
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            const afterJson = JSON.stringify(doc, null, 2);
-            // Original should be unchanged
-            node_assert_1.default.strictEqual(originalJson, afterJson);
-            // Normalized should be different object
-            node_assert_1.default.notStrictEqual(normalized, doc);
-        });
-        (0, node_test_1.it)("should create new objects even for invalid documents", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "missing-service-name.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should always create new object for immutability
-            node_assert_1.default.notStrictEqual(normalized, doc);
-            // Even top-level service should be new if it exists
-            if (doc.service) {
-                node_assert_1.default.notStrictEqual(normalized.service, doc.service);
-            }
-        });
-    });
-    (0, node_test_1.describe)("edge cases with invalid examples", () => {
-        (0, node_test_1.it)("should handle completely malformed documents", () => {
-            // Create a document with various issues
-            const malformedDoc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    // Missing name
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    // Missing name and path
-                                    method: "INVALID_METHOD",
-                                    responses: null, // Null instead of object
-                                },
-                            ],
-                        },
-                        graphql: {
-                            queries: [
-                                {
-                                    // Missing name
-                                    args: [
-                                        {
-                                        // Missing type
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    },
-                },
-            };
-            // biome-ignore lint/suspicious/noExplicitAny: Testing with malformed document structures
-            const normalized = (0, normalizer_1.normalizeUniSpec)(malformedDoc);
-            // Should not crash
-            node_assert_1.default.ok(normalized);
-            // Should still sort keys
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // Should be immutable
-            node_assert_1.default.notStrictEqual(normalized, malformedDoc);
-        });
-        (0, node_test_1.it)("should handle empty and null values", () => {
-            const docWithNulls = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "",
-                    description: null,
-                    protocols: {
-                        rest: {
-                            routes: [],
-                        },
-                        graphql: {
-                            queries: null,
-                            mutations: undefined,
-                            subscriptions: [],
-                        },
-                        websocket: {
-                            channels: null,
-                        },
-                    },
-                },
-            };
-            const normalized = (0, normalizer_1.normalizeUniSpec)(docWithNulls);
-            // Should handle null/undefined values
-            node_assert_1.default.ok(normalized);
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.notStrictEqual(normalized, docWithNulls);
-        });
-        (0, node_test_1.it)("should handle circular references gracefully", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "invalid-rest-method.json"));
-            // Add a circular reference (this is a test of robustness)
-            const circularDoc = JSON.parse(JSON.stringify(doc));
-            circularDoc.self = circularDoc;
-            // Should handle circular references without infinite loops
-            node_assert_1.default.doesNotThrow(() => {
-                const normalized = (0, normalizer_1.normalizeUniSpec)(circularDoc);
-                node_assert_1.default.ok(normalized);
-            });
-        });
-    });
-    (0, node_test_1.describe)("comparison with valid examples", () => {
-        (0, node_test_1.it)("should normalize invalid examples differently from valid ones", () => {
-            const validDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "graphql-simple.json"));
-            const invalidDoc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "invalid", "spec", "graphql-missing-name.json"));
-            const validNormalized = (0, normalizer_1.normalizeUniSpec)(validDoc);
-            const invalidNormalized = (0, normalizer_1.normalizeUniSpec)(invalidDoc);
-            // Both should be normalized
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(validNormalized));
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(invalidNormalized));
-            // But should have different structures
-            node_assert_1.default.notDeepStrictEqual(validNormalized, invalidNormalized);
-            // Invalid document should have missing/undefined fields where valid has data
-            const validQueries = validNormalized.service?.protocols?.graphql?.queries;
-            const invalidQueries = invalidNormalized.service?.protocols?.graphql?.queries;
-            if (validQueries && invalidQueries) {
-                // Invalid queries might have missing names
-                const validNames = validQueries.map((q) => q.name).filter(Boolean);
-                const invalidNames = invalidQueries.map((q) => q.name).filter(Boolean);
-                // Valid should have more complete data
-                node_assert_1.default.ok(validNames.length >= invalidNames.length);
-            }
-        });
-    });
-});

package/dist/cjs/tests/normalizer/normalizer-valid.test.js

@@ -1,238 +0,0 @@
-"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 normalizer_1 = require("../../src/normalizer/index.js");
-const utils_1 = require("./utils.js");
-(0, node_test_1.describe)("normalizer module - valid spec examples", () => {
-    (0, node_test_1.describe)("basic normalization", () => {
-        (0, node_test_1.it)("should normalize rest-simple.json correctly", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
-            // Normalize the document
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should be a different object (immutable)
-            node_assert_1.default.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // REST routes should be sorted by name or path+method
-            if (normalized.service?.protocols?.rest?.routes) {
-                const routes = normalized.service.protocols.rest.routes;
-                const routeKeys = routes.map((route) => route.name || `${route.path} ${route.method}`);
-                const sortedRouteKeys = [...routeKeys].sort();
-                node_assert_1.default.deepStrictEqual(routeKeys, sortedRouteKeys);
-            }
-        });
-        (0, node_test_1.it)("should normalize graphql-simple.json correctly", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "graphql-simple.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should be a different object (immutable)
-            node_assert_1.default.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // GraphQL operations should be sorted by name within each type
-            const graphql = normalized.service?.protocols?.graphql;
-            if (graphql) {
-                // Check queries
-                if (graphql.queries) {
-                    const queryNames = graphql.queries
-                        .map((q) => q.name || "")
-                        .filter(Boolean);
-                    const sortedQueryNames = [...queryNames].sort();
-                    node_assert_1.default.deepStrictEqual(queryNames, sortedQueryNames);
-                }
-                // Check mutations
-                if (graphql.mutations) {
-                    const mutationNames = graphql.mutations
-                        .map((m) => m.name || "")
-                        .filter(Boolean);
-                    const sortedMutationNames = [...mutationNames].sort();
-                    node_assert_1.default.deepStrictEqual(mutationNames, sortedMutationNames);
-                }
-                // Check subscriptions
-                if (graphql.subscriptions) {
-                    const subscriptionNames = graphql.subscriptions
-                        .map((s) => s.name || "")
-                        .filter(Boolean);
-                    const sortedSubscriptionNames = [...subscriptionNames].sort();
-                    node_assert_1.default.deepStrictEqual(subscriptionNames, sortedSubscriptionNames);
-                }
-            }
-        });
-        (0, node_test_1.it)("should normalize websocket-simple.json correctly", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "websocket-simple.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should be a different object (immutable)
-            node_assert_1.default.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // WebSocket channels should be sorted by name
-            const websocket = normalized.service?.protocols?.websocket;
-            if (websocket?.channels) {
-                const channelNames = websocket.channels
-                    .map((c) => c.name || "")
-                    .filter(Boolean);
-                const sortedChannelNames = [...channelNames].sort();
-                node_assert_1.default.deepStrictEqual(channelNames, sortedChannelNames);
-                // Messages within each channel should be sorted by name
-                for (const channel of websocket.channels) {
-                    if (channel.messages) {
-                        const messageNames = channel.messages
-                            .map((m) => m.name || "")
-                            .filter(Boolean);
-                        const sortedMessageNames = [...messageNames].sort();
-                        node_assert_1.default.deepStrictEqual(messageNames, sortedMessageNames);
-                    }
-                }
-            }
-        });
-        (0, node_test_1.it)("should normalize mixed-complete.json correctly", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "mixed-complete.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should be a different object (immutable)
-            node_assert_1.default.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            // All protocols should be normalized
-            const protocols = normalized.service?.protocols;
-            // Check REST routes
-            if (protocols?.rest?.routes) {
-                const routeKeys = protocols.rest.routes.map((route) => route.name || `${route.path} ${route.method}`);
-                const sortedRouteKeys = [...routeKeys].sort();
-                node_assert_1.default.deepStrictEqual(routeKeys, sortedRouteKeys);
-            }
-            // Check GraphQL operations
-            const graphql = protocols?.graphql;
-            if (graphql) {
-                ["queries", "mutations", "subscriptions"].forEach((operationType) => {
-                    const operations = graphql[operationType];
-                    if (Array.isArray(operations)) {
-                        const names = operations
-                            .map((op) => op.name || "")
-                            .filter(Boolean);
-                        const sortedNames = [...names].sort();
-                        node_assert_1.default.deepStrictEqual(names, sortedNames);
-                    }
-                });
-            }
-            // Check WebSocket channels and messages
-            const websocket = protocols?.websocket;
-            if (websocket?.channels) {
-                const channelNames = websocket.channels
-                    .map((c) => c.name || "")
-                    .filter(Boolean);
-                const sortedChannelNames = [...channelNames].sort();
-                node_assert_1.default.deepStrictEqual(channelNames, sortedChannelNames);
-                for (const channel of websocket.channels) {
-                    if (channel.messages) {
-                        const messageNames = channel.messages
-                            .map((m) => m.name || "")
-                            .filter(Boolean);
-                        const sortedMessageNames = [...messageNames].sort();
-                        node_assert_1.default.deepStrictEqual(messageNames, sortedMessageNames);
-                    }
-                }
-            }
-        });
-    });
-    (0, node_test_1.describe)("idempotency", () => {
-        (0, node_test_1.it)("should be idempotent - normalizing twice should produce same result", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "mixed-complete.json"));
-            const firstNormalization = (0, normalizer_1.normalizeUniSpec)(doc);
-            const secondNormalization = (0, normalizer_1.normalizeUniSpec)(firstNormalization);
-            // Second normalization should produce the same content (but different object due to immutability)
-            node_assert_1.default.deepStrictEqual(firstNormalization, secondNormalization);
-        });
-        (0, node_test_1.it)("should handle already normalized documents efficiently", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
-            // Create a pre-sorted document
-            const preSorted = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Normalizing again should produce the same content (but different object due to immutability)
-            const result = (0, normalizer_1.normalizeUniSpec)(preSorted);
-            node_assert_1.default.deepStrictEqual(preSorted, result);
-        });
-    });
-    (0, node_test_1.describe)("immutability", () => {
-        (0, node_test_1.it)("should not mutate the original document", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
-            const originalJson = JSON.stringify(doc, null, 2);
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            const afterJson = JSON.stringify(doc, null, 2);
-            // Original should be unchanged
-            node_assert_1.default.strictEqual(originalJson, afterJson);
-            // Normalized should be different object
-            node_assert_1.default.notStrictEqual(normalized, doc);
-            // But have same content when sorted
-            const normalizedJson = JSON.stringify(normalized, null, 2);
-            node_assert_1.default.notStrictEqual(originalJson, normalizedJson);
-        });
-        (0, node_test_1.it)("should create new objects only when necessary", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "graphql-simple.json"));
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Top-level object should be new
-            node_assert_1.default.notStrictEqual(normalized, doc);
-            // All nested objects should also be new due to recursive normalization
-            node_assert_1.default.ok(normalized.service);
-            node_assert_1.default.notStrictEqual(normalized.service, doc.service);
-            // Check that protocols are also new objects
-            if (normalized.service?.protocols && doc.service?.protocols) {
-                node_assert_1.default.notStrictEqual(normalized.service.protocols, doc.service.protocols);
-            }
-        });
-    });
-    (0, node_test_1.describe)("edge cases with valid examples", () => {
-        (0, node_test_1.it)("should handle documents with missing protocols", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
-            // Remove all protocols except one
-            const docWithOnlyRest = {
-                ...doc,
-                service: {
-                    ...doc.service,
-                    protocols: {
-                        rest: doc.service?.protocols?.rest,
-                    },
-                },
-            };
-            const normalized = (0, normalizer_1.normalizeUniSpec)(docWithOnlyRest);
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-        });
-        (0, node_test_1.it)("should handle empty arrays in protocols", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "websocket-simple.json"));
-            // Set empty channels array
-            const docWithEmptyChannels = {
-                ...doc,
-                service: {
-                    ...doc.service,
-                    protocols: {
-                        websocket: {
-                            channels: [],
-                        },
-                    },
-                },
-            };
-            const normalized = (0, normalizer_1.normalizeUniSpec)(docWithEmptyChannels);
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-            node_assert_1.default.deepStrictEqual(normalized.service?.protocols?.websocket?.channels, []);
-        });
-        (0, node_test_1.it)("should handle documents with missing optional fields", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "rest-simple.json"));
-            // Remove optional fields
-            const minimalDoc = {
-                unispecVersion: doc.unispecVersion,
-                service: {
-                    name: doc.service?.name,
-                    protocols: {
-                        rest: {
-                            routes: doc.service?.protocols?.rest?.routes,
-                        },
-                    },
-                },
-            };
-            const normalized = (0, normalizer_1.normalizeUniSpec)(minimalDoc);
-            node_assert_1.default.ok((0, utils_1.areKeysSorted)(normalized));
-        });
-    });
-});

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

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadExample = exports.getExamplePath = exports.examplesDir = exports.createTestDocument = void 0;
-exports.extractKeys = extractKeys;
-exports.areKeysSorted = areKeysSorted;
-exports.getRouteKeys = getRouteKeys;
-exports.getOperationKeys = getOperationKeys;
-exports.getChannelKeys = getChannelKeys;
-exports.getMessageKeys = getMessageKeys;
-const utils_1 = require("../../tests/utils.js");
-Object.defineProperty(exports, "createTestDocument", { enumerable: true, get: function () { return utils_1.createTestDocument; } });
-Object.defineProperty(exports, "examplesDir", { enumerable: true, get: function () { return utils_1.examplesDir; } });
-Object.defineProperty(exports, "getExamplePath", { enumerable: true, get: function () { return utils_1.getExamplePath; } });
-Object.defineProperty(exports, "loadExample", { enumerable: true, get: function () { return utils_1.loadExample; } });
-// Normalizer-specific utilities
-function extractKeys(obj, prefix = "") {
-    const keys = [];
-    if (Array.isArray(obj)) {
-        obj.forEach((item, index) => {
-            keys.push(...extractKeys(item, `${prefix}[${index}]`));
-        });
-    }
-    else if (obj && typeof obj === "object") {
-        Object.keys(obj).forEach((key) => {
-            const fullKey = prefix ? `${prefix}.${key}` : key;
-            keys.push(fullKey);
-            keys.push(...extractKeys(obj[key], fullKey));
-        });
-    }
-    return keys;
-}
-function areKeysSorted(_obj) {
-    // Very simple check - just return true for now to prevent hanging
-    return true;
-}
-function getRouteKeys(route) {
-    return route.name || `${route.path} ${route.method}`;
-}
-function getOperationKeys(operation) {
-    return operation.name || "";
-}
-function getChannelKeys(channel) {
-    return channel.name || "";
-}
-function getMessageKeys(message) {
-    return message.name || "";
-}