@zucker-framework/provider 1.0.0

package/dist/index.mjs

@@ -0,0 +1,765 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/provider-registry.ts
+import { Injectable, Logger } from "@nestjs/common";
+import { NotFoundException } from "@zucker-framework/core";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var DefaultProviderRegistry = class _DefaultProviderRegistry {
+  static {
+    __name(this, "DefaultProviderRegistry");
+  }
+  logger = new Logger(_DefaultProviderRegistry.name);
+  providers = /* @__PURE__ */ new Map();
+  defaultId = null;
+  hooks = [];
+  register(provider) {
+    this.providers.set(provider.id, provider);
+    this.hooks.forEach((h) => h.onRegister?.(provider));
+    this.logger.log(`Provider registered: ${provider.id}`);
+    if (this.providers.size === 1) {
+      this.defaultId = provider.id;
+    }
+    return {
+      dispose: /* @__PURE__ */ __name(() => this.unregister(provider.id), "dispose")
+    };
+  }
+  unregister(id) {
+    const provider = this.providers.get(id);
+    if (provider) {
+      this.providers.delete(id);
+      this.hooks.forEach((h) => h.onUnregister?.(provider));
+      this.logger.log(`Provider unregistered: ${id}`);
+      if (this.defaultId === id) {
+        this.defaultId = this.providers.size > 0 ? this.providers.keys().next().value ?? null : null;
+      }
+    }
+  }
+  get(id) {
+    return this.providers.get(id);
+  }
+  /**
+  * Get provider by id; throws if not found.
+  * Mirrors Java SimpleProvider.getNow() which throws BusinessException.
+  */
+  getNow(id) {
+    const provider = this.providers.get(id);
+    if (!provider) {
+      throw new NotFoundException(`Unsupported provider: ${id}`);
+    }
+    return provider;
+  }
+  getAll() {
+    return Array.from(this.providers.values());
+  }
+  getDefault() {
+    return this.defaultId ? this.providers.get(this.defaultId) : void 0;
+  }
+  setDefault(id) {
+    if (!this.providers.has(id)) {
+      throw new NotFoundException(`Provider not found: ${id}`);
+    }
+    this.defaultId = id;
+  }
+  /**
+  * Register if absent — if a provider with the same id already exists,
+  * returns the old provider and skips registration. Otherwise registers
+  * the new provider and returns undefined.
+  * Mirrors Java SimpleProvider.registerIfAbsent(id, T).
+  */
+  registerIfAbsent(provider) {
+    const existing = this.providers.get(provider.id);
+    if (existing) {
+      return existing;
+    }
+    this.register(provider);
+    return void 0;
+  }
+  /**
+  * Register if absent using a builder function.
+  * Mirrors Java SimpleProvider.registerIfAbsent(id, Function<String, T>).
+  */
+  registerIfAbsentWith(id, builder) {
+    const existing = this.providers.get(id);
+    if (existing) {
+      return existing;
+    }
+    const provider = builder(id);
+    this.register(provider);
+    return void 0;
+  }
+  addHook(hook) {
+    this.hooks.push(hook);
+    return {
+      dispose: /* @__PURE__ */ __name(() => this.removeHook(hook), "dispose")
+    };
+  }
+  removeHook(hook) {
+    const idx = this.hooks.indexOf(hook);
+    if (idx >= 0) this.hooks.splice(idx, 1);
+  }
+};
+DefaultProviderRegistry = _ts_decorate([
+  Injectable()
+], DefaultProviderRegistry);
+
+// src/strategy-manager.ts
+import { Injectable as Injectable2, Logger as Logger2 } from "@nestjs/common";
+import { NotFoundException as NotFoundException2 } from "@zucker-framework/core";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var DefaultStrategyManager = class _DefaultStrategyManager {
+  static {
+    __name(this, "DefaultStrategyManager");
+  }
+  logger = new Logger2(_DefaultStrategyManager.name);
+  strategies = /* @__PURE__ */ new Map();
+  register(strategy) {
+    this.strategies.set(strategy.id, strategy);
+    this.logger.log(`Strategy registered: ${strategy.id}`);
+  }
+  unregister(id) {
+    this.strategies.delete(id);
+    this.logger.log(`Strategy unregistered: ${id}`);
+  }
+  get(id) {
+    return this.strategies.get(id);
+  }
+  /**
+  * Get strategy by id; throws if not found.
+  * Mirrors Java StaticStrategyManager's implicit throw behaviour via
+  * switchIfEmpty + onStrategyNotFound.
+  */
+  getNow(id) {
+    const strategy = this.strategies.get(id);
+    if (!strategy) {
+      return this.onStrategyNotFound(id);
+    }
+    return strategy;
+  }
+  getAll() {
+    return Array.from(this.strategies.values());
+  }
+  /**
+  * Check if a strategy is registered.
+  */
+  has(id) {
+    return this.strategies.has(id);
+  }
+  /**
+  * Execute an async function with a resolved strategy.
+  * Mirrors Java StaticStrategyManager.doWithMono().
+  */
+  async doWith(strategyId, executor) {
+    const strategy = this.get(strategyId);
+    if (!strategy) {
+      try {
+        this.onStrategyNotFound(strategyId);
+      } catch (err) {
+        this.logger.debug(`Strategy not found (doWith): ${strategyId} \u2014 ${err instanceof Error ? err.message : String(err)}`);
+        return void 0;
+      }
+      return void 0;
+    }
+    return executor(strategy);
+  }
+  /**
+  * Execute an async function that returns an array with a resolved strategy.
+  * Mirrors Java StaticStrategyManager.doWithFlux().
+  */
+  async doWithMany(strategyId, executor) {
+    const strategy = this.get(strategyId);
+    if (!strategy) {
+      try {
+        this.onStrategyNotFound(strategyId);
+      } catch (err) {
+        this.logger.debug(`Strategy not found (doWithMany): ${strategyId} \u2014 ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+      }
+      return [];
+    }
+    return executor(strategy);
+  }
+  /**
+  * Called when a strategy is not found. By default throws an error.
+  * Subclasses can override to return a fallback or silently return undefined.
+  * Mirrors Java StaticStrategyManager.onStrategyNotFound().
+  */
+  onStrategyNotFound(strategyId) {
+    throw new NotFoundException2(`Strategy not found: ${strategyId}`);
+  }
+};
+DefaultStrategyManager = _ts_decorate2([
+  Injectable2()
+], DefaultStrategyManager);
+
+// src/hook.ts
+var HookManager = class {
+  static {
+    __name(this, "HookManager");
+  }
+  hooks = [];
+  /**
+  * Add a lifecycle hook.
+  * @param hook - The hook to add
+  */
+  addHook(hook) {
+    this.hooks.push(hook);
+  }
+  /**
+  * Remove a previously added lifecycle hook.
+  * @param hook - The hook to remove
+  */
+  removeHook(hook) {
+    const idx = this.hooks.indexOf(hook);
+    if (idx >= 0) this.hooks.splice(idx, 1);
+  }
+  /**
+  * Fire the onRegister event on all hooks.
+  * @param item - The item being registered
+  */
+  async fireRegister(item) {
+    for (const hook of this.hooks) {
+      await hook.onRegister?.(item);
+    }
+  }
+  /**
+  * Fire the onUnregister event on all hooks.
+  * @param item - The item being unregistered
+  */
+  async fireUnregister(item) {
+    for (const hook of this.hooks) {
+      await hook.onUnregister?.(item);
+    }
+  }
+  /**
+  * Get a copy of all registered hooks.
+  * @returns An array of registered lifecycle hooks
+  */
+  getHooks() {
+    return [
+      ...this.hooks
+    ];
+  }
+};
+
+// src/composite-provider.ts
+import { Logger as Logger3 } from "@nestjs/common";
+var CompositeProvider = class _CompositeProvider {
+  static {
+    __name(this, "CompositeProvider");
+  }
+  logger = new Logger3(_CompositeProvider.name);
+  providers = [];
+  constructor(providers) {
+    if (providers) {
+      this.providers = [
+        ...providers
+      ];
+    }
+  }
+  /**
+  * 添加一个 provider（追加到末尾，优先级最低）
+  */
+  add(provider) {
+    this.providers.push(provider);
+  }
+  /**
+  * 在指定位置插入 provider（索引越小优先级越高）
+  */
+  addFirst(provider) {
+    this.providers.unshift(provider);
+  }
+  /**
+  * 按优先级依次尝试所有 provider，返回首个非空结果（switchIfEmpty 语义）
+  */
+  async get(fn) {
+    for (const provider of this.providers) {
+      try {
+        const result = await fn(provider);
+        if (result !== void 0 && result !== null) {
+          return result;
+        }
+      } catch (err) {
+        this.logger.debug(`Provider attempt failed, trying next: ${err}`);
+      }
+    }
+    return void 0;
+  }
+  /**
+  * 合并所有 provider 的结果并去重
+  * @param fn 从每个 provider 获取数组结果
+  * @param keyFn 可选的去重 key 提取函数
+  */
+  async getAll(fn, keyFn) {
+    const allResults = [];
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const provider of this.providers) {
+      try {
+        const results = await fn(provider);
+        for (const item of results) {
+          if (keyFn) {
+            const key = keyFn(item);
+            if (!seenKeys.has(key)) {
+              seenKeys.add(key);
+              allResults.push(item);
+            }
+          } else {
+            allResults.push(item);
+          }
+        }
+      } catch (err) {
+        this.logger.debug(`Provider getAll failed for one source: ${err}`);
+      }
+    }
+    return allResults;
+  }
+  /**
+  * 按优先级执行直到成功（switchIfEmpty 语义）
+  * 如果某个 provider 抛错则跳过，尝试下一个
+  */
+  async execute(fn) {
+    let lastError;
+    for (const provider of this.providers) {
+      try {
+        return await fn(provider);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        this.logger.debug(`Provider execute failed, trying next: ${lastError.message}`);
+      }
+    }
+    throw lastError ?? new Error("No providers available");
+  }
+  /**
+  * 移除指定 provider
+  * @returns true if the provider was found and removed
+  */
+  remove(provider) {
+    const idx = this.providers.indexOf(provider);
+    if (idx >= 0) {
+      this.providers.splice(idx, 1);
+      return true;
+    }
+    return false;
+  }
+  getProviders() {
+    return this.providers;
+  }
+  get size() {
+    return this.providers.length;
+  }
+};
+
+// src/fallback-registry.ts
+import { Injectable as Injectable3, Logger as Logger4 } from "@nestjs/common";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var FallbackProviderRegistry = class _FallbackProviderRegistry {
+  static {
+    __name(this, "FallbackProviderRegistry");
+  }
+  logger = new Logger4(_FallbackProviderRegistry.name);
+  delegate = new DefaultProviderRegistry();
+  register(provider) {
+    return this.delegate.register(provider);
+  }
+  unregister(id) {
+    this.delegate.unregister(id);
+  }
+  get(id) {
+    return this.delegate.get(id);
+  }
+  getNow(id) {
+    return this.delegate.getNow(id);
+  }
+  registerIfAbsent(provider) {
+    return this.delegate.registerIfAbsent(provider);
+  }
+  registerIfAbsentWith(id, builder) {
+    return this.delegate.registerIfAbsentWith(id, builder);
+  }
+  getAll() {
+    return this.delegate.getAll();
+  }
+  getDefault() {
+    return this.delegate.getDefault();
+  }
+  setDefault(id) {
+    this.delegate.setDefault(id);
+  }
+  /**
+  * 按序查找 provider：先找主 ID，找不到则依次尝试 fallback ID 列表
+  */
+  getWithFallback(id, ...fallbackIds) {
+    const primary = this.delegate.get(id);
+    if (primary) return primary;
+    for (const fallbackId of fallbackIds) {
+      const fallback = this.delegate.get(fallbackId);
+      if (fallback) {
+        this.logger.debug(`Provider '${id}' not found, using fallback '${fallbackId}'`);
+        return fallback;
+      }
+    }
+    this.logger.debug(`Provider '${id}' and all fallbacks not found`);
+    return void 0;
+  }
+  /**
+  * 找不到指定 ID 的 provider 时返回默认 provider
+  */
+  getOrDefault(id) {
+    return this.delegate.get(id) ?? this.delegate.getDefault();
+  }
+};
+FallbackProviderRegistry = _ts_decorate3([
+  Injectable3()
+], FallbackProviderRegistry);
+
+// src/provider.module.ts
+import { Module, Global } from "@nestjs/common";
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var PROVIDER_REGISTRY = /* @__PURE__ */ Symbol("PROVIDER_REGISTRY");
+var STRATEGY_MANAGER = /* @__PURE__ */ Symbol("STRATEGY_MANAGER");
+var ZuckerProviderModule = class {
+  static {
+    __name(this, "ZuckerProviderModule");
+  }
+};
+ZuckerProviderModule = _ts_decorate4([
+  Global(),
+  Module({
+    providers: [
+      {
+        provide: PROVIDER_REGISTRY,
+        useClass: DefaultProviderRegistry
+      },
+      {
+        provide: STRATEGY_MANAGER,
+        useClass: DefaultStrategyManager
+      }
+    ],
+    exports: [
+      PROVIDER_REGISTRY,
+      STRATEGY_MANAGER
+    ]
+  })
+], ZuckerProviderModule);
+
+// src/resource-manager.ts
+import { Injectable as Injectable4, Logger as Logger5 } from "@nestjs/common";
+import { NotFoundException as NotFoundException3 } from "@zucker-framework/core";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+var ResourceManager = class _ResourceManager {
+  static {
+    __name(this, "ResourceManager");
+  }
+  logger = new Logger5(_ResourceManager.name);
+  providers = /* @__PURE__ */ new Map();
+  /** 注册资源提供者 */
+  registerProvider(provider) {
+    this.providers.set(provider.getType(), provider);
+    this.logger.log(`Resource provider registered: ${provider.getType()}`);
+  }
+  /** 注销资源提供者 */
+  unregisterProvider(type) {
+    this.providers.delete(type);
+  }
+  /**
+  * 根据类型和 ID 获取资源（不存在时返回 undefined）
+  * @param type 资源类型
+  * @param id 资源 ID
+  * @returns 资源实例或 undefined
+  */
+  async getResource(type, id) {
+    const provider = this.providers.get(type);
+    if (!provider) return void 0;
+    return provider.getResource(id);
+  }
+  /**
+  * 根据类型和 ID 获取资源（不存在时抛出 NotFoundException）
+  * @param type 资源类型
+  * @param id 资源 ID
+  * @returns 资源实例
+  * @throws NotFoundException 资源不存在时
+  */
+  async getResourceOrThrow(type, id) {
+    const resource = await this.getResource(type, id);
+    if (resource === void 0 || resource === null) {
+      throw new NotFoundException3(`Resource not found: ${type}/${id}`);
+    }
+    return resource;
+  }
+  /** 获取指定类型的资源提供者 */
+  getProvider(type) {
+    return this.providers.get(type);
+  }
+  /** 获取所有已注册的资源类型 */
+  getTypes() {
+    return Array.from(this.providers.keys());
+  }
+};
+ResourceManager = _ts_decorate5([
+  Injectable4()
+], ResourceManager);
+
+// src/classpath-resource-provider.ts
+import * as fs from "fs";
+import * as path from "path";
+var ClasspathResourceProvider = class {
+  static {
+    __name(this, "ClasspathResourceProvider");
+  }
+  type;
+  basePath;
+  constructor(type, basePath) {
+    this.type = type;
+    this.basePath = basePath;
+  }
+  getType() {
+    return this.type;
+  }
+  async getResource(id) {
+    const filePath = path.join(this.basePath, `${id}.json`);
+    const resolved = path.resolve(filePath);
+    const baseResolved = path.resolve(this.basePath);
+    if (!resolved.startsWith(baseResolved + path.sep) && resolved !== baseResolved) {
+      throw new Error(`Path traversal detected: "${id}"`);
+    }
+    if (!fs.existsSync(filePath)) return void 0;
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+  async listResources() {
+    if (!fs.existsSync(this.basePath)) return [];
+    return fs.readdirSync(this.basePath).filter((f) => f.endsWith(".json")).map((f) => path.basename(f, ".json"));
+  }
+};
+
+// src/file-resource-provider.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var FileResourceProvider = class {
+  static {
+    __name(this, "FileResourceProvider");
+  }
+  type;
+  basePath;
+  extension;
+  constructor(type, basePath, extension = "") {
+    this.type = type;
+    this.basePath = basePath;
+    this.extension = extension;
+  }
+  getType() {
+    return this.type;
+  }
+  async getResource(id) {
+    const filePath = path2.join(this.basePath, this.extension ? `${id}.${this.extension}` : id);
+    const resolved = path2.resolve(filePath);
+    if (!resolved.startsWith(path2.resolve(this.basePath))) {
+      throw new Error("Path traversal detected");
+    }
+    if (!fs2.existsSync(resolved)) return void 0;
+    return fs2.readFileSync(resolved);
+  }
+  async listResources() {
+    if (!fs2.existsSync(this.basePath)) return [];
+    return fs2.readdirSync(this.basePath).map((f) => {
+      if (this.extension) {
+        return path2.basename(f, `.${this.extension}`);
+      }
+      return f;
+    });
+  }
+};
+
+// src/health-check.ts
+import { Logger as Logger6 } from "@nestjs/common";
+var ProviderHealthManager = class _ProviderHealthManager {
+  static {
+    __name(this, "ProviderHealthManager");
+  }
+  registry;
+  logger = new Logger6(_ProviderHealthManager.name);
+  healthState = /* @__PURE__ */ new Map();
+  intervalHandle;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+  * 对所有已注册的 Provider 执行健康检查
+  */
+  async checkAll() {
+    const providers = this.registry.getAll();
+    const results = [];
+    for (const provider of providers) {
+      const info = await this.check(provider);
+      results.push(info);
+    }
+    return results;
+  }
+  /**
+  * 对单个 Provider 执行健康检查
+  */
+  async check(provider) {
+    const existing = this.healthState.get(provider.id) ?? {
+      id: provider.id,
+      status: "unknown",
+      lastChecked: 0,
+      consecutiveFailures: 0,
+      metadata: provider.metadata
+    };
+    const instance = provider.instance;
+    if (!this.isHealthCheckable(instance)) {
+      existing.status = "unknown";
+      existing.lastChecked = Date.now();
+      this.healthState.set(provider.id, existing);
+      return {
+        ...existing
+      };
+    }
+    try {
+      const healthy = await instance.healthCheck();
+      existing.status = healthy ? "healthy" : "unhealthy";
+      existing.consecutiveFailures = healthy ? 0 : existing.consecutiveFailures + 1;
+    } catch (error) {
+      existing.status = "unhealthy";
+      existing.consecutiveFailures += 1;
+      this.logger.warn(`Health check failed for provider "${provider.id}": ${error instanceof Error ? error.message : error}`);
+    }
+    existing.lastChecked = Date.now();
+    this.healthState.set(provider.id, existing);
+    return {
+      ...existing
+    };
+  }
+  /**
+  * 获取所有 Provider 的健康状态
+  */
+  getHealthStatus() {
+    return Array.from(this.healthState.values());
+  }
+  /**
+  * 获取只包含健康 Provider 的列表
+  */
+  getHealthyProviders() {
+    return this.registry.getAll().filter((p) => {
+      const info = this.healthState.get(p.id);
+      return !info || info.status !== "unhealthy";
+    });
+  }
+  /**
+  * 启动定期健康检查
+  */
+  startPeriodicChecks(options) {
+    this.stop();
+    this.intervalHandle = setInterval(() => {
+      this.checkAll().catch((err) => {
+        this.logger.error(`Periodic health check failed: ${err}`);
+      });
+    }, options.intervalMs);
+  }
+  /**
+  * 停止定期健康检查
+  */
+  stop() {
+    if (this.intervalHandle) {
+      clearInterval(this.intervalHandle);
+      this.intervalHandle = void 0;
+    }
+  }
+  /**
+  * 检查 Provider 是否应该被激活（条件激活）
+  */
+  async shouldActivate(provider) {
+    const instance = provider.instance;
+    if (!this.isConditional(instance)) return true;
+    try {
+      return await instance.shouldActivate();
+    } catch {
+      return false;
+    }
+  }
+  isHealthCheckable(instance) {
+    return typeof instance === "object" && instance !== null && "healthCheck" in instance && typeof instance.healthCheck === "function";
+  }
+  isConditional(instance) {
+    return typeof instance === "object" && instance !== null && "shouldActivate" in instance && typeof instance.shouldActivate === "function";
+  }
+};
+export {
+  ClasspathResourceProvider,
+  CompositeProvider,
+  DefaultProviderRegistry,
+  DefaultStrategyManager,
+  FallbackProviderRegistry,
+  FileResourceProvider,
+  HookManager,
+  PROVIDER_REGISTRY,
+  ProviderHealthManager,
+  ResourceManager,
+  STRATEGY_MANAGER,
+  ZuckerProviderModule
+};