@innv/nest-initializer 0.1.0

package/dist/esm/core/app-initializer.js

@@ -0,0 +1,431 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppInitializer = void 0;
+const path_1 = require("path");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const core_1 = require("@nestjs/core");
+const swagger_1 = require("@nestjs/swagger");
+const compression_1 = __importDefault(require("compression"));
+const helmet_1 = __importDefault(require("helmet"));
+const auto_discovery_helper_1 = require("./auto-discovery.helper");
+const config_validator_helper_1 = require("./config-validator.helper");
+const features_1 = require("../features");
+const plugins_1 = require("../plugins");
+const starters_1 = require("../starters");
+/**
+ * Uma classe fluente (Builder) para inicializar uma aplicação NestJS de forma declarativa.
+ */
+class AppInitializer {
+    app;
+    module;
+    adapter;
+    logger = new common_1.Logger(AppInitializer.name);
+    port = parseInt(process.env.PORT || '3000', 10);
+    globalPrefix;
+    versioningOptions;
+    corsOptions;
+    swaggerOptions;
+    setupFunctions = [];
+    plugins = [];
+    featureModules = [];
+    advancedSwaggerUiOptions;
+    autoDiscoveredComponents;
+    globalProviders = [];
+    factoryGeneratedControllers = [];
+    constructor(module, adapter) {
+        this.module = module;
+        this.adapter = adapter;
+    }
+    /**
+     * Aplica um conjunto de configurações padrão recomendadas para o ambiente de desenvolvimento.
+     * Inclui Swagger e um logger de requisições.
+     * @param swaggerOptions Opções para customizar a documentação Swagger.
+     */
+    useDevelopmentDefaults(swaggerOptions) {
+        this.withSwagger({ ...swaggerOptions, path: 'docs' });
+        this.withPlugin(new plugins_1.RequestLoggerPlugin());
+        return this;
+    }
+    /**
+     * Aplica um conjunto de configurações padrão recomendadas para o ambiente de produção.
+     * Inclui Helmet, compressão, graceful shutdown e um rate limiter básico.
+     */
+    useProductionDefaults() {
+        this.useHelmet();
+        this.enableCompression();
+        this.withGracefulShutdown();
+        this.withPlugin(new plugins_1.RateLimiterPlugin());
+        return this;
+    }
+    /**
+     * Aplica um bloco de configurações de forma condicional.
+     * @param condition A condição booleana. Se for `true`, o callback de configuração será executado.
+     * @param configure A função de callback que recebe o builder para aplicar as configurações.
+     */
+    when(condition, configure) {
+        if (condition) {
+            configure(this);
+        }
+        return this;
+    }
+    withHealthCheck(options) {
+        this.featureModules.push(features_1.TerminusHealthCheckModule.forRoot(options));
+        return this;
+    }
+    /**
+     * Habilita a coleta e exposição de métricas no padrão Prometheus
+     * no endpoint /metrics. Inclui métricas padrão do Node.js
+     * e métricas de latência de requisições HTTP.
+     */
+    withMetrics() {
+        this.featureModules.push(features_1.MetricsModule.forRoot());
+        return this;
+    }
+    /**
+     * Ponto de entrada estático para criar, configurar e iniciar a aplicação.
+     * @param module O módulo raiz da aplicação (ex: AppModule).
+     * @param adapterOrConfigurator O adaptador HTTP ou a função de configuração.
+     * @param configurator Uma função de callback que recebe o builder para aplicar as configurações.
+     */
+    static async bootstrap(module, adapterOrConfigurator, configurator) {
+        const isExpress = typeof adapterOrConfigurator === 'function';
+        const adapter = isExpress ? undefined : adapterOrConfigurator;
+        const finalConfigurator = isExpress ? adapterOrConfigurator : configurator;
+        if (!finalConfigurator) {
+            throw new TypeError('Função de configuração do bootstrap não encontrada. Verifique os argumentos.');
+        }
+        const initializer = new AppInitializer(module, adapter);
+        try {
+            initializer.logger.log('Iniciando o processo de bootstrap da aplicação...');
+            finalConfigurator(initializer);
+            await initializer.listen();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                initializer.logger.error(`Falha ao inicializar a aplicação. Error: ${error.message}`, error.stack);
+            }
+            else {
+                initializer.logger.error('Falha ao inicializar a aplicação com um erro não-padrão.', error);
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * Define a porta em que a aplicação vai rodar.
+     * @param port O número da porta.
+     */
+    onPort(port) {
+        this.port = port;
+        return this;
+    }
+    /**
+     * Registra um plugin para ser executado durante a inicialização.
+     * @param plugin Uma instância de um objeto que implementa a interface AppInitializerPlugin.
+     */
+    withPlugin(plugin) {
+        this.plugins.push(plugin);
+        return this;
+    }
+    /**
+     * Habilita e configura o versionamento da API.
+     * @param options As opções de versionamento do NestJS.
+     */
+    withVersioning(options) {
+        this.versioningOptions = options;
+        return this;
+    }
+    /**
+     * Define um prefixo global para todas as rotas da aplicação (ex: /api/v1).
+     * @param prefix O prefixo a ser aplicado.
+     */
+    withGlobalPrefix(prefix) {
+        this.globalPrefix = prefix.startsWith('/') ? prefix : `/${prefix}`;
+        return this;
+    }
+    /**
+     * Habilita e configura o Cross-Origin Resource Sharing (CORS).
+     * @param options As opções de configuração do CORS.
+     */
+    withCors(options = {}) {
+        this.corsOptions = options;
+        return this;
+    }
+    /**
+     * Adiciona o ValidationPipe global com opções customizadas.
+     * Esta é a forma recomendada de habilitar a validação padrão.
+     * @param options Opções de configuração para o ValidationPipe.
+     */
+    withValidationPipe(options = {}) {
+        const defaultOptions = {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+            transform: true,
+            transformOptions: { enableImplicitConversion: true },
+        };
+        const finalOptions = { ...defaultOptions, ...options };
+        this.globalProviders.push({
+            provide: core_1.APP_PIPE,
+            useValue: new common_1.ValidationPipe(finalOptions),
+        });
+        return this;
+    }
+    /**
+     * Registra um Pipe global customizado (ex: um pipe de parsing).
+     * O pipe participará da Injeção de Dependência.
+     * @param pipe A *classe* do pipe a ser registrada.
+     */
+    useGlobalPipe(pipe) {
+        this.globalProviders.push({
+            provide: core_1.APP_PIPE,
+            useClass: pipe,
+        });
+        return this;
+    }
+    /**
+     * Registra um Filtro de Exceção global (ex: HttpExceptionFilter).
+     * O filtro participará da Injeção de Dependência.
+     * @param filter A *classe* do filtro a ser registrada.
+     */
+    useGlobalFilter(filter) {
+        this.globalProviders.push({
+            provide: core_1.APP_FILTER,
+            useClass: filter,
+        });
+        return this;
+    }
+    /**
+     * Registra um Guard global (ex: JwtAuthGuard).
+     * O guard participará da Injeção de Dependência.
+     * @param guard A *classe* do guard a ser registrada.
+     */
+    useGlobalGuard(guard) {
+        this.globalProviders.push({
+            provide: core_1.APP_GUARD,
+            useClass: guard,
+        });
+        return this;
+    }
+    /**
+     * Registra um Interceptor global (ex: LoggingInterceptor).
+     * O interceptor participará da Injeção de Dependência.
+     * @param interceptor A *classe* do interceptor a ser registrada.
+     */
+    useGlobalInterceptor(interceptor) {
+        this.globalProviders.push({
+            provide: core_1.APP_INTERCEPTOR,
+            useClass: interceptor,
+        });
+        return this;
+    }
+    /**
+     * Registra o ClassSerializerInterceptor globalmente.
+     * Essencial para transformações de DTO (@Exclude, @Expose).
+     * Ele automaticamente recebe o Reflector via DI.
+     */
+    withClassSerializer() {
+        this.globalProviders.push({
+            provide: core_1.APP_INTERCEPTOR,
+            useClass: common_1.ClassSerializerInterceptor,
+        });
+        return this;
+    }
+    /**
+     * Habilita e configura a documentação da API via Swagger (OpenAPI).
+     * @param options As opções para construir a documentação.
+     */
+    withSwagger(options) {
+        this.swaggerOptions = { path: 'docs', ...options };
+        return this;
+    }
+    /**
+     * Aplica customizações avançadas à interface do Swagger UI.
+     * Isso pode incluir temas, scripts e outras configurações visuais.
+     * Por padrão, aplica um tema escuro e algumas configurações de layout.
+     */
+    withAdvancedSwaggerUI() {
+        // Aponta para os arquivos de customização que criamos.
+        // O __dirname aponta para o diretório compilado, que deve ser 'dist' ou 'build'.
+        // Os arquivos .css e .js devem estar lá também após a compilação.
+        this.advancedSwaggerUiOptions = {
+            customCss: (0, path_1.join)(__dirname, 'swagger-ui-customization', 'swagger-dark-theme.css'),
+            customJs: (0, path_1.join)(__dirname, 'swagger-ui-customization', 'swagger-custom.js'),
+        };
+        return this;
+    }
+    /**
+     * Habilita os 'shutdown hooks' do NestJS para um desligamento gracioso.
+     */
+    withGracefulShutdown() {
+        this.setupFunctions.push((app) => app.enableShutdownHooks());
+        return this;
+    }
+    /**
+     * Adiciona o middleware de segurança Helmet com configurações padrão.
+     */
+    useHelmet() {
+        this.setupFunctions.push((app) => app.use((0, helmet_1.default)()));
+        return this;
+    }
+    /**
+     * Adiciona o middleware de compressão (gzip) para as respostas.
+     */
+    enableCompression() {
+        this.setupFunctions.push((app) => app.use((0, compression_1.default)()));
+        return this;
+    }
+    /**
+     * Carrega e valida as variáveis de ambiente na inicialização
+     * usando um schema de validação (classe com decoradores class-validator).
+     * Se a validação falhar, a aplicação não será iniciada.
+     * @param schema A classe de schema para validar (ex: EnvironmentVariables).
+     */
+    withValidatedConfig(schema) {
+        const configModule = config_1.ConfigModule.forRoot({
+            isGlobal: true,
+            validate: (config) => (0, config_validator_helper_1.validateConfig)(config, schema),
+        });
+        this.featureModules.push(configModule);
+        return this;
+    }
+    /**
+     * Configura e registra automaticamente o TypeOrmModule (Estilo "Starter").
+     * @param options Opções para o "Starter" de TypeORM.
+     */
+    withTypeOrm(options = {}) {
+        const starter = (0, starters_1.createTypeOrmStarter)(options);
+        this.featureModules.push(starter.module);
+        for (const plugin of starter.plugins) {
+            this.withPlugin(plugin);
+        }
+        return this;
+    }
+    /**
+     * Configura e registra automaticamente o MongooseModule (Estilo "Starter").
+     * Usa a configuração global (de .withValidatedConfig) para se conectar
+     * ao MongoDB e descobre schemas automaticamente.
+     *
+     * @param options Opções para o "Starter" de Mongoose.
+     */
+    withMongoose(options = {}) {
+        const starter = (0, starters_1.createMongooseStarter)(options);
+        this.featureModules.push(starter.module);
+        return this;
+    }
+    /**
+     * Configura e registra automaticamente o CacheModule (Estilo "Starter").
+     * Usa a configuração global (de .withValidatedConfig) para se conectar
+     * ao Redis e torna o cache globalmente disponível.
+     *
+     * @param options Opções para o "Starter" de Cache.
+     */
+    withCaching(options = {}) {
+        const cacheDynamicModule = (0, starters_1.createCachingStarter)(options);
+        this.featureModules.push(cacheDynamicModule);
+        return this;
+    }
+    /**
+     * Retorna a instância da aplicação NestJS (INestApplication) após a inicialização.
+     * @throws Error se a aplicação ainda não foi inicializada.
+     */
+    getApp() {
+        return this.app;
+    }
+    /**
+     * Habilita a descoberta e registro automático de Providers e Controllers.
+     * Varre o projeto em busca de classes com @Injectable() e @Controller()
+     * e as adiciona ao módulo raiz.
+     * @param options Opções para configurar a descoberta.
+     */
+    withAutoDiscovery(options) {
+        const reflector = new core_1.Reflector();
+        this.autoDiscoveredComponents = (0, auto_discovery_helper_1.discoverComponents)(options.basePath, reflector);
+        return this;
+    }
+    async listen() {
+        this.logger.log('Criando a instância da aplicação NestJS...');
+        const rootImports = [this.module, ...this.featureModules];
+        const allProviders = [
+            ...(this.autoDiscoveredComponents?.providers ?? []),
+            ...this.globalProviders,
+        ];
+        const allControllers = [
+            ...(this.autoDiscoveredComponents?.controllers ?? []),
+            ...this.factoryGeneratedControllers,
+        ];
+        let DynamicRootModule = class DynamicRootModule {
+        };
+        DynamicRootModule = __decorate([
+            (0, common_1.Module)({
+                imports: rootImports,
+                controllers: allControllers,
+                providers: allProviders,
+            })
+        ], DynamicRootModule);
+        this.app = this.adapter
+            ? await core_1.NestFactory.create(DynamicRootModule, this.adapter)
+            : await core_1.NestFactory.create(DynamicRootModule);
+        if (this.globalPrefix)
+            this.app.setGlobalPrefix(this.globalPrefix);
+        if (this.corsOptions)
+            this.app.enableCors(this.corsOptions);
+        if (this.versioningOptions) {
+            this.app.enableVersioning(this.versioningOptions);
+        }
+        for (const setup of this.setupFunctions) {
+            setup(this.app);
+        }
+        for (const plugin of this.plugins) {
+            this.logger.log(`Aplicando o plugin: ${plugin.constructor.name}`);
+            await plugin.apply(this.app);
+        }
+        if (this.swaggerOptions) {
+            const config = new swagger_1.DocumentBuilder()
+                .setTitle(this.swaggerOptions.title)
+                .setDescription(this.swaggerOptions.description)
+                .setVersion(this.swaggerOptions.version)
+                .addBearerAuth()
+                .build();
+            const document = swagger_1.SwaggerModule.createDocument(this.app, config);
+            const swaggerSetupOptions = {};
+            if (this.advancedSwaggerUiOptions?.customCss) {
+                swaggerSetupOptions.customCssUrl =
+                    this.advancedSwaggerUiOptions.customCss;
+            }
+            if (this.advancedSwaggerUiOptions?.customJs) {
+                swaggerSetupOptions.customJsUrl =
+                    this.advancedSwaggerUiOptions.customJs;
+            }
+            swaggerSetupOptions.swaggerOptions = {
+                docExpansion: 'none',
+                filter: true,
+                showRequestDuration: true,
+                deepLinking: true,
+                displayRequestDuration: true,
+                tryItOutEnabled: true,
+                persistAuthorization: true,
+                defaultModelsExpandDepth: -1,
+                operationsSorter: 'alpha',
+                tagsSorter: 'alpha',
+            };
+            swagger_1.SwaggerModule.setup(this.swaggerOptions.path ?? 'docs', this.app, document, swaggerSetupOptions);
+        }
+        await this.app.listen(this.port);
+        const appUrl = await this.app.getUrl();
+        this.logger.log(`🚀 Aplicação rodando em: ${appUrl}`);
+        if (this.swaggerOptions) {
+            const swaggerPath = this.swaggerOptions.path ?? 'docs';
+            this.logger.log(`📄 Documentação Swagger disponível em: ${appUrl}/${swaggerPath}`);
+        }
+    }
+}
+exports.AppInitializer = AppInitializer;

package/dist/esm/core/auto-discovery.helper.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverComponents = discoverComponents;
+const path_1 = require("path");
+const glob_1 = require("glob");
+/**
+ * Descobre componentes NestJS (Providers e Controllers) em um diretório.
+ * @param basePath O diretório raiz para a varredura.
+ * @param reflectorInst Uma instância do Reflector.
+ * @param requireFn A função 'require' a ser usada (padrão: Node's require).
+ */
+function discoverComponents(basePath, reflectorInst, requireFn = require) {
+    const providers = [];
+    const controllers = [];
+    const files = (0, glob_1.globSync)((0, path_1.join)(basePath, '**/*.{ts,js}'), {
+        ignore: [
+            '**/*.module.{ts,js}',
+            '**/*.spec.{ts,js}',
+            '**/node_modules/**',
+            '**/features/**',
+            '**/plugins/**',
+        ],
+        absolute: true,
+    });
+    for (const file of files) {
+        try {
+            const exports = requireFn(file);
+            for (const key in exports) {
+                const exportedClass = exports[key];
+                if (typeof exportedClass === 'function' && exportedClass.prototype) {
+                    if (reflectorInst.get('path', exportedClass)) {
+                        controllers.push(exportedClass);
+                    }
+                    else if (reflectorInst.get('__injectable__', exportedClass)) {
+                        providers.push(exportedClass);
+                    }
+                }
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (_) {
+            // Ignora erros
+        }
+    }
+    return { providers, controllers };
+}

package/dist/esm/core/config-validator.helper.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/**
+ * Valida um objeto de configuração (ex: process.env) contra uma classe de schema.
+ * Se a validação falhar, lança um erro detalhado.
+ * @param config O objeto de configuração a ser validado (geralmente process.env).
+ * @param schema A classe de schema com decoradores do class-validator.
+ * @returns O objeto de configuração validado e transformado.
+ */
+function validateConfig(config, schema) {
+    const validatedConfig = (0, class_transformer_1.plainToInstance)(schema, config, {
+        enableImplicitConversion: true,
+        excludeExtraneousValues: true,
+    });
+    const errors = (0, class_validator_1.validateSync)(validatedConfig, {
+        skipMissingProperties: false,
+    });
+    if (errors.length > 0) {
+        const errorMessages = errors
+            .map((error) => Object.values(error.constraints || {}).join(', '))
+            .join('; ');
+        throw new Error(`[Configuração Inválida] ${errorMessages}`);
+    }
+    return validatedConfig;
+}

package/dist/esm/core/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app-initializer"), exports);

package/dist/esm/features/health.controller.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthController = exports.HEALTH_CHECK_OPTIONS = void 0;
+const common_1 = require("@nestjs/common");
+const terminus_1 = require("@nestjs/terminus");
+const terminusHealthCheckModule = __importStar(require("./terminus-health-check.module"));
+exports.HEALTH_CHECK_OPTIONS = 'HEALTH_CHECK_OPTIONS';
+let HealthController = class HealthController {
+    options;
+    health;
+    db;
+    memory;
+    constructor(options, health, db, memory) {
+        this.options = options;
+        this.health = health;
+        this.db = db;
+        this.memory = memory;
+    }
+    check() {
+        const checks = [];
+        if (this.options.database && this.db) {
+            checks.push(() => this.db.pingCheck('database'));
+        }
+        if (this.options.memory) {
+            const { heapThreshold = 200, rssThreshold = 300 } = this.options.memory;
+            checks.push(() => this.memory.checkHeap('memory_heap', heapThreshold * 1024 * 1024));
+            checks.push(() => this.memory.checkRSS('memory_rss', rssThreshold * 1024 * 1024));
+        }
+        return this.health.check(checks);
+    }
+};
+exports.HealthController = HealthController;
+__decorate([
+    (0, common_1.Get)(),
+    (0, terminus_1.HealthCheck)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HealthController.prototype, "check", null);
+exports.HealthController = HealthController = __decorate([
+    (0, common_1.Controller)('health'),
+    __param(0, (0, common_1.Inject)(exports.HEALTH_CHECK_OPTIONS)),
+    __param(2, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [Object, terminus_1.HealthCheckService,
+        terminus_1.TypeOrmHealthIndicator,
+        terminus_1.MemoryHealthIndicator])
+], HealthController);

package/dist/esm/features/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./metrics/metrics.module"), exports);
+__exportStar(require("./terminus-health-check.module"), exports);

package/dist/esm/features/metrics/metrics.controller.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsController = void 0;
+const common_1 = require("@nestjs/common");
+const prom_client_1 = require("prom-client");
+const metrics_tokens_1 = require("./metrics.tokens");
+let MetricsController = class MetricsController {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async getMetrics(res) {
+        res.header('Content-Type', this.registry.contentType);
+        res.send(await this.registry.metrics());
+    }
+};
+exports.MetricsController = MetricsController;
+__decorate([
+    (0, common_1.Get)(),
+    __param(0, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MetricsController.prototype, "getMetrics", null);
+exports.MetricsController = MetricsController = __decorate([
+    (0, common_1.Controller)('metrics'),
+    __param(0, (0, common_1.Inject)(metrics_tokens_1.METRICS_REGISTRY)),
+    __metadata("design:paramtypes", [prom_client_1.Registry])
+], MetricsController);