@koalarx/nest 3.0.3 → 3.0.5

package/core/backgroud-services/cron-service/cron-job.handler.base.d.ts

@@ -0,0 +1,16 @@
+import { ILoggingService } from '../../../services/logging/ilogging.service';
+import { IRedLockService } from '../../../services/redlock/ired-lock.service';
+import { RequestResult } from '../../request-overflow/request-result';
+export type CronJobResponse = RequestResult<Error, null>;
+export interface CronJobSettings {
+    isActive: boolean;
+    timeInMinutes: number;
+}
+export declare abstract class CronJobHandlerBase {
+    private readonly redlockService;
+    private readonly loggingService;
+    constructor(redlockService: IRedLockService, loggingService: ILoggingService);
+    protected abstract run(): Promise<CronJobResponse>;
+    protected abstract settings(): Promise<CronJobSettings>;
+    start(): Promise<void>;
+}

package/core/backgroud-services/cron-service/cron-job.handler.base.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJobHandlerBase = void 0;
+const KlDelay_1 = require("@koalarx/utils/KlDelay");
+const koala_global_vars_1 = require("../../koala-global-vars");
+class CronJobHandlerBase {
+    redlockService;
+    loggingService;
+    constructor(redlockService, loggingService) {
+        this.redlockService = redlockService;
+        this.loggingService = loggingService;
+    }
+    async start() {
+        const name = this.constructor.name;
+        while (true) {
+            const settings = await this.settings();
+            const timeout = settings.timeInMinutes * 60 * 1000;
+            if (settings.isActive) {
+                const ttlSecondsLock = timeout / 1000;
+                const acquiredLock = await this.redlockService.acquiredLock(name, ttlSecondsLock);
+                if (acquiredLock) {
+                    const error = await this.run()
+                        .then((result) => {
+                        if (result.isFailure()) {
+                            return result.value;
+                        }
+                        return null;
+                    })
+                        .catch((error) => error);
+                    if (error) {
+                        try {
+                            await this.loggingService.report({
+                                error,
+                                packageName: koala_global_vars_1.KoalaGlobalVars.appName,
+                                loggedUsername: koala_global_vars_1.KoalaGlobalVars.internalUserName,
+                            });
+                        }
+                        catch {
+                            console.error(error);
+                        }
+                    }
+                }
+            }
+            await (0, KlDelay_1.delay)(timeout);
+            await this.redlockService.releaseLock(name);
+        }
+    }
+}
+exports.CronJobHandlerBase = CronJobHandlerBase;

package/core/backgroud-services/event-service/event-class.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class EventClass<TEntity = any> {
+    data?: TEntity | undefined;
+    ocurredAt: Date;
+    constructor(data?: TEntity | undefined);
+}

package/core/backgroud-services/event-service/event-class.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventClass = void 0;
+class EventClass {
+    data;
+    ocurredAt = new Date();
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.EventClass = EventClass;

package/core/backgroud-services/event-service/event-handler.base.d.ts

@@ -0,0 +1,8 @@
+import { Type } from '@nestjs/common';
+import { EventClass } from './event-class';
+export declare abstract class EventHandlerBase {
+    readonly event: Type<EventClass>;
+    constructor(event: Type<EventClass>);
+    setupSubscriptions(): void;
+    abstract handleEvent(event: InstanceType<this['event']>): Promise<void>;
+}

package/core/backgroud-services/event-service/event-handler.base.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandlerBase = void 0;
+const event_queue_1 = require("./event-queue");
+class EventHandlerBase {
+    event;
+    constructor(event) {
+        this.event = event;
+    }
+    setupSubscriptions() {
+        event_queue_1.EventQueue.register(this.handleEvent.bind(this), this.constructor.name, this.event.name);
+    }
+}
+exports.EventHandlerBase = EventHandlerBase;

package/core/backgroud-services/event-service/event-is-trigger.d.ts

@@ -0,0 +1,3 @@
+export declare class EventIsTrigger {
+    isTrigger(): void;
+}

package/core/backgroud-services/event-service/event-is-trigger.js

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

package/core/backgroud-services/event-service/event-job.d.ts

@@ -0,0 +1,13 @@
+import { Type } from '@nestjs/common';
+import { EventClass } from './event-class';
+import { EventHandlerBase } from './event-handler.base';
+import { EventQueue } from './event-queue';
+export declare abstract class EventJob<TEntity> {
+    _id: `${string}-${string}-${string}-${string}-${string}`;
+    private _eventQueue;
+    constructor();
+    abstract defineHandlers(): Array<Type<EventHandlerBase>>;
+    get eventQueue(): EventQueue[];
+    clearQueue(): void;
+    addEvent(event: EventClass<TEntity>): void;
+}

package/core/backgroud-services/event-service/event-job.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventJob = void 0;
+const event_queue_1 = require("./event-queue");
+const node_crypto_1 = require("node:crypto");
+class EventJob {
+    _id = (0, node_crypto_1.randomUUID)();
+    _eventQueue = [];
+    constructor() { }
+    get eventQueue() {
+        return this._eventQueue;
+    }
+    clearQueue() {
+        this._eventQueue = [];
+    }
+    addEvent(event) {
+        this.eventQueue.push(event);
+        event_queue_1.EventQueue.markAggregateForDispatch(this);
+    }
+}
+exports.EventJob = EventJob;

package/core/backgroud-services/event-service/event-queue.d.ts

@@ -0,0 +1,17 @@
+import { IComparableId } from '../../../core/utils/interfaces/icomparable';
+import { EventJob } from './event-job';
+type EventJobCallback = (event: any) => void;
+export declare class EventQueue {
+    private static handlersMap;
+    private static markedAggregates;
+    static markAggregateForDispatch(aggregate: EventJob<any>): void;
+    static dispatchEventsForAggregate(id: IComparableId): void;
+    static register(callback: EventJobCallback, handlerClassName: string, eventClassName: string): void;
+    static clearHandlers(): void;
+    static clearMarkedAggregates(): void;
+    private static dispatchAggregateEvents;
+    private static removeAggregateFromMarkedDispatchList;
+    private static findMarkedAggregateByID;
+    private static dispatch;
+}
+export {};

package/core/backgroud-services/event-service/event-queue.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueue = void 0;
+class EventQueue {
+    static handlersMap = {};
+    static markedAggregates = [];
+    static markAggregateForDispatch(aggregate) {
+        const aggregateFound = !!this.findMarkedAggregateByID(aggregate._id);
+        if (!aggregateFound) {
+            this.markedAggregates.push(aggregate);
+        }
+    }
+    static dispatchEventsForAggregate(id) {
+        const aggregate = this.findMarkedAggregateByID(id);
+        if (aggregate) {
+            this.dispatchAggregateEvents(aggregate);
+            aggregate.clearQueue();
+            this.removeAggregateFromMarkedDispatchList(aggregate);
+        }
+    }
+    static register(callback, handlerClassName, eventClassName) {
+        const wasEventRegisteredBefore = handlerClassName in this.handlersMap;
+        if (!wasEventRegisteredBefore) {
+            this.handlersMap[handlerClassName] = [];
+        }
+        this.handlersMap[handlerClassName].push({
+            eventClassName,
+            callback,
+        });
+    }
+    static clearHandlers() {
+        this.handlersMap = {};
+    }
+    static clearMarkedAggregates() {
+        this.markedAggregates = [];
+    }
+    static dispatchAggregateEvents(aggregate) {
+        aggregate.eventQueue.forEach((event) => this.dispatch(event));
+    }
+    static removeAggregateFromMarkedDispatchList(aggregate) {
+        const index = this.markedAggregates.findIndex((a) => a._id === aggregate._id);
+        this.markedAggregates.splice(index, 1);
+    }
+    static findMarkedAggregateByID(id) {
+        return this.markedAggregates.find((aggregate) => aggregate._id === id);
+    }
+    static dispatch(event) {
+        const eventJobHandlers = this.markedAggregates.find((a) => a.eventQueue.find((e) => e === event));
+        const eventHandler = Object.keys(this.handlersMap).find((handlerName) => eventJobHandlers
+            ?.defineHandlers()
+            .find((handler) => handler.name === handlerName &&
+            this.handlersMap[handler.name].some((job) => job.eventClassName === event.constructor.name)));
+        const isEventRegistered = !!eventHandler;
+        if (isEventRegistered) {
+            const jobs = this.handlersMap[eventHandler];
+            for (const job of jobs) {
+                job.callback(event);
+            }
+        }
+    }
+}
+exports.EventQueue = EventQueue;

package/core/constants/query-params.d.ts

@@ -0,0 +1,6 @@
+import type { QueryDirectionType } from '..';
+export declare const QUERY_FILTER_PARAMS: {
+    direction: QueryDirectionType;
+    page: number;
+    limit: number;
+};

package/core/constants/query-params.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUERY_FILTER_PARAMS = void 0;
+exports.QUERY_FILTER_PARAMS = {
+    direction: 'asc',
+    page: 0,
+    limit: 30,
+};

package/core/controllers/base.controller.d.ts

@@ -0,0 +1,4 @@
+import { Response as HttpResponse } from 'express';
+export declare abstract class IController<Request, Response, Params = any> {
+    abstract handle(request: Request, params?: Params, response?: HttpResponse): Promise<Response>;
+}

package/core/controllers/base.controller.js

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

package/core/controllers/controller.decorator.d.ts

@@ -0,0 +1,2 @@
+import { RouterConfigBase } from './router-config.base';
+export declare function Controller(config: RouterConfigBase): (target: any) => void;

package/core/controllers/controller.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = Controller;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+function Controller(config) {
+    return function (target) {
+        (0, common_1.Controller)(config.group)(target);
+        (0, swagger_1.ApiTags)(config.tag)(target);
+    };
+}

package/core/controllers/created-registre-response.base.d.ts

@@ -0,0 +1,10 @@
+import { IComparableId } from '../../core/utils/interfaces/icomparable';
+export declare abstract class CreatedRegistreResponseBase<TId = IComparableId> {
+    id: TId;
+}
+export declare abstract class CreatedRegistreWithUUIDResponse extends CreatedRegistreResponseBase<string> {
+    id: string;
+}
+export declare abstract class CreatedRegistreWithIdResponse extends CreatedRegistreResponseBase<number> {
+    id: number;
+}

package/core/controllers/created-registre-response.base.js

@@ -0,0 +1,35 @@
+"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.CreatedRegistreWithIdResponse = exports.CreatedRegistreWithUUIDResponse = exports.CreatedRegistreResponseBase = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class CreatedRegistreResponseBase {
+    id;
+}
+exports.CreatedRegistreResponseBase = CreatedRegistreResponseBase;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Object)
+], CreatedRegistreResponseBase.prototype, "id", void 0);
+class CreatedRegistreWithUUIDResponse extends CreatedRegistreResponseBase {
+}
+exports.CreatedRegistreWithUUIDResponse = CreatedRegistreWithUUIDResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: 'string', format: 'uuid' }),
+    __metadata("design:type", String)
+], CreatedRegistreWithUUIDResponse.prototype, "id", void 0);
+class CreatedRegistreWithIdResponse extends CreatedRegistreResponseBase {
+}
+exports.CreatedRegistreWithIdResponse = CreatedRegistreWithIdResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: 'integer', format: 'int32' }),
+    __metadata("design:type", Number)
+], CreatedRegistreWithIdResponse.prototype, "id", void 0);

package/core/controllers/list-response.base.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class ListResponseBase<TResponse> {
+    abstract items: Array<TResponse>;
+    count: number;
+}

package/core/controllers/list-response.base.js

@@ -0,0 +1,21 @@
+"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.ListResponseBase = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class ListResponseBase {
+    count;
+}
+exports.ListResponseBase = ListResponseBase;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], ListResponseBase.prototype, "count", void 0);

package/core/controllers/pagination.request.d.ts

@@ -0,0 +1,10 @@
+import type { QueryDirectionType } from '..';
+export type PaginatedRequestProps<T extends PaginationRequest> = Omit<{
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+}, '_id'>;
+export declare class PaginationRequest {
+    page?: number;
+    limit?: number;
+    orderBy?: string;
+    direction?: QueryDirectionType;
+}

package/core/controllers/pagination.request.js

@@ -0,0 +1,56 @@
+"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.PaginationRequest = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const auto_mapping_decorator_1 = require("../mapping/auto-mapping.decorator");
+const query_params_1 = require("../constants/query-params");
+class PaginationRequest {
+    page = query_params_1.QUERY_FILTER_PARAMS.page;
+    limit = query_params_1.QUERY_FILTER_PARAMS.limit;
+    orderBy;
+    direction = query_params_1.QUERY_FILTER_PARAMS.direction;
+}
+exports.PaginationRequest = PaginationRequest;
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        format: 'int32',
+        default: query_params_1.QUERY_FILTER_PARAMS.page,
+    }),
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Number)
+], PaginationRequest.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        format: 'int32',
+        default: query_params_1.QUERY_FILTER_PARAMS.limit,
+    }),
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Number)
+], PaginationRequest.prototype, "limit", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+    }),
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", String)
+], PaginationRequest.prototype, "orderBy", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        enum: ['asc', 'desc'],
+        default: query_params_1.QUERY_FILTER_PARAMS.direction,
+    }),
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", String)
+], PaginationRequest.prototype, "direction", void 0);

package/core/controllers/router-config.base.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class RouterConfigBase {
+    private readonly _tag;
+    private readonly _group;
+    protected constructor(_tag: string, _group: string);
+    get group(): string;
+    get tag(): string;
+}

package/core/controllers/router-config.base.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterConfigBase = void 0;
+class RouterConfigBase {
+    _tag;
+    _group;
+    constructor(_tag, _group) {
+        this._tag = _tag;
+        this._group = _group;
+    }
+    get group() {
+        return this._group;
+    }
+    get tag() {
+        return this._tag;
+    }
+}
+exports.RouterConfigBase = RouterConfigBase;

package/core/controllers/schemas/boolean.schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare function booleanSchema(): z.ZodEffects<z.ZodString, boolean | undefined, string>;

package/core/controllers/schemas/boolean.schema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanSchema = booleanSchema;
+const zod_1 = require("zod");
+function booleanSchema() {
+    return zod_1.z.coerce.string().transform((value) => {
+        if (value !== undefined) {
+            return value === 'true';
+        }
+        return undefined;
+    });
+}

package/core/controllers/schemas/document-number.schema.d.ts

@@ -0,0 +1 @@
+export declare function documentNumberSchema(value: string): boolean;

package/core/controllers/schemas/document-number.schema.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentNumberSchema = documentNumberSchema;
+const KlString_1 = require("@koalarx/utils/KlString");
+function documentNumberSchema(value) {
+    if (value !== '' && value !== 'undefined' && value !== 'null') {
+        if (value.includes('.')) {
+            if (value.length === 14) {
+                return (0, KlString_1.validateCpf)(value);
+            }
+            else if (value.length === 18) {
+                return (0, KlString_1.validateCnpj)(value);
+            }
+        }
+        else {
+            if (value.length === 11) {
+                return (0, KlString_1.validateCpf)(value);
+            }
+            else if (value.length === 14) {
+                return (0, KlString_1.validateCnpj)(value);
+            }
+        }
+        return false;
+    }
+    return true;
+}

package/core/controllers/schemas/email.schema.d.ts

@@ -0,0 +1 @@
+export declare function emailSchema(email?: string, isRequired?: boolean): string | boolean;

package/core/controllers/schemas/email.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emailSchema = emailSchema;
+const zod_1 = require("zod");
+function emailSchema(email, isRequired = false) {
+    if (isRequired && !email) {
+        return false;
+    }
+    if (!email) {
+        return true;
+    }
+    return zod_1.z.coerce.string().max(50).email().parse(email);
+}

package/core/controllers/schemas/list-query.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const LIST_QUERY_SCHEMA: z.ZodObject<{
+    page: z.ZodOptional<z.ZodEffects<z.ZodNumber, number, number>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    orderBy: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodDefault<z.ZodEnum<["asc", "desc"]>>>;
+}, "strip", z.ZodTypeAny, {
+    page?: number | undefined;
+    limit?: number | undefined;
+    orderBy?: string | undefined;
+    direction?: "asc" | "desc" | undefined;
+}, {
+    page?: number | undefined;
+    limit?: number | undefined;
+    orderBy?: string | undefined;
+    direction?: "asc" | "desc" | undefined;
+}>;

package/core/controllers/schemas/list-query.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_QUERY_SCHEMA = void 0;
+const zod_1 = require("zod");
+const query_params_1 = require("../../constants/query-params");
+exports.LIST_QUERY_SCHEMA = zod_1.z.object({
+    page: zod_1.z.coerce
+        .number()
+        .transform((value) => {
+        if (value) {
+            return value - 1;
+        }
+        return query_params_1.QUERY_FILTER_PARAMS.page;
+    })
+        .optional(),
+    limit: zod_1.z.coerce.number().default(query_params_1.QUERY_FILTER_PARAMS.limit).optional(),
+    orderBy: zod_1.z.string().optional(),
+    direction: zod_1.z.enum(['asc', 'desc']).default('asc').optional(),
+});

package/core/controllers/schemas/native-enum.schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+interface NativeEnumInterface<TEnum> {
+    isOptional: (value: string) => TEnum[keyof TEnum] | undefined;
+    isRequired: (value: string) => TEnum[keyof TEnum];
+}
+export declare function nativeEnumSchema<TEnum extends z.EnumLike>(nativeEnum: TEnum): NativeEnumInterface<TEnum>;
+export {};

package/core/controllers/schemas/native-enum.schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeEnumSchema = nativeEnumSchema;
+const zod_1 = require("zod");
+function nativeEnumSchema(nativeEnum) {
+    return {
+        isOptional: (value) => {
+            if (value === 'null' || value === '') {
+                return undefined;
+            }
+            return zod_1.z.coerce
+                .number()
+                .transform((value) => {
+                if (value !== undefined) {
+                    return zod_1.z.nativeEnum(nativeEnum).parse(value);
+                }
+                return undefined;
+            })
+                .parse(value);
+        },
+        isRequired: (value) => {
+            return zod_1.z.coerce
+                .number()
+                .transform((value) => zod_1.z.nativeEnum(nativeEnum).parse(value))
+                .parse(value);
+        },
+    };
+}

package/core/controllers/schemas/set-mask-document-number.schema.d.ts

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

package/core/controllers/schemas/set-mask-document-number.schema.js

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

package/core/database/entity.base.d.ts

@@ -0,0 +1,20 @@
+import { Overwrite } from '..';
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
+export declare enum EntityActionType {
+    create = 1,
+    update = 2
+}
+export type EntityProps<T extends IComparable<T>> = Overwrite<Omit<{
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+}, '_id' | '_action'>, {
+    id?: T extends {
+        id: infer U;
+    } ? U : never;
+}>;
+export declare abstract class EntityBase<T extends IComparable<T>> implements IComparable<T> {
+    _id: IComparableId;
+    _action: EntityActionType;
+    constructor(props?: EntityProps<T>);
+    automap(props?: EntityProps<T>): void;
+    equals(obj: EntityBase<T>): boolean;
+}