@koalarx/nest 0.0.3

package/common/mediator/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/common/mediator/request-validator.base.d.ts

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

package/common/mediator/request-validator.base.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidatorBase = void 0;
+class RequestValidatorBase {
+    _request;
+    constructor(_request) {
+        this._request = _request;
+    }
+    validate() {
+        const requestParsed = this.schema.safeParse(this._request);
+        if (requestParsed.success) {
+            return requestParsed.data;
+        }
+        throw requestParsed.error;
+    }
+}
+exports.RequestValidatorBase = RequestValidatorBase;

package/common/models/pagination-params.d.ts

@@ -0,0 +1,14 @@
+export type QueryDirectionType = 'asc' | 'desc';
+export declare const QueryFilterParams: {
+    direction: QueryDirectionType;
+    page: number;
+    limit: number;
+};
+export declare class PaginationParams {
+    page?: number;
+    limit?: number;
+    orderBy?: string;
+    direction?: QueryDirectionType;
+    skip(): number;
+    generateOrderBy(): {} | undefined;
+}

package/common/models/pagination-params.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationParams = exports.QueryFilterParams = void 0;
+const swagger_1 = require("@nestjs/swagger");
+exports.QueryFilterParams = {
+    direction: 'asc',
+    page: 0,
+    limit: 30,
+};
+class PaginationParams {
+    page = exports.QueryFilterParams.page;
+    limit = exports.QueryFilterParams.limit;
+    orderBy;
+    direction = exports.QueryFilterParams.direction;
+    skip() {
+        return (this.limit ?? 0) * (this.page ?? exports.QueryFilterParams.page);
+    }
+    generateOrderBy() {
+        if (this.orderBy) {
+            const orderByField = this.orderBy.split('.');
+            return orderByField.reduceRight((acc, item, index) => ({
+                [item]: index === orderByField.length - 1 ? this.direction : acc,
+            }), {});
+        }
+        return undefined;
+    }
+}
+exports.PaginationParams = PaginationParams;
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        format: 'int32',
+        default: exports.QueryFilterParams.page,
+    })
+], PaginationParams.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        format: 'int32',
+        default: exports.QueryFilterParams.limit,
+    })
+], PaginationParams.prototype, "limit", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+    })
+], PaginationParams.prototype, "orderBy", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        required: false,
+        enum: ['asc', 'desc'],
+        default: exports.QueryFilterParams.direction,
+    })
+], PaginationParams.prototype, "direction", void 0);

package/core/database/entity.d.ts

@@ -0,0 +1,8 @@
+import { Optional } from '../@types';
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
+export type EntityProps<T extends IComparable<T>> = Omit<Optional<T, 'id'>, 'equals'>;
+export declare abstract class Entity<T extends IComparable<T>> implements IComparable<T> {
+    id: IComparableId;
+    protected create(props: EntityProps<T>): void;
+    equals(obj: Entity<T>): boolean;
+}

package/core/database/entity.js

@@ -0,0 +1,23 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const automapper_classes_1 = require("automapper-classes");
+class Entity {
+    id;
+    create(props) {
+        Object.assign(this, props);
+    }
+    equals(obj) {
+        return obj.id === this.id;
+    }
+}
+exports.Entity = Entity;
+__decorate([
+    (0, automapper_classes_1.AutoMap)()
+], Entity.prototype, "id", void 0);

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

@@ -0,0 +1,16 @@
+import { PaginationParams } from '../../common/models/pagination-params';
+import { PrismaClientWithCustomTransaction } from '../../services/prisma/prisma-client-with-custom-transaction.interface';
+import { PrismaTransactionalClient } from '../../services/prisma/prisma-transactional-client';
+import { Entity } from './entity';
+export interface FindAllProps<TPaginateAndOrdering extends PaginationParams, TWhere, TInclude = any> {
+    where: TWhere;
+    paginateAndOrderingProps?: TPaginateAndOrdering;
+    include?: TInclude;
+}
+export declare abstract class RepositoryBase<TEntity extends Entity<TEntity>> {
+    protected prisma: PrismaClientWithCustomTransaction;
+    private readonly _modelName;
+    constructor(prisma: PrismaClientWithCustomTransaction, _modelName: string);
+    withTransaction(fn: (prisma: PrismaTransactionalClient) => Promise<any>): Promise<any>;
+    protected repository(transactionalClient?: PrismaTransactionalClient): import(".prisma/client").Prisma.TestDelegate<import("@prisma/client/runtime/library").DefaultArgs>;
+}

package/core/database/repository.base.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryBase = void 0;
+const prisma_transactional_client_1 = require("../../services/prisma/prisma-transactional-client");
+const prisma_types_1 = require("../../services/prisma/prisma.types");
+class RepositoryBase {
+    prisma;
+    _modelName;
+    constructor(prisma, _modelName) {
+        this.prisma = prisma;
+        this._modelName = _modelName;
+    }
+    withTransaction(fn) {
+        return this.prisma.withTransaction(async (client) => {
+            return fn(new prisma_transactional_client_1.PrismaTransactionalClient(client));
+        });
+    }
+    repository(transactionalClient) {
+        const modelName = this._modelName;
+        const prisma = (transactionalClient ?? this.prisma);
+        const repository = (0, prisma_types_1.getPrismaDelegate)(modelName, prisma);
+        if (!repository)
+            throw new Error('Entidade não mapeada no repositório do prisma');
+        return repository;
+    }
+}
+exports.RepositoryBase = RepositoryBase;

package/core/koala-app.d.ts

@@ -0,0 +1,40 @@
+import { INestApplication, Type } from '@nestjs/common';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { CronJob } from '../common/backgroud-services/cron-service/cron-job';
+import { EventHandler } from '../common/backgroud-services/event-service/event-handler';
+interface ApiDocConfig {
+    endpoint: string;
+    title: string;
+    description?: string;
+    externalDoc?: {
+        message: string;
+        url: string;
+    };
+    version: string;
+    accessDocWithCredentials?: {
+        username: string;
+        password: string;
+    };
+    withAuthorization?: boolean;
+}
+type CronJobClass = string | symbol | Function | Type<CronJob>;
+export declare class KoalaApp {
+    private readonly app;
+    private _globalExceptionFilter;
+    private _prismaValidationExceptionFilter;
+    private _domainExceptionFilter;
+    private _zodExceptionFilter;
+    private _cronJobs;
+    private _eventJobs;
+    constructor(app: INestApplication<any>);
+    addCronJob(job: CronJobClass): this;
+    addEventJob(eventJob: EventHandler<any>): this;
+    addCustomGlobalExceptionFilter(filter: BaseExceptionFilter): this;
+    addCustomPrismaValidationExceptionFilter(filter: BaseExceptionFilter): this;
+    addCustomDomainExceptionFilter(filter: BaseExceptionFilter): this;
+    addCustomZodExceptionFilter(filter: BaseExceptionFilter): this;
+    includeSwagger(config: ApiDocConfig): this;
+    enableCors(): this;
+    build(): Promise<INestApplication<any>>;
+}
+export {};

package/core/koala-app.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaApp = void 0;
+const core_1 = require("@nestjs/core");
+const swagger_1 = require("@nestjs/swagger");
+const express_basic_auth_1 = require("express-basic-auth");
+const domain_errors_filter_1 = require("../filters/domain-errors.filter");
+const global_exception_filter_1 = require("../filters/global-exception.filter");
+const prisma_validation_exception_filter_1 = require("../filters/prisma-validation-exception.filter");
+const zod_errors_filter_1 = require("../filters/zod-errors.filter");
+const env_config_1 = require("./utils/env.config");
+class KoalaApp {
+    app;
+    _globalExceptionFilter;
+    _prismaValidationExceptionFilter;
+    _domainExceptionFilter;
+    _zodExceptionFilter;
+    _cronJobs = [];
+    _eventJobs = [];
+    constructor(app) {
+        this.app = app;
+        const { httpAdapter } = app.get(core_1.HttpAdapterHost);
+        this._globalExceptionFilter = new global_exception_filter_1.GlobalExceptionsFilter(httpAdapter);
+        this._prismaValidationExceptionFilter =
+            new prisma_validation_exception_filter_1.PrismaValidationExceptionFilter();
+        this._domainExceptionFilter = new domain_errors_filter_1.DomainErrorsFilter();
+        this._zodExceptionFilter = new zod_errors_filter_1.ZodErrorsFilter();
+    }
+    addCronJob(job) {
+        this._cronJobs.push(job);
+        return this;
+    }
+    addEventJob(eventJob) {
+        this._eventJobs.push(eventJob);
+        return this;
+    }
+    addCustomGlobalExceptionFilter(filter) {
+        this._globalExceptionFilter = filter;
+        return this;
+    }
+    addCustomPrismaValidationExceptionFilter(filter) {
+        this._prismaValidationExceptionFilter = filter;
+        return this;
+    }
+    addCustomDomainExceptionFilter(filter) {
+        this._domainExceptionFilter = filter;
+        return this;
+    }
+    addCustomZodExceptionFilter(filter) {
+        this._zodExceptionFilter = filter;
+        return this;
+    }
+    includeSwagger(config) {
+        if (env_config_1.EnvConfig.isEnvDevelop && config.accessDocWithCredentials) {
+            this.app.use([config.endpoint], (0, express_basic_auth_1.default)({
+                challenge: true,
+                users: {
+                    [config.accessDocWithCredentials.username]: config.accessDocWithCredentials.password,
+                },
+            }));
+        }
+        const documentBuilder = new swagger_1.DocumentBuilder()
+            .setTitle(config.title)
+            .setVersion(config.version);
+        if (config.description) {
+            documentBuilder.setDescription(config.description);
+        }
+        if (config.externalDoc) {
+            documentBuilder.setExternalDoc(config.externalDoc.message, config.externalDoc.url);
+        }
+        if (config.withAuthorization) {
+            documentBuilder.addBearerAuth();
+        }
+        const document = swagger_1.SwaggerModule.createDocument(this.app, documentBuilder.build());
+        const swaggerEndpoint = config.endpoint;
+        swagger_1.SwaggerModule.setup(swaggerEndpoint, this.app, document);
+        return this;
+    }
+    enableCors() {
+        this.app.enableCors({
+            credentials: true,
+            origin: true,
+            optionsSuccessStatus: 200,
+        });
+        return this;
+    }
+    async build() {
+        this.app.useGlobalFilters(this._globalExceptionFilter, this._prismaValidationExceptionFilter, this._domainExceptionFilter, this._zodExceptionFilter);
+        Promise.all(this._cronJobs.map((job) => this.app.resolve(job))).then((cronJobs) => cronJobs.forEach((job) => job.run()));
+        this._eventJobs.forEach((eventJob) => eventJob.setupSubscriptions());
+        return this.app;
+    }
+}
+exports.KoalaApp = KoalaApp;

package/core/koala-nest-database.module.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule, InjectionToken, Type } from '@nestjs/common';
+import { RepositoryBase } from '../core/database/repository.base';
+export interface KoalaNestDatabaseRepositoryConfig {
+    interface: InjectionToken;
+    class: Type<RepositoryBase<any>>;
+}
+interface KoalaNestDatabaseModuleConfig {
+    repositories?: KoalaNestDatabaseRepositoryConfig[];
+}
+export declare class KoalaNestDatabaseModule {
+    static forRoot(config: KoalaNestDatabaseModuleConfig): DynamicModule;
+}
+export {};

package/core/koala-nest-database.module.js

@@ -0,0 +1,37 @@
+"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 KoalaNestDatabaseModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaNestDatabaseModule = void 0;
+const common_1 = require("@nestjs/common");
+const env_service_1 = require("../services/env/env.service");
+const prisma_service_1 = require("../services/prisma/prisma.service");
+let KoalaNestDatabaseModule = exports.KoalaNestDatabaseModule = KoalaNestDatabaseModule_1 = class KoalaNestDatabaseModule {
+    static forRoot(config) {
+        return {
+            module: KoalaNestDatabaseModule_1,
+            providers: config.repositories?.map((repository) => ({
+                provide: repository.interface,
+                useClass: repository.class,
+            })),
+            exports: config.repositories?.map((repository) => repository.interface),
+        };
+    }
+};
+exports.KoalaNestDatabaseModule = KoalaNestDatabaseModule = KoalaNestDatabaseModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [
+            {
+                provide: 'PRISMA_SERVICE_TOKEN',
+                useClass: prisma_service_1.PrismaService,
+            },
+            env_service_1.EnvService,
+        ],
+        exports: ['PRISMA_SERVICE_TOKEN'],
+    })
+], KoalaNestDatabaseModule);

package/core/koala-nest-http.module.d.ts

@@ -0,0 +1,12 @@
+import { DynamicModule, MiddlewareConsumer, NestMiddleware, NestModule, Provider, Type } from '@nestjs/common';
+import { AutomapperProfile } from 'automapper-nestjs';
+interface KoalaNestHttpModuleConfig {
+    automapperProfile: Provider<AutomapperProfile>;
+    middlewares: Type<NestMiddleware>[];
+}
+export declare class KoalaNestHttpModule implements NestModule {
+    private static _config;
+    static forRoot(config: KoalaNestHttpModuleConfig): DynamicModule;
+    configure(consumer: MiddlewareConsumer): void;
+}
+export {};

package/core/koala-nest-http.module.js

@@ -0,0 +1,38 @@
+"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 KoalaNestHttpModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaNestHttpModule = void 0;
+const common_1 = require("@nestjs/common");
+const automapper_classes_1 = require("automapper-classes");
+const automapper_nestjs_1 = require("automapper-nestjs");
+const env_service_1 = require("../services/env/env.service");
+let KoalaNestHttpModule = exports.KoalaNestHttpModule = class KoalaNestHttpModule {
+    static { KoalaNestHttpModule_1 = this; }
+    static _config;
+    static forRoot(config) {
+        this._config = config;
+        return {
+            module: KoalaNestHttpModule_1,
+            providers: [config.automapperProfile],
+        };
+    }
+    configure(consumer) {
+        KoalaNestHttpModule_1._config.middlewares.forEach((middleware) => consumer.apply(middleware).forRoutes('*'));
+    }
+};
+exports.KoalaNestHttpModule = KoalaNestHttpModule = KoalaNestHttpModule_1 = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            automapper_nestjs_1.AutomapperModule.forRoot({
+                strategyInitializer: (0, automapper_classes_1.classes)(),
+            }),
+        ],
+        providers: [env_service_1.EnvService],
+    })
+], KoalaNestHttpModule);

package/core/koala-nest.module.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule, Provider } from '@nestjs/common';
+import { ZodType } from 'zod';
+import { ILoggingService } from '../services/logging/ilogging.service';
+import { KoalaNestDatabaseRepositoryConfig } from './koala-nest-database.module';
+interface KoalaNestModuleConfig {
+    logging?: Provider<ILoggingService>;
+    env?: ZodType;
+    repositories?: KoalaNestDatabaseRepositoryConfig[];
+}
+export declare class KoalaNestModule {
+    static forRoot({ env, logging, repositories, }: KoalaNestModuleConfig): DynamicModule;
+}
+export {};

package/core/koala-nest.module.js

@@ -0,0 +1,52 @@
+"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 KoalaNestModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaNestModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const env_1 = require("../services/env/env");
+const env_service_1 = require("../services/env/env.service");
+const ilogging_service_1 = require("../services/logging/ilogging.service");
+const logging_service_1 = require("../services/logging/logging.service");
+const iredis_service_1 = require("../services/redis/iredis.service");
+const redis_service_1 = require("../services/redis/redis.service");
+const ired_lock_service_1 = require("../services/redlock/ired-lock.service");
+const red_lock_service_1 = require("../services/redlock/red-lock.service");
+const koala_nest_database_module_1 = require("./koala-nest-database.module");
+let KoalaNestModule = exports.KoalaNestModule = KoalaNestModule_1 = class KoalaNestModule {
+    static forRoot({ env, logging, repositories, }) {
+        return {
+            module: KoalaNestModule_1,
+            imports: [
+                config_1.ConfigModule.forRoot({
+                    validate: (envData) => (env ?? env_1.envSchema).parse(envData),
+                    isGlobal: true,
+                }),
+                koala_nest_database_module_1.KoalaNestDatabaseModule.forRoot({
+                    repositories,
+                }),
+            ],
+            providers: [
+                {
+                    provide: ilogging_service_1.ILoggingService,
+                    useValue: logging ?? logging_service_1.LoggingService,
+                },
+            ],
+        };
+    }
+};
+exports.KoalaNestModule = KoalaNestModule = KoalaNestModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [
+            { provide: iredis_service_1.IRedisService, useClass: redis_service_1.RedisService },
+            { provide: ired_lock_service_1.IRedLockService, useClass: red_lock_service_1.RedLockService },
+            env_service_1.EnvService,
+        ],
+    })
+], KoalaNestModule);

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/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,24 @@
+import { IComparableId } from './interfaces/icomparable';
+export type ListActionType = 'added' | 'updated' | 'removed';
+export declare class List<T> {
+    private _list;
+    private _addedItemsList;
+    private _updatedItemsList;
+    private _removedItemsList;
+    constructor(list?: T[]);
+    get length(): number;
+    findById(id: IComparableId): T | null;
+    findByValue(value: any): T | null;
+    add(item: T): void;
+    remove(item: T): void;
+    clear(): void;
+    forEach(callback: (item: T, index: number) => void): void;
+    forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<void[]>;
+    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>>;
+    toArray(type?: ListActionType): T[];
+    private indexOf;
+    private contains;
+}