@koalarx/nest 3.1.50 → 4.0.2

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

@@ -1,25 +0,0 @@
-"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

@@ -1,24 +0,0 @@
-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

@@ -1,104 +0,0 @@
-"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

@@ -1,83 +0,0 @@
-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>;
-    deepLimit?: number;
-}
-export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient = PrismaTransactionalClient, TModelKey extends keyof TContext = keyof TContext> {
-    protected _context: TContext;
-    protected readonly _modelName: Type<TEntity>;
-    protected readonly _includeFindMany?: RepositoryInclude<TEntity>;
-    constructor({ context, modelName, deepLimit, }: RepositoryInitProps<TEntity, TContext>);
-    protected get entityInstance(): any;
-    protected getIdPropName(entity?: TEntity): string | string[];
-    protected getWhereByIdSchema(entity: TEntity, value: any): {};
-    protected getConnectPrismaSchemaForRelation(entity: TEntity | Type<TEntity>, data?: any): {
-        connect: {};
-    };
-    protected checkIdHasValue(entity: TEntity, value: any): boolean;
-    protected getSelectRootPrismaSchema(entity: TEntity): {};
-    protected getSelectWithRelationsId(entity: TEntity): {};
-    protected getPropNameFromEntitySource(source: TEntity, entity: Type<TEntity>): string | undefined;
-    protected listRelationEntities(entity: TEntity, fromList?: boolean): TEntity[];
-    protected listToRelationActionList(entity: TEntity): {
-        relationCreates: {
-            modelName: string;
-            entityInstance: Type<TEntity>;
-            schema: any;
-            relations: TEntity[];
-        }[];
-        relationUpdates: {
-            modelName: string;
-            entityInstance: Type<TEntity>;
-            schema: any;
-            relations: TEntity[];
-        }[];
-        relationDeletes: {
-            modelName: string;
-            entityInstance: Type<TEntity>;
-            schema: any;
-            relations: TEntity[];
-        }[];
-    };
-    protected entityToPrisma(entity: TEntity): {};
-    protected getInclude(include?: RepositoryInclude<TEntity>): {};
-    protected findManySchema<T>(where: T, pagination?: PaginationDto): {
-        include: {};
-        where: T;
-        orderBy: {} | undefined;
-        skip: number | undefined;
-        take: number | undefined;
-    };
-    protected createEntity(data: any, entityClass?: Type<TEntity>): TEntity;
-    protected orphanRemoval(client: PrismaTransactionalClient, entity: EntityBase<TEntity>): any;
-    protected getIdOnEntity(entity: TEntity, data: any): string;
-    protected loadRelationForEntity(where: Record<string, any>, entity: TEntity, cache: Map<string, any>): Promise<any>;
-    protected loadEntityFromCache(entity: TEntity, data: any, cache: Map<string, any>): any;
-    protected enrichEntityWithRelations(entity: TEntity, data: any, cache?: Map<string, any>): Promise<any>;
-    protected persistRelations(transaction: PrismaTransactionalClient, entity: TEntity): Promise<void>;
-    protected setIdOnEntity(entityInstance: TEntity, data: any): void;
-    protected autofillCreatedId(entity: TEntity, response: any): void;
-    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>;
-    protected withTransaction(fn: (prisma: TContext) => Promise<any>): Promise<any>;
-}
-export {};