rl-core-api 0.1.0

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateWithFilter = void 0;
+const applyFilter_util_1 = require("./applyFilter.util");
+const filterOperator_enum_1 = require("./filterOperator.enum");
+const filterSort_util_1 = require("./filterSort.util");
+const parseFilter_util_1 = require("./parseFilter.util");
+const paginateWithFilter = async (qb, options) => {
+    const { query, catalog, defaultSort, permissions, searchFields } = options;
+    (0, applyFilter_util_1.applyFilter)(qb, (0, parseFilter_util_1.parseFilter)(query.filter, catalog, permissions));
+    applySearch(qb, query.search, catalog, searchFields);
+    const order = (0, filterSort_util_1.resolveCatalogOrder)(query.sortBy, query.sortDir, catalog, qb.alias, defaultSort);
+    return await qb
+        .orderBy(order.column, order.direction)
+        .skip((query.page - 1) * query.limit)
+        .take(query.limit)
+        .getManyAndCount();
+};
+exports.paginateWithFilter = paginateWithFilter;
+const applySearch = (qb, search, catalog, searchFields) => {
+    if (!search || !searchFields?.length) {
+        return;
+    }
+    const parts = searchFields
+        .map((name, index) => {
+        const definition = catalog.find((item) => item.field === name);
+        if (!definition || definition.relation) {
+            return null;
+        }
+        return (0, applyFilter_util_1.buildOperatorSql)(`${qb.alias}.${definition.column}`, filterOperator_enum_1.FilterOperator.Substring, search, `s${index}`);
+    })
+        .filter((part) => part !== null);
+    if (parts.length === 0) {
+        return;
+    }
+    qb.andWhere(`(${parts.map((part) => part.sql).join(" OR ")})`, Object.assign({}, ...parts.map((part) => part.params)));
+};

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

@@ -0,0 +1,2 @@
+import { FilterCatalog, FilterNode } from "./filterField.interface";
+export declare const parseFilter: (raw: string | undefined, catalog: FilterCatalog, permissions?: string[]) => FilterNode | null;

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

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFilter = void 0;
+const appErrorCode_enum_1 = require("../filters/appErrorCode.enum");
+const filter_constants_1 = require("./filter.constants");
+const filterFieldType_enum_1 = require("./filterFieldType.enum");
+const filterOperator_enum_1 = require("./filterOperator.enum");
+const codedError_util_1 = require("../utils/codedError.util");
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const NULLABILITY_OPERATORS = [
+    filterOperator_enum_1.FilterOperator.Is,
+    filterOperator_enum_1.FilterOperator.Not,
+];
+const LIST_OPERATORS = [
+    filterOperator_enum_1.FilterOperator.In,
+    filterOperator_enum_1.FilterOperator.NotIn,
+];
+const PAIR_OPERATORS = [
+    filterOperator_enum_1.FilterOperator.Between,
+    filterOperator_enum_1.FilterOperator.NotBetween,
+];
+const TEXT_OPERATORS = [
+    filterOperator_enum_1.FilterOperator.Like,
+    filterOperator_enum_1.FilterOperator.NotLike,
+    filterOperator_enum_1.FilterOperator.StartsWith,
+    filterOperator_enum_1.FilterOperator.EndsWith,
+    filterOperator_enum_1.FilterOperator.Substring,
+];
+const UPPER_BOUND_OPERATORS = [filterOperator_enum_1.FilterOperator.Lte];
+const OPERATORS = new Set(Object.values(filterOperator_enum_1.FilterOperator));
+const COMBINATORS = new Set(Object.values(filterOperator_enum_1.FilterCombinator));
+const invalid = (message) => (0, codedError_util_1.codedBadRequest)(message, appErrorCode_enum_1.AppErrorCode.INVALID_FILTER);
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseFilter = (raw, catalog, permissions) => {
+    if (!raw || raw.trim() === "") {
+        return null;
+    }
+    if (raw.length > filter_constants_1.FILTER_MAX_LENGTH) {
+        throw invalid(`Filtro maior que ${filter_constants_1.FILTER_MAX_LENGTH} caracteres`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw invalid("Filtro inválido: não é um JSON válido");
+    }
+    if (!isPlainObject(parsed)) {
+        throw invalid("Filtro inválido: esperado um objeto");
+    }
+    const context = { catalog, permissions, nodes: 0 };
+    return parseObject(parsed, context, filterOperator_enum_1.FilterCombinator.And, 0);
+};
+exports.parseFilter = parseFilter;
+const parseObject = (source, context, combinator, depth) => {
+    if (depth > filter_constants_1.FILTER_MAX_DEPTH) {
+        throw invalid(`Filtro aninhado além de ${filter_constants_1.FILTER_MAX_DEPTH} níveis`);
+    }
+    const nodes = [];
+    for (const [key, value] of Object.entries(source)) {
+        if (COMBINATORS.has(key)) {
+            nodes.push(parseCombinator(key, value, context, depth));
+            continue;
+        }
+        nodes.push(parseField(key, value, context, depth));
+    }
+    if (nodes.length === 0) {
+        return null;
+    }
+    return nodes.length === 1 ? nodes[0] : { combinator, nodes };
+};
+const parseCombinator = (combinator, value, context, depth) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw invalid(`"${combinator}" espera uma lista de condições`);
+    }
+    const nodes = value.map((entry) => {
+        if (!isPlainObject(entry)) {
+            throw invalid(`"${combinator}" espera objetos na lista`);
+        }
+        const node = parseObject(entry, context, filterOperator_enum_1.FilterCombinator.And, depth + 1);
+        if (!node) {
+            throw invalid(`"${combinator}" tem uma condição vazia`);
+        }
+        return node;
+    });
+    return { combinator, nodes };
+};
+const parseField = (field, value, context, depth) => {
+    const definition = context.catalog.find((item) => item.field === field);
+    if (!definition ||
+        definition.filterable === false ||
+        (definition.permission &&
+            !context.permissions?.includes(definition.permission))) {
+        throw invalid(`Campo "${field}" não é filtrável`);
+    }
+    const operators = isPlainObject(value)
+        ? value
+        : { [filterOperator_enum_1.FilterOperator.Eq]: value };
+    const conditions = Object.entries(operators).map(([operator, operand]) => parseCondition(definition, operator, operand, context));
+    if (conditions.length === 0) {
+        throw invalid(`Campo "${field}" veio sem operador`);
+    }
+    if (conditions.length === 1) {
+        return conditions[0];
+    }
+    if (depth >= filter_constants_1.FILTER_MAX_DEPTH) {
+        throw invalid(`Filtro aninhado além de ${filter_constants_1.FILTER_MAX_DEPTH} níveis`);
+    }
+    return { combinator: filterOperator_enum_1.FilterCombinator.And, nodes: conditions };
+};
+const parseCondition = (definition, rawOperator, value, context) => {
+    if (!OPERATORS.has(rawOperator)) {
+        throw invalid(`Operador "${rawOperator}" não existe`);
+    }
+    const operator = rawOperator;
+    const allowed = definition.operators?.length
+        ? definition.operators
+        : filter_constants_1.DEFAULT_OPERATORS[definition.type];
+    if (!allowed.includes(operator)) {
+        throw invalid(`Operador "${operator}" não é aceito no campo "${definition.field}"`);
+    }
+    context.nodes += 1;
+    if (context.nodes > filter_constants_1.FILTER_MAX_NODES) {
+        throw invalid(`Filtro com mais de ${filter_constants_1.FILTER_MAX_NODES} condições`);
+    }
+    return { field: definition, operator, value: coerce(definition, operator, value) };
+};
+const coerce = (definition, operator, value) => {
+    if (NULLABILITY_OPERATORS.includes(operator)) {
+        if (value !== null && typeof value !== "boolean") {
+            throw invalid(`"${operator}" em "${definition.field}" espera null, true ou false`);
+        }
+        return value;
+    }
+    if (LIST_OPERATORS.includes(operator)) {
+        if (!Array.isArray(value) || value.length === 0) {
+            throw invalid(`"${operator}" em "${definition.field}" espera uma lista`);
+        }
+        if (value.length > filter_constants_1.FILTER_MAX_IN_ITEMS) {
+            throw invalid(`"${operator}" em "${definition.field}" aceita no máximo ${filter_constants_1.FILTER_MAX_IN_ITEMS} itens`);
+        }
+        return value.map((item) => coerceScalar(definition, item));
+    }
+    if (PAIR_OPERATORS.includes(operator)) {
+        if (!Array.isArray(value) || value.length !== 2) {
+            throw invalid(`"${operator}" em "${definition.field}" espera exatamente dois valores`);
+        }
+        return [
+            coerceScalar(definition, value[0]),
+            coerceScalar(definition, value[1], true),
+        ];
+    }
+    if (TEXT_OPERATORS.includes(operator)) {
+        if (typeof value !== "string" || value === "") {
+            throw invalid(`"${operator}" em "${definition.field}" espera um texto não vazio`);
+        }
+        return value;
+    }
+    return coerceScalar(definition, value, UPPER_BOUND_OPERATORS.includes(operator));
+};
+const coerceScalar = (definition, value, upperBound = false) => {
+    const { field, type } = definition;
+    switch (type) {
+        case filterFieldType_enum_1.FilterFieldType.Text:
+            if (typeof value !== "string") {
+                throw invalid(`"${field}" espera um texto`);
+            }
+            return value;
+        case filterFieldType_enum_1.FilterFieldType.Number: {
+            const parsed = typeof value === "string" ? Number(value) : value;
+            if (typeof parsed !== "number" || !Number.isFinite(parsed)) {
+                throw invalid(`"${field}" espera um número`);
+            }
+            return parsed;
+        }
+        case filterFieldType_enum_1.FilterFieldType.Boolean:
+            if (typeof value === "boolean") {
+                return value;
+            }
+            if (value === "true" || value === "false") {
+                return value === "true";
+            }
+            throw invalid(`"${field}" espera true ou false`);
+        case filterFieldType_enum_1.FilterFieldType.Date:
+        case filterFieldType_enum_1.FilterFieldType.DateTime: {
+            if (typeof value !== "string" && typeof value !== "number") {
+                throw invalid(`"${field}" espera uma data`);
+            }
+            const date = new Date(value);
+            if (Number.isNaN(date.getTime())) {
+                throw invalid(`"${field}" espera uma data válida (ISO 8601)`);
+            }
+            if (upperBound && typeof value === "string" && DATE_ONLY.test(value)) {
+                date.setUTCHours(23, 59, 59, 999);
+            }
+            return date;
+        }
+        case filterFieldType_enum_1.FilterFieldType.Enum: {
+            if (typeof value !== "string") {
+                throw invalid(`"${field}" espera um dos valores da lista`);
+            }
+            const options = definition.options ?? [];
+            if (!options.some((option) => option.value === value)) {
+                throw invalid(`"${value}" não é um valor válido para "${field}"`);
+            }
+            return value;
+        }
+        case filterFieldType_enum_1.FilterFieldType.Select:
+            if (typeof value !== "string" || value === "") {
+                throw invalid(`"${field}" espera um texto não vazio`);
+            }
+            return value;
+        case filterFieldType_enum_1.FilterFieldType.Uuid:
+            if (typeof value !== "string" || !UUID_PATTERN.test(value)) {
+                throw invalid(`"${field}" espera um UUID`);
+            }
+            return value;
+    }
+};

package/dist/core/utils/codedError.util.d.ts

@@ -0,0 +1,5 @@
+import { BadRequestException, HttpException, UnauthorizedException } from "@nestjs/common";
+import { AppErrorCode } from "../filters/appErrorCode.enum";
+export declare function codedUnauthorized(message: string, errorCode: AppErrorCode): UnauthorizedException;
+export declare function codedBadRequest(message: string, errorCode: AppErrorCode): BadRequestException;
+export declare function codedTooManyRequests(message: string, errorCode: AppErrorCode): HttpException;

package/dist/core/utils/codedError.util.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codedUnauthorized = codedUnauthorized;
+exports.codedBadRequest = codedBadRequest;
+exports.codedTooManyRequests = codedTooManyRequests;
+const common_1 = require("@nestjs/common");
+function codedUnauthorized(message, errorCode) {
+    return new common_1.UnauthorizedException({
+        message,
+        error: "Unauthorized",
+        errorCode,
+    });
+}
+function codedBadRequest(message, errorCode) {
+    return new common_1.BadRequestException({
+        message,
+        error: "Bad Request",
+        errorCode,
+    });
+}
+function codedTooManyRequests(message, errorCode) {
+    return new common_1.HttpException({ message, error: "Too Many Requests", errorCode }, common_1.HttpStatus.TOO_MANY_REQUESTS);
+}

package/dist/core/utils/crypto.util.d.ts

@@ -0,0 +1,2 @@
+export declare function encryptSecret(plain: string): string;
+export declare function decryptSecret(stored: string): string;

package/dist/core/utils/crypto.util.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptSecret = encryptSecret;
+exports.decryptSecret = decryptSecret;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const logger = new common_1.Logger("CryptoUtil");
+const ALGO = "aes-256-gcm";
+function key() {
+    const hex = process.env.TOTP_ENC_KEY ?? "";
+    return Buffer.from(hex, "hex");
+}
+function encryptSecret(plain) {
+    const iv = (0, crypto_1.randomBytes)(12);
+    const cipher = (0, crypto_1.createCipheriv)(ALGO, key(), iv);
+    const enc = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return `${iv.toString("hex")}:${tag.toString("hex")}:${enc.toString("hex")}`;
+}
+function decryptSecret(stored) {
+    const parts = stored.split(":");
+    if (parts.length !== 3) {
+        return stored;
+    }
+    try {
+        const [ivHex, tagHex, dataHex] = parts;
+        const decipher = (0, crypto_1.createDecipheriv)(ALGO, key(), Buffer.from(ivHex, "hex"));
+        decipher.setAuthTag(Buffer.from(tagHex, "hex"));
+        const dec = Buffer.concat([
+            decipher.update(Buffer.from(dataHex, "hex")),
+            decipher.final(),
+        ]);
+        return dec.toString("utf8");
+    }
+    catch (err) {
+        logger.warn(`Falha ao descriptografar segredo (assumindo legado): ${err.message}`);
+        return stored;
+    }
+}

package/dist/core/utils/hash.util.d.ts

@@ -0,0 +1,6 @@
+export declare function hashPassword(plain: string): Promise<string>;
+export declare function verifyPassword(hash: string, plain: string): Promise<boolean>;
+export declare function sha256(value: string): string;
+export declare function randomToken(bytes?: number): string;
+export declare function numericCode(): string;
+export declare function backupCode(): string;

package/dist/core/utils/hash.util.js

@@ -0,0 +1,67 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashPassword = hashPassword;
+exports.verifyPassword = verifyPassword;
+exports.sha256 = sha256;
+exports.randomToken = randomToken;
+exports.numericCode = numericCode;
+exports.backupCode = backupCode;
+const argon2 = __importStar(require("argon2"));
+const crypto_1 = require("crypto");
+async function hashPassword(plain) {
+    return argon2.hash(plain, { type: argon2.argon2id });
+}
+async function verifyPassword(hash, plain) {
+    try {
+        return await argon2.verify(hash, plain);
+    }
+    catch {
+        return false;
+    }
+}
+function sha256(value) {
+    return (0, crypto_1.createHash)("sha256").update(value).digest("hex");
+}
+function randomToken(bytes = 48) {
+    return (0, crypto_1.randomBytes)(bytes).toString("hex");
+}
+function numericCode() {
+    return (0, crypto_1.randomInt)(100000, 1000000).toString();
+}
+function backupCode() {
+    const raw = (0, crypto_1.randomBytes)(4).toString("hex").toUpperCase();
+    return `${raw.slice(0, 4)}-${raw.slice(4, 8)}`;
+}

package/dist/core/utils/ip.util.d.ts

@@ -0,0 +1 @@
+export declare function normalizeIp(ip: string | undefined): string | undefined;

package/dist/core/utils/ip.util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeIp = normalizeIp;
+function normalizeIp(ip) {
+    if (!ip) {
+        return ip;
+    }
+    if (ip === "::1") {
+        return "127.0.0.1";
+    }
+    if (ip.startsWith("::ffff:")) {
+        return ip.slice("::ffff:".length);
+    }
+    return ip;
+}

package/dist/core/utils/pagination.util.d.ts

@@ -0,0 +1,21 @@
+export type SortDir = "ASC" | "DESC";
+export declare class PaginationQuery {
+    page: number;
+    limit: number;
+    search?: string;
+    sortBy?: string;
+    sortDir?: SortDir;
+    filter?: string;
+}
+export declare function resolveOrder<T extends string>(sortBy: string | undefined, sortDir: SortDir | undefined, allowed: readonly T[], fallback: T): Record<string, SortDir>;
+export interface PaginationMeta {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+export declare class Paginated<T> {
+    items: T[];
+    meta: PaginationMeta;
+    constructor(items: T[], total: number, page: number, limit: number);
+}

package/dist/core/utils/pagination.util.js

@@ -0,0 +1,98 @@
+"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.Paginated = exports.PaginationQuery = void 0;
+exports.resolveOrder = resolveOrder;
+const swagger_1 = require("@nestjs/swagger");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const filter_constants_1 = require("../query/filter.constants");
+class PaginationQuery {
+    constructor() {
+        this.page = 1;
+        this.limit = 20;
+    }
+}
+exports.PaginationQuery = PaginationQuery;
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false, default: 1 }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Type)(() => Number),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    __metadata("design:type", Number)
+], PaginationQuery.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false, default: 20 }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Type)(() => Number),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(100),
+    __metadata("design:type", Number)
+], PaginationQuery.prototype, "limit", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], PaginationQuery.prototype, "search", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        description: "Coluna para ordenar (whitelist por endpoint)",
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], PaginationQuery.prototype, "sortBy", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false, enum: ["ASC", "DESC"] }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)(["ASC", "DESC"]),
+    __metadata("design:type", String)
+], PaginationQuery.prototype, "sortDir", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        description: 'JSON, ex.: {"name":{"$SUBSTRING":"ana"}}',
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(filter_constants_1.FILTER_MAX_LENGTH),
+    __metadata("design:type", String)
+], PaginationQuery.prototype, "filter", void 0);
+function resolveOrder(sortBy, sortDir, allowed, fallback) {
+    const column = allowed.includes(sortBy ?? "")
+        ? sortBy
+        : fallback;
+    return { [column]: sortDir ?? "DESC" };
+}
+class Paginated {
+    constructor(items, total, page, limit) {
+        this.items = items;
+        this.meta = {
+            total,
+            page,
+            limit,
+            totalPages: Math.max(1, Math.ceil(total / limit)),
+        };
+    }
+}
+exports.Paginated = Paginated;
+__decorate([
+    (0, swagger_1.ApiProperty)({ isArray: true }),
+    __metadata("design:type", Array)
+], Paginated.prototype, "items", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Object)
+], Paginated.prototype, "meta", void 0);

package/dist/core/utils/paginationMeta.response.d.ts

@@ -0,0 +1,7 @@
+import { PaginationMeta } from "./pagination.util";
+export declare class PaginationMetaResponse implements PaginationMeta {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}

package/dist/core/utils/paginationMeta.response.js

@@ -0,0 +1,32 @@
+"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.PaginationMetaResponse = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class PaginationMetaResponse {
+}
+exports.PaginationMetaResponse = PaginationMetaResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 42 }),
+    __metadata("design:type", Number)
+], PaginationMetaResponse.prototype, "total", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 1 }),
+    __metadata("design:type", Number)
+], PaginationMetaResponse.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 20 }),
+    __metadata("design:type", Number)
+], PaginationMetaResponse.prototype, "limit", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 3 }),
+    __metadata("design:type", Number)
+], PaginationMetaResponse.prototype, "totalPages", void 0);

package/dist/core/utils/password.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const STRONG_PASSWORD_REGEX: RegExp;
+export declare const WEAK_PASSWORD_MESSAGE = "A senha deve ter ao menos 8 caracteres, incluindo mai\u00FAscula, min\u00FAscula, n\u00FAmero e caractere especial";

package/dist/core/utils/password.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEAK_PASSWORD_MESSAGE = exports.STRONG_PASSWORD_REGEX = void 0;
+exports.STRONG_PASSWORD_REGEX = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*(),.?":{}|<>]).{8,}$/;
+exports.WEAK_PASSWORD_MESSAGE = "A senha deve ter ao menos 8 caracteres, incluindo maiúscula, minúscula, número e caractere especial";

package/dist/core/websocket/baseGateway.d.ts

@@ -0,0 +1,21 @@
+import { Logger } from "@nestjs/common";
+import { OnGatewayConnection, OnGatewayDisconnect } from "@nestjs/websockets";
+import { Server, Socket } from "socket.io";
+import { AuthenticatedUser } from "../auth/authenticatedUser.interface";
+import { EnvService } from "../config/env.service";
+import { WsAuthService } from "./wsAuth.service";
+export interface SocketData {
+    user: AuthenticatedUser;
+    expiryTimer?: NodeJS.Timeout;
+}
+export declare abstract class BaseGateway implements OnGatewayConnection, OnGatewayDisconnect {
+    protected readonly wsAuth: WsAuthService;
+    protected readonly env: EnvService;
+    protected abstract server: Server;
+    protected readonly logger: Logger;
+    constructor(wsAuth: WsAuthService, env: EnvService);
+    handleConnection(socket: Socket): Promise<void>;
+    handleDisconnect(socket: Socket): void;
+    protected emitTo<T>(rooms: string[], event: string, data: T): void;
+    private scheduleExpiry;
+}