7858722036

Committed 11 Feb 2024 01:19AM UTC coverage: 97.027% (+0.09%) from 96.942%

Build # 7858722036

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #449 from jiho-kr/feature/embedded-entities

Run Details

1000 of 1052 branches covered (0.0%)

Branch coverage included in aggregate %.

22 of 22 new or added lines in 2 files covered. (100.0%)

3 existing lines in 1 file now uncovered.

991 of 1000 relevant lines covered (99.1%)

566.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.77

/src/lib/crud.service.ts

import { ConflictException, Logger, NotFoundException } from '@nestjs/common';
import _ from 'lodash';
import { DeepPartial, FindOptionsWhere, Repository } from 'typeorm';

import {
    CrudReadOneRequest,
    CrudDeleteOneRequest,
    CrudUpdateOneRequest,
    CrudUpsertRequest,
    CrudRecoverRequest,
    PaginationResponse,
    isCrudCreateManyRequest,
    CrudCreateOneRequest,
    CrudCreateManyRequest,
    EntityType,
} from './interface';
import { CrudReadManyRequest } from './request';

const SUPPORTED_REPLICATION_TYPES = new Set(['mysql', 'mariadb', 'postgres', 'aurora-postgres', 'aurora-mysql']);

export class CrudService<T extends EntityType> {
    private primaryKey: string[];
    private columnNames: string[];
    private usableQueryRunner = false;

    constructor(public readonly repository: Repository<T>) {
        this.usableQueryRunner = SUPPORTED_REPLICATION_TYPES.has(this.repository.metadata.connection?.options.type);
        this.primaryKey = this.repository.metadata.primaryColumns?.map((columnMetadata) => columnMetadata.propertyName) ?? [];
        this.columnNames = this.repository.metadata.columns.map((column) =>
            column.embeddedMetadata ? column.propertyPath : column.databaseName,
        );
    }

    readonly reservedReadMany = async (crudReadManyRequest: CrudReadManyRequest<T>): Promise<PaginationResponse<T>> => {
        crudReadManyRequest.excludedColumns(this.columnNames);
        try {
            const { entities, total } = await (async () => {
                const findEntities = this.repository.find({ ...crudReadManyRequest.findOptions });

                if (crudReadManyRequest.pagination.isNext) {
                    const entities = await findEntities;
                    return { entities, total: crudReadManyRequest.pagination.nextTotal() };
                }
                const [entities, total] = await Promise.all([
                    findEntities,
                    this.repository.count({
                        where: crudReadManyRequest.findOptions.where,
                        withDeleted: crudReadManyRequest.findOptions.withDeleted,
                    }),
                ]);
                return { entities, total };
            })();
            return crudReadManyRequest.toResponse(entities, total);
        } catch (error) {
            Logger.error(JSON.stringify(crudReadManyRequest));
            Logger.error(error);
            throw error;
        }
    };

    readonly reservedReadOne = async (crudReadOneRequest: CrudReadOneRequest<T>): Promise<T> => {
        return this.repository
            .findOne({
                select: (crudReadOneRequest.selectColumns ?? this.columnNames).filter(
                    (columnName) => !crudReadOneRequest.excludedColumns?.includes(columnName),
                ),
                where: crudReadOneRequest.params as FindOptionsWhere<T>,
                withDeleted: crudReadOneRequest.softDeleted,
                relations: crudReadOneRequest.relations,
            })
            .then((entity) => {
                if (_.isNil(entity)) {
                    throw new NotFoundException();
                }
                return entity;
            });
    };

    readonly reservedCreate = async (crudCreateRequest: CrudCreateOneRequest<T> | CrudCreateManyRequest<T>): Promise<T | T[]> => {
        const entities = this.repository.create(
            isCrudCreateManyRequest<T>(crudCreateRequest) ? crudCreateRequest.body : [crudCreateRequest.body],
        );

        if (crudCreateRequest.author) {
            for (const entity of entities) {
                _.merge(entity, { [crudCreateRequest.author.property]: crudCreateRequest.author.value });
            }
        }

        return this.repository
            .save(entities, crudCreateRequest.saveOptions)
            .then((result) => {
                return isCrudCreateManyRequest<T>(crudCreateRequest)
                    ? result.map((entity) => this.excludeEntity(entity, crudCreateRequest.exclude))
                    : this.excludeEntity(result[0], crudCreateRequest.exclude);
            })
            .catch(this.throwConflictException);
    };

    readonly reservedUpsert = async (crudUpsertRequest: CrudUpsertRequest<T>): Promise<T> => {
        return this.findOne(crudUpsertRequest.params as unknown as FindOptionsWhere<T>, true).then(async (entity: T | null) => {
            const upsertEntity = entity ?? this.repository.create(crudUpsertRequest.params as unknown as DeepPartial<T>);
            if ('deletedAt' in upsertEntity && upsertEntity.deletedAt != null) {
                throw new ConflictException('it has been deleted');
            }

            if (crudUpsertRequest.author) {
                _.merge(upsertEntity, { [crudUpsertRequest.author.property]: crudUpsertRequest.author.value });
            }

            return this.repository
                .save(_.assign(upsertEntity, crudUpsertRequest.body), crudUpsertRequest.saveOptions)
                .then((entity) => this.excludeEntity(entity, crudUpsertRequest.exclude))
                .catch(this.throwConflictException);
        });
    };

    readonly reservedUpdate = async (crudUpdateOneRequest: CrudUpdateOneRequest<T>): Promise<T> => {
        return this.findOne(crudUpdateOneRequest.params as unknown as FindOptionsWhere<T>, false).then(async (entity: T | null) => {
            if (!entity) {
                throw new NotFoundException();
            }

            if (crudUpdateOneRequest.author) {
                _.merge(entity, { [crudUpdateOneRequest.author.property]: crudUpdateOneRequest.author.value });
            }

            return this.repository
                .save(_.assign(entity, crudUpdateOneRequest.body), crudUpdateOneRequest.saveOptions)
                .then((entity) => this.excludeEntity(entity, crudUpdateOneRequest.exclude))
                .catch(this.throwConflictException);
        });
    };

    readonly reservedDelete = async (crudDeleteOneRequest: CrudDeleteOneRequest<T>): Promise<T> => {
        if (this.primaryKey.length === 0) {
            throw new ConflictException('cannot found primary key from entity');
        }
        return this.findOne(crudDeleteOneRequest.params as unknown as FindOptionsWhere<T>, false).then(async (entity: T | null) => {
            if (!entity) {
                throw new NotFoundException();
            }

            if (crudDeleteOneRequest.author) {
                _.merge(entity, { [crudDeleteOneRequest.author.property]: crudDeleteOneRequest.author.value });

                await this.repository.save(entity, crudDeleteOneRequest.saveOptions);
            }

            await (crudDeleteOneRequest.softDeleted
                ? this.repository.softRemove(entity, crudDeleteOneRequest.saveOptions)
                : this.repository.remove(entity, crudDeleteOneRequest.saveOptions));
            return this.excludeEntity(entity, crudDeleteOneRequest.exclude);
        });
    };

    readonly reservedRecover = async (crudRecoverRequest: CrudRecoverRequest<T>): Promise<T> => {
        return this.findOne(crudRecoverRequest.params as unknown as FindOptionsWhere<T>, true).then(async (entity: T | null) => {
            if (!entity) {
                throw new NotFoundException();
            }
            await this.repository.recover(entity, crudRecoverRequest.saveOptions).catch(this.throwConflictException);
            return this.excludeEntity(entity, crudRecoverRequest.exclude);
        });
    };

    private async findOne(where: FindOptionsWhere<T>, withDeleted: boolean): Promise<T | null> {
        if (!this.usableQueryRunner) {
            return this.repository.findOne({ where, withDeleted });
        }
        const queryBuilder = this.repository.createQueryBuilder().where(where);
        if (withDeleted) {
            queryBuilder.withDeleted();
        }
        const runner = queryBuilder.connection.createQueryRunner('master');
        try {
            return await queryBuilder.setQueryRunner(runner).getOne();
        } finally {
            await runner.release();
        }
    }

    private excludeEntity(entity: T, exclude: Set<string>): T {
        if (exclude.size === 0) {
            return entity;
        }
        for (const excludeKey of exclude.values()) {
            delete entity[excludeKey as unknown as keyof T];
        }
        return entity;
    }

    private throwConflictException(error: Error): never {
        Logger.error(error);
        throw new ConflictException(error);
    }
}

1	import { ConflictException, Logger, NotFoundException } from '@nestjs/common';	288✔
2	import _ from 'lodash';	288✔
3	import { DeepPartial, FindOptionsWhere, Repository } from 'typeorm';
4
5	import {	288✔
6	CrudReadOneRequest,
7	CrudDeleteOneRequest,
8	CrudUpdateOneRequest,
9	CrudUpsertRequest,
10	CrudRecoverRequest,
11	PaginationResponse,
12	isCrudCreateManyRequest,
13	CrudCreateOneRequest,
14	CrudCreateManyRequest,
15	EntityType,
16	} from './interface';
17	import { CrudReadManyRequest } from './request';
18
19	const SUPPORTED_REPLICATION_TYPES = new Set(['mysql', 'mariadb', 'postgres', 'aurora-postgres', 'aurora-mysql']);	288✔
20
21	export class CrudService<T extends EntityType> {	288✔
22	private primaryKey: string[];
23	private columnNames: string[];
24	private usableQueryRunner = false;	396✔
25
26	constructor(public readonly repository: Repository<T>) {	396✔
27	this.usableQueryRunner = SUPPORTED_REPLICATION_TYPES.has(this.repository.metadata.connection?.options.type);	396✔
28	this.primaryKey = this.repository.metadata.primaryColumns?.map((columnMetadata) => columnMetadata.propertyName) ?? [];	412!
29	this.columnNames = this.repository.metadata.columns.map((column) =>	396✔
30	column.embeddedMetadata ? column.propertyPath : column.databaseName,	2,248✔
31	);
32	}
33
34	readonly reservedReadMany = async (crudReadManyRequest: CrudReadManyRequest<T>): Promise<PaginationResponse<T>> => {	724✔
35	crudReadManyRequest.excludedColumns(this.columnNames);	724✔
36	try {	720✔
37	const { entities, total } = await (async () => {	720✔
38	const findEntities = this.repository.find({ ...crudReadManyRequest.findOptions });	720✔
39
40	if (crudReadManyRequest.pagination.isNext) {	720✔
41	const entities = await findEntities;	96✔
42	return { entities, total: crudReadManyRequest.pagination.nextTotal() };	96✔
43	}
44	const [entities, total] = await Promise.all([	624✔
45	findEntities,
46	this.repository.count({
47	where: crudReadManyRequest.findOptions.where,
48	withDeleted: crudReadManyRequest.findOptions.withDeleted,
49	}),
50	]);
51	return { entities, total };	624✔
52	})();
53	return crudReadManyRequest.toResponse(entities, total);	720✔
54	} catch (error) {
UNCOV 55	Logger.error(JSON.stringify(crudReadManyRequest));	×
UNCOV 56	Logger.error(error);	×
UNCOV 57	throw error;	×
58	}
59	};
60
61	readonly reservedReadOne = async (crudReadOneRequest: CrudReadOneRequest<T>): Promise<T> => {	396✔
62	return this.repository	376✔
63	.findOne({
64	select: (crudReadOneRequest.selectColumns ?? this.columnNames).filter(	564✔
65	(columnName) => !crudReadOneRequest.excludedColumns?.includes(columnName),	2,016✔
66	),
67	where: crudReadOneRequest.params as FindOptionsWhere<T>,
68	withDeleted: crudReadOneRequest.softDeleted,
69	relations: crudReadOneRequest.relations,
70	})
71	.then((entity) => {
72	if (_.isNil(entity)) {	376✔
73	throw new NotFoundException();	96✔
74	}
75	return entity;	280✔
76	});
77	};
78
79	readonly reservedCreate = async (crudCreateRequest: CrudCreateOneRequest<T> \| CrudCreateManyRequest<T>): Promise<T \| T[]> => {	1,420✔
80	const entities = this.repository.create(	1,420✔
81	isCrudCreateManyRequest<T>(crudCreateRequest) ? crudCreateRequest.body : [crudCreateRequest.body],	710✔
82	);
83
84	if (crudCreateRequest.author) {	1,420✔
85	for (const entity of entities) {	12✔
86	_.merge(entity, { [crudCreateRequest.author.property]: crudCreateRequest.author.value });	12✔
87	}
88	}
89
90	return this.repository	1,420✔
91	.save(entities, crudCreateRequest.saveOptions)
92	.then((result) => {
93	return isCrudCreateManyRequest<T>(crudCreateRequest)	1,388✔
94	? result.map((entity) => this.excludeEntity(entity, crudCreateRequest.exclude))	24✔
95	: this.excludeEntity(result[0], crudCreateRequest.exclude);
96	})
97	.catch(this.throwConflictException);
98	};
99
100	readonly reservedUpsert = async (crudUpsertRequest: CrudUpsertRequest<T>): Promise<T> => {	396✔
101	return this.findOne(crudUpsertRequest.params as unknown as FindOptionsWhere<T>, true).then(async (entity: T \| null) => {	116✔
102	const upsertEntity = entity ?? this.repository.create(crudUpsertRequest.params as unknown as DeepPartial<T>);	116✔
103	if ('deletedAt' in upsertEntity && upsertEntity.deletedAt != null) {	116✔
104	throw new ConflictException('it has been deleted');	4✔
105	}
106
107	if (crudUpsertRequest.author) {	112✔
108	_.merge(upsertEntity, { [crudUpsertRequest.author.property]: crudUpsertRequest.author.value });	12✔
109	}
110
111	return this.repository	112✔
112	.save(_.assign(upsertEntity, crudUpsertRequest.body), crudUpsertRequest.saveOptions)
113	.then((entity) => this.excludeEntity(entity, crudUpsertRequest.exclude))	112✔
114	.catch(this.throwConflictException);
115	});
116	};
117
118	readonly reservedUpdate = async (crudUpdateOneRequest: CrudUpdateOneRequest<T>): Promise<T> => {	396✔
119	return this.findOne(crudUpdateOneRequest.params as unknown as FindOptionsWhere<T>, false).then(async (entity: T \| null) => {	112✔
120	if (!entity) {	112✔
121	throw new NotFoundException();	4✔
122	}
123
124	if (crudUpdateOneRequest.author) {	108✔
125	_.merge(entity, { [crudUpdateOneRequest.author.property]: crudUpdateOneRequest.author.value });	12✔
126	}
127
128	return this.repository	108✔
129	.save(_.assign(entity, crudUpdateOneRequest.body), crudUpdateOneRequest.saveOptions)
130	.then((entity) => this.excludeEntity(entity, crudUpdateOneRequest.exclude))	104✔
131	.catch(this.throwConflictException);
132	});
133	};
134
135	readonly reservedDelete = async (crudDeleteOneRequest: CrudDeleteOneRequest<T>): Promise<T> => {	408✔
136	if (this.primaryKey.length === 0) {	408✔
137	throw new ConflictException('cannot found primary key from entity');	4✔
138	}
139	return this.findOne(crudDeleteOneRequest.params as unknown as FindOptionsWhere<T>, false).then(async (entity: T \| null) => {	404✔
140	if (!entity) {	404✔
141	throw new NotFoundException();	20✔
142	}
143
144	if (crudDeleteOneRequest.author) {	384✔
145	_.merge(entity, { [crudDeleteOneRequest.author.property]: crudDeleteOneRequest.author.value });	8✔
146
147	await this.repository.save(entity, crudDeleteOneRequest.saveOptions);	8✔
148	}
149
150	await (crudDeleteOneRequest.softDeleted	384✔
151	? this.repository.softRemove(entity, crudDeleteOneRequest.saveOptions)
152	: this.repository.remove(entity, crudDeleteOneRequest.saveOptions));
153	return this.excludeEntity(entity, crudDeleteOneRequest.exclude);	384✔
154	});
155	};
156
157	readonly reservedRecover = async (crudRecoverRequest: CrudRecoverRequest<T>): Promise<T> => {	396✔
158	return this.findOne(crudRecoverRequest.params as unknown as FindOptionsWhere<T>, true).then(async (entity: T \| null) => {	68✔
159	if (!entity) {	68✔
160	throw new NotFoundException();	4✔
161	}
162	await this.repository.recover(entity, crudRecoverRequest.saveOptions).catch(this.throwConflictException);	64✔
163	return this.excludeEntity(entity, crudRecoverRequest.exclude);	64✔
164	});
165	};
166
167	private async findOne(where: FindOptionsWhere<T>, withDeleted: boolean): Promise<T \| null> {
168	if (!this.usableQueryRunner) {	700✔
169	return this.repository.findOne({ where, withDeleted });	16✔
170	}
171	const queryBuilder = this.repository.createQueryBuilder().where(where);	684✔
172	if (withDeleted) {	684✔
173	queryBuilder.withDeleted();	176✔
174	}
175	const runner = queryBuilder.connection.createQueryRunner('master');	684✔
176	try {	684✔
177	return await queryBuilder.setQueryRunner(runner).getOne();	684✔
178	} finally {
179	await runner.release();	684✔
180	}
181	}
182
183	private excludeEntity(entity: T, exclude: Set<string>): T {
184	if (exclude.size === 0) {	2,064✔
185	return entity;	2,032✔
186	}
187	for (const excludeKey of exclude.values()) {	32✔
188	delete entity[excludeKey as unknown as keyof T];	60✔
189	}
190	return entity;	32✔
191	}
192
193	private throwConflictException(error: Error): never {
194	Logger.error(error);	36✔
195	throw new ConflictException(error);	36✔
196	}
197	}

woowabros / nestjs-library-crud / 7858722036

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous