@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/src/versions.js

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

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

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

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

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

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

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

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

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