Modular Monolith Boilerplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

@Service()
@JsonController('/users')
@UseBefore(AuthMiddleware)
export class UserController extends BaseController {
  constructor(
    @Inject() private readonly userService: UserService,
    @Inject() private readonly cacheService: CacheService
  ) { super(); }

  @Get('/')
  async list(@QueryParam('page') page = 1, @QueryParam('pageSize') pageSize = 20) {
    const cacheKey = this.cacheService.listKey('users', page, pageSize);
    const cached = await this.cacheService.get(cacheKey);
    if (cached) return this.response.paginated(cached.users, cached.total, page, pageSize);

    const { users, total } = await this.userService.list(page, pageSize);
    await this.cacheService.set(cacheKey, { users, total });
    return this.response.paginated(users, total, page, pageSize);
  }

  @Post('/')
  async create(@Body() body: CreateUserRequest, @Res() res: Response) {
    const existing = await this.userService.getByEmail(body.email);
    if (existing) return res.status(HttpStatus.CONFLICT).json(this.response.error('Email already exists'));

    const user = await this.userService.create(body);
    return res.status(HttpStatus.CREATED).json(this.response.success(user));
  }
  // ...update() and delete() follow the same controller -> service -> response shape
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@Service()
export class UserService {
  constructor(
    @Inject('UserInterface') private readonly userRepository: UserInterface,
    @Inject() private readonly mailService: MailService
  ) {}

  async create(data: Parameters<UserInterface['create']>[0]): Promise<User> {
    const hashed = await bcrypt.hash(data.password, 10);
    const user = await this.userRepository.create({ ...data, password: hashed });

    this.mailService
      .sendWelcomeEmail({ email: user.email, name: user.name })
      .catch((err) => logger.warn('Welcome email failed', { email: user.email, err: err.message }));

    return entityToUser(user);
  }

  async getByEmail(email: string): Promise<User | null> {
    const user = await this.userRepository.findOneBy('email', email);
    return user ? entityToUser(user) : null;
  }
  // ...update(), delete(), list() call the same repository, hashing only on password changes
}

1
2
3
4
5
6
7
8

@Service()
export class UserRepository
  extends DrizzleBaseRepository<UserEntity, UserCreateInput, UserUpdateInput>
  implements UserInterface
{
  protected readonly table = user;
  // find, create, update, delete, findAll, findOneBy, listSorted, … — inherited
}

1
2
3
4
5
6
7
8
9
10
11

export const user = pgTable('User', {
  id: uuid('id').primaryKey().defaultRandom(),
  email: varchar('email', { length: 255 }).notNull().unique(),
  password: varchar('password', { length: 255 }).notNull(),
  name: varchar('name', { length: 255 }),
  createdAt: timestamp('createdAt', { mode: 'date' }).defaultNow().notNull(),
  updatedAt: timestamp('updatedAt', { mode: 'date' }).defaultNow().notNull(),
});

export type UserRow = typeof user.$inferSelect;
export type UserInsert = typeof user.$inferInsert;