feat: implemented user model with mongo integration

apps/sample-verifier/src/config/config.ts

@@ -4,6 +4,7 @@ import {
   createWalletClient,
   custom,
   http,
+  WalletClient,
 } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { mainnet, goerli } from 'viem/chains';
@@ -68,7 +69,7 @@ function getMockConnector(chain: Chain) {
   return new MockConnector({ options: mockOptions });
 }
 
-export function getWalletClient() {
+export function getWalletClient(): WalletClient {
   const chain = getChain();
 
   if (import.meta.env.MODE === 'e2e') {

apps/server/.gitignore

@@ -0,0 +1 @@
+scripts/init-mongo.js

apps/server/scripts/init-mongo.js.template

@@ -0,0 +1,11 @@
+const MONGO_DATABASE = '<MONGO_DATABASE>';
+const MONGO_DATABASE_USERNAME = '<MONGO_DATABASE_USERNAME>';
+const MONGO_DATABASE_PASSWORD = '<MONGO_DATABASE_PASSWORD>';
+
+db = db.getSiblingDB(MONGO_DATABASE);
+
+db.createUser({
+  user: MONGO_DATABASE_USERNAME,
+  pwd: MONGO_DATABASE_PASSWORD,
+  roles: [{ role: 'readWrite', db: MONGO_DATABASE }],
+});

apps/server/scripts/start-db.js

@@ -0,0 +1,31 @@
+const { join } = require('path');
+const shell = require('shelljs');
+require('dotenv').config({
+  path: join(__dirname, '..', '.env.local'),
+});
+
+let template = shell.cat(join(__dirname, 'init-mongo.js.template'));
+const replaceTerms = [
+  'MONGO_DATABASE',
+  'MONGO_DATABASE_USERNAME',
+  'MONGO_DATABASE_PASSWORD',
+];
+
+replaceTerms.forEach((term) => {
+  template = template.replaceAll(`<${term}>`, process.env[term]);
+});
+
+const outputFile = join(__dirname, 'init-mongo.js');
+shell.ShellString(template).to(outputFile);
+
+const command = `docker run \
+--name ${process.env.MONGO_CONTAINER_NAME} \
+-e MONGO_INITDB_ROOT_USERNAME=${process.env.MONGO_INITDB_ROOT_USERNAME} \
+-e MONGO_INITDB_ROOT_PASSWORD=${process.env.MONGO_INITDB_ROOT_PASSWORD} \
+-p 27017:27017 \
+-v ${outputFile}:/docker-entrypoint-initdb.d/init-mongo.js:ro \
+mongo`;
+
+shell.exec(`docker stop ${process.env.MONGO_CONTAINER_NAME}`);
+shell.exec(`docker rm ${process.env.MONGO_CONTAINER_NAME}`);
+shell.exec(command);

apps/server/src/app/app.module.ts

@@ -1,10 +1,33 @@
 import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ConfigModule, ConfigService } from '@nestjs/config';
 
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { UsersModule } from '../user/user.module';
+import { Config, getConfig } from '../config/configuration';
 
 @Module({
-  imports: [],
+  imports: [
+    ConfigModule.forRoot({
+      envFilePath: ['.env', '.env.local'],
+      load: [getConfig],
+    }),
+    MongooseModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => {
+        const host = configService.get<Config>('mongo.host');
+        const database = configService.get<Config>('mongo.database');
+        const username = configService.get<Config>('mongo.username');
+        const password = configService.get<Config>('mongo.password');
+        return {
+          uri: `mongodb://${username}:${password}@${host}/${database}`,
+        };
+      },
+    }),
+    UsersModule,
+  ],
   controllers: [AppController],
   providers: [AppService],
 })

apps/server/src/config/configuration.ts

@@ -0,0 +1,38 @@
+export interface Config {
+  mongo: {
+    username: string;
+    password: string;
+    host: string;
+    database: string;
+  };
+}
+
+class PropertyNotFoundError extends Error {
+  constructor(missingProperties: string[]) {
+    const missings = missingProperties.join(', ');
+    super(`The following properties could not be found: ${missings}`);
+    this.name = 'PropertyNotFoundError';
+    Object.setPrototypeOf(this, PropertyNotFoundError.prototype);
+  }
+}
+
+export function getConfig(): Config {
+  const config = {
+    mongo: {
+      username: process.env.MONGO_DATABASE_USERNAME,
+      password: process.env.MONGO_DATABASE_PASSWORD,
+      host: process.env.MONGO_HOST,
+      database: process.env.MONGO_DATABASE,
+    },
+  };
+
+  const missingProperties = Object.keys(config.mongo).filter(
+    (key) => !config.mongo[key]
+  );
+
+  if (missingProperties.length > 0) {
+    throw new PropertyNotFoundError(missingProperties);
+  }
+
+  return config;
+}

apps/server/src/user/create-user.dto.ts

@@ -0,0 +1,3 @@
+export class CreateUserDto {
+  nationalId: string;
+}

apps/server/src/user/schemas/user.schema.ts

@@ -0,0 +1,12 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+
+export type UserDocument = HydratedDocument<User>;
+
+@Schema()
+export class User {
+  @Prop({ required: true })
+  nationalId: string;
+}
+
+export const UserSchema = SchemaFactory.createForClass(User);

apps/server/src/user/user.controller.ts

@@ -0,0 +1,19 @@
+import { Body, Controller, Get, Post } from '@nestjs/common';
+import { User } from './schemas/user.schema';
+import { UsersService } from './user.service';
+import { CreateUserDto } from './create-user.dto';
+
+@Controller('users')
+export class UsersController {
+  constructor(private usersService: UsersService) {}
+
+  @Post()
+  create(@Body() createUserDto: CreateUserDto) {
+    this.usersService.create(createUserDto);
+  }
+
+  @Get()
+  findAll(): Promise<User[]> {
+    return this.usersService.findAll();
+  }
+}

apps/server/src/user/user.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { User, UserSchema } from './schemas/user.schema';
+import { UsersController } from './user.controller';
+import { UsersService } from './user.service';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+  ],
+  controllers: [UsersController],
+  providers: [UsersService],
+})
+export class UsersModule {}

apps/server/src/user/user.service.ts

@@ -0,0 +1,27 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { User } from './schemas/user.schema';
+import { CreateUserDto } from './create-user.dto';
+import { Model } from 'mongoose';
+
+@Injectable()
+export class UsersService implements OnModuleInit {
+  constructor(@InjectModel(User.name) private userModel: Model<User>) {}
+
+  async create(createUserDto: CreateUserDto): Promise<User> {
+    const createdUser = new this.userModel(createUserDto);
+    return createdUser.save();
+  }
+
+  async findAll(): Promise<User[]> {
+    return this.userModel.find().exec();
+  }
+
+  async onModuleInit() {
+    const count = await this.userModel.count();
+    if (count === 0) {
+      const dto: CreateUserDto = { nationalId: 'A123456789' };
+      return this.create(dto);
+    }
+  }
+}