@innv/nest-initializer 0.1.0

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

@@ -0,0 +1,45 @@
+"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.MetricsInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const prom_client_1 = require("prom-client");
+const operators_1 = require("rxjs/operators");
+const metrics_tokens_1 = require("./metrics.tokens");
+let MetricsInterceptor = class MetricsInterceptor {
+    histogram;
+    constructor(histogram) {
+        this.histogram = histogram;
+    }
+    intercept(context, next) {
+        const httpContext = context.switchToHttp();
+        const request = httpContext.getRequest();
+        const response = httpContext.getResponse();
+        const end = this.histogram.startTimer();
+        return next.handle().pipe((0, operators_1.finalize)(() => {
+            const path = request.route?.path ?? request.path;
+            end({
+                method: request.method,
+                path: path,
+                status_code: response.statusCode,
+            });
+        }));
+    }
+};
+exports.MetricsInterceptor = MetricsInterceptor;
+exports.MetricsInterceptor = MetricsInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(metrics_tokens_1.METRICS_HTTP_HISTOGRAM)),
+    __metadata("design:paramtypes", [prom_client_1.Histogram])
+], MetricsInterceptor);

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

@@ -0,0 +1,38 @@
+"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 MetricsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const metrics_controller_1 = require("./metrics.controller");
+const metrics_interceptor_1 = require("./metrics.interceptor");
+const metrics_provider_1 = require("./metrics.provider");
+const metrics_tokens_1 = require("./metrics.tokens");
+let MetricsModule = MetricsModule_1 = class MetricsModule {
+    static forRoot() {
+        const providers = [
+            ...metrics_provider_1.metricsProviders,
+            metrics_interceptor_1.MetricsInterceptor,
+            {
+                provide: core_1.APP_INTERCEPTOR,
+                useClass: metrics_interceptor_1.MetricsInterceptor,
+            },
+        ];
+        return {
+            module: MetricsModule_1,
+            controllers: [metrics_controller_1.MetricsController],
+            providers: providers,
+            exports: [metrics_tokens_1.METRICS_REGISTRY, metrics_tokens_1.METRICS_HTTP_HISTOGRAM],
+        };
+    }
+};
+exports.MetricsModule = MetricsModule;
+exports.MetricsModule = MetricsModule = MetricsModule_1 = __decorate([
+    (0, common_1.Module)({})
+], MetricsModule);

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metricsProviders = void 0;
+const prom_client_1 = require("prom-client");
+const metrics_tokens_1 = require("./metrics.tokens");
+exports.metricsProviders = [
+    {
+        provide: metrics_tokens_1.METRICS_REGISTRY,
+        useFactory: () => {
+            const registry = new prom_client_1.Registry();
+            (0, prom_client_1.collectDefaultMetrics)({ register: registry });
+            return registry;
+        },
+    },
+    {
+        provide: metrics_tokens_1.METRICS_HTTP_HISTOGRAM,
+        useFactory: (registry) => {
+            const histogram = new prom_client_1.Histogram({
+                name: 'http_requests_duration_seconds',
+                help: 'Duração das requisições HTTP em segundos',
+                labelNames: ['method', 'path', 'status_code'],
+                buckets: [0.1, 0.3, 0.5, 0.7, 1, 3, 5, 10], // Buckets em segundos
+            });
+            registry.registerMetric(histogram);
+            return histogram;
+        },
+        inject: [metrics_tokens_1.METRICS_REGISTRY],
+    },
+];

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METRICS_HTTP_HISTOGRAM = exports.METRICS_REGISTRY = void 0;
+exports.METRICS_REGISTRY = 'METRICS_REGISTRY';
+exports.METRICS_HTTP_HISTOGRAM = 'METRICS_HTTP_HISTOGRAM';

package/dist/esm/features/terminus-health-check.module.js

@@ -0,0 +1,39 @@
+"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 TerminusHealthCheckModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminusHealthCheckModule = void 0;
+const axios_1 = require("@nestjs/axios");
+const common_1 = require("@nestjs/common");
+const terminus_1 = require("@nestjs/terminus");
+const health_controller_1 = require("./health.controller");
+let TerminusHealthCheckModule = TerminusHealthCheckModule_1 = class TerminusHealthCheckModule {
+    static forRoot(options) {
+        const providers = [];
+        if (options.database) {
+            providers.push(terminus_1.TypeOrmHealthIndicator);
+        }
+        const optionsProvider = {
+            provide: health_controller_1.HEALTH_CHECK_OPTIONS,
+            useValue: options,
+        };
+        providers.push(optionsProvider);
+        providers.push(terminus_1.MemoryHealthIndicator);
+        return {
+            module: TerminusHealthCheckModule_1,
+            imports: [terminus_1.TerminusModule, axios_1.HttpModule],
+            controllers: [health_controller_1.HealthController],
+            providers: providers,
+            exports: [],
+        };
+    }
+};
+exports.TerminusHealthCheckModule = TerminusHealthCheckModule;
+exports.TerminusHealthCheckModule = TerminusHealthCheckModule = TerminusHealthCheckModule_1 = __decorate([
+    (0, common_1.Module)({})
+], TerminusHealthCheckModule);

package/dist/esm/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("./core/app-initializer"), exports);
+__exportStar(require("./plugins"), exports);

package/dist/esm/plugins/index.js

@@ -0,0 +1,19 @@
+"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("./rate-limiter.plugin"), exports);
+__exportStar(require("./request-logger.plugin"), exports);
+__exportStar(require("./typeorm-migration.plugin"), exports);

package/dist/esm/plugins/rate-limiter.plugin.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiterPlugin = void 0;
+const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+class RateLimiterPlugin {
+    options;
+    constructor(options = {}) {
+        const finalOptions = {
+            windowMs: 15 * 60 * 1000,
+            limit: 100,
+            statusCode: 429,
+            message: 'Too many requests from this IP, please try again after 15 minutes',
+            standardHeaders: true,
+            legacyHeaders: false,
+            ...options,
+        };
+        this.options = finalOptions;
+    }
+    apply(app) {
+        app.use((0, express_rate_limit_1.default)(this.options));
+    }
+}
+exports.RateLimiterPlugin = RateLimiterPlugin;

package/dist/esm/plugins/request-logger.plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLoggerPlugin = void 0;
+const morgan_1 = __importDefault(require("morgan"));
+class RequestLoggerPlugin {
+    apply(app) {
+        app.use((0, morgan_1.default)('dev'));
+    }
+}
+exports.RequestLoggerPlugin = RequestLoggerPlugin;

package/dist/esm/plugins/typeorm-migration.plugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmMigrationPlugin = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+/**
+ * Um plugin do AppInitializer que executa automaticamente as migrations
+ * do TypeORM na inicialização da aplicação.
+ */
+class TypeOrmMigrationPlugin {
+    logger = new common_1.Logger(TypeOrmMigrationPlugin.name);
+    /**
+     * Método 'apply' que será chamado pelo AppInitializer durante o bootstrap.
+     * Este método é assíncrono para poder aguardar a conclusão das migrations.
+     * @param app A instância da aplicação NestJS.
+     */
+    async apply(app) {
+        try {
+            const dataSource = app.get(typeorm_1.DataSource);
+            this.logger.log('Iniciando execução das migrations do banco de dados...');
+            await dataSource.runMigrations();
+            this.logger.log('Migrations executadas com sucesso.');
+        }
+        catch (error) {
+            this.logger.error('Falha ao obter DataSource ou executar migrations.', error);
+            throw error;
+        }
+    }
+}
+exports.TypeOrmMigrationPlugin = TypeOrmMigrationPlugin;

package/dist/esm/starters/caching.starter.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCachingStarter = createCachingStarter;
+const cache_manager_1 = require("@nestjs/cache-manager");
+const config_1 = require("@nestjs/config");
+const cache_manager_redis_store_1 = require("cache-manager-redis-store");
+/**
+ * Cria o módulo dinâmico para o "Starter" de Cache.
+ * Configura o CacheModule para ser global e usar o Redis.
+ */
+function createCachingStarter(options = {}) {
+    const { redisUrlEnvKey = 'REDIS_URL', defaultTtlInSeconds = 300 } = options;
+    return cache_manager_1.CacheModule.registerAsync({
+        isGlobal: true,
+        imports: [],
+        inject: [config_1.ConfigService],
+        useFactory: async (configService) => {
+            const store = await (0, cache_manager_redis_store_1.redisStore)({
+                url: configService.get(redisUrlEnvKey),
+            });
+            return {
+                store: () => store,
+                ttl: defaultTtlInSeconds,
+            };
+        },
+    });
+}

package/dist/esm/starters/index.js

@@ -0,0 +1,19 @@
+"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("./typeorm.starter"), exports);
+__exportStar(require("./mongoose.starter"), exports);
+__exportStar(require("./caching.starter"), exports);

package/dist/esm/starters/mongoose.starter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongooseStarter = createMongooseStarter;
+const config_1 = require("@nestjs/config");
+const mongoose_1 = require("@nestjs/mongoose");
+/**
+ * Cria o módulo dinâmico para o "Starter" de Mongoose.
+ * Configura o MongooseModule para ser global e usar a URI do .env.
+ */
+function createMongooseStarter(options = {}) {
+    const { uriEnvKey = 'MONGO_URI', mongooseOptions = {} } = options;
+    const mongooseDynamicModule = mongoose_1.MongooseModule.forRootAsync({
+        imports: [],
+        inject: [config_1.ConfigService],
+        useFactory: (configService) => ({
+            uri: configService.get(uriEnvKey),
+            ...mongooseOptions,
+        }),
+    });
+    return {
+        module: mongooseDynamicModule,
+        plugins: [],
+    };
+}

package/dist/esm/starters/typeorm.starter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeOrmStarter = createTypeOrmStarter;
+const config_1 = require("@nestjs/config");
+const typeorm_1 = require("@nestjs/typeorm");
+const plugins_1 = require("../plugins");
+/**
+ * Cria o módulo dinâmico para o "Starter" de TypeORM.
+ * Esta função constrói toda a configuração necessária para o TypeOrmModule.
+ */
+function createTypeOrmStarter(options = {}) {
+    const { autoLoadEntities = true, runMigrationsOnStartup = false, databaseUrlEnvKey = 'DATABASE_URL', typeOrmOptions = {}, } = options;
+    const typeOrmDynamicModule = typeorm_1.TypeOrmModule.forRootAsync({
+        imports: [],
+        inject: [config_1.ConfigService],
+        useFactory: (configService) => ({
+            url: configService.get(databaseUrlEnvKey),
+            autoLoadEntities: autoLoadEntities,
+            synchronize: false,
+            ...typeOrmOptions,
+        }),
+    });
+    const plugins = [];
+    if (runMigrationsOnStartup) {
+        plugins.push(new plugins_1.TypeOrmMigrationPlugin());
+    }
+    return {
+        module: typeOrmDynamicModule,
+        plugins: plugins,
+    };
+}

package/dist/types/core/app-initializer.d.ts

@@ -0,0 +1,206 @@
+import { CanActivate, ExceptionFilter, INestApplication, NestInterceptor, PipeTransform, Type, ValidationPipeOptions, VersioningOptions } from '@nestjs/common';
+import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+import { AbstractHttpAdapter } from '@nestjs/core';
+import { TerminusHealthCheckOptions } from '../features';
+import { CachingStarterOptions, MongooseStarterOptions, TypeOrmStarterOptions } from '../starters';
+/**
+ * Interface que todos os plugins do AppInitializer devem implementar.
+ */
+export interface AppInitializerPlugin {
+    /**
+     * Método que será executado durante a inicialização para aplicar a lógica do plugin.
+     * Pode ser síncrono ou assíncrono.
+     * @param app A instância da aplicação NestJS (INestApplication).
+     */
+    apply(app: INestApplication): Promise<void> | void;
+}
+/**
+ * Opções para a configuração do Swagger (OpenAPI).
+ */
+export type SwaggerOptions = {
+    title: string;
+    description: string;
+    version: string;
+    path?: string;
+};
+/**
+ * Assinatura da função de callback usada para configurar o inicializador.
+ * @param app A instância do AppInitializer a ser configurada.
+ */
+type AppConfigurator<T extends INestApplication> = (app: AppInitializer<T>) => void;
+/**
+ * Uma classe fluente (Builder) para inicializar uma aplicação NestJS de forma declarativa.
+ */
+export declare class AppInitializer<T extends INestApplication = INestApplication> {
+    private app;
+    private readonly module;
+    private readonly adapter?;
+    private readonly logger;
+    private port;
+    private globalPrefix?;
+    private versioningOptions?;
+    private corsOptions?;
+    private swaggerOptions?;
+    private readonly setupFunctions;
+    private readonly plugins;
+    private readonly featureModules;
+    private advancedSwaggerUiOptions?;
+    private autoDiscoveredComponents?;
+    private readonly globalProviders;
+    private readonly factoryGeneratedControllers;
+    private constructor();
+    /**
+     * 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: Omit<SwaggerOptions, 'path'>): 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;
+    /**
+     * 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: boolean, configure: (builder: this) => void): this;
+    withHealthCheck(options: TerminusHealthCheckOptions): 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;
+    static bootstrap<T extends INestApplication = INestApplication>(module: Type, configurator: AppConfigurator<T>): Promise<void>;
+    static bootstrap<T extends INestApplication = INestApplication>(module: Type, adapter: AbstractHttpAdapter, configurator: AppConfigurator<T>): Promise<void>;
+    /**
+     * Define a porta em que a aplicação vai rodar.
+     * @param port O número da porta.
+     */
+    onPort(port: number): 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: AppInitializerPlugin): this;
+    /**
+     * Habilita e configura o versionamento da API.
+     * @param options As opções de versionamento do NestJS.
+     */
+    withVersioning(options: VersioningOptions): this;
+    /**
+     * Define um prefixo global para todas as rotas da aplicação (ex: /api/v1).
+     * @param prefix O prefixo a ser aplicado.
+     */
+    withGlobalPrefix(prefix: string): this;
+    /**
+     * Habilita e configura o Cross-Origin Resource Sharing (CORS).
+     * @param options As opções de configuração do CORS.
+     */
+    withCors(options?: CorsOptions): 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?: ValidationPipeOptions): 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: Type<PipeTransform>): 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: Type<ExceptionFilter>): 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: Type<CanActivate>): 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: Type<NestInterceptor>): this;
+    /**
+     * Registra o ClassSerializerInterceptor globalmente.
+     * Essencial para transformações de DTO (@Exclude, @Expose).
+     * Ele automaticamente recebe o Reflector via DI.
+     */
+    withClassSerializer(): this;
+    /**
+     * Habilita e configura a documentação da API via Swagger (OpenAPI).
+     * @param options As opções para construir a documentação.
+     */
+    withSwagger(options: SwaggerOptions): 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(): this;
+    /**
+     * Habilita os 'shutdown hooks' do NestJS para um desligamento gracioso.
+     */
+    withGracefulShutdown(): this;
+    /**
+     * Adiciona o middleware de segurança Helmet com configurações padrão.
+     */
+    useHelmet(): this;
+    /**
+     * Adiciona o middleware de compressão (gzip) para as respostas.
+     */
+    enableCompression(): 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<T extends object>(schema: Type<T>): this;
+    /**
+     * Configura e registra automaticamente o TypeOrmModule (Estilo "Starter").
+     * @param options Opções para o "Starter" de TypeORM.
+     */
+    withTypeOrm(options?: TypeOrmStarterOptions): 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?: MongooseStarterOptions): 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?: CachingStarterOptions): 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(): T;
+    /**
+     * 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: {
+        basePath: string;
+    }): this;
+    private listen;
+}
+export {};

package/dist/types/core/auto-discovery.helper.d.ts

@@ -0,0 +1,15 @@
+import { Type } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+interface DiscoveredComponents {
+    providers: Type[];
+    controllers: Type[];
+}
+type RequireFn = (id: string) => any;
+/**
+ * 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).
+ */
+export declare function discoverComponents(basePath: string, reflectorInst: Reflector, requireFn?: RequireFn): DiscoveredComponents;
+export {};

package/dist/types/core/config-validator.helper.d.ts

@@ -0,0 +1,9 @@
+import { Type } from '@nestjs/common';
+/**
+ * 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.
+ */
+export declare function validateConfig<T extends object>(config: Record<string, any>, schema: Type<T>): T;

package/dist/types/core/index.d.ts

@@ -0,0 +1 @@
+export * from './app-initializer';

package/dist/types/features/health.controller.d.ts

@@ -0,0 +1,11 @@
+import { HealthCheckService, MemoryHealthIndicator, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import * as terminusHealthCheckModule from './terminus-health-check.module';
+export declare const HEALTH_CHECK_OPTIONS = "HEALTH_CHECK_OPTIONS";
+export declare class HealthController {
+    private readonly options;
+    private readonly health;
+    private readonly db;
+    private readonly memory;
+    constructor(options: terminusHealthCheckModule.TerminusHealthCheckOptions, health: HealthCheckService, db: TypeOrmHealthIndicator, memory: MemoryHealthIndicator);
+    check(): Promise<import("@nestjs/terminus").HealthCheckResult>;
+}

package/dist/types/features/index.d.ts

@@ -0,0 +1,2 @@
+export * from './metrics/metrics.module';
+export * from './terminus-health-check.module';

package/dist/types/features/metrics/metrics.controller.d.ts

@@ -0,0 +1,6 @@
+import { Registry } from 'prom-client';
+export declare class MetricsController {
+    private readonly registry;
+    constructor(registry: Registry);
+    getMetrics(res: any): Promise<void>;
+}

package/dist/types/features/metrics/metrics.interceptor.d.ts

@@ -0,0 +1,8 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Histogram } from 'prom-client';
+import { Observable } from 'rxjs';
+export declare class MetricsInterceptor implements NestInterceptor {
+    private readonly histogram;
+    constructor(histogram: Histogram);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}

package/dist/types/features/metrics/metrics.module.d.ts

@@ -0,0 +1,4 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class MetricsModule {
+    static forRoot(): DynamicModule;
+}

package/dist/types/features/metrics/metrics.provider.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '@nestjs/common';
+export declare const metricsProviders: Provider[];