Files
mtusi2026lab4/app/src/main.ts
T

113 lines
3.9 KiB
TypeScript

import { NestFactory } from '@nestjs/core';
import { HttpAdapterHost } from '@nestjs/core';
import { ConfigService } from '@nestjs/config';
import {
PayloadTooLargeException,
UnsupportedMediaTypeException,
ValidationPipe,
} from '@nestjs/common';
import type { Readable } from 'node:stream';
import {
FastifyAdapter,
NestFastifyApplication,
} from '@nestjs/platform-fastify';
import { AppModule } from './app.module.js';
import { HealthService } from './health/health.service.js';
import { MetricsService } from './metrics/metrics.service.js';
import { RequestIdInterceptor } from './common/http/request-id.interceptor.js';
const TEXT_BODY_LIMIT = 1_048_576;
const UPLOAD_ROUTE = '/api/v1/chats/:chatId/attachments';
async function bootstrap(): Promise<void> {
const app = await NestFactory.create<NestFastifyApplication>(
AppModule,
new FastifyAdapter({ logger: true }),
);
// Raw image bodies reach the controller as an unread stream: the upload is
// bounded by our own checks, not by Fastify's bodyLimit. A stream may reach
// only the upload route: on JSON routes it would hit the ValidationPipe and
// overflow the stack there, so other routes keep the pre-upload behavior.
const fastify = app.getHttpAdapter().getInstance();
type ParserRequest = { method: string; routeOptions?: { url?: string } };
type Done = (error: Error | null, body?: unknown) => void;
const isUpload = (request: ParserRequest) =>
request.method === 'POST' && request.routeOptions?.url === UPLOAD_ROUTE;
fastify.addContentTypeParser(
['image/png', 'image/jpeg'],
(request: ParserRequest, payload: unknown, done: Done) =>
isUpload(request)
? done(null, payload)
: done(new UnsupportedMediaTypeException()),
);
// Fastify's built-in text/plain parser buffers the body and fails binary
// input with 400; on the upload route the service answers 415 instead.
// Elsewhere text/plain keeps being buffered as a string (1 MiB cap).
fastify.removeContentTypeParser('text/plain');
fastify.addContentTypeParser(
'text/plain',
(request: ParserRequest, payload: Readable, done: Done) => {
if (isUpload(request)) return done(null, payload);
const chunks: Buffer[] = [];
let size = 0;
payload.on('data', (chunk: Buffer) => {
size += chunk.length;
if (size > TEXT_BODY_LIMIT) {
payload.destroy();
done(new PayloadTooLargeException());
} else chunks.push(chunk);
});
payload.on('end', () =>
done(null, Buffer.concat(chunks).toString('utf8')),
);
payload.on('error', (error: Error) => done(error));
},
);
app.useGlobalInterceptors(
new RequestIdInterceptor(
app.get(HttpAdapterHost),
app.get(MetricsService),
app.get(ConfigService),
),
);
app.useGlobalPipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}),
);
const config = app.get(ConfigService);
const port = config.getOrThrow<number>('APP_PORT');
const host = config.getOrThrow<string>('APP_HOST');
await app.listen(port, host);
// Drain before teardown. Nest's own shutdown sequence destroys providers
// (closing the database pool and Redis) before `beforeApplicationShutdown`
// runs, so relying on it would keep the replica listed in the load balancer
// while it can no longer serve: SIGTERM must first turn the replica
// not-ready for the LB probe, then wait DRAIN_DELAY_MS, and only then close
// the server and the pools.
const health = app.get(HealthService);
const drainDelayMs = config.getOrThrow<number>('DRAIN_DELAY_MS');
let shuttingDown = false;
const shutdown = async (): Promise<void> => {
if (shuttingDown) return;
shuttingDown = true;
health.setDraining();
if (drainDelayMs > 0)
await new Promise<void>((resolve) =>
setTimeout(resolve, drainDelayMs),
);
await app.close();
process.exit(0);
};
for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP'] as const)
process.once(signal, () => {
void shutdown();
});
}
await bootstrap();