我想在我的UserService中注入存储库。
但我不知道该怎么做。我正在使用typescript、typedi和sequelize。
我认为,服务加载速度比加载程序快。
当我尝试注入我在数据库加载器上设置的存储库时,会发生错误。
错误如下:ServiceNotFoundError:Service with"存储库";在容器中找不到标识符。在使用前通过显式调用";Container.set";函数或使用"@服务((";装饰师
所以,我检查了";userRepo";使用console.log,结果未定义。我还在CreateUser方法中检查了Container.get("positories"(,它加载得很好。我的意思是,我可以得到我的Container实例。
我只是无法在构造函数中加载存储库实例。
我应该如何在构造函数中加载存储库?我应该把sequelize改成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;
}
}
首先,尝试将initializeRepositories
调用放在reflect-metadata
调用之后,以测试执行顺序是否会产生影响。您不需要在数据库连接文件内部调用。
从我在旧文档中看到的情况来看,要使用Container.set
来设置所有的repo,需要提供一个数组,其中包含带有id的对象。
Container.set([{ id: 'userRepository', value: new UserRepository() }])
如果您只需要设置一个存储库:
Container.set('userRepository', new UserRepository())
在以上两种情况下,都使用like:Container.get('userRepository')
;
如果你想保持引用为repositories
,你的initializeRepositories
方法是可以的,但用法必须像:
@Inject('repositories') repositories: { UserRepository: UserRepository};
repositories.UserRepository
如果不需要使用该方法设置存储库,只需在UserRepository
类中放置一个decorator @Service('userRepository')
即可。