@unispechq/unispec-core 0.3.0 → 0.3.2

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

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

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

@@ -0,0 +1,223 @@
+"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);
+        });
+    });
+});