@unispechq/unispec-core 0.3.2 → 0.3.4

package/dist/src/versions.js

@@ -1,143 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-let cachedUniSpecVersion = null;
-let cachedSchemaPackagePath = null;
-/**
- * Validate package.json content to ensure it's the correct @unispechq/unispec-schema package
- * @param content Package.json content as string
- * @returns Package info object if valid, null otherwise
- */
-function validatePackageJson(content) {
-    try {
-        const packageInfo = JSON.parse(content);
-        if (packageInfo.name === "@unispechq/unispec-schema" &&
-            packageInfo.version) {
-            return packageInfo;
-        }
-    }
-    catch {
-        // Invalid JSON
-    }
-    return null;
-}
-/**
- * Get current module directory (supports both ESM and CJS)
- * @returns Current directory path
- */
-function getCurrentDirectory() {
-    if (typeof __dirname !== "undefined") {
-        return __dirname;
-    }
-    // Try ESM import.meta.url
-    try {
-        if (typeof globalThis !== "undefined" &&
-            globalThis.import
-                ?.meta?.url) {
-            return dirname(fileURLToPath(globalThis
-                .import.meta.url));
-        }
-    }
-    catch {
-        // Fallback to current working directory
-    }
-    return process.cwd();
-}
-/**
- * Find the package.json path for @unispechq/unispec-schema
- * Works in both ESM and CJS contexts with improved reliability
- * @returns Path to package.json file
- */
-function findSchemaPackagePath() {
-    // Return cached path if available
-    if (cachedSchemaPackagePath) {
-        return cachedSchemaPackagePath;
-    }
-    const currentDir = getCurrentDirectory();
-    // Define all possible paths to check
-    const candidatePaths = [
-        // Try direct package.json resolution first (most reliable for CJS)
-        () => {
-            if (typeof require !== "undefined") {
-                try {
-                    return require.resolve("@unispechq/unispec-schema/package.json");
-                }
-                catch {
-                    return null;
-                }
-            }
-            return null;
-        },
-        // Try require.resolve for main entry point
-        () => {
-            if (typeof require !== "undefined") {
-                try {
-                    const packageMainPath = require.resolve("@unispechq/unispec-schema");
-                    return join(dirname(packageMainPath), "package.json");
-                }
-                catch {
-                    return null;
-                }
-            }
-            return null;
-        },
-        // Fallback paths
-        () => join(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "package.json"),
-        () => join(currentDir, "..", "node_modules", "@unispechq", "unispec-schema", "package.json"),
-        () => join(currentDir, "..", "..", "node_modules", "@unispechq", "unispec-schema", "package.json"),
-        () => join(currentDir, "..", "..", "..", "node_modules", "@unispechq", "unispec-schema", "package.json"),
-    ];
-    // Try each candidate path
-    for (const getPath of candidatePaths) {
-        try {
-            const path = getPath();
-            if (!path)
-                continue;
-            const content = readFileSync(path, "utf-8");
-            const packageInfo = validatePackageJson(content);
-            if (packageInfo) {
-                cachedSchemaPackagePath = path;
-                return path;
-            }
-        }
-        catch {
-            // Continue to next path
-        }
-    }
-    throw new Error(`Could not find @unispechq/unispec-schema package.json. Searched in multiple node_modules locations.`);
-}
-/**
- * Get the latest supported UniSpec version from @unispechq/unispec-schema package
- * The version is derived from the package.json version (major.minor.0 format)
- * @returns The latest UniSpec format version (SemVer)
- */
-export function getLatestUniSpecVersion() {
-    if (cachedUniSpecVersion) {
-        return cachedUniSpecVersion;
-    }
-    try {
-        // Find and read package.json from @unispechq/unispec-schema
-        const schemaPackagePath = findSchemaPackagePath();
-        const packageJson = readFileSync(schemaPackagePath, "utf-8");
-        const packageInfo = JSON.parse(packageJson);
-        // Extract version and convert to major.minor.0 format
-        const version = packageInfo.version;
-        const [major, minor] = version.split(".");
-        // Create UniSpec version in major.minor.0 format
-        const unispecVersion = `${major}.${minor}.0`;
-        cachedUniSpecVersion = unispecVersion;
-        return unispecVersion;
-    }
-    catch {
-        // Fallback to default version if package.json is not available
-        cachedUniSpecVersion = "1.0.0";
-        return cachedUniSpecVersion;
-    }
-}
-/**
- * Clear the version cache (useful for testing or dynamic updates)
- */
-export function clearVersionCache() {
-    cachedUniSpecVersion = null;
-    cachedSchemaPackagePath = null;
-}

package/dist/tests/cache/cache.test.d.ts

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

package/dist/tests/cache/cache.test.js

@@ -1,269 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { createCacheManager, createNamedCacheManager, getManagersStats, } from "../../src/cache/cache-factory.js";
-import { UniSpecCacheManager } from "../../src/cache/cache-manager.js";
-import { generateDiffHash, generateDocumentHash } from "../../src/cache/hash-utils.js";
-import { LRUCache } from "../../src/cache/lru-cache.js";
-const createTestDoc = (name) => ({
-    unispecVersion: "1.0.0",
-    service: {
-        name,
-        description: `Test service ${name}`,
-        protocols: {
-            rest: {
-                routes: [
-                    {
-                        name: "test",
-                        method: "GET",
-                        path: "/test",
-                        responses: { "200": { description: "Success" } },
-                    },
-                ],
-            },
-        },
-    },
-});
-describe("cache module", () => {
-    describe("LRUCache", () => {
-        it("should store and retrieve values", async () => {
-            const cache = new LRUCache();
-            await cache.set("key", "value");
-            assert.strictEqual(await cache.get("key"), "value");
-        });
-        it("should handle LRU eviction", async () => {
-            const cache = new LRUCache({ maxSize: 2 });
-            await cache.set("a", "1");
-            await cache.set("b", "2");
-            await cache.set("c", "3"); // evicts a
-            assert.strictEqual(await cache.get("a"), undefined);
-            assert.strictEqual(await cache.get("b"), "2");
-            assert.strictEqual(await cache.get("c"), "3");
-        });
-        it("should track statistics", async () => {
-            const cache = new LRUCache({ enableStats: true });
-            await cache.set("key", "value");
-            await cache.get("key"); // hit
-            await cache.get("missing"); // miss
-            const stats = cache.getStats();
-            assert.strictEqual(stats.hits, 1);
-            assert.strictEqual(stats.misses, 1);
-            assert.strictEqual(stats.hitRate, 0.5);
-        });
-    });
-    describe("CacheManager", () => {
-        it("should handle validation caching", async () => {
-            const manager = new UniSpecCacheManager({ enableStats: true });
-            const doc = createTestDoc("test");
-            const hash = await generateDocumentHash(doc);
-            const result = { valid: true, errors: [] };
-            await manager.setValidationResult(hash, result);
-            const cached = await manager.getValidationResult(hash);
-            assert.deepStrictEqual(cached, result);
-            assert.strictEqual(manager.getStats().validation.size, 1);
-            manager.destroy();
-        });
-        it("should handle normalization caching", async () => {
-            const manager = new UniSpecCacheManager({ enableStats: true });
-            const doc = createTestDoc("test");
-            const hash = await generateDocumentHash(doc);
-            const normalized = { ...doc, normalized: true };
-            await manager.setNormalizationResult(hash, normalized);
-            const cached = await manager.getNormalizationResult(hash);
-            assert.deepStrictEqual(cached, normalized);
-            assert.strictEqual(manager.getStats().normalization.size, 1);
-            manager.destroy();
-        });
-        it("should handle diff caching", async () => {
-            const manager = new UniSpecCacheManager({ enableStats: true });
-            const doc1 = createTestDoc("test1");
-            const doc2 = createTestDoc("test2");
-            const hash = await generateDiffHash(doc1, doc2);
-            const diffResult = { changes: [] };
-            await manager.setDiffResult(hash, diffResult);
-            const cached = await manager.getDiffResult(hash);
-            assert.deepStrictEqual(cached, diffResult);
-            assert.strictEqual(manager.getStats().diff.size, 1);
-            manager.destroy();
-        });
-        it("should provide comprehensive statistics", async () => {
-            const manager = new UniSpecCacheManager({ enableStats: true });
-            const doc = createTestDoc("test");
-            const hash = await generateDocumentHash(doc);
-            await manager.setValidationResult(hash, { valid: true, errors: [] });
-            await manager.setNormalizationResult(hash, { normalized: true });
-            await manager.setDiffResult(hash, { changes: [] });
-            const stats = manager.getStats();
-            assert.strictEqual(stats.total.size, 3);
-            assert.strictEqual(stats.validation.size, 1);
-            assert.strictEqual(stats.normalization.size, 1);
-            assert.strictEqual(stats.diff.size, 1);
-            manager.destroy();
-        });
-        it("should clear all caches", async () => {
-            const manager = new UniSpecCacheManager({ enableStats: true });
-            const doc = createTestDoc("test");
-            const hash = await generateDocumentHash(doc);
-            await manager.setValidationResult(hash, { valid: true, errors: [] });
-            await manager.setNormalizationResult(hash, { normalized: true });
-            await manager.setDiffResult(hash, { changes: [] });
-            manager.clearAll();
-            const stats = manager.getStats();
-            assert.strictEqual(stats.total.size, 0);
-            manager.destroy();
-        });
-    });
-    describe("CacheFactory", () => {
-        it("should create isolated instances", () => {
-            const manager1 = createCacheManager();
-            const manager2 = createCacheManager();
-            assert.notStrictEqual(manager1, manager2);
-            manager1.destroy();
-            manager2.destroy();
-        });
-        it("should create named managers with cleanup", () => {
-            const manager1 = createNamedCacheManager("test");
-            const manager2 = createNamedCacheManager("test"); // replaces first
-            assert.notStrictEqual(manager1, manager2);
-            manager1.destroy();
-            manager2.destroy();
-        });
-        it("should provide statistics for multiple managers", () => {
-            const manager1 = createNamedCacheManager("stats1", { enableStats: true });
-            const manager2 = createNamedCacheManager("stats2", { enableStats: true });
-            const stats = getManagersStats([manager1, manager2]);
-            assert.ok(stats.stats1);
-            assert.ok(stats.stats2);
-            assert.strictEqual(Object.keys(stats).length, 2);
-            manager1.destroy();
-            manager2.destroy();
-        });
-    });
-    describe("HashUtils", () => {
-        it("should generate consistent hashes", async () => {
-            const doc = createTestDoc("test");
-            const hash1 = await generateDocumentHash(doc);
-            const hash2 = await generateDocumentHash(doc);
-            assert.strictEqual(hash1, hash2);
-            assert.strictEqual(hash1.length, 20);
-        });
-        it("should generate different hashes for different documents", async () => {
-            const doc1 = createTestDoc("test1");
-            const doc2 = createTestDoc("test2");
-            const hash1 = await generateDocumentHash(doc1);
-            const hash2 = await generateDocumentHash(doc2);
-            assert.notStrictEqual(hash1, hash2);
-        });
-        it("should handle deep copies consistently", async () => {
-            const doc = createTestDoc("test");
-            const copy = JSON.parse(JSON.stringify(doc));
-            const hash1 = await generateDocumentHash(doc);
-            const hash2 = await generateDocumentHash(copy);
-            assert.strictEqual(hash1, hash2);
-        });
-        it("should generate diff hashes", async () => {
-            const doc1 = createTestDoc("test1");
-            const doc2 = createTestDoc("test2");
-            const hash = await generateDiffHash(doc1, doc2);
-            assert.strictEqual(typeof hash, "string");
-            assert.strictEqual(hash.length, 22);
-        });
-        it("should generate different diff hashes for different pairs", async () => {
-            const doc1 = createTestDoc("test1");
-            const doc2 = createTestDoc("test2");
-            const doc3 = createTestDoc("test3");
-            const hash1 = await generateDiffHash(doc1, doc2);
-            const hash2 = await generateDiffHash(doc2, doc3);
-            assert.notStrictEqual(hash1, hash2);
-        });
-    });
-    describe("Integration", () => {
-        it("should handle complete workflow", async () => {
-            const manager = createCacheManager({ enableStats: true });
-            const validDoc = createTestDoc("valid");
-            const invalidDoc = { unispecVersion: "1.0.0" };
-            // Process valid document
-            const validHash = await generateDocumentHash(validDoc);
-            await manager.setValidationResult(validHash, { valid: true, errors: [] });
-            await manager.setNormalizationResult(validHash, {
-                ...validDoc,
-                normalized: true,
-            });
-            // Process invalid document
-            const invalidHash = await generateDocumentHash(invalidDoc);
-            await manager.setValidationResult(invalidHash, {
-                valid: false,
-                errors: [{ path: "/", message: "Invalid", code: "INVALID" }],
-            });
-            // Process diff
-            const diffHash = await generateDiffHash(validDoc, invalidDoc);
-            await manager.setDiffResult(diffHash, { changes: [] });
-            // Verify results
-            const validResult = await manager.getValidationResult(validHash);
-            const invalidResult = await manager.getValidationResult(invalidHash);
-            const normResult = await manager.getNormalizationResult(validHash);
-            const diffResult = await manager.getDiffResult(diffHash);
-            assert.strictEqual(validResult?.valid, true);
-            assert.strictEqual(invalidResult?.valid, false);
-            assert.notStrictEqual(normResult, undefined);
-            assert.notStrictEqual(diffResult, undefined);
-            // Verify statistics
-            const stats = manager.getStats();
-            assert.strictEqual(stats.total.size, 4);
-            manager.destroy();
-        });
-        it("should handle concurrent operations", async () => {
-            const manager = createCacheManager({ enableStats: true });
-            const promises = [];
-            // Create concurrent operations
-            for (let i = 0; i < 10; i++) {
-                const doc = createTestDoc(`test${i}`);
-                const hash = await generateDocumentHash(doc);
-                promises.push(manager.setValidationResult(hash, { valid: true, errors: [] }));
-                promises.push(manager
-                    .getValidationResult(hash)
-                    .then(() => { })
-                    .catch(() => { }));
-            }
-            await Promise.all(promises);
-            // Verify integrity
-            const stats = manager.getStats();
-            assert.ok(stats.validation.size >= 0);
-            manager.destroy();
-        });
-    });
-    describe("Error handling", () => {
-        it("should handle malformed documents", async () => {
-            const manager = createCacheManager();
-            const malformedDocs = [
-                { unispecVersion: "1.0.0" },
-                { service: { name: "test" } },
-            ];
-            for (const doc of malformedDocs) {
-                try {
-                    const hash = await generateDocumentHash(doc);
-                    await manager.setValidationResult(hash, { valid: false, errors: [] });
-                    const result = await manager.getValidationResult(hash);
-                    assert.strictEqual(result?.valid, false);
-                }
-                catch (error) {
-                    // Expected for some malformed docs
-                    assert.ok(error instanceof Error);
-                }
-            }
-            manager.destroy();
-        });
-        it("should handle cache overflow gracefully", async () => {
-            const manager = createCacheManager({ enableStats: true, maxSize: 5 });
-            // Fill beyond capacity
-            for (let i = 0; i < 10; i++) {
-                const doc = createTestDoc(`test${i}`);
-                const hash = await generateDocumentHash(doc);
-                await manager.setValidationResult(hash, { valid: true, errors: [] });
-            }
-            const stats = manager.getStats();
-            assert.strictEqual(stats.validation.size, 5); // Should respect max size
-            assert.ok(stats.validation.evictions >= 0); // May have evictions
-            manager.destroy();
-        });
-    });
-});

package/dist/tests/cache/utils.d.ts

@@ -1,4 +0,0 @@
-import { getExamplePath, loadExample } from "../../tests/utils.js";
-export declare function getValidExamplePaths(): string[];
-export declare function getInvalidExamplePaths(): string[];
-export { loadExample, getExamplePath };

package/dist/tests/cache/utils.js

@@ -1,24 +0,0 @@
-import path from "node:path";
-import { examplesDir, getExamplePath, loadExample } from "../../tests/utils.js";
-// Cache-specific utilities
-export function getValidExamplePaths() {
-    const validSpecDir = path.join(examplesDir, "valid", "spec");
-    return [
-        path.join(validSpecDir, "rest-simple.json"),
-        path.join(validSpecDir, "graphql-simple.json"),
-        path.join(validSpecDir, "websocket-simple.json"),
-        path.join(validSpecDir, "mixed-complete.json"),
-    ];
-}
-export function getInvalidExamplePaths() {
-    const invalidSpecDir = path.join(examplesDir, "invalid", "spec");
-    return [
-        path.join(invalidSpecDir, "missing-unispec-version.json"),
-        path.join(invalidSpecDir, "missing-service-name.json"),
-        path.join(invalidSpecDir, "invalid-rest-method.json"),
-        path.join(invalidSpecDir, "graphql-missing-name.json"),
-        path.join(invalidSpecDir, "invalid-identifier.json"),
-    ];
-}
-// Re-export commonly used functions from tests/utils for convenience
-export { loadExample, getExamplePath };

package/dist/tests/concurrency-normalizer-optimizer.test.js

@@ -1 +0,0 @@
-"use strict";

package/dist/tests/diff/diff-annotators.test.d.ts

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