@unispechq/unispec-core 0.3.2 → 0.3.4

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

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

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

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

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

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

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

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

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