@koalarx/nest 3.0.2 → 3.0.4

package/core/mapping/for-member.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forMember = forMember;
+function forMember(targetProp, map) {
+    return {
+        [targetProp]: map,
+    };
+}

package/core/request-overflow/request-handler.base.d.ts

@@ -0,0 +1,4 @@
+import { RequestResult } from './request-result';
+export declare abstract class RequestHandlerBase<TRequest, TResponse extends RequestResult<Error, any>> {
+    abstract handle(req: TRequest): Promise<TResponse>;
+}

package/core/request-overflow/request-handler.base.js

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

package/core/request-overflow/request-result.d.ts

@@ -0,0 +1,15 @@
+export declare class Failure<L, R> {
+    readonly value: L;
+    constructor(value: L);
+    isFailure(): this is Failure<L, R>;
+    isOk(): this is Ok<L, R>;
+}
+export declare class Ok<L, R> {
+    readonly value: R;
+    constructor(value: R);
+    isFailure(): this is Failure<L, R>;
+    isOk(): this is Ok<L, R>;
+}
+export type RequestResult<L, R> = Failure<L, R> | Ok<L, R>;
+export declare const failure: <L, R>(value: L) => RequestResult<L, R>;
+export declare const ok: <L, R>(value: R) => RequestResult<L, R>;

package/core/request-overflow/request-result.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ok = exports.failure = exports.Ok = exports.Failure = void 0;
+class Failure {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    isFailure() {
+        return true;
+    }
+    isOk() {
+        return false;
+    }
+}
+exports.Failure = Failure;
+class Ok {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    isFailure() {
+        return false;
+    }
+    isOk() {
+        return true;
+    }
+}
+exports.Ok = Ok;
+const failure = (value) => {
+    return new Failure(value);
+};
+exports.failure = failure;
+const ok = (value) => {
+    return new Ok(value);
+};
+exports.ok = ok;

package/core/request-overflow/request-validator.base.d.ts

@@ -0,0 +1,7 @@
+import { ZodType } from 'zod';
+export declare abstract class RequestValidatorBase<TRequest extends Record<string, any>> {
+    protected _request: Record<string, any>;
+    constructor(request: TRequest);
+    validate(): TRequest;
+    protected abstract get schema(): ZodType;
+}

package/core/request-overflow/request-validator.base.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidatorBase = void 0;
+class RequestValidatorBase {
+    _request;
+    constructor(request) {
+        this._request = { ...request };
+    }
+    validate() {
+        Object.keys(this._request).forEach((key) => {
+            if (key.includes('[]')) {
+                const newKey = key.replace('[]', '');
+                const value = this._request[key];
+                this._request[newKey] =
+                    typeof value === 'string' ? value.split(',') : value;
+                delete this._request[key];
+            }
+        });
+        const requestParsed = this.schema.safeParse(this._request);
+        if (requestParsed.success) {
+            return Object.assign(this._request, requestParsed.data);
+        }
+        throw requestParsed.error;
+    }
+}
+exports.RequestValidatorBase = RequestValidatorBase;

package/core/security/strategies/api-key.strategy.d.ts

@@ -0,0 +1,16 @@
+import { Request } from 'express';
+import { Strategy } from 'passport-custom';
+export type DoneFn = (err: Error | null, user?: any) => void;
+interface ApiKeyStrategyOptions {
+    header: string;
+    prefix?: string;
+}
+declare abstract class ApiKeyStrategyBase extends Strategy {
+    constructor({ header, prefix }: ApiKeyStrategyOptions);
+    abstract validate(apikey: string, done: DoneFn, request: Request): Promise<void> | void;
+}
+export declare class ApiKeyStrategy extends ApiKeyStrategyBase {
+    constructor(options: ApiKeyStrategyOptions);
+    validate(apikey: string, done: DoneFn, request: Request): void;
+}
+export {};

package/core/security/strategies/api-key.strategy.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyStrategy = void 0;
+const common_1 = require("@nestjs/common");
+const passport_custom_1 = require("passport-custom");
+class ApiKeyStrategyBase extends passport_custom_1.Strategy {
+    constructor({ header, prefix }) {
+        super(async (request, done) => {
+            try {
+                const apikey = request.headers[header.toLowerCase()];
+                const apiKeyEncoded = apikey?.replace(`${prefix || ''} `, '');
+                if (apiKeyEncoded) {
+                    return await this.validate(apiKeyEncoded, done, request);
+                }
+                return done(new common_1.UnauthorizedException());
+            }
+            catch (err) {
+                return done(err, null);
+            }
+        });
+    }
+}
+class ApiKeyStrategy extends ApiKeyStrategyBase {
+    constructor(options) {
+        super(options);
+    }
+    validate(apikey, done, request) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.ApiKeyStrategy = ApiKeyStrategy;

package/core/utils/assing-object.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export type ObjectProps<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+export declare function assignObject<T>(Target: Type<T>, source: ObjectProps<T>): T;

package/core/utils/assing-object.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignObject = assignObject;
+function assignObject(Target, source) {
+    return Object.assign(new Target(), source);
+}

package/core/utils/env.config.d.ts

@@ -0,0 +1,6 @@
+export declare class EnvConfig {
+    static get isEnvTest(): boolean;
+    static get isEnvDevelop(): boolean;
+    static get isEnvStaging(): boolean;
+    static get isEnvProduction(): boolean;
+}

package/core/utils/env.config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvConfig = void 0;
+class EnvConfig {
+    static get isEnvTest() {
+        return process.env.NODE_ENV === 'test';
+    }
+    static get isEnvDevelop() {
+        return process.env.NODE_ENV === 'develop';
+    }
+    static get isEnvStaging() {
+        return process.env.NODE_ENV === 'staging';
+    }
+    static get isEnvProduction() {
+        return process.env.NODE_ENV === 'production';
+    }
+}
+exports.EnvConfig = EnvConfig;

package/core/utils/filter-request-params.d.ts

@@ -0,0 +1,13 @@
+import { ArgumentsHost } from '@nestjs/common/interfaces';
+import { Response } from 'express';
+export declare class FilterRequestParams {
+    static get(host: ArgumentsHost): {
+        response: Response<any, Record<string, any>>;
+        loggedUserName: string;
+        filterParams: {
+            method: string;
+            payload: any;
+            endpoint: string;
+        };
+    };
+}

package/core/utils/filter-request-params.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterRequestParams = void 0;
+class FilterRequestParams {
+    static get(host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const method = request.method;
+        const isGetMethod = method === 'GET';
+        return {
+            response,
+            loggedUserName: request?.user?.login ?? request.headers.origin ?? request.ip ?? '',
+            filterParams: {
+                method,
+                payload: !isGetMethod ? request.body : undefined,
+                endpoint: request.url,
+            },
+        };
+    }
+}
+exports.FilterRequestParams = FilterRequestParams;

package/core/utils/find-on-list.d.ts

@@ -0,0 +1,2 @@
+import { List } from './list';
+export declare function findOnList<T>(list: List<T>, ...predicates: ((item: T) => boolean)[]): T | null;

package/core/utils/find-on-list.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findOnList = findOnList;
+function findOnList(list, ...predicates) {
+    let result = null;
+    for (const predicate of predicates) {
+        result = list.find(predicate);
+        if (result) {
+            break;
+        }
+    }
+    return result;
+}

package/core/utils/get-type-by-prop.d.ts

@@ -0,0 +1,2 @@
+import { AutoMappingClassProp } from '../mapping/auto-mapping-class-context';
+export declare function getTypeByProp(prop: AutoMappingClassProp): string;

package/core/utils/get-type-by-prop.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeByProp = getTypeByProp;
+function getTypeByProp(prop) {
+    try {
+        return prop.type().name ?? prop.type.name ?? '';
+    }
+    catch {
+        return prop.type.name ?? '';
+    }
+}

package/core/utils/instanciate-class-with-dependencies-injection.d.ts

@@ -0,0 +1,2 @@
+import { INestApplication } from '@nestjs/common';
+export declare function instanciateClassWithDependenciesInjection(app: INestApplication, Target: any): any;

package/core/utils/instanciate-class-with-dependencies-injection.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanciateClassWithDependenciesInjection = instanciateClassWithDependenciesInjection;
+function instanciateClassWithDependenciesInjection(app, Target) {
+    const dependencies = Reflect.getMetadata('design:paramtypes', Target) ?? [];
+    const injections = dependencies.map((dependency) => {
+        return app.get(dependency);
+    });
+    return new Target(...injections);
+}

package/core/utils/interfaces/icomparable.d.ts

@@ -0,0 +1,5 @@
+export type IComparableId = string | number;
+export declare abstract class IComparable<T = any> {
+    abstract _id: IComparableId;
+    abstract equals(obj: IComparable<T>): boolean;
+}

package/core/utils/interfaces/icomparable.js

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

package/core/utils/list.d.ts

@@ -0,0 +1,39 @@
+import { Type } from '@nestjs/common';
+import 'reflect-metadata';
+import { IComparableId } from './interfaces/icomparable';
+export type OrderDirection = 'asc' | 'desc';
+export type ListActionType = 'added' | 'updated' | 'removed';
+export interface ListProps<T> {
+    list?: T[];
+    entityType?: Type<T>;
+}
+export declare class List<T> {
+    readonly entityType?: Type<T> | undefined;
+    private _list;
+    private _addedItemsList;
+    private _updatedItemsList;
+    private _removedItemsList;
+    constructor(entityType?: Type<T> | undefined);
+    private indexOf;
+    private contains;
+    private mapInternalIdIfIsEmpty;
+    get length(): number;
+    orderBy(by: keyof T, direction?: OrderDirection): this;
+    first(): NonNullable<T> | null;
+    last(): NonNullable<T> | null;
+    findById(id: IComparableId): T | null;
+    findByValue(value: any): T | null;
+    setList(list: T[]): this;
+    add(item: T): this | undefined;
+    remove(item: T): this;
+    update(items: T[]): this;
+    clear(): this;
+    forEach(callback: (item: T, index: number) => void): this;
+    forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<this>;
+    map<U>(callback: (item: T, index: number) => U): List<U>;
+    mapAsync<U>(callback: (item: T, index: number) => Promise<U>): Promise<List<U>>;
+    filter(callback: (item: T, index: number) => boolean): List<T>;
+    filterAsync(callback: (item: T, index: number) => Promise<boolean>): Promise<List<T>>;
+    find(callback: (item: T, index: number) => boolean): T | null;
+    toArray(type?: ListActionType): T[];
+}

package/core/utils/list.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = void 0;
+require("reflect-metadata");
+const entity_base_1 = require("../database/entity.base");
+class List {
+    entityType;
+    _list = [];
+    _addedItemsList = [];
+    _updatedItemsList = [];
+    _removedItemsList = [];
+    constructor(entityType) {
+        this.entityType = entityType;
+    }
+    indexOf(item, list = this._list) {
+        if (item instanceof entity_base_1.EntityBase) {
+            return list
+                .filter((i) => i instanceof entity_base_1.EntityBase)
+                .filter((i) => !!i._id)
+                .findIndex((i) => item._id === i._id ||
+                item.id === i.id);
+        }
+        return list
+            .filter((i) => !(i instanceof entity_base_1.EntityBase))
+            .findIndex((i) => item === i);
+    }
+    contains(item, list = this._list) {
+        return this.indexOf(item, list) > -1;
+    }
+    mapInternalIdIfIsEmpty(list) {
+        return list.map((item) => {
+            if (item instanceof entity_base_1.EntityBase && !item._id) {
+                item._id = item.id;
+            }
+            return item;
+        });
+    }
+    get length() {
+        return this._list.length;
+    }
+    orderBy(by, direction = 'asc') {
+        const inverse = direction === 'desc';
+        this._list.sort((a, b) => {
+            if (typeof a !== 'string' && typeof b !== 'string') {
+                if ((!inverse && a[by] > b[by]) || (inverse && a[by] < b[by])) {
+                    return 1;
+                }
+                else if ((!inverse && a[by] < b[by]) || (inverse && a[by] > b[by])) {
+                    return -1;
+                }
+                else {
+                    return 0;
+                }
+            }
+            else {
+                return 0;
+            }
+        });
+        return this;
+    }
+    first() {
+        return this._list[0] ?? null;
+    }
+    last() {
+        return this._list[this._list.length - 1] ?? null;
+    }
+    findById(id) {
+        return (this._list
+            .filter((item) => item instanceof entity_base_1.EntityBase)
+            .find((item) => item._id === id || item.id === id) ??
+            null);
+    }
+    findByValue(value) {
+        return this._list.find((item) => item === value) ?? null;
+    }
+    setList(list) {
+        this._list = this.mapInternalIdIfIsEmpty(list);
+        return this;
+    }
+    add(item) {
+        if (this.contains(item)) {
+            this._list[this.indexOf(item)] = item;
+            if (!this.contains(item, this._updatedItemsList)) {
+                this._updatedItemsList.push(item);
+            }
+            return;
+        }
+        this._list.push(item);
+        this._addedItemsList.push(item);
+        return this;
+    }
+    remove(item) {
+        const index = this.indexOf(item);
+        if (index > -1) {
+            this._list.splice(index, 1);
+            if (!this.contains(item, this._removedItemsList)) {
+                this._removedItemsList.push(item);
+            }
+        }
+        return this;
+    }
+    update(items) {
+        items = this.mapInternalIdIfIsEmpty(items);
+        items.forEach((item) => this.add(item));
+        this._list
+            .filter((item) => !this.contains(item, items))
+            .forEach((item) => this.remove(item));
+        return this;
+    }
+    clear() {
+        this._addedItemsList = [];
+        this._updatedItemsList = [];
+        this._removedItemsList = this._list;
+        this._list = [];
+        return this;
+    }
+    forEach(callback) {
+        this._list.forEach(callback);
+        return this;
+    }
+    async forEachAsync(callback) {
+        return Promise.all(this._list.map(callback)).then(() => this);
+    }
+    map(callback) {
+        const mappedItems = this._list.map(callback);
+        const list = new List();
+        list.setList(mappedItems);
+        return list;
+    }
+    async mapAsync(callback) {
+        return Promise.all(this._list.map(callback)).then((mappedItems) => {
+            const mappedList = new List();
+            mappedList.setList(mappedItems);
+            return mappedList;
+        });
+    }
+    filter(callback) {
+        const filteredItems = this._list.filter(callback);
+        const list = new List();
+        list.setList(filteredItems);
+        return list;
+    }
+    async filterAsync(callback) {
+        return Promise.all(this._list.filter(callback))
+            .then((list) => list.filter((item) => item))
+            .then((filteredItems) => {
+            const list = new List();
+            list.setList(filteredItems);
+            return list;
+        });
+    }
+    find(callback) {
+        return this._list.find(callback) ?? null;
+    }
+    toArray(type) {
+        switch (type) {
+            case 'added':
+                return this._addedItemsList;
+            case 'updated':
+                return this._updatedItemsList;
+            case 'removed':
+                return this._removedItemsList;
+            default:
+                return this._list;
+        }
+    }
+}
+exports.List = List;

package/core/utils/promise-all.d.ts

@@ -0,0 +1,7 @@
+type PromisesResponseType<T> = {
+    [K in keyof T]: Awaited<T[K]>;
+};
+export declare class Promises {
+    static result<T>(requests: T): Promise<PromisesResponseType<T>>;
+}
+export {};

package/core/utils/promise-all.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Promises = void 0;
+class Promises {
+    static async result(requests) {
+        const promises = [];
+        Object.values(requests).forEach((promise) => promises.push(promise));
+        return Promise.all(promises).then((result) => {
+            let currentIndex = 0;
+            const response = {};
+            Object.keys(requests).forEach((propName) => {
+                response[propName] = result[currentIndex];
+                currentIndex++;
+            });
+            return response;
+        });
+    }
+}
+exports.Promises = Promises;

package/core/utils/set-mask-document-number.d.ts

@@ -0,0 +1 @@
+export declare function setMaskDocumentNumber(document?: string): string;

package/core/utils/set-mask-document-number.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMaskDocumentNumber = setMaskDocumentNumber;
+const KlString_1 = require("@koalarx/utils/KlString");
+function setMaskDocumentNumber(document) {
+    if (!document) {
+        return '';
+    }
+    const documentWithoutMask = document.replace(/[^0-9]/g, '');
+    return documentWithoutMask.length === 11
+        ? (0, KlString_1.maskCpf)(documentWithoutMask)
+        : (0, KlString_1.maskCnpj)(documentWithoutMask);
+}

package/core/validators/file-validator.d.ts

@@ -0,0 +1,27 @@
+import { FileValidator } from '@nestjs/common';
+import { FileType } from '..';
+type FileTypeInternal = FileType | FileType[] | Record<string, FileType[]>;
+export declare class FileSizeValidator extends FileValidator {
+    private maxSizeBytes;
+    private multiple;
+    private errorFileName;
+    constructor(args: {
+        maxSizeBytes: number;
+        multiple: boolean;
+    });
+    isValid(file?: FileTypeInternal): Promise<boolean>;
+    buildErrorMessage(file: any): string;
+}
+export declare class FileTypeValidator extends FileValidator {
+    private multiple;
+    private errorFileName;
+    private filetype;
+    constructor(args: {
+        multiple: boolean;
+        filetype: RegExp | string;
+    });
+    isMimeTypeValid(file: FileType): boolean;
+    isValid(file?: FileTypeInternal): Promise<boolean>;
+    buildErrorMessage(file: any): string;
+}
+export {};