@unispechq/unispec-core 0.3.2 → 0.3.4

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

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

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

@@ -1,209 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadExample = exports.getExamplePath = exports.examplesDir = exports.createTestDocument = void 0;
-exports.createTestDocumentWithSchemas = createTestDocumentWithSchemas;
-exports.createDocumentWithDuplicateSchemas = createDocumentWithDuplicateSchemas;
-exports.createDocumentWithOrphanedSchemas = createDocumentWithOrphanedSchemas;
-exports.createDocumentWithUnsortedSchemas = createDocumentWithUnsortedSchemas;
-exports.createDocumentWithLongReferences = createDocumentWithLongReferences;
-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; } });
-// Optimizer-specific utilities
-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);
-}
-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",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-            },
-        },
-    });
-}
-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",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-            },
-        },
-    });
-}
-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" },
-        },
-    });
-}
-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;
-}

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

@@ -1,223 +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_test_1 = require("node:test");
-const schemas_1 = require("../../src/schemas/index.js");
-const utils_1 = require("../../src/schemas/utils.js");
-const utils_2 = require("./utils.js");
-(0, node_test_1.describe)("schemas module - edge cases and invalid examples", () => {
-    (0, node_test_1.describe)("resolveSchemaRef with invalid examples", () => {
-        (0, node_test_1.it)("should handle documents without schemas gracefully", () => {
-            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("invalid", "spec", "missing-unispec-version.json"));
-            // Should not throw even with invalid documents
-            const schema = (0, schemas_1.resolveSchemaRef)(doc, "AnySchema");
-            node_assert_1.default.strictEqual(schema, undefined);
-        });
-        (0, node_test_1.it)("should handle malformed schema references", () => {
-            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
-            // Test various malformed references
-            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(doc, ""), undefined);
-            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(doc, "   "), undefined);
-            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(doc, "#"), undefined);
-            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(doc, "#/"), undefined);
-            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(doc, "#/service/schemas/"), undefined);
-        });
-        (0, node_test_1.it)("should handle deeply nested JSON pointers", () => {
-            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
-            // Test deeply nested pointer that doesn't exist
-            const schema = (0, schemas_1.resolveSchemaRef)(doc, "#/service/schemas/nonexistent/deep/nested/schema");
-            node_assert_1.default.strictEqual(schema, undefined);
-        });
-        (0, node_test_1.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" } },
-                    },
-                },
-            };
-            node_assert_1.default.ok((0, schemas_1.resolveSchemaRef)(doc, "schema-with-dashes"));
-            node_assert_1.default.ok((0, schemas_1.resolveSchemaRef)(doc, "schema_with_underscores"));
-            node_assert_1.default.ok((0, schemas_1.resolveSchemaRef)(doc, "schema.with.dots"));
-            node_assert_1.default.ok((0, schemas_1.resolveSchemaRef)(doc, "schema with spaces"));
-        });
-    });
-    (0, node_test_1.describe)("dedupeSchemas with complex scenarios", () => {
-        (0, node_test_1.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
-            (0, schemas_1.dedupeSchemas)(doc);
-            // Both schemas should remain since they have different content
-            node_assert_1.default.strictEqual(Object.keys(doc.service.schemas).length, 2);
-        });
-        (0, node_test_1.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" } },
-                    },
-                },
-            };
-            (0, schemas_1.dedupeSchemas)(doc);
-            // Should deduplicate one of the string schemas and keep the number schema
-            const remainingSchemas = Object.keys(doc.service.schemas);
-            node_assert_1.default.strictEqual(remainingSchemas.length, 2);
-            node_assert_1.default.ok(remainingSchemas.includes("SecondSchema")); // Number schema should remain
-            node_assert_1.default.ok(remainingSchemas.includes("FirstSchema") ||
-                remainingSchemas.includes("ThirdSchema")); // One string schema should remain
-        });
-        (0, node_test_1.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
-            (0, schemas_1.dedupeSchemas)(doc);
-            // Should handle null/undefined gracefully
-            node_assert_1.default.ok(doc.service.schemas.ValidSchema);
-        });
-        (0, node_test_1.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" } },
-                    },
-                },
-            };
-            (0, schemas_1.dedupeSchemas)(doc);
-            // Should deduplicate empty schemas
-            const schemas = Object.keys(doc.service.schemas);
-            node_assert_1.default.strictEqual(schemas.length, 2);
-            node_assert_1.default.ok(schemas.includes("ValidSchema"));
-            node_assert_1.default.ok(schemas.includes("EmptySchema1") || schemas.includes("EmptySchema2"));
-        });
-    });
-    (0, node_test_1.describe)("normalizeSchemaRef edge cases", () => {
-        (0, node_test_1.it)("should handle Unicode characters", () => {
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("Схема"), "Схема");
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#/service/schemas/Схема"), "Схема");
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#Схема"), "Схема");
-        });
-        (0, node_test_1.it)("should handle very long schema names", () => {
-            const longName = "a".repeat(1000);
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)(longName), longName);
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)(`#/service/schemas/${longName}`), longName);
-        });
-        (0, node_test_1.it)("should handle JSON pointer encoding", () => {
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#/service/schemas/schema~0name"), "schema~0name");
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#/service/schemas/schema~1name"), "schema~1name");
-            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#/service/schemas/schema/name"), "name");
-        });
-    });
-    (0, node_test_1.describe)("integration with invalid examples", () => {
-        (0, node_test_1.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
-                node_assert_1.default.doesNotThrow(() => {
-                    // biome-ignore lint/suspicious/noExplicitAny: Testing invalid document structures
-                    (0, schemas_1.resolveSchemaRef)(doc, "test");
-                    // biome-ignore lint/suspicious/noExplicitAny: Testing invalid document structures
-                    (0, schemas_1.dedupeSchemas)(doc);
-                });
-            }
-            // null and undefined should be handled by resolveSchemaRef
-            // biome-ignore lint/suspicious/noExplicitAny: Testing null input handling
-            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(null, "test"), undefined);
-            // biome-ignore lint/suspicious/noExplicitAny: Testing undefined input handling
-            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(undefined, "test"), undefined);
-        });
-        (0, node_test_1.it)("should handle documents with missing required fields", () => {
-            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("invalid", "spec", "missing-service-name.json"));
-            // Should handle gracefully
-            const schema = (0, schemas_1.resolveSchemaRef)(doc, "anything");
-            node_assert_1.default.strictEqual(schema, undefined);
-            // Should not throw
-            node_assert_1.default.doesNotThrow(() => (0, schemas_1.dedupeSchemas)(doc));
-        });
-    });
-    (0, node_test_1.describe)("performance and memory", () => {
-        (0, node_test_1.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();
-            (0, schemas_1.dedupeSchemas)(doc);
-            const endTime = Date.now();
-            // Should complete in reasonable time (less than 1 second)
-            node_assert_1.default.ok(endTime - startTime < 1000);
-            // Should deduplicate to only 10 unique schemas
-            node_assert_1.default.strictEqual(Object.keys(doc.service.schemas).length, 10);
-        });
-    });
-});