9241675021

Committed 26 May 2024 07:53AM UTC coverage: 97.873% (-0.002%) from 97.875%

Build # 9241675021

Build Type

Pull #547

github

Committed by

web-flow

Commit Message

Merge 5ecf0f044 into a103a02b8

Pull Request Pull Request #547: feat: update eslint

Run Details

1016 of 1055 branches covered (96.3%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

1009 of 1014 relevant lines covered (99.51%)

627.07 hits per line

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

95.29

/src/lib/provider/typeorm-query-builder.helper.ts

import { UnprocessableEntityException } from '@nestjs/common';
import { Not, MoreThan, MoreThanOrEqual, LessThan, LessThanOrEqual, Like, ILike, Between, In, IsNull, Raw } from 'typeorm';

import { operatorBetween, operatorIn, operatorNull } from '../interface/query-operation.interface';

import type { EntityType } from '../interface';
import type { QueryFilter } from '../interface/query-operation.interface';
import type { FindOptionsWhere } from 'typeorm';

export class TypeOrmQueryBuilderHelper {
    static queryFilterToFindOptionsWhere<T extends EntityType>(filter: QueryFilter<T>, index: number): FindOptionsWhere<T> {
        const prefix = (() => {
            let num = index;
            let letters = '';
            while (num >= 0) {
                letters = String.fromCharCode(65 + (num % 26)) + letters;
                num = Math.floor(num / 26) - 1;
            }
            return letters;
        })();
        let parametersIndex = 0;
        function getParameterName() {
            return [prefix, parametersIndex++].join('');
        }
        const findOptionsWhere: Record<string, unknown> = {};
        for (const [field, operation] of Object.entries(filter)) {
            if (typeof operation === 'object' && operation !== null) {
                if ('operator' in operation) {
                    if (operation.operator === operatorNull) {
                        findOptionsWhere[field] = IsNull();
                    }

                    if ('operand' in operation) {
                        const paramName = getParameterName();
                        const { operator, operand } = operation;
                        switch (operator) {
                            case '=':
                                findOptionsWhere[field] = operand;
                                break;
                            case '!=':
                                findOptionsWhere[field] = Not(operand);
                                break;
                            case '>':
                                findOptionsWhere[field] = MoreThan(operand);
                                break;
                            case '>=':
                                findOptionsWhere[field] = MoreThanOrEqual(operand);
                                break;
                            case '<':
                                findOptionsWhere[field] = LessThan(operand);
                                break;
                            case '<=':
                                findOptionsWhere[field] = LessThanOrEqual(operand);
                                break;
                            case 'LIKE':
                                findOptionsWhere[field] = Like(operand);
                                break;
                            case 'ILIKE':
                                findOptionsWhere[field] = ILike(operand);
                                break;
                            case '?':
                                findOptionsWhere[field] = Raw((alias) => `${alias} ? :${paramName}`, {
                                    [paramName]: operand,
                                });
                                break;
                            case '@>':
                                findOptionsWhere[field] = Raw((alias) => `${alias} @> :${paramName}`, {
                                    [paramName]: operand,
                                });
                                break;
                            case 'JSON_CONTAINS':
                                findOptionsWhere[field] = Raw((alias) => `JSON_CONTAINS (${alias}, :${paramName})`, {
                                    [paramName]: operand,
                                });
                                break;
                            case operatorBetween:
                                if (!Array.isArray(operand) || operand.length !== 2) {
                                    throw new UnprocessableEntityException(`Invalid operand for operator ${operatorBetween}`);
                                }
                                findOptionsWhere[field] = Between(operand[0], operand[1]);
                                break;
                            case operatorIn:
                                if (!Array.isArray(operand)) {
                                    throw new UnprocessableEntityException(`Invalid operand for operator ${operatorBetween}`);
                                }
                                findOptionsWhere[field] = In(operand);
                                break;
                        }
                    }
                }

                if (findOptionsWhere[field] && 'not' in operation && operation.not) {
                    findOptionsWhere[field] = Not(findOptionsWhere[field]);
                }
            }
        }

        return findOptionsWhere as FindOptionsWhere<T>;
    }
}

1	import { UnprocessableEntityException } from '@nestjs/common';	336✔
2	import { Not, MoreThan, MoreThanOrEqual, LessThan, LessThanOrEqual, Like, ILike, Between, In, IsNull, Raw } from 'typeorm';	336✔
3
4	import { operatorBetween, operatorIn, operatorNull } from '../interface/query-operation.interface';	336✔
5
6	import type { EntityType } from '../interface';
7	import type { QueryFilter } from '../interface/query-operation.interface';
8	import type { FindOptionsWhere } from 'typeorm';
9
10	export class TypeOrmQueryBuilderHelper {	336✔
11	static queryFilterToFindOptionsWhere<T extends EntityType>(filter: QueryFilter<T>, index: number): FindOptionsWhere<T> {
12	const prefix = (() => {	300✔
13	let num = index;	300✔
14	let letters = '';	300✔
15	while (num >= 0) {	300✔
16	letters = String.fromCharCode(65 + (num % 26)) + letters;	300✔
17	num = Math.floor(num / 26) - 1;	300✔
18	}
19	return letters;	300✔
20	})();
21	let parametersIndex = 0;	300✔
22	function getParameterName() {
23	return [prefix, parametersIndex++].join('');	356✔
24	}
25	const findOptionsWhere: Record<string, unknown> = {};	300✔
26	for (const [field, operation] of Object.entries(filter)) {	300✔
27	if (typeof operation === 'object' && operation !== null) {	384✔
28	if ('operator' in operation) {	384✔
29	if (operation.operator === operatorNull) {	384✔
30	findOptionsWhere[field] = IsNull();	28✔
31	}
32
33	if ('operand' in operation) {	384✔
34	const paramName = getParameterName();	356✔
35	const { operator, operand } = operation;	356✔
36	switch (operator) {	356✔
37	case '=':
38	findOptionsWhere[field] = operand;	80✔
39	break;	80✔
40	case '!=':
41	findOptionsWhere[field] = Not(operand);	12✔
42	break;	12✔
43	case '>':
44	findOptionsWhere[field] = MoreThan(operand);	12✔
45	break;	12✔
46	case '>=':
47	findOptionsWhere[field] = MoreThanOrEqual(operand);	12✔
48	break;	12✔
49	case '<':
50	findOptionsWhere[field] = LessThan(operand);	28✔
51	break;	28✔
52	case '<=':
53	findOptionsWhere[field] = LessThanOrEqual(operand);	12✔
54	break;	12✔
55	case 'LIKE':
56	findOptionsWhere[field] = Like(operand);	24✔
57	break;	24✔
58	case 'ILIKE':
59	findOptionsWhere[field] = ILike(operand);	12✔
60	break;	12✔
61	case '?':
62	findOptionsWhere[field] = Raw((alias) => `${alias} ? :${paramName}`, {	16✔
63	[paramName]: operand,
64	});
65	break;	8✔
66	case '@>':
67	findOptionsWhere[field] = Raw((alias) => `${alias} @> :${paramName}`, {	128✔
68	[paramName]: operand,
69	});
70	break;	64✔
71	case 'JSON_CONTAINS':
72	findOptionsWhere[field] = Raw((alias) => `JSON_CONTAINS (${alias}, :${paramName})`, {	40✔
73	[paramName]: operand,
74	});
75	break;	20✔
76	case operatorBetween:
77	if (!Array.isArray(operand) \|\| operand.length !== 2) {	24✔
UNCOV 78	throw new UnprocessableEntityException(`Invalid operand for operator ${operatorBetween}`);	×
79	}
80	findOptionsWhere[field] = Between(operand[0], operand[1]);	24✔
81	break;	24✔
82	case operatorIn:
83	if (!Array.isArray(operand)) {	48!
84	throw new UnprocessableEntityException(`Invalid operand for operator ${operatorBetween}`);	×
85	}
86	findOptionsWhere[field] = In(operand);	48✔
87	break;	48✔
88	}
89	}
90	}
91
92	if (findOptionsWhere[field] && 'not' in operation && operation.not) {	384✔
93	findOptionsWhere[field] = Not(findOptionsWhere[field]);	56✔
94	}
95	}
96	}
97
98	return findOptionsWhere as FindOptionsWhere<T>;	300✔
99	}
100	}

woowabros / nestjs-library-crud / 9241675021

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