@ever_cheng/memory-task-mcp/dist/src/resource_manager.js

Memory and task management MCP Server

"use strict";
/**
 * Resource Management for MemTask
 *
 * Provides a clean way to manage disposable resources and ensure proper cleanup.
 * Implements the Disposable pattern for consistent resource lifecycle management.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.globalResourceManager = exports.ResourceManager = void 0;
exports.disposable = disposable;
exports.safeDispose = safeDispose;
exports.createDisposable = createDisposable;
/**
 * Resource manager for tracking and disposing of resources
 */
class ResourceManager {
    constructor() {
        this.resources = [];
        this.disposed = false;
    }
    /**
     * Register a disposable resource for automatic cleanup
     * @param resource The resource to register
     * @returns The same resource for method chaining
     */
    register(resource) {
        if (this.disposed) {
            throw new Error('ResourceManager has been disposed');
        }
        this.resources.push(resource);
        return resource;
    }
    /**
     * Unregister a resource (useful if resource is manually disposed)
     * @param resource The resource to unregister
     */
    unregister(resource) {
        const index = this.resources.indexOf(resource);
        if (index >= 0) {
            this.resources.splice(index, 1);
        }
    }
    /**
     * Dispose all registered resources
     */
    async disposeAll() {
        if (this.disposed) {
            return;
        }
        const errors = [];
        // Dispose resources in reverse order (LIFO)
        for (let i = this.resources.length - 1; i >= 0; i--) {
            try {
                await this.resources[i].dispose();
            }
            catch (error) {
                errors.push(error instanceof Error ? error : new Error(String(error)));
            }
        }
        this.resources = [];
        this.disposed = true;
        // If there were errors, throw an aggregate error
        if (errors.length > 0) {
            const message = `Failed to dispose ${errors.length} resource(s): ${errors.map(e => e.message).join(', ')}`;
            throw new Error(message);
        }
    }
    /**
     * Alias for disposeAll() to implement Disposable interface
     */
    async dispose() {
        await this.disposeAll();
    }
    /**
     * Get the number of registered resources
     */
    get resourceCount() {
        return this.resources.length;
    }
    /**
     * Check if the resource manager has been disposed
     */
    get isDisposed() {
        return this.disposed;
    }
}
exports.ResourceManager = ResourceManager;
/**
 * Global resource manager instance for convenience
 */
exports.globalResourceManager = new ResourceManager();
/**
 * Decorator for automatic resource registration
 */
function disposable(resource) {
    return exports.globalResourceManager.register(resource);
}
/**
 * Utility function to safely dispose a resource
 */
async function safeDispose(resource) {
    if (resource) {
        try {
            await resource.dispose();
        }
        catch (error) {
            console.warn('Error during resource disposal:', error);
        }
    }
}
/**
 * Utility function to create a disposable wrapper for cleanup functions
 */
function createDisposable(cleanupFn) {
    let disposed = false;
    return {
        async dispose() {
            if (disposed)
                return;
            disposed = true;
            await cleanupFn();
        }
    };
}
//# sourceMappingURL=resource_manager.js.map