@russ-b/nestjs-common-tools 2.1.0 → 2.2.0

package/README.md

@@ -31,13 +31,105 @@ This package uses subpath exports for most features.
 | `@russ-b/nestjs-common-tools` | root exports such as `services` |
 | `@russ-b/nestjs-common-tools/class-transformer` | reusable `class-transformer` decorators and helpers |
 | `@russ-b/nestjs-common-tools/modules` | NestJS modules such as `S3Module` |
+| `@russ-b/nestjs-common-tools/modules/outbox` | PostgreSQL TypeORM outbox module |
 | `@russ-b/nestjs-common-tools/validators` | validation decorators and constraints |
 | `@russ-b/nestjs-common-tools/typeorm` | TypeORM filters, helpers, transformers, and types |
 | `@russ-b/nestjs-common-tools/logger` | logger builder and logger-related interfaces/types |
+| `@russ-b/nestjs-common-tools/logger/pino` | config-first `nestjs-pino` module options helper |
+| `@russ-b/nestjs-common-tools/errors` | API error response helpers and validation exception factories |
+| `@russ-b/nestjs-common-tools/zod` | Zod exception filters for NestJS HTTP apps |
 | `@russ-b/nestjs-common-tools/pagination` | pagination DTOs, response builders, and errors |
 | `@russ-b/nestjs-common-tools/common/util` | generic utility helpers |
 | `@russ-b/nestjs-common-tools/common/filters` | shared filter exports |
 
+## Pino logger
+
+Import Pino helpers from `@russ-b/nestjs-common-tools/logger/pino`.
+
+Install the required peer dependencies in applications that use this entrypoint:
+
+```bash
+npm install nestjs-pino pino pino-http
+```
+
+Install `pino-pretty` as well if you enable pretty logs:
+
+```bash
+npm install pino-pretty
+```
+
+`createPinoLoggerModuleOptions` does not read from `process.env`. Pass application config explicitly, for example from `ConfigService` or your own validated config object.
+
+```typescript
+import { LoggerModule } from 'nestjs-pino';
+import { createPinoLoggerModuleOptions } from '@russ-b/nestjs-common-tools/logger/pino';
+
+@Module({
+  imports: [
+    LoggerModule.forRoot(
+      createPinoLoggerModuleOptions({
+        appName: 'billing-api',
+        level: 'info',
+        pretty: false,
+        logHttpRequests: true,
+        version: '1.2.3',
+        environment: 'production',
+      }),
+    ),
+  ],
+})
+export class AppModule {}
+```
+
+## Error Responses
+
+Import error helpers from `@russ-b/nestjs-common-tools/errors`.
+
+Use `classValidatorExceptionFactory` with Nest's `ValidationPipe` to return the shared API error response shape for `class-validator` errors:
+
+```typescript
+import { ValidationPipe } from '@nestjs/common';
+import { classValidatorExceptionFactory } from '@russ-b/nestjs-common-tools/errors';
+
+app.useGlobalPipes(
+  new ValidationPipe({
+    exceptionFactory: classValidatorExceptionFactory,
+  }),
+);
+```
+
+The shared validation response uses `ApiErrorCode.VALIDATION_FAILED`; root-level errors use `'_root'` as the field name.
+
+## Zod Exception Filters
+
+Import Zod filters from `@russ-b/nestjs-common-tools/zod`.
+
+Install `zod` in applications that use this entrypoint:
+
+```bash
+npm install zod
+```
+
+Use the filter that matches your NestJS HTTP adapter:
+
+```typescript
+import { Module } from '@nestjs/common';
+import { APP_FILTER } from '@nestjs/core';
+import { ZodExpressExceptionFilter } from '@russ-b/nestjs-common-tools/zod';
+
+@Module({
+  providers: [
+    {
+      provide: APP_FILTER,
+      useFactory: () => new ZodExpressExceptionFilter(),
+    },
+  ],
+})
+export class AppModule {}
+```
+
+For Fastify apps, use `ZodFastifyExceptionFilter` instead. Both filters return a `400` response with a `Validation failed` message and mapped Zod issue details.
+
 ## Pagination
 
 Import pagination helpers from `@russ-b/nestjs-common-tools/pagination`.
@@ -470,6 +562,126 @@ export class CarPhotoService {
 }
 ```
 
+## Outbox Module
+
+Import outbox helpers from `@russ-b/nestjs-common-tools/modules/outbox`.
+
+`OutboxModule` is a PostgreSQL TypeORM implementation of the outbox pattern. It stores events in the database, lets workers claim pending events with `FOR UPDATE SKIP LOCKED`, tracks stale processing attempts, and retries failed handlers.
+
+### Register the module
+
+```typescript
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { OutboxModule } from '@russ-b/nestjs-common-tools/modules/outbox';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      // your TypeORM options
+    }),
+    OutboxModule.forRoot({
+      operationalPolicy: {
+        claimBatchSize: 100,
+        maxRetries: 5,
+        staleProcessingMinutes: 5,
+        maxConcurrentEvents: 10,
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+If your app has multiple TypeORM data sources, pass the registered data source name:
+
+```typescript
+OutboxModule.forRoot({
+  dataSource: 'primary',
+});
+```
+
+### Create events
+
+Create outbox events inside the same transaction as the domain change whenever possible.
+
+```typescript
+await dataSource.transaction(async (manager) => {
+  await manager.save(order);
+
+  await outboxService.createEvent(
+    'order.created',
+    { orderId: order.id },
+    manager,
+  );
+});
+```
+
+### Process events
+
+Extend `BaseWorker` and implement event selection plus handling.
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import {
+  BaseWorker,
+  OutboxEvent,
+  OutboxService,
+} from '@russ-b/nestjs-common-tools/modules/outbox';
+
+@Injectable()
+export class OrderCreatedWorker extends BaseWorker {
+  constructor(outboxService: OutboxService) {
+    super(outboxService);
+  }
+
+  getEvents(): Promise<OutboxEvent[]> {
+    return this.outboxService.claimPendingEvents('order.created');
+  }
+
+  async handle(event: OutboxEvent): Promise<void> {
+    // Send email, publish message, call another service, etc.
+  }
+}
+```
+
+Outbox delivery is at-least-once. Handlers must be idempotent, especially when they call external services or publish messages.
+
+### Cleanup processed events
+
+`OutboxCleanupWorker` deletes processed events older than the configured `processedEventRetentionHours`. The library does not schedule it by itself, so wire it to your app scheduler. If retention should come from environment or config, pass it through `OutboxModule.forRootAsync`.
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { Cron } from '@nestjs/schedule';
+import { OutboxCleanupWorker } from '@russ-b/nestjs-common-tools/modules/outbox';
+
+@Injectable()
+export class OutboxCleanupCron {
+  constructor(private readonly cleanupWorker: OutboxCleanupWorker) {}
+
+  @Cron('0 0 3 * * *')
+  cleanupProcessedEvents(): Promise<number> {
+    return this.cleanupWorker.cleanupProcessedEvents();
+  }
+}
+```
+
+### Operational policy
+
+`operationalPolicy` supports:
+
+| Option                         | Default   | Description                                                    |
+| ------------------------------ | --------- | -------------------------------------------------------------- |
+| `claimBatchSize`               | `100`     | Default number of events claimed per poll                      |
+| `maxRetries`                   | `5`       | Failed events become `failed` when this retry count is reached |
+| `staleProcessingMinutes`       | `5`       | Processing events older than this are reset to pending         |
+| `resetStaleProcessingEvents`   | `true`    | Enables stale processing reset in `BaseWorker`                 |
+| `maxConcurrentEvents`          | unlimited | Limits parallel handler execution inside one worker cycle      |
+| `processedEventRetentionHours` | `24`      | Default age used by `deleteProcessed()`                        |
+
+The outbox entity uses PostgreSQL-specific column types and requires a nullable `processing_started_at` column for stale processing detection.
+
 ## Entity Validator
 
 A custom validator for NestJS that validates if an entity exists in the database using TypeORM.
@@ -598,6 +810,32 @@ export class AppModule {}
 
 PostgreSQL support is also exposed directly as `createPostgresTypeormOptions`. Its `schema` option is applied both as TypeORM's schema and as `search_path`, and pool options are passed through the `pg` driver via TypeORM's `extra` config.
 
+For managed PostgreSQL providers that require SSL with a CA certificate, you can pass atomic connection fields and `sslCa`. This avoids `pg` overwriting the explicit `ssl` object when `sslmode` or `sslrootcert` exists in the connection string.
+
+```typescript
+TypeOrmModule.forRootAsync({
+  imports: [ConfigModule],
+  inject: [ConfigService],
+  useFactory: (config: ConfigService) =>
+    createTypeOrmOptions({
+      type: 'postgres',
+      database: {
+        host: config.getOrThrow<string>('DB_HOST'),
+        port: config.get<number>('DB_PORT'),
+        username: config.getOrThrow<string>('DB_USER'),
+        password: config.getOrThrow<string>('DB_PASSWORD'),
+        database: config.getOrThrow<string>('DB_NAME'),
+      },
+      sslCa: config.get<string>('DB_CA_CERT'),
+      sync: config.get<string>('TYPEORM_SYNC'),
+      logging: config.get<string>('TYPEORM_LOGGING'),
+      isProduction: config.get<string>('NODE_ENV') === 'production',
+    }),
+});
+```
+
+When `sslCa` is used together with `databaseUrl`, SSL-related query params such as `sslmode` and `sslrootcert` are removed from the URL before TypeORM passes the config to `pg`.
+
 For MySQL, use `type: 'mysql'` or call `createMysqlTypeormOptions` directly:
 
 ```typescript
@@ -650,6 +888,27 @@ export class AppModule {}
 
 By default, the filter already maps common TypeORM database errors such as unique constraint violations, foreign key violations, and invalid input format to NestJS HTTP exceptions. Custom constraint handlers let you keep those responses specific to your business rules.
 
+### Entity Not Found Filter
+
+TypeORM throws `EntityNotFoundError` when methods such as `findOneOrFail` cannot find a requested entity. `EntityNotFoundFilter` maps that error to NestJS `NotFoundException` for HTTP requests and rethrows the original error for non-HTTP contexts.
+
+```typescript
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { APP_FILTER } from '@nestjs/core';
+import { EntityNotFoundFilter } from '@russ-b/nestjs-common-tools/typeorm';
+
+@Module({
+  providers: [
+    {
+      provide: APP_FILTER,
+      useClass: EntityNotFoundFilter,
+    },
+  ],
+})
+export class AppModule {}
+```
+
 ## isTypeOrmQueryFailedError
 
 Sometimes a global filter is not enough and you want to react differently to one exact database error inside a service. `isTypeOrmQueryFailedError` is useful for that kind of targeted branching without scattering manual `instanceof QueryFailedError` checks and driver casts around the codebase.

package/dist/common/util/error.util.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessage(error: unknown): string;

package/dist/common/util/error.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMessage = getErrorMessage;
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+//# sourceMappingURL=error.util.js.map

package/dist/common/util/error.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.util.js","sourceRoot":"","sources":["../../../src/common/util/error.util.ts"],"names":[],"mappings":";;AAAA,0CAMC;AAND,SAAgB,eAAe,CAAC,KAAc;IAC5C,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC,OAAO,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC"}

package/dist/common/util/index.d.ts

@@ -1,3 +1,4 @@
 export * from './collection.util';
 export * from './sleep.util';
 export * from './mask-string.util';
+export * from './error.util';

package/dist/common/util/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./collection.util"), exports);
 __exportStar(require("./sleep.util"), exports);
 __exportStar(require("./mask-string.util"), exports);
+__exportStar(require("./error.util"), exports);
 //# sourceMappingURL=index.js.map

package/dist/common/util/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/util/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,+CAA6B;AAC7B,qDAAmC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/util/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,+CAA6B;AAC7B,qDAAmC;AACnC,+CAA6B"}

package/dist/errors/api-error-code.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum ApiErrorCode {
+    BAD_REQUEST = "BAD_REQUEST",
+    CONFLICT = "CONFLICT",
+    FORBIDDEN = "FORBIDDEN",
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR",
+    NOT_FOUND = "NOT_FOUND",
+    TOO_MANY_REQUESTS = "TOO_MANY_REQUESTS",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    UNPROCESSABLE_ENTITY = "UNPROCESSABLE_ENTITY",
+    VALIDATION_FAILED = "VALIDATION_FAILED"
+}

package/dist/errors/api-error-code.enum.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiErrorCode = void 0;
+var ApiErrorCode;
+(function (ApiErrorCode) {
+    ApiErrorCode["BAD_REQUEST"] = "BAD_REQUEST";
+    ApiErrorCode["CONFLICT"] = "CONFLICT";
+    ApiErrorCode["FORBIDDEN"] = "FORBIDDEN";
+    ApiErrorCode["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+    ApiErrorCode["NOT_FOUND"] = "NOT_FOUND";
+    ApiErrorCode["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
+    ApiErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    ApiErrorCode["UNPROCESSABLE_ENTITY"] = "UNPROCESSABLE_ENTITY";
+    ApiErrorCode["VALIDATION_FAILED"] = "VALIDATION_FAILED";
+})(ApiErrorCode || (exports.ApiErrorCode = ApiErrorCode = {}));
+//# sourceMappingURL=api-error-code.enum.js.map

package/dist/errors/api-error-code.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-error-code.enum.js","sourceRoot":"","sources":["../../src/errors/api-error-code.enum.ts"],"names":[],"mappings":";;;AAAA,IAAY,YAUX;AAVD,WAAY,YAAY;IACtB,2CAA2B,CAAA;IAC3B,qCAAqB,CAAA;IACrB,uCAAuB,CAAA;IACvB,+DAA+C,CAAA;IAC/C,uCAAuB,CAAA;IACvB,uDAAuC,CAAA;IACvC,6CAA6B,CAAA;IAC7B,6DAA6C,CAAA;IAC7C,uDAAuC,CAAA;AACzC,CAAC,EAVW,YAAY,4BAAZ,YAAY,QAUvB"}

package/dist/errors/api-error-response.type.d.ts

@@ -0,0 +1,11 @@
+export type ApiErrorItem = {
+    field: string;
+    message: string;
+};
+export type ApiErrorResponse = {
+    statusCode: number;
+    error: string;
+    message: string;
+    code: string;
+    errors?: ApiErrorItem[];
+};

package/dist/errors/api-error-response.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api-error-response.type.js.map

package/dist/errors/api-error-response.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-error-response.type.js","sourceRoot":"","sources":["../../src/errors/api-error-response.type.ts"],"names":[],"mappings":""}

package/dist/errors/api-error-root-field.constant.d.ts

@@ -0,0 +1 @@
+export declare const API_ERROR_ROOT_FIELD = "_root";

package/dist/errors/api-error-root-field.constant.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_ERROR_ROOT_FIELD = void 0;
+exports.API_ERROR_ROOT_FIELD = '_root';
+//# sourceMappingURL=api-error-root-field.constant.js.map

package/dist/errors/api-error-root-field.constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-error-root-field.constant.js","sourceRoot":"","sources":["../../src/errors/api-error-root-field.constant.ts"],"names":[],"mappings":";;;AAAa,QAAA,oBAAoB,GAAG,OAAO,CAAC"}

package/dist/errors/class-validator-exception.factory.d.ts

@@ -0,0 +1,6 @@
+import { BadRequestException } from '@nestjs/common';
+import type { ValidationError } from '@nestjs/common';
+export interface ClassValidatorExceptionFactoryOptions {
+    message?: string;
+}
+export declare function classValidatorExceptionFactory(errors: ValidationError[], options?: ClassValidatorExceptionFactoryOptions): BadRequestException;

package/dist/errors/class-validator-exception.factory.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classValidatorExceptionFactory = classValidatorExceptionFactory;
+const common_1 = require("@nestjs/common");
+const api_error_root_field_constant_1 = require("./api-error-root-field.constant");
+const api_error_code_enum_1 = require("./api-error-code.enum");
+const error_response_factory_1 = require("./error-response.factory");
+const DEFAULT_VALIDATION_ERROR_MESSAGE = 'Validation failed';
+function classValidatorExceptionFactory(errors, options = {}) {
+    return new common_1.BadRequestException((0, error_response_factory_1.createApiErrorResponse)({
+        statusCode: common_1.HttpStatus.BAD_REQUEST,
+        message: options.message ?? DEFAULT_VALIDATION_ERROR_MESSAGE,
+        code: api_error_code_enum_1.ApiErrorCode.VALIDATION_FAILED,
+        errors: flattenValidationErrors(errors),
+    }));
+}
+function flattenValidationErrors(errors, parentPath) {
+    const items = [];
+    for (const error of errors) {
+        const field = formatValidationErrorPath(error.property, parentPath);
+        if (error.constraints) {
+            for (const message of Object.values(error.constraints)) {
+                items.push({ field, message });
+            }
+        }
+        if (error.children?.length) {
+            items.push(...flattenValidationErrors(error.children, field));
+        }
+    }
+    return items;
+}
+function formatValidationErrorPath(property, parentPath) {
+    if (!property) {
+        return parentPath ?? api_error_root_field_constant_1.API_ERROR_ROOT_FIELD;
+    }
+    return parentPath ? `${parentPath}.${property}` : property;
+}
+//# sourceMappingURL=class-validator-exception.factory.js.map

package/dist/errors/class-validator-exception.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-validator-exception.factory.js","sourceRoot":"","sources":["../../src/errors/class-validator-exception.factory.ts"],"names":[],"mappings":";;AAaA,wEAYC;AAzBD,2CAAiE;AAEjE,mFAAuE;AACvE,+DAAqD;AAErD,qEAAkE;AAMlE,MAAM,gCAAgC,GAAG,mBAAmB,CAAC;AAE7D,SAAgB,8BAA8B,CAC5C,MAAyB,EACzB,UAAiD,EAAE;IAEnD,OAAO,IAAI,4BAAmB,CAC5B,IAAA,+CAAsB,EAAC;QACrB,UAAU,EAAE,mBAAU,CAAC,WAAW;QAClC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,gCAAgC;QAC5D,IAAI,EAAE,kCAAY,CAAC,iBAAiB;QACpC,MAAM,EAAE,uBAAuB,CAAC,MAAM,CAAC;KACxC,CAAC,CACH,CAAC;AACJ,CAAC;AAED,SAAS,uBAAuB,CAC9B,MAAyB,EACzB,UAAmB;IAEnB,MAAM,KAAK,GAAmB,EAAE,CAAC;IAEjC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,yBAAyB,CAAC,KAAK,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAEpE,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACtB,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC;gBACvD,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QAED,IAAI,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;YAC3B,KAAK,CAAC,IAAI,CAAC,GAAG,uBAAuB,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,yBAAyB,CAChC,QAA4B,EAC5B,UAAmB;IAEnB,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,UAAU,IAAI,oDAAoB,CAAC;IAC5C,CAAC;IAED,OAAO,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC7D,CAAC"}

package/dist/errors/error-response.factory.d.ts

@@ -0,0 +1,10 @@
+import { ApiErrorCode } from './api-error-code.enum';
+import type { ApiErrorItem, ApiErrorResponse } from './api-error-response.type';
+export type CreateApiErrorResponseParams = {
+    statusCode: number;
+    message?: string;
+    code?: ApiErrorCode | string;
+    error?: string;
+    errors?: ApiErrorItem[];
+};
+export declare function createApiErrorResponse(params: CreateApiErrorResponseParams): ApiErrorResponse;

package/dist/errors/error-response.factory.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiErrorResponse = createApiErrorResponse;
+const common_1 = require("@nestjs/common");
+const api_error_code_enum_1 = require("./api-error-code.enum");
+const HTTP_ERROR_LABELS = {
+    [common_1.HttpStatus.BAD_REQUEST]: 'Bad Request',
+    [common_1.HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+    [common_1.HttpStatus.FORBIDDEN]: 'Forbidden',
+    [common_1.HttpStatus.NOT_FOUND]: 'Not Found',
+    [common_1.HttpStatus.CONFLICT]: 'Conflict',
+    [common_1.HttpStatus.UNPROCESSABLE_ENTITY]: 'Unprocessable Entity',
+    [common_1.HttpStatus.TOO_MANY_REQUESTS]: 'Too Many Requests',
+    [common_1.HttpStatus.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+};
+const DEFAULT_ERROR_CODES = {
+    [common_1.HttpStatus.BAD_REQUEST]: api_error_code_enum_1.ApiErrorCode.BAD_REQUEST,
+    [common_1.HttpStatus.UNAUTHORIZED]: api_error_code_enum_1.ApiErrorCode.UNAUTHORIZED,
+    [common_1.HttpStatus.FORBIDDEN]: api_error_code_enum_1.ApiErrorCode.FORBIDDEN,
+    [common_1.HttpStatus.NOT_FOUND]: api_error_code_enum_1.ApiErrorCode.NOT_FOUND,
+    [common_1.HttpStatus.CONFLICT]: api_error_code_enum_1.ApiErrorCode.CONFLICT,
+    [common_1.HttpStatus.UNPROCESSABLE_ENTITY]: api_error_code_enum_1.ApiErrorCode.UNPROCESSABLE_ENTITY,
+    [common_1.HttpStatus.TOO_MANY_REQUESTS]: api_error_code_enum_1.ApiErrorCode.TOO_MANY_REQUESTS,
+    [common_1.HttpStatus.INTERNAL_SERVER_ERROR]: api_error_code_enum_1.ApiErrorCode.INTERNAL_SERVER_ERROR,
+};
+function createApiErrorResponse(params) {
+    const error = params.error ?? HTTP_ERROR_LABELS[params.statusCode] ?? 'Error';
+    const message = params.message ?? error;
+    const code = params.code ?? DEFAULT_ERROR_CODES[params.statusCode] ?? 'ERROR';
+    if (!params.errors?.length) {
+        return {
+            statusCode: params.statusCode,
+            error,
+            message,
+            code,
+        };
+    }
+    return {
+        statusCode: params.statusCode,
+        error,
+        message,
+        code,
+        errors: params.errors,
+    };
+}
+//# sourceMappingURL=error-response.factory.js.map

package/dist/errors/error-response.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-response.factory.js","sourceRoot":"","sources":["../../src/errors/error-response.factory.ts"],"names":[],"mappings":";;AAkCA,wDAuBC;AAzDD,2CAA4C;AAC5C,+DAAqD;AAGrD,MAAM,iBAAiB,GAA2B;IAChD,CAAC,mBAAU,CAAC,WAAW,CAAC,EAAE,aAAa;IACvC,CAAC,mBAAU,CAAC,YAAY,CAAC,EAAE,cAAc;IACzC,CAAC,mBAAU,CAAC,SAAS,CAAC,EAAE,WAAW;IACnC,CAAC,mBAAU,CAAC,SAAS,CAAC,EAAE,WAAW;IACnC,CAAC,mBAAU,CAAC,QAAQ,CAAC,EAAE,UAAU;IACjC,CAAC,mBAAU,CAAC,oBAAoB,CAAC,EAAE,sBAAsB;IACzD,CAAC,mBAAU,CAAC,iBAAiB,CAAC,EAAE,mBAAmB;IACnD,CAAC,mBAAU,CAAC,qBAAqB,CAAC,EAAE,uBAAuB;CAC5D,CAAC;AAEF,MAAM,mBAAmB,GAAiC;IACxD,CAAC,mBAAU,CAAC,WAAW,CAAC,EAAE,kCAAY,CAAC,WAAW;IAClD,CAAC,mBAAU,CAAC,YAAY,CAAC,EAAE,kCAAY,CAAC,YAAY;IACpD,CAAC,mBAAU,CAAC,SAAS,CAAC,EAAE,kCAAY,CAAC,SAAS;IAC9C,CAAC,mBAAU,CAAC,SAAS,CAAC,EAAE,kCAAY,CAAC,SAAS;IAC9C,CAAC,mBAAU,CAAC,QAAQ,CAAC,EAAE,kCAAY,CAAC,QAAQ;IAC5C,CAAC,mBAAU,CAAC,oBAAoB,CAAC,EAAE,kCAAY,CAAC,oBAAoB;IACpE,CAAC,mBAAU,CAAC,iBAAiB,CAAC,EAAE,kCAAY,CAAC,iBAAiB;IAC9D,CAAC,mBAAU,CAAC,qBAAqB,CAAC,EAAE,kCAAY,CAAC,qBAAqB;CACvE,CAAC;AAUF,SAAgB,sBAAsB,CACpC,MAAoC;IAEpC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,iBAAiB,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC;IAC9E,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC;IACxC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,mBAAmB,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC;IAE9E,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAC3B,OAAO;YACL,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,KAAK;YACL,OAAO;YACP,IAAI;SACL,CAAC;IACJ,CAAC;IAED,OAAO;QACL,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,KAAK;QACL,OAAO;QACP,IAAI;QACJ,MAAM,EAAE,MAAM,CAAC,MAAM;KACtB,CAAC;AACJ,CAAC"}

package/dist/errors/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api-error-code.enum';
+export * from './api-error-response.type';
+export * from './api-error-root-field.constant';
+export * from './class-validator-exception.factory';
+export * from './error-response.factory';

package/dist/errors/index.js

@@ -0,0 +1,22 @@
+"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("./api-error-code.enum"), exports);
+__exportStar(require("./api-error-response.type"), exports);
+__exportStar(require("./api-error-root-field.constant"), exports);
+__exportStar(require("./class-validator-exception.factory"), exports);
+__exportStar(require("./error-response.factory"), exports);
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC;AACtC,4DAA0C;AAC1C,kEAAgD;AAChD,sEAAoD;AACpD,2DAAyC"}

package/dist/logger/pino/index.d.ts

@@ -0,0 +1 @@
+export * from '../pino-logger';

package/dist/{common/filters → logger/pino}/index.js

@@ -14,5 +14,5 @@ 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/filters"), exports);
+__exportStar(require("../pino-logger"), exports);
 //# sourceMappingURL=index.js.map

package/dist/logger/pino/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/logger/pino/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B"}

package/dist/logger/pino-logger.d.ts

@@ -0,0 +1,13 @@
+import { type Params } from 'nestjs-pino';
+export type PinoLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'silent';
+export interface PinoLoggerConfig {
+    appName: string;
+    level?: PinoLogLevel;
+    pretty?: boolean;
+    logHttpRequests?: boolean;
+    version?: string;
+    environment?: string;
+    redactPaths?: string[];
+    base?: Record<string, unknown>;
+}
+export declare function createPinoLoggerModuleOptions(config: PinoLoggerConfig): Params;

package/dist/logger/pino-logger.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPinoLoggerModuleOptions = createPinoLoggerModuleOptions;
+const node_os_1 = require("node:os");
+const nestjs_pino_1 = require("nestjs-pino");
+const pino_1 = __importDefault(require("pino"));
+const DEFAULT_REDACT_PATHS = [
+    'req.headers.authorization',
+    'req.headers.cookie',
+    'res.headers["set-cookie"]',
+];
+function createPinoLoggerModuleOptions(config) {
+    const pinoHttp = {
+        ...nestjs_pino_1.nativeLoggerOptions,
+        level: config.level ?? 'debug',
+        base: {
+            pid: process.pid,
+            hostname: (0, node_os_1.hostname)(),
+            app: config.appName,
+            version: config.version ?? 'unknown',
+            env: config.environment ?? 'development',
+            ...config.base,
+        },
+        redact: {
+            paths: config.redactPaths ?? DEFAULT_REDACT_PATHS,
+            censor: '[REDACTED]',
+        },
+        autoLogging: config.logHttpRequests ?? false,
+    };
+    if (config.pretty) {
+        delete pinoHttp.formatters;
+        return {
+            pinoHttp: {
+                ...pinoHttp,
+                transport: {
+                    target: 'pino-pretty',
+                    options: {
+                        colorize: true,
+                        ignore: 'pid,hostname,app,version,env',
+                        messageFormat: '[{context}] {message}',
+                        messageKey: 'message',
+                        singleLine: true,
+                        timestampKey: 'timestamp',
+                        translateTime: 'SYS:HH:MM:ss.l',
+                    },
+                },
+            },
+        };
+    }
+    return {
+        pinoHttp: {
+            ...pinoHttp,
+            stream: pino_1.default.destination({
+                sync: false,
+            }),
+        },
+    };
+}
+//# sourceMappingURL=pino-logger.js.map

package/dist/logger/pino-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino-logger.js","sourceRoot":"","sources":["../../src/logger/pino-logger.ts"],"names":[],"mappings":";;;;;AA8BA,sEAmDC;AAjFD,qCAAmC;AACnC,6CAA+D;AAC/D,gDAAwB;AAsBxB,MAAM,oBAAoB,GAAG;IAC3B,2BAA2B;IAC3B,oBAAoB;IACpB,2BAA2B;CAC5B,CAAC;AAEF,SAAgB,6BAA6B,CAC3C,MAAwB;IAExB,MAAM,QAAQ,GAAG;QACf,GAAG,iCAAmB;QACtB,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,OAAO;QAC9B,IAAI,EAAE;YACJ,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,QAAQ,EAAE,IAAA,kBAAQ,GAAE;YACpB,GAAG,EAAE,MAAM,CAAC,OAAO;YACnB,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,SAAS;YACpC,GAAG,EAAE,MAAM,CAAC,WAAW,IAAI,aAAa;YACxC,GAAG,MAAM,CAAC,IAAI;SACf;QACD,MAAM,EAAE;YACN,KAAK,EAAE,MAAM,CAAC,WAAW,IAAI,oBAAoB;YACjD,MAAM,EAAE,YAAY;SACrB;QACD,WAAW,EAAE,MAAM,CAAC,eAAe,IAAI,KAAK;KAC7C,CAAC;IAEF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,OAAO,QAAQ,CAAC,UAAU,CAAC;QAE3B,OAAO;YACL,QAAQ,EAAE;gBACR,GAAG,QAAQ;gBACX,SAAS,EAAE;oBACT,MAAM,EAAE,aAAa;oBACrB,OAAO,EAAE;wBACP,QAAQ,EAAE,IAAI;wBACd,MAAM,EAAE,8BAA8B;wBACtC,aAAa,EAAE,uBAAuB;wBACtC,UAAU,EAAE,SAAS;wBACrB,UAAU,EAAE,IAAI;wBAChB,YAAY,EAAE,WAAW;wBACzB,aAAa,EAAE,gBAAgB;qBAChC;iBACF;aACF;SACF,CAAC;IACJ,CAAC;IAED,OAAO;QACL,QAAQ,EAAE;YACR,GAAG,QAAQ;YACX,MAAM,EAAE,cAAI,CAAC,WAAW,CAAC;gBACvB,IAAI,EAAE,KAAK;aACZ,CAAC;SACH;KACF,CAAC;AACJ,CAAC"}

package/dist/modules/index.d.ts

@@ -1 +1,2 @@
 export * from './s3';
+export * from './outbox';

package/dist/modules/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./s3"), exports);
+__exportStar(require("./outbox"), exports);
 //# sourceMappingURL=index.js.map