1
import { Injectable } from "@nestjs/common";
2
import { ConfigService } from "@nestjs/config";
3
import * as qiniu from "qiniu";
4
import { Readable } from "stream";
5
import { UploadCallback } from "./types";
6
import { v4 as uuidV4 } from "uuid";
7

8
@Injectable()
9
export class QiniuService {
10
  constructor(private readonly configService: ConfigService) {
11
  }
12

13
  ak = this.configService.get<string>("qiniu.ak");
14
  sk = this.configService.get<string>("qiniu.sk");
15
  bucket = this.configService.get<string>("qiniu.bucket");
16

17
  // 生成凭证
18
  generateMac() {
19
    return new qiniu.auth.digest.Mac(this.ak, this.sk);
20
  }
21

22
  // 生成上传凭证
23
  generateUploadToken() {
24
    const putPolicy = new qiniu.rs.PutPolicy({
25
      scope: this.bucket,
26
      // 定义返回格式
27
      // 魔法变量：https://developer.qiniu.com/kodo/1235/vars#magicvar
28
      returnBody:
29
        '{"key":"$(key)","hash":"$(etag)","imageInfo":$(imageInfo),"fname":"$(fname)","fsize":$(fsize),"type":"$(mimeType)"}',
30
      // 如果需要将body返回给其他域名/服务则使用如下参数
31
      // returnUrl: ''
32
    });
33
    return putPolicy.uploadToken(this.generateMac());
34
  }
35

36
  // 上传
37
  async upload(file: Express.Multer.File): Promise<UploadCallback> {
38
    const uploader = new qiniu.form_up.FormUploader(
39
      new qiniu.conf.Config({
40
        zone: qiniu.zone.Zone_z0,
41
        useHttpsDomain: true,
42
      })
43
    );
44
    const putExtra = new qiniu.form_up.PutExtra();
45
    // buffer转换为可读流
46
    const stream = Readable.from(file.buffer);
47

48
    return new Promise((resolve, reject) => {
49
      uploader.putStream(
50
        this.generateUploadToken(),
51
        `${ uuidV4() }.${ file.originalname }`,
52
        stream,
53
        putExtra,
54
        (e, respBody, respInfo) => {
55
          if (e) {
56
            reject(e);
57
          }
58
          if (respInfo.statusCode === 200) {
59
            resolve(respBody);
60
          } else {
61
            reject(respBody);
62
          }
63
        }
64
      );
65
    });
66
  }
67

68
  // 生成预览链接 https://developer.qiniu.com/kodo/sdk/nodejs#private-get
69
  async preview(key: string) {
70
    const bucketManager = new qiniu.rs.BucketManager(
71
      this.generateMac(),
72
      new qiniu.conf.Config({
73
        zone: qiniu.zone.Zone_z0,
74
        useHttpsDomain: true,
75
      })
76
    );
77
    const domain = this.configService.get<string>("qiniu.domain");
78
    // 1小时后过期
79
    const deadline = Math.floor(Date.now() / 1000) + 3600;
80
    return bucketManager.privateDownloadUrl(domain, key, deadline);
81
  }
82
}

1
import {
2
  Controller,
3
  Get,
4
  Post,
5
  Query,
6
  UploadedFile,
7
  UseInterceptors,
8
} from "@nestjs/common";
9
import { Express } from "express";
10
import { QiniuService } from "./qiniu.service";
11
import { FileInterceptor } from "@nestjs/platform-express";
12
import { response } from "../../utils/response";
13
import { UploadCallback } from "./types";
14

15
@Controller("/file")
16
export class QiniuController {
17
  constructor(private readonly qiniuService: QiniuService) {
18
  }
19

20
  @Post("/upload")
21
  @UseInterceptors(FileInterceptor("file"))
22
  async uploadFile(@UploadedFile() file: Express.Multer.File) {
23
    try {
24
      const res: UploadCallback = await this.qiniuService.upload(file);
25
      const url = await this.qiniuService.preview(res.key);
26
      return response.ok({
27
        ...res,
28
        url,
29
      });
30
    } catch (e) {
31
      return response.fail("上传失败");
32
    }
33
  }
34

35
  @Get("/preview")
36
  async getPreviewUrl(@Query("key") key: string) {
37
    try {
38
      const url = await this.qiniuService.preview(key);
39
      return response.ok(url);
40
    } catch (e) {
41
      return response.fail();
42
    }
43
  }
44
}

1
import { Module } from "@nestjs/common";
2
import { QiniuService } from "./qiniu.service";
3
import { ConfigModule } from "@nestjs/config";
4
import { QiniuController } from "./qiniu.controller";
5

6
@Module({
7
  imports: [ConfigModule],
8
  controllers: [QiniuController],
9
  providers: [QiniuService],
10
  exports: [QiniuService],
11
})
12
export class QiniuModule {
13
}

1
import { MiddlewareConsumer, Module, NestModule } from "@nestjs/common";
2
import { TypeOrmModule } from "@nestjs/typeorm";
3
import { TenantMiddleware } from "./middleware/tenant.middleware";
4
import { ConfigModule, ConfigService } from "@nestjs/config";
5
import config from "./config";
6
import { RedisModule } from "./modules/redis/redis.module";
7
import { QiniuModule } from "./modules/qiniu/qiniu.module";
8

9
@Module({
10
  imports: [
11
    // env
12
    ConfigModule.forRoot({
13
      load: [config],
14
      envFilePath: [".env", ".env.dev", ".env.prod", ".env.local"],
15
    }),
16
    // database
17
    TypeOrmModule.forRootAsync({
18
      imports: [ConfigModule],
19
      inject: [ConfigService],
20
      useFactory: (configService: ConfigService) => ({
21
        type: "mysql",
22
        host: configService.get<string>("database.host"),
23
        port: configService.get<number>("database.port"),
24
        username: configService.get<string>("database.username"),
25
        password: configService.get<string>("database.password"),
26
        database: configService.get<string>("database.name"),
27
        autoLoadEntities: true,
28
        synchronize: true,
29
      }),
30
    }),
31
    // redis
32
    RedisModule,
33
    // qiniu
34
    QiniuModule,
35
  ],
36
})
37
export class AppModule implements NestModule {
38
  configure(consumer: MiddlewareConsumer): any {
39
    // 多租户中间件
40
    consumer.apply(TenantMiddleware).forRoutes("");
41
  }
42
}