@unispechq/unispec-core 0.3.2 → 0.3.3

package/dist/normalizer/websocket-normalizer.js

@@ -1,78 +0,0 @@
-/**
- * Normalize WebSocket channels and messages by sorting them lexicographically by name.
- *
- * @param doc - The UniSpec document to normalize
- * @returns The document with normalized WebSocket channels and messages
- */
-export function normalizeWebSocket(doc) {
-    if (!doc || !doc.service?.protocols) {
-        return doc;
-    }
-    const protocols = doc.service.protocols;
-    const websocket = protocols.websocket;
-    if (!websocket || !Array.isArray(websocket.channels)) {
-        return doc;
-    }
-    // Check if channels are already sorted
-    const areChannelsSorted = websocket.channels.every((channel, index, arr) => {
-        if (index === 0)
-            return true;
-        const prevName = arr[index - 1]?.name ?? "";
-        const currentName = channel?.name ?? "";
-        return prevName.localeCompare(currentName) <= 0;
-    });
-    // Sort messages within each channel only if needed
-    const normalizedChannels = websocket.channels.map((channel) => {
-        if (!channel || !Array.isArray(channel.messages)) {
-            return channel;
-        }
-        // Check if messages are already sorted
-        const areMessagesSorted = channel.messages.every((message, index, arr) => {
-            if (index === 0)
-                return true;
-            const prevName = arr[index - 1]?.name ?? "";
-            const currentName = message?.name ?? "";
-            return prevName.localeCompare(currentName) <= 0;
-        });
-        if (areMessagesSorted) {
-            return channel; // No changes needed
-        }
-        const sortedMessages = [...channel.messages].sort((a, b) => {
-            const aName = a?.name ?? "";
-            const bName = b?.name ?? "";
-            return aName.localeCompare(bName);
-        });
-        // Return new channel with sorted messages (immutable)
-        return {
-            ...channel,
-            messages: sortedMessages,
-        };
-    });
-    if (areChannelsSorted) {
-        // Check if any channels were modified
-        const channelsModified = normalizedChannels.some((channel, index) => channel !== websocket.channels?.[index]);
-        if (!channelsModified) {
-            return doc; // No changes needed
-        }
-    }
-    // Sort channels
-    const sortedChannels = normalizedChannels.sort((a, b) => {
-        const aName = a?.name ?? "";
-        const bName = b?.name ?? "";
-        return aName.localeCompare(bName);
-    });
-    // Return new document with sorted channels (immutable)
-    return {
-        ...doc,
-        service: {
-            ...doc.service,
-            protocols: {
-                ...protocols,
-                websocket: {
-                    ...websocket,
-                    channels: sortedChannels,
-                },
-            },
-        },
-    };
-}

package/dist/optimizer/core.d.ts

@@ -1,17 +0,0 @@
-import type { UniSpecDocument } from "../types/index.js";
-import type { OptimizationOptions, OptimizationReport, OptimizationResult } from "./types.js";
-/**
- * Optimize a UniSpec document with various optimization strategies.
- *
- * @param doc - The UniSpec document to optimize
- * @param options - Optimization options
- * @returns Optimization result with statistics and changes
- */
-export declare function optimizeDocument(doc: UniSpecDocument, options?: OptimizationOptions): OptimizationResult;
-/**
- * Generate optimization report for a UniSpec document.
- *
- * @param doc - The UniSpec document to analyze
- * @returns Optimization recommendations
- */
-export declare function generateOptimizationReport(doc: UniSpecDocument): OptimizationReport;

package/dist/optimizer/core.js

@@ -1,111 +0,0 @@
-import { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions.js";
-/**
- * Optimize a UniSpec document with various optimization strategies.
- *
- * @param doc - The UniSpec document to optimize
- * @param options - Optimization options
- * @returns Optimization result with statistics and changes
- */
-export function optimizeDocument(doc, options = {}) {
-    const changes = [];
-    const originalSchemaCount = Object.keys(doc.service?.schemas || {}).length;
-    // Create a deep copy to avoid mutating the original
-    const optimizedDoc = JSON.parse(JSON.stringify(doc));
-    // Ensure service and schemas exist
-    if (!optimizedDoc.service) {
-        optimizedDoc.service = { name: "" };
-    }
-    if (!optimizedDoc.service.schemas) {
-        optimizedDoc.service.schemas = {};
-    }
-    let deduplicatedCount = 0;
-    // Apply optimizations in order
-    if (options.removeUnusedSchemas === true) {
-        const removed = removeOrphanedSchemas(optimizedDoc);
-        if (removed.length > 0) {
-            changes.push(`Removed ${removed.length} orphaned schemas: ${removed.join(", ")}`);
-        }
-    }
-    if (options.dedupeSchemas !== false) {
-        const dedupResult = deduplicateSchemas(optimizedDoc);
-        if (dedupResult.removedSchemas.length > 0) {
-            changes.push(`Deduplicated ${dedupResult.removedSchemas.length} schemas: ${dedupResult.removedSchemas.join(", ")}`);
-            changes.push(`Updated ${dedupResult.updatedReferences} schema references`);
-            deduplicatedCount = dedupResult.removedSchemas.length;
-        }
-    }
-    if (options.sortSchemas !== false) {
-        const sortedCount = sortSchemas(optimizedDoc);
-        if (sortedCount > 0) {
-            changes.push(`Sorted ${sortedCount} schemas alphabetically`);
-        }
-    }
-    if (options.compressReferences !== false) {
-        const compressedCount = compressSchemaReferences(optimizedDoc);
-        if (compressedCount > 0) {
-            changes.push(`Compressed ${compressedCount} schema references`);
-        }
-    }
-    const finalSchemaCount = Object.keys(optimizedDoc.service.schemas).length;
-    return {
-        document: optimizedDoc,
-        statistics: {
-            originalSchemas: originalSchemaCount,
-            optimizedSchemas: finalSchemaCount,
-            removedSchemas: originalSchemaCount - finalSchemaCount,
-            deduplicatedSchemas: deduplicatedCount,
-        },
-        changes,
-    };
-}
-/**
- * Generate optimization report for a UniSpec document.
- *
- * @param doc - The UniSpec document to analyze
- * @returns Optimization recommendations
- */
-export function generateOptimizationReport(doc) {
-    const recommendations = [];
-    // Create copies for analysis to avoid mutating original
-    const docForDedup = JSON.parse(JSON.stringify(doc));
-    const _docForOrphaned = JSON.parse(JSON.stringify(doc));
-    // First find duplicates
-    const dedupResult = deduplicateSchemas(docForDedup);
-    // Find orphaned schemas that are NOT duplicates
-    const allSchemas = Object.keys(doc.service?.schemas || {});
-    const duplicateNames = new Set(dedupResult.removedSchemas);
-    // Find referenced schemas
-    const referencedSchemas = new Set();
-    function findReferences(obj) {
-        if (!obj || typeof obj !== "object")
-            return;
-        for (const [key, value] of Object.entries(obj)) {
-            if (key === "schemaRef" && typeof value === "string") {
-                const schemaName = value.split("/").pop(); // Simple extraction for analysis
-                if (schemaName)
-                    referencedSchemas.add(schemaName);
-            }
-            else if (typeof value === "object" && value !== null) {
-                findReferences(value);
-            }
-        }
-    }
-    findReferences(doc);
-    // Find orphaned schemas that are not duplicates
-    const orphaned = allSchemas.filter((name) => !referencedSchemas.has(name) && !duplicateNames.has(name));
-    if (orphaned.length > 0) {
-        recommendations.push(`Remove ${orphaned.length} orphaned schemas to reduce document size`);
-    }
-    if (dedupResult.removedSchemas.length > 0) {
-        recommendations.push(`Deduplicate ${dedupResult.removedSchemas.length} identical schemas`);
-    }
-    const totalSchemas = Object.keys(doc.service?.schemas || {}).length;
-    const potentialReduction = orphaned.length + dedupResult.removedSchemas.length;
-    return {
-        recommendations,
-        potentialSavings: {
-            schemaReduction: potentialReduction,
-            referenceCompression: totalSchemas * 0.1, // Estimate 10% compression
-        },
-    };
-}

package/dist/optimizer/index.d.ts

@@ -1,4 +0,0 @@
-export { generateOptimizationReport, optimizeDocument, } from "./core.js";
-export { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions.js";
-export type { DeduplicationResult, OptimizationOptions, OptimizationReport, OptimizationResult, } from "./types.js";
-export { compressReference } from "./utils.js";

package/dist/optimizer/index.js

@@ -1,7 +0,0 @@
-// Export types
-// Export core functions
-export { generateOptimizationReport, optimizeDocument, } from "./core.js";
-// Export optimization functions
-export { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions.js";
-// Export utilities
-export { compressReference } from "./utils.js";

package/dist/optimizer/optimization-functions.d.ts

@@ -1,32 +0,0 @@
-import type { UniSpecDocument } from "../types/index.js";
-import type { DeduplicationResult } from "./types.js";
-/**
- * Remove duplicate schemas from a UniSpec document.
- * Duplicates are identified by identical JSON Schema content.
- * Updates all schema references to point to the retained schema.
- *
- * @param doc - The UniSpec document to deduplicate
- * @returns Object with deduplication statistics
- */
-export declare function deduplicateSchemas(doc: UniSpecDocument): DeduplicationResult;
-/**
- * Remove orphaned schemas (not referenced anywhere).
- *
- * @param doc - The UniSpec document to optimize
- * @returns Array of removed schema names
- */
-export declare function removeOrphanedSchemas(doc: UniSpecDocument): string[];
-/**
- * Sort schemas alphabetically by name for consistent output.
- *
- * @param doc - The UniSpec document to optimize
- * @returns Number of schemas sorted
- */
-export declare function sortSchemas(doc: UniSpecDocument): number;
-/**
- * Compress schema references by using shortest possible format.
- *
- * @param doc - The UniSpec document to optimize
- * @returns Number of references compressed
- */
-export declare function compressSchemaReferences(doc: UniSpecDocument): number;

package/dist/optimizer/optimization-functions.js

@@ -1,179 +0,0 @@
-import { normalizeSchemaRef, stableStringify } from "../schemas/index.js";
-import { compressReference } from "./utils.js";
-/**
- * Remove duplicate schemas from a UniSpec document.
- * Duplicates are identified by identical JSON Schema content.
- * Updates all schema references to point to the retained schema.
- *
- * @param doc - The UniSpec document to deduplicate
- * @returns Object with deduplication statistics
- */
-export function deduplicateSchemas(doc) {
-    if (!doc.service?.schemas) {
-        return { removedSchemas: [], updatedReferences: 0 };
-    }
-    // First, find all referenced schemas
-    const referencedSchemas = new Set();
-    function findReferences(obj) {
-        if (!obj || typeof obj !== "object")
-            return;
-        for (const [key, value] of Object.entries(obj)) {
-            if (key === "schemaRef" && typeof value === "string") {
-                const schemaName = normalizeSchemaRef(value);
-                if (schemaName)
-                    referencedSchemas.add(schemaName);
-            }
-            else if (typeof value === "object" && value !== null) {
-                findReferences(value);
-            }
-        }
-    }
-    findReferences(doc);
-    const names = Object.keys(doc.service.schemas);
-    const hashToName = new Map();
-    const renameMap = {};
-    const removedSchemas = [];
-    for (const name of names) {
-        const schema = doc.service.schemas[name];
-        // Only hash the jsonSchema content, not the name field
-        const hash = stableStringify(schema?.jsonSchema ?? null);
-        const existing = hashToName.get(hash);
-        if (!existing) {
-            hashToName.set(hash, name);
-            continue;
-        }
-        // Found duplicate - prefer referenced schema over unreferenced one
-        const existingIsReferenced = referencedSchemas.has(existing);
-        const currentIsReferenced = referencedSchemas.has(name);
-        if (existingIsReferenced && !currentIsReferenced) {
-            // Keep existing, remove current
-            renameMap[name] = existing;
-            removedSchemas.push(name);
-        }
-        else if (!existingIsReferenced && currentIsReferenced) {
-            // Keep current, remove existing
-            renameMap[existing] = name;
-            removedSchemas.push(existing);
-            hashToName.set(hash, name); // Update to current as preferred
-        }
-        else {
-            // Both referenced or both unreferenced - keep first encountered
-            renameMap[name] = existing;
-            removedSchemas.push(name);
-        }
-    }
-    if (removedSchemas.length === 0) {
-        return { removedSchemas: [], updatedReferences: 0 };
-    }
-    // Update all schema references
-    let updatedReferences = 0;
-    function updateReferences(obj, path = "") {
-        if (!obj || typeof obj !== "object")
-            return;
-        const objRecord = obj;
-        for (const [key, value] of Object.entries(objRecord)) {
-            const currentPath = path ? `${path}.${key}` : key;
-            if (key === "schemaRef" && typeof value === "string") {
-                const schemaName = normalizeSchemaRef(value);
-                if (renameMap[schemaName]) {
-                    objRecord[key] = renameMap[schemaName];
-                    updatedReferences++;
-                }
-            }
-            else if (typeof value === "object" && value !== null) {
-                updateReferences(value, currentPath);
-            }
-        }
-    }
-    updateReferences(doc);
-    // Remove duplicate schemas
-    for (const dup of removedSchemas) {
-        delete doc.service.schemas[dup];
-    }
-    return { removedSchemas, updatedReferences };
-}
-/**
- * Remove orphaned schemas (not referenced anywhere).
- *
- * @param doc - The UniSpec document to optimize
- * @returns Array of removed schema names
- */
-export function removeOrphanedSchemas(doc) {
-    if (!doc.service?.schemas)
-        return [];
-    const referencedSchemas = new Set();
-    // Find all referenced schemas
-    function findReferences(obj) {
-        if (!obj || typeof obj !== "object")
-            return;
-        for (const [key, value] of Object.entries(obj)) {
-            if (key === "schemaRef" && typeof value === "string") {
-                const schemaName = normalizeSchemaRef(value);
-                if (schemaName)
-                    referencedSchemas.add(schemaName);
-            }
-            else if (typeof value === "object" && value !== null) {
-                findReferences(value);
-            }
-        }
-    }
-    findReferences(doc);
-    // Remove orphaned schemas
-    const allSchemas = Object.keys(doc.service.schemas);
-    const orphaned = allSchemas.filter((schema) => !referencedSchemas.has(schema));
-    for (const orphan of orphaned) {
-        delete doc.service.schemas[orphan];
-    }
-    return orphaned;
-}
-/**
- * Sort schemas alphabetically by name for consistent output.
- *
- * @param doc - The UniSpec document to optimize
- * @returns Number of schemas sorted
- */
-export function sortSchemas(doc) {
-    if (!doc.service?.schemas)
-        return 0;
-    const schemaNames = Object.keys(doc.service.schemas);
-    if (schemaNames.length === 0)
-        return 0;
-    const sortedSchemas = {};
-    schemaNames.sort().forEach((name) => {
-        const schema = doc.service?.schemas?.[name];
-        if (schema) {
-            sortedSchemas[name] = schema;
-        }
-    });
-    doc.service.schemas = sortedSchemas;
-    return schemaNames.length;
-}
-/**
- * Compress schema references by using shortest possible format.
- *
- * @param doc - The UniSpec document to optimize
- * @returns Number of references compressed
- */
-export function compressSchemaReferences(doc) {
-    let compressedCount = 0;
-    function compressReferences(obj) {
-        if (!obj || typeof obj !== "object")
-            return;
-        const objRecord = obj;
-        for (const [key, value] of Object.entries(objRecord)) {
-            if (key === "schemaRef" && typeof value === "string") {
-                const original = value;
-                const compressed = compressReference(original);
-                if (compressed !== original) {
-                    objRecord[key] = compressed;
-                    compressedCount++;
-                }
-            }
-            else if (typeof value === "object" && value !== null) {
-                compressReferences(value);
-            }
-        }
-    }
-    compressReferences(doc);
-    return compressedCount;
-}

package/dist/optimizer/types.d.ts

@@ -1,28 +0,0 @@
-import type { UniSpecDocument } from "../types/index.js";
-export interface OptimizationOptions {
-    dedupeSchemas?: boolean;
-    sortSchemas?: boolean;
-    removeUnusedSchemas?: boolean;
-    compressReferences?: boolean;
-}
-export interface OptimizationResult {
-    document: UniSpecDocument;
-    statistics: {
-        originalSchemas: number;
-        optimizedSchemas: number;
-        removedSchemas: number;
-        deduplicatedSchemas: number;
-    };
-    changes: string[];
-}
-export interface DeduplicationResult {
-    removedSchemas: string[];
-    updatedReferences: number;
-}
-export interface OptimizationReport {
-    recommendations: string[];
-    potentialSavings: {
-        schemaReduction: number;
-        referenceCompression: number;
-    };
-}

package/dist/optimizer/types.js

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

package/dist/optimizer/utils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Compress a single schema reference to its shortest form.
- *
- * @param ref - The schema reference to compress
- * @returns Compressed reference
- */
-export declare function compressReference(ref: string): string;

package/dist/optimizer/utils.js

@@ -1,29 +0,0 @@
-/**
- * Compress a single schema reference to its shortest form.
- *
- * @param ref - The schema reference to compress
- * @returns Compressed reference
- */
-export function compressReference(ref) {
-    const trimmed = ref.trim();
-    if (trimmed.length === 0)
-        return "";
-    // If it's already a simple name, keep it
-    if (!trimmed.startsWith("#") && !trimmed.includes("/")) {
-        return trimmed;
-    }
-    // Convert JSON Pointer to simple name
-    if (trimmed.startsWith("#/service/schemas/")) {
-        const parts = trimmed.split("/");
-        return parts[parts.length - 1];
-    }
-    // Convert hash format to simple name
-    if (trimmed.startsWith("#")) {
-        const withoutHash = trimmed.slice(1);
-        const parts = withoutHash.split("/").filter(Boolean);
-        return parts.length > 0 ? parts[parts.length - 1] : withoutHash;
-    }
-    // Convert path format to simple name
-    const parts = trimmed.split("/").filter(Boolean);
-    return parts.length > 0 ? parts[parts.length - 1] : trimmed;
-}

package/dist/schemas/dedupe.d.ts

@@ -1,9 +0,0 @@
-import type { UniSpecDocument } from "../types/index.js";
-/**
- * Remove duplicate schemas from a UniSpec document.
- * Duplicates are identified by identical JSON Schema content.
- * Updates all schema references to point to the retained schema.
- *
- * @param doc - The UniSpec document to deduplicate
- */
-export declare function dedupeSchemas(doc: UniSpecDocument): void;

package/dist/schemas/dedupe.js

@@ -1,97 +0,0 @@
-import { normalizeSchemaRef, stableStringify } from "./utils.js";
-function updateSchemaRefs(doc, mapping) {
-    const rest = doc.service?.protocols?.rest;
-    const websocket = doc.service?.protocols?.websocket;
-    if (rest?.routes) {
-        for (const route of rest.routes) {
-            for (const params of [
-                route.pathParams,
-                route.queryParams,
-                route.headers,
-            ]) {
-                if (!params)
-                    continue;
-                for (const p of params) {
-                    if (!p.schemaRef)
-                        continue;
-                    const key = normalizeSchemaRef(p.schemaRef);
-                    const next = mapping[key];
-                    if (next && next !== key)
-                        p.schemaRef = next;
-                }
-            }
-            const requestContent = route.requestBody?.content;
-            if (requestContent) {
-                for (const media of Object.values(requestContent)) {
-                    if (!media.schemaRef)
-                        continue;
-                    const key = normalizeSchemaRef(media.schemaRef);
-                    const next = mapping[key];
-                    if (next && next !== key)
-                        media.schemaRef = next;
-                }
-            }
-            const responses = route.responses;
-            if (responses) {
-                for (const resp of Object.values(responses)) {
-                    const respContent = resp.content;
-                    if (!respContent)
-                        continue;
-                    for (const media of Object.values(respContent)) {
-                        if (!media.schemaRef)
-                            continue;
-                        const key = normalizeSchemaRef(media.schemaRef);
-                        const next = mapping[key];
-                        if (next && next !== key)
-                            media.schemaRef = next;
-                    }
-                }
-            }
-        }
-    }
-    if (websocket?.channels) {
-        for (const channel of websocket.channels) {
-            if (!channel.messages)
-                continue;
-            for (const message of channel.messages) {
-                if (!message.schemaRef)
-                    continue;
-                const key = normalizeSchemaRef(message.schemaRef);
-                const next = mapping[key];
-                if (next && next !== key)
-                    message.schemaRef = next;
-            }
-        }
-    }
-}
-/**
- * Remove duplicate schemas from a UniSpec document.
- * Duplicates are identified by identical JSON Schema content.
- * Updates all schema references to point to the retained schema.
- *
- * @param doc - The UniSpec document to deduplicate
- */
-export function dedupeSchemas(doc) {
-    if (!doc.service?.schemas)
-        return;
-    const names = Object.keys(doc.service.schemas);
-    const hashToName = new Map();
-    const renameMap = {};
-    for (const name of names) {
-        const schema = doc.service.schemas[name];
-        const hash = stableStringify(schema?.jsonSchema ?? null);
-        const existing = hashToName.get(hash);
-        if (!existing) {
-            hashToName.set(hash, name);
-            continue;
-        }
-        renameMap[name] = existing;
-    }
-    const duplicates = Object.keys(renameMap);
-    if (duplicates.length === 0)
-        return;
-    updateSchemaRefs(doc, renameMap);
-    for (const dup of duplicates) {
-        delete doc.service.schemas[dup];
-    }
-}

package/dist/schemas/index.d.ts

@@ -1,3 +0,0 @@
-export { dedupeSchemas } from "./dedupe.js";
-export { registerSchema, resolveSchemaRef } from "./resolver.js";
-export { normalizeSchemaRef, stableStringify } from "./utils.js";

package/dist/schemas/index.js

@@ -1,6 +0,0 @@
-// Export utility functions
-// Export deduplication functions
-export { dedupeSchemas } from "./dedupe.js";
-// Export resolver functions
-export { registerSchema, resolveSchemaRef } from "./resolver.js";
-export { normalizeSchemaRef, stableStringify } from "./utils.js";

package/dist/schemas/resolver.d.ts

@@ -1,19 +0,0 @@
-import type { UniSpecDocument, UniSpecSchemaDefinition } from "../types/index.js";
-/**
- * Resolve a schema reference to its definition in a UniSpec document.
- *
- * @param doc - The UniSpec document containing schemas
- * @param ref - The schema reference to resolve
- * @returns The schema definition or undefined if not found
- */
-export declare function resolveSchemaRef(doc: UniSpecDocument, ref: string): UniSpecSchemaDefinition | undefined;
-/**
- * Register a new schema definition in a UniSpec document.
- * Creates the schemas container if it doesn't exist.
- *
- * @param doc - The UniSpec document to modify
- * @param name - The schema name
- * @param jsonSchema - The JSON Schema definition
- * @returns The created schema definition
- */
-export declare function registerSchema(doc: UniSpecDocument, name: string, jsonSchema: Record<string, unknown>): UniSpecSchemaDefinition;