[migrate] upgrade Source Code & Test Case to latest Upstream Scaffold

Author: TechQuery

.github/workflows/deploy-production.yml

@@ -59,6 +59,7 @@ jobs:
 
             - name: Run Image
               uses: appleboy/ssh-action@v1
+              if: ${{ env.HOST }}
               with:
                   host: ${{ secrets.HOST }}
                   username: ${{ secrets.USER }}

.gitignore

@@ -1,7 +1,10 @@
 node_modules/
 package-lock.json
+yarn.lock
+test/client.ts
 dist/
 type/*.d.ts
-.env
+.env*
+!.env.example
 .data/
 .vscode/settings.json

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@open-source-bazaar/open-library-service",
-    "version": "0.7.0",
+    "version": "1.0.0",
     "license": "LGPL-3.0",
     "author": "[email protected]",
     "description": "RESTful API service scaffold based on Node.js & TypeScript",

source/controller/ActivityLog.ts

@@ -0,0 +1,114 @@
+import { Get, JsonController, Param, QueryParams } from 'routing-controllers';
+import { ResponseSchema } from 'routing-controllers-openapi';
+import { FindOptionsWhere } from 'typeorm';
+
+import {
+    ActivityLog,
+    ActivityLogFilter,
+    ActivityLogListChunk,
+    BaseFilter,
+    dataSource,
+    LogableTable,
+    Operation,
+    User,
+    UserRank,
+    UserRankListChunk
+} from '../model';
+
+const store = dataSource.getRepository(ActivityLog),
+    userStore = dataSource.getRepository(User),
+    userRankStore = dataSource.getRepository(UserRank);
+
+@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) {
+        const skip = pageSize * (pageIndex - 1);
+
+        const [list, count] = await userRankStore.findAndCount({
+            order: { score: 'DESC' },
+            skip,
+            take: pageSize
+        });
+        for (let i = 0, item: UserRank; (item = list[i]); i++) {
+            item.rank = skip + i + 1;
+            item.user = await userStore.findOneBy({ id: item.userId });
+        }
+        return { list, count };
+    }
+
+    @Get('/user/:id')
+    @ResponseSchema(ActivityLogListChunk)
+    getUserList(
+        @Param('id') id: number,
+        @QueryParams() { operation, pageSize, pageIndex }: ActivityLogFilter
+    ) {
+        return this.queryList(
+            { operation, createdBy: { id } },
+            { pageSize, pageIndex }
+        );
+    }
+
+    @Get('/:table/:id')
+    @ResponseSchema(ActivityLogListChunk)
+    getList(
+        @Param('table') tableName: keyof typeof LogableTable,
+        @Param('id') recordId: number,
+        @QueryParams() { operation, pageSize, pageIndex }: ActivityLogFilter
+    ) {
+        return this.queryList(
+            { operation, tableName, recordId },
+            { pageSize, pageIndex }
+        );
+    }
+
+    async queryList(
+        where: FindOptionsWhere<ActivityLog>,
+        { pageSize, pageIndex }: BaseFilter
+    ) {
+        const [list, count] = await store.findAndCount({
+            where,
+            relations: ['createdBy'],
+            skip: pageSize * (pageIndex - 1),
+            take: pageSize
+        });
+
+        for (const activity of list)
+            activity.record = await dataSource
+                .getRepository<ActivityLog['record']>(activity.tableName)
+                .findOneBy({ id: activity.recordId });
+
+        return { list, count };
+    }
+}

source/controller/Base.ts

@@ -0,0 +1,29 @@
+import { marked } from 'marked';
+import { Controller, Get, HeaderParam, HttpCode } from 'routing-controllers';
+
+import { isProduct } from '../utility';
+
+@Controller()
+export class BaseController {
+    static entryOf(host: string) {
+        host = 'http://' + host;
+
+        return `
+- HTTP served at ${host}
+- Swagger API served at ${host}/docs/
+- Swagger API exposed at ${host}/docs/spec
+${isProduct ? '' : `- Mock API served at ${host}/mock/`}
+`;
+    }
+
+    @Get('/_health')
+    @HttpCode(200)
+    getHealthStatus() {
+        return '';
+    }
+
+    @Get()
+    getIndex(@HeaderParam('host') host: string) {
+        return marked(BaseController.entryOf(host));
+    }
+}

source/controller/File.ts

@@ -0,0 +1,47 @@
+import { DeleteObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import {
+    Authorized,
+    Controller,
+    CurrentUser,
+    Delete,
+    HttpCode,
+    OnUndefined,
+    Param,
+    Post
+} from 'routing-controllers';
+import { ResponseSchema } from 'routing-controllers-openapi';
+
+import { SignedLink, User } from '../model';
+import { AWS_S3_BUCKET, AWS_S3_PUBLIC_HOST, s3Client } from '../utility';
+
+@Controller('/file')
+export class FileController {
+    @Post('/signed-link/:path(.+)')
+    @Authorized()
+    @HttpCode(201)
+    @ResponseSchema(SignedLink)
+    async createSignedLink(
+        @CurrentUser() { id }: User,
+        @Param('path') path: string
+    ) {
+        const Key = `user/${id}/${path}`;
+
+        const command = new PutObjectCommand({ Bucket: AWS_S3_BUCKET, Key });
+
+        const putLink = await getSignedUrl(s3Client, command);
+
+        return { putLink, getLink: `${AWS_S3_PUBLIC_HOST}/${Key}` };
+    }
+
+    @Delete('/:path(.+)')
+    @Authorized()
+    @OnUndefined(204)
+    async deleteFile(@CurrentUser() { id }: User, @Param('path') path: string) {
+        const Key = `user/${id}/${path}`;
+
+        const command = new DeleteObjectCommand({ Bucket: AWS_S3_BUCKET, Key });
+
+        await s3Client.send(command);
+    }
+}

source/controller/OAuth.ts

@@ -0,0 +1,35 @@
+import { githubClient, User as GitHubUser } from 'mobx-github';
+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);
+
+@JsonController('/user/OAuth')
+export class OauthController {
+    @Post('/GitHub')
+    @HttpCode(201)
+    @ResponseSchema(User)
+    async signInWithGithub(@Body() { accessToken }: OAuthSignInData) {
+        const { body } = await githubClient.get<GitHubUser>('user', {
+            Authorization: `Bearer ${accessToken}`
+        });
+        const { email, login, avatar_url } = body!;
+        const user =
+            (await store.findOneBy({ email })) ||
+            (await UserController.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 ActivityLogController.logUpdate(user, 'User', user.id);
+        }
+        return UserController.sign(user);
+    }
+}