Class PoolingService

extensions/pooling/src/pooling.ts:139–275

 */
@injectable({scope: BindingScope.SINGLETON})
export class PoolingService<T> implements LifeCycleObserver {
  private readonly factory: PoolFactory<T>;
  /**
   * The resource pool
   */
  readonly pool: Pool<T>;

  constructor(
    @inject.context() readonly context: Context,
    @config() private options: PoolingServiceOptions<T>,
  ) {
    let factory = this.options.factory;
    if (typeof factory === 'function') {
      factory = factory(this.context);
    }
    this.factory = factory;
    this.options = {...options, factory};
    this.pool = createPool(factory, {
      max: 8, // Default to 8 instances
      ...this.options.poolOptions,
      // Disable `autostart` so that it follows LoopBack application life cycles
      autostart: false,
    });
  }

  /**
   * Start the pool
   */
  start() {
    if (this.options.poolOptions?.autostart !== false) {
      debug('Starting pool for context %s', this.context.name);
      this.pool.start();
    }
  }

  /**
   * Stop the pool
   */
  async stop() {
    debug('Stopping pool for context %s', this.context.name);
    if (this.pool == null) return;
    await this.pool.drain();
    await this.pool.clear();
  }

  /**
   * Acquire a new instance
   * @param requestCtx - Optional request context, default to the owning context
   */
  async acquire(requestCtx: Context = this.context) {
    debug('Acquiring a resource from the pool for context %s', requestCtx.name);
    const resource = await this.pool.acquire();

    try {
      // Try factory-level acquire hook first
      if (this.factory.acquire) {
        await this.factory.acquire(resource, requestCtx);
      } else {