feat(api): refactored to share more code between frontend and backend

Author: xmlking

apps/api/src/app/auth/auth.module.ts

@@ -1,22 +1,17 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { APP_GUARD } from '@nestjs/core';
-import { TypeOrmModule } from '@nestjs/typeorm';
-
-import { AuthService } from './auth.service';
-import { AuthController } from './auth.controller';
-import { User } from './user.entity';
 import { JwtStrategy } from './passport/jwt.strategy';
 import { AuthGuard } from './guards/auth.guard';
 import { AllowGuard } from './guards/allow.guard';
 import { RoleGuard } from './guards/role.guard';
 import { ComposeGuard } from './guards/compose.guard';
 import { WsAuthGuard } from './guards/ws-auth.guard';
 import { WsJwtStrategy } from './passport/ws-jwt.strategy';
+import { UserModule } from '../user';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([User])],
+  imports: [UserModule],
   providers: [
-    AuthService,
     JwtStrategy,
     WsJwtStrategy,
     AllowGuard,
@@ -40,7 +35,6 @@ import { WsJwtStrategy } from './passport/ws-jwt.strategy';
       useClass: ComposeGuard,
     },
   ],
-  controllers: [AuthController],
-  exports: [AuthService, AuthGuard, WsAuthGuard],
+  exports: [AuthGuard, WsAuthGuard],
 })
 export class AuthModule {}

apps/api/src/app/auth/guards/auth.guard.ts

@@ -1,6 +1,7 @@
 import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
 import * as passport from 'passport';
 import { HttpAuthException } from '../auth.exception';
+import { User, JwtToken } from '@ngx-starter-kit/models';
 
 export const defaultOptions = {
   session: false,
@@ -16,7 +17,7 @@ export const defaultOptions = {
 };
 
 const createPassportContext = (request, response) => (type, options) =>
-  new Promise((resolve, reject) =>
+  new Promise<{ user: User; info: JwtToken }>((resolve, reject) =>
     passport.authenticate(type, options, (err, user, info) => {
       try {
         return resolve(options.callback(err, user, info));
@@ -36,8 +37,8 @@ export class AuthGuard implements CanActivate {
     const [request, response] = [httpContext.getRequest(), httpContext.getResponse()];
     const passportFn = createPassportContext(request, response);
     const userAndInfo = await passportFn('jwt', defaultOptions);
-    request[defaultOptions.property] = (userAndInfo as any).user;
-    request[defaultOptions.infoProperty] = (userAndInfo as any).info;
+    request[defaultOptions.property] = userAndInfo.user;
+    request[defaultOptions.infoProperty] = userAndInfo.info;
     return true;
   }
 }

apps/api/src/app/auth/guards/role.guard.ts

@@ -26,6 +26,7 @@ export class RoleGuard implements CanActivate {
       throw new UnauthorizedException('RoleGuard should have been executed after AuthGuard');
     }
 
+    // FIXME: useless
     if (endpointRoles.includes(RolesEnum.SELF)) {
       if (token.preferred_username === this.resolveUsername(request)) {
         return true;
@@ -38,15 +39,15 @@ export class RoleGuard implements CanActivate {
       if (this.isRoleOverlay(token.realm_access.roles, [RolesEnum.ADMIN])) {
         return true;
       } else {
-        throw new ForbiddenException(`SumoApp admin users only`);
+        throw new ForbiddenException(`NgxApp admin users only`);
       }
     }
 
     if (endpointRoles.includes(RolesEnum.USER)) {
       if (this.isRoleOverlay(token.realm_access.roles, [RolesEnum.USER])) {
         return true;
       } else {
-        throw new ForbiddenException(`SumoApp users only`);
+        throw new ForbiddenException(`NgxApp users only`);
       }
     }
 

apps/api/src/app/auth/guards/ws-auth.guard.ts

@@ -1,6 +1,7 @@
 import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
 import * as passport from 'passport';
 import { WsAuthException } from '../auth.exception';
+import { User, JwtToken } from '@ngx-starter-kit/models';
 
 export const defaultWsOptions = {
   session: false,
@@ -16,7 +17,7 @@ export const defaultWsOptions = {
 };
 
 const createPassportContext = (request, response) => (type, options) =>
-  new Promise((resolve, reject) =>
+  new Promise<{ user: User; info: JwtToken }>((resolve, reject) =>
     passport.authenticate(type, options, (err, user, info) => {
       try {
         return resolve(options.callback(err, user, info));
@@ -37,8 +38,8 @@ export class WsAuthGuard implements CanActivate {
     const passportFn = createPassportContext(request, {});
     try {
       const userAndInfo = await passportFn('ws-jwt', defaultWsOptions);
-      request[defaultWsOptions.property] = (userAndInfo as any).user;
-      request[defaultWsOptions.infoProperty] = (userAndInfo as any).info;
+      request[defaultWsOptions.property] = userAndInfo.user;
+      request[defaultWsOptions.infoProperty] = userAndInfo.info;
       return true;
     } catch (err) {
       request.disconnect();

apps/api/src/app/auth/index.ts

@@ -1,6 +1,4 @@
-export * from './auth.module';
-export * from './auth.service';
-export * from './user.entity';
+export { AuthModule } from './auth.module';
 export * from './decorators';
-export * from './guards/ws-auth.guard';
-export * from './guards/auth.guard';
+export { WsAuthGuard } from './guards/ws-auth.guard';
+export { AuthGuard } from './guards/auth.guard';

apps/api/src/app/auth/passport/jwt.strategy.ts

@@ -3,13 +3,13 @@ import { PassportStrategy } from '@nestjs/passport';
 import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { passportJwtSecret, SigningKeyNotFoundError } from '@xmlking/jwks-rsa';
 
-import { AuthService } from '../auth.service';
-import { JwtToken } from '../interfaces/jwt-token.interface';
 import { environment as env } from '@env-api/environment';
+import { JwtToken } from '@ngx-starter-kit/models';
+import { UserService } from '../../user';
 
 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy) {
-  constructor(private readonly authService: AuthService) {
+  constructor(private readonly userService: UserService) {
     super({
       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
       // secretOrKey: env.auth.publicKey,
@@ -36,7 +36,7 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
 
   // tslint:disable-next-line:ban-types
   async validate(token: any, done: Function) {
-    const user = await this.authService.getLoggedUserOrCreate(token).catch(console.error);
+    const user = await this.userService.getLoggedUserOrCreate(token).catch(console.error);
     if (!user) {
       return done(new UnauthorizedException('user not found and cannot create new user in database'), false);
     }

apps/api/src/app/auth/passport/ws-jwt.strategy.ts

@@ -3,10 +3,10 @@ import { PassportStrategy } from '@nestjs/passport';
 import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { passportJwtSecret, SigningKeyNotFoundError } from '@xmlking/jwks-rsa';
 
-import { AuthService } from '../auth.service';
-import { JwtToken } from '../interfaces/jwt-token.interface';
 import { WsException } from '@nestjs/websockets';
 import { environment as env } from '@env-api/environment';
+import { JwtToken } from '@ngx-starter-kit/models';
+import { UserService } from '../../user';
 
 const extractJwtFromWsQuery = req => {
   let token = null;
@@ -20,7 +20,7 @@ const extractJwtFromWsQuery = req => {
 
 @Injectable()
 export class WsJwtStrategy extends PassportStrategy(Strategy, 'ws-jwt') {
-  constructor(private readonly authService: AuthService) {
+  constructor(private readonly userService: UserService) {
     super({
       jwtFromRequest: extractJwtFromWsQuery, // ExtractJwt.fromUrlQueryParameter('token'),
       // secretOrKey: env.auth.publicKey,
@@ -47,7 +47,7 @@ export class WsJwtStrategy extends PassportStrategy(Strategy, 'ws-jwt') {
 
   // tslint:disable-next-line:ban-types
   async validate(token: any, done: Function) {
-    const user = await this.authService.getLoggedUserOrCreate(token).catch(console.error);
+    const user = await this.userService.getLoggedUserOrCreate(token).catch(console.error);
     if (!user) {
       return done(new WsException('user not found and cannot create new user in database'), false);
     }

apps/api/src/app/chat/interfaces/message.ts

@@ -1,4 +1,4 @@
-import { User } from './user';
+import { User } from '@ngx-starter-kit/models';
 
 export class Message {
   message: string;

apps/api/src/app/core/context/request-context.ts

@@ -1,7 +1,7 @@
 import { HttpException, HttpStatus } from '@nestjs/common';
 import * as cls from 'cls-hooked';
 import uuid from 'uuid';
-import { User } from '../../auth';
+import { User } from '@ngx-starter-kit/models';
 
 export class RequestContext {
   readonly id: number;
@@ -38,7 +38,7 @@ export class RequestContext {
 
     if (requestContext) {
       // tslint:disable-next-line
-      const user: any = requestContext.request['user'];
+      const user: User = requestContext.request['user'];
       if (user) {
         return user;
       }

apps/api/src/app/core/core.module.ts

@@ -1,38 +1,38 @@
 import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
 import { EmailModule } from '../email';
 import { ConfigModule } from '../config';
-import { TypeOrmModule } from '@nestjs/typeorm';
+import { TypeOrmModule, TypeOrmModuleOptions } from '@nestjs/typeorm';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import { LoggingInterceptor, TransformInterceptor } from './interceptors';
 import { RequestContextMiddleware } from './context';
 import { ConfigService } from '../config';
-import { ConnectionOptions } from 'typeorm';
 import { environment as env } from '@env-api/environment';
 import { isClass } from '@ngx-starter-kit/utils';
 
 function requireAllClasses(rc) {
   return rc
     .keys()
-    .filter(filePath => !filePath.includes('base'))
     .flatMap(key => Object.values(rc(key)))
     .filter(isClass);
 }
 
 const requireContext = (require as any).context('../..', true, /\.entity.ts/);
-// const requireContext = (require as any).context('../..', true, /^\.\/.*\/.*\/(?!(base|audit-base)).*\.entity.ts$/);
 const entities = requireAllClasses(requireContext);
 
+// const migrationsRequireContext = (require as any).context('../../../migrations/', true, /\.ts/);
+// const migrations = requireAllClasses(migrationsRequireContext);
+
 @Module({
   imports: [
     ConfigModule,
     EmailModule.forRoot(env.email),
     TypeOrmModule.forRootAsync({
       imports: [ConfigModule],
-      useFactory: async (config: ConfigService) =>
-        ({
-          ...env.database,
-          entities,
-        } as ConnectionOptions),
+      useFactory: (config: ConfigService): TypeOrmModuleOptions => ({
+        ...env.database,
+        entities,
+        // migrations,
+      }),
       inject: [ConfigService],
     }),
   ],