NestJSアプリの信頼性を高める ─ ログ・エラーハンドリング・テスト戦略

import { Logger } from '@nestjs/common';

const logger = new Logger('MyContext');

logger.log('通常のログ');
logger.warn('警告ログ');
logger.error('エラーログ', error.stack);

[Nest] 43018   - 2025/04/23 18:30:25   LOG [MyContext] 通常のログ
[Nest] 43018   - 2025/04/23 18:30:25  WARN [MyContext] 警告ログ
[Nest] 43018   - 2025/04/23 18:30:25 ERROR [MyContext] エラーログ

+ import { Logger } from '@nestjs/common';

@Injectable()
export class PostsService {
+ private readonly logger = new Logger(PostsService.name);

  findAll() {
+   this.logger.log('記事一覧を取得します');
    return this.prisma.post.findMany();
  }
}

import { LoggerService, LogLevel } from '@nestjs/common';
import * as fs from 'fs';

export class CustomLogger implements LoggerService {
  log(message: string) {
    this.writeToFile('LOG', message);
  }

  error(message: string, trace?: string) {
    this.writeToFile('ERROR', `${message} \n ${trace}`);
  }

  warn(message: string) {
    this.writeToFile('WARN', message);
  }

  private writeToFile(level: LogLevel, message: string) {
    const log = `[${new Date().toISOString()}] [${level}] ${message}\n`;
    fs.appendFileSync('app.log', log);
  }
}

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { CustomLogger } from './common/logger/custom-logger.service';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    logger: new CustomLogger(),
  });

  await app.listen(3000);
}
bootstrap();

npx nest g filter common/filters/http

import { ArgumentsHost, Catch, ExceptionFilter } from '@nestjs/common';

@Catch()
export class HttpFilter<T> implements ExceptionFilter {
  catch(exception: T, host: ArgumentsHost) {}
}

import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
  HttpStatus,
  Logger,
} from '@nestjs/common';
import { Request, Response } from 'express';

@Catch()
export class HttpExceptionFilter implements ExceptionFilter {
  private readonly logger = new Logger(HttpExceptionFilter.name);

  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();

    const status =
      exception instanceof HttpException
        ? exception.getStatus()
        : HttpStatus.INTERNAL_SERVER_ERROR;

    let message = 'Internal server error';

    if (exception instanceof HttpException) {
      const res = exception.getResponse();

      if (
        typeof res === 'object' &&
        res !== null &&
        'message' in res &&
        typeof (res as Record<string, unknown>).message === 'string'
      ) {
        message = (res as Record<string, unknown>).message as string;
      }
    }

    this.logger.error(
      `[${request.method}] ${request.url}`,
      JSON.stringify(message),
    );

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message,
    });
  }
}

const ctx = host.switchToHttp();
const response = ctx.getResponse<Response>();
const request = ctx.getRequest<Request>();

const status =
  exception instanceof HttpException
    ? exception.getStatus()
    : HttpStatus.INTERNAL_SERVER_ERROR;

let message = 'Internal server error';

if (exception instanceof HttpException) {
  const res = exception.getResponse();

  if (
    typeof res === 'object' &&
    res !== null &&
    'message' in res &&
    typeof (res as Record<string, unknown>).message === 'string'
  ) {
    message = (res as Record<string, unknown>).message as string;
  }
}

this.logger.error(
  `[${request.method}] ${request.url}`,
  JSON.stringify(message),
);

response.status(status).json({
  statusCode: status,
  timestamp: new Date().toISOString(),
  path: request.url,
  message,
});

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';
+ import { HttpExceptionFilter } from './common/filters/http/http.filter';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe());
+ app.useGlobalFilters(new HttpExceptionFilter());
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap().catch((err) => {
  console.error('Application failed to start', err);
});

import { Injectable } from '@nestjs/common';
import { CreatePostDto } from './dto/create-post.dto';
import { UpdatePostDto } from './dto/update-post.dto';
import { PrismaService } from 'src/prisma/prisma.service';
import { Logger } from '@nestjs/common';

@Injectable()
export class PostsService {
  constructor(private readonly prisma: PrismaService) {}
  private readonly logger = new Logger(PostsService.name);

  create(createPostDto: CreatePostDto) {
    return this.prisma.post.create({ data: createPostDto });
  }

  findAll() {
    this.logger.log('記事一覧を取得します');
    return this.prisma.post.findMany();
  }

  findOne(id: number) {
    return this.prisma.post.findUnique({ where: { id } });
  }

  update(id: number, updatePostDto: UpdatePostDto) {
    return this.prisma.post.update({
      where: { id },
      data: updatePostDto,
    });
  }

  remove(id: number) {
    return this.prisma.post.delete({ where: { id } });
  }
}

  const mockPrismaService = {
    post: {
      create: jest.fn(),
      findMany: jest.fn(),
      findUnique: jest.fn(),
      update: jest.fn(),
      delete: jest.fn(),
    },
  };

import { Test, TestingModule } from '@nestjs/testing';
import { PostsService } from './posts.service';
import { PrismaService } from '../prisma/prisma.service';
import { Logger } from '@nestjs/common';

describe('PostsService', () => {
  let service: PostsService;

  const mockPrismaService = {
    post: {
      create: jest.fn(),
      findMany: jest.fn(),
      findUnique: jest.fn(),
      update: jest.fn(),
      delete: jest.fn(),
    },
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        PostsService,
        {
          provide: PrismaService,
          useValue: mockPrismaService,
        },
      ],
    }).compile();

    service = module.get<PostsService>(PostsService);
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

  it('should call prisma.post.create with correct data', async () => {
    const dto = { title: 'Test', content: 'Content' };
    await service.create(dto);

    expect(mockPrismaService.post.create).toHaveBeenCalledWith({
      data: dto,
    });
  });

  it('should call prisma.post.findMany and log a message', async () => {
    const logSpy = jest.spyOn(Logger.prototype, 'log').mockImplementation();

    await service.findAll();

    expect(mockPrismaService.post.findMany).toHaveBeenCalled();
    expect(logSpy).toHaveBeenCalledWith('記事一覧を取得します');

    logSpy.mockRestore();
  });

  it('should call prisma.post.findUnique with correct id', async () => {
    await service.findOne(42);

    expect(mockPrismaService.post.findUnique).toHaveBeenCalledWith({
      where: { id: 42 },
    });
  });

  it('should call prisma.post.update with correct id and data', async () => {
    const dto = { title: 'Updated', content: 'Updated content' };

    await service.update(99, dto);

    expect(mockPrismaService.post.update).toHaveBeenCalledWith({
      where: { id: 99 },
      data: dto,
    });
  });

  it('should call prisma.post.delete with correct id', async () => {
    await service.remove(7);

    expect(mockPrismaService.post.delete).toHaveBeenCalledWith({
      where: { id: 7 },
    });
  });
});

let service: PostsService;

const mockPrismaService = {
  post: {
    create: jest.fn(),
    findMany: jest.fn(),
    findUnique: jest.fn(),
    update: jest.fn(),
    delete: jest.fn(),
  },
};

beforeEach(async () => {
  const module: TestingModule = await Test.createTestingModule({
    providers: [
      PostsService,
      {
        provide: PrismaService,
        useValue: mockPrismaService,
      },
    ],
  }).compile();

  service = module.get<PostsService>(PostsService);
});

  afterEach(() => {
    jest.clearAllMocks();
  });

it('should call prisma.post.create with correct data', async () => {
  const dto = { title: 'Test', content: 'Content' };
  await service.create(dto);
  expect(mockPrismaService.post.create).toHaveBeenCalledWith({ data: dto });
});

it('should call prisma.post.findMany and log a message', async () => {
  const logSpy = jest.spyOn(Logger.prototype, 'log').mockImplementation();

  await service.findAll();

  expect(mockPrismaService.post.findMany).toHaveBeenCalled();
  expect(logSpy).toHaveBeenCalledWith('記事一覧を取得します');

  logSpy.mockRestore();
});

it('should call prisma.post.findUnique with correct id', async () => {
  await service.findOne(42);
  expect(mockPrismaService.post.findUnique).toHaveBeenCalledWith({
    where: { id: 42 },
  });
});

it('should call prisma.post.update with correct id and data', async () => {
  const dto = { title: 'Updated', content: 'Updated content' };
  await service.update(99, dto);
  expect(mockPrismaService.post.update).toHaveBeenCalledWith({
    where: { id: 99 },
    data: dto,
  });
});

it('should call prisma.post.delete with correct id', async () => {
  await service.remove(7);
  expect(mockPrismaService.post.delete).toHaveBeenCalledWith({
    where: { id: 7 },
  });
});

  "jest": {
    "moduleFileExtensions": [
      "js",
      "json",
      "ts"
    ],
    "rootDir": "src",
    "testRegex": ".*\\.spec\\.ts$",
    "transform": {
      "^.+\\.(t|j)s$": "ts-jest"
    },
    "collectCoverageFrom": [
      "**/*.(t|j)s"
    ],
    "coverageDirectory": "../coverage",
    "testEnvironment": "node",
+   "moduleNameMapper": {
+     "^src/(.*)$": "<rootDir>/$1"
+   }
  }

{
  "compilerOptions": {
    "module": "commonjs",
    "declaration": true,
    "removeComments": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "allowSyntheticDefaultImports": true,
    "target": "ES2023",
    "sourceMap": true,
    "outDir": "./dist",
    "baseUrl": "./",
    "incremental": true,
    "skipLibCheck": true,
    "strictNullChecks": true,
    "forceConsistentCasingInFileNames": true,
    "noImplicitAny": false,
    "strictBindCallApply": false,
    "noFallthroughCasesInSwitch": false,
+   "resolveJsonModule": true,
+   "paths": {
+     "src/*": ["src/*"]
+   }
  }
}

cd backend
npm run test -- src/posts/posts.service.spec.ts

services:
  db:
    image: postgres:15
    container_name: nestjs-postgres
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: nestjs_blog
    volumes:
      - db-data:/var/lib/postgresql/data

+ test-db:
+   image: postgres:15
+   container_name: nestjs-postgres-test
+   ports:
+     - "5433:5432"
+   environment:
+     POSTGRES_USER: postgres
+     POSTGRES_PASSWORD: postgres
+     POSTGRES_DB: test_db
+   volumes:
+     - test-db-data:/var/lib/postgresql/data

volumes:
  db-data:
+ test-db-data:

DATABASE_URL=postgresql://postgres:postgres@localhost:5433/test_db

import * as dotenv from 'dotenv';
import * as path from 'path';

const testEnv = dotenv.config({
  path: path.join(process.cwd(), '.env.test.local'),
});

Object.assign(process.env, {
  ...testEnv.parsed,
});

{
  "moduleFileExtensions": ["js", "json", "ts"],
  "rootDir": "../",
  "moduleNameMapper": {
    "^src/(.*)$": "<rootDir>/src/$1"
  },
  "testEnvironment": "node",
  "testRegex": ".e2e-spec.ts$",
  "transform": {
    "^.+\\.(t|j)s$": "ts-jest"
  },
+ "setupFiles": [
+   "<rootDir>/src/config/dotenv/unit-test-config.ts"
+ ]
}

import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

export async function resetDatabase() {
  await prisma.post.deleteMany();
}

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from '../src/app.module';
import { resetDatabase } from './utils/db';

describe('PostsController (e2e)', () => {
  let app: INestApplication;
  let createdPostId: number;
  beforeAll(async () => {
    await resetDatabase();
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  afterAll(async () => {
    await app.close();
  });

  it('/posts (POST)', async () => {
    const response = await request(app.getHttpServer())
      .post('/posts')
      .send({ title: 'E2E Test Title', content: 'E2E Test Content' })
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.title).toBe('E2E Test Title');
    createdPostId = response.body.id;
  });

  it('/posts (GET)', async () => {
    const response = await request(app.getHttpServer())
      .get('/posts')
      .expect(200);
    expect(Array.isArray(response.body)).toBe(true);
    expect(response.body.length).toBeGreaterThan(0);
  });

  it('GET /posts/:id', async () => {
    const response = await request(app.getHttpServer())
      .get(`/posts/${createdPostId}`)
      .expect(200);

    expect(response.body.id).toBe(createdPostId);
    expect(response.body.title).toBe('E2E Test Title');
  });

  it('PATCH /posts/:id', async () => {
    const response = await request(app.getHttpServer())
      .patch(`/posts/${createdPostId}`)
      .send({ title: 'Updated Title', content: 'Updated Content' })
      .expect(200);

    expect(response.body.title).toBe('Updated Title');
    expect(response.body.content).toBe('Updated Content');
  });

  it('DELETE /posts/:id', async () => {
    await request(app.getHttpServer())
      .delete(`/posts/${createdPostId}`)
      .expect(200);

    await request(app.getHttpServer())
      .get(`/posts/${createdPostId}`)
      .expect(404);
  });
});

let app: INestApplication;
let createdPostId: number;

beforeAll(async () => {
  await resetDatabase();
  const moduleFixture = await Test.createTestingModule({ imports: [AppModule] }).compile();
  app = moduleFixture.createNestApplication();
  await app.init();
});

afterAll(async () => {
  await app.close();
});

it('/posts (POST)', async () => {
  const response = await request(app.getHttpServer())
    .post('/posts')
    .send({ title: 'E2E Test Title', content: 'E2E Test Content' })
    .expect(201);

  expect(response.body).toHaveProperty('id');
  expect(response.body.title).toBe('E2E Test Title');
  createdPostId = response.body.id;
});

it('/posts (GET)', async () => {
  const response = await request(app.getHttpServer())
    .get('/posts')
    .expect(200);
  expect(Array.isArray(response.body)).toBe(true);
  expect(response.body.length).toBeGreaterThan(0);
});

it('GET /posts/:id', async () => {
  const response = await request(app.getHttpServer())
    .get(`/posts/${createdPostId}`)
    .expect(200);

  expect(response.body.id).toBe(createdPostId);
  expect(response.body.title).toBe('E2E Test Title');
});

it('PATCH /posts/:id', async () => {
  const response = await request(app.getHttpServer())
    .patch(`/posts/${createdPostId}`)
    .send({ title: 'Updated Title', content: 'Updated Content' })
    .expect(200);

  expect(response.body.title).toBe('Updated Title');
  expect(response.body.content).toBe('Updated Content');
});

it('DELETE /posts/:id', async () => {
  await request(app.getHttpServer())
    .delete(`/posts/${createdPostId}`)
    .expect(200);

  await request(app.getHttpServer())
    .get(`/posts/${createdPostId}`)
    .expect(404);
});

docker-compose up -d test-db

DATABASE_URL=postgresql://postgres:postgres@localhost:5433/test_db npx prisma migrate deploy

npm run test:e2e

  findOne(id: number) {
    return this.prisma.post.findUnique({ where: { id } });
  }

import { NotFoundException } from '@nestjs/common';

async findOne(id: number) {
  const post = await this.prisma.post.findUnique({ where: { id } });
  if (!post) throw new NotFoundException(`Post with ID ${id} not found`);
  return post;
}

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from '../src/app.module';
import { resetDatabase } from './utils/db';
import { Server } from 'http';

type PostResponse = {
  id: number;
  title: string;
  content: string;
};

describe('PostsController (e2e)', () => {
  let app: INestApplication;
  let httpServer: Server;
  let createdPostId: number;
  beforeAll(async () => {
    await resetDatabase();
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    await app.init();
    httpServer = app.getHttpServer() as Server;
  });

  afterAll(async () => {
    await app.close();
  });

  it('/posts (POST)', async () => {
    const response = await request(httpServer)
      .post('/posts')
      .send({ title: 'E2E Test Title', content: 'E2E Test Content' })
      .expect(201);

    const body = response.body as PostResponse;
    expect(body).toHaveProperty('id');
    expect(body.title).toBe('E2E Test Title');
    createdPostId = body.id;
  });

  it('/posts (GET)', async () => {
    const response = await request(httpServer).get('/posts').expect(200);
    const body = response.body as PostResponse[];
    expect(Array.isArray(body)).toBe(true);
    expect(body.length).toBeGreaterThan(0);
  });

  it('GET /posts/:id', async () => {
    const response = await request(httpServer)
      .get(`/posts/${createdPostId}`)
      .expect(200);
    const body = response.body as PostResponse;

    expect(body.id).toBe(createdPostId);
    expect(body.title).toBe('E2E Test Title');
  });

  it('PATCH /posts/:id', async () => {
    const response = await request(httpServer)
      .patch(`/posts/${createdPostId}`)
      .send({ title: 'Updated Title', content: 'Updated Content' })
      .expect(200);
    const body = response.body as PostResponse;

    expect(body.title).toBe('Updated Title');
    expect(body.content).toBe('Updated Content');
  });

  it('DELETE /posts/:id', async () => {
    await request(httpServer).delete(`/posts/${createdPostId}`).expect(200);

    await request(httpServer).get(`/posts/${createdPostId}`).expect(404);
  });
});