@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/tests/optimizer/optimization-report.test.js

@@ -0,0 +1,217 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { generateOptimizationReport } from "../../src/optimizer/core.js";
+import { createDocumentWithDuplicateSchemas, createDocumentWithOrphanedSchemas, getExamplePath, loadExample, } from "./utils.js";
+describe("generateOptimizationReport", () => {
+    it("should generate report for document with duplicates", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        const report = generateOptimizationReport(doc);
+        // Check properties exist using if statements
+        if (!report.recommendations) {
+            throw new Error("recommendations should exist");
+        }
+        if (!report.potentialSavings) {
+            throw new Error("potentialSavings should exist");
+        }
+        // Should recommend deduplication
+        const dedupRecommendation = report.recommendations.find((rec) => rec.includes("Deduplicate"));
+        if (!dedupRecommendation) {
+            throw new Error("Should recommend deduplication");
+        }
+        // The test document has 3 schemas: User (referenced), Person (duplicate of User), Profile (orphaned)
+        // So we expect 1 duplicate removal + 1 orphaned removal = 2 total reduction
+        assert.strictEqual(report.potentialSavings.schemaReduction, 2);
+    });
+    it("should generate report for document with orphaned schemas", () => {
+        const doc = createDocumentWithOrphanedSchemas();
+        const report = generateOptimizationReport(doc);
+        // Should recommend removing orphaned schemas
+        const orphanedRecommendation = report.recommendations.find((rec) => rec.includes("orphaned"));
+        assert.ok(orphanedRecommendation);
+        assert.strictEqual(report.potentialSavings.schemaReduction, 2);
+    });
+    it("should generate report for document with both duplicates and orphaned schemas", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        // Add orphaned schema
+        if (doc.service?.schemas) {
+            doc.service.schemas.OrphanedSchema = {
+                description: "Orphaned schema",
+                jsonSchema: { type: "string" },
+            };
+        }
+        const report = generateOptimizationReport(doc);
+        // Should recommend both optimizations
+        const dedupRecommendation = report.recommendations.find((rec) => rec.includes("Deduplicate"));
+        const orphanedRecommendation = report.recommendations.find((rec) => rec.includes("orphaned"));
+        assert.ok(dedupRecommendation);
+        assert.ok(orphanedRecommendation);
+        // Now we have: 1 duplicate + 2 orphaned (Profile + OrphanedSchema) = 3 total reduction
+        assert.strictEqual(report.potentialSavings.schemaReduction, 3);
+    });
+    it("should generate empty report for optimized document", () => {
+        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",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const report = generateOptimizationReport(doc);
+        assert.strictEqual(report.recommendations.length, 0);
+        assert.strictEqual(report.potentialSavings.schemaReduction, 0);
+        // This schema is referenced, so no compression savings
+        assert.strictEqual(report.potentialSavings.referenceCompression, 0);
+    });
+    it("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const report = generateOptimizationReport(doc);
+        assert.strictEqual(report.recommendations.length, 0);
+        assert.strictEqual(report.potentialSavings.schemaReduction, 0);
+        assert.strictEqual(report.potentialSavings.referenceCompression, 0);
+    });
+    it("should handle documents without service", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const report = generateOptimizationReport(doc);
+        assert.strictEqual(report.recommendations.length, 0);
+        assert.strictEqual(report.potentialSavings.schemaReduction, 0);
+        assert.strictEqual(report.potentialSavings.referenceCompression, 0);
+    });
+    it("should estimate reference compression savings", () => {
+        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",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const report = generateOptimizationReport(doc);
+        // Should estimate reference compression (only 1 reference, so no compression)
+        assert.strictEqual(report.potentialSavings.referenceCompression, 0);
+    });
+    it("should work with real examples from node_modules", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        const report = generateOptimizationReport(JSON.parse(JSON.stringify(doc)));
+        // mixed-complete.json is well-structured, so minimal recommendations
+        assert.ok(report.recommendations.length >= 0);
+        assert.ok(report.potentialSavings.schemaReduction >= 0);
+        assert.ok(report.potentialSavings.referenceCompression >= 0);
+    });
+    it("should handle complex documents with multiple optimization opportunities", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        // Add multiple orphaned schemas
+        if (doc.service?.schemas) {
+            doc.service.schemas.Orphaned1 = {
+                description: "Orphaned schema 1",
+                jsonSchema: { type: "string" },
+            };
+            doc.service.schemas.Orphaned2 = {
+                description: "Orphaned schema 2",
+                jsonSchema: { type: "number" },
+            };
+            doc.service.schemas.Orphaned3 = {
+                description: "Orphaned schema 3",
+                jsonSchema: { type: "boolean" },
+            };
+        }
+        const report = generateOptimizationReport(doc);
+        // Should recommend multiple optimizations
+        assert.ok(report.recommendations.length >= 2);
+        // Should account for all potential savings
+        assert.ok(report.potentialSavings.schemaReduction >= 3); // 1 duplicate + 2+ orphaned
+    });
+    it("should not recommend removing schemas that are referenced", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    ReferencedSchema: {
+                        name: "ReferencedSchema",
+                        description: "Referenced schema",
+                        jsonSchema: { type: "string" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "ReferencedSchema",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const report = generateOptimizationReport(doc);
+        // Should not recommend removing the referenced schema
+        const removeRecommendation = report.recommendations.find((rec) => rec.includes("Remove"));
+        assert.strictEqual(removeRecommendation, undefined);
+        assert.strictEqual(report.potentialSavings.schemaReduction, 0);
+    });
+});

package/dist/tests/optimizer/optimize-document.test.d.ts

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

package/dist/tests/optimizer/optimize-document.test.js

@@ -0,0 +1,182 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { optimizeDocument } from "../../src/optimizer/core.js";
+import { createDocumentWithDuplicateSchemas, createDocumentWithLongReferences, createDocumentWithOrphanedSchemas, createDocumentWithUnsortedSchemas, getExamplePath, loadExample, } from "./utils.js";
+describe("optimizeDocument", () => {
+    it("should apply all optimizations by default", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        const result = optimizeDocument(doc);
+        assert.ok(result.document);
+        assert.ok(result.statistics);
+        assert.ok(Array.isArray(result.changes));
+        // Should have removed duplicate schemas
+        assert.strictEqual(result.statistics.originalSchemas, 3);
+        assert.strictEqual(result.statistics.optimizedSchemas, 2);
+        assert.strictEqual(result.statistics.removedSchemas, 1);
+        assert.strictEqual(result.statistics.deduplicatedSchemas, 1);
+        // Should have changes recorded
+        assert.ok(result.changes.length > 0);
+    });
+    it("should apply only specified optimizations", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        const result = optimizeDocument(doc, {
+            dedupeSchemas: true,
+            sortSchemas: false,
+            removeUnusedSchemas: false,
+            compressReferences: false,
+        });
+        // Should only deduplicate
+        assert.strictEqual(result.statistics.removedSchemas, 1);
+        assert.strictEqual(result.statistics.deduplicatedSchemas, 1);
+        // Check that changes mention deduplication
+        const deduplicationChange = result.changes.find((change) => change.includes("Deduplicated"));
+        assert.ok(deduplicationChange);
+    });
+    it("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const result = optimizeDocument(doc);
+        assert.strictEqual(result.statistics.originalSchemas, 0);
+        assert.strictEqual(result.statistics.optimizedSchemas, 0);
+        assert.strictEqual(result.statistics.removedSchemas, 0);
+        assert.strictEqual(result.statistics.deduplicatedSchemas, 0);
+        assert.strictEqual(result.changes.length, 0);
+    });
+    it("should handle documents without service", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const result = optimizeDocument(doc);
+        assert.strictEqual(result.statistics.originalSchemas, 0);
+        assert.strictEqual(result.statistics.optimizedSchemas, 0);
+        assert.strictEqual(result.statistics.removedSchemas, 0);
+        assert.strictEqual(result.statistics.deduplicatedSchemas, 0);
+        assert.strictEqual(result.changes.length, 0);
+    });
+    it("should remove orphaned schemas when enabled", () => {
+        const doc = createDocumentWithOrphanedSchemas();
+        const result = optimizeDocument(doc, {
+            removeUnusedSchemas: true,
+            dedupeSchemas: false,
+            sortSchemas: false,
+            compressReferences: false,
+        });
+        assert.strictEqual(result.statistics.originalSchemas, 3);
+        assert.strictEqual(result.statistics.optimizedSchemas, 1);
+        assert.strictEqual(result.statistics.removedSchemas, 2);
+        // Should have changes about orphaned schema removal
+        const orphanedChange = result.changes.find((change) => change.includes("orphaned"));
+        assert.ok(orphanedChange);
+    });
+    it("should sort schemas when enabled", () => {
+        const doc = createDocumentWithUnsortedSchemas();
+        const result = optimizeDocument(doc, {
+            sortSchemas: true,
+            dedupeSchemas: false,
+            removeUnusedSchemas: false,
+            compressReferences: false,
+        });
+        assert.strictEqual(result.statistics.originalSchemas, 3);
+        assert.strictEqual(result.statistics.optimizedSchemas, 3);
+        // Check schemas are sorted
+        const schemaNames = Object.keys(result.document.service?.schemas || {});
+        assert.deepStrictEqual(schemaNames, ["Alpha", "Beta", "Zebra"]);
+        // Should have changes about sorting
+        const sortChange = result.changes.find((change) => change.includes("Sorted"));
+        assert.ok(sortChange);
+    });
+    it("should compress references when enabled", () => {
+        const doc = createDocumentWithLongReferences();
+        const result = optimizeDocument(doc, {
+            compressReferences: true,
+            dedupeSchemas: false,
+            sortSchemas: false,
+            removeUnusedSchemas: false,
+        });
+        assert.strictEqual(result.statistics.originalSchemas, 1);
+        assert.strictEqual(result.statistics.optimizedSchemas, 1);
+        // Should have changes about compression
+        const compressionChange = result.changes.find((change) => change.includes("Compressed"));
+        assert.ok(compressionChange);
+    });
+    it("should create a deep copy of the document", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        const originalSchemas = doc.service?.schemas;
+        const result = optimizeDocument(doc);
+        // Original document should be unchanged
+        assert.strictEqual(doc.service?.schemas, originalSchemas);
+        assert.strictEqual(Object.keys(doc.service?.schemas || {}).length, 3);
+        // Result document should be different object
+        assert.notStrictEqual(result.document, doc);
+        assert.notStrictEqual(result.document.service, doc.service);
+        assert.notStrictEqual(result.document.service?.schemas, doc.service?.schemas);
+    });
+    it("should work with complex documents", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        const result = optimizeDocument(JSON.parse(JSON.stringify(doc)));
+        assert.ok(result.document);
+        assert.ok(result.statistics);
+        assert.ok(Array.isArray(result.changes));
+        // mixed-complete.json has 2 schemas that are referenced
+        assert.strictEqual(result.statistics.originalSchemas, 2);
+        assert.strictEqual(result.statistics.optimizedSchemas, 2);
+        assert.strictEqual(result.statistics.removedSchemas, 0);
+        assert.strictEqual(result.statistics.deduplicatedSchemas, 0);
+    });
+    it("should handle all optimizations together", () => {
+        // Create a simpler document with all optimization opportunities
+        const doc = createDocumentWithDuplicateSchemas();
+        // Add one orphaned schema
+        if (doc.service?.schemas) {
+            doc.service.schemas.OrphanedSchema = {
+                description: "Orphaned schema",
+                jsonSchema: { type: "string" },
+            };
+        }
+        // Add long reference
+        if (doc.service?.protocols?.rest?.routes?.[0]) {
+            doc.service.protocols.rest.routes[0].responses = {
+                "200": {
+                    description: "Success",
+                    content: {
+                        "application/json": {
+                            schemaRef: "#/service/schemas/Person",
+                        },
+                    },
+                },
+            };
+        }
+        const result = optimizeDocument(doc, {
+            dedupeSchemas: true,
+            sortSchemas: true,
+            removeUnusedSchemas: true,
+            compressReferences: true,
+        });
+        assert.strictEqual(result.statistics.originalSchemas, 4);
+        assert.strictEqual(result.statistics.optimizedSchemas, 1); // Person (Profile is orphaned)
+        assert.strictEqual(result.statistics.removedSchemas, 3); // User + Profile + OrphanedSchema
+        assert.strictEqual(result.statistics.deduplicatedSchemas, 1); // User removed as duplicate
+        // Should have multiple changes
+        assert.ok(result.changes.length >= 2);
+        // Check final state
+        const finalSchemaNames = Object.keys(result.document.service?.schemas || {});
+        assert.deepStrictEqual(finalSchemaNames, ["Person"]); // Only Person remains
+        // Check reference was compressed
+        const route = result.document.service?.protocols?.rest?.routes?.[0];
+        const schemaRef = route?.responses?.["200"]?.content?.["application/json"]?.schemaRef;
+        assert.strictEqual(schemaRef, "Person");
+    });
+    it("should handle empty options", () => {
+        const doc = createDocumentWithDuplicateSchemas();
+        const result = optimizeDocument(doc, {});
+        // Should apply default optimizations (all enabled except removeUnusedSchemas)
+        assert.ok(result.statistics.removedSchemas >= 1); // At least deduplication
+    });
+    it("should preserve document structure", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        const result = optimizeDocument(JSON.parse(JSON.stringify(doc)));
+        // Should preserve all required fields
+        assert.strictEqual(result.document.unispecVersion, doc.unispecVersion);
+        assert.strictEqual(result.document.service?.name, doc.service?.name);
+        assert.strictEqual(result.document.service?.description, doc.service?.description);
+        assert.ok(result.document.service?.protocols);
+        assert.ok(result.document.service?.schemas);
+    });
+});

package/dist/tests/optimizer/orphaned-schemas.test.d.ts

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

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

@@ -0,0 +1,189 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { removeOrphanedSchemas } from "../../src/optimizer/optimization-functions.js";
+import { createDocumentWithOrphanedSchemas, getExamplePath, loadExample, } from "./utils.js";
+describe("removeOrphanedSchemas", () => {
+    it("should remove orphaned schemas", () => {
+        const doc = createDocumentWithOrphanedSchemas();
+        const removed = removeOrphanedSchemas(doc);
+        assert.strictEqual(removed.length, 2);
+        assert.ok(removed.includes("OrphanedSchema1"));
+        assert.ok(removed.includes("OrphanedSchema2"));
+        // Check that only used schema remains
+        const remainingSchemas = Object.keys(doc.service?.schemas || {});
+        assert.strictEqual(remainingSchemas.length, 1);
+        assert.ok(remainingSchemas.includes("UsedSchema"));
+    });
+    it("should keep all schemas when all are referenced", () => {
+        const doc = createDocumentWithOrphanedSchemas();
+        // Add references to all schemas
+        if (doc.service?.protocols?.rest?.routes?.[0]) {
+            doc.service.protocols.rest.routes[0].responses = {
+                "200": {
+                    description: "Success",
+                    content: {
+                        "application/json": {
+                            schemaRef: "UsedSchema",
+                        },
+                    },
+                },
+                "201": {
+                    description: "Created",
+                    content: {
+                        "application/json": {
+                            schemaRef: "OrphanedSchema1",
+                        },
+                    },
+                },
+                "202": {
+                    description: "Accepted",
+                    content: {
+                        "application/json": {
+                            schemaRef: "OrphanedSchema2",
+                        },
+                    },
+                },
+            };
+        }
+        const removed = removeOrphanedSchemas(doc);
+        assert.strictEqual(removed.length, 0);
+        assert.strictEqual(Object.keys(doc.service?.schemas || {}).length, 3);
+    });
+    it("should handle documents without schemas", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const removed = removeOrphanedSchemas(doc);
+        assert.strictEqual(removed.length, 0);
+    });
+    it("should handle documents without service", () => {
+        const doc = { unispecVersion: "1.0.0", service: { name: "test" } };
+        const removed = removeOrphanedSchemas(doc);
+        assert.strictEqual(removed.length, 0);
+    });
+    it("should handle empty schemas object", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: { name: "test", schemas: {} },
+        };
+        const removed = removeOrphanedSchemas(doc);
+        assert.strictEqual(removed.length, 0);
+    });
+    it("should find references in nested structures", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    ReferencedSchema: {
+                        name: "ReferencedSchema",
+                        description: "Referenced schema",
+                        jsonSchema: { type: "string" },
+                    },
+                    UnreferencedSchema: {
+                        name: "UnreferencedSchema",
+                        description: "Unreferenced schema",
+                        jsonSchema: { type: "number" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "ReferencedSchema",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    graphql: {
+                        queries: [
+                            {
+                                name: "testQuery",
+                                returnType: "ReferencedSchema",
+                            },
+                        ],
+                    },
+                    websocket: {
+                        channels: [
+                            {
+                                name: "testChannel",
+                                messages: [
+                                    {
+                                        name: "testMessage",
+                                        schemaRef: "ReferencedSchema",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const removed = removeOrphanedSchemas(doc);
+        assert.strictEqual(removed.length, 1);
+        assert.ok(removed.includes("UnreferencedSchema"));
+        assert.ok(doc.service?.schemas?.ReferencedSchema);
+        assert.ok(!doc.service?.schemas?.UnreferencedSchema);
+    });
+    it("should work with real examples from node_modules", () => {
+        const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
+        const removed = removeOrphanedSchemas(JSON.parse(JSON.stringify(doc)));
+        // mixed-complete.json has schemas that are referenced, so nothing should be removed
+        assert.strictEqual(removed.length, 0);
+    });
+    it("should handle schema references in different formats", () => {
+        const doc = {
+            unispecVersion: "1.0.0",
+            service: {
+                name: "test",
+                schemas: {
+                    TestSchema: {
+                        name: "TestSchema",
+                        description: "Test schema",
+                        jsonSchema: { type: "string" },
+                    },
+                    OrphanedSchema: {
+                        name: "OrphanedSchema",
+                        description: "Orphaned schema",
+                        jsonSchema: { type: "number" },
+                    },
+                },
+                protocols: {
+                    rest: {
+                        routes: [
+                            {
+                                name: "testRoute",
+                                method: "GET",
+                                path: "/test",
+                                responses: {
+                                    "200": {
+                                        description: "Success",
+                                        content: {
+                                            "application/json": {
+                                                schemaRef: "#/service/schemas/TestSchema", // JSON Pointer format
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const removed = removeOrphanedSchemas(doc);
+        assert.strictEqual(removed.length, 1);
+        assert.ok(removed.includes("OrphanedSchema"));
+        assert.ok(doc.service?.schemas?.TestSchema);
+        assert.ok(!doc.service?.schemas?.OrphanedSchema);
+    });
+});

package/dist/tests/optimizer/sort-schemas.test.d.ts

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