@unispechq/unispec-core 0.3.2 → 0.3.4

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

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

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

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

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

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

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

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