packages
├── common
├── core
├── microservices
├── platform-express
├── platform-fastify
├── platform-socket.io
├── platform-ws
├── testing
└── websockets

@Module({
  imports: [...],
  controllers: [...],
  providers: [...],
  exports: [...].
})
export class CatsModule {}

const app = await NestFactory.createApplicationContext(AppModule);
const tasksService = app.get(TasksService);

await NestFactory.create(AppModule)

public async create(...){
    ...
    // 创建配置和容器的实例
    const applicationConfig = new ApplicationConfig();
    const container = new NestContainer(applicationConfig);
    ...

    // 初始化模块，实例化对象，完成依赖注入
    await this.initialize(
      moduleCls,
      container,
      graphInspector,
      applicationConfig,
      appOptions,
      httpServer,
    );

    // 创建NestApp实例并为其创建代理
    const instance = new NestApplication(
      container,
      httpServer,
      applicationConfig,
      graphInspector,
      appOptions,
    );
    const target = this.createNestInstance(instance);
    return this.createAdapterProxy<T>(target, httpServer);
  }

private async initialize(...) {
    ...

    const injector = new Injector({ preview: options.preview });
    const instanceLoader = new InstanceLoader(...);
    const metadataScanner = new MetadataScanner();
    const dependenciesScanner = new DependenciesScanner(...);
    ...
    try {
      // 用过模块间的依赖关系，创建出依赖树
      await dependenciesScanner.scan(module);
      // 实例化模块中的可注入对象，并进行依赖注入
      await instanceLoader.createInstancesOfDependencies();
      // 应用全局enhancer
      dependenciesScanner.applyApplicationProviders();
    } catch (e) {
      this.handleInitializationError(e);
    }
  }

public async scan(module: Type<any>) {
    // 注册核心模块
    await this.registerCoreModule();
    // 深度优先扫描模块，构造模块依赖树
    await this.scanForModules(module);
    // 扫描模块的依赖，向容器注册
    await this.scanModulesForDependencies();
    this.calculateModulesDistance();

    this.addScopedEnhancersMetadata();
    this.container.bindGlobalScope();
  }

public async scanForModules(...): Promise<Module[]> {
    // 实例化module并将module加入全局容器NestContainer中
    const moduleInstance = await this.insertModule(moduleDefinition, scope);
    ...
    // ctxRegistry用于记录已扫描的module
    ctxRegistry.push(moduleDefinition);
    ...
    // 从reflect metadata中取出当前module依赖的所有module
    const modules = this.reflectMetadata(
          MODULE_METADATA.IMPORTS,
          moduleDefinition as Type<any>,
        )

    let registeredModuleRefs = [];
    // 遍历当前模块所依赖的所有模块
    for (const [index, innerModule] of modules.entries()) {
      ...
      if (ctxRegistry.includes(innerModule)) {
        // 遇到已经扫描过的module，则跳过
        continue;
      }
      // 递归调用自身
      const moduleRefs = await this.scanForModules(
        innerModule,
        [].concat(scope, moduleDefinition),
        ctxRegistry,
      );
      registeredModuleRefs = registeredModuleRefs.concat(moduleRefs);
    }
    if (!moduleInstance) {
      return registeredModuleRefs;
    }
    return [moduleInstance].concat(registeredModuleRefs);
  }

...
const { type, dynamicMetadata, token } = await this.moduleCompiler.compile(
      metatype,
    );
...
const moduleRef = new Module(type, this);
...
this.modules.set(token, moduleRef);
...

@Module({
  imports: [...],
  providers: [...],
  exports: [...],
})
export class CatModule {}

public async scanModulesForDependencies(
    modules: Map<string, Module> = this.container.getModules(),
  ) {
    for (const [token, { metatype }] of modules) {
      await this.reflectImports(metatype, token, metatype.name);
      this.reflectProviders(metatype, token);
      this.reflectControllers(metatype, token);
      this.reflectExports(metatype, token);
    }
  }

public async addImport(
    relatedModule: Type<any> | DynamicModule,
    token: string,
  ) {
    if (!this.modules.has(token)) {
      return;
    }
    const moduleRef = this.modules.get(token);
    const { token: relatedModuleToken } = await this.moduleCompiler.compile(
      relatedModule,
    );
    // 当前处理的模块
    const related = this.modules.get(relatedModuleToken);
    moduleRef.addRelatedModule(related);
  }

...
this._providers.set(
      provider,
      new InstanceWrapper({
        token: provider,
        name: (provider as Type<Injectable>).name,
        metatype: provider as Type<Injectable>,
        instance: null,
        isResolved: false,
        scope: getClassScope(provider),
        durable: isDurable(provider),
        host: this,
      }),
    );
...

public reflectDynamicMetadata(cls: Type<Injectable>, token: string) {
    if (!cls || !cls.prototype) {
      return;
    }
    this.reflectInjectables(cls, token, GUARDS_METADATA);
    this.reflectInjectables(cls, token, INTERCEPTORS_METADATA);
    this.reflectInjectables(cls, token, EXCEPTION_FILTERS_METADATA);
    this.reflectInjectables(cls, token, PIPES_METADATA);
    this.reflectParamInjectables(cls, token, ROUTE_ARGS_METADATA);
  }

public async createInstancesOfDependencies(
    modules: Map<string, Module> = this.container.getModules(),
  ) {
    // 使用原型链创建空实例
    this.createPrototypes(modules);
    // 装填实例
    await this.createInstances(modules);
    ...
  }

  public loadPrototype<T>(
    { token }: InstanceWrapper<T>,
    collection: Map<InstanceToken, InstanceWrapper<T>>,
    contextId = STATIC_CONTEXT,
  ) {
    if (!collection) {
      return;
    }
    // 获取InstanceWrapper
    const target = collection.get(token);
    // 使用原型链创建空实例
    const instance = target.createPrototype(contextId);
    if (instance) {
      // 将新的InstanceWrapper写回
      const wrapper = new InstanceWrapper({
        ...target,
        instance,
      });
      collection.set(token, wrapper);
    }
  }

public async loadInstance<T>(
    wrapper: InstanceWrapper<T>,
    collection: Map<InstanceToken, InstanceWrapper>,
    moduleRef: Module,
    contextId = STATIC_CONTEXT,
    inquirer?: InstanceWrapper,
  ) {
    ...
    const token = wrapper.token || wrapper.name;

    const { inject } = wrapper;
    const targetWrapper = collection.get(token);
    ...
    // 定义callback，该hook在解析出对象的所有依赖后被调用，用以执行
    const callback = async (instances: unknown[]) => {
      ...
    };
    // 从对象构造函数中提取依赖
    await this.resolveConstructorParams<T>(
      wrapper,
      moduleRef,
      inject,
      callback,
      contextId,
      wrapper,
      inquirer,
    );
  }

@Injectable()
class AppService {
  constructor(private readonly CatService) {}
}

AppService = __decorate([
    (0, common_1.Injectable)(),
    __metadata("design:paramtypes", [CatService])
], AppService);

const callback = async (instances: unknown[]) => {
  // 获取属性依赖
  const properties = await this.resolveProperties(
    wrapper,
    moduleRef,
    inject as InjectionToken[],
    contextId,
    wrapper,
    inquirer,
  );
  // 装填实例
  const instance = await this.instantiateClass(
    instances,
    wrapper,
    targetWrapper,
    contextId,
    inquirer,
  );
  // 装填属性
  this.applyProperties(instance, properties);
  wrapper.initTime = this.getNowTimestamp() - t0;
  done();
};

@Injectable()
export class HttpService<T> {
  @Inject('HTTP_OPTIONS')
  private readonly httpClient: T;
}

instanceHost.instance = new (metatype as Type<any>)(...instances)

instanceHost.instance = Object.assign(
  instanceHost.instance,
  new (metatype as Type<any>)(...instances),
)

iterate(properties)
  .filter(item => !isNil(item.instance))
  .forEach(item => (instance[item.key] = item.instance));