[refactor] simplify controllers with independent Base, User, Session & Activity Log services

Author: TechQuery

source/controller/ActivityLog.ts

@@ -9,7 +9,6 @@ import {
     BaseFilter,
     dataSource,
     LogableTable,
-    Operation,
     User,
     UserRank,
     UserRankListChunk
@@ -21,36 +20,6 @@ const store = dataSource.getRepository(ActivityLog),
 
 @JsonController('/activity-log')
 export class ActivityLogController {
-    static logCreate(
-        createdBy: User,
-        tableName: ActivityLog['tableName'],
-        recordId: number
-    ) {
-        const operation = Operation.Create;
-
-        return store.save({ createdBy, operation, tableName, recordId });
-    }
-
-    static logUpdate(
-        createdBy: User,
-        tableName: ActivityLog['tableName'],
-        recordId: number
-    ) {
-        const operation = Operation.Update;
-
-        return store.save({ createdBy, operation, tableName, recordId });
-    }
-
-    static logDelete(
-        createdBy: User,
-        tableName: ActivityLog['tableName'],
-        recordId: number
-    ) {
-        const operation = Operation.Delete;
-
-        return store.save({ createdBy, operation, tableName, recordId });
-    }
-
     @Get('/user-rank')
     @ResponseSchema(UserRankListChunk)
     async getUserRankList(@QueryParams() { pageSize, pageIndex }: BaseFilter) {
@@ -74,10 +43,7 @@ export class ActivityLogController {
         @Param('id') id: number,
         @QueryParams() { operation, pageSize, pageIndex }: ActivityLogFilter
     ) {
-        return this.queryList(
-            { operation, createdBy: { id } },
-            { pageSize, pageIndex }
-        );
+        return this.queryList({ operation, createdBy: { id } }, { pageSize, pageIndex });
     }
 
     @Get('/:table/:id')
@@ -87,16 +53,10 @@ export class ActivityLogController {
         @Param('id') recordId: number,
         @QueryParams() { operation, pageSize, pageIndex }: ActivityLogFilter
     ) {
-        return this.queryList(
-            { operation, tableName, recordId },
-            { pageSize, pageIndex }
-        );
+        return this.queryList({ operation, tableName, recordId }, { pageSize, pageIndex });
     }
 
-    async queryList(
-        where: FindOptionsWhere<ActivityLog>,
-        { pageSize, pageIndex }: BaseFilter
-    ) {
+    async queryList(where: FindOptionsWhere<ActivityLog>, { pageSize, pageIndex }: BaseFilter) {
         const [list, count] = await store.findAndCount({
             where,
             relations: ['createdBy'],

source/controller/OAuth.ts

@@ -3,14 +3,13 @@ import { Body, HttpCode, JsonController, Post } from 'routing-controllers';
 import { ResponseSchema } from 'routing-controllers-openapi';
 import { isDeepStrictEqual } from 'util';
 
-import { dataSource, OAuthSignInData, User } from '../model';
-import { ActivityLogController } from './ActivityLog';
-import { UserController } from './User';
-
-const store = dataSource.getRepository(User);
+import { OAuthSignInData, User } from '../model';
+import { activityLogService, sessionService } from '../service';
 
 @JsonController('/user/OAuth')
 export class OauthController {
+    userStore = sessionService.userStore;
+
     @Post('/GitHub')
     @HttpCode(201)
     @ResponseSchema(User)
@@ -20,16 +19,16 @@ export class OauthController {
         });
         const { email, login, avatar_url } = body!;
         const user =
-            (await store.findOneBy({ email })) ||
-            (await UserController.signUp({ email, password: accessToken }));
+            (await this.userStore.findOneBy({ email })) ||
+            (await sessionService.signUp({ email, password: accessToken }));
         const newProfile = { name: login, avatar: avatar_url },
             oldPofile = { name: user.name, avatar: user.avatar };
 
         if (!isDeepStrictEqual(oldPofile, newProfile)) {
-            await store.save(Object.assign(user, newProfile));
+            await this.userStore.save(Object.assign(user, newProfile));
 
-            await ActivityLogController.logUpdate(user, 'User', user.id);
+            await activityLogService.logUpdate(user, 'User', user.id);
         }
-        return UserController.sign(user);
+        return sessionService.sign(user);
     }
 }

source/controller/User.ts

@@ -1,5 +1,3 @@
-import { createHash } from 'crypto';
-import { JsonWebTokenError, sign } from 'jsonwebtoken';
 import {
     Authorized,
     Body,
@@ -19,50 +17,14 @@ import {
 } from 'routing-controllers';
 import { ResponseSchema } from 'routing-controllers-openapi';
 
-import {
-    dataSource,
-    JWTAction,
-    Role,
-    SignInData,
-    User,
-    UserFilter,
-    UserListChunk
-} from '../model';
-import { APP_SECRET, searchConditionOf, supabase } from '../utility';
-import { ActivityLogController } from './ActivityLog';
-
-const store = dataSource.getRepository(User);
+import { Role, SignInData, User, UserFilter, UserListChunk } from '../model';
+import { activityLogService, BaseService, sessionService } from '../service';
+import { searchConditionOf, supabase } from '../utility';
 
 @JsonController('/user')
 export class UserController {
-    static encrypt = (raw: string) =>
-        createHash('sha1')
-            .update(APP_SECRET + raw)
-            .digest('hex');
-
-    static sign = (user: User): User => ({
-        ...user,
-        token: sign({ ...user }, APP_SECRET)
-    });
-
-    static async signUp({ email, password }: SignInData) {
-        const sum = await store.count();
-
-        const { password: _, ...user } = await store.save({
-            name: email,
-            email,
-            password: UserController.encrypt(password),
-            roles: [sum ? Role.Client : Role.Administrator]
-        });
-        await ActivityLogController.logCreate(user, 'User', user.id);
-
-        return user;
-    }
-
-    static getSession = ({ context: { state } }: JWTAction) =>
-        'user' in state
-            ? state.user
-            : (console.error(state.jwtOriginalError), null);
+    store = sessionService.userStore;
+    service = new BaseService(User, ['email', 'mobilePhone', 'name']);
 
     @Post('/session/email/:email/OTP')
     @OnUndefined(204)
@@ -83,9 +45,9 @@ export class UserController {
     @HttpCode(201)
     @ResponseSchema(User)
     async signIn(@Body() { email, password }: SignInData): Promise<User> {
-        let user = await store.findOneBy({
+        let user = await this.store.findOneBy({
             email,
-            password: UserController.encrypt(password)
+            password: sessionService.encrypt(password)
         });
 
         if (!user) {
@@ -97,17 +59,17 @@ export class UserController {
             if (error) throw new HttpError(error.status, error.message);
 
             user =
-                (await store.findOneBy({ email })) ||
+                (await this.store.findOneBy({ email })) ||
                 (await this.signUp({ email, password: data.user.id }));
         }
-        return UserController.sign(user);
+        return sessionService.sign(user);
     }
 
     @Post()
     @HttpCode(201)
     @ResponseSchema(User)
     signUp(@Body() data: SignInData) {
-        return UserController.signUp(data);
+        return sessionService.signUp(data);
     }
 
     @Put('/:id')
@@ -118,27 +80,24 @@ export class UserController {
         @CurrentUser() updatedBy: User,
         @Body() { password, ...data }: User
     ) {
-        if (
-            !updatedBy.roles.includes(Role.Administrator) &&
-            id !== updatedBy.id
-        )
+        if (!updatedBy.roles.includes(Role.Administrator) && id !== updatedBy.id)
             throw new ForbiddenError();
 
-        const saved = await store.save({
+        const saved = await this.store.save({
             ...data,
-            password: password && UserController.encrypt(password),
+            password: password && sessionService.encrypt(password),
             id
         });
-        await ActivityLogController.logUpdate(updatedBy, 'User', id);
+        await activityLogService.logUpdate(updatedBy, 'User', id);
 
-        return UserController.sign(saved);
+        return sessionService.sign(saved);
     }
 
     @Get('/:id')
     @OnNull(404)
     @ResponseSchema(User)
     getOne(@Param('id') id: number) {
-        return store.findOne({ where: { id } });
+        return this.service.getOne(id);
     }
 
     @Delete('/:id')
@@ -148,26 +107,19 @@ export class UserController {
         if (deletedBy.roles.includes(Role.Administrator) && id == deletedBy.id)
             throw new ForbiddenError();
 
-        await store.softDelete(id);
+        await this.store.softDelete(id);
 
-        await ActivityLogController.logDelete(deletedBy, 'User', id);
+        await activityLogService.logDelete(deletedBy, 'User', id);
     }
 
     @Get()
     @ResponseSchema(UserListChunk)
-    async getList(
-        @QueryParams() { gender, keywords, pageSize, pageIndex }: UserFilter
-    ) {
+    getList(@QueryParams() { gender, keywords, ...filter }: UserFilter) {
         const where = searchConditionOf<User>(
             ['email', 'mobilePhone', 'name'],
             keywords,
             gender && { gender }
         );
-        const [list, count] = await store.findAndCount({
-            where,
-            skip: pageSize * (pageIndex - 1),
-            take: pageSize
-        });
-        return { list, count };
+        return this.service.getList({ keywords, ...filter }, where);
     }
 }

source/controller/WebAuthn.ts

@@ -1,12 +1,6 @@
 import { server } from '@passwordless-id/webauthn';
 import { CollectedClientData } from '@passwordless-id/webauthn/dist/esm/types';
-import {
-    BadRequestError,
-    Body,
-    HttpCode,
-    JsonController,
-    Post
-} from 'routing-controllers';
+import { BadRequestError, Body, HttpCode, JsonController, Post } from 'routing-controllers';
 import { ResponseSchema } from 'routing-controllers-openapi';
 
 import {
@@ -17,8 +11,7 @@ import {
     WebAuthnChallenge,
     WebAuthnRegistration
 } from '../model';
-import { ActivityLogController } from './ActivityLog';
-import { UserController } from './User';
+import { activityLogService, sessionService } from '../service';
 
 const credentialStore = dataSource.getRepository(UserCredential);
 
@@ -49,7 +42,7 @@ export class WebAuthnController {
             challenge,
             origin
         });
-        const createdBy = await UserController.signUp({
+        const createdBy = await sessionService.signUp({
             email: name,
             password: id
         });
@@ -62,20 +55,15 @@ export class WebAuthnController {
             userVerified
         } as UserCredential);
 
-        await ActivityLogController.logCreate(
-            createdBy,
-            'UserCredential',
-            saved.id
-        );
-        return UserController.sign(createdBy);
+        await activityLogService.logCreate(createdBy, 'UserCredential', saved.id);
+
+        return sessionService.sign(createdBy);
     }
 
     @Post('/authentication')
     @HttpCode(201)
     @ResponseSchema(User)
-    async signIn(
-        @Body() { challenge, ...authentication }: WebAuthnAuthentication
-    ) {
+    async signIn(@Body() { challenge, ...authentication }: WebAuthnAuthentication) {
         const userCredential = await credentialStore.findOne({
             where: { uuid: authentication.id },
             relations: ['createdBy']
@@ -92,6 +80,6 @@ export class WebAuthnController {
             { ...credential, id: uuid },
             { origin, challenge, userVerified }
         );
-        return UserController.sign(createdBy);
+        return sessionService.sign(createdBy);
     }
 }

source/index.ts

@@ -6,14 +6,9 @@ import KoaLogger from 'koa-logger';
 import { useKoaServer } from 'routing-controllers';
 import { ProxyAgent, setGlobalDispatcher } from 'undici';
 
-import {
-    BaseController,
-    controllers,
-    mocker,
-    swagger,
-    UserController
-} from './controller';
+import { BaseController, controllers, mocker, swagger } from './controller';
 import { dataSource } from './model';
+import { sessionService } from './service';
 import { APP_SECRET, HTTP_PROXY, isProduct, PORT } from './utility';
 
 if (HTTP_PROXY) setGlobalDispatcher(new ProxyAgent(HTTP_PROXY));
@@ -29,8 +24,8 @@ if (!isProduct) app.use(mocker());
 useKoaServer(app, {
     controllers,
     cors: true,
-    authorizationChecker: action => !!UserController.getSession(action),
-    currentUserChecker: UserController.getSession
+    authorizationChecker: action => !!sessionService.checkJWT(action),
+    currentUserChecker: sessionService.checkJWT
 });
 
 console.time('Server boot');

source/service/ActivityLog.ts

@@ -0,0 +1,25 @@
+import { ActivityLog, dataSource,Operation, User } from '../model';
+
+export class ActivityLogService {
+    store = dataSource.getRepository(ActivityLog);
+
+    logCreate(createdBy: User, tableName: ActivityLog['tableName'], recordId: number) {
+        const operation = Operation.Create;
+
+        return this.store.save({ createdBy, operation, tableName, recordId });
+    }
+
+    logUpdate(createdBy: User, tableName: ActivityLog['tableName'], recordId: number) {
+        const operation = Operation.Update;
+
+        return this.store.save({ createdBy, operation, tableName, recordId });
+    }
+
+    logDelete(createdBy: User, tableName: ActivityLog['tableName'], recordId: number) {
+        const operation = Operation.Delete;
+
+        return this.store.save({ createdBy, operation, tableName, recordId });
+    }
+}
+
+export const activityLogService = new ActivityLogService();