@koalarx/nest 0.0.9 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "0.0.9",
+  "version": "1.0.0",
   "description": "",
   "repository": {
     "type": "git",
@@ -14,38 +14,21 @@
   "homepage": "https://github.com/igordrangel/koala-nest#readme",
   "types": "./koala-nest.d.ts",
   "peerDependencies": {
-    "@koalarx/utils": "^3.1.3",
-    "@nestjs/common": "10.2.4",
-    "@nestjs/config": "3.0.1",
-    "@nestjs/core": "10.2.4",
-    "@nestjs/jwt": "10.1.1",
-    "@nestjs/mapped-types": "2.0.2",
-    "@nestjs/passport": "10.0.1",
-    "@nestjs/platform-express": "10.2.5",
-    "@nestjs/swagger": "7.1.10",
-    "@prisma/client": "5.3.1",
-    "automapper-classes": "8.7.12",
-    "automapper-core": "8.7.12",
-    "automapper-nestjs": "8.7.12",
-    "bcrypt": "5.1.0",
-    "class-transformer": "0.5.1",
-    "class-validator": "0.14.0",
-    "class-validator-cpf": "1.1.1",
+    "@koalarx/utils": "3.1.3",
+    "@nestjs/common": "11.0.12",
+    "@nestjs/config": "4.0.1",
+    "@nestjs/core": "11.0.12",
+    "@nestjs/mapped-types": "2.1.0",
+    "@nestjs/platform-express": "11.0.12",
+    "@nestjs/swagger": "11.0.7",
+    "@prisma/client": "6.5.0",
+    "@scalar/nestjs-api-reference": "0.4.2",
     "cookie-parser": "1.4.6",
-    "cpf-cnpj-validator": "1.0.3",
     "dotenv": "16.0.3",
     "express-basic-auth": "1.2.1",
-    "googleapis": "118.0.0",
     "ioredis": "5.3.2",
-    "passport": "0.6.0",
-    "passport-headerapikey": "1.2.2",
-    "passport-jwt": "4.0.1",
-    "passport-local": "1.0.0",
-    "phone": "3.1.40",
     "reflect-metadata": "0.1.13",
     "rimraf": "3.0.2",
-    "rxjs": "7.2.0",
-    "swagger-ui-express": "4.6.3",
     "zod": "3.22.4",
     "zod-validation-error": "1.5.0"
   }

package/services/redis/redis.service.d.ts

@@ -1,5 +1,5 @@
 import { OnModuleDestroy } from '@nestjs/common';
-import { EnvService } from '../env/env.service';
+import { EnvService } from '../../env/env.service';
 import { IRedisService } from './iredis.service';
 export declare class RedisService implements IRedisService, OnModuleDestroy {
     private readonly redisClient;

package/services/redis/redis.service.js

@@ -5,11 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.RedisService = void 0;
 const common_1 = require("@nestjs/common");
 const ioredis_1 = require("ioredis");
 const env_config_1 = require("../../core/utils/env.config");
+const env_service_1 = require("../../env/env.service");
 let RedisService = exports.RedisService = class RedisService {
     redisClient;
     environment;
@@ -49,5 +53,6 @@ let RedisService = exports.RedisService = class RedisService {
     }
 };
 exports.RedisService = RedisService = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [env_service_1.EnvService])
 ], RedisService);

package/services/redlock/red-lock.service.js

@@ -5,10 +5,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.RedLockService = void 0;
 const common_1 = require("@nestjs/common");
 const env_config_1 = require("../../core/utils/env.config");
+const iredis_service_1 = require("../redis/iredis.service");
 let RedLockService = exports.RedLockService = class RedLockService {
     redisService;
     constructor(redisService) {
@@ -36,5 +40,6 @@ let RedLockService = exports.RedLockService = class RedLockService {
     }
 };
 exports.RedLockService = RedLockService = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [iredis_service_1.IRedisService])
 ], RedLockService);

package/test/koala-app-test-dependencies.d.ts

@@ -0,0 +1,10 @@
+import { Type } from "@nestjs/common";
+interface KoalaAppTestDependenciesConfig {
+    dependencies: any[];
+}
+export declare class KoalaAppTestDependencies {
+    private readonly _config;
+    constructor(_config: KoalaAppTestDependenciesConfig);
+    get<T>(objectType: Type<T>): T;
+}
+export {};

package/test/koala-app-test-dependencies.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaAppTestDependencies = void 0;
+class KoalaAppTestDependencies {
+    _config;
+    constructor(_config) {
+        this._config = _config;
+    }
+    get(objectType) {
+        return this._config.dependencies.find((dependency) => dependency instanceof objectType);
+    }
+}
+exports.KoalaAppTestDependencies = KoalaAppTestDependencies;

package/test/koala-app-test.d.ts

@@ -0,0 +1,20 @@
+import { INestApplication, Type } from '@nestjs/common';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { PrismaTransactionalClient } from '../core/database/prisma-transactional-client';
+export declare class KoalaAppTest {
+    private readonly app;
+    private _globalExceptionFilter;
+    private _prismaValidationExceptionFilter;
+    private _domainExceptionFilter;
+    private _zodExceptionFilter;
+    constructor(app: INestApplication<any>);
+    addCustomGlobalExceptionFilter(filter: BaseExceptionFilter): this;
+    addCustomPrismaValidationExceptionFilter(filter: BaseExceptionFilter): this;
+    addCustomDomainExceptionFilter(filter: BaseExceptionFilter): this;
+    addCustomZodExceptionFilter(filter: BaseExceptionFilter): this;
+    enableCors(): this;
+    setAppName(name: string): this;
+    setInternalUserName(name: string): this;
+    setDbTransactionContext(transactionContext: Type<PrismaTransactionalClient>): this;
+    build(): INestApplication<any>;
+}

package/test/koala-app-test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaAppTest = void 0;
+const core_1 = require("@nestjs/core");
+const koala_global_vars_1 = require("../core/koala-global-vars");
+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");
+class KoalaAppTest {
+    app;
+    _globalExceptionFilter;
+    _prismaValidationExceptionFilter;
+    _domainExceptionFilter;
+    _zodExceptionFilter;
+    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();
+    }
+    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;
+    }
+    enableCors() {
+        this.app.enableCors({
+            credentials: true,
+            origin: true,
+            optionsSuccessStatus: 200,
+        });
+        return this;
+    }
+    setAppName(name) {
+        koala_global_vars_1.KoalaGlobalVars.appName = name;
+        return this;
+    }
+    setInternalUserName(name) {
+        koala_global_vars_1.KoalaGlobalVars.internalUserName = name;
+        return this;
+    }
+    setDbTransactionContext(transactionContext) {
+        koala_global_vars_1.KoalaGlobalVars.dbTransactionContext = transactionContext;
+        return this;
+    }
+    build() {
+        this.app.useGlobalFilters(this._globalExceptionFilter, this._prismaValidationExceptionFilter, this._domainExceptionFilter, this._zodExceptionFilter);
+        return this.app;
+    }
+}
+exports.KoalaAppTest = KoalaAppTest;

package/test/repositories/in-memory-base.repository.d.ts

@@ -0,0 +1,16 @@
+import { CreatedRegistreResponseBase } from '../../core/controllers/created-registre-response.base';
+import { ListResponseBase } from '../../core/controllers/list-response.base';
+import { EntityBase } from '../../core/database/entity.base';
+import { PaginationParams } from '../../core/models/pagination-params';
+import { IComparableId } from '../../core/utils/interfaces/icomparable';
+export declare abstract class InMemoryBaseRepository<TClass extends EntityBase<any>> {
+    private readonly typeId;
+    protected items: TClass[];
+    constructor(typeId?: 'number' | 'string');
+    protected findById(id: IComparableId): Promise<TClass | null>;
+    protected findMany<T extends PaginationParams>(query: T, predicate?: (value: TClass, index: number, array: TClass[]) => unknown): Promise<TClass[]>;
+    protected findManyAndCount<T extends PaginationParams>(query: T, predicate?: (value: TClass, index: number, array: TClass[]) => unknown): Promise<ListResponseBase<TClass>>;
+    protected saveChanges(item: TClass): Promise<CreatedRegistreResponseBase<any>>;
+    protected remove(predicate: (value: TClass, index: number, obj: TClass[]) => unknown): Promise<void>;
+    private getNewId;
+}

package/test/repositories/in-memory-base.repository.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryBaseRepository = void 0;
+const array_1 = require("@koalarx/utils/operators/array");
+const pagination_params_1 = require("../../core/models/pagination-params");
+const node_crypto_1 = require("node:crypto");
+class InMemoryBaseRepository {
+    typeId;
+    items = [];
+    constructor(typeId = 'number') {
+        this.typeId = typeId;
+    }
+    async findById(id) {
+        return this.items.find((item) => item._id === id) ?? null;
+    }
+    async findMany(query, predicate) {
+        const page = query.page ?? pagination_params_1.QueryFilterParams.page;
+        const limit = query.limit ?? pagination_params_1.QueryFilterParams.limit;
+        return (0, array_1.klArray)(predicate ? this.items.filter(predicate) : this.items)
+            .orderBy(query.orderBy ?? '', query.direction === 'desc')
+            .getValue()
+            .slice(page * limit, (page + 1) * limit);
+    }
+    async findManyAndCount(query, predicate) {
+        const items = await this.findMany(query, predicate);
+        return {
+            items,
+            count: items.length,
+        };
+    }
+    async saveChanges(item) {
+        const itemIndex = this.items.findIndex((itemDB) => itemDB.equals(item));
+        if (itemIndex > -1) {
+            this.items[itemIndex] = item;
+        }
+        const id = this.typeId === 'number'
+            ? this.getNewId()
+            : (0, node_crypto_1.randomUUID)();
+        item.automap({ ...item, id });
+        this.items.push(item);
+        return { id: item._id };
+    }
+    async remove(predicate) {
+        const itemIndex = this.items.findIndex(predicate);
+        if (itemIndex > -1) {
+            this.items.splice(itemIndex, 1);
+        }
+    }
+    getNewId() {
+        return this.typeId === 'number'
+            ? (0, array_1.klArray)(this.items).orderBy('_id', true).getValue()[0]?._id ?? 0 + 1
+            : (0, node_crypto_1.randomUUID)();
+    }
+}
+exports.InMemoryBaseRepository = InMemoryBaseRepository;

package/test/services/fake-logging.service.d.ts

@@ -0,0 +1,4 @@
+import { ILoggingService } from '../../services/logging/ilogging.service';
+export declare class FakeLoggingService implements ILoggingService {
+    report(data: any): Promise<void>;
+}

package/test/services/fake-logging.service.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeLoggingService = void 0;
+class FakeLoggingService {
+    async report(data) {
+        console.log('FakeLoggingService.report', data);
+    }
+}
+exports.FakeLoggingService = FakeLoggingService;

package/test/services/fake-red-lock.service.d.ts

@@ -0,0 +1,5 @@
+import { IRedLockService } from '../../services/redlock/ired-lock.service';
+export declare class FakeRedLockService implements IRedLockService {
+    acquiredLock(key: string, ttlSecondsLock: number): Promise<boolean>;
+    releaseLock(key: string): Promise<void>;
+}

package/test/services/fake-red-lock.service.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeRedLockService = void 0;
+class FakeRedLockService {
+    async acquiredLock(key, ttlSecondsLock) {
+        return true;
+    }
+    async releaseLock(key) {
+    }
+}
+exports.FakeRedLockService = FakeRedLockService;

package/test/utils/create-e2e-database.d.ts

@@ -0,0 +1,2 @@
+import 'dotenv/config';
+export declare function createE2EDatabase(): `${string}-${string}-${string}-${string}-${string}`;

package/test/utils/create-e2e-database.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createE2EDatabase = void 0;
+require("dotenv/config");
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+function generateUniqueDatabaseURL() {
+    const schemaId = (0, node_crypto_1.randomUUID)();
+    if (!process.env.DATABASE_URL) {
+        throw new Error('Please provider a DATABASE_URL environment variable');
+    }
+    const url = new URL(process.env.DATABASE_URL);
+    url.searchParams.set('schema', schemaId);
+    return {
+        url: url.toString(),
+        schemaId
+    };
+}
+function createE2EDatabase() {
+    const { url, schemaId } = generateUniqueDatabaseURL();
+    process.env.DATABASE_URL = url;
+    process.env.DIRECT_URL = url;
+    process.env.PRISMA_SCHEMA_DISABLE_ADVISORY_LOCK = 'true';
+    (0, node_child_process_1.execSync)('npx prisma migrate deploy', {});
+    return schemaId;
+}
+exports.createE2EDatabase = createE2EDatabase;

package/test/utils/drop-e2e-database.d.ts

@@ -0,0 +1 @@
+export declare function dropE2EDatabase(schemaId: string): import(".prisma/client").Prisma.PrismaPromise<number>;

package/test/utils/drop-e2e-database.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropE2EDatabase = void 0;
+const client_1 = require("@prisma/client");
+function dropE2EDatabase(schemaId) {
+    return new client_1.PrismaClient().$executeRawUnsafe(`DROP SCHEMA IF EXISTS "${schemaId}" CASCADE`);
+}
+exports.dropE2EDatabase = dropE2EDatabase;

package/test/utils/wait-for.d.ts

@@ -0,0 +1 @@
+export declare function waitFor(assertions: () => void, maxDuration?: number): Promise<void>;

package/test/utils/wait-for.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = void 0;
+async function waitFor(assertions, maxDuration = 1000) {
+    return new Promise((resolve, reject) => {
+        let elapsedTime = 0;
+        const interval = setInterval(() => {
+            elapsedTime += 10;
+            try {
+                assertions();
+                clearInterval(interval);
+                resolve();
+            }
+            catch (err) {
+                if (elapsedTime >= maxDuration) {
+                    reject(err);
+                }
+            }
+        }, 10);
+    });
+}
+exports.waitFor = waitFor;