@react-querybuilder/core
Version:
React Query Builder component for constructing queries and filters, with utilities for executing them in various database and evaluation contexts
1 lines • 31.2 kB
Source Map (JSON)
{"version":3,"file":"parseJSONata.mjs","names":["negatedLikeOperators: Record<\n Extract<DefaultOperatorName, 'beginsWith' | 'contains' | 'endsWith'>,\n DefaultOperatorName\n>","returnArray: (DefaultCombinatorName | JSONataExprNode | ('and' | JSONataExprNode)[])[]","emptyQuery: DefaultRuleGroupTypeAny","rules","field: string","regex: string | RegExp","valueSource: ValueSource | undefined","value: any[]","field: string | null","value: any","jsonataExpr: jsonata.Expression"],"sources":["../src/utils/parseJSONata/utils.ts","../src/utils/parseJSONata/parseJSONata.ts"],"sourcesContent":["import type { DefaultCombinatorName, DefaultOperatorName } from '../../types';\nimport type {\n JSONataAnd,\n JSONataBinaryNode,\n JSONataBlock,\n JSONataBoolean,\n JSONataContains,\n JSONataEqual,\n JSONataExprNode,\n JSONataGreaterThan,\n JSONataGreaterThanOrEqual,\n JSONataIdentifier,\n JSONataIn,\n JSONataLessThan,\n JSONataLessThanOrEqual,\n JSONataList,\n JSONataName,\n JSONataNot,\n JSONataNotEqual,\n JSONataNull,\n JSONataNumber,\n JSONataOr,\n JSONataPath,\n JSONataRegex,\n JSONataString,\n JSONataToMillis,\n} from './types';\n\n// oxlint-disable-next-line typescript/no-explicit-any\ntype Any = any;\n\nexport const isJSONataExprNode = (expr: Any): expr is JSONataExprNode => {\n return expr && typeof expr === 'object' && typeof expr.type === 'string';\n};\nconst isJSONataBinaryNode = (expr: Any): expr is JSONataBinaryNode =>\n isJSONataExprNode(expr) && expr.type === 'binary';\n\n// Identifiers\nexport const isJSONataPath = (expr: Any): expr is JSONataPath =>\n isJSONataExprNode(expr) &&\n expr.type === 'path' &&\n Array.isArray(expr.steps) &&\n expr.steps.length > 0 &&\n isJSONataExprNode(expr.steps[0]);\nexport const isJSONataName = (expr: Any): expr is JSONataName =>\n isJSONataExprNode(expr) &&\n expr.type === 'name' &&\n typeof expr.value === 'string' &&\n expr.value.length > 0;\nexport const isJSONataIdentifier = (expr: Any): expr is JSONataIdentifier =>\n isJSONataPath(expr) && expr.steps.every(v => isJSONataName(v));\n\n// Groups\nexport const isJSONataBlock = (expr: Any): expr is JSONataBlock =>\n isJSONataExprNode(expr) &&\n expr.type === 'block' &&\n Array.isArray(expr.expressions) &&\n expr.expressions.length > 0 &&\n isJSONataExprNode(expr.expressions[0]);\n\n// Values\nexport const isJSONataString = (expr: Any): expr is JSONataString =>\n isJSONataExprNode(expr) && expr.type === 'string' && typeof expr.value === 'string';\nexport const isJSONataNumber = (expr: Any): expr is JSONataNumber =>\n isJSONataExprNode(expr) && expr.type === 'number' && typeof expr.value === 'number';\nexport const isJSONataBoolean = (expr: Any): expr is JSONataBoolean =>\n isJSONataExprNode(expr) && expr.type === 'value' && typeof expr.value === 'boolean';\nexport const isJSONataNull = (expr: Any): expr is JSONataNull =>\n isJSONataExprNode(expr) && expr.type === 'value' && expr.value === null;\nexport const isJSONataRegex = (expr: Any): expr is JSONataRegex =>\n isJSONataExprNode(expr) && expr.type === 'regex' && expr.value instanceof RegExp;\n\n// Combinators\nexport const isJSONataAnd = (expr: Any): expr is JSONataAnd =>\n isJSONataBinaryNode(expr) && expr.value === 'and';\nexport const isJSONataOr = (expr: Any): expr is JSONataOr =>\n isJSONataBinaryNode(expr) && expr.value === 'or';\n\n// Operators\nexport const isJSONataEqual = (expr: Any): expr is JSONataEqual =>\n isJSONataBinaryNode(expr) && expr.value === '=';\nexport const isJSONataNotEqual = (expr: Any): expr is JSONataNotEqual =>\n isJSONataBinaryNode(expr) && expr.value === '!=';\nexport const isJSONataGreaterThan = (expr: Any): expr is JSONataGreaterThan =>\n isJSONataBinaryNode(expr) && expr.value === '>';\nexport const isJSONataGreaterThanOrEqual = (expr: Any): expr is JSONataGreaterThanOrEqual =>\n isJSONataBinaryNode(expr) && expr.value === '>=';\nexport const isJSONataLessThan = (expr: Any): expr is JSONataLessThan =>\n isJSONataBinaryNode(expr) && expr.value === '<';\nexport const isJSONataLessThanOrEqual = (expr: Any): expr is JSONataLessThanOrEqual =>\n isJSONataBinaryNode(expr) && expr.value === '<=';\nexport const isJSONataIn = (expr: Any): expr is JSONataIn =>\n isJSONataBinaryNode(expr) &&\n expr.value === 'in' &&\n isJSONataPath(expr.lhs) &&\n isJSONataList(expr.rhs);\n\n// Functions\nexport const isJSONataNot = (expr: Any): expr is JSONataNot =>\n isJSONataExprNode(expr) &&\n expr.type === 'function' &&\n expr.value === '(' &&\n Array.isArray(expr.arguments) &&\n isJSONataExprNode(expr.arguments[0]) &&\n isJSONataExprNode(expr.procedure) &&\n expr.procedure.value === 'not' &&\n expr.procedure.type === 'variable';\nexport const isJSONataContains = (expr: Any): expr is JSONataContains =>\n isJSONataExprNode(expr) &&\n expr.type === 'function' &&\n expr.value === '(' &&\n Array.isArray(expr.arguments) &&\n expr.arguments.length >= 2 &&\n isJSONataExprNode(expr.arguments[0]) &&\n isJSONataExprNode(expr.procedure) &&\n expr.procedure.value === 'contains' &&\n expr.procedure.type === 'variable';\nexport const isJSONataToMillis = (expr: Any): expr is JSONataToMillis =>\n isJSONataExprNode(expr) &&\n expr.type === 'function' &&\n expr.value === '(' &&\n Array.isArray(expr.arguments) &&\n expr.arguments.length > 0 &&\n isJSONataString(expr.arguments[0]) &&\n isJSONataExprNode(expr.procedure) &&\n expr.procedure.value === 'toMillis' &&\n expr.procedure.type === 'variable';\n\n// Miscellaneous\nexport const isJSONataList = (expr: Any): expr is JSONataList =>\n isJSONataExprNode(expr) &&\n expr.type === 'unary' &&\n expr.value === '[' &&\n Array.isArray(expr.expressions);\nexport const isJSONataPrimitive = (expr: Any): boolean => {\n return (\n isJSONataString(expr) ||\n isJSONataNumber(expr) ||\n isJSONataBoolean(expr) ||\n isJSONataNull(expr) ||\n isJSONataToMillis(expr)\n );\n};\nexport const isJSONataPrimitiveList = (expr: Any): boolean =>\n isJSONataList(expr) && expr.expressions.every(v => isJSONataPrimitive(v));\nexport const isJSONataIdentifierList = (expr: Any): boolean =>\n isJSONataList(expr) && expr.expressions.every(v => isJSONataIdentifier(v));\nexport const isJSONataValidValue = (expr: Any): boolean =>\n isJSONataPrimitive(expr) ||\n isJSONataRegex(expr) ||\n isJSONataIdentifier(expr) ||\n isJSONataPrimitiveList(expr) ||\n isJSONataIdentifierList(expr) ||\n isJSONataToMillis(expr);\nexport const isJSONataComparison = (\n expr: Any\n): expr is\n | JSONataEqual\n | JSONataNotEqual\n | JSONataGreaterThan\n | JSONataGreaterThanOrEqual\n | JSONataLessThan\n | JSONataLessThanOrEqual =>\n isJSONataEqual(expr) ||\n isJSONataNotEqual(expr) ||\n isJSONataGreaterThan(expr) ||\n isJSONataGreaterThanOrEqual(expr) ||\n isJSONataLessThan(expr) ||\n isJSONataLessThanOrEqual(expr);\n\nexport const getValidValue = (expr: Any): Any => {\n if (isJSONataToMillis(expr)) {\n return getValidValue(expr.arguments[0]);\n } else if (isJSONataIdentifier(expr)) {\n return getFieldFromPath(expr);\n } else if (isJSONataPrimitiveList(expr)) {\n return expr.expressions.map((v: Any) => getValidValue(v));\n } else if (isJSONataIdentifierList(expr)) {\n return expr.expressions.map((v: Any) => getFieldFromPath(v));\n }\n return expr.value;\n};\n\nexport const getFieldFromPath = (path: JSONataPath): string =>\n isJSONataIdentifier(path)\n ? path.steps.map(s => s.value).join('.')\n : /* istanbul ignore next */ '';\n\nexport const normalizeOperator = (\n opType: DefaultOperatorName,\n flip?: boolean\n): DefaultOperatorName => {\n if (flip) {\n if (opType === '<') return '>';\n if (opType === '<=') return '>=';\n if (opType === '>') return '<';\n if (opType === '>=') return '<=';\n }\n return opType;\n};\n\nexport const negatedLikeOperators: Record<\n Extract<DefaultOperatorName, 'beginsWith' | 'contains' | 'endsWith'>,\n DefaultOperatorName\n> = {\n contains: 'doesNotContain',\n beginsWith: 'doesNotBeginWith',\n endsWith: 'doesNotEndWith',\n} satisfies Record<\n Extract<DefaultOperatorName, 'beginsWith' | 'contains' | 'endsWith'>,\n DefaultOperatorName\n>;\n\nexport const generateFlatAndOrList = (\n expr: JSONataExprNode\n): (DefaultCombinatorName | JSONataExprNode)[] => {\n // istanbul ignore else\n if (isJSONataAnd(expr) || isJSONataOr(expr)) {\n const { lhs, rhs, value: combinator } = expr;\n if (isJSONataAnd(lhs) || isJSONataOr(lhs)) {\n return [...generateFlatAndOrList(lhs), combinator, rhs];\n }\n return [lhs, combinator, rhs];\n }\n // istanbul ignore next\n return [];\n};\n\nexport const generateMixedAndOrList = (\n expr: JSONataAnd | JSONataOr\n): (JSONataExprNode | DefaultCombinatorName | (JSONataExprNode | 'and')[])[] => {\n const arr = generateFlatAndOrList(expr);\n const returnArray: (DefaultCombinatorName | JSONataExprNode | ('and' | JSONataExprNode)[])[] = [];\n let startIndex = 0;\n for (let i = 0; i < arr.length; i += 2) {\n if (arr[i + 1] === 'and') {\n startIndex = i;\n let j = 1;\n while (arr[startIndex + j] === 'and') {\n i += 2;\n j += 2;\n }\n const tempAndArray = arr.slice(startIndex, i + 1) as ('and' | JSONataExprNode)[];\n returnArray.push(tempAndArray);\n i -= 2;\n } else if (arr[i + 1] === 'or') {\n if (i === 0 || i === arr.length - 3) {\n if (i === 0 || arr[i - 1] === 'or') {\n returnArray.push(arr[i]);\n }\n returnArray.push(arr[i + 1]);\n if (i === arr.length - 3) {\n returnArray.push(arr[i + 2]);\n }\n } else {\n if (arr[i - 1] === 'and') {\n returnArray.push(arr[i + 1]);\n } else {\n returnArray.push(arr[i], arr[i + 1]);\n }\n }\n }\n }\n if (returnArray.length === 1 && Array.isArray(returnArray[0])) {\n // If length is 1, then the only element is an AND array so just return that\n return returnArray[0];\n }\n return returnArray;\n};\n","import jsonata from 'jsonata';\nimport type { Except } from 'type-fest';\nimport type {\n DefaultCombinatorName,\n DefaultOperatorName,\n DefaultRuleGroupArray,\n DefaultRuleGroupICArray,\n DefaultRuleGroupType,\n DefaultRuleGroupTypeAny,\n DefaultRuleGroupTypeIC,\n DefaultRuleType,\n ValueSource,\n} from '../../types';\nimport type { ParserCommonOptions } from '../../types/import';\nimport { isRuleGroup } from '../isRuleGroup';\nimport { fieldIsValidUtil, getFieldsArray } from '../parserUtils';\nimport { prepareRuleGroup } from '../prepareQueryObjects';\nimport type { JSONataExprNode } from './types';\nimport {\n generateFlatAndOrList,\n generateMixedAndOrList,\n getFieldFromPath,\n getValidValue,\n isJSONataAnd,\n isJSONataBlock,\n isJSONataComparison,\n isJSONataContains,\n isJSONataIdentifier,\n isJSONataIdentifierList,\n isJSONataIn,\n isJSONataNot,\n isJSONataOr,\n isJSONataRegex,\n isJSONataString,\n isJSONataValidValue,\n negatedLikeOperators,\n normalizeOperator,\n} from './utils';\n\n/**\n * Options object for {@link parseJSONata}.\n *\n * Note: `listsAsArrays` is ignored by `parseJSONata`; lists are _always_ arrays.\n */\nexport interface ParseJSONataOptions extends ParserCommonOptions {}\n\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJSONata(jsonataInput: string): DefaultRuleGroupType;\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJSONata(\n jsonataInput: string,\n options: Except<ParseJSONataOptions, 'independentCombinators'> & {\n independentCombinators?: false;\n }\n): DefaultRuleGroupType;\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).\n */\nfunction parseJSONata(\n jsonataInput: string,\n options: Except<ParseJSONataOptions, 'independentCombinators'> & {\n independentCombinators: true;\n }\n): DefaultRuleGroupTypeIC;\nfunction parseJSONata(\n jsonataInput: string,\n options: ParseJSONataOptions = {}\n): DefaultRuleGroupTypeAny {\n const { fields, independentCombinators, listsAsArrays: _laa } = options;\n const ic = !!independentCombinators;\n const fieldsFlat = getFieldsArray(fields);\n\n const fieldIsValid = (\n fieldName: string,\n operator: DefaultOperatorName,\n subordinateFieldName?: string\n ) =>\n fieldIsValidUtil({\n fieldName,\n fieldsFlat,\n operator,\n subordinateFieldName,\n getValueSources: options?.getValueSources,\n });\n\n const emptyQuery: DefaultRuleGroupTypeAny = {\n rules: [],\n ...(ic ? {} : { combinator: 'and' }),\n };\n\n const parseJSONataAST = (\n expr: JSONataExprNode,\n processOpts: {\n groupOnlyIfNecessary?: boolean;\n forwardNegation?: boolean;\n } = {}\n ): DefaultRuleType | DefaultRuleGroupTypeAny | null => {\n const { forwardNegation: _forwardedNegation, groupOnlyIfNecessary: _g } = processOpts;\n if (isJSONataBlock(expr)) {\n if (\n isJSONataAnd(expr.expressions[0]) ||\n isJSONataOr(expr.expressions[0]) ||\n isJSONataBlock(expr.expressions[0])\n ) {\n return parseJSONataAST(expr.expressions[0]);\n }\n const blockOfExpr = parseJSONataAST(expr.expressions[0]);\n // istanbul ignore else\n if (blockOfExpr) {\n return ic\n ? ({ rules: [blockOfExpr] } as DefaultRuleGroupTypeIC)\n : ({\n combinator: 'and',\n rules: [blockOfExpr],\n } as DefaultRuleGroupType);\n }\n } else if (isJSONataAnd(expr) || isJSONataOr(expr)) {\n if (ic) {\n const andOrList = generateFlatAndOrList(expr);\n const rules = andOrList.map(v => {\n if (typeof v === 'string') {\n return v;\n }\n return parseJSONataAST(v);\n });\n // Bail out completely if any rules in the list were invalid\n // so as not to return an incorrect and/or sequence\n if (!rules.every(Boolean)) {\n return null;\n }\n\n // Reduce this group to a single between/notBetween rule if possible\n if (\n ((rs: unknown[]): rs is [DefaultRuleType, DefaultCombinatorName, DefaultRuleType] =>\n rs.length === 3 &&\n (rs[1] === 'and' || rs[1] === 'or') &&\n !isRuleGroup(rs[0]) &&\n !isRuleGroup(rs[2]))(rules) &&\n rules[0].field === rules[2].field &&\n (rules[0].valueSource ?? 'value') === (rules[2].valueSource ?? 'value') &&\n ((rules[1] === 'and' &&\n ((rules[0].operator === '>=' && rules[2].operator === '<=') ||\n (rules[0].operator === '<=' && rules[2].operator === '>='))) ||\n (rules[1] === 'or' &&\n ((rules[0].operator === '>' && rules[2].operator === '<') ||\n (rules[0].operator === '<' && rules[2].operator === '>'))))\n ) {\n return {\n field: rules[0].field,\n operator: rules[1] === 'and' ? 'between' : 'notBetween',\n value:\n (rules[1] === 'and' && rules[0].operator === '<=') ||\n (rules[1] === 'or' && rules[0].operator === '>')\n ? [rules[2].value, rules[0].value]\n : [rules[0].value, rules[2].value],\n ...(rules[0].valueSource ? { valueSource: rules[0].valueSource } : null),\n };\n }\n\n return {\n rules: rules as DefaultRuleGroupICArray,\n };\n }\n const andOrList = generateMixedAndOrList(expr);\n const combinator = andOrList[1] as DefaultCombinatorName;\n const filteredList = andOrList\n .filter(v => Array.isArray(v) || (!!v && typeof v !== 'string' && 'type' in v))\n .map(v =>\n Array.isArray(v) ? v.filter(vf => !!v && typeof vf !== 'string' && 'type' in vf) : v\n ) as (JSONataExprNode | JSONataExprNode[])[];\n const rules = filteredList\n .map((exp): DefaultRuleGroupType | DefaultRuleType | null => {\n if (Array.isArray(exp)) {\n return {\n combinator: 'and',\n rules: exp.map(e => parseJSONataAST(e)).filter(Boolean) as DefaultRuleGroupArray,\n };\n }\n return parseJSONataAST(exp) as DefaultRuleType | DefaultRuleGroupType | null;\n })\n .filter(Boolean) as DefaultRuleGroupArray;\n\n // Reduce this group to a single between/notBetween rule if possible\n if (\n ((rs: unknown[]): rs is [DefaultRuleType, DefaultRuleType] =>\n rs.length === 2 && !isRuleGroup(rs[0]) && !isRuleGroup(rs[1]))(rules) &&\n rules[0].field === rules[1].field &&\n (rules[0].valueSource ?? 'value') === (rules[1].valueSource ?? 'value') &&\n ((combinator === 'and' &&\n ((rules[0].operator === '>=' && rules[1].operator === '<=') ||\n (rules[0].operator === '<=' && rules[1].operator === '>='))) ||\n (combinator === 'or' &&\n ((rules[0].operator === '>' && rules[1].operator === '<') ||\n (rules[0].operator === '<' && rules[1].operator === '>'))))\n ) {\n return {\n field: rules[0].field,\n operator: combinator === 'and' ? 'between' : 'notBetween',\n value:\n (combinator === 'and' && rules[0].operator === '<=') ||\n (combinator === 'or' && rules[0].operator === '>')\n ? [rules[1].value, rules[0].value]\n : [rules[0].value, rules[1].value],\n ...(rules[0].valueSource ? { valueSource: rules[0].valueSource } : null),\n };\n }\n\n // istanbul ignore else\n if (rules.length > 0) {\n return { combinator, rules };\n }\n } else if (isJSONataNot(expr)) {\n const negatedExpr = parseJSONataAST(expr.arguments[0]);\n // istanbul ignore else\n if (negatedExpr) {\n if (\n !isRuleGroup(negatedExpr) &&\n (negatedExpr.operator === 'contains' ||\n negatedExpr.operator === 'beginsWith' ||\n negatedExpr.operator === 'endsWith')\n ) {\n return {\n ...negatedExpr,\n operator: negatedLikeOperators[negatedExpr.operator],\n };\n }\n return ic\n ? ({ rules: [negatedExpr], not: true } as DefaultRuleGroupTypeIC)\n : ({\n combinator: 'and',\n rules: [negatedExpr],\n not: true,\n } as DefaultRuleGroupType);\n }\n } else if (isJSONataContains(expr)) {\n const [arg1, arg2] = expr.arguments;\n let field: string = '';\n let regex: string | RegExp = '';\n let valueSource: ValueSource | undefined = undefined;\n // istanbul ignore else\n if (isJSONataIdentifier(arg1)) {\n field = getFieldFromPath(arg1);\n if (isJSONataIdentifier(arg2)) {\n regex = getFieldFromPath(arg2);\n valueSource = 'field';\n } else {\n // istanbul ignore else\n if (isJSONataString(arg2) || isJSONataRegex(arg2)) {\n regex = getValidValue(arg2);\n }\n }\n }\n\n // istanbul ignore else\n if (\n valueSource === 'field'\n ? fieldIsValid(field, 'contains', regex as string)\n : fieldIsValid(field, 'contains')\n ) {\n return {\n field,\n operator: 'contains',\n value: regex,\n ...(valueSource ? { valueSource } : {}),\n };\n }\n } else if (isJSONataIn(expr)) {\n const field = getFieldFromPath(expr.lhs);\n let valueSource: ValueSource | undefined = undefined;\n if (isJSONataIdentifierList(expr.rhs)) {\n valueSource = 'field';\n }\n if (isJSONataValidValue(expr.rhs)) {\n // oxlint-disable-next-line typescript/no-explicit-any\n const value: any[] = getValidValue(expr.rhs);\n // istanbul ignore else\n if (\n field &&\n value.every(v => fieldIsValid(field, 'in', valueSource === 'field' ? v : undefined))\n ) {\n return { field, operator: 'in', value, ...(valueSource ? { valueSource } : {}) };\n }\n }\n } else if (isJSONataComparison(expr)) {\n let field: string | null = null;\n // oxlint-disable-next-line typescript/no-explicit-any\n let value: any = undefined;\n let valueSource: ValueSource | undefined = undefined;\n let flip = false;\n const { lhs, rhs } = expr;\n\n if (isJSONataIdentifier(lhs) && isJSONataValidValue(rhs)) {\n field = getFieldFromPath(lhs);\n value = getValidValue(rhs);\n if (isJSONataIdentifier(rhs)) {\n valueSource = 'field';\n }\n } else {\n // istanbul ignore else\n if (isJSONataIdentifier(rhs) && isJSONataValidValue(lhs)) {\n flip = true;\n field = getFieldFromPath(rhs);\n value = getValidValue(lhs);\n }\n }\n let operator = normalizeOperator(expr.value, flip);\n if (value === null && (operator === '=' || operator === '!=')) {\n operator = operator === '=' ? 'null' : 'notNull';\n }\n if (\n field &&\n fieldIsValid(field, operator, valueSource === 'field' ? value : undefined) &&\n value !== undefined\n ) {\n return valueSource ? { field, operator, value, valueSource } : { field, operator, value };\n }\n }\n return null;\n };\n\n const prepare = options.generateIDs ? prepareRuleGroup : <T>(g: T) => g;\n\n let jsonataExpr: jsonata.Expression;\n try {\n jsonataExpr = jsonata(jsonataInput);\n } catch {\n return prepare(emptyQuery);\n }\n const jsonataAST = jsonataExpr.ast() as JSONataExprNode;\n\n const result = parseJSONataAST(jsonataAST);\n if (result) {\n if (isRuleGroup(result)) {\n return prepare(result);\n }\n return prepare({ rules: [result], ...(ic ? {} : { combinator: 'and' }) });\n }\n\n return prepare(emptyQuery);\n}\n\nexport { parseJSONata };\n"],"mappings":"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"}