@smounters/imperium 1.0.0

package/dist/core/container.js

@@ -0,0 +1,687 @@
+import "reflect-metadata";
+import { container, Lifecycle } from "tsyringe";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { MODULE_KEY } from "../decorators/di.decorators";
+import { ConfigService, LoggerService } from "../services";
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from "./app-tokens";
+import { CONFIG_TOKEN } from "./config";
+import { createLogger, LOGGER_TOKEN } from "./logger";
+import { Reflector } from "./reflector";
+function isDynamicModule(value) {
+    return typeof value === "object" && value !== null && "module" in value && typeof value.module === "function";
+}
+function getProviderToken(provider) {
+    if (typeof provider === "function") {
+        return provider;
+    }
+    return provider.provide;
+}
+function tokenToString(token) {
+    if (typeof token === "string") {
+        return token;
+    }
+    if (typeof token === "symbol") {
+        return token.toString();
+    }
+    if (typeof token === "function") {
+        return token.name || "<anonymous constructor>";
+    }
+    return String(token);
+}
+function enhancerKey(value) {
+    if (typeof value === "function") {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        const maybeCtor = value.constructor;
+        if (maybeCtor && maybeCtor !== Object) {
+            return maybeCtor;
+        }
+    }
+    return value;
+}
+function pushUniqueEnhancer(values, value) {
+    const key = enhancerKey(value);
+    if (values.some((current) => enhancerKey(current) === key)) {
+        return values;
+    }
+    return [...values, value];
+}
+function isAppEnhancerToken(token) {
+    return token === APP_GUARD || token === APP_INTERCEPTOR || token === APP_PIPE || token === APP_FILTER;
+}
+function normalizeLifecycleError(error, phase) {
+    if (error instanceof Error) {
+        return new Error(`[${phase}] ${error.message}`, { cause: error });
+    }
+    return new Error(`[${phase}] ${String(error)}`);
+}
+function hasLifecycleHooks(target) {
+    const prototype = target.prototype;
+    return (typeof prototype.onModuleInit === "function" ||
+        typeof prototype.onApplicationBootstrap === "function" ||
+        typeof prototype.onModuleDestroy === "function" ||
+        typeof prototype.beforeApplicationShutdown === "function" ||
+        typeof prototype.onApplicationShutdown === "function");
+}
+function normalizeSignatureValue(value, seen = new WeakSet()) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const valueType = typeof value;
+    if (valueType === "string" || valueType === "number" || valueType === "boolean") {
+        return value;
+    }
+    if (valueType === "bigint") {
+        return `[bigint:${value.toString()}]`;
+    }
+    if (valueType === "symbol") {
+        return `[symbol:${value.toString()}]`;
+    }
+    if (valueType === "function") {
+        const fn = value;
+        return `[fn:${fn.name || "<anonymous>"}]`;
+    }
+    if (value instanceof Date) {
+        return `[date:${value.toISOString()}]`;
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) {
+            return "[circular]";
+        }
+        seen.add(value);
+        const normalized = value.map((item) => normalizeSignatureValue(item, seen));
+        seen.delete(value);
+        return normalized;
+    }
+    if (valueType === "object") {
+        const objectValue = value;
+        if (seen.has(objectValue)) {
+            return "[circular]";
+        }
+        seen.add(objectValue);
+        const normalized = {};
+        const entries = Object.entries(objectValue).sort(([left], [right]) => left.localeCompare(right));
+        for (const [key, currentValue] of entries) {
+            normalized[key] = normalizeSignatureValue(currentValue, seen);
+        }
+        seen.delete(objectValue);
+        return normalized;
+    }
+    return String(value);
+}
+function createDynamicModuleSignature(meta) {
+    return JSON.stringify(normalizeSignatureValue(meta));
+}
+export class AppContainer {
+    constructor() {
+        this.loadedModules = new Map();
+        this.dynamicModuleSignatures = new Map();
+        this.globalExportOwners = new Map();
+        this.loadingModules = new Set();
+        this.rpcControllerSet = new Set();
+        this.httpControllerSet = new Set();
+        this.rpcControllerModules = new Map();
+        this.httpControllerModules = new Map();
+        this.lifecycleTargets = [];
+        this.requestScopeOwners = new WeakMap();
+        this.requestScopeLinkedScopes = new WeakMap();
+        this.requestContextStorage = new AsyncLocalStorage();
+        this.rootModuleRef = null;
+        this.controllers = [];
+        this.httpControllers = [];
+        this.lifecycleInstances = null;
+        this.initialized = false;
+        this.closed = false;
+        this.exposeInternalErrors = false;
+        this.globalGuards = [];
+        this.globalInterceptors = [];
+        this.globalPipes = [];
+        this.globalFilters = [];
+        this.root = container.createChildContainer();
+        this.setConfig(process.env);
+        this.setLogger(createLogger());
+        this.root.registerSingleton(ConfigService, ConfigService);
+        this.root.registerSingleton(LoggerService, LoggerService);
+        this.root.registerSingleton(Reflector, Reflector);
+    }
+    addLifecycleTarget(containerRef, target) {
+        if (!hasLifecycleHooks(target)) {
+            return;
+        }
+        const exists = this.lifecycleTargets.some((item) => item.container === containerRef && item.target === target);
+        if (exists) {
+            return;
+        }
+        this.lifecycleTargets.push({ container: containerRef, target });
+        this.lifecycleInstances = null;
+    }
+    getLifecycleInstances() {
+        if (this.lifecycleInstances) {
+            return this.lifecycleInstances;
+        }
+        const instances = this.lifecycleTargets.map(({ container, target }) => container.resolve(target));
+        this.lifecycleInstances = instances;
+        return instances;
+    }
+    normalizeModuleImport(moduleImport) {
+        if (isDynamicModule(moduleImport)) {
+            const { module, id, ...dynamicMeta } = moduleImport;
+            const normalizedId = typeof id === "string" && id.trim().length > 0 ? id.trim() : "__default__";
+            return {
+                key: `dynamic:${module.name || "<anonymous module>"}:${normalizedId}`,
+                moduleClass: module,
+                dynamicMeta,
+                dynamicSignature: createDynamicModuleSignature(dynamicMeta),
+                dynamicId: normalizedId,
+            };
+        }
+        return {
+            key: moduleImport,
+            moduleClass: moduleImport,
+        };
+    }
+    readModuleMetadata(moduleClass) {
+        const meta = Reflect.getMetadata(MODULE_KEY, moduleClass);
+        if (!meta) {
+            throw new Error(`Invalid module: ${moduleClass.name || "<anonymous module>"} has no @Module() metadata`);
+        }
+        return meta;
+    }
+    mergeModuleMetadata(staticMeta, dynamicMeta) {
+        return {
+            providers: [...(staticMeta.providers ?? []), ...(dynamicMeta?.providers ?? [])],
+            controllers: [...(staticMeta.controllers ?? []), ...(dynamicMeta?.controllers ?? [])],
+            httpControllers: [...(staticMeta.httpControllers ?? []), ...(dynamicMeta?.httpControllers ?? [])],
+            imports: [...(staticMeta.imports ?? []), ...(dynamicMeta?.imports ?? [])],
+            exports: [...(staticMeta.exports ?? []), ...(dynamicMeta?.exports ?? [])],
+            global: dynamicMeta?.global ?? staticMeta.global ?? false,
+        };
+    }
+    collectProviderTokens(providers) {
+        const tokens = new Set();
+        for (const provider of providers) {
+            tokens.add(getProviderToken(provider));
+        }
+        return tokens;
+    }
+    linkImportedExports(moduleRef) {
+        for (const importedRef of moduleRef.imports) {
+            for (const token of importedRef.exportedTokens) {
+                if (moduleRef.providers.has(token)) {
+                    continue;
+                }
+                if (moduleRef.container.isRegistered(token, false)) {
+                    continue;
+                }
+                moduleRef.container.register(token, {
+                    useFactory: () => this.resolveTokenFromModuleScope(importedRef, token),
+                });
+            }
+        }
+    }
+    resolveAppEnhancerInstance(moduleRef, provider) {
+        if ("useValue" in provider) {
+            return provider.useValue;
+        }
+        if ("useFactory" in provider) {
+            return provider.useFactory(moduleRef.container);
+        }
+        if ("useExisting" in provider) {
+            return moduleRef.container.resolve(provider.useExisting);
+        }
+        if (!moduleRef.container.isRegistered(provider.useClass, false)) {
+            moduleRef.container.register(provider.useClass, { useClass: provider.useClass }, provider.options);
+            this.addLifecycleTarget(moduleRef.container, provider.useClass);
+        }
+        return moduleRef.container.resolve(provider.useClass);
+    }
+    registerAppEnhancerProvider(moduleRef, provider) {
+        if (typeof provider === "function") {
+            return false;
+        }
+        if (provider.provide === APP_GUARD) {
+            const guard = this.resolveAppEnhancerInstance(moduleRef, provider);
+            this.globalGuards = pushUniqueEnhancer(this.globalGuards, guard);
+            return true;
+        }
+        if (provider.provide === APP_INTERCEPTOR) {
+            const interceptor = this.resolveAppEnhancerInstance(moduleRef, provider);
+            this.globalInterceptors = pushUniqueEnhancer(this.globalInterceptors, interceptor);
+            return true;
+        }
+        if (provider.provide === APP_PIPE) {
+            const pipe = this.resolveAppEnhancerInstance(moduleRef, provider);
+            this.globalPipes = pushUniqueEnhancer(this.globalPipes, pipe);
+            return true;
+        }
+        if (provider.provide === APP_FILTER) {
+            const filter = this.resolveAppEnhancerInstance(moduleRef, provider);
+            this.globalFilters = pushUniqueEnhancer(this.globalFilters, filter);
+            return true;
+        }
+        return false;
+    }
+    registerProvider(moduleRef, provider) {
+        if (this.registerAppEnhancerProvider(moduleRef, provider)) {
+            return;
+        }
+        if (typeof provider === "function") {
+            moduleRef.container.registerSingleton(provider, provider);
+            this.addLifecycleTarget(moduleRef.container, provider);
+            return;
+        }
+        if ("useValue" in provider) {
+            moduleRef.container.registerInstance(provider.provide, provider.useValue);
+            return;
+        }
+        if ("useFactory" in provider) {
+            moduleRef.container.register(provider.provide, {
+                useFactory: (dc) => provider.useFactory(dc),
+            });
+            return;
+        }
+        if ("useExisting" in provider) {
+            moduleRef.container.register(provider.provide, { useToken: provider.useExisting }, provider.options);
+            return;
+        }
+        moduleRef.container.register(provider.provide, { useClass: provider.useClass }, provider.options);
+        this.addLifecycleTarget(moduleRef.container, provider.useClass);
+    }
+    resolveModuleExports(moduleRef) {
+        const exportedTokens = new Set();
+        for (const token of moduleRef.meta.exports) {
+            const exportedBySelf = moduleRef.providers.has(token);
+            const exportedByImport = moduleRef.imports.some((imported) => imported.exportedTokens.has(token));
+            if (!exportedBySelf && !exportedByImport) {
+                const moduleName = moduleRef.moduleClass.name || "<anonymous module>";
+                throw new Error(`Module ${moduleName} exports unknown token: ${String(token)}`);
+            }
+            exportedTokens.add(token);
+        }
+        return exportedTokens;
+    }
+    registerGlobalExports(moduleRef) {
+        const moduleOwner = typeof moduleRef.key === "string" ? moduleRef.key : moduleRef.moduleClass.name || "<anonymous module>";
+        for (const token of moduleRef.exportedTokens) {
+            if (isAppEnhancerToken(token)) {
+                continue;
+            }
+            const existingOwner = this.globalExportOwners.get(token);
+            if (existingOwner && existingOwner !== moduleOwner) {
+                throw new Error(`Global provider token collision: "${tokenToString(token)}" is exported by both ` +
+                    `${existingOwner} and ${moduleOwner}.`);
+            }
+            if (!existingOwner) {
+                this.globalExportOwners.set(token, moduleOwner);
+            }
+            if (this.root.isRegistered(token, false)) {
+                continue;
+            }
+            this.root.register(token, {
+                useFactory: () => this.resolveTokenFromModuleScope(moduleRef, token),
+            });
+        }
+    }
+    resolveControllerModule(controller) {
+        return this.httpControllerModules.get(controller) ?? this.rpcControllerModules.get(controller);
+    }
+    getOrCreateLinkedScopes(originScope) {
+        const existing = this.requestScopeLinkedScopes.get(originScope);
+        if (existing) {
+            return existing;
+        }
+        const created = new Set();
+        this.requestScopeLinkedScopes.set(originScope, created);
+        return created;
+    }
+    getModuleScopeForRequest(context, moduleRef) {
+        const existing = context.scopesByModule.get(moduleRef);
+        if (existing) {
+            return existing;
+        }
+        const scopedContainer = moduleRef.container.createChildContainer();
+        context.scopesByModule.set(moduleRef, scopedContainer);
+        this.getOrCreateLinkedScopes(context.originScope).add(scopedContainer);
+        return scopedContainer;
+    }
+    resolveTokenFromModuleScope(moduleRef, token) {
+        const context = this.requestContextStorage.getStore();
+        if (!context) {
+            return moduleRef.container.resolve(token);
+        }
+        const scope = this.getModuleScopeForRequest(context, moduleRef);
+        return scope.resolve(token);
+    }
+    assertRuntimeConfigMutable(settingName) {
+        if (this.closed) {
+            throw new Error(`Cannot configure ${settingName}: container is already closed`);
+        }
+        if (this.initialized) {
+            throw new Error(`Cannot configure ${settingName} after container initialization`);
+        }
+    }
+    loadModuleRef(moduleImport) {
+        const normalized = this.normalizeModuleImport(moduleImport);
+        const dynamicKey = typeof normalized.key === "string" ? normalized.key : undefined;
+        let signatureInserted = false;
+        if (dynamicKey && normalized.dynamicSignature) {
+            const existingSignature = this.dynamicModuleSignatures.get(dynamicKey);
+            if (existingSignature && existingSignature !== normalized.dynamicSignature) {
+                const moduleName = normalized.moduleClass.name || "<anonymous module>";
+                const dynamicId = normalized.dynamicId ?? "__default__";
+                throw new Error(`Dynamic module collision for ${moduleName} with id "${dynamicId}". ` +
+                    "Use unique DynamicModule.id values for different module configurations.");
+            }
+            if (!existingSignature) {
+                this.dynamicModuleSignatures.set(dynamicKey, normalized.dynamicSignature);
+                signatureInserted = true;
+            }
+        }
+        const existing = this.loadedModules.get(normalized.key);
+        if (existing) {
+            return existing;
+        }
+        if (this.loadingModules.has(normalized.key)) {
+            const moduleName = normalized.moduleClass.name || "<anonymous module>";
+            throw new Error(`Circular module import detected: ${moduleName}`);
+        }
+        this.loadingModules.add(normalized.key);
+        const staticMeta = this.readModuleMetadata(normalized.moduleClass);
+        const meta = this.mergeModuleMetadata(staticMeta, normalized.dynamicMeta);
+        const moduleRef = {
+            key: normalized.key,
+            moduleClass: normalized.moduleClass,
+            container: this.root.createChildContainer(),
+            meta,
+            providers: this.collectProviderTokens(meta.providers),
+            exportedTokens: new Set(),
+            imports: [],
+        };
+        this.loadedModules.set(normalized.key, moduleRef);
+        try {
+            moduleRef.imports = meta.imports.map((imported) => this.loadModuleRef(imported));
+            this.linkImportedExports(moduleRef);
+            const appEnhancerProviders = [];
+            for (const provider of meta.providers) {
+                if (typeof provider !== "function" && isAppEnhancerToken(provider.provide)) {
+                    appEnhancerProviders.push(provider);
+                    continue;
+                }
+                this.registerProvider(moduleRef, provider);
+            }
+            for (const provider of appEnhancerProviders) {
+                this.registerProvider(moduleRef, provider);
+            }
+            for (const ctrl of meta.controllers) {
+                if (this.rpcControllerSet.has(ctrl)) {
+                    continue;
+                }
+                moduleRef.container.register(ctrl, { useClass: ctrl }, { lifecycle: Lifecycle.ContainerScoped });
+                this.addLifecycleTarget(moduleRef.container, ctrl);
+                this.rpcControllerSet.add(ctrl);
+                this.rpcControllerModules.set(ctrl, moduleRef);
+                this.controllers.push(ctrl);
+            }
+            for (const ctrl of meta.httpControllers) {
+                if (this.httpControllerSet.has(ctrl)) {
+                    continue;
+                }
+                moduleRef.container.register(ctrl, { useClass: ctrl }, { lifecycle: Lifecycle.ContainerScoped });
+                this.addLifecycleTarget(moduleRef.container, ctrl);
+                this.httpControllerSet.add(ctrl);
+                this.httpControllerModules.set(ctrl, moduleRef);
+                this.httpControllers.push(ctrl);
+            }
+            moduleRef.exportedTokens = this.resolveModuleExports(moduleRef);
+            if (moduleRef.meta.global) {
+                this.registerGlobalExports(moduleRef);
+            }
+            return moduleRef;
+        }
+        catch (error) {
+            this.loadedModules.delete(normalized.key);
+            if (signatureInserted && dynamicKey) {
+                this.dynamicModuleSignatures.delete(dynamicKey);
+            }
+            throw error;
+        }
+        finally {
+            this.loadingModules.delete(normalized.key);
+        }
+    }
+    loadModule(moduleImport) {
+        const moduleRef = this.loadModuleRef(moduleImport);
+        if (!this.rootModuleRef) {
+            this.rootModuleRef = moduleRef;
+        }
+    }
+    resolve(token) {
+        if (this.root.isRegistered(token, false)) {
+            return this.root.resolve(token);
+        }
+        if (this.rootModuleRef?.container.isRegistered(token, true)) {
+            return this.rootModuleRef.container.resolve(token);
+        }
+        throw new Error(`Token "${tokenToString(token)}" is not available in the root module scope. ` +
+            "Export it from an imported module or register it as global.");
+    }
+    resolveAll(token) {
+        if (this.root.isRegistered(token, false)) {
+            return this.root.resolveAll(token);
+        }
+        if (this.rootModuleRef?.container.isRegistered(token, true)) {
+            return this.rootModuleRef.container.resolveAll(token);
+        }
+        throw new Error(`Token "${tokenToString(token)}" is not available in the root module scope. ` +
+            "Export it from an imported module or register it as global.");
+    }
+    setLogger(logger) {
+        this.assertRuntimeConfigMutable("logger");
+        this.root.registerInstance(LOGGER_TOKEN, logger);
+    }
+    configureLogger(options) {
+        const logger = createLogger(options);
+        this.setLogger(logger);
+        return logger;
+    }
+    getLogger() {
+        return this.resolve(LOGGER_TOKEN);
+    }
+    setExposeInternalErrors(value) {
+        this.exposeInternalErrors = value;
+    }
+    shouldExposeInternalErrors() {
+        return this.exposeInternalErrors;
+    }
+    setConfig(config) {
+        this.assertRuntimeConfigMutable("config");
+        this.root.registerInstance(CONFIG_TOKEN, config);
+    }
+    configureConfig(schema, source = process.env) {
+        const parsed = schema.safeParse(source);
+        if (!parsed.success) {
+            const details = parsed.error.issues
+                .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+                .join("; ");
+            throw new Error(`Invalid configuration: ${details}`);
+        }
+        const data = parsed.data;
+        if (typeof data !== "object" || data === null || Array.isArray(data)) {
+            throw new Error("Config schema must produce an object");
+        }
+        this.setConfig(data);
+        return data;
+    }
+    getConfig() {
+        return this.resolve(CONFIG_TOKEN);
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.closed) {
+            throw new Error("Container is already closed");
+        }
+        const instances = this.getLifecycleInstances();
+        for (const instance of instances) {
+            const hook = instance.onModuleInit;
+            if (typeof hook === "function") {
+                await hook.call(instance);
+            }
+        }
+        for (const instance of instances) {
+            const hook = instance.onApplicationBootstrap;
+            if (typeof hook === "function") {
+                await hook.call(instance);
+            }
+        }
+        this.initialized = true;
+    }
+    async close(signal) {
+        if (this.closed) {
+            return;
+        }
+        const instances = this.getLifecycleInstances();
+        const shutdownInstances = [...instances].reverse();
+        const shutdownErrors = [];
+        for (const instance of shutdownInstances) {
+            const hook = instance.beforeApplicationShutdown;
+            if (typeof hook === "function") {
+                try {
+                    await hook.call(instance, signal);
+                }
+                catch (error) {
+                    shutdownErrors.push(normalizeLifecycleError(error, "beforeApplicationShutdown"));
+                }
+            }
+        }
+        for (const instance of shutdownInstances) {
+            const hook = instance.onModuleDestroy;
+            if (typeof hook === "function") {
+                try {
+                    await hook.call(instance);
+                }
+                catch (error) {
+                    shutdownErrors.push(normalizeLifecycleError(error, "onModuleDestroy"));
+                }
+            }
+        }
+        for (const instance of shutdownInstances) {
+            const hook = instance.onApplicationShutdown;
+            if (typeof hook === "function") {
+                try {
+                    await hook.call(instance, signal);
+                }
+                catch (error) {
+                    shutdownErrors.push(normalizeLifecycleError(error, "onApplicationShutdown"));
+                }
+            }
+        }
+        const disposed = new Set();
+        for (const moduleRef of this.loadedModules.values()) {
+            if (disposed.has(moduleRef.container)) {
+                continue;
+            }
+            disposed.add(moduleRef.container);
+            try {
+                await moduleRef.container.dispose();
+            }
+            catch (error) {
+                shutdownErrors.push(normalizeLifecycleError(error, "moduleContainer.dispose"));
+            }
+        }
+        try {
+            await this.root.dispose();
+        }
+        catch (error) {
+            shutdownErrors.push(normalizeLifecycleError(error, "rootContainer.dispose"));
+        }
+        this.closed = true;
+        if (shutdownErrors.length > 0) {
+            throw new AggregateError(shutdownErrors, `Application shutdown completed with ${shutdownErrors.length} error(s)`);
+        }
+    }
+    async runInRequestScope(scope, execute) {
+        const originModuleRef = this.requestScopeOwners.get(scope);
+        const context = {
+            originScope: scope,
+            originModuleRef,
+            scopesByModule: new Map(),
+        };
+        if (originModuleRef) {
+            context.scopesByModule.set(originModuleRef, scope);
+        }
+        return this.requestContextStorage.run(context, async () => execute());
+    }
+    async disposeRequestScope(scope) {
+        const linkedScopes = this.requestScopeLinkedScopes.get(scope);
+        const errors = [];
+        if (linkedScopes && linkedScopes.size > 0) {
+            for (const linkedScope of linkedScopes) {
+                try {
+                    await linkedScope.dispose();
+                }
+                catch (error) {
+                    errors.push(normalizeLifecycleError(error, "requestScope.linked.dispose"));
+                }
+            }
+        }
+        this.requestScopeLinkedScopes.delete(scope);
+        try {
+            await scope.dispose();
+        }
+        catch (error) {
+            errors.push(normalizeLifecycleError(error, "requestScope.dispose"));
+        }
+        if (errors.length > 0) {
+            throw new AggregateError(errors, `Request scope dispose completed with ${errors.length} error(s)`);
+        }
+    }
+    createRequestScope(controller) {
+        if (!controller) {
+            const scope = this.root.createChildContainer();
+            this.requestScopeOwners.set(scope, undefined);
+            return scope;
+        }
+        const moduleRef = this.resolveControllerModule(controller);
+        if (!moduleRef) {
+            const scope = this.root.createChildContainer();
+            this.requestScopeOwners.set(scope, undefined);
+            return scope;
+        }
+        const scope = moduleRef.container.createChildContainer();
+        this.requestScopeOwners.set(scope, moduleRef);
+        return scope;
+    }
+    getControllers() {
+        return [...this.controllers];
+    }
+    getHttpControllers() {
+        return [...this.httpControllers];
+    }
+    setGlobalGuards(guards) {
+        this.globalGuards = [...guards];
+    }
+    getGlobalGuards() {
+        return [...this.globalGuards];
+    }
+    setGlobalInterceptors(inters) {
+        this.globalInterceptors = [...inters];
+    }
+    getGlobalInterceptors() {
+        return [...this.globalInterceptors];
+    }
+    setGlobalPipes(pipes) {
+        this.globalPipes = [...pipes];
+    }
+    getGlobalPipes() {
+        return [...this.globalPipes];
+    }
+    setGlobalFilters(filters) {
+        this.globalFilters = [...filters];
+    }
+    getGlobalFilters() {
+        return [...this.globalFilters];
+    }
+}