src
- app.controller.spec.ts # Controller 测试文件
- app.controller.ts # Controller 路由处理器
- app.module.ts # Module 主模块入口 ，其他模块都需要在些进行注册
- app.service.ts # Service 业务逻辑或数据逻辑，根据实际需求使用
- main.ts # 入口文件

import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

import { Module, NestModule, MiddlewareConsumer } from "@nestjs/common";
import { LoggerMiddleware } from "./common/middleware/logger.middleware";
import { CatsModule } from "./cats/cats.module";

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes("cats");
  }
}

// main.ts
const app = await NestFactory.create(AppModule);
app.use(logger);
await app.listen(3000);

{
  "statusCode": 500,
  "message": "Internal server error"
}

async createMany(users: User[]) {
  const queryRunner = this.connection.createQueryRunner();

  await queryRunner.connect();
  await queryRunner.startTransaction();
  try {
    await queryRunner.manager.save(users[0]);
    await queryRunner.manager.save(users[1]);

    await queryRunner.commitTransaction();
  } catch (err) {
    // since we have errors lets rollback the changes we made
    await queryRunner.rollbackTransaction();
  } finally {
    // you need to release a queryRunner which was manually instantiated
    await queryRunner.release();
  }
}

async createMany(users: User[]) {
  await this.connection.transaction(async manager => {
    await manager.save(users[0]);
    await manager.save(users[1]);
  });
}

@Entity()
export class Post {
  @AfterRemove()
  updateStatus() {
    this.status = "removed";
  }
}

import {
  Connection,
  EntitySubscriberInterface,
  EventSubscriber,
  InsertEvent,
} from "typeorm";
import { User } from "./user.entity";

@EventSubscriber()
export class UserSubscriber implements EntitySubscriberInterface<User> {
  constructor(connection: Connection) {
    connection.subscribers.push(this);
  }

  listenTo() {
    return User;
  }

  beforeInsert(event: InsertEvent<User>) {
    console.log(`BEFORE USER INSERTED: `, event.entity);
  }
}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe());
  await app.listen(3000);
}
bootstrap();

{
  "statusCode": 400,
  "error": "Bad Request",
  "message": ["email must be an email"]
}

import { CacheModule, Module } from "@nestjs/common";
import { AppController } from "./app.controller";

@Module({
  imports: [CacheModule.register()],
  controllers: [AppController],
})
export class AppModule {}

constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
const value = await this.cacheManager.get('key');
await this.cacheManager.set('key', 'value', { ttl: 1000 });
await this.cacheManager.del('key');
await this.cacheManager.reset(); // Clear all cache

import type { ClientOpts as RedisClientOpts } from "redis";
import * as redisStore from "cache-manager-redis-store";
import { CacheModule, Module } from "@nestjs/common";
import { AppController } from "./app.controller";

@Module({
  imports: [
    CacheModule.register <
      RedisClientOpts >
      {
        store: redisStore,
        // Store-specific configuration:
        host: "localhost",
        port: 6379,
      },
  ],
  controllers: [AppController],
})
export class AppModule {}

@Controller("file")
export class FileController {
  @Get()
  getFile(@Res() res: Response) {
    const file = createReadStream(join(process.cwd(), "package.json"));
    file.pipe(res);
  }
}

$ npm install --save @nestjs/bull bull
$ npm install --save-dev @types/bull

app.module.tsJS;

import { Module } from "@nestjs/common";
import { BullModule } from "@nestjs/bull";

@Module({
  imports: [
    BullModule.forRoot({
      redis: {
        host: "localhost",
        port: 6379,
      },
    }),
  ],
})
export class AppModule {}

BullModule.registerQueue({
  name: "audio",
});

import { Injectable } from '@nestjs/common';
import { Queue } from 'bull';
import { InjectQueue } from '@nestjs/bull';

@Injectable()
export class AudioService {
  constructor(@InjectQueue('audio') private audioQueue: Queue) {}

	add() {
		const job = await this.audioQueue.add({
		  foo: 'bar',
		});
	}
}

import { Processor, Process } from "@nestjs/bull";
import { Job } from "bull";

@Processor("audio")
export class AudioConsumer {
  @Process()
  async transcode(job: Job<unknown>) {
    let progress = 0;
    for (i = 0; i < 100; i++) {
      await doSomething(job.data);
      progress += 10;
      await job.progress(progress);
    }
    return {};
  }
}

import * as session from "express-session";
// somewhere in your initialization file
app.use(
  session({
    secret: "my-secret",
    resave: false,
    saveUninitialized: false,
  })
);

$ npm i --save @nestjs/event-emitter

app.module.tsJS;

import { Module } from "@nestjs/common";
import { EventEmitterModule } from "@nestjs/event-emitter";

@Module({
  imports: [EventEmitterModule.forRoot()],
})
export class AppModule {}

constructor(private eventEmitter: EventEmitter2) {}
this.eventEmitter.emit(
  'order.created',
  new OrderCreatedEvent({
    orderId: 1,
    payload: {},
  }),
);

@OnEvent('order.created')
handleOrderCreatedEvent(payload: OrderCreatedEvent) {
  // handle and process "OrderCreatedEvent" event
}

@Post('upload')
@UseInterceptors(FileInterceptor('file'))
uploadFile(@UploadedFile() file: Express.Multer.File) {
  console.log(file);
}

@Module({
  imports: [HttpModule],
  providers: [CatsService],
})
export class CatsModule {}

@Injectable()
export class CatsService {
  constructor(private httpService: HttpService) {}

  findAll(): Observable<AxiosResponse<Cat[]>> {
    return this.httpService.get('http://localhost:3000/cats');
  }
}

# 直接运行
yarn
yarn start

# PM2运行
yarn install pm2@latest -g
yarn build
pm2 start dist/main.js --name <application_name>

# PM2 开机自启动
pm2 startup systemd
pm2 save

FROM node:16 as builder

# Create app directory
WORKDIR /app
# Install app dependencies
COPY package.json ./
COPY yarn.lock ./
RUN yarn install

# Build app
COPY . .
RUN yarn build

# =========

FROM node:16 as production

# Add bash for testing
# RUN apk add --no-cache bash

# Create app directory
WORKDIR /app

ARG NODE_ENV=production
ENV NODE_ENV=${NODE_ENV}

COPY --from=builder /app/package*.json ./
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/.env.production ./.env

EXPOSE 3008
CMD [ "node", "dist/main" ]