@hiki9/rich-domain/dist/implementations/prisma.repository.js

Rich Domain is a library that provides a set of tools to help you build complex business logic in NodeJS using Domain Driven Design principles.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseQueryWithDots = exports.PrismaRepository = void 0;
const repository_1 = require("../core/application/repository");
const pagination_1 = require("../core/common/pagination");
class PrismaRepository extends repository_1.RepositoryImplementation {
    constructor(prisma, adapterToDomain, adapterToPersistence, unitOfWorkService) {
        super();
        this.prisma = prisma;
        this.adapterToDomain = adapterToDomain;
        this.adapterToPersistence = adapterToPersistence;
        this.unitOfWorkService = unitOfWorkService;
    }
    getContext(options) {
        const unitOfWorkContext = this.unitOfWorkService.getContext();
        return unitOfWorkContext || options?.context || this.prisma;
    }
    generateFindQuery(criteria) {
        const query = {};
        query.skip = criteria.offset;
        query.take = criteria.limit;
        const filter = { AND: [] };
        if (criteria.businessFilter) {
            filter.AND.push(criteria.businessFilter);
        }
        if (criteria.search) {
            query.skip = 0;
            filter.AND.push(this.generateSearchQuery(criteria.search));
        }
        if (criteria.filter) {
            filter.AND.push(criteria.filter);
        }
        if (filter.AND.length > 0)
            query.where = filter;
        if (criteria.orderBy) {
            query.orderBy = criteria.orderBy;
        }
        return query;
    }
    async find(criteria) {
        const tableName = this.model;
        const context = this.getContext();
        const query = this.generateFindQuery(criteria);
        const [models, total] = await Promise.all([
            context[tableName].findMany({
                ...query,
                include: this.findIncludes,
            }),
            context[tableName].count({ where: query.where }),
        ]);
        const result = models.map((value) => this.adapterToDomain.build(value));
        const pagination = new pagination_1.Pagination(criteria, {
            result,
            total,
        });
        return pagination;
    }
    async findById(id) {
        const tableName = this.model;
        const context = this.getContext();
        const query = {};
        query.where = { id };
        const model = await context[tableName].findUnique({
            ...query,
            include: this.uniqueIncludes,
        });
        if (!model) {
            return null;
        }
        const domain = this.adapterToDomain.build(model);
        return domain;
    }
    async create(entity, options) {
        const tableName = this.model;
        const context = this.getContext(options);
        const model = this.adapterToPersistence.build(entity);
        const query = await context[tableName].create({ data: model });
        if (!query) {
            throw query;
        }
    }
    async update(entity, options) {
        const tableName = this.model;
        const context = this.getContext(options);
        const model = this.adapterToPersistence.build(entity);
        const query = await context[tableName].update({
            where: { id: entity.id.value },
            data: model,
        });
        if (!query) {
            throw query;
        }
    }
    async delete(entity, options) {
        const tableName = this.model;
        const context = this.getContext(options);
        const query = await context[tableName].delete({
            where: { id: entity.id.value },
        });
        if (!query) {
            throw query;
        }
    }
    async forceCloseConnection() {
        await this.prisma.$disconnect();
    }
}
exports.PrismaRepository = PrismaRepository;
function parseQueryWithDots(field, verb, value) {
    const fieldMap = field.split('.');
    const m = {};
    fieldMap.reduce((acc, curr, index) => {
        if (index === fieldMap.length - 1) {
            acc[curr] = { [verb]: value };
        }
        else {
            acc[curr] = {};
        }
        return acc[curr];
    }, m);
    return m;
}
exports.parseQueryWithDots = parseQueryWithDots;
//# sourceMappingURL=prisma.repository.js.map