@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/cjs/tests/optimizer/compress-references.test.js

@@ -0,0 +1,304 @@
+"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)("compressSchemaReferences", () => {
+    (0, node_test_1.it)("should compress JSON Pointer references", () => {
+        const doc = (0, utils_1.createDocumentWithLongReferences)();
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 1);
+        // Check that reference was compressed
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        node_assert_1.default.strictEqual(schemaRef, "TestSchema");
+    });
+    (0, node_test_1.it)("should compress hash references", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    TestSchema: {
+                        name: "TestSchema",
+                        description: "Test schema",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "#TestSchema", // Hash format
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 1);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        node_assert_1.default.strictEqual(schemaRef, "TestSchema");
+    });
+    (0, node_test_1.it)("should compress path references", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    TestSchema: {
+                        name: "TestSchema",
+                        description: "Test schema",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "path/to/TestSchema", // Path format
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 1);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        node_assert_1.default.strictEqual(schemaRef, "TestSchema");
+    });
+    (0, node_test_1.it)("should not compress already simple references", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    TestSchema: {
+                        name: "TestSchema",
+                        description: "Test schema",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "TestSchema", // Already simple
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 0);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        node_assert_1.default.strictEqual(schemaRef, "TestSchema");
+    });
+    (0, node_test_1.it)("should handle multiple references", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    TestSchema: {
+                        name: "TestSchema",
+                        description: "Test schema",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute1",
+                                method: "GET",
+                                path: "/test1",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "#/service/schemas/TestSchema",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                            {
+                                name: "testRoute2",
+                                method: "POST",
+                                path: "/test2",
+                                requestBody: {
+                                    content: {
+                                        "application/json": {
+                                            schemaRef: "#TestSchema",
+                                        },
+                                    },
+                                },
+                                responses: {
+                                    "201": {
+                                        description: "Created",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "path/to/TestSchema",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 3);
+        // Check all references were compressed
+        const routes = doc.service?.protocols?.rest?.routes || [];
+        const ref1 = routes[0]?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        const ref2 = routes[1]?.requestBody?.content?.["application/json"]?.schemaRef;
+        const ref3 = routes[1]?.responses?.["201"]?.content?.["application/json"]?.schemaRef;
+        node_assert_1.default.strictEqual(ref1, "TestSchema");
+        node_assert_1.default.strictEqual(ref2, "TestSchema");
+        node_assert_1.default.strictEqual(ref3, "TestSchema");
+    });
+    (0, node_test_1.it)("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 0);
+    });
+    (0, node_test_1.it)("should handle empty references", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 0);
+    });
+    (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 compressedCount = (0, optimization_functions_1.compressSchemaReferences)(JSON.parse(JSON.stringify(doc)));
+        // mixed-complete.json uses simple references, so nothing should be compressed
+        node_assert_1.default.strictEqual(compressedCount, 0);
+    });
+    (0, node_test_1.it)("should find references in nested structures", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    TestSchema: {
+                        name: "TestSchema",
+                        description: "Test schema",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "#/service/schemas/TestSchema",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    websocket: {
+                        channels: [
+                            {
+                                name: "testChannel",
+                                messages: [
+                                    {
+                                        name: "testMessage",
+                                        schemaRef: "#/service/schemas/TestSchema",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const compressedCount = (0, optimization_functions_1.compressSchemaReferences)(doc);
+        node_assert_1.default.strictEqual(compressedCount, 2); // One in REST response, one in WebSocket
+    });
+});

package/dist/cjs/tests/optimizer/deduplication.test.js

@@ -0,0 +1,132 @@
+"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)("deduplicateSchemas", () => {
+    (0, node_test_1.it)("should remove duplicate schemas and update references", () => {
+        const doc = (0, utils_1.createDocumentWithDuplicateSchemas)();
+        const result = (0, optimization_functions_1.deduplicateSchemas)(doc);
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 1);
+        node_assert_1.default.ok(result.removedSchemas.includes("Person") ||
+            result.removedSchemas.includes("User"));
+        node_assert_1.default.strictEqual(result.updatedReferences, 0);
+        // Check that only one of the duplicate schemas remains
+        const remainingSchemas = Object.keys(doc.service?.schemas || {});
+        node_assert_1.default.ok(remainingSchemas.includes("User") || remainingSchemas.includes("Person"));
+        node_assert_1.default.strictEqual(remainingSchemas.filter((name) => name === "User" || name === "Person")
+            .length, 1);
+        node_assert_1.default.ok(remainingSchemas.includes("Profile"));
+    });
+    (0, node_test_1.it)("should prefer referenced schema over unreferenced one", () => {
+        const doc = (0, utils_1.createDocumentWithDuplicateSchemas)();
+        // Add reference to User schema
+        if (doc.service?.protocols?.rest?.routes?.[0]) {
+            doc.service.protocols.rest.routes[0].responses = {
+                "200": {
+                    description: "Success",
+                    content: {
+                        "application/json": {
+                            schemaRef: "User",
+                        },
+                    },
+                },
+            };
+        }
+        const result = (0, optimization_functions_1.deduplicateSchemas)(doc);
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 1);
+        node_assert_1.default.ok(result.removedSchemas.includes("Person"));
+        node_assert_1.default.ok(!result.removedSchemas.includes("User"));
+        node_assert_1.default.ok(doc.service?.schemas?.User);
+        node_assert_1.default.ok(!doc.service?.schemas?.Person);
+    });
+    (0, node_test_1.it)("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const result = (0, optimization_functions_1.deduplicateSchemas)(doc);
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 0);
+        node_assert_1.default.strictEqual(result.updatedReferences, 0);
+    });
+    (0, node_test_1.it)("should handle documents without service", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const result = (0, optimization_functions_1.deduplicateSchemas)(doc);
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 0);
+        node_assert_1.default.strictEqual(result.updatedReferences, 0);
+    });
+    (0, node_test_1.it)("should handle empty schemas object", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: { name: "test", schemas: {} },
+        };
+        const result = (0, optimization_functions_1.deduplicateSchemas)(doc);
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 0);
+        node_assert_1.default.strictEqual(result.updatedReferences, 0);
+    });
+    (0, node_test_1.it)("should update schema references when removing duplicates", () => {
+        // Test case where reference points to Person (which will be kept)
+        const doc = (0, utils_1.createDocumentWithDuplicateSchemas)();
+        if (doc.service?.protocols?.rest?.routes?.[0]) {
+            doc.service.protocols.rest.routes[0].responses = {
+                "200": {
+                    description: "Success",
+                    content: {
+                        "application/json": {
+                            schemaRef: "Person", // This will be kept, User will be removed
+                        },
+                    },
+                },
+            };
+        }
+        const result = (0, optimization_functions_1.deduplicateSchemas)(doc);
+        // Should remove User (no reference update needed since Person stays)
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 1);
+        node_assert_1.default.ok(result.removedSchemas.includes("User"));
+        node_assert_1.default.strictEqual(result.updatedReferences, 0);
+        // Check that Person still exists and reference points to it
+        node_assert_1.default.ok(doc.service?.schemas?.Person);
+        node_assert_1.default.ok(!doc.service?.schemas?.User);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        node_assert_1.default.strictEqual(schemaRef, "Person");
+    });
+    (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 result = (0, optimization_functions_1.deduplicateSchemas)(JSON.parse(JSON.stringify(doc)));
+        // mixed-complete.json has no duplicates, so nothing should be removed
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 0);
+        node_assert_1.default.strictEqual(result.updatedReferences, 0);
+    });
+    (0, node_test_1.it)("should handle schemas with null jsonSchema", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    Schema1: {
+                        name: "Schema1",
+                        description: "Schema 1",
+                        jsonSchema: {},
+                    },
+                    Schema2: {
+                        name: "Schema2",
+                        description: "Schema 2",
+                        jsonSchema: {},
+                    },
+                    Schema3: {
+                        name: "Schema3",
+                        description: "Schema 3",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+            },
+        };
+        const result = (0, optimization_functions_1.deduplicateSchemas)(doc);
+        // Two schemas with empty jsonSchema should be considered duplicates
+        node_assert_1.default.strictEqual(result.removedSchemas.length, 1);
+        node_assert_1.default.strictEqual(result.updatedReferences, 0);
+        node_assert_1.default.strictEqual(Object.keys(doc.service?.schemas || {}).length, 2);
+    });
+});

package/dist/cjs/tests/optimizer/integration.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 core_1 = require("../../src/optimizer/core.js");
+const optimization_functions_1 = require("../../src/optimizer/optimization-functions.js");
+const utils_1 = require("./utils.js");
+(0, node_test_1.describe)("Optimizer Integration Tests", () => {
+    (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"));
+        // Test individual functions
+        const dedupResult = (0, optimization_functions_1.deduplicateSchemas)(JSON.parse(JSON.stringify(doc)));
+        node_assert_1.default.ok(dedupResult.removedSchemas.length >= 0);
+        const orphanedResult = (0, optimization_functions_1.removeOrphanedSchemas)(JSON.parse(JSON.stringify(doc)));
+        node_assert_1.default.ok(orphanedResult.length >= 0);
+        const sortResult = (0, optimization_functions_1.sortSchemas)(JSON.parse(JSON.stringify(doc)));
+        node_assert_1.default.ok(sortResult >= 0);
+        const compressResult = (0, optimization_functions_1.compressSchemaReferences)(JSON.parse(JSON.stringify(doc)));
+        node_assert_1.default.ok(compressResult >= 0);
+        // Test optimizeDocument
+        const optimizeResult = (0, core_1.optimizeDocument)(JSON.parse(JSON.stringify(doc)));
+        node_assert_1.default.ok(optimizeResult.document);
+        node_assert_1.default.ok(optimizeResult.statistics);
+        node_assert_1.default.ok(Array.isArray(optimizeResult.changes));
+        // Test generateOptimizationReport
+        const report = (0, core_1.generateOptimizationReport)(JSON.parse(JSON.stringify(doc)));
+        node_assert_1.default.ok(report.recommendations);
+        node_assert_1.default.ok(report.potentialSavings);
+    });
+    (0, node_test_1.it)("should handle edge cases gracefully", () => {
+        // Empty document
+        const emptyDoc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const optimizeResult = (0, core_1.optimizeDocument)(emptyDoc);
+        node_assert_1.default.strictEqual(optimizeResult.statistics.originalSchemas, 0);
+        node_assert_1.default.strictEqual(optimizeResult.statistics.optimizedSchemas, 0);
+        const report = (0, core_1.generateOptimizationReport)(emptyDoc);
+        node_assert_1.default.strictEqual(report.recommendations.length, 0);
+        node_assert_1.default.strictEqual(report.potentialSavings.schemaReduction, 0);
+    });
+    (0, node_test_1.it)("should preserve document integrity", () => {
+        const doc = (0, utils_1.loadExample)((0, utils_1.getExamplePath)("valid", "spec", "rest-simple.json"));
+        const result = (0, core_1.optimizeDocument)(JSON.parse(JSON.stringify(doc)));
+        // Should preserve required fields
+        node_assert_1.default.strictEqual(result.document.unispecVersion, doc.unispecVersion);
+        node_assert_1.default.strictEqual(result.document.service?.name, doc.service?.name);
+        node_assert_1.default.ok(result.document.service?.protocols);
+        node_assert_1.default.ok(result.document.service?.schemas);
+    });
+    (0, node_test_1.it)("should handle complex optimization scenarios", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    // Duplicate schemas
+                    User: {
+                        description: "User schema",
+                        jsonSchema: {
+                            type: "object",
+                            properties: { id: { type: "string" } },
+                        },
+                    },
+                    Person: {
+                        description: "Person schema",
+                        jsonSchema: {
+                            type: "object",
+                            properties: { id: { type: "string" } },
+                        },
+                    },
+                    // Orphaned schema
+                    Orphaned: {
+                        description: "Orphaned schema",
+                        jsonSchema: { type: "string" },
+                    },
+                    // Referenced schema
+                    Profile: {
+                        description: "Profile schema",
+                        jsonSchema: {
+                            type: "object",
+                            properties: { profileId: { type: "string" } },
+                        },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "#/service/schemas/Person", // Long reference to duplicate
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const result = (0, core_1.optimizeDocument)(doc, {
+            dedupeSchemas: true,
+            sortSchemas: true,
+            removeUnusedSchemas: true,
+            compressReferences: true,
+        });
+        // Should optimize correctly
+        node_assert_1.default.strictEqual(result.statistics.originalSchemas, 4);
+        node_assert_1.default.strictEqual(result.statistics.optimizedSchemas, 1); // Person (Profile is orphaned)
+        node_assert_1.default.strictEqual(result.statistics.removedSchemas, 3); // User + Orphaned + Profile
+        node_assert_1.default.strictEqual(result.statistics.deduplicatedSchemas, 1);
+        // Should have changes recorded
+        node_assert_1.default.ok(result.changes.length >= 3);
+        // Check final state
+        const schemas = Object.keys(result.document.service?.schemas || {});
+        node_assert_1.default.deepStrictEqual(schemas, ["Person"]); // Only Person remains
+        // Check reference was updated and compressed
+        const route = result.document.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        node_assert_1.default.strictEqual(schemaRef, "Person");
+    });
+});