@sigmaott/base-next 1.0.6

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

@@ -0,0 +1,194 @@
+export const defaultConfig = {
+  conditions: {
+    AND: { label: 'AND', value: 'AND' },
+    OR: { label: 'OR', value: 'OR' },
+  },
+  operators: {
+    contains: {
+      type: 'contains',
+      label: 'contains',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text'],
+    },
+    not_contains: {
+      type: 'not_contains',
+      label: 'not_contains',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text'],
+    },
+    equal: {
+      type: 'equal',
+      label: '==',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text', 'number', 'boolean', 'select', 'time'],
+    },
+    not_equal: {
+      type: 'not_equal',
+      label: '!=',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text', 'number', 'boolean', 'select', 'time'],
+    },
+    less: {
+      type: 'less',
+      label: '<',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['number', 'datetime', 'time'],
+    },
+    less_or_equal: {
+      type: 'less_or_equal',
+      label: '<=',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['number', 'datetime', 'time'],
+    },
+    greater: {
+      type: 'greater',
+      label: '>',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['number', 'datetime', 'time'],
+    },
+    greater_or_equal: {
+      type: 'greater_or_equal',
+      label: '>=',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['number', 'datetime', 'time'],
+    },
+    in: {
+      type: 'in',
+      label: 'in',
+      nb_input: 1,
+      multiple: true,
+      apply_to: ['multiselect'],
+    },
+    not_in: {
+      type: 'not_in',
+      label: 'not_in',
+      nb_input: 1,
+      multiple: true,
+      apply_to: ['multiselect'],
+    },
+    between: {
+      type: 'between',
+      label: 'between',
+      nb_input: 2,
+      multiple: false,
+      apply_to: ['number', 'time'],
+    },
+    not_between: {
+      type: 'not_between',
+      label: 'not_between',
+      nb_input: 2,
+      multiple: false,
+      apply_to: ['number', 'time'],
+    },
+    is_empty: {
+      type: 'is_empty',
+      label: 'is_empty',
+      nb_input: 0,
+      multiple: false,
+      apply_to: ['text', 'select', 'boolean'],
+    },
+    is_not_empty: {
+      type: 'is_not_empty',
+      label: 'is_not_empty',
+      nb_input: 0,
+      multiple: false,
+      apply_to: ['text', 'select', 'boolean'],
+    },
+    // like: {
+    //   type: 'like',
+    //   label: 'like',
+    //   nb_input: 1,
+    //   multiple: false,
+    //   apply_to: ['text'],
+    // },
+    // not_like: {
+    //   type: 'not_like',
+    //   label: 'not_like',
+    //   nb_input: 1,
+    //   multiple: false,
+    //   apply_to: ['text'],
+    // },
+    begins_with: {
+      type: 'begins_with',
+      label: 'begins_with',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text'],
+    },
+    not_begins_with: {
+      type: 'not_begins_with',
+      label: 'not_begins_with',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text'],
+    },
+    ends_with: {
+      type: 'ends_with',
+      label: 'ends_with',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text'],
+    },
+    not_ends_with: {
+      type: 'not_ends_with',
+      label: 'not_ends_with',
+      nb_input: 1,
+      multiple: false,
+      apply_to: ['text'],
+    },
+    is_null: {
+      type: 'is_null',
+      label: 'is_null',
+      nb_input: 0,
+      multiple: false,
+      apply_to: ['text', 'number', 'select', 'boolean'],
+    },
+    is_not_null: {
+      type: 'is_not_null',
+      label: 'is_not_null',
+      nb_input: 0,
+      multiple: false,
+      apply_to: ['text', 'number', 'select', 'boolean'],
+    },
+  },
+  settings: {
+    canSetCondition: true,
+    canSetNot: true,
+    showCondition: true,
+    showNot: true,
+    showActions: true,
+    showAddGroup: true,
+    showAddRule: true,
+    showDelGroup: true,
+    showDelRule: true,
+    showEditRule: true,
+    showDrag: false,
+    isFieldSelect: true,
+    size: 'small',
+    fieldSelectLabel: 'Field',
+    fieldSelectPlaceholder: 'Select Field',
+    operatorSelectLabel: 'Operator',
+    operatorsSelectPlaceholder: 'Select operator',
+    inputPlaceholder: 'Input value',
+    addGroupLabel: 'Add group',
+    addRuleLabel: 'Add rule',
+    delGroupLabel: '',
+    delRuleLabel: '',
+    maxHeight: '',
+    defaultCondition: 'AND',
+  },
+  fields: {},
+}
+
+export const defaultField = {
+  options: ['', ''],
+  operator: '',
+}

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

@@ -0,0 +1,3 @@
+export * from './config'
+export * from './mongodb'
+export * from './rules'

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

@@ -0,0 +1,175 @@
+import type { JsonGroup } from '../types'
+import { defaultConfig } from './config'
+
+function escapeStringRegexp(string) {
+  if (typeof string !== 'string') {
+    throw new TypeError('Expected a string')
+  }
+
+  // Escape characters with special meaning either inside or outside character sets.
+  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+  return string
+    .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
+    .replace(/-/g, '\\x2d')
+}
+const mongoSettings: any = {
+  mongoOperators: {
+    equal(v: Array<string>) {
+      return { $eq: v[0] ?? '' }
+    },
+    not_equal(v: Array<string>) {
+      return { $ne: v[0] ?? '' }
+    },
+    in(v: string | Array<string>) {
+      return { $in: v || [] }
+    },
+    not_in(v: string | Array<string>) {
+      return { $nin: v || [] }
+    },
+    less(v: Array<string>) {
+      return { $lt: v[0] ?? null }
+    },
+    less_or_equal(v: Array<string>) {
+      return { $lte: v[0] ?? null }
+    },
+    greater(v: Array<string>) {
+      return { $gt: v[0] ?? null }
+    },
+    greater_or_equal(v: Array<string>) {
+      return { $gte: v[0] ?? null }
+    },
+    between(v: Array<string>) {
+      if (v.length >= 2) { // number
+        return { $gte: v[0] ?? null, $lte: v[1] ?? null }
+      }
+      else { return { $gte: v[0] ? v[0][0] : null, $lte: v[0] ? v[0][1] : null } } // datetrange
+    },
+    not_between(v: Array<string>) {
+      if (v.length >= 2) { // number
+        return { $not: { $gte: v[0] ?? null, $lte: v[1] ?? null } }
+      }
+      else {
+        return { $not: { $gt: v[0] ? v[0][0] : null, $lt: v[0] ? v[0][1] : null } }
+      } // datetrange
+    },
+    begins_with(v: Array<string>) {
+      return { $regex: `^${escapeStringRegexp(v[0]) ?? ''}`, $options: 'i' }
+    },
+    not_begins_with(v: Array<string>) {
+      return { $regex: `^(?!${escapeStringRegexp(v[0]) ?? ''})`, $options: 'i' }
+    },
+    contains(v: Array<string>) {
+      return { $regex: escapeStringRegexp(v[0]) ?? '', $options: 'i' }
+    },
+    not_contains(v: Array<string>) {
+      return {
+        $regex: `^((?!${escapeStringRegexp(v[0]) ?? ''}).)*$`,
+        $options: 'i',
+      }
+    },
+    // This operator does not correct and maybe same as contains => consider to remove
+    // like(v: Array<string>) {
+    //   return { $regex: v[0] ? `^${v[0]}.*` : '', $options: 'si' }
+    // },
+    // not_like(v: Array<string>) {
+    //   return {
+    //     $not: { $regex: `^${v[0]}.*` ?? '' },
+    //   }
+    // },
+    ends_with(v: Array<string>) {
+      return { $regex: `${escapeStringRegexp(v[0]) ?? ''}$`, $options: 'i' }
+    },
+    not_ends_with(v: Array<string>) {
+      return { $regex: `(?<!${escapeStringRegexp(v[0]) ?? ''})$`, $options: 'i' }
+    },
+    is_empty() {
+      return { $eq: '' }
+    },
+    is_not_empty() {
+      return { $ne: '' }
+    },
+    is_null() {
+      return null
+    },
+    is_not_null() {
+      return { $ne: null }
+    },
+  },
+}
+
+export function getMongo(data: JsonGroup): Record<string, any> | null {
+  if (!data || data.rules.length === 0)
+    return null
+
+  return (function parse(group) {
+    if (!group.condition)
+      group.condition = defaultConfig.settings.defaultCondition
+
+    if (!['AND', 'OR'].includes(group.condition.toUpperCase())) {
+      console.error(
+        'UndefinedMongoCondition',
+        'Unable to build MongoDB query with condition "{0}"',
+        group.condition,
+      )
+    }
+
+    if (!group.rules)
+      return {}
+
+    const parts: any = []
+
+    group.rules.forEach((rule: any) => {
+      if (rule.rules && rule.rules.length > 0) {
+        parts.push(parse(rule))
+      }
+      else {
+        const mdb = mongoSettings.mongoOperators[rule.operator]
+        const ope = defaultConfig.operators[rule.operator]
+        if (ope === undefined)
+          return
+
+        if (mdb === undefined) {
+          console.error(
+            'UndefinedMongoOperator',
+            'Unknown MongoDB operation for operator "{0}"',
+            rule.operator,
+          )
+        }
+
+        if (ope.nb_input !== 0) {
+          if (!(Array.isArray(rule.value)))
+            rule.value = [rule.value]
+        }
+
+        /**
+         * Modifies the MongoDB field used by a rule
+         */
+        const field = rule.field
+
+        const ruleExpression: any = {}
+        ruleExpression[field] = mdb(rule.value)
+
+        /**
+         * Modifies the MongoDB expression generated for a rule
+         */
+
+        const ruleExp = ruleExpression
+        parts.push(ruleExp)
+      }
+    })
+
+    let groupExpression: any = {}
+    groupExpression[`$${group.condition.toLowerCase()}`] = parts
+
+    /**
+     * Modifies the MongoDB expression generated for a group
+     */
+
+    //  return self.change('groupToMongo', groupExpression, group)
+    const key = `$${group.condition.toLowerCase()}`
+    if (group.not && groupExpression[key])
+      groupExpression = { $nor: [groupExpression] }
+
+    return groupExpression
+  })(data)
+}

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

@@ -0,0 +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
+    }
+  }
+}