@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
132 lines • 20.8 kB
JavaScript
import { Query } from '../query/query';
import { BooleanOperator } from '../boolean-operator';
/**
* Represents the low level abstraction of query generation that is responsible for the creation of queries themselves.
*
* Operators are ment to be stateless and held as singleton instances, as they can be shared without any issues.
* This library uses the {@link OperatorService} to store the singleton instances, but you can use your own solution,
* or instantiate them multiple times if you prefer.
*
* @typeparam T type of arguments this Operator can generate queries from
*/
export class Operator {
/**
* Represents the placeholder "block" in operator display names.
*/
static INPUT_PLACEHOLDER = '';
/**
* Reserved characters for Elasticsearch queries. These characters can be escaped with a `\` character.
*/
static ESCAPABLE_CHARACTERS = new Set(['+', '-', '=', '&', '|', '!', '(', ')', '{', '}', '[', ']', '^', '"', '~', '*', '?', ':', '\\', '/']);
/**
* Reserved characters for Elasticsearch queries. These characters cannot be escaped and must be removed from queries.
*/
static UNESCAPABLE_CHARACTERS = new Set(['<', '>']);
/**
* Determines the arity of the operator, that is the number of arguments/operands it takes.
*/
_numberOfOperands;
/**
* The operator symbol that is used to generate the query.
*/
_operatorSymbols;
constructor(numberOfOperands, operatorSymbols = '') {
this._numberOfOperands = numberOfOperands;
this._operatorSymbols = operatorSymbols;
}
/**
* Escapes all escapable Elasticsearch symbols. Removes all unescapable Elasticsearch symbols.
*
* For a list of symbols see Elasticsearch's Query string query
* [doc]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters}.
* @param input user input that should have special characters escaped
* @returns user input with the escapable characters escaped and the unescapable characters removed
*/
static escapeInput(input) {
if (typeof input === 'string') {
let escaped = false;
let output = '';
for (let i = 0; i < input.length; i++) {
if (Operator.UNESCAPABLE_CHARACTERS.has(input.charAt(i)))
continue;
if (Operator.ESCAPABLE_CHARACTERS.has(input.charAt(i))) {
output += '\\';
escaped = true;
}
output += input.charAt(i);
}
return { value: output, wasEscaped: escaped };
}
return { value: input, wasEscaped: false };
}
/**
* Creates a Query string query string literal with the provided arguments.
* @param elasticKeyword Elasticsearch index keyword for the field you want to query
* @param arg The value that you want to query the property for
* @param operator The operator you want to use to query the indexed field. Consult the Elasticsearch's
* [documentation]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html}
* for more information.
* @returns combines the input strings by this pattern: `([elasticKeyword]:[operator][arg])`
*/
static query(elasticKeyword, arg, operator) {
return `(${elasticKeyword}:${operator}${arg})`;
}
/**
* Applies the provided function to all keywords and combines the resulting queries with an `OR` operator.
* @param elasticKeywords keywords that the function is call on
* @param queryConstructor function that generates a `Query` object for each keyword
*/
static forEachKeyword(elasticKeywords, queryConstructor) {
const simpleQueries = [];
elasticKeywords.forEach(keyword => {
simpleQueries.push(queryConstructor(keyword));
});
return Query.combineQueries(simpleQueries, BooleanOperator.OR);
}
/**
* If the value contains a space character, or if `force` is set to `true`.
* @param input user input that should be wrapped with double quotes
* @param forceWrap if set to `true` the value will be wrapped regardless of it's content
*/
static wrapInputWithQuotes(input, forceWrap = false) {
if (typeof input === 'string' && (input?.includes(' ') || forceWrap))
return { value: `"${input}"`, wasWrapped: true };
else
return { value: input, wasWrapped: false };
}
/**
* @returns the arity of the operator.
*/
get numberOfOperands() {
return this._numberOfOperands;
}
/**
* Simple implementation of query generation. Will not be suitable for all Operator derivatives.
*
* Escapes the first argument from the `args` array, calls the [query()]{@link Operator#query} function for each `keyword` and combines
* the results with an `OR` operator.
* @returns query that wos constructed with the given arguments and keywords. Returns an empty query if no arguments are provided.
*/
createQuery(elasticKeywords, args, escapeArgs = true) {
this.checkArgumentsCount(args);
return Operator.forEachKeyword(elasticKeywords, (keyword) => {
const escapedValue = escapeArgs ?
Operator.escapeInput(args[0]) : ({ value: args[0], wasEscaped: false });
const wrappedValue = Operator.wrapInputWithQuotes(escapedValue.value, escapedValue.wasEscaped);
const queryString = Operator.query(keyword, wrappedValue.value, this._operatorSymbols);
return new Query(queryString);
});
}
/**
* Checks whether the provided array contains at leas as many arguments, as is the operators number of operands.
* Throws an error if not enough arguments is provided.
* @param args an array of potential operands
*/
checkArgumentsCount(args) {
if (args.length < this.numberOfOperands) {
throw new Error(`At least ${this.numberOfOperands} arguments must be provided to `
+ `create a query with ${this.numberOfOperands} operands!`);
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operator.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/lib/search/models/operator/operator.ts"],"names":[],"mappings":"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","sourcesContent":["import {EscapeResult} from '../escape-result';\nimport {Query} from '../query/query';\nimport {BooleanOperator} from '../boolean-operator';\nimport {WrapResult} from '../wrap-result';\nimport {Operators} from './operators';\n\n/**\n * Represents the low level abstraction of query generation that is responsible for the creation of queries themselves.\n *\n * Operators are ment to be stateless and held as singleton instances, as they can be shared without any issues.\n * This library uses the {@link OperatorService} to store the singleton instances, but you can use your own solution,\n * or instantiate them multiple times if you prefer.\n *\n * @typeparam T type of arguments this Operator can generate queries from\n */\nexport abstract class Operator<T> {\n\n    /**\n     * Represents the placeholder \"block\" in operator display names.\n     */\n    public static readonly INPUT_PLACEHOLDER = '';\n\n    /**\n     * Reserved characters for Elasticsearch queries. These characters can be escaped with a `\\` character.\n     */\n    private static readonly ESCAPABLE_CHARACTERS = new Set(\n        ['+', '-', '=', '&', '|', '!', '(', ')', '{', '}', '[', ']', '^', '\"', '~', '*', '?', ':', '\\\\', '/']);\n\n    /**\n     * Reserved characters for Elasticsearch queries. These characters cannot be escaped and must be removed from queries.\n     */\n    private static readonly UNESCAPABLE_CHARACTERS = new Set(['<', '>']);\n\n    /**\n     * Determines the arity of the operator, that is the number of arguments/operands it takes.\n     */\n    private readonly _numberOfOperands: number;\n\n    /**\n     * The operator symbol that is used to generate the query.\n     */\n    private readonly _operatorSymbols: string;\n\n    protected constructor(numberOfOperands: number, operatorSymbols = '') {\n        this._numberOfOperands = numberOfOperands;\n        this._operatorSymbols = operatorSymbols;\n    }\n\n    /**\n     * Escapes all escapable Elasticsearch symbols. Removes all unescapable Elasticsearch symbols.\n     *\n     * For a list of symbols see Elasticsearch's Query string query\n     * [doc]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters}.\n     * @param input user input that should have special characters escaped\n     * @returns user input with the escapable characters escaped and the unescapable characters removed\n     */\n    public static escapeInput(input: string): EscapeResult {\n        if (typeof input === 'string') {\n            let escaped = false;\n            let output = '';\n            for (let i = 0; i < input.length; i++) {\n                if (Operator.UNESCAPABLE_CHARACTERS.has(input.charAt(i)))\n                    continue;\n                if (Operator.ESCAPABLE_CHARACTERS.has(input.charAt(i))) {\n                    output += '\\\\';\n                    escaped = true;\n                }\n                output += input.charAt(i);\n            }\n            return {value: output, wasEscaped: escaped};\n        }\n        return {value: input, wasEscaped: false};\n    }\n\n    /**\n     * Creates a Query string query string literal with the provided arguments.\n     * @param elasticKeyword Elasticsearch index keyword for the field you want to query\n     * @param arg The value that you want to query the property for\n     * @param operator The operator you want to use to query the indexed field. Consult the Elasticsearch's\n     * [documentation]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html}\n     * for more information.\n     * @returns combines the input strings by this pattern: `([elasticKeyword]:[operator][arg])`\n     */\n    public static query(elasticKeyword: string, arg: string, operator: string): string {\n        return `(${elasticKeyword}:${operator}${arg})`;\n    }\n\n    /**\n     * Applies the provided function to all keywords and combines the resulting queries with an `OR` operator.\n     * @param elasticKeywords keywords that the function is call on\n     * @param queryConstructor function that generates a `Query` object for each keyword\n     */\n    public static forEachKeyword(elasticKeywords: Array<string>, queryConstructor: (keyword: string) => Query): Query {\n        const simpleQueries = [];\n        elasticKeywords.forEach(keyword => {\n            simpleQueries.push(queryConstructor(keyword));\n        });\n        return Query.combineQueries(simpleQueries, BooleanOperator.OR);\n    }\n\n    /**\n     * If the value contains a space character, or if `force` is set to `true`.\n     * @param input user input that should be wrapped with double quotes\n     * @param forceWrap if set to `true` the value will be wrapped regardless of it's content\n     */\n    public static wrapInputWithQuotes(input: string, forceWrap = false): WrapResult {\n        if (typeof input === 'string' && (input?.includes(' ') || forceWrap))\n            return {value: `\"${input}\"`, wasWrapped: true};\n        else\n            return {value: input, wasWrapped: false};\n    }\n\n    /**\n     * @returns the arity of the operator.\n     */\n    public get numberOfOperands(): number {\n        return this._numberOfOperands;\n    }\n\n    /**\n     * Simple implementation of query generation. Will not be suitable for all Operator derivatives.\n     *\n     * Escapes the first argument from the `args` array, calls the [query()]{@link Operator#query} function for each `keyword` and combines\n     * the results with an `OR` operator.\n     * @returns query that wos constructed with the given arguments and keywords. Returns an empty query if no arguments are provided.\n     */\n    public createQuery(elasticKeywords: Array<string>, args: Array<T>, escapeArgs = true): Query {\n        this.checkArgumentsCount(args);\n        return Operator.forEachKeyword(elasticKeywords, (keyword: string) => {\n            const escapedValue = escapeArgs ?\n                Operator.escapeInput(args[0] as unknown as string) : ({value: args[0] as unknown as string, wasEscaped: false});\n            const wrappedValue = Operator.wrapInputWithQuotes(escapedValue.value, escapedValue.wasEscaped);\n            const queryString = Operator.query(keyword, wrappedValue.value, this._operatorSymbols);\n            return new Query(queryString);\n        });\n    }\n\n    /**\n     * The name template is used when generating search GUI, and so the arity of the operator should match the number of\n     * {@link INPUT_PLACEHOLDER} constant occurrences in the returned array.\n     *\n     * @returns an array of translation paths that represent the operator name, as it should be displayed to the user.\n     * The {@link INPUT_PLACEHOLDER} constant (or any falsy value) can be used to place visual input placeholder blocks in the\n     * operator name where user input is expected.\n     */\n    public abstract getOperatorNameTemplate(): Array<string>;\n\n    /**\n     * @returns the operator class in a serializable form\n     */\n    public abstract serialize(): Operators | string;\n\n    /**\n     * Checks whether the provided array contains at leas as many arguments, as is the operators number of operands.\n     * Throws an error if not enough arguments is provided.\n     * @param args an array of potential operands\n     */\n    protected checkArgumentsCount(args: Array<any>): void {\n        if (args.length < this.numberOfOperands) {\n            throw new Error(`At least ${this.numberOfOperands} arguments must be provided to `\n                + `create a query with ${this.numberOfOperands} operands!`);\n        }\n    }\n}\n"]}