113 lines
3.9 KiB
TypeScript
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();
|