@dbs-portal/tool-mock/dist/handlers/registry.js

API mocking toolkit using MSW for DBS Portal development workflows

/**
 * Handler registry for managing MSW request handlers
 */
/**
 * Implementation of handler registry
 */
export class MockHandlerRegistry {
    handlers = new Set();
    taggedHandlers = new Map();
    handlerMetadata = new WeakMap();
    /**
     * Register handlers
     */
    register(...handlers) {
        for (const handler of handlers) {
            this.handlers.add(handler);
        }
    }
    /**
     * Unregister handlers
     */
    unregister(...handlers) {
        for (const handler of handlers) {
            this.handlers.delete(handler);
            // Remove from tagged handlers
            for (const taggedSet of this.taggedHandlers.values()) {
                taggedSet.delete(handler);
            }
            // Remove metadata
            this.handlerMetadata.delete(handler);
        }
    }
    /**
     * Get all registered handlers
     */
    getHandlers() {
        return Array.from(this.handlers);
    }
    /**
     * Clear all handlers
     */
    clear() {
        this.handlers.clear();
        this.taggedHandlers.clear();
        // WeakMap will be garbage collected automatically
    }
    /**
     * Get handlers by tag
     */
    getByTag(tag) {
        const taggedSet = this.taggedHandlers.get(tag);
        return taggedSet ? Array.from(taggedSet) : [];
    }
    /**
     * Tag handlers
     */
    tag(tag, ...handlers) {
        if (!this.taggedHandlers.has(tag)) {
            this.taggedHandlers.set(tag, new Set());
        }
        const taggedSet = this.taggedHandlers.get(tag);
        for (const handler of handlers) {
            taggedSet.add(handler);
            // Update metadata
            const existingMetadata = this.handlerMetadata.get(handler) || {};
            const tags = existingMetadata.tags || [];
            if (!tags.includes(tag)) {
                tags.push(tag);
            }
            this.handlerMetadata.set(handler, {
                ...existingMetadata,
                tags,
            });
        }
    }
    /**
     * Set metadata for a handler
     */
    setMetadata(handler, metadata) {
        this.handlerMetadata.set(handler, metadata);
        // Add to tagged handlers if tags are specified
        if (metadata.tags) {
            for (const tag of metadata.tags) {
                this.tag(tag, handler);
            }
        }
    }
    /**
     * Get metadata for a handler
     */
    getMetadata(handler) {
        return this.handlerMetadata.get(handler);
    }
    /**
     * Get all tags
     */
    getTags() {
        return Array.from(this.taggedHandlers.keys());
    }
    /**
     * Remove tag
     */
    removeTag(tag) {
        const taggedSet = this.taggedHandlers.get(tag);
        if (taggedSet) {
            // Update metadata for all handlers with this tag
            for (const handler of taggedSet) {
                const metadata = this.handlerMetadata.get(handler);
                if (metadata?.tags) {
                    metadata.tags = metadata.tags.filter(t => t !== tag);
                    if (metadata.tags.length === 0) {
                        delete metadata.tags;
                    }
                }
            }
            this.taggedHandlers.delete(tag);
        }
    }
    /**
     * Get handlers with metadata
     */
    getTaggedHandlers() {
        return this.getHandlers().map(handler => ({
            handler,
            metadata: this.getMetadata(handler) || {},
        }));
    }
    /**
     * Find handlers by criteria
     */
    find(criteria) {
        const handlers = this.getHandlers();
        return handlers.filter(handler => {
            const metadata = this.getMetadata(handler);
            if (criteria.name && metadata?.name !== criteria.name) {
                return false;
            }
            if (criteria.author && metadata?.author !== criteria.author) {
                return false;
            }
            if (criteria.tags && criteria.tags.length > 0) {
                const handlerTags = metadata?.tags || [];
                const hasAllTags = criteria.tags.every(tag => handlerTags.includes(tag));
                if (!hasAllTags) {
                    return false;
                }
            }
            return true;
        });
    }
    /**
     * Get registry statistics
     */
    getStats() {
        const handlers = this.getHandlers();
        const tags = this.getTags();
        const tagStats = tags.map(tag => ({
            tag,
            count: this.getByTag(tag).length,
        }));
        return {
            totalHandlers: handlers.length,
            totalTags: tags.length,
            tagStats,
        };
    }
}
/**
 * Global handler registry instance
 */
export const globalHandlerRegistry = new MockHandlerRegistry();
/**
 * Register handlers globally
 */
export function registerHandlers(...handlers) {
    globalHandlerRegistry.register(...handlers);
}
/**
 * Unregister handlers globally
 */
export function unregisterHandlers(...handlers) {
    globalHandlerRegistry.unregister(...handlers);
}
/**
 * Get all registered handlers
 */
export function getRegisteredHandlers() {
    return globalHandlerRegistry.getHandlers();
}
/**
 * Clear all registered handlers
 */
export function clearRegisteredHandlers() {
    globalHandlerRegistry.clear();
}
/**
 * Tag handlers globally
 */
export function tagHandlers(tag, ...handlers) {
    globalHandlerRegistry.tag(tag, ...handlers);
}
/**
 * Get handlers by tag
 */
export function getHandlersByTag(tag) {
    return globalHandlerRegistry.getByTag(tag);
}
/**
 * Create a scoped registry
 */
export function createHandlerRegistry() {
    return new MockHandlerRegistry();
}
//# sourceMappingURL=registry.js.map