Ecosystem — DI 위에서 동작하는 패키지들

export abstract class CqrsBusBase {
  protected readonly handlerInstances = new Map<Token, Promise<unknown>>();

  constructor(
    protected readonly runtimeContainer: Container,
    protected readonly compiledModules: readonly CompiledModule[],
    protected readonly logger: ApplicationLogger,
  ) {}

  protected discoveryCandidates(): DiscoveryCandidate[] {
    const candidates: DiscoveryCandidate[] = [];

    // bootstrap이 끝난 뒤의 compiled module graph를 순회한다.
    // CQRS는 별도 registry를 만들지 않고, DI에 등록된 provider/controller를 discovery source로 사용한다.
    for (const compiledModule of this.compiledModules) {
      for (const provider of compiledModule.definition.providers ?? []) {
        if (typeof provider === 'function') {
          candidates.push({
            moduleName: compiledModule.type.name,
            scope: scopeFromProvider(provider),
            targetType: provider,
            token: provider,
          });
          continue;
        }

        if (isClassProvider(provider)) {
          candidates.push({
            moduleName: compiledModule.type.name,
            scope: scopeFromProvider(provider),
            targetType: provider.useClass,
            token: provider.provide,
          });
        }
      }

      // controller도 DI가 알고 있는 class token이므로 handler decorator 탐색 후보에 포함된다.
      for (const controller of compiledModule.definition.controllers ?? []) {
        candidates.push({
          moduleName: compiledModule.type.name,
          scope: scopeFromProvider(controller),
          targetType: controller,
          token: controller,
        });
      }
    }

    return candidates;
  }
}

for (const candidate of this.discoveryCandidates()) {
  const metadata = getCommandHandlerMetadata(candidate.targetType);

  if (!metadata) {
    continue;
  }

  if (candidate.scope !== 'singleton') {
    this.logger.warn(
      `${candidate.targetType.name} in module ${candidate.moduleName} declares @CommandHandler() but is registered with ${candidate.scope} scope. Command handlers are registered only for singleton providers.`,
      'CommandBusLifecycleService',
    );
    continue;
  }

  // command type -> handler descriptor 등록
}

protected async preloadHandlerInstance(token: Token): Promise<void> {
  if (this.handlerInstances.has(token)) {
    return;
  }

  // handler 인스턴스는 runtime container에서 resolve하고 Promise를 먼저 캐시한다.
  // 동시에 같은 handler를 preload해도 중복 생성하지 않기 위해서다.
  const resolving = this.runtimeContainer.resolve(token);
  this.handlerInstances.set(token, resolving);

  try {
    await resolving;
  } catch (error) {
    // 실패한 Promise는 캐시에 남기지 않아 다음 bootstrap/dispatch에서 재시도할 수 있다.
    this.handlerInstances.delete(token);
    throw error;
  }
}

export class ConfigModule {
  static forRoot(options?: ConfigModuleOptions): new () => ConfigModule {
    // options를 snapshot으로 고정해 module metadata가 나중에 외부 객체 변경의 영향을 받지 않게 한다.
    const loadOptions = snapshotConfigModuleOptions(options);
    // forRoot 호출마다 고유한 module class를 만들어 서로 다른 설정을 담을 수 있게 한다.
    class ConfigModuleImpl extends ConfigModule {}

    const providers: NonNullable<ModuleMetadata['providers']> = [
      {
        provide: ConfigService,
        // ConfigService는 factory에서 한 번 로드한 설정 snapshot을 감싼다.
        useFactory: () => createConfigServiceFromSnapshot(loadConfig(loadOptions)),
      },
    ];

    if (loadOptions.watch) {
      providers.push(
        {
          provide: CONFIG_MODULE_WATCH_OPTIONS,
          useValue: loadOptions,
        },
        ConfigModuleWatchManager,
      );
    }

    defineModuleMetadata(ConfigModuleImpl, {
      global: loadOptions.global ?? true,
      exports: [ConfigService],
      providers,
    });

    return ConfigModuleImpl;
  }
}

@Inject(ConfigService, CONFIG_MODULE_WATCH_OPTIONS)
class ConfigModuleWatchManager {
  private reloader: ConfigReloader | undefined;
  private reloadForwarder: ConfigReloadSubscription | undefined;

  onApplicationBootstrap(): void {
    if (!this.options.watch) {
      return;
    }

    if (this.reloader) {
      return;
    }

    this.reloader = createConfigReloader(this.options);
    this.reloadForwarder = this.reloader.subscribe((snapshot) => {
      const previousConfig = this.config.snapshot();

      try {
        replaceConfigServiceSnapshotUnchecked(this.config, snapshot);
      } catch (error: unknown) {
        replaceConfigServiceSnapshotUnchecked(this.config, previousConfig);
        throw error;
      }
    });
  }

  onModuleDestroy(): void {
    this.reloadForwarder?.unsubscribe();
    this.reloadForwarder = undefined;
    this.reloader?.close();
    this.reloader = undefined;
  }
}

export const CONFIG_RELOADER = Symbol('fluo.config.reloader');

export class ConfigReloadModule {
  static forRoot(options?: ConfigLoadOptions): new () => ConfigReloadModule {
    const loadOptions = snapshotConfigLoadOptions(options);
    class ConfigReloadModuleImpl extends ConfigReloadModule {}

    defineModuleMetadata(ConfigReloadModuleImpl, {
      exports: [CONFIG_RELOADER],
      providers: [
        { provide: CONFIG_RELOAD_OPTIONS, useValue: loadOptions },
        ConfigReloadManager,
        { provide: CONFIG_RELOADER, useExisting: ConfigReloadManager },
      ],
    });

    return ConfigReloadModuleImpl;
  }
}

function createRootDispatchScope(rootContainer: Container): DispatchScope {
  return {
    // guard/interceptor가 없으면 root container를 그대로 써 singleton 경로를 유지한다.
    container: rootContainer,
    requestScoped: false,
  };
}

function createRequestDispatchScope(rootContainer: Container): DispatchScope {
  return {
    // 요청별 상태가 필요하면 child container를 만들어 request-scoped provider를 격리한다.
    container: rootContainer.createRequestScope(),
    requestScoped: true,
  };
}

function compileHandlerExecutionPlan(
  handler: HandlerDescriptor,
  options: CreateDispatcherOptions,
): CompiledHandlerExecutionPlan {
  const routeGuards = handler.route.guards ?? [];
  const requestScope = compileMiddlewareScopePlan(handler.metadata.moduleMiddleware);
  const mergedInterceptors = mergeInterceptors(options.interceptors ?? [], handler.route.interceptors ?? []);

  return {
    mergedInterceptors,
    requestScope,
    // true면 요청마다 child container를 만들고 dispatch 후 dispose한다.
    requiresRequestScope:
      routeGuards.length > 0
      || mergedInterceptors.length > 0
      || requestScope.alwaysRequiresRequestScope
      || requestDtoMayRequireRequestScope(handler, options)
      || handlerMethodMayUseRequestContext(handler)
      || (hasRequestScopeInspector(options.rootContainer)
        ? options.rootContainer.hasRequestScopedDependency(handler.controllerToken)
        : true),
    routeGuards,
  };
}

function determineRequestScopeRequirement(
  handler: HandlerDescriptor,
  options: CreateDispatcherOptions,
): boolean {
  // guard/interceptor/middleware는 요청별 principal, header, body에 접근할 수 있으므로 request scope가 안전하다.
  if (handler.route.guards && handler.route.guards.length > 0) {
    // inspector가 없으면 singleton으로 단정하지 않고 보수적으로 request scope를 사용한다.
  return true;
  }
  if (handler.route.interceptors && handler.route.interceptors.length > 0) {
    return true;
  }
  if (handler.metadata.moduleMiddleware && handler.metadata.moduleMiddleware.length > 0) {
    return true;
  }
  if (requestDtoMayRequireRequestScope(handler, options)) {
    return true;
  }
  if (hasRequestScopeInspector(options.rootContainer)) {
    // DI container가 controller 의존성 그래프에 request scope가 섞였는지 판정한다.
    return options.rootContainer.hasRequestScopedDependency(handler.controllerToken);
  }
  return true;
}

@Module({
  imports: [
    // Config/CQRS 모두 DI module entrypoint를 제공하므로 AppModule은 import만으로 기능을 조립한다.
    ConfigModule.forRoot({ envFile: '.env' }),
    CqrsModule.forRoot(),
  ],
})
class AppModule {}

@Inject(RUNTIME_CONTAINER, COMPILED_MODULES, APPLICATION_LOGGER)
export class CommandBusLifecycleService extends CqrsBusBase {
  // compiled modules를 읽어 handler를 발견하고,
  // runtime container로 handler instance를 resolve한다.
}