@sigmaott/base-next 1.4.0 → 1.4.2

package/src/components/QueryBuilder/utils/rules.ts

@@ -1,213 +1,213 @@
-import { nanoid } from 'nanoid'
-import type { FieldConfigMap, JsonRule } from '../types'
-import { defaultConfig } from './config'
-
-function revertEscapedRegex(value: string): string {
-  return value
-    .replace(/\\\\/g, '\\')
-    .replace(/\\\./g, '.')
-    .replace(/\\\+/g, '+')
-    .replace(/\\\*/g, '*')
-    .replace(/\\\?/g, '?')
-    .replace(/\\\^/g, '^')
-    .replace(/\\\$/g, '$')
-    .replace(/\\\[/g, '[')
-    .replace(/\\\]/g, ']')
-    .replace(/\\\{/g, '{')
-    .replace(/\\\}/g, '}')
-    .replace(/\\\(/g, '(')
-    .replace(/\\\)/g, ')')
-    .replace(/\\\|/g, '|')
-    .replace(/\\\//g, '/')
-    .replace(/\\x2d/g, '-')
-}
-
-const mongoRuleOperators: Record<string, any> = {
-  $eq(v: Record<string, any>) {
-    const value = v.$eq
-    return {
-      val: value === null || value === '' ? [] : [value],
-      op: value === null ? 'is_null' : (value === '' ? 'is_empty' : 'equal'),
-    }
-  },
-  $ne(v: Record<string, any>) {
-    const value = v.$ne
-    return {
-      val: value === null || value === '' ? [] : [value],
-      op: value === null ? 'is_not_null' : (value === '' ? 'is_not_empty' : 'not_equal'),
-    }
-  },
-  $not(v: Record<string, any>) {
-    if (v.$not) {
-      // datetime { $not : { $gt : val1 } , { $lt : val2 } } -> [[val1 , val2]]
-      // number { $not : { $gte : val1 } , { $lte : val2 } } -> [val1 , val2]
-      const vals = Object.values(v.$not).flat()
-      return { val: v.$not.$gt ? [[...vals]] : [...vals], op: 'not_between' }
-    }
-    else {
-      return {
-        val: [v.$regex],
-        op: 'not_like',
-      }
-    }
-  },
-  $regex(v: Record<string, any>) {
-    const value = revertEscapedRegex(v.$regex)
-    if (value.slice(0, 4) === '(?<!' && value.slice(-2) === ')$')
-      return { val: [value.slice(4, -2)], op: 'not_ends_with' }
-    else if ((value.slice(0, 5) === '^((?!' && value.slice(-5) === ').)*$'))
-      return { val: [value.slice(5, -5)], op: 'not_contains' }
-    else if (value.slice(0, 4) === '^(?!' && value.slice(-1) === ')')
-      return { val: [value.slice(4, -1)], op: 'not_begins_with' }
-    else if (value.slice(0, 1) === '^')
-      return { val: [value.slice(1)], op: 'begins_with' }
-    else if (value.slice(-1) === '$')
-      return { val: [value.slice(0, -1)], op: 'ends_with' }
-    else return { val: [value], op: 'contains' }
-  },
-  between(v: Record<string, any>) {
-    return { val: [[v.$gte, v.$lte]], op: 'between' }
-  },
-
-  $in(v: Record<string, any>) {
-    return { val: v.$in, op: 'in' }
-  },
-  $nin(v: Record<string, any>) {
-    return { val: v.$nin, op: 'not_in' }
-  },
-  $lt(v: Record<string, any>) {
-    return { val: [v.$lt], op: 'less' }
-  },
-  $lte(v: Record<string, any>) {
-    return { val: [v.$lte], op: 'less_or_equal' }
-  },
-  $gt(v: Record<string, any>) {
-    return { val: [v.$gt], op: 'greater' }
-  },
-  $gte(v: Record<string, any>) {
-    return { val: [v.$gte], op: 'greater_or_equal' }
-  },
-}
-
-function getMongoOperator(data: Record<string, any>) {
-  if (data !== null && typeof data === 'object') {
-    if (data.$gte !== undefined && data.$lte !== undefined)
-      return 'between'
-
-    const knownKeys = Object.keys(data).filter((key) => {
-      return !!mongoRuleOperators[key]
-    })
-
-    if (knownKeys.length === 1)
-      return knownKeys[0]
-  }
-  else {
-    return '$eq'
-  }
-}
-
-function getMongoCondition(data: Record<string, any>) {
-  const keys = Object.keys(data)
-
-  for (let i = 0, l = keys.length; i < l; i++) {
-    if (keys[i].toLowerCase() === '$or' || keys[i].toLowerCase() === '$and')
-      return keys[i]
-  }
-}
-
-function parse(data: Record<string, any>, topKey: string, fieldConfig: FieldConfigMap) {
-  const rules = data[topKey]
-  const parts: Record<string, any> = []
-  rules.forEach((data) => {
-    // a plugin returned a group
-    if ('rules' in data && 'condition' in data) {
-      parts.push(data)
-      return
-    }
-
-    // a plugin returned a rule
-    if ('id' in data && 'operator' in data && 'value' in data) {
-      parts.push(data)
-      return
-    }
-
-    const key = getMongoCondition(data)
-    if (key) {
-      parts.push(parse(data, key, fieldConfig))
-    }
-    else {
-      const field = Object.keys(data)[0]
-      const value = data[field]
-
-      const operator: string | undefined = getMongoOperator(value)
-      if (operator === undefined)
-        console.log('MongoParse', 'Invalid MongoDB query format')
-
-      const mdbrl = mongoRuleOperators[operator || '']
-      if (mdbrl === undefined)
-        console.log('UndefinedMongoOperator', 'JSON Rule operation unknown for operator "{0}"', operator)
-
-      const opValInit = mdbrl.call(self, value)
-
-      // if input number and range operator: [[val1 , val2]] -> [val1 , val2]
-      const opVal = fieldConfig[field]?.input === 'number' && ['between', 'not_between'].includes(operator) ? [opValInit.val[0][0], opValInit.val[0][1]] : opValInit.val
-      const rule: JsonRule = {
-        id: field,
-        label: fieldConfig[field]?.label || field,
-        field,
-        input: fieldConfig[field]?.input || 'text',
-        operator: opValInit.op,
-        value: opVal,
-        validation: {
-          required: true,
-          ...(fieldConfig[field]?.validation || {}),
-        },
-        options: [...fieldConfig[field]?.options || []],
-      }
-
-      parts.push(rule)
-    }
-  })
-
-  return {
-    id: nanoid(),
-    input: 'group',
-    not: false,
-    condition: topKey.replace('$', '').toUpperCase(),
-    rules: parts,
-    valid: true,
-  }
-}
-
-export function getRulesFromMongo(query: Record<string, any>, fieldConfig: FieldConfigMap) {
-  if (query === undefined || query === null)
-    return null
-  // a plugin returned a group
-  if ('rules' in query && 'condition' in query)
-    return query
-
-  // a plugin returned a rule
-  if ('id' in query && 'operator' in query && 'value' in query) {
-    return {
-      condition: defaultConfig.settings.defaultCondition,
-      rules: [query],
-    }
-  }
-  if (query.$nor) {
-    const _query = query.$nor[0]
-    const key = getMongoCondition(_query)
-    if (!key) { console.log('MongoParse', 'Invalid MongoDB query format') }
-    else {
-      const result = parse(_query, key, fieldConfig)
-      return { ...result, not: true }
-    }
-  }
-  else {
-    const key = getMongoCondition(query)
-    if (!key) { console.log('MongoParse', 'Invalid MongoDB query format') }
-    else {
-      const result = parse(query, key, fieldConfig)
-      return result
-    }
-  }
-}
+import { nanoid } from 'nanoid'
+import type { FieldConfigMap, JsonRule } from '../types'
+import { defaultConfig } from './config'
+
+function revertEscapedRegex(value: string): string {
+  return value
+    .replace(/\\\\/g, '\\')
+    .replace(/\\\./g, '.')
+    .replace(/\\\+/g, '+')
+    .replace(/\\\*/g, '*')
+    .replace(/\\\?/g, '?')
+    .replace(/\\\^/g, '^')
+    .replace(/\\\$/g, '$')
+    .replace(/\\\[/g, '[')
+    .replace(/\\\]/g, ']')
+    .replace(/\\\{/g, '{')
+    .replace(/\\\}/g, '}')
+    .replace(/\\\(/g, '(')
+    .replace(/\\\)/g, ')')
+    .replace(/\\\|/g, '|')
+    .replace(/\\\//g, '/')
+    .replace(/\\x2d/g, '-')
+}
+
+const mongoRuleOperators: Record<string, any> = {
+  $eq(v: Record<string, any>) {
+    const value = v.$eq
+    return {
+      val: value === null || value === '' ? [] : [value],
+      op: value === null ? 'is_null' : (value === '' ? 'is_empty' : 'equal'),
+    }
+  },
+  $ne(v: Record<string, any>) {
+    const value = v.$ne
+    return {
+      val: value === null || value === '' ? [] : [value],
+      op: value === null ? 'is_not_null' : (value === '' ? 'is_not_empty' : 'not_equal'),
+    }
+  },
+  $not(v: Record<string, any>) {
+    if (v.$not) {
+      // datetime { $not : { $gt : val1 } , { $lt : val2 } } -> [[val1 , val2]]
+      // number { $not : { $gte : val1 } , { $lte : val2 } } -> [val1 , val2]
+      const vals = Object.values(v.$not).flat()
+      return { val: v.$not.$gt ? [[...vals]] : [...vals], op: 'not_between' }
+    }
+    else {
+      return {
+        val: [v.$regex],
+        op: 'not_like',
+      }
+    }
+  },
+  $regex(v: Record<string, any>) {
+    const value = revertEscapedRegex(v.$regex)
+    if (value.slice(0, 4) === '(?<!' && value.slice(-2) === ')$')
+      return { val: [value.slice(4, -2)], op: 'not_ends_with' }
+    else if ((value.slice(0, 5) === '^((?!' && value.slice(-5) === ').)*$'))
+      return { val: [value.slice(5, -5)], op: 'not_contains' }
+    else if (value.slice(0, 4) === '^(?!' && value.slice(-1) === ')')
+      return { val: [value.slice(4, -1)], op: 'not_begins_with' }
+    else if (value.slice(0, 1) === '^')
+      return { val: [value.slice(1)], op: 'begins_with' }
+    else if (value.slice(-1) === '$')
+      return { val: [value.slice(0, -1)], op: 'ends_with' }
+    else return { val: [value], op: 'contains' }
+  },
+  between(v: Record<string, any>) {
+    return { val: [[v.$gte, v.$lte]], op: 'between' }
+  },
+
+  $in(v: Record<string, any>) {
+    return { val: v.$in, op: 'in' }
+  },
+  $nin(v: Record<string, any>) {
+    return { val: v.$nin, op: 'not_in' }
+  },
+  $lt(v: Record<string, any>) {
+    return { val: [v.$lt], op: 'less' }
+  },
+  $lte(v: Record<string, any>) {
+    return { val: [v.$lte], op: 'less_or_equal' }
+  },
+  $gt(v: Record<string, any>) {
+    return { val: [v.$gt], op: 'greater' }
+  },
+  $gte(v: Record<string, any>) {
+    return { val: [v.$gte], op: 'greater_or_equal' }
+  },
+}
+
+function getMongoOperator(data: Record<string, any>) {
+  if (data !== null && typeof data === 'object') {
+    if (data.$gte !== undefined && data.$lte !== undefined)
+      return 'between'
+
+    const knownKeys = Object.keys(data).filter((key) => {
+      return !!mongoRuleOperators[key]
+    })
+
+    if (knownKeys.length === 1)
+      return knownKeys[0]
+  }
+  else {
+    return '$eq'
+  }
+}
+
+function getMongoCondition(data: Record<string, any>) {
+  const keys = Object.keys(data)
+
+  for (let i = 0, l = keys.length; i < l; i++) {
+    if (keys[i].toLowerCase() === '$or' || keys[i].toLowerCase() === '$and')
+      return keys[i]
+  }
+}
+
+function parse(data: Record<string, any>, topKey: string, fieldConfig: FieldConfigMap) {
+  const rules = data[topKey]
+  const parts: Record<string, any> = []
+  rules.forEach((data) => {
+    // a plugin returned a group
+    if ('rules' in data && 'condition' in data) {
+      parts.push(data)
+      return
+    }
+
+    // a plugin returned a rule
+    if ('id' in data && 'operator' in data && 'value' in data) {
+      parts.push(data)
+      return
+    }
+
+    const key = getMongoCondition(data)
+    if (key) {
+      parts.push(parse(data, key, fieldConfig))
+    }
+    else {
+      const field = Object.keys(data)[0]
+      const value = data[field]
+
+      const operator: string | undefined = getMongoOperator(value)
+      if (operator === undefined)
+        console.log('MongoParse', 'Invalid MongoDB query format')
+
+      const mdbrl = mongoRuleOperators[operator || '']
+      if (mdbrl === undefined)
+        console.log('UndefinedMongoOperator', 'JSON Rule operation unknown for operator "{0}"', operator)
+
+      const opValInit = mdbrl.call(self, value)
+
+      // if input number and range operator: [[val1 , val2]] -> [val1 , val2]
+      const opVal = fieldConfig[field]?.input === 'number' && ['between', 'not_between'].includes(operator) ? [opValInit.val[0][0], opValInit.val[0][1]] : opValInit.val
+      const rule: JsonRule = {
+        id: field,
+        label: fieldConfig[field]?.label || field,
+        field,
+        input: fieldConfig[field]?.input || 'text',
+        operator: opValInit.op,
+        value: opVal,
+        validation: {
+          required: true,
+          ...(fieldConfig[field]?.validation || {}),
+        },
+        options: [...fieldConfig[field]?.options || []],
+      }
+
+      parts.push(rule)
+    }
+  })
+
+  return {
+    id: nanoid(),
+    input: 'group',
+    not: false,
+    condition: topKey.replace('$', '').toUpperCase(),
+    rules: parts,
+    valid: true,
+  }
+}
+
+export function getRulesFromMongo(query: Record<string, any>, fieldConfig: FieldConfigMap) {
+  if (query === undefined || query === null)
+    return null
+  // a plugin returned a group
+  if ('rules' in query && 'condition' in query)
+    return query
+
+  // a plugin returned a rule
+  if ('id' in query && 'operator' in query && 'value' in query) {
+    return {
+      condition: defaultConfig.settings.defaultCondition,
+      rules: [query],
+    }
+  }
+  if (query.$nor) {
+    const _query = query.$nor[0]
+    const key = getMongoCondition(_query)
+    if (!key) { console.log('MongoParse', 'Invalid MongoDB query format') }
+    else {
+      const result = parse(_query, key, fieldConfig)
+      return { ...result, not: true }
+    }
+  }
+  else {
+    const key = getMongoCondition(query)
+    if (!key) { console.log('MongoParse', 'Invalid MongoDB query format') }
+    else {
+      const result = parse(query, key, fieldConfig)
+      return result
+    }
+  }
+}