define the user management database

src/app.module.ts

@@ -11,6 +11,7 @@ import { AirportController } from './airport/airport.controller';
 import { InboundModule } from './inbound/inbound.module';
 import { InboundController } from './inbound/inbound.controller';
 import { WeatherModule } from './weather/weather.module';
+import { UserModule } from './user/user.module';
 
 @Module({
   imports: [
@@ -35,6 +36,7 @@ import { WeatherModule } from './weather/weather.module';
     LoggingModule,
     InboundModule,
     WeatherModule,
+    UserModule,
   ],
   controllers: [LoggingController, AirportController, InboundController],
 })

src/user/models/user.model.ts

@@ -0,0 +1,39 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+
+export type UserDocument = User & Document;
+
+@Schema()
+export class User {
+  @Prop({
+    required: true,
+    index: true,
+    type: Number,
+  })
+  vatsimId: number;
+
+  @Prop({
+    required: true,
+    type: String,
+  })
+  apiCode: string;
+
+  @Prop({
+    type: Boolean,
+    default: false,
+  })
+  systemAdminAccess: boolean;
+
+  @Prop({
+    type: [String],
+    default: [],
+  })
+  airportAdminAccess: string[];
+
+  @Prop({
+    type: String,
+  })
+  fullName: string;
+}
+
+export const UserSchema = SchemaFactory.createForClass(User);

src/user/user.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { UserSchema } from './models/user.model';
+import { UserService } from './user.service';
+
+@Module({
+  imports: [MongooseModule.forFeature([{ name: 'user', schema: UserSchema }])],
+  providers: [UserService],
+  exports: [MongooseModule, UserService],
+})
+export class UserModule {}

src/user/user.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UserService } from './user.service';
+
+describe('UserService', () => {
+  let service: UserService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [UserService],
+    }).compile();
+
+    service = module.get<UserService>(UserService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/user/user.service.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { randomBytes } from 'crypto';
+import { Model } from 'mongoose';
+import { UserDocument, User } from './models/user.model';
+
+const ApiKeyLength = 64;
+
+@Injectable()
+export class UserService {
+  constructor(
+    @InjectModel('user')
+    private readonly userModel: Model<UserDocument>,
+  ) {}
+
+  private static createApiKey(): string {
+    return randomBytes(ApiKeyLength).toString('hex');
+  }
+
+  async register(vatsimId: number, fullName: string): Promise<User> {
+    return this.user(vatsimId).then((user) => {
+      if (user) return user;
+
+      return this.userModel
+        .create({
+          vatsimId,
+          apiCode: UserService.createApiKey(),
+          systemAdminAccess: false,
+          airportAdminAccess: [],
+          fullName,
+        })
+        .then(() => this.user(vatsimId));
+    });
+  }
+
+  async user(vatsimId: number): Promise<User | undefined> {
+    return this.userModel.findOne({ vatsimId });
+  }
+
+  async refreshApiKey(vatsimId: number): Promise<User | undefined> {
+    return this.userModel
+      .findOneAndUpdate({ vatsimId }, { apiCode: UserService.createApiKey() })
+      .then(() =>
+        this.user(vatsimId).then((user) => {
+          if (!user) return undefined;
+          return user;
+        }),
+      );
+  }
+}