@unispechq/unispec-core 0.3.2 → 0.3.4

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

@@ -1,253 +0,0 @@
-import assert from "node:assert";
-import path from "node:path";
-import { describe, it } from "node:test";
-import { normalizeUniSpec } from "../../src/normalizer/index.js";
-import { areKeysSorted, examplesDir, loadExample } from "./utils.js";
-describe("normalizer module - invalid spec examples", () => {
-    describe("basic normalization with invalid documents", () => {
-        it("should handle graphql-missing-arg-type.json without crashing", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "graphql-missing-arg-type.json"));
-            // Should not crash on invalid documents
-            const normalized = normalizeUniSpec(doc);
-            // Should still normalize keys
-            assert.ok(areKeysSorted(normalized));
-            // Should be a different object (immutable)
-            assert.notStrictEqual(normalized, doc);
-        });
-        it("should handle graphql-missing-name.json without crashing", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "graphql-missing-name.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should not crash and should normalize
-            assert.ok(areKeysSorted(normalized));
-            assert.notStrictEqual(normalized, doc);
-        });
-        it("should handle invalid-identifier.json without crashing", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "invalid-identifier.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should not crash and should normalize
-            assert.ok(areKeysSorted(normalized));
-            assert.notStrictEqual(normalized, doc);
-        });
-        it("should handle invalid-rest-method.json without crashing", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "invalid-rest-method.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should not crash and should normalize
-            assert.ok(areKeysSorted(normalized));
-            assert.notStrictEqual(normalized, doc);
-        });
-        it("should handle missing-service-name.json without crashing", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "missing-service-name.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should not crash and should normalize
-            assert.ok(areKeysSorted(normalized));
-            assert.notStrictEqual(normalized, doc);
-        });
-        it("should handle missing-unispec-version.json without crashing", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "missing-unispec-version.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should not crash and should normalize
-            assert.ok(areKeysSorted(normalized));
-            assert.notStrictEqual(normalized, doc);
-        });
-    });
-    describe("normalization behavior with invalid data", () => {
-        it("should handle missing required fields gracefully", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "missing-service-name.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Even with missing fields, should normalize what exists
-            assert.ok(areKeysSorted(normalized));
-            // Should preserve the structure as much as possible
-            assert.strictEqual(normalized.unispecVersion, doc.unispecVersion);
-        });
-        it("should handle null/undefined values in protocols", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "graphql-missing-name.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should handle null/undefined gracefully
-            assert.ok(areKeysSorted(normalized));
-            // Should not crash on undefined operation names
-            const graphql = normalized.service?.protocols?.graphql;
-            if (graphql?.queries) {
-                // Should handle operations with missing names
-                assert.doesNotThrow(() => {
-                    graphql.queries?.forEach(() => {
-                        // Should handle empty names in sorting
-                    });
-                });
-            }
-        });
-        it("should handle invalid data types without crashing", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "invalid-rest-method.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should handle invalid REST method
-            assert.ok(areKeysSorted(normalized));
-            assert.notStrictEqual(normalized, doc);
-        });
-        it("should handle malformed GraphQL operations", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "graphql-missing-arg-type.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should handle missing argument types
-            assert.ok(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
-                assert.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
-                            });
-                        }
-                    });
-                });
-            }
-        });
-    });
-    describe("idempotency with invalid documents", () => {
-        it("should be idempotent even with invalid documents", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "missing-unispec-version.json"));
-            const firstNormalization = normalizeUniSpec(doc);
-            const secondNormalization = normalizeUniSpec(firstNormalization);
-            // Second normalization should produce the same content (but different object due to immutability)
-            assert.deepStrictEqual(firstNormalization, secondNormalization);
-        });
-        it("should handle repeated normalization of malformed data", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "invalid-identifier.json"));
-            const normalized = normalizeUniSpec(doc);
-            const renormalized = normalizeUniSpec(normalized);
-            // Should be idempotent in content (but different objects due to immutability)
-            assert.deepStrictEqual(normalized, renormalized);
-            // Should still have sorted keys
-            assert.ok(areKeysSorted(normalized));
-        });
-    });
-    describe("immutability with invalid documents", () => {
-        it("should not mutate invalid original documents", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "graphql-missing-name.json"));
-            const originalJson = JSON.stringify(doc, null, 2);
-            const normalized = normalizeUniSpec(doc);
-            const afterJson = JSON.stringify(doc, null, 2);
-            // Original should be unchanged
-            assert.strictEqual(originalJson, afterJson);
-            // Normalized should be different object
-            assert.notStrictEqual(normalized, doc);
-        });
-        it("should create new objects even for invalid documents", () => {
-            const doc = loadExample(path.join(examplesDir, "invalid", "spec", "missing-service-name.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should always create new object for immutability
-            assert.notStrictEqual(normalized, doc);
-            // Even top-level service should be new if it exists
-            if (doc.service) {
-                assert.notStrictEqual(normalized.service, doc.service);
-            }
-        });
-    });
-    describe("edge cases with invalid examples", () => {
-        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 = normalizeUniSpec(malformedDoc);
-            // Should not crash
-            assert.ok(normalized);
-            // Should still sort keys
-            assert.ok(areKeysSorted(normalized));
-            // Should be immutable
-            assert.notStrictEqual(normalized, malformedDoc);
-        });
-        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 = normalizeUniSpec(docWithNulls);
-            // Should handle null/undefined values
-            assert.ok(normalized);
-            assert.ok(areKeysSorted(normalized));
-            assert.notStrictEqual(normalized, docWithNulls);
-        });
-        it("should handle circular references gracefully", () => {
-            const doc = loadExample(path.join(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
-            assert.doesNotThrow(() => {
-                const normalized = normalizeUniSpec(circularDoc);
-                assert.ok(normalized);
-            });
-        });
-    });
-    describe("comparison with valid examples", () => {
-        it("should normalize invalid examples differently from valid ones", () => {
-            const validDoc = loadExample(path.join(examplesDir, "valid", "spec", "graphql-simple.json"));
-            const invalidDoc = loadExample(path.join(examplesDir, "invalid", "spec", "graphql-missing-name.json"));
-            const validNormalized = normalizeUniSpec(validDoc);
-            const invalidNormalized = normalizeUniSpec(invalidDoc);
-            // Both should be normalized
-            assert.ok(areKeysSorted(validNormalized));
-            assert.ok(areKeysSorted(invalidNormalized));
-            // But should have different structures
-            assert.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
-                assert.ok(validNames.length >= invalidNames.length);
-            }
-        });
-    });
-});

package/dist/tests/normalizer/normalizer-valid.test.d.ts

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

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

@@ -1,233 +0,0 @@
-import assert from "node:assert";
-import path from "node:path";
-import { describe, it } from "node:test";
-import { normalizeUniSpec } from "../../src/normalizer/index.js";
-import { areKeysSorted, examplesDir, loadExample } from "./utils.js";
-describe("normalizer module - valid spec examples", () => {
-    describe("basic normalization", () => {
-        it("should normalize rest-simple.json correctly", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "rest-simple.json"));
-            // Normalize the document
-            const normalized = normalizeUniSpec(doc);
-            // Should be a different object (immutable)
-            assert.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            assert.ok(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();
-                assert.deepStrictEqual(routeKeys, sortedRouteKeys);
-            }
-        });
-        it("should normalize graphql-simple.json correctly", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "graphql-simple.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should be a different object (immutable)
-            assert.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            assert.ok(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();
-                    assert.deepStrictEqual(queryNames, sortedQueryNames);
-                }
-                // Check mutations
-                if (graphql.mutations) {
-                    const mutationNames = graphql.mutations
-                        .map((m) => m.name || "")
-                        .filter(Boolean);
-                    const sortedMutationNames = [...mutationNames].sort();
-                    assert.deepStrictEqual(mutationNames, sortedMutationNames);
-                }
-                // Check subscriptions
-                if (graphql.subscriptions) {
-                    const subscriptionNames = graphql.subscriptions
-                        .map((s) => s.name || "")
-                        .filter(Boolean);
-                    const sortedSubscriptionNames = [...subscriptionNames].sort();
-                    assert.deepStrictEqual(subscriptionNames, sortedSubscriptionNames);
-                }
-            }
-        });
-        it("should normalize websocket-simple.json correctly", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "websocket-simple.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should be a different object (immutable)
-            assert.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            assert.ok(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();
-                assert.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();
-                        assert.deepStrictEqual(messageNames, sortedMessageNames);
-                    }
-                }
-            }
-        });
-        it("should normalize mixed-complete.json correctly", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "mixed-complete.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Should be a different object (immutable)
-            assert.notStrictEqual(normalized, doc);
-            // Should have all keys sorted
-            assert.ok(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();
-                assert.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();
-                        assert.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();
-                assert.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();
-                        assert.deepStrictEqual(messageNames, sortedMessageNames);
-                    }
-                }
-            }
-        });
-    });
-    describe("idempotency", () => {
-        it("should be idempotent - normalizing twice should produce same result", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "mixed-complete.json"));
-            const firstNormalization = normalizeUniSpec(doc);
-            const secondNormalization = normalizeUniSpec(firstNormalization);
-            // Second normalization should produce the same content (but different object due to immutability)
-            assert.deepStrictEqual(firstNormalization, secondNormalization);
-        });
-        it("should handle already normalized documents efficiently", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "rest-simple.json"));
-            // Create a pre-sorted document
-            const preSorted = normalizeUniSpec(doc);
-            // Normalizing again should produce the same content (but different object due to immutability)
-            const result = normalizeUniSpec(preSorted);
-            assert.deepStrictEqual(preSorted, result);
-        });
-    });
-    describe("immutability", () => {
-        it("should not mutate the original document", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "rest-simple.json"));
-            const originalJson = JSON.stringify(doc, null, 2);
-            const normalized = normalizeUniSpec(doc);
-            const afterJson = JSON.stringify(doc, null, 2);
-            // Original should be unchanged
-            assert.strictEqual(originalJson, afterJson);
-            // Normalized should be different object
-            assert.notStrictEqual(normalized, doc);
-            // But have same content when sorted
-            const normalizedJson = JSON.stringify(normalized, null, 2);
-            assert.notStrictEqual(originalJson, normalizedJson);
-        });
-        it("should create new objects only when necessary", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "graphql-simple.json"));
-            const normalized = normalizeUniSpec(doc);
-            // Top-level object should be new
-            assert.notStrictEqual(normalized, doc);
-            // All nested objects should also be new due to recursive normalization
-            assert.ok(normalized.service);
-            assert.notStrictEqual(normalized.service, doc.service);
-            // Check that protocols are also new objects
-            if (normalized.service?.protocols && doc.service?.protocols) {
-                assert.notStrictEqual(normalized.service.protocols, doc.service.protocols);
-            }
-        });
-    });
-    describe("edge cases with valid examples", () => {
-        it("should handle documents with missing protocols", () => {
-            const doc = loadExample(path.join(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 = normalizeUniSpec(docWithOnlyRest);
-            assert.ok(areKeysSorted(normalized));
-        });
-        it("should handle empty arrays in protocols", () => {
-            const doc = loadExample(path.join(examplesDir, "valid", "spec", "websocket-simple.json"));
-            // Set empty channels array
-            const docWithEmptyChannels = {
-                ...doc,
-                service: {
-                    ...doc.service,
-                    protocols: {
-                        websocket: {
-                            channels: [],
-                        },
-                    },
-                },
-            };
-            const normalized = normalizeUniSpec(docWithEmptyChannels);
-            assert.ok(areKeysSorted(normalized));
-            assert.deepStrictEqual(normalized.service?.protocols?.websocket?.channels, []);
-        });
-        it("should handle documents with missing optional fields", () => {
-            const doc = loadExample(path.join(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 = normalizeUniSpec(minimalDoc);
-            assert.ok(areKeysSorted(normalized));
-        });
-    });
-});

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

@@ -1,18 +0,0 @@
-import { createTestDocument, examplesDir, getExamplePath, loadExample } from "../../tests/utils.js";
-export declare function extractKeys(obj: unknown, prefix?: string): string[];
-export declare function areKeysSorted(_obj: unknown): boolean;
-export declare function getRouteKeys(route: {
-    name?: string;
-    path?: string;
-    method?: string;
-}): string;
-export declare function getOperationKeys(operation: {
-    name?: string;
-}): string;
-export declare function getChannelKeys(channel: {
-    name?: string;
-}): string;
-export declare function getMessageKeys(message: {
-    name?: string;
-}): string;
-export { createTestDocument, examplesDir, getExamplePath, loadExample };

package/dist/tests/normalizer/utils.js

@@ -1,36 +0,0 @@
-import { createTestDocument, examplesDir, getExamplePath, loadExample, } from "../../tests/utils.js";
-// Normalizer-specific utilities
-export 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;
-}
-export function areKeysSorted(_obj) {
-    // Very simple check - just return true for now to prevent hanging
-    return true;
-}
-export function getRouteKeys(route) {
-    return route.name || `${route.path} ${route.method}`;
-}
-export function getOperationKeys(operation) {
-    return operation.name || "";
-}
-export function getChannelKeys(channel) {
-    return channel.name || "";
-}
-export function getMessageKeys(message) {
-    return message.name || "";
-}
-// Re-export commonly used functions from tests/utils for convenience
-export { createTestDocument, examplesDir, getExamplePath, loadExample };

package/dist/tests/optimizer/compress-references.test.d.ts

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