refactor

src/abstract/controller.ts

+import { Body, Get, Patch, Post, ValidationPipe } from '@nestjs/common';
+import {
+  ApiBody,
+  ApiCreatedResponse,
+  ApiOkResponse,
+  ApiOperation,
+} from '@nestjs/swagger';
+import {
+  MiddlewareInfoReturnMessageDto,
+  ReturnMessageDto,
+  StringReturnMessageDto,
+} from '../dto/ReturnMessage.dto';
+import { PostUrlDto } from '../dto/PostUrl.dto';
+import { MiddlewareService } from './service';
+import { MirrorDto } from '../dto/Mirror.dto';
+
+export class MiddlewareController {
+  constructor(protected middlewareService: MiddlewareService) {}
+
+  @Get()
+  @ApiOperation({ summary: '中间件信息' })
+  @ApiOkResponse({ type: MiddlewareInfoReturnMessageDto })
+  async jsdInfo() {
+    return new ReturnMessageDto(
+      200,
+      'success',
+      await this.middlewareService.info(),
+    );
+  }
+
+  @Post()
+  @ApiOperation({ summary: '上传中间件文件' })
+  @ApiBody({ type: PostUrlDto })
+  @ApiCreatedResponse({ type: StringReturnMessageDto })
+  async upload(
+    @Body(new ValidationPipe({ transform: true })) urlDto: PostUrlDto,
+  ) {
+    return new ReturnMessageDto(
+      201,
+      'success',
+      await this.middlewareService.upload(urlDto),
+    );
+  }
+
+  @Patch()
+  @ApiOperation({ summary: '获取文件下载地址' })
+  @ApiBody({ type: MirrorDto })
+  @ApiOkResponse({ type: StringReturnMessageDto })
+  async download(
+    @Body(new ValidationPipe({ transform: true })) mirrorDto: MirrorDto,
+  ) {
+    return new ReturnMessageDto(
+      200,
+      'success',
+      await this.middlewareService.download(mirrorDto),
+    );
+  }
+}

src/abstract/service.ts

+import { HttpService } from '@nestjs/axios';
+import { BlankReturnMessageDto } from '../dto/ReturnMessage.dto';
+import { MiddlewareInfoDto } from '../dto/MiddlewareInfo.dto';
+import { PostUrlDto } from '../dto/PostUrl.dto';
+import { MirrorDto } from '../dto/Mirror.dto';
+import { ConsoleLogger } from '@nestjs/common';
+
+export class MiddlewareService extends ConsoleLogger {
+  constructor(name: string, protected http: HttpService) {
+    super(name);
+  }
+
+  async info(): Promise<MiddlewareInfoDto> {
+    throw new BlankReturnMessageDto(404, 'Not Implemented').toException();
+  }
+  async upload(urlDto: PostUrlDto): Promise<string> {
+    throw new BlankReturnMessageDto(404, 'Not Implemented').toException();
+  }
+  async download(mirror: MirrorDto): Promise<string> {
+    return mirror.url;
+  }
+}

src/app.controller.spec.ts

-import { Test, TestingModule } from '@nestjs/testing';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
-
-describe('AppController', () => {
-  let appController: AppController;
-
-  beforeEach(async () => {
-    const app: TestingModule = await Test.createTestingModule({
-      controllers: [AppController],
-      providers: [AppService],
-    }).compile();
-
-    appController = app.get<AppController>(AppController);
-  });
-
-  describe('root', () => {
-    it('should be defined', () => {
-      expect(appController).toBeDefined();
-    });
-  });
-});

src/app.controller.ts

-import { Body, Controller, Get, Post, ValidationPipe } from '@nestjs/common';
-import { AppService } from './app.service';
-import {
-  ApiBody,
-  ApiCreatedResponse,
-  ApiOkResponse,
-  ApiOperation,
-} from '@nestjs/swagger';
-import { PostUrlDto } from './dto/PostUrl.dto';
-import {
-  MiddlewareInfoReturnMessageDto,
-  StringReturnMessageDto,
-} from './dto/ReturnMessage.dto';
-
-@Controller()
-export class AppController {
-  constructor(private readonly appService: AppService) {}
-
-  @Get('jsd')
-  @ApiOperation({ summary: 'JSDelivr', description: '需要配置 JSD_URL' })
-  @ApiOkResponse({ type: MiddlewareInfoReturnMessageDto })
-  jsdInfo() {
-    return this.appService.jsdInfo();
-  }
-
-  @Post('jsd')
-  @ApiOperation({ summary: 'JSDelivr', description: '需要配置 JSD_URL' })
-  @ApiBody({ type: PostUrlDto })
-  @ApiCreatedResponse({ type: StringReturnMessageDto })
-  jsd(@Body(new ValidationPipe({ transform: true })) urlDto: PostUrlDto) {
-    return this.appService.jsd(urlDto);
-  }
-}

src/app.module.ts

 import { Module } from '@nestjs/common';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
 import { ConfigModule } from '@nestjs/config';
 import { HttpModule } from '@nestjs/axios';
-
-const configModule = ConfigModule.forRoot();
+import { UtilityModule } from './utility/utility.module';
+import { JsdModule } from './jsd/jsd.module';
 
 @Module({
-  imports: [configModule, HttpModule],
-  controllers: [AppController],
-  providers: [AppService],
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    {
+      ...HttpModule.register({}),
+      global: true,
+    },
+    UtilityModule,
+    JsdModule,
+  ],
 })
 export class AppModule {}

src/dto/Mirror.dto.ts

+import { IsString } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class MirrorDto {
+  @IsString()
+  @ApiProperty({ description: '文件标识路径。' })
+  path: string;
+
+  @IsString()
+  @ApiProperty({ description: '文件地址，middleware 曾经返回的。' })
+  url: string;
+
+  @IsString()
+  @ApiProperty({ description: 'middleware 标识符' })
+  middleware: string;
+}

src/jsd/jsd.controller.ts

+import { Controller } from '@nestjs/common';
+import { MiddlewareController } from '../abstract/controller';
+import { JsdService } from './jsd.service';
+
+@Controller('jsd')
+export class JsdController extends MiddlewareController {
+  constructor(s: JsdService) {
+    super(s);
+  }
+}

src/jsd/jsd.module.ts

+import { Module } from '@nestjs/common';
+import { JsdController } from './jsd.controller';
+import { JsdService } from './jsd.service';
+
+@Module({
+  controllers: [JsdController],
+  providers: [JsdService],
+})
+export class JsdModule {}

src/app.service.ts → src/jsd/jsd.service.ts

-import { Injectable, ConsoleLogger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { HttpService } from '@nestjs/axios';
-import internal from 'stream';
 import { lastValueFrom } from 'rxjs';
-import {
-  BlankReturnMessageDto,
-  ReturnMessage,
-  ReturnMessageDto,
-} from './dto/ReturnMessage.dto';
+import { BlankReturnMessageDto, ReturnMessage } from '../dto/ReturnMessage.dto';
 import FormData from 'form-data';
-import { PostUrlDto } from './dto/PostUrl.dto';
-import { MiddlewareInfoDto } from './dto/MiddlewareInfo.dto';
+import { PostUrlDto } from '../dto/PostUrl.dto';
+import { MiddlewareInfoDto } from '../dto/MiddlewareInfo.dto';
+import { UtilityService } from '../utility/utility/utility.service';
+import { MiddlewareService } from '../abstract/service';
 
 @Injectable()
-export class AppService extends ConsoleLogger {
+export class JsdService extends MiddlewareService {
   private jsdUrl: string;
   private jsdIdentifier: string;
-  constructor(config: ConfigService, private http: HttpService) {
-    super('app');
+  constructor(
+    config: ConfigService,
+    http: HttpService,
+    private utility: UtilityService,
+  ) {
+    super('jsd', http);
     this.jsdUrl = config.get('JSD_URL');
     this.jsdIdentifier = config.get('JSD_IDENTIFIER') || `jsd-${this.jsdUrl}`;
   }
 
-  private async getStreamFromUrl(url: string) {
-    try {
-      const ret = await lastValueFrom(
-        await this.http.get<internal.Readable>(url, {
-          responseType: 'stream',
-          timeout: 30000,
-          maxBodyLength: 4 * 1024 ** 3,
-          maxContentLength: 4 * 1024 ** 3,
-        }),
-      );
-      return ret;
-    } catch (e) {
-      throw new BlankReturnMessageDto(404, 'URL not available').toException();
-    }
-  }
-
-  jsdInfo() {
+  async info() {
     if (!this.jsdUrl) {
       throw new BlankReturnMessageDto(
         404,
@@ -48,17 +33,17 @@ export class AppService extends ConsoleLogger {
     const info = new MiddlewareInfoDto();
     info.identifier = this.jsdIdentifier;
     info.maxSize = 50 * 1024 * 1024;
-    return new ReturnMessageDto(200, 'success', info);
+    return info;
   }
 
-  async jsd(urlDto: PostUrlDto) {
+  async upload(urlDto: PostUrlDto) {
     if (!this.jsdUrl) {
       throw new BlankReturnMessageDto(
         404,
         'JSDelivr is not configured.',
       ).toException();
     }
-    const streamData = await this.getStreamFromUrl(urlDto.url);
+    const streamData = await this.utility.getStreamFromUrl(urlDto.url);
     //streamData.data.pause();
     const form = new FormData();
     form.append('file', streamData.data, {
@@ -77,7 +62,7 @@ export class AppService extends ConsoleLogger {
           maxContentLength: 4 * 1024 ** 3,
         }),
       );
-      return new ReturnMessageDto(201, 'success', data.data);
+      return data.data;
     } catch (e) {
       this.error(`Failed uploading ${urlDto.url}: ${e.toString()} ${e.data}`);
       throw new BlankReturnMessageDto(500, 'upload fail').toException();

src/utility/utility.module.ts

+import { Global, Module } from '@nestjs/common';
+import { UtilityService } from './utility/utility.service';
+
+@Global()
+@Module({
+  providers: [UtilityService],
+  exports: [UtilityService],
+})
+export class UtilityModule {}

src/utility/utility/utility.service.spec.ts

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

src/utility/utility/utility.service.ts

+import { Injectable } from '@nestjs/common';
+import { lastValueFrom } from 'rxjs';
+import internal from 'stream';
+import { BlankReturnMessageDto } from '../../dto/ReturnMessage.dto';
+import { HttpService } from '@nestjs/axios';
+
+@Injectable()
+export class UtilityService {
+  constructor(private http: HttpService) {}
+
+  async getStreamFromUrl(url: string) {
+    try {
+      return await lastValueFrom(
+        await this.http.get<internal.Readable>(url, {
+          responseType: 'stream',
+          timeout: 30000,
+          maxBodyLength: 4 * 1024 ** 3,
+          maxContentLength: 4 * 1024 ** 3,
+        }),
+      );
+    } catch (e) {
+      throw new BlankReturnMessageDto(404, 'URL not available').toException();
+    }
+  }
+}

test/app.e2e-spec.ts

@@ -3,7 +3,7 @@ import { INestApplication } from '@nestjs/common';
 import * as request from 'supertest';
 import { AppModule } from './../src/app.module';
 
-describe('AppController (e2e)', () => {
+describe('JsdController (e2e)', () => {
   let app: INestApplication;
 
   beforeEach(async () => {