@miguelmorales13/nestkit 0.1.0

package/README.md

@@ -0,0 +1,411 @@
+# @miguelmorales13/nestkit
+
+Bloques de infraestructura reutilizables para servicios NestJS: i18n, manejo de errores,
+respuestas estandarizadas, tracking de requests, entidades base, CRUD genérico, y conexión a
+Postgres/Supabase (con el contrato listo para Mongo a futuro). Pensado para eliminar el boilerplate
+que se repite al arrancar cada backend nuevo.
+
+## ¿Para qué proyectos es esto?
+
+**Sí**: cualquier proyecto NestJS nuevo que arranque con el patrón hexagonal/ports-and-adapters
+(entidad → `Repository<T>` como puerto → adaptador de infraestructura), como `hr-pymes-saas`,
+`schools-saas`, `restaurant-inventory-saas`, o cualquier proyecto futuro que empiece de cero.
+
+**No**: proyectos existentes con convenciones ya establecidas y opuestas — por ejemplo `ms-pigmento`,
+que usa Mongoose directo sin capa de Repository y sin DTOs con `class-validator` (ver la skill
+`nestjs-backend` de ese proyecto). Meter `nestkit` ahí introduciría dos formas distintas de hacer lo
+mismo en el mismo código base. Si dudas si un proyecto califica, pregúntate: ¿los servicios llaman al
+ORM/cliente de DB directamente, o pasan por una interfaz de Repository? Si es lo primero, esta
+librería no es para ese proyecto.
+
+## Instalación
+
+```bash
+bun add @miguelmorales13/nestkit
+```
+
+`nestkit` declara sus dependencias de framework como **peer dependencies** — instala solo las que
+tu proyecto realmente use:
+
+| Siempre necesarios | Solo si usas... |
+|---------------------|------------------|
+| `@nestjs/common`, `@nestjs/core`, `reflect-metadata`, `rxjs` | `pg` → `./database/postgres` |
+| | `@supabase/supabase-js` → `./database/supabase` |
+| | `helmet`, `@nestjs/swagger` → `./bootstrap` (`applyNestKitDefaults`) |
+
+```bash
+bun add @nestjs/common @nestjs/core reflect-metadata rxjs
+bun add pg                          # si usas ./database/postgres
+bun add @supabase/supabase-js       # si usas ./database/supabase
+bun add helmet @nestjs/swagger      # si usas ./bootstrap
+bun add class-validator class-transformer  # requeridos en runtime por ValidationPipe
+```
+
+## Quickstart (`main.ts`)
+
+```ts
+import { NestFactory } from '@nestjs/core';
+import { applyNestKitDefaults } from '@miguelmorales13/nestkit/bootstrap';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  applyNestKitDefaults(app, {
+    swagger: { title: 'Mi API' },
+  });
+
+  await app.listen(process.env.PORT ?? 3000);
+}
+
+bootstrap();
+```
+
+`applyNestKitDefaults` aplica, en orden: `helmet`, CORS, `ValidationPipe` global
+(`whitelist + transform`), `GlobalExceptionFilter`, `ResponseInterceptor` y (salvo que pases
+`swagger: false`) Swagger. Cada pieza también se puede usar suelta si no quieres el paquete completo
+— ver cada módulo abajo.
+
+No olvides importar `TrackingModule` en tu `AppModule` para que `ResponseInterceptor` y
+`GlobalExceptionFilter` tengan un `requestId` que leer:
+
+```ts
+import { Module } from '@nestjs/common';
+import { TrackingModule } from '@miguelmorales13/nestkit/tracking';
+
+@Module({
+  imports: [TrackingModule],
+})
+export class AppModule {}
+```
+
+Con esto ya tienes: cualquier respuesta de cualquier controller sale envuelta en
+`{ success: true, data, requestId, timestamp }`, cualquier excepción sale como
+`{ success: false, error: { code, message, details? }, requestId, timestamp }`, con el header
+`X-Request-Id` reflejado en la respuesta.
+
+## Módulos
+
+### `entities` — entidades y DTOs base
+
+```ts
+import type { BaseEntity, SoftDeleteEntity } from '@miguelmorales13/nestkit/entities';
+import { BaseResponseDto } from '@miguelmorales13/nestkit/entities';
+
+// Entidad de dominio normal — id/createdAt/updatedAt vienen de BaseEntity
+export interface Widget extends BaseEntity {
+  name: string;
+}
+
+// Entidad con borrado lógico — agrega deletedAt: Date | null
+export interface Widget extends SoftDeleteEntity {
+  name: string;
+}
+
+// DTO de respuesta que mapea 1:1 la entidad, sin repetir constructor
+export class WidgetDto extends BaseResponseDto {
+  name!: string;
+}
+
+const dto = WidgetDto.fromEntity(widget); // instancia de WidgetDto, no de BaseResponseDto
+```
+
+`SoftDeleteEntity` es opcional — solo la usan las entidades que de verdad necesitan borrado lógico.
+Una entidad con `BaseEntity` a secas no carga el campo `deletedAt`.
+
+### `response` — envelope estandarizado
+
+Normalmente no construyes esto a mano: `ResponseInterceptor` (aplicado por `applyNestKitDefaults` o
+manualmente con `app.useGlobalInterceptors(new ResponseInterceptor())`) envuelve automáticamente
+cualquier valor que un controller retorne. Los tipos existen para cuando necesitas tipar el lado del
+cliente/consumidor de la API:
+
+```ts
+import type { ApiResponse, ApiSuccessResponse, ApiErrorResponse } from '@miguelmorales13/nestkit/response';
+
+async function fetchWidget(id: string): Promise<ApiResponse<Widget>> {
+  const res = await fetch(`/widgets/${id}`);
+  return res.json(); // { success: true, data: Widget, requestId, timestamp } | ApiErrorResponse
+}
+```
+
+### `errors` — excepciones tipadas + filtro global
+
+```ts
+import { NotFoundAppException, ConflictAppException } from '@miguelmorales13/nestkit/errors';
+
+async findOrFail(id: string): Promise<Widget> {
+  const widget = await this.repository.findById(id);
+  if (!widget) {
+    throw new NotFoundAppException(`Widget ${id} not found`, { id });
+  }
+  return widget;
+}
+```
+
+Subclases incluidas: `NotFoundAppException` (404), `ConflictAppException` (409),
+`ValidationAppException` (400), `UnauthorizedAppException` (401), `ForbiddenAppException` (403) — cada
+una acepta `(message?, details?, code?)`, con un `code` por default (ej. `'NOT_FOUND'`) que puedes
+sobreescribir si necesitas un código más específico del dominio. Para un error que no encaja en
+ninguna, usa `AppException` directo: `new AppException('INSUFFICIENT_STOCK', 'No hay suficiente inventario', HttpStatus.CONFLICT, { available: 3 })`.
+
+`GlobalExceptionFilter` (aplicado por `applyNestKitDefaults`) traduce **cualquier** excepción —
+`AppException`, cualquier `HttpException` nativa de Nest, o un error no controlado — al mismo
+`ApiErrorResponse`. Los errores 5xx se loggean con el stack completo vía el `Logger` de Nest, pero el
+stack **nunca** llega al cliente en el body de la respuesta.
+
+### `tracking` — request id por request
+
+```ts
+import { RequestContext } from '@miguelmorales13/nestkit/tracking';
+
+@Injectable()
+export class WidgetsService {
+  async create(data: CreateWidgetDto): Promise<Widget> {
+    this.logger.log(`Creating widget, request ${RequestContext.getRequestId()}`);
+    // ...
+  }
+}
+```
+
+Cualquier capa (servicio, repositorio, logger) puede leer `RequestContext.getRequestId()` sin que se
+lo pasen por parámetro — vive en un `AsyncLocalStorage` que `RequestIdMiddleware` inicializa al
+principio de cada request (`TrackingModule` lo registra globalmente). El middleware respeta el header
+`X-Request-Id` si el cliente ya lo mandó (útil para tracing distribuido entre servicios), o genera uno
+nuevo con `crypto.randomUUID()`.
+
+### `database/postgres` — Pool + aislamiento por tenant (RLS)
+
+```ts
+import { Module } from '@nestjs/common';
+import { PgModule, PG_POOL, withTenantScope } from '@miguelmorales13/nestkit/database/postgres';
+
+@Module({ imports: [PgModule] })
+export class AppModule {}
+```
+
+```ts
+// dentro de un repository o guard
+import { Inject, Injectable } from '@nestjs/common';
+import { PG_POOL, withTenantScope } from '@miguelmorales13/nestkit/database/postgres';
+import type { Pool } from 'pg';
+
+@Injectable()
+export class WidgetRepository {
+  constructor(@Inject(PG_POOL) private readonly pool: Pool) {}
+
+  async findAllForTenant(authUserId: string) {
+    return withTenantScope(this.pool, authUserId, (client) =>
+      client.query('SELECT * FROM widgets'), // RLS solo deja ver lo que auth.uid() puede ver
+    );
+  }
+}
+```
+
+`PgModule` lee `DATABASE_URL` del entorno y lanza un error explícito al arrancar si falta —
+falla rápido en vez de fallar silenciosamente en el primer query. `withTenantScope` es la pieza que
+hace que Row-Level-Security de Postgres vea el usuario correcto: abre una transacción, corre
+`SELECT set_config('request.jwt.claim.sub', authUserId, true)`, ejecuta tu función, y hace
+commit/rollback — **cualquier query que dependa de una policy RLS basada en `auth.uid()` debe pasar
+por aquí**, `pool.query()` directo no aplica el `set_config` y verá (o no verá) filas incorrectamente.
+
+### `database/supabase` — clientes anon y service-role
+
+```ts
+import { Module } from '@nestjs/common';
+import { SupabaseModule, SUPABASE_ANON_CLIENT, SUPABASE_SERVICE_ROLE_CLIENT } from '@miguelmorales13/nestkit/database/supabase';
+
+@Module({ imports: [SupabaseModule] })
+export class AppModule {}
+```
+
+```ts
+import { Inject, Injectable } from '@nestjs/common';
+import { SUPABASE_SERVICE_ROLE_CLIENT } from '@miguelmorales13/nestkit/database/supabase';
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+@Injectable()
+export class StorageService {
+  constructor(@Inject(SUPABASE_SERVICE_ROLE_CLIENT) private readonly supabase: SupabaseClient) {}
+  // service-role: bypasea RLS — úsalo solo server-side, nunca lo expongas al cliente
+}
+```
+
+Requiere `SUPABASE_URL`, `SUPABASE_ANON_KEY`, `SUPABASE_SERVICE_ROLE_KEY` en el entorno — igual que
+`PgModule`, falla explícito al arrancar si falta alguna. Usa el cliente `anon` cuando quieras que las
+policies RLS apliquen tal cual verían al usuario final; usa `service-role` solo para operaciones
+administrativas server-side (nunca en un contexto que un cliente externo pueda influenciar).
+
+### `database/mongo` — solo el contrato, todavía
+
+```ts
+import type { MongoRepositoryPort } from '@miguelmorales13/nestkit/database/mongo';
+```
+
+Es un alias del mismo `Repository<T>` de `crud` — no hay `MongoModule` ni una implementación
+concreta todavía porque ningún proyecto del portafolio usa Mongo hoy. El día que haga falta, se
+implementa un adaptador que satisfaga `Repository<T>` con Mongoose por debajo — el CRUD genérico y
+las entidades base no cambian, porque nunca dependieron de Postgres/Supabase directamente.
+
+### `crud` — Repository, servicio y controller genéricos
+
+```ts
+// widget.repository.ts
+import { Injectable, Inject } from '@nestjs/common';
+import type { Repository } from '@miguelmorales13/nestkit/crud';
+import { PG_POOL } from '@miguelmorales13/nestkit/database/postgres';
+import type { Pool } from 'pg';
+import type { Widget } from './widget.entity';
+
+@Injectable()
+export class WidgetRepository implements Repository<Widget> {
+  constructor(@Inject(PG_POOL) private readonly pool: Pool) {}
+
+  async findById(id: string): Promise<Widget | null> {
+    const { rows } = await this.pool.query('SELECT * FROM widgets WHERE id = $1', [id]);
+    return rows[0] ?? null;
+  }
+
+  async findAll(): Promise<Widget[]> {
+    const { rows } = await this.pool.query('SELECT * FROM widgets');
+    return rows;
+  }
+
+  async create(data: Omit<Widget, 'id' | 'createdAt' | 'updatedAt'>): Promise<Widget> {
+    const { rows } = await this.pool.query(
+      'INSERT INTO widgets (name) VALUES ($1) RETURNING *',
+      [data.name],
+    );
+    return rows[0];
+  }
+
+  async update(id: string, data: Partial<Widget>): Promise<Widget> {
+    const { rows } = await this.pool.query(
+      'UPDATE widgets SET name = COALESCE($2, name) WHERE id = $1 RETURNING *',
+      [id, data.name],
+    );
+    return rows[0];
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.pool.query('DELETE FROM widgets WHERE id = $1', [id]);
+  }
+}
+```
+
+```ts
+// widgets.module.ts
+import { Module } from '@nestjs/common';
+import { BaseCrudService, createCrudController } from '@miguelmorales13/nestkit/crud';
+import { WidgetRepository } from './widget.repository';
+
+const WIDGETS_SERVICE = 'WIDGETS_SERVICE';
+
+class WidgetsController extends createCrudController(WIDGETS_SERVICE as any, { path: 'widgets' }) {}
+
+@Module({
+  controllers: [WidgetsController],
+  providers: [
+    WidgetRepository,
+    { provide: WIDGETS_SERVICE, useFactory: (repo: WidgetRepository) => new BaseCrudService(repo), inject: [WidgetRepository] },
+  ],
+})
+export class WidgetsModule {}
+```
+
+> En la práctica, usa una subclase concreta de `BaseCrudService` como provider/token (en vez de un
+> string token) para que `createCrudController` infiera los tipos sin castear. `createCrudController`
+> es composición opcional: si prefieres tu propio controller, simplemente consume
+> `BaseCrudService`/`Repository<T>` directamente y no lo uses.
+
+**Borrado lógico**: pasa `deleteStrategy: 'soft'` al construir el servicio para una entidad
+`SoftDeleteEntity` — `delete()` hace un `update(id, { deletedAt: new Date() })` en vez de borrar la
+fila/documento:
+
+```ts
+new BaseCrudService(widgetRepository, { deleteStrategy: 'soft' })
+```
+
+Por defecto (`'hard'` o sin especificar) `delete()` llama a `repository.delete()` tal cual. Si usas
+`'soft'`, tu `Repository<T>` debe estar tipado sobre una entidad que extienda `SoftDeleteEntity` y tu
+`findAll`/`findById` deben filtrar `deletedAt IS NULL` por su cuenta — el servicio genérico no hace
+ese filtro automáticamente, solo decide cómo borra.
+
+**Multi-tenant**: por defecto `createCrudController` **no aísla por tenant** — llama al servicio sin
+`tenantId` (igual que si lo omitieras a mano), correcto para un recurso single-tenant. Si tu
+`Repository<T>`/tabla sí necesita aislar por tenant (ej. RLS de Postgres, o un filtro
+`WHERE company_id = ?` en cualquier otro motor), pasa `tenantIdExtractor` para que los 5 métodos
+generados lo saquen del request y se lo pasen al servicio automáticamente — normalmente lee un valor
+que un guard de auth ya dejó en el request (como `req.companyId` en el guard de `hr-pymes-saas`):
+
+```ts
+class WidgetsController extends createCrudController(WIDGETS_SERVICE as any, {
+  path: 'widgets',
+  tenantIdExtractor: (req) => (req as AuthenticatedRequest).companyId,
+}) {}
+```
+
+Sin esta opción, un `Repository<T>` que solo filtra correctamente cuando recibe `tenantId` **no
+queda protegido automáticamente** por el CRUD genérico — es responsabilidad de quien monta el
+controller pasarla si el recurso es multi-tenant.
+
+### `i18n` — mensajes en JSON
+
+```ts
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { I18nModule } from '@miguelmorales13/nestkit/i18n';
+
+@Module({
+  imports: [I18nModule.forRoot({ path: './i18n/', fallbackLanguage: 'es' })],
+})
+export class AppModule {}
+```
+
+```json
+// i18n/es/widgets.json
+{ "not_found": "No se encontró el widget {id}" }
+```
+
+```json
+// i18n/en/widgets.json
+{ "not_found": "Widget {id} not found" }
+```
+
+```ts
+import { I18nService } from 'nestjs-i18n';
+import { translateOr } from '@miguelmorales13/nestkit/i18n';
+import { NotFoundAppException } from '@miguelmorales13/nestkit/errors';
+
+throw new NotFoundAppException(
+  translateOr(this.i18n, 'widgets.not_found', `Widget ${id} not found`, { id }),
+);
+```
+
+El idioma se resuelve por el `Accept-Language` del request (comportamiento por defecto de
+`nestjs-i18n`, que `I18nModule.forRoot` no cambia). `translateOr` nunca lanza si la key no existe —
+regresa el `fallback`, así una traducción faltante no se convierte en un error 500 encima del error
+original.
+
+## Subpaths disponibles
+
+| Subpath | Qué trae |
+|---------|----------|
+| `@miguelmorales13/nestkit` | Reexporta todo lo demás |
+| `@miguelmorales13/nestkit/entities` | `BaseEntity`, `SoftDeleteEntity`, `BaseResponseDto` |
+| `@miguelmorales13/nestkit/response` | `ApiResponse`/`ApiSuccessResponse`/`ApiErrorResponse`, `ResponseInterceptor` |
+| `@miguelmorales13/nestkit/errors` | `AppException` y subclases comunes, `GlobalExceptionFilter` |
+| `@miguelmorales13/nestkit/tracking` | `RequestContext`, `RequestIdMiddleware`, `TrackingModule` |
+| `@miguelmorales13/nestkit/crud` | `Repository<T>`, `BaseCrudService`, `createCrudController` |
+| `@miguelmorales13/nestkit/database/postgres` | `PgModule`, `PG_POOL`, `withTenantScope` |
+| `@miguelmorales13/nestkit/database/supabase` | `SupabaseModule`, `SUPABASE_ANON_CLIENT`, `SUPABASE_SERVICE_ROLE_CLIENT` |
+| `@miguelmorales13/nestkit/database/mongo` | Solo el contrato `MongoRepositoryPort` — sin implementación |
+| `@miguelmorales13/nestkit/i18n` | `I18nModule` (wrapper de `nestjs-i18n`), `translateOr` |
+| `@miguelmorales13/nestkit/bootstrap` | `applyNestKitDefaults` |
+
+## Estado del paquete
+
+`0.1.0`, no publicado en npm todavía (repo privado, se prueba localmente con `bun link` antes de
+publicar). Sin adaptador Mongo real. Sin tests unitarios propios — es un paquete nuevo sin
+consumidor productivo todavía; la primera integración real (ej. en `hr-pymes-saas`) es la que va a
+ejercitar el código de verdad.

package/dist/bootstrap/apply-defaults.d.ts

@@ -0,0 +1,23 @@
+import { type INestApplication, type ValidationPipeOptions } from '@nestjs/common';
+import type { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+export interface SwaggerBootstrapOptions {
+    title: string;
+    path?: string;
+}
+export interface ApplyNestKitDefaultsOptions {
+    cors?: CorsOptions;
+    /** Pass `false` to skip mounting Swagger entirely. */
+    swagger?: SwaggerBootstrapOptions | false;
+    validation?: ValidationPipeOptions;
+}
+/**
+ * Applies nestkit's opinionated defaults to a Nest application, in order:
+ * helmet -> CORS -> global ValidationPipe -> GlobalExceptionFilter ->
+ * ResponseInterceptor -> (optionally) Swagger. Call once from `main.ts`
+ * before `app.listen()`.
+ *
+ * Requires `helmet` and, unless `swagger: false`, `@nestjs/swagger` to be
+ * installed — both are optional peer dependencies of the package overall,
+ * required only when importing this `bootstrap` subpath.
+ */
+export declare function applyNestKitDefaults(app: INestApplication, options?: ApplyNestKitDefaultsOptions): void;

package/dist/bootstrap/index.d.ts

@@ -0,0 +1,2 @@
+export { applyNestKitDefaults } from './apply-defaults.js';
+export type { ApplyNestKitDefaultsOptions, SwaggerBootstrapOptions } from './apply-defaults.js';

package/dist/bootstrap/index.js

@@ -0,0 +1,10 @@
+import {
+  applyNestKitDefaults
+} from "../chunk-KP7GRCZW.js";
+import "../chunk-KDAA6GFF.js";
+import "../chunk-EQXYK6AL.js";
+import "../chunk-EBO6UKHL.js";
+import "../chunk-4MGIQFAJ.js";
+export {
+  applyNestKitDefaults
+};

package/dist/chunk-4MGIQFAJ.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+export {
+  __decorateClass,
+  __decorateParam
+};

package/dist/chunk-EBO6UKHL.js

@@ -0,0 +1,20 @@
+// src/tracking/request-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var RequestContext = class {
+  static {
+    this.storage = new AsyncLocalStorage();
+  }
+  static run(store, fn) {
+    return this.storage.run(store, fn);
+  }
+  static getStore() {
+    return this.storage.getStore();
+  }
+  static getRequestId() {
+    return this.storage.getStore()?.requestId;
+  }
+};
+
+export {
+  RequestContext
+};

package/dist/chunk-EQXYK6AL.js

@@ -0,0 +1,81 @@
+import {
+  RequestContext
+} from "./chunk-EBO6UKHL.js";
+import {
+  __decorateClass
+} from "./chunk-4MGIQFAJ.js";
+
+// src/errors/app.exception.ts
+import { HttpException } from "@nestjs/common";
+var AppException = class extends HttpException {
+  constructor(code, message, status, details) {
+    super({ code, message, details }, status);
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/errors/global-exception.filter.ts
+import {
+  Catch,
+  HttpException as HttpException2,
+  HttpStatus,
+  Logger
+} from "@nestjs/common";
+var GlobalExceptionFilter = class {
+  constructor() {
+    this.logger = new Logger(GlobalExceptionFilter.name);
+  }
+  catch(exception, host) {
+    const response = host.switchToHttp().getResponse();
+    const resolved = this.resolve(exception);
+    if (resolved.status >= HttpStatus.INTERNAL_SERVER_ERROR) {
+      const stack = exception instanceof Error ? exception.stack : void 0;
+      this.logger.error(`Unhandled exception: ${resolved.message}`, stack);
+    }
+    const body = {
+      success: false,
+      requestId: RequestContext.getRequestId() ?? "unknown",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: {
+        code: resolved.code,
+        message: resolved.message,
+        details: resolved.details
+      }
+    };
+    response.status(resolved.status).send(body);
+  }
+  resolve(exception) {
+    if (exception instanceof AppException) {
+      return {
+        status: exception.getStatus(),
+        code: exception.code,
+        message: exception.message,
+        details: exception.details
+      };
+    }
+    if (exception instanceof HttpException2) {
+      const status = exception.getStatus();
+      const payload = exception.getResponse();
+      const rawMessage = typeof payload === "string" ? payload : payload.message ?? exception.message;
+      return {
+        status,
+        code: HttpStatus[status] ?? "HTTP_ERROR",
+        message: Array.isArray(rawMessage) ? rawMessage.join(", ") : rawMessage
+      };
+    }
+    return {
+      status: HttpStatus.INTERNAL_SERVER_ERROR,
+      code: "INTERNAL_ERROR",
+      message: "Internal server error"
+    };
+  }
+};
+GlobalExceptionFilter = __decorateClass([
+  Catch()
+], GlobalExceptionFilter);
+
+export {
+  AppException,
+  GlobalExceptionFilter
+};

package/dist/chunk-EYURGACO.js

@@ -0,0 +1,40 @@
+import {
+  RequestContext
+} from "./chunk-EBO6UKHL.js";
+import {
+  __decorateClass
+} from "./chunk-4MGIQFAJ.js";
+
+// src/tracking/request-id.middleware.ts
+import { randomUUID } from "crypto";
+import { Injectable } from "@nestjs/common";
+var REQUEST_ID_HEADER = "x-request-id";
+var RequestIdMiddleware = class {
+  use(req, res, next) {
+    const incoming = req.headers[REQUEST_ID_HEADER];
+    const requestId = (Array.isArray(incoming) ? incoming[0] : incoming) ?? randomUUID();
+    req.requestId = requestId;
+    res.setHeader(REQUEST_ID_HEADER, requestId);
+    RequestContext.run({ requestId }, () => next());
+  }
+};
+RequestIdMiddleware = __decorateClass([
+  Injectable()
+], RequestIdMiddleware);
+
+// src/tracking/tracking.module.ts
+import { Module } from "@nestjs/common";
+var TrackingModule = class {
+  configure(consumer) {
+    consumer.apply(RequestIdMiddleware).forRoutes("*");
+  }
+};
+TrackingModule = __decorateClass([
+  Module({})
+], TrackingModule);
+
+export {
+  REQUEST_ID_HEADER,
+  RequestIdMiddleware,
+  TrackingModule
+};

package/dist/chunk-HGJX2GPE.js

@@ -0,0 +1,39 @@
+import {
+  AppException
+} from "./chunk-EQXYK6AL.js";
+
+// src/errors/common.exceptions.ts
+import { HttpStatus } from "@nestjs/common";
+var NotFoundAppException = class extends AppException {
+  constructor(message = "Resource not found", details, code = "NOT_FOUND") {
+    super(code, message, HttpStatus.NOT_FOUND, details);
+  }
+};
+var ConflictAppException = class extends AppException {
+  constructor(message = "Conflict", details, code = "CONFLICT") {
+    super(code, message, HttpStatus.CONFLICT, details);
+  }
+};
+var ValidationAppException = class extends AppException {
+  constructor(message = "Validation failed", details, code = "VALIDATION_ERROR") {
+    super(code, message, HttpStatus.BAD_REQUEST, details);
+  }
+};
+var UnauthorizedAppException = class extends AppException {
+  constructor(message = "Unauthorized", details, code = "UNAUTHORIZED") {
+    super(code, message, HttpStatus.UNAUTHORIZED, details);
+  }
+};
+var ForbiddenAppException = class extends AppException {
+  constructor(message = "Forbidden", details, code = "FORBIDDEN") {
+    super(code, message, HttpStatus.FORBIDDEN, details);
+  }
+};
+
+export {
+  NotFoundAppException,
+  ConflictAppException,
+  ValidationAppException,
+  UnauthorizedAppException,
+  ForbiddenAppException
+};

package/dist/chunk-IYUUYCP5.js

@@ -0,0 +1,36 @@
+import {
+  __decorateClass
+} from "./chunk-4MGIQFAJ.js";
+
+// src/i18n/i18n.module.ts
+import { Module } from "@nestjs/common";
+import { I18nModule as BaseI18nModule, I18nJsonLoader } from "nestjs-i18n";
+var I18nModule = class {
+  static forRoot(options = {}) {
+    return BaseI18nModule.forRoot({
+      fallbackLanguage: options.fallbackLanguage ?? "es",
+      loaderOptions: {
+        path: options.path ?? "./i18n/",
+        watch: true
+      },
+      loader: I18nJsonLoader
+    });
+  }
+};
+I18nModule = __decorateClass([
+  Module({})
+], I18nModule);
+
+// src/i18n/translate.helper.ts
+function translateOr(i18n, key, fallback, args) {
+  try {
+    return i18n.t(key, { args, defaultValue: fallback });
+  } catch {
+    return fallback;
+  }
+}
+
+export {
+  I18nModule,
+  translateOr
+};