rl-core-api 0.1.0

package/dist/core/mailer/mailer.service.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var MailerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailerService = void 0;
+const common_1 = require("@nestjs/common");
+const nodemailer = __importStar(require("nodemailer"));
+const env_service_1 = require("../config/env.service");
+let MailerService = MailerService_1 = class MailerService {
+    constructor(env) {
+        this.env = env;
+        this.logger = new common_1.Logger(MailerService_1.name);
+        this.transporter = nodemailer.createTransport({
+            host: this.env.get("EMAIL_HOST"),
+            port: this.env.get("EMAIL_PORT"),
+            secure: this.env.get("EMAIL_SECURE"),
+            auth: {
+                user: this.env.get("EMAIL_USER"),
+                pass: this.env.get("EMAIL_PASSWORD"),
+            },
+        });
+    }
+    async send(to, subject, html) {
+        const from = `"${this.env.get("EMAIL_FROM_NAME")}" <${this.env.get("EMAIL_FROM")}>`;
+        try {
+            await this.transporter.sendMail({ from, to, subject, html });
+            this.logger.log(`Email enviado: ${subject} -> ${to}`);
+        }
+        catch (error) {
+            this.logger.error(`Falha ao enviar email para ${to}`, error);
+            throw error;
+        }
+    }
+    escapeHtml(value) {
+        return value
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#39;");
+    }
+    layout(title, body) {
+        return `
+      <div style="font-family: Arial, sans-serif; padding: 20px; max-width: 600px; margin: 0 auto;">
+        <h2 style="color: #333;">${title}</h2>
+        ${body}
+        <hr style="border: none; border-top: 1px solid #ddd; margin: 30px 0;">
+        <p style="color: #999; font-size: 12px;">Mensagem automática, não responda.</p>
+      </div>`;
+    }
+    async sendTwoFactorCode(to, code, userName) {
+        const expiry = this.env.get("TWO_FACTOR_EMAIL_CODE_EXPIRY");
+        const body = `
+      <p>Olá ${this.escapeHtml(userName)},</p>
+      <p>Seu código de verificação (2FA) é:</p>
+      <div style="text-align:center;margin:30px 0;">
+        <div style="background:#f5f5f5;padding:20px;border-radius:5px;display:inline-block;">
+          <h1 style="margin:0;font-size:36px;letter-spacing:8px;color:#007bff;">${code}</h1>
+        </div>
+      </div>
+      <p><strong>Este código expira em ${expiry} minutos.</strong></p>
+      <p>Se você não tentou fazer login, proteja sua conta imediatamente.</p>`;
+        await this.send(to, "Seu código de verificação (2FA)", this.layout("Autenticação em duas etapas", body));
+    }
+    async sendPasswordReset(to, token, userName) {
+        const url = `${this.env.get("APP_URL")}/reset-password?token=${token}`;
+        const expiry = this.env.get("PASSWORD_RESET_TOKEN_EXPIRY");
+        const body = `
+      <p>Olá ${this.escapeHtml(userName)},</p>
+      <p>Recebemos uma solicitação para redefinir sua senha. Clique no botão abaixo:</p>
+      <div style="text-align:center;margin:30px 0;">
+        <a href="${url}" style="background:#007bff;color:#fff;padding:12px 30px;text-decoration:none;border-radius:5px;display:inline-block;">Redefinir senha</a>
+      </div>
+      <p>Ou copie e cole este link no navegador:</p>
+      <p style="word-break:break-all;color:#666;">${url}</p>
+      <p><strong>Este link expira em ${expiry} minutos.</strong></p>
+      <p>Se você não solicitou, ignore este email.</p>`;
+        await this.send(to, "Redefinição de senha", this.layout("Redefinição de senha", body));
+    }
+    formatExpiry(minutes) {
+        if (minutes < 60) {
+            return `${minutes} minutos`;
+        }
+        const hours = Math.round(minutes / 60);
+        return hours === 1 ? "1 hora" : `${hours} horas`;
+    }
+    async sendFirstAccess(to, token, userName) {
+        const url = `${this.env.get("APP_URL")}/reset-password?token=${token}`;
+        const expiry = this.formatExpiry(this.env.get("FIRST_ACCESS_TOKEN_EXPIRY"));
+        const body = `
+      <p>Olá ${this.escapeHtml(userName)},</p>
+      <p>Sua conta foi criada. Para acessar o sistema, defina sua senha clicando no botão abaixo:</p>
+      <div style="text-align:center;margin:30px 0;">
+        <a href="${url}" style="background:#007bff;color:#fff;padding:12px 30px;text-decoration:none;border-radius:5px;display:inline-block;">Definir minha senha</a>
+      </div>
+      <p>Ou copie e cole este link no navegador:</p>
+      <p style="word-break:break-all;color:#666;">${url}</p>
+      <p><strong>Este link expira em ${expiry}.</strong></p>
+      <p>No primeiro login você também precisará configurar a autenticação em duas etapas (2FA).</p>`;
+        await this.send(to, "Defina sua senha de primeiro acesso", this.layout("Primeiro acesso", body));
+    }
+};
+exports.MailerService = MailerService;
+exports.MailerService = MailerService = MailerService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [env_service_1.EnvService])
+], MailerService);

package/dist/core/openapi/exportOpenapi.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/openapi/exportOpenapi.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@nestjs/core");
+const swagger_1 = require("@nestjs/swagger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const app_module_1 = require("../../app.module");
+async function exportOpenapi() {
+    const app = await core_1.NestFactory.create(app_module_1.AppModule, { logger: false });
+    const config = new swagger_1.DocumentBuilder()
+        .setTitle("Core API")
+        .setDescription("Auth + 2FA obrigatório (TOTP) + RBAC + auditoria")
+        .setVersion("1.0")
+        .addBearerAuth()
+        .addCookieAuth("access_token")
+        .build();
+    const document = swagger_1.SwaggerModule.createDocument(app, config);
+    const target = (0, path_1.join)(process.cwd(), "..", "..", "openapi.json");
+    (0, fs_1.writeFileSync)(target, `${JSON.stringify(document, null, 2)}\n`);
+    await app.close();
+    const paths = Object.keys(document.paths).length;
+    const schemas = Object.keys(document.components?.schemas ?? {}).length;
+    console.log(`openapi.json gerado: ${paths} rotas, ${schemas} schemas`);
+}
+void exportOpenapi();

package/dist/core/query/applyFilter.util.d.ts

@@ -0,0 +1,11 @@
+import { ObjectLiteral, SelectQueryBuilder } from "typeorm";
+import { FilterGroup, FilterNode } from "./filterField.interface";
+import { FilterOperator } from "./filterOperator.enum";
+export interface FilterSql {
+    sql: string;
+    params: Record<string, unknown>;
+}
+export declare const isFilterGroup: (node: FilterNode) => node is FilterGroup;
+export declare const escapeLike: (value: string) => string;
+export declare const buildOperatorSql: (column: string, operator: FilterOperator, value: unknown, param: string) => FilterSql;
+export declare const applyFilter: <T extends ObjectLiteral>(qb: SelectQueryBuilder<T>, node: FilterNode | null) => SelectQueryBuilder<T>;

package/dist/core/query/applyFilter.util.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFilter = exports.buildOperatorSql = exports.escapeLike = exports.isFilterGroup = void 0;
+const filterOperator_enum_1 = require("./filterOperator.enum");
+const isFilterGroup = (node) => "combinator" in node;
+exports.isFilterGroup = isFilterGroup;
+const escapeLike = (value) => value.replace(/[\\%_]/g, (char) => `\\${char}`);
+exports.escapeLike = escapeLike;
+const buildOperatorSql = (column, operator, value, param) => {
+    const one = (sql, bound = value) => ({
+        sql,
+        params: { [param]: bound },
+    });
+    switch (operator) {
+        case filterOperator_enum_1.FilterOperator.Eq:
+            return one(`${column} = :${param}`);
+        case filterOperator_enum_1.FilterOperator.Ne:
+            return one(`${column} <> :${param}`);
+        case filterOperator_enum_1.FilterOperator.Is:
+            return { sql: `${column} IS ${nullabilityOperand(value)}`, params: {} };
+        case filterOperator_enum_1.FilterOperator.Not:
+            return {
+                sql: `${column} IS NOT ${nullabilityOperand(value)}`,
+                params: {},
+            };
+        case filterOperator_enum_1.FilterOperator.Gt:
+            return one(`${column} > :${param}`);
+        case filterOperator_enum_1.FilterOperator.Gte:
+            return one(`${column} >= :${param}`);
+        case filterOperator_enum_1.FilterOperator.Lt:
+            return one(`${column} < :${param}`);
+        case filterOperator_enum_1.FilterOperator.Lte:
+            return one(`${column} <= :${param}`);
+        case filterOperator_enum_1.FilterOperator.Between:
+        case filterOperator_enum_1.FilterOperator.NotBetween: {
+            const [from, to] = value;
+            const negation = operator === filterOperator_enum_1.FilterOperator.NotBetween ? "NOT " : "";
+            return {
+                sql: `${column} ${negation}BETWEEN :${param}_from AND :${param}_to`,
+                params: { [`${param}_from`]: from, [`${param}_to`]: to },
+            };
+        }
+        case filterOperator_enum_1.FilterOperator.In:
+            return one(`${column} IN (:...${param})`);
+        case filterOperator_enum_1.FilterOperator.NotIn:
+            return one(`${column} NOT IN (:...${param})`);
+        case filterOperator_enum_1.FilterOperator.Like:
+            return one(`${column} LIKE :${param}`);
+        case filterOperator_enum_1.FilterOperator.NotLike:
+            return one(`${column} NOT LIKE :${param}`);
+        case filterOperator_enum_1.FilterOperator.StartsWith:
+            return one(`${column} LIKE :${param}`, `${(0, exports.escapeLike)(String(value))}%`);
+        case filterOperator_enum_1.FilterOperator.EndsWith:
+            return one(`${column} LIKE :${param}`, `%${(0, exports.escapeLike)(String(value))}`);
+        case filterOperator_enum_1.FilterOperator.Substring:
+            return one(`${column} LIKE :${param}`, `%${(0, exports.escapeLike)(String(value))}%`);
+    }
+};
+exports.buildOperatorSql = buildOperatorSql;
+const nullabilityOperand = (value) => {
+    if (value === null) {
+        return "NULL";
+    }
+    return value === true ? "TRUE" : "FALSE";
+};
+const applyFilter = (qb, node) => {
+    if (!node) {
+        return qb;
+    }
+    const context = { qb, alias: qb.alias, index: 0 };
+    const { sql, params } = buildNodeSql(node, context);
+    return qb.andWhere(sql, params);
+};
+exports.applyFilter = applyFilter;
+const buildNodeSql = (node, context) => {
+    if ((0, exports.isFilterGroup)(node)) {
+        const parts = node.nodes.map((child) => buildNodeSql(child, context));
+        const glue = node.combinator === filterOperator_enum_1.FilterCombinator.Or ? " OR " : " AND ";
+        return {
+            sql: `(${parts.map((part) => part.sql).join(glue)})`,
+            params: Object.assign({}, ...parts.map((part) => part.params)),
+        };
+    }
+    return buildConditionSql(node, context);
+};
+const buildConditionSql = (condition, context) => {
+    const param = `f${context.index++}`;
+    const { relation } = condition.field;
+    if (relation?.kind === "toMany") {
+        return buildExistsSql(condition, context, param);
+    }
+    const alias = relation ? relation.alias : context.alias;
+    if (relation) {
+        ensureJoin(context, relation.property, relation.alias);
+    }
+    return (0, exports.buildOperatorSql)(`${alias}.${condition.field.column}`, condition.operator, condition.value, param);
+};
+const ensureJoin = (context, property, alias) => {
+    const joined = context.qb.expressionMap.joinAttributes.some((join) => join.alias.name === alias);
+    if (!joined) {
+        context.qb.leftJoin(`${context.alias}.${property}`, alias);
+    }
+};
+const buildExistsSql = (condition, context, param) => {
+    const relation = condition.field.relation;
+    const metadata = context.qb.expressionMap.mainAlias?.metadata;
+    if (!relation || !metadata) {
+        throw new Error("applyFilter: relação to-many sem metadata da entidade raiz");
+    }
+    const primaryKey = metadata.primaryColumns[0].propertyName;
+    const rootAlias = `${relation.alias}_root_${param}`;
+    const joinAlias = `${relation.alias}_${param}`;
+    const inner = (0, exports.buildOperatorSql)(`${joinAlias}.${condition.field.column}`, condition.operator, condition.value, param);
+    const subQuery = context.qb.connection
+        .createQueryBuilder()
+        .select("1")
+        .from(metadata.target, rootAlias)
+        .innerJoin(`${rootAlias}.${relation.property}`, joinAlias)
+        .where(`${rootAlias}.${primaryKey} = ${context.alias}.${primaryKey}`)
+        .andWhere(inner.sql);
+    return { sql: `EXISTS (${subQuery.getQuery()})`, params: inner.params };
+};

package/dist/core/query/filter.constants.d.ts

@@ -0,0 +1,7 @@
+import { FilterFieldType } from "./filterFieldType.enum";
+import { FilterOperator } from "./filterOperator.enum";
+export declare const FILTER_MAX_LENGTH = 4000;
+export declare const FILTER_MAX_DEPTH = 3;
+export declare const FILTER_MAX_NODES = 50;
+export declare const FILTER_MAX_IN_ITEMS = 100;
+export declare const DEFAULT_OPERATORS: Readonly<Record<FilterFieldType, readonly FilterOperator[]>>;

package/dist/core/query/filter.constants.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OPERATORS = exports.FILTER_MAX_IN_ITEMS = exports.FILTER_MAX_NODES = exports.FILTER_MAX_DEPTH = exports.FILTER_MAX_LENGTH = void 0;
+const filterFieldType_enum_1 = require("./filterFieldType.enum");
+const filterOperator_enum_1 = require("./filterOperator.enum");
+exports.FILTER_MAX_LENGTH = 4000;
+exports.FILTER_MAX_DEPTH = 3;
+exports.FILTER_MAX_NODES = 50;
+exports.FILTER_MAX_IN_ITEMS = 100;
+const ORDERING_OPERATORS = [
+    filterOperator_enum_1.FilterOperator.Gt,
+    filterOperator_enum_1.FilterOperator.Gte,
+    filterOperator_enum_1.FilterOperator.Lt,
+    filterOperator_enum_1.FilterOperator.Lte,
+    filterOperator_enum_1.FilterOperator.Between,
+    filterOperator_enum_1.FilterOperator.NotBetween,
+];
+const NULLABILITY = [filterOperator_enum_1.FilterOperator.Is, filterOperator_enum_1.FilterOperator.Not];
+exports.DEFAULT_OPERATORS = {
+    [filterFieldType_enum_1.FilterFieldType.Text]: [
+        filterOperator_enum_1.FilterOperator.Substring,
+        filterOperator_enum_1.FilterOperator.StartsWith,
+        filterOperator_enum_1.FilterOperator.EndsWith,
+        filterOperator_enum_1.FilterOperator.Like,
+        filterOperator_enum_1.FilterOperator.NotLike,
+        filterOperator_enum_1.FilterOperator.Eq,
+        filterOperator_enum_1.FilterOperator.Ne,
+        filterOperator_enum_1.FilterOperator.In,
+        filterOperator_enum_1.FilterOperator.NotIn,
+        ...NULLABILITY,
+    ],
+    [filterFieldType_enum_1.FilterFieldType.Number]: [
+        filterOperator_enum_1.FilterOperator.Eq,
+        filterOperator_enum_1.FilterOperator.Ne,
+        ...ORDERING_OPERATORS,
+        filterOperator_enum_1.FilterOperator.In,
+        filterOperator_enum_1.FilterOperator.NotIn,
+        ...NULLABILITY,
+    ],
+    [filterFieldType_enum_1.FilterFieldType.Date]: [...ORDERING_OPERATORS, ...NULLABILITY],
+    [filterFieldType_enum_1.FilterFieldType.DateTime]: [...ORDERING_OPERATORS, ...NULLABILITY],
+    [filterFieldType_enum_1.FilterFieldType.Boolean]: [filterOperator_enum_1.FilterOperator.Eq, ...NULLABILITY],
+    [filterFieldType_enum_1.FilterFieldType.Enum]: [
+        filterOperator_enum_1.FilterOperator.In,
+        filterOperator_enum_1.FilterOperator.NotIn,
+        filterOperator_enum_1.FilterOperator.Eq,
+        filterOperator_enum_1.FilterOperator.Ne,
+        ...NULLABILITY,
+    ],
+    [filterFieldType_enum_1.FilterFieldType.Select]: [
+        filterOperator_enum_1.FilterOperator.In,
+        filterOperator_enum_1.FilterOperator.NotIn,
+        filterOperator_enum_1.FilterOperator.Eq,
+        filterOperator_enum_1.FilterOperator.Ne,
+        ...NULLABILITY,
+    ],
+    [filterFieldType_enum_1.FilterFieldType.Uuid]: [
+        filterOperator_enum_1.FilterOperator.Eq,
+        filterOperator_enum_1.FilterOperator.Ne,
+        filterOperator_enum_1.FilterOperator.In,
+        filterOperator_enum_1.FilterOperator.NotIn,
+        ...NULLABILITY,
+    ],
+};

package/dist/core/query/filterField.interface.d.ts

@@ -0,0 +1,35 @@
+import { FilterFieldType } from "./filterFieldType.enum";
+import { FilterCombinator, FilterOperator } from "./filterOperator.enum";
+export interface FilterOption {
+    value: string;
+    label: string;
+}
+export interface FilterRelation {
+    property: string;
+    alias: string;
+    kind: "toOne" | "toMany";
+}
+export interface FilterFieldDefinition {
+    field: string;
+    column: string;
+    label: string;
+    type: FilterFieldType;
+    operators?: FilterOperator[];
+    options?: FilterOption[];
+    optionsUrl?: string;
+    relation?: FilterRelation;
+    permission?: string;
+    sortable?: boolean;
+    filterable?: boolean;
+}
+export type FilterCatalog = readonly FilterFieldDefinition[];
+export interface FilterCondition {
+    field: FilterFieldDefinition;
+    operator: FilterOperator;
+    value: unknown;
+}
+export interface FilterGroup {
+    combinator: FilterCombinator;
+    nodes: FilterNode[];
+}
+export type FilterNode = FilterCondition | FilterGroup;

package/dist/core/query/filterField.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/query/filterFieldType.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum FilterFieldType {
+    Text = "TEXT",
+    Number = "NUMBER",
+    Date = "DATE",
+    DateTime = "DATETIME",
+    Boolean = "BOOLEAN",
+    Enum = "ENUM",
+    Select = "SELECT",
+    Uuid = "UUID"
+}

package/dist/core/query/filterFieldType.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterFieldType = void 0;
+var FilterFieldType;
+(function (FilterFieldType) {
+    FilterFieldType["Text"] = "TEXT";
+    FilterFieldType["Number"] = "NUMBER";
+    FilterFieldType["Date"] = "DATE";
+    FilterFieldType["DateTime"] = "DATETIME";
+    FilterFieldType["Boolean"] = "BOOLEAN";
+    FilterFieldType["Enum"] = "ENUM";
+    FilterFieldType["Select"] = "SELECT";
+    FilterFieldType["Uuid"] = "UUID";
+})(FilterFieldType || (exports.FilterFieldType = FilterFieldType = {}));

package/dist/core/query/filterOperator.enum.d.ts

@@ -0,0 +1,23 @@
+export declare enum FilterOperator {
+    Eq = "$EQ",
+    Ne = "$NE",
+    Is = "$IS",
+    Not = "$NOT",
+    Gt = "$GT",
+    Gte = "$GTE",
+    Lt = "$LT",
+    Lte = "$LTE",
+    Between = "$BETWEEN",
+    NotBetween = "$NOTBETWEEN",
+    In = "$IN",
+    NotIn = "$NOTIN",
+    Like = "$LIKE",
+    NotLike = "$NOTLIKE",
+    StartsWith = "$STARTSWITH",
+    EndsWith = "$ENDSWITH",
+    Substring = "$SUBSTRING"
+}
+export declare enum FilterCombinator {
+    And = "$AND",
+    Or = "$OR"
+}

package/dist/core/query/filterOperator.enum.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterCombinator = exports.FilterOperator = void 0;
+var FilterOperator;
+(function (FilterOperator) {
+    FilterOperator["Eq"] = "$EQ";
+    FilterOperator["Ne"] = "$NE";
+    FilterOperator["Is"] = "$IS";
+    FilterOperator["Not"] = "$NOT";
+    FilterOperator["Gt"] = "$GT";
+    FilterOperator["Gte"] = "$GTE";
+    FilterOperator["Lt"] = "$LT";
+    FilterOperator["Lte"] = "$LTE";
+    FilterOperator["Between"] = "$BETWEEN";
+    FilterOperator["NotBetween"] = "$NOTBETWEEN";
+    FilterOperator["In"] = "$IN";
+    FilterOperator["NotIn"] = "$NOTIN";
+    FilterOperator["Like"] = "$LIKE";
+    FilterOperator["NotLike"] = "$NOTLIKE";
+    FilterOperator["StartsWith"] = "$STARTSWITH";
+    FilterOperator["EndsWith"] = "$ENDSWITH";
+    FilterOperator["Substring"] = "$SUBSTRING";
+})(FilterOperator || (exports.FilterOperator = FilterOperator = {}));
+var FilterCombinator;
+(function (FilterCombinator) {
+    FilterCombinator["And"] = "$AND";
+    FilterCombinator["Or"] = "$OR";
+})(FilterCombinator || (exports.FilterCombinator = FilterCombinator = {}));

package/dist/core/query/filterSchema.response.d.ts

@@ -0,0 +1,17 @@
+import { FilterCatalog, FilterOption } from "./filterField.interface";
+import { FilterFieldType } from "./filterFieldType.enum";
+import { FilterOperator } from "./filterOperator.enum";
+export declare class FilterOptionResponse implements FilterOption {
+    value: string;
+    label: string;
+}
+export declare class FilterFieldResponse {
+    field: string;
+    label: string;
+    type: FilterFieldType;
+    operators: FilterOperator[];
+    options?: FilterOptionResponse[];
+    optionsUrl?: string;
+    sortable: boolean;
+}
+export declare const toFilterSchema: (catalog: FilterCatalog, permissions?: string[]) => FilterFieldResponse[];

package/dist/core/query/filterSchema.response.js

@@ -0,0 +1,82 @@
+"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.toFilterSchema = exports.FilterFieldResponse = exports.FilterOptionResponse = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const filter_constants_1 = require("./filter.constants");
+const filterFieldType_enum_1 = require("./filterFieldType.enum");
+const filterOperator_enum_1 = require("./filterOperator.enum");
+class FilterOptionResponse {
+}
+exports.FilterOptionResponse = FilterOptionResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], FilterOptionResponse.prototype, "value", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], FilterOptionResponse.prototype, "label", void 0);
+class FilterFieldResponse {
+}
+exports.FilterFieldResponse = FilterFieldResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], FilterFieldResponse.prototype, "field", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], FilterFieldResponse.prototype, "label", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: filterFieldType_enum_1.FilterFieldType, enumName: "FilterFieldType" }),
+    __metadata("design:type", String)
+], FilterFieldResponse.prototype, "type", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        enum: filterOperator_enum_1.FilterOperator,
+        enumName: "FilterOperator",
+        isArray: true,
+    }),
+    __metadata("design:type", Array)
+], FilterFieldResponse.prototype, "operators", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: FilterOptionResponse, isArray: true, required: false }),
+    __metadata("design:type", Array)
+], FilterFieldResponse.prototype, "options", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        description: "Endpoint que lista as opções de um campo SELECT",
+    }),
+    __metadata("design:type", String)
+], FilterFieldResponse.prototype, "optionsUrl", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Boolean)
+], FilterFieldResponse.prototype, "sortable", void 0);
+const toFilterSchema = (catalog, permissions) => catalog
+    .filter((field) => field.filterable !== false &&
+    (!field.permission || (permissions ?? []).includes(field.permission)))
+    .map((field) => ({
+    field: field.field,
+    label: field.label,
+    type: field.type,
+    operators: [
+        ...(field.operators?.length
+            ? field.operators
+            : filter_constants_1.DEFAULT_OPERATORS[field.type]),
+    ],
+    options: field.options,
+    optionsUrl: field.optionsUrl,
+    sortable: field.sortable ?? false,
+}));
+exports.toFilterSchema = toFilterSchema;

package/dist/core/query/filterSort.util.d.ts

@@ -0,0 +1,7 @@
+import { FilterCatalog } from "./filterField.interface";
+import { SortDir } from "../utils/pagination.util";
+export interface CatalogOrder {
+    column: string;
+    direction: SortDir;
+}
+export declare const resolveCatalogOrder: (sortBy: string | undefined, sortDir: SortDir | undefined, catalog: FilterCatalog, alias: string, fallback: string) => CatalogOrder;

package/dist/core/query/filterSort.util.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCatalogOrder = void 0;
+const resolveCatalogOrder = (sortBy, sortDir, catalog, alias, fallback) => {
+    const chosen = catalog.find((field) => field.field === sortBy && field.sortable && !field.relation);
+    const column = chosen?.column ??
+        catalog.find((field) => field.field === fallback)?.column ??
+        fallback;
+    return { column: `${alias}.${column}`, direction: sortDir ?? "DESC" };
+};
+exports.resolveCatalogOrder = resolveCatalogOrder;

package/dist/core/query/paginateWithFilter.util.d.ts

@@ -0,0 +1,11 @@
+import { ObjectLiteral, SelectQueryBuilder } from "typeorm";
+import { FilterCatalog } from "./filterField.interface";
+import { PaginationQuery } from "../utils/pagination.util";
+export interface PaginateWithFilterOptions {
+    query: PaginationQuery;
+    catalog: FilterCatalog;
+    defaultSort: string;
+    permissions?: string[];
+    searchFields?: readonly string[];
+}
+export declare const paginateWithFilter: <T extends ObjectLiteral>(qb: SelectQueryBuilder<T>, options: PaginateWithFilterOptions) => Promise<[T[], number]>;