@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/tests/optimizer/sort-schemas.test.js

@@ -0,0 +1,126 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { sortSchemas } from "../../src/optimizer/optimization-functions.js";
+import { createDocumentWithUnsortedSchemas, getExamplePath, loadExample, } from "./utils.js";
+describe("sortSchemas", () => {
+    it("should sort schemas alphabetically", () => {
+        const doc = createDocumentWithUnsortedSchemas();
+        const sortedCount = sortSchemas(doc);
+        assert.strictEqual(sortedCount, 3);
+        const schemaNames = Object.keys(doc.service?.schemas || {});
+        assert.deepStrictEqual(schemaNames, ["Alpha", "Beta", "Zebra"]);
+    });
+    it("should return 0 for empty schemas", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: { name: "test", schemas: {} },
+        };
+        const sortedCount = sortSchemas(doc);
+        assert.strictEqual(sortedCount, 0);
+    });
+    it("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const sortedCount = sortSchemas(doc);
+        assert.strictEqual(sortedCount, 0);
+    });
+    it("should handle documents without service", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const sortedCount = sortSchemas(doc);
+        assert.strictEqual(sortedCount, 0);
+    });
+    it("should preserve schema content while sorting", () => {
+        const doc = createDocumentWithUnsortedSchemas();
+        sortSchemas(doc);
+        const schemas = doc.service?.schemas || {};
+        assert.strictEqual(schemas.Alpha.description, "Alpha schema");
+        assert.strictEqual(schemas.Beta.description, "Beta schema");
+        assert.strictEqual(schemas.Zebra.description, "Zebra schema");
+    });
+    it("should handle already sorted schemas", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    Alpha: {
+                        name: "Alpha",
+                        description: "Alpha schema",
+                        jsonSchema: { type: "string" },
+                    },
+                    Beta: {
+                        name: "Beta",
+                        description: "Beta schema",
+                        jsonSchema: { type: "number" },
+                    },
+                    Zebra: {
+                        name: "Zebra",
+                        description: "Zebra schema",
+                        jsonSchema: { type: "boolean" },
+                    },
+                },
+            },
+        };
+        const sortedCount = sortSchemas(doc);
+        assert.strictEqual(sortedCount, 3);
+        const schemaNames = Object.keys(doc.service?.schemas || {});
+        assert.deepStrictEqual(schemaNames, ["Alpha", "Beta", "Zebra"]);
+    });
+    it("should handle single schema", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    SingleSchema: {
+                        name: "SingleSchema",
+                        description: "Single schema",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+            },
+        };
+        const sortedCount = sortSchemas(doc);
+        assert.strictEqual(sortedCount, 1);
+        const schemaNames = Object.keys(doc.service?.schemas || {});
+        assert.deepStrictEqual(schemaNames, ["SingleSchema"]);
+    });
+    it("should work with real examples from node_modules", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        const sortedCount = sortSchemas(JSON.parse(JSON.stringify(doc)));
+        // mixed-complete.json has 2 schemas
+        assert.strictEqual(sortedCount, 2);
+        // Check that schemas are sorted
+        const schemaNames = Object.keys(doc.service?.schemas || {});
+        const sortedSchemaNames = [...schemaNames].sort();
+        assert.deepStrictEqual(schemaNames, sortedSchemaNames);
+    });
+    it("should handle case-sensitive sorting", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    zebra: {
+                        name: "zebra",
+                        description: "lowercase zebra",
+                        jsonSchema: { type: "string" },
+                    },
+                    Alpha: {
+                        name: "Alpha",
+                        description: "uppercase Alpha",
+                        jsonSchema: { type: "string" },
+                    },
+                    beta: {
+                        name: "beta",
+                        description: "lowercase beta",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+            },
+        };
+        sortSchemas(doc);
+        const schemaNames = Object.keys(doc.service?.schemas || {});
+        // Default JavaScript sort is case-sensitive: uppercase letters come before lowercase
+        assert.deepStrictEqual(schemaNames, ["Alpha", "beta", "zebra"]);
+    });
+});

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

@@ -0,0 +1,8 @@
+import { createTestDocument, examplesDir, getExamplePath, loadExample } from "../../tests/utils.js";
+import type { UniSpecDocument, UniSpecSchemaDefinition } from "../../src/types/index.js";
+export declare function createTestDocumentWithSchemas(schemas?: Record<string, UniSpecSchemaDefinition>, overrides?: Partial<UniSpecDocument>): UniSpecDocument;
+export declare function createDocumentWithDuplicateSchemas(): UniSpecDocument;
+export declare function createDocumentWithOrphanedSchemas(): UniSpecDocument;
+export declare function createDocumentWithUnsortedSchemas(): UniSpecDocument;
+export declare function createDocumentWithLongReferences(): UniSpecDocument;
+export { createTestDocument, examplesDir, getExamplePath, loadExample };

package/dist/tests/optimizer/utils.js

@@ -0,0 +1,199 @@
+import { createTestDocument, examplesDir, getExamplePath, loadExample, } from "../../tests/utils.js";
+// Optimizer-specific utilities
+export function createTestDocumentWithSchemas(schemas = {}, overrides = {}) {
+    const base = {
+        unispecVersion: "1.0.0",
+        service: {
+            name: "test-service",
+            description: "Test service description",
+            protocols: {
+                rest: {
+                    routes: [
+                        {
+                            name: "testRoute",
+                            summary: "Test route",
+                            path: "/test",
+                            method: "GET",
+                            responses: {
+                                "200": { description: "Success" },
+                            },
+                        },
+                    ],
+                },
+            },
+            schemas,
+        },
+    };
+    // Deep merge overrides
+    return mergeDeep(base, overrides);
+}
+export function createDocumentWithDuplicateSchemas() {
+    const duplicateSchema = {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+        },
+        required: ["id", "name"],
+    };
+    return createTestDocumentWithSchemas({
+        User: {
+            description: "User schema",
+            jsonSchema: duplicateSchema,
+        },
+        Person: {
+            description: "Person schema",
+            jsonSchema: duplicateSchema,
+        },
+        Profile: {
+            description: "Profile schema",
+            jsonSchema: {
+                type: "object",
+                properties: {
+                    profileId: { type: "string" },
+                    title: { type: "string" },
+                },
+                required: ["profileId", "title"],
+            },
+        },
+    }, {
+        service: {
+            name: "test-service",
+            protocols: {
+                rest: {
+                    routes: [
+                        {
+                            name: "userRoute",
+                            method: "GET",
+                            path: "/users",
+                            responses: {
+                                "200": {
+                                    description: "Success",
+                                    content: {
+                                        "application/json": {
+                                            schemaRef: "User",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    });
+}
+export function createDocumentWithOrphanedSchemas() {
+    return createTestDocumentWithSchemas({
+        UsedSchema: {
+            description: "Used schema",
+            jsonSchema: {
+                type: "object",
+                properties: { id: { type: "string" } },
+                required: ["id"],
+            },
+        },
+        OrphanedSchema1: {
+            description: "Orphaned schema 1",
+            jsonSchema: { type: "string" },
+        },
+        OrphanedSchema2: {
+            description: "Orphaned schema 2",
+            jsonSchema: { type: "number" },
+        },
+    }, {
+        service: {
+            name: "test-service",
+            protocols: {
+                rest: {
+                    routes: [
+                        {
+                            name: "testRoute",
+                            summary: "Test route",
+                            path: "/test",
+                            method: "GET",
+                            responses: {
+                                "200": {
+                                    description: "Success",
+                                    content: {
+                                        "application/json": {
+                                            schemaRef: "UsedSchema",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    });
+}
+export function createDocumentWithUnsortedSchemas() {
+    return createTestDocumentWithSchemas({
+        Zebra: {
+            description: "Zebra schema",
+            jsonSchema: { type: "string" },
+        },
+        Alpha: {
+            description: "Alpha schema",
+            jsonSchema: { type: "number" },
+        },
+        Beta: {
+            description: "Beta schema",
+            jsonSchema: { type: "boolean" },
+        },
+    });
+}
+export function createDocumentWithLongReferences() {
+    return createTestDocumentWithSchemas({
+        TestSchema: {
+            description: "Test schema",
+            jsonSchema: { type: "string" },
+        },
+    }, {
+        service: {
+            name: "test-service",
+            protocols: {
+                rest: {
+                    routes: [
+                        {
+                            name: "testRoute",
+                            summary: "Test route",
+                            path: "/test",
+                            method: "GET",
+                            responses: {
+                                "200": {
+                                    description: "Success",
+                                    content: {
+                                        "application/json": {
+                                            schemaRef: "#/service/schemas/TestSchema",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    });
+}
+function mergeDeep(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (source[key] !== undefined) {
+            if (typeof source[key] === "object" &&
+                source[key] !== null &&
+                !Array.isArray(source[key])) {
+                result[key] = mergeDeep(result[key], source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+    }
+    return result;
+}
+// Re-export commonly used functions from tests/utils for convenience
+export { createTestDocument, examplesDir, getExamplePath, loadExample };

package/dist/tests/schemas/schemas-edge-cases.test.d.ts

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

package/dist/tests/schemas/schemas-edge-cases.test.js

@@ -0,0 +1,218 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { dedupeSchemas, resolveSchemaRef } from "../../src/schemas/index.js";
+import { normalizeSchemaRef } from "../../src/schemas/utils.js";
+import { getExamplePath, loadExample } from "./utils.js";
+describe("schemas module - edge cases and invalid examples", () => {
+    describe("resolveSchemaRef with invalid examples", () => {
+        it("should handle documents without schemas gracefully", () => {
+            const doc = loadExample(getExamplePath("invalid", "spec", "missing-unispec-version.json"));
+            // Should not throw even with invalid documents
+            const schema = resolveSchemaRef(doc, "AnySchema");
+            assert.strictEqual(schema, undefined);
+        });
+        it("should handle malformed schema references", () => {
+            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+            // Test various malformed references
+            assert.strictEqual(resolveSchemaRef(doc, ""), undefined);
+            assert.strictEqual(resolveSchemaRef(doc, "   "), undefined);
+            assert.strictEqual(resolveSchemaRef(doc, "#"), undefined);
+            assert.strictEqual(resolveSchemaRef(doc, "#/"), undefined);
+            assert.strictEqual(resolveSchemaRef(doc, "#/service/schemas/"), undefined);
+        });
+        it("should handle deeply nested JSON pointers", () => {
+            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+            // Test deeply nested pointer that doesn't exist
+            const schema = resolveSchemaRef(doc, "#/service/schemas/nonexistent/deep/nested/schema");
+            assert.strictEqual(schema, undefined);
+        });
+        it("should handle special characters in schema names", () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Testing edge cases with special characters
+            const doc = {
+                service: {
+                    schemas: {
+                        "schema-with-dashes": { jsonSchema: { type: "string" } },
+                        "schema_with_underscores": { jsonSchema: { type: "number" } },
+                        "schema.with.dots": { jsonSchema: { type: "boolean" } },
+                        "schema with spaces": { jsonSchema: { type: "array" } },
+                    },
+                },
+            };
+            assert.ok(resolveSchemaRef(doc, "schema-with-dashes"));
+            assert.ok(resolveSchemaRef(doc, "schema_with_underscores"));
+            assert.ok(resolveSchemaRef(doc, "schema.with.dots"));
+            assert.ok(resolveSchemaRef(doc, "schema with spaces"));
+        });
+    });
+    describe("dedupeSchemas with complex scenarios", () => {
+        it("should handle circular references safely", () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Testing edge cases with circular references
+            const doc = {
+                service: {
+                    schemas: {
+                        SchemaA: {
+                            jsonSchema: {
+                                type: "object",
+                                properties: {
+                                    ref: { $ref: "#/service/schemas/SchemaB" },
+                                },
+                            },
+                        },
+                        SchemaB: {
+                            jsonSchema: {
+                                type: "object",
+                                properties: {
+                                    ref: { $ref: "#/service/schemas/SchemaA" },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            // Should not throw with circular references
+            dedupeSchemas(doc);
+            // Both schemas should remain since they have different content
+            assert.strictEqual(Object.keys(doc.service.schemas).length, 2);
+        });
+        it("should preserve schema order during deduplication", () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Testing edge cases with schema ordering
+            const doc = {
+                service: {
+                    schemas: {
+                        ThirdSchema: { jsonSchema: { type: "string" } },
+                        FirstSchema: { jsonSchema: { type: "string" } },
+                        SecondSchema: { jsonSchema: { type: "number" } },
+                    },
+                },
+            };
+            dedupeSchemas(doc);
+            // Should deduplicate one of the string schemas and keep the number schema
+            const remainingSchemas = Object.keys(doc.service.schemas);
+            assert.strictEqual(remainingSchemas.length, 2);
+            assert.ok(remainingSchemas.includes("SecondSchema")); // Number schema should remain
+            assert.ok(remainingSchemas.includes("FirstSchema") ||
+                remainingSchemas.includes("ThirdSchema")); // One string schema should remain
+        });
+        it("should handle null and undefined schemas", () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Testing edge cases with null/undefined schemas
+            const doc = {
+                service: {
+                    schemas: {
+                        NullSchema: null,
+                        UndefinedSchema: undefined,
+                        ValidSchema: { jsonSchema: { type: "string" } },
+                    },
+                },
+            };
+            // Should not throw
+            dedupeSchemas(doc);
+            // Should handle null/undefined gracefully
+            assert.ok(doc.service.schemas.ValidSchema);
+        });
+        it("should handle empty schema objects", () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Testing edge cases with empty schemas
+            const doc = {
+                service: {
+                    schemas: {
+                        EmptySchema1: {},
+                        EmptySchema2: {},
+                        ValidSchema: { jsonSchema: { type: "string" } },
+                    },
+                },
+            };
+            dedupeSchemas(doc);
+            // Should deduplicate empty schemas
+            const schemas = Object.keys(doc.service.schemas);
+            assert.strictEqual(schemas.length, 2);
+            assert.ok(schemas.includes("ValidSchema"));
+            assert.ok(schemas.includes("EmptySchema1") || schemas.includes("EmptySchema2"));
+        });
+    });
+    describe("normalizeSchemaRef edge cases", () => {
+        it("should handle Unicode characters", () => {
+            assert.strictEqual(normalizeSchemaRef("Схема"), "Схема");
+            assert.strictEqual(normalizeSchemaRef("#/service/schemas/Схема"), "Схема");
+            assert.strictEqual(normalizeSchemaRef("#Схема"), "Схема");
+        });
+        it("should handle very long schema names", () => {
+            const longName = "a".repeat(1000);
+            assert.strictEqual(normalizeSchemaRef(longName), longName);
+            assert.strictEqual(normalizeSchemaRef(`#/service/schemas/${longName}`), longName);
+        });
+        it("should handle JSON pointer encoding", () => {
+            assert.strictEqual(normalizeSchemaRef("#/service/schemas/schema~0name"), "schema~0name");
+            assert.strictEqual(normalizeSchemaRef("#/service/schemas/schema~1name"), "schema~1name");
+            assert.strictEqual(normalizeSchemaRef("#/service/schemas/schema/name"), "name");
+        });
+    });
+    describe("integration with invalid examples", () => {
+        it("should not crash on completely invalid documents", () => {
+            const invalidDocs = [
+                { invalid: "structure" },
+                {},
+                { service: null },
+                { service: { schemas: "not an object" } },
+            ];
+            for (const doc of invalidDocs) {
+                // Should not throw
+                assert.doesNotThrow(() => {
+                    // biome-ignore lint/suspicious/noExplicitAny: Testing invalid document structures
+                    resolveSchemaRef(doc, "test");
+                    // biome-ignore lint/suspicious/noExplicitAny: Testing invalid document structures
+                    dedupeSchemas(doc);
+                });
+            }
+            // null and undefined should be handled by resolveSchemaRef
+            // biome-ignore lint/suspicious/noExplicitAny: Testing null input handling
+            assert.strictEqual(resolveSchemaRef(null, "test"), undefined);
+            // biome-ignore lint/suspicious/noExplicitAny: Testing undefined input handling
+            assert.strictEqual(resolveSchemaRef(undefined, "test"), undefined);
+        });
+        it("should handle documents with missing required fields", () => {
+            const doc = loadExample(getExamplePath("invalid", "spec", "missing-service-name.json"));
+            // Should handle gracefully
+            const schema = resolveSchemaRef(doc, "anything");
+            assert.strictEqual(schema, undefined);
+            // Should not throw
+            assert.doesNotThrow(() => dedupeSchemas(doc));
+        });
+    });
+    describe("performance and memory", () => {
+        it("should handle large numbers of schemas efficiently", () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Testing performance with large schema sets
+            const doc = {
+                service: {
+                    schemas: {},
+                },
+            };
+            // Create 100 schemas with some duplicates (10 unique types, each repeated 10 times)
+            const schemaTypes = [
+                { type: "string" },
+                { type: "number" },
+                { type: "boolean" },
+                { type: "array" },
+                { type: "object" },
+                { type: "null" },
+                { type: "string", format: "date" },
+                { type: "string", format: "email" },
+                { type: "integer" },
+                { type: "number", format: "float" },
+            ];
+            let schemaIndex = 0;
+            for (let i = 0; i < 10; i++) {
+                for (let j = 0; j < schemaTypes.length; j++) {
+                    doc.service.schemas[`Schema${schemaIndex++}`] = {
+                        jsonSchema: schemaTypes[j],
+                    };
+                }
+            }
+            const startTime = Date.now();
+            dedupeSchemas(doc);
+            const endTime = Date.now();
+            // Should complete in reasonable time (less than 1 second)
+            assert.ok(endTime - startTime < 1000);
+            // Should deduplicate to only 10 unique schemas
+            assert.strictEqual(Object.keys(doc.service.schemas).length, 10);
+        });
+    });
+});

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

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