@sapphire-caitlyn/schema-kit-nest 0.0.0-stage → 0.0.2

package/README.md

@@ -1,3 +1,146 @@
-# Temporary Holding Version
+# schema-kit-nest (`@sapphire-caitlyn/schema-kit-nest`)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Base NestJS do schema-kit: o par `SchemaService` + `SchemaController` monta o CRUD que o `<schema-table>` e o
+`<schema-view>` do `@sapphire-caitlyn/schema-kit-ng` consomem. Traz também decorators, validators, entidades base,
+Pub/Sub, Storage, Redis e o módulo de monitoramento.
+
+## Instalação
+
+```bash
+npm i @sapphire-caitlyn/schema-kit-nest
+npm i @nestjs/common @nestjs/config @nestjs/platform-express @nestjs/typeorm typeorm zod luxon class-transformer \
+  handlebars ioredis @google-cloud/pubsub @google-cloud/storage reflect-metadata rxjs
+npm i -D @types/express @types/luxon
+```
+
+O pacote é CommonJS e não tem `exports`: além do barrel, imports profundos funcionam
+(`@sapphire-caitlyn/schema-kit-nest/schema/schema-builder`).
+
+## Uso
+
+### Módulo
+
+Importe o `SchemaKitModule` uma vez (é `@Global()`). Ele provê o `ContextLogger`, o `PubSub` e o `StorageService`,
+que o `SchemaService` injeta por propriedade. Precisa do `ConfigModule` global.
+
+```ts
+@Module({
+  imports: [ConfigModule.forRoot({ isGlobal: true }), SchemaKitModule, ProdutoModule],
+})
+export class AppModule {}
+```
+
+### Entidade e DTOs
+
+```ts
+@Entity()
+export class Produto extends AbstractEntity { // uuid v7 + createdAt/updatedAt/deletedAt
+  @Column() nome: string;
+  @Column({ type: 'uuid', nullable: true }) uuidCategoria: string | null;
+}
+
+export const modelSchemaProduto = z.object({
+  uuid: z.uuidv7(),
+  nome: z.string().min(1, 'Nome é obrigatório'),
+  uuidCategoria: z.uuidv7().nullable().optional(),
+});
+
+// Campos aceitos na listagem (filtro e ordenação)
+export const indexSchemaProduto: IIndexSchema = {
+  uuid: { type: FieldType.UUID },
+  nome: { type: FieldType.String },
+  uuidCategoria: { type: FieldType.UUID },
+};
+
+export const { createValidator, patchValidator, indexValidator } = SchemaBuilder.build({
+  modelSchema: modelSchemaProduto,
+  indexSchema: indexSchemaProduto,
+});
+export type CreateProdutoDto = z.infer<typeof createValidator>;
+export type PatchProdutoDto = z.infer<typeof patchValidator>;
+export type IndexProdutoDto = z.infer<typeof indexValidator>;
+```
+
+Sem soft delete, use `TimestampedEntity`, ou componha com `UuidEntity`, `Timestamped(...)` e `SoftDeletable(...)`.
+
+### Service e controller
+
+```ts
+@Injectable()
+export class ProdutoService extends SchemaService<Produto, CreateProdutoDto, PatchProdutoDto, IndexProdutoDto> {
+  constructor(@InjectRepository(Produto) repository: Repository<Produto>) {
+    super(repository, indexSchemaProduto);
+  }
+}
+
+@Controller('produto')
+export class ProdutoController extends SchemaController<Produto, CreateProdutoDto, PatchProdutoDto, IndexProdutoDto>({
+  createSchema: createValidator,
+  patchSchema: patchValidator,
+  indexParamsSchema: indexValidator,
+  // routes: ['index', 'find'],  // opcional: só essas rotas base
+}) {
+  constructor(service: ProdutoService) {
+    super(service);
+  }
+}
+```
+
+Rotas base (o contrato que a schema-kit-ng usa):
+
+| Rota                         | Uso                                                                  |
+| ---------------------------- | -------------------------------------------------------------------- |
+| `GET/POST /produto/index`    | Listagem paginada `{ data, total, page, size }` (params em query ou body) |
+| `GET /produto/:uuid`         | Registro para edição                                                 |
+| `POST /produto`              | Cria (aceita `multipart/form-data` com arquivos)                     |
+| `PATCH /produto/:uuid`       | Salva só os campos enviados                                          |
+| `DELETE /produto/:uuid`      | Exclui                                                               |
+
+Pontos de extensão:
+
+- **Controller:** `beforeRoute(route, args)` roda antes de cada rota base (lance exceção para bloquear, ex.: permissão).
+  `afterRoute(route, result)` pode transformar o resultado.
+- **Service:** `beforeIndex(qb, params)` e `applyFilters(qb, params)`, para filtros que não são igualdade simples.
+
+### Módulos opcionais
+
+- **`RedisModule`** (`@Global()`): provê o cliente `ioredis` em `REDIS_CLIENT`. Lê `DB_REDIS_HOST`, `DB_REDIS_PORT`,
+  `DB_REDIS_USERNAME` e `DB_REDIS_PASSWORD` do `ConfigService`.
+- **`MonitoramentoModule.forRoot(...)` / `forRootAsync(...)`:** abre uma conexão TypeORM nomeada
+  (`MONITORAMENTO_CONNECTION`), separada do DataSource default, para os logs de requisição HTTP e de mensagens Pub/Sub.
+  As migrations não rodam sozinhas. Aponte o DataSource de CLI para os arquivos do pacote:
+
+  ```ts
+  migrations: ['node_modules/@sapphire-caitlyn/schema-kit-nest/monitoramento/migrations/*.js'],
+  migrationsTableName: MONITORAMENTO_MIGRATIONS_TABLE,
+  entities: MONITORAMENTO_ENTITIES,
+  namingStrategy: new SnakeCaseNamingStrategy(),
+  ```
+
+## Atenção
+
+- **Instale todos os peers**, mesmo sem usar Redis, Pub/Sub ou Storage: o barrel importa esses módulos, então o
+  `import` do pacote falha sem `ioredis` e `@google-cloud/*`. O `handlebars` só é carregado pelos componentes de
+  `html/components` (import profundo).
+- **O `SchemaKitModule` exige `GOOGLE_CLOUD_STORAGE_BUCKET`** (`getOrThrow` na subida). As credenciais do Google vêm de
+  `GOOGLE_APPLICATION_CREDENTIALS`.
+- **Importar o pacote altera o `Repository` do TypeORM** (`repository.use(manager)`, para usar o repositório dentro de
+  uma transação). Por isso o `typeorm` é peer: com duas cópias, o patch cai na cópia errada.
+- **O default do `uuid` é `uuidv7()` do Postgres**, que só existe a partir do PostgreSQL 18.
+
+## Build e publicação
+
+No `api-backoffice` a lib não é usada pelo pacote: a API importa o código-fonte pelo alias do `tsconfig.json`
+(`@sapphire-caitlyn/schema-kit-nest` → `libs/nest/src`). Na raiz do `api-backoffice`:
+
+```bash
+npm run build:lib                  # tsc → dist/libs/nest + package.json e README
+npm run publish:lib -- --dry-run   # empacota sem publicar
+npm run publish:lib                # build:lib + npm publish ./dist/libs/nest
+```
+
+- Antes de publicar, suba a `version` em `libs/nest/package.json`: o registry recusa uma versão já publicada.
+- **Dentro da lib, use só imports relativos.** O `tsc` não reescreve `paths`: um import pelo alias compila aqui, mas
+  publica um `require` que não resolve em quem instala.
+- Pacote externo novo: em `peerDependencies` quando a app precisa de uma cópia única (Nest, TypeORM, zod, luxon...),
+  em `dependencies` para utilitários sem estado (`juice`).

package/config/naming-strategy.d.ts

@@ -0,0 +1,6 @@
+import { DefaultNamingStrategy } from 'typeorm';
+export declare class SnakeCaseNamingStrategy extends DefaultNamingStrategy {
+    tableName(className: string, customName: string): string;
+    columnName(propertyName: string, customName: string, embeddedPrefixes: string[]): string;
+    joinColumnName(relationName: string, referencedColumnName: string): string;
+}

package/config/naming-strategy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnakeCaseNamingStrategy = void 0;
+const typeorm_1 = require("typeorm");
+const StringUtils_1 = require("typeorm/util/StringUtils");
+class SnakeCaseNamingStrategy extends typeorm_1.DefaultNamingStrategy {
+    tableName(className, customName) {
+        return customName || (0, StringUtils_1.snakeCase)(className);
+    }
+    columnName(propertyName, customName, embeddedPrefixes) {
+        return ((0, StringUtils_1.snakeCase)(embeddedPrefixes.concat('').join('_')) +
+            (customName || (0, StringUtils_1.snakeCase)(propertyName)));
+    }
+    joinColumnName(relationName, referencedColumnName) {
+        return (0, StringUtils_1.snakeCase)(`${referencedColumnName}_${relationName}`);
+    }
+}
+exports.SnakeCaseNamingStrategy = SnakeCaseNamingStrategy;

package/config/redis.constants.d.ts

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

package/config/redis.constants.js

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

package/context-logger.service.d.ts

@@ -0,0 +1,4 @@
+import { ConsoleLogger } from '@nestjs/common';
+export declare class ContextLogger extends ConsoleLogger {
+    constructor();
+}

package/context-logger.service.js

@@ -0,0 +1,23 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextLogger = void 0;
+const common_1 = require("@nestjs/common");
+let ContextLogger = class ContextLogger extends common_1.ConsoleLogger {
+    constructor() {
+        super();
+    }
+};
+exports.ContextLogger = ContextLogger;
+exports.ContextLogger = ContextLogger = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.TRANSIENT }),
+    __metadata("design:paramtypes", [])
+], ContextLogger);

package/decorators/date-range.d.ts

@@ -0,0 +1,4 @@
+import { ColumnOptions } from 'typeorm';
+export type { Span } from '../transformers/date-range.transformer';
+export declare const DateRangeColumn: (o?: ColumnOptions) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare const DateTimeRangeColumn: (o?: ColumnOptions) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/decorators/date-range.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeRangeColumn = exports.DateRangeColumn = void 0;
+const common_1 = require("@nestjs/common");
+const class_transformer_1 = require("class-transformer");
+const typeorm_1 = require("typeorm");
+const date_range_transformer_1 = require("../transformers/date-range.transformer");
+const toIso = (0, class_transformer_1.Transform)(({ value }) => value?.map((p) => p?.toISO() ?? p) ?? value, { toPlainOnly: true });
+const toIsoDate = (0, class_transformer_1.Transform)(({ value }) => value?.map((p) => p?.toISODate() ?? p) ?? value, { toPlainOnly: true });
+const DateRangeColumn = (o = {}) => (0, common_1.applyDecorators)((0, typeorm_1.Column)({ type: 'daterange', ...o, transformer: date_range_transformer_1.dateRangeTransformer }), toIsoDate);
+exports.DateRangeColumn = DateRangeColumn;
+const DateTimeRangeColumn = (o = {}) => (0, common_1.applyDecorators)((0, typeorm_1.Column)({ type: 'tstzrange', ...o, transformer: date_range_transformer_1.dateTimeRangeTransformer }), toIso);
+exports.DateTimeRangeColumn = DateTimeRangeColumn;

package/decorators/file-column.d.ts

@@ -0,0 +1,17 @@
+import { ColumnOptions } from 'typeorm';
+/**
+ * Coluna com o caminho de um arquivo no Cloud Storage (`text`, ou `text[]` com `multiple`).
+ * O `SchemaService` envia os `File` recebidos para o bucket e devolve URLs assinadas no lugar dos caminhos.
+ */
+export declare const FileColumn: ({ multiple, ...o }?: ColumnOptions & {
+    multiple?: boolean;
+}) => PropertyDecorator;
+/** Propriedades da entidade decoradas com `@FileColumn()` */
+export declare function getFileColumns(target: unknown): string[];
+/**
+ * Entidade como o DTO a recebe: colunas de texto aceitam também `File`, que o `SchemaService` troca pelo caminho no bucket.
+ * O tipo não distingue as colunas `@FileColumn()`, então vale para qualquer coluna de texto.
+ */
+export type WithFileInput<T> = {
+    [K in keyof T]: T[K] extends string | string[] | null ? T[K] | File | File[] : T[K];
+};

package/decorators/file-column.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileColumn = void 0;
+exports.getFileColumns = getFileColumns;
+const typeorm_1 = require("typeorm");
+const FILE_COLUMNS = Symbol('FILE_COLUMNS');
+/**
+ * Coluna com o caminho de um arquivo no Cloud Storage (`text`, ou `text[]` com `multiple`).
+ * O `SchemaService` envia os `File` recebidos para o bucket e devolve URLs assinadas no lugar dos caminhos.
+ */
+const FileColumn = ({ multiple = false, ...o } = {}) => (target, key) => {
+    (0, typeorm_1.Column)({ type: 'text', nullable: true, array: multiple, ...o })(target, key);
+    const columns = Reflect.getMetadata(FILE_COLUMNS, target.constructor) ?? [];
+    Reflect.defineMetadata(FILE_COLUMNS, [...columns, String(key)], target.constructor);
+};
+exports.FileColumn = FileColumn;
+/** Propriedades da entidade decoradas com `@FileColumn()` */
+function getFileColumns(target) {
+    return typeof target === 'function' ? (Reflect.getMetadata(FILE_COLUMNS, target) ?? []) : [];
+}

package/decorators/luxon.d.ts

@@ -0,0 +1,6 @@
+import { ColumnOptions } from 'typeorm';
+export declare const DateTimeColumn: (o?: ColumnOptions) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare const CreateDateTimeColumn: (o?: ColumnOptions) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare const UpdateDateTimeColumn: (o?: ColumnOptions) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare const DeleteDateTimeColumn: (o?: ColumnOptions) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare const DateOnlyColumn: (o?: ColumnOptions) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/decorators/luxon.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateOnlyColumn = exports.DeleteDateTimeColumn = exports.UpdateDateTimeColumn = exports.CreateDateTimeColumn = exports.DateTimeColumn = void 0;
+const common_1 = require("@nestjs/common");
+const class_transformer_1 = require("class-transformer");
+const typeorm_1 = require("typeorm");
+const luxon_transformer_1 = require("../transformers/luxon.transformer");
+const toIso = (0, class_transformer_1.Transform)(({ value }) => value?.toISO() ?? value, { toPlainOnly: true });
+const toIsoDate = (0, class_transformer_1.Transform)(({ value }) => value?.toISODate() ?? value, { toPlainOnly: true });
+const dt = (o) => ({ type: 'timestamptz', ...o, transformer: luxon_transformer_1.dateTimeTransformer });
+const DateTimeColumn = (o = {}) => (0, common_1.applyDecorators)((0, typeorm_1.Column)(dt(o)), toIso);
+exports.DateTimeColumn = DateTimeColumn;
+const CreateDateTimeColumn = (o = {}) => (0, common_1.applyDecorators)((0, typeorm_1.CreateDateColumn)(dt(o)), toIso);
+exports.CreateDateTimeColumn = CreateDateTimeColumn;
+const UpdateDateTimeColumn = (o = {}) => (0, common_1.applyDecorators)((0, typeorm_1.UpdateDateColumn)(dt(o)), toIso);
+exports.UpdateDateTimeColumn = UpdateDateTimeColumn;
+const DeleteDateTimeColumn = (o = {}) => (0, common_1.applyDecorators)((0, typeorm_1.DeleteDateColumn)(dt(o)), toIso);
+exports.DeleteDateTimeColumn = DeleteDateTimeColumn;
+const DateOnlyColumn = (o = {}) => (0, common_1.applyDecorators)((0, typeorm_1.Column)({ type: 'date', ...o, transformer: luxon_transformer_1.dateOnlyTransformer }), toIsoDate);
+exports.DateOnlyColumn = DateOnlyColumn;

package/decorators/multipart.decorator.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Aceita `multipart/form-data` na rota, além de JSON. Os arquivos ficam em memória até o handler.
+ */
+export declare function Multipart(): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/decorators/multipart.decorator.js

@@ -0,0 +1,51 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Multipart = Multipart;
+const common_1 = require("@nestjs/common");
+const platform_express_1 = require("@nestjs/platform-express");
+const zod_extensions_1 = require("../schema/zod-extensions");
+const MAX_FILE_SIZE = 20 * 1024 * 1024;
+/**
+ * Reconstrói o body de uma requisição multipart no mesmo formato de um body JSON:
+ * cada campo de texto é o JSON do valor e cada arquivo vira um `File` (o que `z.file()` valida).
+ * Arquivos enviados como `campo[]` formam um array em `campo`.
+ */
+let MultipartBodyInterceptor = class MultipartBodyInterceptor {
+    intercept(context, next) {
+        const req = context.switchToHttp().getRequest();
+        if (!Array.isArray(req.files)) {
+            return next.handle();
+        }
+        const body = {};
+        for (const [key, value] of Object.entries(req.body ?? {})) {
+            body[key] = (0, zod_extensions_1.fromJson)(value);
+        }
+        for (const { fieldname, originalname, mimetype, buffer } of req.files) {
+            const file = new File([new Uint8Array(buffer)], originalname, { type: mimetype });
+            if (fieldname.endsWith('[]')) {
+                const key = fieldname.slice(0, -2);
+                body[key] = [...(Array.isArray(body[key]) ? body[key] : []), file];
+            }
+            else {
+                body[fieldname] = file;
+            }
+        }
+        req.body = body;
+        return next.handle();
+    }
+};
+MultipartBodyInterceptor = __decorate([
+    (0, common_1.Injectable)()
+], MultipartBodyInterceptor);
+/**
+ * Aceita `multipart/form-data` na rota, além de JSON. Os arquivos ficam em memória até o handler.
+ */
+function Multipart() {
+    return (0, common_1.applyDecorators)((0, common_1.UseInterceptors)((0, platform_express_1.AnyFilesInterceptor)({ limits: { fileSize: MAX_FILE_SIZE } }), MultipartBodyInterceptor));
+}

package/decorators/post-get.decorator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Registers a route that answers to both GET and POST.
+ * Any other HTTP method on the same path is rejected with 405 Method Not Allowed.
+ *
+ * Stacking `@Get()` and `@Post()` doesn't work, since each overwrites the other's route metadata,
+ * so the route is registered with `@All()` and the method is filtered by a guard.
+ *
+ * @param endpoint - Route path(s), same as `@Get()` / `@Post()`.
+ */
+export declare function PostGet(endpoint?: string | string[]): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/decorators/post-get.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGet = PostGet;
+const common_1 = require("@nestjs/common");
+const ALLOWED_METHODS = ['GET', 'POST'];
+class PostGetGuard {
+    canActivate(context) {
+        const { method } = context.switchToHttp().getRequest();
+        if (!ALLOWED_METHODS.includes(method?.toUpperCase()))
+            throw new common_1.MethodNotAllowedException();
+        return true;
+    }
+}
+/**
+ * Registers a route that answers to both GET and POST.
+ * Any other HTTP method on the same path is rejected with 405 Method Not Allowed.
+ *
+ * Stacking `@Get()` and `@Post()` doesn't work, since each overwrites the other's route metadata,
+ * so the route is registered with `@All()` and the method is filtered by a guard.
+ *
+ * @param endpoint - Route path(s), same as `@Get()` / `@Post()`.
+ */
+function PostGet(endpoint) {
+    return (0, common_1.applyDecorators)((0, common_1.All)(endpoint), (0, common_1.UseGuards)(PostGetGuard));
+}

package/decorators/query-or-body.decorator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads the request body on POST and the query string otherwise.
+ * Meant for `@PostGet()` routes, which answer to both methods.
+ *
+ * Accepts `{ schema }` like `@Query()` / `@Body()`, but the global `StandardSchemaValidationPipe`
+ * must be created with `validateCustomDecorators: true` for it to be validated.
+ */
+export declare const QueryOrBody: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/decorators/query-or-body.decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryOrBody = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Reads the request body on POST and the query string otherwise.
+ * Meant for `@PostGet()` routes, which answer to both methods.
+ *
+ * Accepts `{ schema }` like `@Query()` / `@Body()`, but the global `StandardSchemaValidationPipe`
+ * must be created with `validateCustomDecorators: true` for it to be validated.
+ */
+exports.QueryOrBody = (0, common_1.createParamDecorator)((_, ctx) => {
+    const req = ctx.switchToHttp().getRequest();
+    return req.method.toUpperCase() === 'POST' ? (req.body ?? {}) : req.query;
+});

package/decorators/when.decorator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A decorator that conditionally applies other decorators based on the provided boolean value.
+ *
+ * @param enabled - A boolean value that determines whether the provided decorators should be applied.
+ * @param decorators - A list of method decorators to be conditionally applied.
+ * @returns A method decorator that applies the provided decorators if `enabled` is true.
+ */
+export declare function When(enabled: boolean, ...decorators: MethodDecorator[]): MethodDecorator;

package/decorators/when.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.When = When;
+/**
+ * A decorator that conditionally applies other decorators based on the provided boolean value.
+ *
+ * @param enabled - A boolean value that determines whether the provided decorators should be applied.
+ * @param decorators - A list of method decorators to be conditionally applied.
+ * @returns A method decorator that applies the provided decorators if `enabled` is true.
+ */
+function When(enabled, ...decorators) {
+    return (target, key, descriptor) => {
+        if (enabled)
+            decorators.forEach((d) => d(target, key, descriptor));
+    };
+}

package/html/components/badge.d.ts

@@ -0,0 +1,13 @@
+import { Color } from './colors';
+import { HtmlComponent } from './component';
+export interface IBadgeHtmlContent {
+    text: string;
+    class?: string;
+    color: Color;
+}
+declare class BadgeHtmlComponent extends HtmlComponent<IBadgeHtmlContent> {
+    constructor();
+    compile(content: IBadgeHtmlContent): string;
+}
+export declare const badgeHtmlComponent: BadgeHtmlComponent;
+export {};

package/html/components/badge.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.badgeHtmlComponent = void 0;
+const colors_1 = require("./colors");
+const component_1 = require("./component");
+// Variantes no estilo do badge do shadcn (modo claro): cores com escala usam a variante "soft" (fundo 50, borda 200, texto 700)
+const variantClasses = {
+    [colors_1.Color.PRIMARY]: 'bg-primary text-primary-foreground border-primary',
+    [colors_1.Color.SECONDARY]: 'bg-secondary text-secondary-foreground border-secondary',
+    [colors_1.Color.SUCCESS]: 'bg-success-50 text-success-700 border-success-200',
+    [colors_1.Color.DANGER]: 'bg-danger-50 text-danger-700 border-danger-200',
+    [colors_1.Color.WARNING]: 'bg-warning-50 text-warning-700 border-warning-200',
+    [colors_1.Color.INFO]: 'bg-info-50 text-info-700 border-info-200',
+    [colors_1.Color.LIGHT]: 'bg-muted text-muted-foreground border-border',
+    [colors_1.Color.DARK]: 'bg-foreground text-background border-foreground',
+    [colors_1.Color.NEUTRAL]: 'bg-neutral-100 text-neutral-700 border-neutral-200',
+};
+class BadgeHtmlComponent extends component_1.HtmlComponent {
+    constructor() {
+        const content = `
+      <span class="badge {{variant}} {{class}}">{{text}}</span>
+    `;
+        super('', content);
+    }
+    compile(content) {
+        return super.compile({ ...content, variant: variantClasses[content.color] });
+    }
+}
+exports.badgeHtmlComponent = new BadgeHtmlComponent();

package/html/components/colors.d.ts

@@ -0,0 +1,11 @@
+export declare enum Color {
+    PRIMARY = "primary",
+    SECONDARY = "secondary",
+    SUCCESS = "success",
+    DANGER = "danger",
+    WARNING = "warning",
+    INFO = "info",
+    LIGHT = "light",
+    DARK = "dark",
+    NEUTRAL = "neutral"
+}

package/html/components/colors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+var Color;
+(function (Color) {
+    Color["PRIMARY"] = "primary";
+    Color["SECONDARY"] = "secondary";
+    Color["SUCCESS"] = "success";
+    Color["DANGER"] = "danger";
+    Color["WARNING"] = "warning";
+    Color["INFO"] = "info";
+    Color["LIGHT"] = "light";
+    Color["DARK"] = "dark";
+    Color["NEUTRAL"] = "neutral";
+})(Color || (exports.Color = Color = {}));

package/html/components/component.d.ts

@@ -0,0 +1,11 @@
+export declare class HtmlComponent<T = void> {
+    readonly css?: string | undefined;
+    readonly content?: string | undefined;
+    private options?;
+    constructor(css?: string | undefined, content?: string | undefined, options?: CompileOptions | undefined);
+    private template;
+    compile(content: T): string;
+    compile(content?: T): string;
+    compile(content?: unknown): string;
+    private setTemplate;
+}

package/html/components/component.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlComponent = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const juice_1 = __importDefault(require("juice"));
+class HtmlComponent {
+    css;
+    content;
+    options;
+    constructor(css, content, options) {
+        this.css = css;
+        this.content = content;
+        this.options = options;
+        this.setTemplate();
+    }
+    template;
+    compile(content) {
+        const html = this.template(content);
+        return (0, juice_1.default)(html);
+    }
+    setTemplate() {
+        if (!this.template) {
+            this.template = handlebars_1.default.compile(`
+        <style>
+          ${this.css}
+        </style>
+        ${this.content}  
+      `, this.options);
+        }
+    }
+}
+exports.HtmlComponent = HtmlComponent;

package/html/components/default/default-footer.d.ts

@@ -0,0 +1,6 @@
+import { HtmlComponent } from '../component';
+declare class DefaultFooterHtmlComponent extends HtmlComponent<void> {
+    constructor();
+}
+export declare const defaultFooterHtmlComponent: DefaultFooterHtmlComponent;
+export {};

package/html/components/default/default-footer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFooterHtmlComponent = void 0;
+const component_1 = require("../component");
+class DefaultFooterHtmlComponent extends component_1.HtmlComponent {
+    constructor() {
+        const content = `
+      <div class="border-t px-8 py-4 text-center text-xs text-muted-foreground">
+        <p>Av. Vinte e Cinco de Julho, 3000,
+          Flores da Cunha - RS CEP: 95270-000
+        </p>
+      </div>
+    `;
+        super('', content);
+    }
+}
+exports.defaultFooterHtmlComponent = new DefaultFooterHtmlComponent();
+exports.defaultFooterHtmlComponent.compile();

package/html/components/default/default-header.d.ts

@@ -0,0 +1,13 @@
+import { HtmlComponent } from '../component';
+export interface IDefaultHeaderHtmlContent {
+    logoUrl: string;
+    headerWatermarkCss: string;
+    headerWatermarkUrl: string;
+    logoHeightPx: number;
+}
+declare class DefaultHeaderHtmlComponent extends HtmlComponent<IDefaultHeaderHtmlContent> {
+    constructor();
+    compile(data: IDefaultHeaderHtmlContent): string;
+}
+export declare const defaultHeaderHtmlComponent: DefaultHeaderHtmlComponent;
+export {};