@unispechq/unispec-core 0.3.0 → 0.3.2

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

@@ -0,0 +1,299 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { compressSchemaReferences } from "../../src/optimizer/optimization-functions.js";
+import { createDocumentWithLongReferences, getExamplePath, loadExample, } from "./utils.js";
+describe("compressSchemaReferences", () => {
+    it("should compress JSON Pointer references", () => {
+        const doc = createDocumentWithLongReferences();
+        const compressedCount = compressSchemaReferences(doc);
+        assert.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;
+        assert.strictEqual(schemaRef, "TestSchema");
+    });
+    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 = compressSchemaReferences(doc);
+        assert.strictEqual(compressedCount, 1);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        assert.strictEqual(schemaRef, "TestSchema");
+    });
+    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 = compressSchemaReferences(doc);
+        assert.strictEqual(compressedCount, 1);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        assert.strictEqual(schemaRef, "TestSchema");
+    });
+    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 = compressSchemaReferences(doc);
+        assert.strictEqual(compressedCount, 0);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        assert.strictEqual(schemaRef, "TestSchema");
+    });
+    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 = compressSchemaReferences(doc);
+        assert.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;
+        assert.strictEqual(ref1, "TestSchema");
+        assert.strictEqual(ref2, "TestSchema");
+        assert.strictEqual(ref3, "TestSchema");
+    });
+    it("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const compressedCount = compressSchemaReferences(doc);
+        assert.strictEqual(compressedCount, 0);
+    });
+    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 = compressSchemaReferences(doc);
+        assert.strictEqual(compressedCount, 0);
+    });
+    it("should work with real examples from node_modules", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        const compressedCount = compressSchemaReferences(JSON.parse(JSON.stringify(doc)));
+        // mixed-complete.json uses simple references, so nothing should be compressed
+        assert.strictEqual(compressedCount, 0);
+    });
+    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 = compressSchemaReferences(doc);
+        assert.strictEqual(compressedCount, 2); // One in REST response, one in WebSocket
+    });
+});

package/dist/tests/optimizer/deduplication.test.d.ts

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

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

@@ -0,0 +1,127 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { deduplicateSchemas } from "../../src/optimizer/optimization-functions.js";
+import { createDocumentWithDuplicateSchemas, getExamplePath, loadExample, } from "./utils.js";
+describe("deduplicateSchemas", () => {
+    it("should remove duplicate schemas and update references", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        const result = deduplicateSchemas(doc);
+        assert.strictEqual(result.removedSchemas.length, 1);
+        assert.ok(result.removedSchemas.includes("Person") ||
+            result.removedSchemas.includes("User"));
+        assert.strictEqual(result.updatedReferences, 0);
+        // Check that only one of the duplicate schemas remains
+        const remainingSchemas = Object.keys(doc.service?.schemas || {});
+        assert.ok(remainingSchemas.includes("User") || remainingSchemas.includes("Person"));
+        assert.strictEqual(remainingSchemas.filter((name) => name === "User" || name === "Person")
+            .length, 1);
+        assert.ok(remainingSchemas.includes("Profile"));
+    });
+    it("should prefer referenced schema over unreferenced one", () => {
+        const doc = 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 = deduplicateSchemas(doc);
+        assert.strictEqual(result.removedSchemas.length, 1);
+        assert.ok(result.removedSchemas.includes("Person"));
+        assert.ok(!result.removedSchemas.includes("User"));
+        assert.ok(doc.service?.schemas?.User);
+        assert.ok(!doc.service?.schemas?.Person);
+    });
+    it("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const result = deduplicateSchemas(doc);
+        assert.strictEqual(result.removedSchemas.length, 0);
+        assert.strictEqual(result.updatedReferences, 0);
+    });
+    it("should handle documents without service", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const result = deduplicateSchemas(doc);
+        assert.strictEqual(result.removedSchemas.length, 0);
+        assert.strictEqual(result.updatedReferences, 0);
+    });
+    it("should handle empty schemas object", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: { name: "test", schemas: {} },
+        };
+        const result = deduplicateSchemas(doc);
+        assert.strictEqual(result.removedSchemas.length, 0);
+        assert.strictEqual(result.updatedReferences, 0);
+    });
+    it("should update schema references when removing duplicates", () => {
+        // Test case where reference points to Person (which will be kept)
+        const doc = 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 = deduplicateSchemas(doc);
+        // Should remove User (no reference update needed since Person stays)
+        assert.strictEqual(result.removedSchemas.length, 1);
+        assert.ok(result.removedSchemas.includes("User"));
+        assert.strictEqual(result.updatedReferences, 0);
+        // Check that Person still exists and reference points to it
+        assert.ok(doc.service?.schemas?.Person);
+        assert.ok(!doc.service?.schemas?.User);
+        const route = doc.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        assert.strictEqual(schemaRef, "Person");
+    });
+    it("should work with real examples from node_modules", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        const result = deduplicateSchemas(JSON.parse(JSON.stringify(doc)));
+        // mixed-complete.json has no duplicates, so nothing should be removed
+        assert.strictEqual(result.removedSchemas.length, 0);
+        assert.strictEqual(result.updatedReferences, 0);
+    });
+    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 = deduplicateSchemas(doc);
+        // Two schemas with empty jsonSchema should be considered duplicates
+        assert.strictEqual(result.removedSchemas.length, 1);
+        assert.strictEqual(result.updatedReferences, 0);
+        assert.strictEqual(Object.keys(doc.service?.schemas || {}).length, 2);
+    });
+});

package/dist/tests/optimizer/integration.test.d.ts

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

package/dist/tests/optimizer/integration.test.js

@@ -0,0 +1,126 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { generateOptimizationReport, optimizeDocument } from "../../src/optimizer/core.js";
+import { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "../../src/optimizer/optimization-functions.js";
+import { getExamplePath, loadExample } from "./utils.js";
+describe("Optimizer Integration Tests", () => {
+    it("should work with real examples from node_modules", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        // Test individual functions
+        const dedupResult = deduplicateSchemas(JSON.parse(JSON.stringify(doc)));
+        assert.ok(dedupResult.removedSchemas.length >= 0);
+        const orphanedResult = removeOrphanedSchemas(JSON.parse(JSON.stringify(doc)));
+        assert.ok(orphanedResult.length >= 0);
+        const sortResult = sortSchemas(JSON.parse(JSON.stringify(doc)));
+        assert.ok(sortResult >= 0);
+        const compressResult = compressSchemaReferences(JSON.parse(JSON.stringify(doc)));
+        assert.ok(compressResult >= 0);
+        // Test optimizeDocument
+        const optimizeResult = optimizeDocument(JSON.parse(JSON.stringify(doc)));
+        assert.ok(optimizeResult.document);
+        assert.ok(optimizeResult.statistics);
+        assert.ok(Array.isArray(optimizeResult.changes));
+        // Test generateOptimizationReport
+        const report = generateOptimizationReport(JSON.parse(JSON.stringify(doc)));
+        assert.ok(report.recommendations);
+        assert.ok(report.potentialSavings);
+    });
+    it("should handle edge cases gracefully", () => {
+        // Empty document
+        const emptyDoc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const optimizeResult = optimizeDocument(emptyDoc);
+        assert.strictEqual(optimizeResult.statistics.originalSchemas, 0);
+        assert.strictEqual(optimizeResult.statistics.optimizedSchemas, 0);
+        const report = generateOptimizationReport(emptyDoc);
+        assert.strictEqual(report.recommendations.length, 0);
+        assert.strictEqual(report.potentialSavings.schemaReduction, 0);
+    });
+    it("should preserve document integrity", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "rest-simple.json"));
+        const result = optimizeDocument(JSON.parse(JSON.stringify(doc)));
+        // Should preserve required fields
+        assert.strictEqual(result.document.unispecVersion, doc.unispecVersion);
+        assert.strictEqual(result.document.service?.name, doc.service?.name);
+        assert.ok(result.document.service?.protocols);
+        assert.ok(result.document.service?.schemas);
+    });
+    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 = optimizeDocument(doc, {
+            dedupeSchemas: true,
+            sortSchemas: true,
+            removeUnusedSchemas: true,
+            compressReferences: true,
+        });
+        // Should optimize correctly
+        assert.strictEqual(result.statistics.originalSchemas, 4);
+        assert.strictEqual(result.statistics.optimizedSchemas, 1); // Person (Profile is orphaned)
+        assert.strictEqual(result.statistics.removedSchemas, 3); // User + Orphaned + Profile
+        assert.strictEqual(result.statistics.deduplicatedSchemas, 1);
+        // Should have changes recorded
+        assert.ok(result.changes.length >= 3);
+        // Check final state
+        const schemas = Object.keys(result.document.service?.schemas || {});
+        assert.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;
+        assert.strictEqual(schemaRef, "Person");
+    });
+});

package/dist/tests/optimizer/optimization-report.test.d.ts

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