我想使用typedi在服务构造函数处注入存储库容器

Question

我想在我的UserService上注入存储库。

但我不知道该怎么做。我用的是打字稿，打字和续写。

我认为，这项服务的装载速度比装载机快。

当我试图注入我在数据库加载器上设置的存储库时，就会发生错误。

在容器中找不到这样的错误:带有“存储库”标识符的ServiceNotFoundError: Service。在使用前通过显式调用"Container.set“函数或使用"@Service()”装饰器.注册

所以，我用console.log检查了“console.log”，结果没有定义。我还检查了Container.get(“存储库”)在CreateUser meathod，它加载收集。我的意思是我可以得到我的容器实例。

我只是不能在构造函数中加载存储库实例。

如何在构造函数中加载存储库？我是否应该将后缀改为typeorm来加载这个？

// ** UserService.ts **
import { Inject, Service } from 'typedi';
import { UserRepository } from '../repositories/user.repository';
import { UserCreationAttributes } from '../models/interface/User.interface';
import { User, UserModel, UserStatic } from '../models/User';

@Service()
export default class UserService {
  constructor(@Inject('repositories') private userRepo: UserRepository) {}

  public async CreateUser(userData: UserCreationAttributes): Promise<boolean> {
    try {
      await this.userRepo.create(userData);
      return true;
    } catch (err) {
      console.log(err);
      return false;
    }
  }
}

// ** Database Loader **
import { Sequelize } from 'sequelize';
import config from '../config';
import Logger from './logger';
import { UserStatic } from '../models/User';
import { FeedStatic } from '../models/Feed';
import { CommentStatic } from '../models/Comment';
import { VerificationStatic } from '../models/Verification';
import { initializeModels } from '../models';
import { initializeRepositories, Repositories } from '../repositories';
import { Container } from 'typedi';

export interface Models {
  User: UserStatic;
  Feed: FeedStatic;
  Comment: CommentStatic;
  Verification: VerificationStatic;
}

export default async function loadSequelize() {
  const sequelize = new Sequelize(
    config.database,
    config.databaseUsername,
    config.databasePassword,
    {
      host: config.databaseHost,
      port: config.databasePort,
      dialect: 'postgres',
    },
  );

  try {
    await sequelize.authenticate();
    const models: Models = initializeModels(sequelize);
    const repositories: Repositories = initializeRepositories(models);
    await sequelize.sync({ force: true });

    // This part might be loaded after services were loaded
    Container.set('models', models);
    Container.set('repositories', repositories);


    console.log('load finish');
  } catch (err) {
    Logger.error(err);
  }
}

// ** ./repositories/index.ts **
import { Models } from '../loaders/database';
import { UserRepository } from './user.repository';

export interface Repositories {
  UserRepository: UserRepository;
}
export const initializeRepositories = (models: Models): Repositories => {
  const usersRepository = new UserRepository(models.User);
  const repositories: Repositories = {
    UserRepository: usersRepository,
  };
  return repositories;
};

// ** ./repositories/base.repository.ts **
import { Model, BuildOptions, FindOptions } from 'sequelize/types';
import { IFilter } from './filter/base.filter';

export type RichModel = typeof Model & {
  new (values?: Record<string, unknown>, options?: BuildOptions): Model;
};

export interface IMeta {
  globalCount: number;
  countAfterFiltering: number;
}

export interface IWithMeta<M extends Model> {
  meta: IMeta;
  data: M[];
}

export abstract class BaseRepository<
  M extends Model,
  C extends object,
  F extends IFilter = IFilter
> {
  constructor(public _model: RichModel, private filterFactory: new () => F) {}

  private async getCount(where?: Record<string, unknown>): Promise<number> {
    const count = await this._model.count({ where });
    return count;
  }

  async getAll(params?: FindOptions, filter?: F): Promise<IWithMeta<M>> {
    const { from: offset, count: limit } = filter || {};
    const result = await this._model.findAndCountAll({
      order: [['id', 'ASC']],
      offset: offset,
      limit: limit,
      ...params,
    });

    const globalCount = await this.getCount();
    const countAfterFiltering = ((result.count as unknown) as Record<
      string,
      unknown
    >[]).length;

    return {
      meta: { globalCount, countAfterFiltering },
      data: result.rows as M[],
    };
  }

  async getById(id: string | number): Promise<M> {
    const result = await this._model.findByPk(id);
    return result as M;
  }

  async get(where: Record<string, unknown>): Promise<M> {
    const result = await this._model.findOne({ where });
    return result as M;
  }

  async updateById(id: string | number, data: C): Promise<M> {
    const result = await this._model.update(data, {
      where: { id },
      returning: true,
    });

    const [, models] = result;

    return models[0] as M;
  }

  async deleteById(id: string | number): Promise<void> {
    await this._model.destroy({
      where: { id },
    });
  }

  async create(data: C): Promise<M> {
    const model = await this._model.create(data);
    return (model as unknown) as M;
  }
}

// ** ./repositories/user.repository.ts
import { BaseRepository, IWithMeta, RichModel } from './base.repository';
import { UserModel, UserStatic } from '../models/User';
import { UserCreationAttributes } from '../models/interface/User.interface';
import { IFilter } from './filter/base.filter';
import { UserFilter } from './filter/user.filter';
import { Service } from 'typedi';

@Service()
export class UserRepository extends BaseRepository<
  UserModel,
  UserCreationAttributes,
  IFilter
> {
  constructor(private model: UserStatic) {
    super(<RichModel>model, IFilter);
  }

  async getAllUsers(): Promise<IWithMeta<UserModel>> {
    const users = await this.getAll();
    return users;
  }

  async getOneByFilter({
    email,
    password,
  }: UserFilter): Promise<UserModel | null> {
    const user = await this.model.findOne({
      where: {
        email,
        password,
      },
    });
    return user;
  }

  async getAdminOneByFilter({
    email,
    password,
  }: UserFilter): Promise<UserModel | null> {
    const user = await this.model.findOne({
      where: {
        email,
        password,
        isAdmin: true,
      },
    });
    return user;
  }
}

Answer 1

首先，尝试将initializeRepositories调用放在reflect-metadata调用之后，以测试执行顺序是否会产生影响。您不需要在数据库连接文件中调用。

从我在旧文档中看到的情况来看，要使用Container.set设置所有repos，您需要为它们提供一个包含有id的对象的数组。

Container.set([{ id: 'userRepository', value: new UserRepository() }])

如果您只需要设置一个存储库：

Container.set('userRepository', new UserRepository())

在上述两种情况下，您使用的是：Container.get('userRepository')；

如果希望将引用保留为repositories，则可以使用initializeRepositories方法，但用法必须如下：

@Inject('repositories') repositories: { UserRepository: UserRepository}; 

repositories.UserRepository

如果您不需要从该方法中设置存储库，那么只需在@Service('userRepository')类中添加一个装饰器UserRepository，它就可以工作了。