@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/classes/api-service.class.js

@@ -1,621 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-import { Injectable, InternalServerErrorException, NotFoundException, Scope } from '@nestjs/common';
-import { EntityTarget, In } from 'typeorm';
-import { ERROR_MESSAGES, SYSTEM_MESSAGES } from '../constants';
-import { LogAction } from '../decorators/log-action.decorator';
-import { DeleteDto } from '../dtos';
-import { IDataSourceProvider } from '../interfaces';
-import { UtilsService } from '../modules/utils/utils.service';
-import { publishDomainEvent } from './domain-event.publisher';
-import { HybridCache } from './hybrid-cache.class';
-const DELETE_EVENT_ACTIONS = {
-    delete: 'deleted',
-    restore: 'restored',
-    permanent: 'purged'
-};
-export class ApiService {
-    getDataSourceProvider() {
-        return this._dataSourceProvider;
-    }
-    async ensureDataSourceRepository() {
-        if (!this.repositoryInitialized) {
-            const provider = this.getDataSourceProvider();
-            this.repository = await provider.getRepository(this._entity);
-            this.repositoryInitialized = true;
-        }
-    }
-    async resolveRepositories(entities) {
-        const provider = this.getDataSourceProvider();
-        const repositories = [];
-        for (const entity of entities){
-            repositories.push(await provider.getRepository(entity));
-        }
-        return repositories;
-    }
-    async insert(dto, user) {
-        return this.executeInTransaction('created', async (qr)=>{
-            await this.beforeInsertOperation(dto, user, qr);
-            const entities = await this.convertRequestDtoToEntity(dto, user);
-            const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterInsertOperation(this.ensureArray(saved), dto, user, qr);
-            return {
-                saved,
-                returnFirst: true
-            };
-        }, user);
-    }
-    async insertMany(dtos, user) {
-        return this.executeInTransaction('created', async (qr)=>{
-            await this.beforeInsertOperation(dtos, user, qr);
-            const entities = await this.convertRequestDtoToEntity(dtos, user);
-            const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterInsertOperation(this.ensureArray(saved), dtos, user, qr);
-            return {
-                saved,
-                returnFirst: false
-            };
-        }, user);
-    }
-    async update(dto, user) {
-        return this.executeInTransaction('updated', async (qr)=>{
-            await this.beforeUpdateOperation(dto, user, qr);
-            const entities = await this.convertRequestDtoToEntity(dto, user);
-            const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterUpdateOperation(this.ensureArray(saved), dto, user, qr);
-            return {
-                saved,
-                returnFirst: true
-            };
-        }, user);
-    }
-    async updateMany(dtos, user) {
-        return this.executeInTransaction('updated', async (qr)=>{
-            await this.beforeUpdateOperation(dtos, user, qr);
-            const entities = await this.convertRequestDtoToEntity(dtos, user);
-            const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterUpdateOperation(this.ensureArray(saved), dtos, user, qr);
-            return {
-                saved,
-                returnFirst: false
-            };
-        }, user);
-    }
-    async bulkUpsert(toInsert, toUpdate, user) {
-        return this.executeInTransaction(undefined, async (qr)=>{
-            const allResults = [];
-            const eventGroups = [];
-            if (toInsert.length > 0) {
-                await this.beforeInsertOperation(toInsert, user, qr);
-                const insertedEntities = await this.convertRequestDtoToEntity(toInsert, user);
-                const insertedSaved = await qr.manager.save(this.repository.target, insertedEntities);
-                await this.afterInsertOperation(this.ensureArray(insertedSaved), toInsert, user, qr);
-                allResults.push(...this.ensureArray(insertedSaved));
-                eventGroups.push({
-                    action: 'created',
-                    entities: this.ensureArray(insertedSaved)
-                });
-            }
-            if (toUpdate.length > 0) {
-                await this.beforeUpdateOperation(toUpdate, user, qr);
-                const updatedEntities = await this.convertRequestDtoToEntity(toUpdate, user);
-                const updatedSaved = await qr.manager.save(this.repository.target, updatedEntities);
-                await this.afterUpdateOperation(this.ensureArray(updatedSaved), toUpdate, user, qr);
-                allResults.push(...this.ensureArray(updatedSaved));
-                eventGroups.push({
-                    action: 'updated',
-                    entities: this.ensureArray(updatedSaved)
-                });
-            }
-            return {
-                saved: allResults,
-                returnFirst: false,
-                eventGroups
-            };
-        }, user);
-    }
-    async findByIds(ids, user, select) {
-        await this.ensureDataSourceRepository();
-        try {
-            const query = this.repository.createQueryBuilder(this.entityName);
-            query.where({
-                id: In(ids)
-            });
-            const selectArray = typeof select === 'string' ? select.split(',').map((s)=>s.trim()) : select;
-            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user, selectArray);
-            let output;
-            if (isRaw) {
-                output = await finalQuery.getRawMany();
-            } else {
-                output = await finalQuery.getMany();
-            }
-            const result = this.convertEntityListToResponseListDto(output, isRaw);
-            if (!result || !result.length) throw new NotFoundException({
-                message: 'No Data Found',
-                messageKey: ERROR_MESSAGES.NOT_FOUND
-            });
-            return result;
-        } catch (error) {
-            if (error instanceof NotFoundException) {
-                throw error;
-            }
-            this.handleError(error);
-        }
-    }
-    async findById(id, user, select) {
-        await this.ensureDataSourceRepository();
-        try {
-            const query = this.repository.createQueryBuilder(this.entityName);
-            query.where({
-                id
-            });
-            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user, select);
-            let result;
-            let cacheKey = '';
-            if (this.isCacheable) {
-                cacheKey = this.utilsService.getCacheKey(this.entityName, finalQuery.getQueryAndParameters(), id);
-                result = await this.cacheManager.get(cacheKey);
-            }
-            if (!result) {
-                if (isRaw) {
-                    const rawOutput = await finalQuery.getRawMany();
-                    const convertResult = this.convertEntityListToResponseListDto(rawOutput, isRaw);
-                    if (convertResult.length) result = convertResult[0];
-                } else {
-                    const singleOutput = await finalQuery.getOne();
-                    if (!singleOutput) throw new NotFoundException({
-                        message: 'No Data Found',
-                        messageKey: ERROR_MESSAGES.NOT_FOUND
-                    });
-                    result = this.convertEntityToResponseDto(singleOutput, false);
-                }
-                if (this.isCacheable) {
-                    await this.cacheManager.set(cacheKey, result);
-                    await this.utilsService.trackCacheKey(cacheKey, this.entityName, this.cacheManager, id);
-                }
-            }
-            return result;
-        } catch (error) {
-            if (error instanceof NotFoundException) {
-                throw error;
-            }
-            this.handleError(error);
-        }
-    }
-    async getAll(search, filterAndPaginationDto, user) {
-        await this.ensureDataSourceRepository();
-        try {
-            let data;
-            let total;
-            let isRaw = false;
-            let query = this.repository.createQueryBuilder(this.entityName);
-            if (filterAndPaginationDto.filter) {
-                const { query: filterQuery, isRaw: filterIsRaw } = await this.getFilterQuery(query, filterAndPaginationDto.filter, user);
-                query = filterQuery;
-                isRaw = isRaw || filterIsRaw;
-            }
-            if (search) {
-                const { query: searchQuery, isRaw: searchIsRaw } = await this.getGlobalSearchQuery(query, search, user);
-                query = searchQuery;
-                isRaw = isRaw || searchIsRaw;
-            }
-            const { query: selectQuery, isRaw: selectIsRaw } = await this.getSelectQuery(query, user, filterAndPaginationDto.select);
-            query = selectQuery;
-            isRaw = isRaw || selectIsRaw;
-            if (filterAndPaginationDto.sort) {
-                const { query: sortQuery, isRaw: sortIsRaw } = await this.getSortQuery(query, filterAndPaginationDto.sort, user);
-                query = sortQuery;
-                isRaw = isRaw || sortIsRaw;
-            }
-            if (filterAndPaginationDto.withDeleted) query.withDeleted();
-            const { query: extraQuery, isRaw: extraIsRaw } = await this.getExtraManipulateQuery(query, filterAndPaginationDto, user);
-            query = extraQuery;
-            isRaw = isRaw || extraIsRaw;
-            if (filterAndPaginationDto.pagination) {
-                const offset = filterAndPaginationDto.pagination.currentPage * filterAndPaginationDto.pagination.pageSize;
-                const limit = filterAndPaginationDto.pagination.pageSize;
-                if (isRaw) {
-                    query.offset(offset).limit(limit);
-                } else {
-                    query.skip(offset).take(limit);
-                }
-            }
-            let cacheKey = '';
-            if (this.isCacheable) {
-                cacheKey = this.utilsService.getCacheKey(this.entityName, {
-                    raw: isRaw,
-                    pagination: filterAndPaginationDto.pagination,
-                    query: query.getQueryAndParameters()
-                });
-                const cached = await this.cacheManager.get(cacheKey);
-                if (cached) {
-                    return cached;
-                }
-            }
-            if (isRaw) {
-                const rawSubQuery = query.clone().offset(undefined).limit(undefined);
-                rawSubQuery.expressionMap.orderBys = {};
-                rawSubQuery.distinct(true);
-                const countSql = `
-            SELECT COUNT(*) as count
-            FROM (
-                SELECT COUNT(*) as count
-                FROM (${rawSubQuery.getQuery()}) AS subquery
-                GROUP BY subquery.${this.entityName}_id
-            ) AS final
-          `;
-                const parameters = rawSubQuery.getParameters();
-                const orderedValues = [];
-                const isPostgres = this.repository.manager.connection.options.type === 'postgres';
-                let paramIndex = 0;
-                const convertedQuery = countSql.replace(/:(\w+)/g, (_, key)=>{
-                    if (!(key in parameters)) {
-                        throw new InternalServerErrorException({
-                            message: `Missing parameter value for: ${key}`,
-                            messageKey: SYSTEM_MESSAGES.MISSING_PARAMETER,
-                            messageVariables: {
-                                key
-                            }
-                        });
-                    }
-                    orderedValues.push(parameters[key]);
-                    return isPostgres ? `$${++paramIndex}` : '?';
-                });
-                const result = await this.repository.query(convertedQuery, orderedValues);
-                total = Number(result[0]?.count || 0);
-                data = await query.getRawMany();
-            } else {
-                [data, total] = await query.getManyAndCount();
-            }
-            const convertedFinalData = this.convertEntityListToResponseListDto(data, isRaw);
-            const finalResponse = {
-                data: convertedFinalData,
-                total
-            };
-            if (this.isCacheable) {
-                await this.cacheManager.set(cacheKey, finalResponse);
-                await this.utilsService.trackCacheKey(cacheKey, this.entityName, this.cacheManager);
-            }
-            return finalResponse;
-        } catch (error) {
-            this.handleError(error);
-        }
-    }
-    async delete(option, user) {
-        await this.ensureDataSourceRepository();
-        const queryRunner = this.repository.manager.connection.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-        try {
-            await this.beforeDeleteOperation(option, user, queryRunner);
-            if (option.type === 'delete') {
-                await queryRunner.manager.softDelete(this.repository.target, option.id);
-                await queryRunner.manager.update(this.repository.target, option.id, {
-                    deletedById: option['deletedById']
-                });
-            } else if (option.type === 'restore') {
-                await queryRunner.manager.restore(this.repository.target, option.id);
-                await queryRunner.manager.update(this.repository.target, option.id, {
-                    deletedById: option['deletedById']
-                });
-            } else {
-                await queryRunner.manager.delete(this.repository.target, option.id);
-            }
-            const ids = (Array.isArray(option.id) ? option.id : [
-                option.id
-            ]).map((id)=>{
-                return {
-                    id
-                };
-            });
-            await this.afterDeleteOperation(ids, option, user, queryRunner);
-            await queryRunner.commitTransaction();
-            await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId(ids)
-            ]);
-            await this.publishLifecycleEvents([
-                {
-                    action: DELETE_EVENT_ACTIONS[option.type],
-                    entities: ids,
-                    idsOnly: true
-                }
-            ], user);
-            return null;
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            this.handleError(error);
-        } finally{
-            await queryRunner.release();
-        }
-    }
-    async publishLifecycleEvents(groups, user) {
-        for (const group of groups){
-            if (!group.entities.length) continue;
-            await publishDomainEvent({
-                module: this.moduleName,
-                entity: this.entityName,
-                action: group.action,
-                ids: group.entities.map((entity)=>entity.id),
-                ...group.idsOnly ? {} : {
-                    data: group.entities
-                },
-                user
-            });
-        }
-    }
-    /**
-   * Publishes a domain action for this service's entity - anything past plain
-   * CRUD, such as a submission or a state transition.
-   */ async publishDomainAction(action, input = {}) {
-        await publishDomainEvent({
-            ...input,
-            module: this.moduleName,
-            entity: this.entityName,
-            action
-        });
-    }
-    async clearCacheForAll() {
-        await this.utilsService.clearCache(this.entityName, this.cacheManager);
-    }
-    async clearCacheForId(entities) {
-        await Promise.all(entities.map((item)=>this.utilsService.clearCache(this.entityName, this.cacheManager, item.id)));
-    }
-    handleError(error) {
-        if (error instanceof Error) {
-            throw error;
-        }
-        throw new InternalServerErrorException({
-            message: typeof error === 'string' ? error : 'Unknown error',
-            messageKey: ERROR_MESSAGES.INTERNAL
-        });
-    }
-    ensureArray(value) {
-        return Array.isArray(value) ? value : [
-            value
-        ];
-    }
-    /**
-   * `action` is the lifecycle action to publish for the whole batch; an
-   * operation that saves more than one kind of row - a bulk upsert - passes
-   * `undefined` and returns its own `eventGroups` instead.
-   */ async executeInTransaction(action, fn, user) {
-        await this.ensureDataSourceRepository();
-        const qr = this.repository.manager.connection.createQueryRunner();
-        await qr.connect();
-        await qr.startTransaction();
-        try {
-            const { saved, returnFirst, eventGroups } = await fn(qr);
-            await qr.commitTransaction();
-            const savedArray = this.ensureArray(saved);
-            if (this.isCacheable) {
-                await Promise.all([
-                    this.clearCacheForAll(),
-                    this.clearCacheForId(savedArray)
-                ]);
-            }
-            await this.publishLifecycleEvents(eventGroups ?? (action ? [
-                {
-                    action,
-                    entities: savedArray
-                }
-            ] : []), user ?? null);
-            if (returnFirst) {
-                return this.convertEntityToResponseDto(savedArray[0], false);
-            }
-            return savedArray.map((e)=>this.convertEntityToResponseDto(e, false));
-        } catch (error) {
-            await qr.rollbackTransaction();
-            this.handleError(error);
-        } finally{
-            await qr.release();
-        }
-    }
-    async beforeInsertOperation(_dto, _user, _queryRunner) {}
-    async afterInsertOperation(_entity, _dto, _user, _queryRunner) {}
-    async beforeUpdateOperation(_dto, _user, _queryRunner) {}
-    async afterUpdateOperation(_entity, _dto, _user, _queryRunner) {}
-    async beforeDeleteOperation(_dto, _user, _queryRunner) {}
-    async afterDeleteOperation(_entity, _dto, _user, _queryRunner) {}
-    async getFilterQuery(query, filter, _user) {
-        Object.entries(filter).forEach(([key, value])=>{
-            query.andWhere(`${this.entityName}.${key} = :value`, {
-                value
-            });
-        });
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getSortQuery(query, sort, _user) {
-        Object.entries(sort).forEach(([key, direction])=>{
-            query.addOrderBy(`${this.entityName}.${key}`, direction);
-        });
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getSelectQuery(query, _user, select) {
-        if (select && select.length) query.select(select.map((field)=>`${this.entityName}.${field}`));
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getGlobalSearchQuery(query, search, _user) {
-        query.andWhere(`${this.entityName}.name LIKE :search`, {
-            search: `%${search}%`
-        });
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getExtraManipulateQuery(query, _dto, _user) {
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async convertRequestDtoToEntity(dto, user) {
-        return Array.isArray(dto) ? await this.convertArrayDtoToEntities(dto, user) : [
-            await this.convertSingleDtoToEntity(dto, user)
-        ];
-    }
-    async convertSingleDtoToEntity(dto, _user) {
-        const d = dto;
-        if (d?.id && d.id !== '0' && d.id !== '') {
-            const existing = await this.repository.findOne({
-                where: {
-                    id: d.id
-                }
-            });
-            if (!existing) throw new NotFoundException({
-                message: 'No such entity data found for update! Please, Try Again.',
-                messageKey: ERROR_MESSAGES.NOT_FOUND
-            });
-            return Object.assign(existing, d);
-        }
-        delete d.id;
-        return Object.assign(this.repository.create(), d);
-    }
-    async convertArrayDtoToEntities(dtos, user) {
-        return await Promise.all(dtos.map((dto)=>this.convertSingleDtoToEntity(dto, user)));
-    }
-    convertEntityToResponseDto(entity, _isRaw) {
-        return Object.assign({}, entity);
-    }
-    convertEntityListToResponseListDto(entities, _isRaw) {
-        return entities.map((entity)=>this.convertEntityToResponseDto(entity, _isRaw));
-    }
-    /**
-   * `entity` is the table this service reads and writes. A service whose table
-   * depends on runtime config - the company feature, say - passes the ternary
-   * here, reading the injected config through the constructor parameter.
-   */ constructor(entityName, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName, dataSourceProvider, entity){
-        _define_property(this, "entityName", void 0);
-        _define_property(this, "cacheManager", void 0);
-        _define_property(this, "utilsService", void 0);
-        _define_property(this, "_loggerName", void 0);
-        _define_property(this, "isCacheable", void 0);
-        _define_property(this, "moduleName", void 0);
-        _define_property(this, "repository", void 0);
-        _define_property(this, "repositoryInitialized", void 0);
-        _define_property(this, "_entity", void 0);
-        _define_property(this, "_dataSourceProvider", void 0);
-        this.entityName = entityName;
-        this.cacheManager = cacheManager;
-        this.utilsService = utilsService;
-        this._loggerName = _loggerName;
-        this.isCacheable = isCacheable;
-        this.moduleName = moduleName;
-        this.repositoryInitialized = false;
-        this._dataSourceProvider = dataSourceProvider;
-        this._entity = entity;
-    }
-}
-_ts_decorate([
-    LogAction({
-        action: 'create'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof CreateDtoT === "undefined" ? Object : CreateDtoT,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], ApiService.prototype, "insert", null);
-_ts_decorate([
-    LogAction({
-        action: 'createMany'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Array === "undefined" ? Object : Array,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], ApiService.prototype, "insertMany", null);
-_ts_decorate([
-    LogAction({
-        action: 'update'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof UpdateDtoT === "undefined" ? Object : UpdateDtoT,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], ApiService.prototype, "update", null);
-_ts_decorate([
-    LogAction({
-        action: 'updateMany'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Array,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], ApiService.prototype, "updateMany", null);
-_ts_decorate([
-    LogAction({
-        action: 'bulkUpsert'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Array,
-        Array,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], ApiService.prototype, "bulkUpsert", null);
-_ts_decorate([
-    LogAction({
-        action: 'delete'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof DeleteDto === "undefined" ? Object : DeleteDto,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], ApiService.prototype, "delete", null);
-ApiService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        String,
-        Boolean,
-        String,
-        typeof IDataSourceProvider === "undefined" ? Object : IDataSourceProvider,
-        typeof EntityTarget === "undefined" ? Object : EntityTarget
-    ])
-], ApiService);