@koalarx/nest 3.0.3 → 3.0.5

package/core/database/entity.base.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBase = exports.EntityActionType = void 0;
+const utils_1 = require("@koalarx/utils");
+const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
+const list_1 = require("../utils/list");
+var EntityActionType;
+(function (EntityActionType) {
+    EntityActionType[EntityActionType["create"] = 1] = "create";
+    EntityActionType[EntityActionType["update"] = 2] = "update";
+})(EntityActionType || (exports.EntityActionType = EntityActionType = {}));
+class EntityBase {
+    _id;
+    _action = EntityActionType.create;
+    constructor(props) {
+        if (props) {
+            this.automap(props);
+        }
+    }
+    automap(props) {
+        if (props) {
+            for (const key of Object.keys(props)) {
+                if (props[key] === undefined) {
+                    continue;
+                }
+                const propDefinitions = auto_mapping_list_1.AutoMappingList.getPropDefinitions(this.constructor.prototype.constructor, key);
+                const EntityOnPropKey = auto_mapping_list_1.AutoMappingList.getSourceByName(propDefinitions?.type ?? '');
+                if (Array.isArray(props[key]) && this[key] instanceof list_1.List) {
+                    let value = props[key];
+                    if (this[key].entityType) {
+                        value = value.map((item) => {
+                            const entity = new this[key].entityType();
+                            entity._action = this._action;
+                            entity.automap(item);
+                            return entity;
+                        });
+                    }
+                    this[key].setList(value);
+                }
+                else if (propDefinitions?.type === 'KlArray' &&
+                    (props[key] instanceof Array || Array.isArray(props[key]))) {
+                    this[key] = new utils_1.KlArray(props[key]);
+                }
+                else if (propDefinitions?.type === 'KlDate' && props[key] instanceof Date) {
+                    this[key] = new utils_1.KlDate(props[key]);
+                }
+                else if (propDefinitions?.type === 'KlTime' && props[key] instanceof Date) {
+                    this[key] = new utils_1.KlTime(props[key].getHours(), props[key].getMinutes(), props[key].getSeconds(), props[key].getMilliseconds());
+                }
+                else if (EntityOnPropKey) {
+                    if (props[key]) {
+                        const entity = new EntityOnPropKey();
+                        entity._action = this._action;
+                        entity.automap(props[key]);
+                        this[key] = entity;
+                    }
+                }
+                else if (propDefinitions) {
+                    if (key === 'id') {
+                        this._id = props[key];
+                    }
+                    this[key] = props[key];
+                }
+            }
+        }
+    }
+    equals(obj) {
+        return obj._id === this._id;
+    }
+}
+exports.EntityBase = EntityBase;

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

@@ -0,0 +1,13 @@
+import { EntityBase } from './entity.base';
+type EntityProps<T> = Omit<{
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+}, '_id' | '_action'>;
+export declare function Entity<T extends new (...args: any[]) => EntityBase<any>>(id?: keyof EntityProps<InstanceType<T>>): (target: T) => {
+    new (...args: any[]): {
+        _id: import("../utils/interfaces/icomparable").IComparableId;
+        _action: import("./entity.base").EntityActionType;
+        automap(props?: import("./entity.base").EntityProps<any> | undefined): void;
+        equals(obj: EntityBase<any>): boolean;
+    };
+} & T;
+export {};

package/core/database/entity.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = Entity;
+function Entity(id) {
+    return function (target) {
+        class NewConstructor extends target {
+            constructor(...args) {
+                super(...args);
+                if (typeof this.automap === 'function') {
+                    this.automap(args[0]);
+                }
+            }
+        }
+        Object.setPrototypeOf(NewConstructor.prototype, target.prototype);
+        Object.setPrototypeOf(NewConstructor, target);
+        Object.defineProperty(NewConstructor, 'name', {
+            value: target.name,
+            writable: false,
+        });
+        Reflect.defineMetadata('entity:id', id, NewConstructor.prototype);
+        return NewConstructor;
+    };
+}

package/core/database/prisma-client-with-custom-transaction.interface.d.ts

@@ -0,0 +1,8 @@
+import { Prisma } from 'prisma/generated/client';
+export interface PrismaClientWithCustomTransaction extends Readonly<Prisma.TransactionClient> {
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>, options?: {
+        maxWait?: number | undefined;
+        timeout?: number | undefined;
+        isolationLevel?: Prisma.TransactionIsolationLevel | undefined;
+    }): Promise<F>;
+}

package/core/database/prisma-client-with-custom-transaction.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/database/prisma-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function setPrismaClient(prismaClientClass: any): void;
+export declare function getPrismaClientClass(): any;

package/core/database/prisma-resolver.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPrismaClient = setPrismaClient;
+exports.getPrismaClientClass = getPrismaClientClass;
+const path = require("path");
+const fs = require("fs");
+let cachedPrismaClient = null;
+function findPrismaClient() {
+    const possiblePaths = [
+        path.join(process.cwd(), 'prisma/generated/client.js'),
+        path.join(__dirname, '../../../../../prisma/generated/client.js'),
+        path.join(process.cwd(), 'prisma/generated/client.ts'),
+        path.join(__dirname, '../../../../../prisma/generated/client.ts'),
+        ...(require.main?.filename
+            ? [
+                path.join(path.dirname(require.main.filename), '../prisma/generated/client.js'),
+                path.join(path.dirname(require.main.filename), '../prisma/generated/client.ts'),
+            ]
+            : []),
+    ];
+    for (const prismaPath of possiblePaths) {
+        if (fs.existsSync(prismaPath)) {
+            return prismaPath;
+        }
+    }
+    return null;
+}
+async function resolvePrismaClient() {
+    if (cachedPrismaClient) {
+        return cachedPrismaClient;
+    }
+    const prismaPath = findPrismaClient();
+    if (!prismaPath) {
+        throw new Error(`
+      Não foi possível carregar o Prisma Client automaticamente.
+      
+      Certifique-se de que você:
+      1. Executou 'bunx prisma generate' no seu projeto
+      2. Tem a pasta 'prisma/generated/client' no seu projeto
+      3. A lib @koalarx/nest está instalada como dependência
+      
+      Se o problema persistir, você pode registrar manualmente o Prisma Client:
+      
+      import { setPrismaClient } from '@koalarx/nest'
+      import { PrismaClient } from './prisma/generated/client'
+      
+      setPrismaClient(PrismaClient)
+      `.trim());
+    }
+    try {
+        const module = await Promise.resolve(`${prismaPath}`).then(s => require(s));
+        cachedPrismaClient = module.PrismaClient || module.default || module;
+        return cachedPrismaClient;
+    }
+    catch (error) {
+        throw new Error(`
+      Erro ao carregar o Prisma Client de ${prismaPath}:
+      ${error instanceof Error ? error.message : String(error)}
+      
+      Certifique-se de que 'bunx prisma generate' foi executado com sucesso.
+      `.trim());
+    }
+}
+let manualPrismaClient = null;
+function setPrismaClient(prismaClientClass) {
+    manualPrismaClient = prismaClientClass;
+    cachedPrismaClient = null;
+}
+function getPrismaClientClass() {
+    if (manualPrismaClient) {
+        return manualPrismaClient;
+    }
+    return resolvePrismaClient();
+}

package/core/database/prisma-transactional-client.d.ts

@@ -0,0 +1,11 @@
+import { Prisma } from 'prisma/generated/client';
+export declare abstract class PrismaTransactionalClient {
+    protected readonly transactionalClient: Prisma.TransactionClient;
+    [key: symbol]: any;
+    constructor(transactionalClient: Prisma.TransactionClient);
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>): Promise<F>;
+    $executeRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
+    $executeRawUnsafe(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
+    $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
+}

package/core/database/prisma-transactional-client.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaTransactionalClient = void 0;
+class PrismaTransactionalClient {
+    transactionalClient;
+    constructor(transactionalClient) {
+        this.transactionalClient = transactionalClient;
+    }
+    async withTransaction(fn) {
+        return await fn(this.transactionalClient);
+    }
+    $executeRaw(query, ...values) {
+        return this.transactionalClient.$executeRaw(query, ...values);
+    }
+    $executeRawUnsafe(query, ...values) {
+        return this.transactionalClient.$executeRawUnsafe(query, ...values);
+    }
+    $queryRaw(query, ...values) {
+        return this.transactionalClient.$queryRaw(query, ...values);
+    }
+    $queryRawUnsafe(query, ...values) {
+        return this.transactionalClient.$queryRawUnsafe(query, ...values);
+    }
+}
+exports.PrismaTransactionalClient = PrismaTransactionalClient;

package/core/database/prisma.service.d.ts

@@ -0,0 +1,24 @@
+import { EnvService } from '@koalarx/nest/env/env.service';
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { PrismaClientWithCustomTransaction } from './prisma-client-with-custom-transaction.interface';
+import type { Prisma } from 'prisma/generated/client';
+export declare function setPrismaClientOptions(options: Prisma.PrismaClientOptions): void;
+export declare class PrismaService implements OnModuleInit, OnModuleDestroy, PrismaClientWithCustomTransaction {
+    private readonly env;
+    private prismaInstance;
+    constructor(env: EnvService);
+    initialize(): Promise<void>;
+    onModuleInit(): Promise<any>;
+    onModuleDestroy(): any;
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>, options?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: Prisma.TransactionIsolationLevel;
+    }): Promise<F>;
+    [Symbol.toPrimitive](): any;
+    toString(): string;
+    get $connect(): any;
+    get $disconnect(): any;
+    get $transaction(): any;
+    get $on(): any;
+}

package/core/database/prisma.service.js

@@ -0,0 +1,104 @@
+"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.PrismaService = void 0;
+exports.setPrismaClientOptions = setPrismaClientOptions;
+const env_service_1 = require("../../env/env.service");
+const common_1 = require("@nestjs/common");
+const prisma_resolver_1 = require("./prisma-resolver");
+let globalPrismaOptions = {};
+function setPrismaClientOptions(options) {
+    globalPrismaOptions = options;
+}
+let PrismaClientClass = null;
+async function loadPrismaClient() {
+    if (!PrismaClientClass) {
+        PrismaClientClass = await (0, prisma_resolver_1.getPrismaClientClass)();
+    }
+    return PrismaClientClass;
+}
+let PrismaService = class PrismaService {
+    env;
+    prismaInstance;
+    constructor(env) {
+        this.env = env;
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (prop in target) {
+                    const value = Reflect.get(target, prop, receiver);
+                    if (typeof value === 'function') {
+                        return value.bind(target);
+                    }
+                    return value;
+                }
+                if (target.prismaInstance && typeof prop === 'string') {
+                    const value = target.prismaInstance[prop];
+                    if (typeof value === 'function') {
+                        return value.bind(target.prismaInstance);
+                    }
+                    return value;
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    async initialize() {
+        const PrismaClientType = await loadPrismaClient();
+        this.prismaInstance = new PrismaClientType({
+            log: [{ emit: 'event', level: 'query' }],
+            ...globalPrismaOptions,
+        });
+    }
+    async onModuleInit() {
+        await this.initialize();
+        if (this.env.get('PRISMA_QUERY_LOG')) {
+            this.prismaInstance?.$on?.('query', async (e) => {
+                console.log(`${e.query} ${e.params}`);
+            });
+        }
+        return this.prismaInstance?.$connect?.();
+    }
+    onModuleDestroy() {
+        return this.prismaInstance?.$disconnect?.();
+    }
+    async withTransaction(fn, options) {
+        return this.prismaInstance?.$transaction?.(fn, options ?? {
+            maxWait: 20000,
+            timeout: 20000,
+        });
+    }
+    [Symbol.toPrimitive]() {
+        return this.prismaInstance;
+    }
+    toString() {
+        return '[PrismaService]';
+    }
+    get $connect() {
+        return this.prismaInstance?.$connect?.bind(this.prismaInstance);
+    }
+    get $disconnect() {
+        return this.prismaInstance?.$disconnect?.bind(this.prismaInstance);
+    }
+    get $transaction() {
+        return this.prismaInstance?.$transaction?.bind(this.prismaInstance);
+    }
+    get $on() {
+        return this.prismaInstance?.$on?.bind(this.prismaInstance);
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.prismaInstance;
+    }
+};
+exports.PrismaService = PrismaService;
+exports.PrismaService = PrismaService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [env_service_1.EnvService])
+], PrismaService);

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

@@ -0,0 +1,44 @@
+import { Type } from '@nestjs/common';
+import { ListResponse } from '..';
+import { PaginationDto } from '../dtos/pagination.dto';
+import { IComparableId } from '../utils/interfaces/icomparable';
+import { List } from '../utils/list';
+import { EntityBase } from './entity.base';
+import { PrismaTransactionalClient } from './prisma-transactional-client';
+type RepositoryInclude<TEntity> = Omit<{
+    [K in keyof TEntity as TEntity[K] extends Function ? never : K]?: boolean | (TEntity[K] extends List<infer U> ? RepositoryInclude<U> : RepositoryInclude<TEntity[K]>);
+}, '_id' | '_action'>;
+interface RepositoryInitProps<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient> {
+    context: TContext;
+    modelName: Type<TEntity>;
+    transactionContext?: Type<TContext>;
+    include?: RepositoryInclude<TEntity>;
+}
+export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient = PrismaTransactionalClient, TModelKey extends keyof TContext = keyof TContext> {
+    protected _context: TContext;
+    private readonly _modelName;
+    private readonly _include?;
+    constructor({ context, modelName, include, }: RepositoryInitProps<TEntity, TContext>);
+    private listRelationEntities;
+    private listToRelationActionList;
+    private entityToPrisma;
+    private findManySchema;
+    private createEntity;
+    private orphanRemoval;
+    private getIdPropName;
+    private getInclude;
+    private getPropNameFromEntitySource;
+    private persistRelations;
+    protected context(transactionalClient?: TContext): TContext[TModelKey];
+    protected findById(id: IComparableId): Promise<TEntity | null>;
+    protected findFirst<T>(where: T): Promise<TEntity | null>;
+    protected findUnique<T>(where: T): Promise<TEntity | null>;
+    protected findMany<T>(where: T, pagination?: PaginationDto): Promise<TEntity[]>;
+    protected findManyAndCount<T>(where: T, pagination?: PaginationDto): Promise<ListResponse<TEntity>>;
+    protected saveChanges<TWhere = any>(entity: TEntity, updateWhere?: TWhere): Promise<TEntity>;
+    protected saveMany<TWhere = any>(entities: TEntity[], updateWhere?: TWhere): Promise<void>;
+    protected remove<TWhere = any>(where: TWhere, notCascadeEntityProps?: Array<keyof TEntity>, externalServices?: Promise<any>): Promise<any>;
+    protected removeMany<TWhere = any>(where: TWhere, notCascadeEntityProps?: Array<keyof TEntity>, externalServices?: Promise<any>): Promise<void>;
+    withTransaction(fn: (prisma: TContext) => Promise<any>): Promise<any>;
+}
+export {};