regevbr/json-expression-eval

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export interface NinCompareOp<C extends Context, Ignore, V extends Primitive> {
    nin: (V | PropertyRef<C, Ignore, V> | (V extends number ? MathOp<C, Ignore> : never))[];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export interface InqCompareOp<C extends Context, Ignore, V extends Primitive> {
    inq: (V | PropertyRef<C, Ignore, V> | (V extends number ? MathOp<C, Ignore> : never))[];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export interface NotEqualCompareOp<C extends Context, Ignore, V extends Primitive> {
    neq: V | PropertyRef<C, Ignore, V> | (V extends number ? MathOp<C, Ignore> : never);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export interface EqualCompareOp<C extends Context, Ignore, V extends Primitive> {
    eq: V | PropertyRef<C, Ignore, V> | (V extends number ? MathOp<C, Ignore> : never);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export const isNinCompareOp = (op: ExtendedCompareOp<any, any, any>)
    : op is NinCompareOp<any, any, any> => {
    return Array.isArray((op as NinCompareOp<any, any, any>).nin);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export const isInqCompareOp = (op: ExtendedCompareOp<any, any, any>)
    : op is InqCompareOp<any, any, any> => {
    return Array.isArray((op as InqCompareOp<any, any, any>).inq);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export const isNotEqualCompareOp = (op: ExtendedCompareOp<any, any, any>)
    : op is NotEqualCompareOp<any, any, any> => {
    return (op as NotEqualCompareOp<any, any, any>).neq !== undefined;
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export const isEqualCompareOp = (op: ExtendedCompareOp<any, any, any>)
    : op is EqualCompareOp<any, any, any> => {
    return (op as EqualCompareOp<any, any, any>).eq !== undefined;
}

• Read up
  Read up

Function evaluateCompareOp has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

async function evaluateCompareOp<C extends Context, Ignore>(expressionValue: ExtendedCompareOp<any, any, any>,
                                                            expressionKey: string, contextValue: any,
                                                            context: C, validation: boolean)

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    } else if (isLteCompareOp(expressionValue)) {
        contextNumberAssertion(expressionKey, contextValue);
        const lteValue = computeValue(context, validation, expressionValue.lte, expressionKey);
        expressionNumberAssertion(expressionKey, lteValue);
        return contextValue <= lteValue;

• Read up
  Read up

Avoid too many return statements within this function.

Open

        return expressionValue.nin.map((value) => computeValue(context, validation, value, expressionKey))
            .indexOf(contextValue) < 0;

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    } else if (isGteCompareOp(expressionValue)) {
        contextNumberAssertion(expressionKey, contextValue);
        const gteValue = computeValue(context, validation, expressionValue.gte, expressionKey);
        expressionNumberAssertion(expressionKey, gteValue);
        return contextValue >= gteValue;

• Read up
  Read up

Avoid too many return statements within this function.

Open

        return evaluateCompareOp<C, Ignore>(
            (expression as PropertyCompareOps<C, Ignore>)
                [expressionKey as any as keyof PropertyCompareOps<C, Ignore>] as
                unknown as ExtendedCompareOp<any, any, any>,
            expressionKey, contextValue, context, validation);

Avoid too many return statements within this function.

Open

        return contextValue > gtValue;

Avoid too many return statements within this function.

Open

        return Boolean(contextValue.match(new RegExp(regexpiValue, `i`)));

Avoid too many return statements within this function.

Open

        return contextValue < ltValue;

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    } else if (isGtCompareOp(expressionValue)) {
        contextNumberAssertion(expressionKey, contextValue);
        const gtValue = computeValue(context, validation, expressionValue.gt, expressionKey);
        expressionNumberAssertion(expressionKey, gtValue);
        return contextValue > gtValue;

• Read up
  Read up

Avoid too many return statements within this function.

Open

        return Boolean(contextValue.match(new RegExp(regexpValue)));

Avoid too many return statements within this function.

Open

        return contextValue >= gteValue;

Avoid too many return statements within this function.

Open

        return contextValue <= lteValue;