diff --git a/packages/nc-gui/components/smartsheet/column/FormulaOptions.vue b/packages/nc-gui/components/smartsheet/column/FormulaOptions.vue
index f87585f490..e52df87238 100644
--- a/packages/nc-gui/components/smartsheet/column/FormulaOptions.vue
+++ b/packages/nc-gui/components/smartsheet/column/FormulaOptions.vue
@@ -2,34 +2,28 @@
 import type { Ref } from 'vue'
 import type { ListItem as AntListItem } from 'ant-design-vue'
 import jsep from 'jsep'
-import type { ColumnType, FormulaType, LinkToAnotherRecordType, TableType } from 'nocodb-sdk'
 import {
+  FormulaError,
   UITypes,
-  isLinksOrLTAR,
-  isNumericCol,
-  isSystemColumn,
   jsepCurlyHook,
   substituteColumnIdWithAliasInFormula,
-  validateDateWithUnknownFormat,
+  validateFormulaAndExtractTreeWithType,
 } from 'nocodb-sdk'
+import type { ColumnType, FormulaType } from 'nocodb-sdk'
 import {
   MetaInj,
   NcAutocompleteTree,
   computed,
   formulaList,
-  formulaTypes,
   formulas,
   getUIDTIcon,
   getWordUntilCaret,
   iconMap,
   inject,
   insertAtCursor,
-  isDate,
   nextTick,
   onMounted,
   ref,
-  storeToRefs,
-  useBase,
   useColumnCreateStoreOrThrow,
   useDebounceFn,
   useI18n,
@@ -52,59 +46,38 @@ const { setAdditionalValidations, validateInfos, sqlUi, column } = useColumnCrea
 
 const { t } = useI18n()
 
-const baseStore = useBase()
-
-const { tables } = storeToRefs(baseStore)
-
 const { predictFunction: _predictFunction } = useNocoEe()
 
-enum JSEPNode {
-  COMPOUND = 'Compound',
-  IDENTIFIER = 'Identifier',
-  MEMBER_EXP = 'MemberExpression',
-  LITERAL = 'Literal',
-  THIS_EXP = 'ThisExpression',
-  CALL_EXP = 'CallExpression',
-  UNARY_EXP = 'UnaryExpression',
-  BINARY_EXP = 'BinaryExpression',
-  ARRAY_EXP = 'ArrayExpression',
-}
-
 const meta = inject(MetaInj, ref())
 
 const supportedColumns = computed(
   () => meta?.value?.columns?.filter((col) => !uiTypesNotSupportedInFormulas.includes(col.uidt as UITypes)) || [],
 )
-const { metas } = useMetas()
-
-const refTables = computed(() => {
-  if (!tables.value || !tables.value.length || !meta.value || !meta.value.columns) {
-    return []
-  }
-
-  const _refTables = meta.value.columns
-    .filter((column) => isLinksOrLTAR(column) && !column.system && column.source_id === meta.value?.source_id)
-    .map((column) => ({
-      col: column.colOptions,
-      column,
-      ...tables.value.find((table) => table.id === (column.colOptions as LinkToAnotherRecordType).fk_related_model_id),
-    }))
-    .filter((table) => (table.col as LinkToAnotherRecordType)?.fk_related_model_id === table.id && !table.mm)
-  return _refTables as Required<TableType & { column: ColumnType; col: Required<LinkToAnotherRecordType> }>[]
-})
+const { getMeta } = useMetas()
 
 const validators = {
   formula_raw: [
     {
       validator: (_: any, formula: any) => {
-        return new Promise<void>((resolve, reject) => {
-          if (!formula?.trim()) return reject(new Error('Required'))
-          const res = parseAndValidateFormula(formula)
-          if (res !== true) {
-            return reject(new Error(res))
+        return (async () => {
+          if (!formula?.trim()) throw new Error('Required')
+
+          try {
+            await validateFormulaAndExtractTreeWithType({
+              column: column.value,
+              formula,
+              columns: supportedColumns.value,
+              clientOrSqlUi: sqlUi.value,
+              getMeta,
+            })
+          } catch (e: any) {
+            if (e instanceof FormulaError && e.extra?.key) {
+              throw new Error(t(e.extra.key, e.extra))
+            }
+
+            throw new Error(e.message)
           }
-          resolve()
-        })
+        })()
       },
     },
   ],
@@ -176,522 +149,6 @@ const acTree = computed(() => {
   return ref
 })
 
-function parseAndValidateFormula(formula: string) {
-  try {
-    const parsedTree = jsep(formula)
-    const metaErrors = validateAgainstMeta(parsedTree)
-    if (metaErrors.size) {
-      return [...metaErrors].join(', ')
-    }
-    return true
-  } catch (e: any) {
-    return e.message
-  }
-}
-
-function validateAgainstMeta(parsedTree: any, errors = new Set(), typeErrors = new Set()) {
-  if (parsedTree.type === JSEPNode.CALL_EXP) {
-    const calleeName = parsedTree.callee.name.toUpperCase()
-    // validate function name
-    if (!availableFunctions.includes(calleeName)) {
-      errors.add(t('msg.formula.functionNotAvailable', { function: calleeName }))
-    }
-    // validate arguments
-    const validation = formulas[calleeName] && formulas[calleeName].validation
-    if (validation && validation.args) {
-      if (validation.args.rqd !== undefined && validation.args.rqd !== parsedTree.arguments.length) {
-        errors.add(t('msg.formula.requiredArgumentsFormula', { requiredArguments: validation.args.rqd, calleeName }))
-      } else if (validation.args.min !== undefined && validation.args.min > parsedTree.arguments.length) {
-        errors.add(t('msg.formula.minRequiredArgumentsFormula', { minRequiredArguments: validation.args.min, calleeName }))
-      } else if (validation.args.max !== undefined && validation.args.max < parsedTree.arguments.length) {
-        errors.add(t('msg.formula.maxRequiredArgumentsFormula', { maxRequiredArguments: validation.args.max, calleeName }))
-      }
-    }
-    parsedTree.arguments.map((arg: Record<string, any>) => validateAgainstMeta(arg, errors))
-
-    // validate data type
-    if (parsedTree.callee.type === JSEPNode.IDENTIFIER) {
-      const expectedType = formulas[calleeName.toUpperCase()].type
-      if (expectedType === formulaTypes.NUMERIC) {
-        if (calleeName === 'WEEKDAY') {
-          // parsedTree.arguments[0] = date
-          validateAgainstType(
-            parsedTree.arguments[0],
-            formulaTypes.DATE,
-            (v: any) => {
-              if (!validateDateWithUnknownFormat(v)) {
-                typeErrors.add(t('msg.formula.firstParamWeekDayHaveDate'))
-              }
-            },
-            typeErrors,
-          )
-          // parsedTree.arguments[1] = startDayOfWeek (optional)
-          validateAgainstType(
-            parsedTree.arguments[1],
-            formulaTypes.STRING,
-            (v: any) => {
-              if (
-                typeof v !== 'string' ||
-                !['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'].includes(v.toLowerCase())
-              ) {
-                typeErrors.add(t('msg.formula.secondParamWeekDayHaveDate'))
-              }
-            },
-            typeErrors,
-          )
-        } else {
-          parsedTree.arguments.map((arg: Record<string, any>) => validateAgainstType(arg, expectedType, null, typeErrors))
-        }
-      } else if (expectedType === formulaTypes.DATE) {
-        if (calleeName === 'DATEADD') {
-          // parsedTree.arguments[0] = date
-          validateAgainstType(
-            parsedTree.arguments[0],
-            formulaTypes.DATE,
-            (v: any) => {
-              if (!validateDateWithUnknownFormat(v)) {
-                typeErrors.add(t('msg.formula.firstParamDateAddHaveDate'))
-              }
-            },
-            typeErrors,
-          )
-          // parsedTree.arguments[1] = numeric
-          validateAgainstType(
-            parsedTree.arguments[1],
-            formulaTypes.NUMERIC,
-            (v: any) => {
-              if (typeof v !== 'number') {
-                typeErrors.add(t('msg.formula.secondParamDateAddHaveNumber'))
-              }
-            },
-            typeErrors,
-          )
-          // parsedTree.arguments[2] = ["day" | "week" | "month" | "year"]
-          validateAgainstType(
-            parsedTree.arguments[2],
-            formulaTypes.STRING,
-            (v: any) => {
-              if (!['day', 'week', 'month', 'year'].includes(v)) {
-                typeErrors.add(typeErrors.add(t('msg.formula.thirdParamDateAddHaveDate')))
-              }
-            },
-            typeErrors,
-          )
-        } else if (calleeName === 'DATETIME_DIFF') {
-          // parsedTree.arguments[0] = date
-          validateAgainstType(
-            parsedTree.arguments[0],
-            formulaTypes.DATE,
-            (v: any) => {
-              if (!validateDateWithUnknownFormat(v)) {
-                typeErrors.add(t('msg.formula.firstParamDateDiffHaveDate'))
-              }
-            },
-            typeErrors,
-          )
-          // parsedTree.arguments[1] = date
-          validateAgainstType(
-            parsedTree.arguments[1],
-            formulaTypes.DATE,
-            (v: any) => {
-              if (!validateDateWithUnknownFormat(v)) {
-                typeErrors.add(t('msg.formula.secondParamDateDiffHaveDate'))
-              }
-            },
-            typeErrors,
-          )
-          // parsedTree.arguments[2] = ["milliseconds" | "ms" | "seconds" | "s" | "minutes" | "m" | "hours" | "h" | "days" | "d" | "weeks" | "w" | "months" | "M" | "quarters" | "Q" | "years" | "y"]
-          validateAgainstType(
-            parsedTree.arguments[2],
-            formulaTypes.STRING,
-            (v: any) => {
-              if (
-                ![
-                  'milliseconds',
-                  'ms',
-                  'seconds',
-                  's',
-                  'minutes',
-                  'm',
-                  'hours',
-                  'h',
-                  'days',
-                  'd',
-                  'weeks',
-                  'w',
-                  'months',
-                  'M',
-                  'quarters',
-                  'Q',
-                  'years',
-                  'y',
-                ].includes(v)
-              ) {
-                typeErrors.add(t('msg.formula.thirdParamDateDiffHaveDate'))
-              }
-            },
-            typeErrors,
-          )
-        }
-      }
-    }
-
-    errors = new Set([...errors, ...typeErrors])
-  } else if (parsedTree.type === JSEPNode.IDENTIFIER) {
-    if (supportedColumns.value.filter((c) => !column || column.value?.id !== c.id).every((c) => c.title !== parsedTree.name)) {
-      errors.add(
-        t('msg.formula.columnNotAvailable', {
-          columnName: parsedTree.name,
-        }),
-      )
-    }
-
-    // check circular reference
-    // e.g. formula1 -> formula2 -> formula1 should return circular reference error
-
-    // get all formula columns excluding itself
-    const formulaPaths = supportedColumns.value
-      .filter((c) => c.id !== column.value?.id && c.uidt === UITypes.Formula)
-      .reduce((res: Record<string, any>[], c: Record<string, any>) => {
-        // in `formula`, get all the (unique) target neighbours
-        // i.e. all column id (e.g. cl_xxxxxxxxxxxxxx) with formula type
-        const neighbours = [
-          ...new Set(
-            (c.colOptions.formula.match(/cl_\w{14}/g) || []).filter(
-              (colId: string) =>
-                supportedColumns.value.filter((col: ColumnType) => col.id === colId && col.uidt === UITypes.Formula).length,
-            ),
-          ),
-        ]
-        if (neighbours.length > 0) {
-          // e.g. formula column 1 -> [formula column 2, formula column3]
-          res.push({ [c.id]: neighbours })
-        }
-        return res
-      }, [])
-    // include target formula column (i.e. the one to be saved if applicable)
-    const targetFormulaCol = supportedColumns.value.find(
-      (c: ColumnType) => c.title === parsedTree.name && c.uidt === UITypes.Formula,
-    )
-
-    if (targetFormulaCol && column.value?.id) {
-      formulaPaths.push({
-        [column.value?.id as string]: [targetFormulaCol.id],
-      })
-    }
-    const vertices = formulaPaths.length
-    if (vertices > 0) {
-      // perform kahn's algo for cycle detection
-      const adj = new Map()
-      const inDegrees = new Map()
-      // init adjacency list & indegree
-
-      for (const [_, v] of Object.entries(formulaPaths)) {
-        const src = Object.keys(v)[0]
-        const neighbours = v[src]
-        inDegrees.set(src, inDegrees.get(src) || 0)
-        for (const neighbour of neighbours) {
-          adj.set(src, (adj.get(src) || new Set()).add(neighbour))
-          inDegrees.set(neighbour, (inDegrees.get(neighbour) || 0) + 1)
-        }
-      }
-      const queue: string[] = []
-      // put all vertices with in-degree = 0 (i.e. no incoming edges) to queue
-      inDegrees.forEach((inDegree, col) => {
-        if (inDegree === 0) {
-          // in-degree = 0 means we start traversing from this node
-          queue.push(col)
-        }
-      })
-      // init count of visited vertices
-      let visited = 0
-      // BFS
-      while (queue.length !== 0) {
-        // remove a vertex from the queue
-        const src = queue.shift()
-        // if this node has neighbours, increase visited by 1
-        const neighbours = adj.get(src) || new Set()
-        if (neighbours.size > 0) {
-          visited += 1
-        }
-        // iterate each neighbouring nodes
-        neighbours.forEach((neighbour: string) => {
-          // decrease in-degree of its neighbours by 1
-          inDegrees.set(neighbour, inDegrees.get(neighbour) - 1)
-          // if in-degree becomes 0
-          if (inDegrees.get(neighbour) === 0) {
-            // then put the neighboring node to the queue
-            queue.push(neighbour)
-          }
-        })
-      }
-      // vertices not same as visited = cycle found
-      if (vertices !== visited) {
-        errors.add(t('msg.formula.cantSaveCircularReference'))
-      }
-    }
-  } else if (parsedTree.type === JSEPNode.BINARY_EXP) {
-    if (!availableBinOps.includes(parsedTree.operator)) {
-      errors.add(t('msg.formula.operationNotAvailable', { operation: parsedTree.operator }))
-    }
-    validateAgainstMeta(parsedTree.left, errors)
-    validateAgainstMeta(parsedTree.right, errors)
-  } else if (parsedTree.type === JSEPNode.LITERAL || parsedTree.type === JSEPNode.UNARY_EXP) {
-    // do nothing
-  } else if (parsedTree.type === JSEPNode.COMPOUND) {
-    if (parsedTree.body.length) {
-      errors.add(t('msg.formula.cantSaveFieldFormulaInvalid'))
-    }
-  } else {
-    errors.add(t('msg.formula.cantSaveFieldFormulaInvalid'))
-  }
-  return errors
-}
-
-function validateAgainstType(parsedTree: any, expectedType: string, func: any, typeErrors = new Set()) {
-  if (parsedTree === false || typeof parsedTree === 'undefined') {
-    return typeErrors
-  }
-  if (parsedTree.type === JSEPNode.LITERAL) {
-    if (typeof func === 'function') {
-      func(parsedTree.value)
-    } else if (expectedType === formulaTypes.NUMERIC) {
-      if (typeof parsedTree.value !== 'number') {
-        typeErrors.add(t('msg.formula.numericTypeIsExpected'))
-      }
-    } else if (expectedType === formulaTypes.STRING) {
-      if (typeof parsedTree.value !== 'string') {
-        typeErrors.add(t('msg.formula.stringTypeIsExpected'))
-      }
-    }
-  } else if (parsedTree.type === JSEPNode.IDENTIFIER) {
-    const col = supportedColumns.value.find((c) => c.title === parsedTree.name)
-
-    if (col === undefined) {
-      return
-    }
-
-    if (col.uidt === UITypes.Formula) {
-      const foundType = getRootDataType(jsep(col.colOptions?.formula_raw))
-      if (foundType === 'N/A') {
-        typeErrors.add(t('msg.formula.notSupportedToReferenceColumn', { columnName: col.title }))
-      } else if (expectedType !== foundType) {
-        typeErrors.add(
-          t('msg.formula.typeIsExpectedButFound', {
-            type: expectedType,
-            found: foundType,
-          }),
-        )
-      }
-    } else {
-      switch (col.uidt) {
-        // string
-        case UITypes.SingleLineText:
-        case UITypes.LongText:
-        case UITypes.MultiSelect:
-        case UITypes.SingleSelect:
-        case UITypes.PhoneNumber:
-        case UITypes.Email:
-        case UITypes.URL:
-          if (expectedType !== formulaTypes.STRING) {
-            typeErrors.add(
-              t('msg.formula.columnWithTypeFoundButExpected', {
-                columnName: parsedTree.name,
-                columnType: formulaTypes.STRING,
-                expectedType,
-              }),
-            )
-          }
-          break
-
-        // numeric
-        case UITypes.Year:
-        case UITypes.Number:
-        case UITypes.Decimal:
-        case UITypes.Rating:
-        case UITypes.Count:
-        case UITypes.AutoNumber:
-        case UITypes.Currency:
-          if (expectedType !== formulaTypes.NUMERIC) {
-            typeErrors.add(
-              t('msg.formula.columnWithTypeFoundButExpected', {
-                columnName: parsedTree.name,
-                columnType: formulaTypes.NUMERIC,
-                expectedType,
-              }),
-            )
-          }
-          break
-
-        // date
-        case UITypes.Date:
-        case UITypes.DateTime:
-        case UITypes.CreateTime:
-        case UITypes.LastModifiedTime:
-          if (expectedType !== formulaTypes.DATE) {
-            typeErrors.add(
-              t('msg.formula.columnWithTypeFoundButExpected', {
-                columnName: parsedTree.name,
-                columnType: formulaTypes.DATE,
-                expectedType,
-              }),
-            )
-          }
-          break
-
-        case UITypes.Rollup: {
-          const rollupFunction = col.colOptions.rollup_function
-          if (['count', 'avg', 'sum', 'countDistinct', 'sumDistinct', 'avgDistinct'].includes(rollupFunction)) {
-            // these functions produce a numeric value, which can be used in numeric functions
-            if (expectedType !== formulaTypes.NUMERIC) {
-              typeErrors.add(
-                t('msg.formula.columnWithTypeFoundButExpected', {
-                  columnName: parsedTree.name,
-                  columnType: formulaTypes.NUMERIC,
-                  expectedType,
-                }),
-              )
-            }
-          } else {
-            // the value is based on the foreign rollup column type
-            const selectedTable = refTables.value.find((t) => t.column.id === col.colOptions.fk_relation_column_id)
-            const refTableColumns = metas.value[selectedTable.id].columns.filter(
-              (c: ColumnType) =>
-                vModel.value.fk_lookup_column_id === c.id ||
-                (!isSystemColumn(c) && c.id !== vModel.value.id && c.uidt !== UITypes.Links),
-            )
-            const childFieldColumn = refTableColumns.find(
-              (column: ColumnType) => column.id === col.colOptions.fk_rollup_column_id,
-            )
-            const abstractType = sqlUi.value.getAbstractType(childFieldColumn)
-
-            if (expectedType === formulaTypes.DATE && !isDate(childFieldColumn, sqlUi.value.getAbstractType(childFieldColumn))) {
-              typeErrors.add(
-                t('msg.formula.columnWithTypeFoundButExpected', {
-                  columnName: parsedTree.name,
-                  columnType: abstractType,
-                  expectedType,
-                }),
-              )
-            } else if (expectedType === formulaTypes.NUMERIC && !isNumericCol(childFieldColumn)) {
-              typeErrors.add(
-                t('msg.formula.columnWithTypeFoundButExpected', {
-                  columnName: parsedTree.name,
-                  columnType: abstractType,
-                  expectedType,
-                }),
-              )
-            }
-          }
-          break
-        }
-
-        // not supported
-        case UITypes.ForeignKey:
-        case UITypes.Attachment:
-        case UITypes.ID:
-        case UITypes.Time:
-        case UITypes.Percent:
-        case UITypes.Duration:
-        case UITypes.Lookup:
-        case UITypes.Barcode:
-        case UITypes.Button:
-        case UITypes.Checkbox:
-        case UITypes.Collaborator:
-        case UITypes.QrCode:
-        default:
-          typeErrors.add(t('msg.formula.notSupportedToReferenceColumn', { columnName: parsedTree.name }))
-          break
-      }
-    }
-  } else if (parsedTree.type === JSEPNode.UNARY_EXP || parsedTree.type === JSEPNode.BINARY_EXP) {
-    if (expectedType !== formulaTypes.NUMERIC) {
-      // parsedTree.name won't be available here
-      typeErrors.add(
-        t('msg.formula.typeIsExpectedButFound', {
-          type: formulaTypes.NUMERIC,
-          found: expectedType,
-        }),
-      )
-    }
-  } else if (parsedTree.type === JSEPNode.CALL_EXP) {
-    const calleeName = parsedTree.callee.name.toUpperCase()
-    if (formulas[calleeName]?.type && expectedType !== formulas[calleeName].type) {
-      typeErrors.add(
-        t('msg.formula.typeIsExpectedButFound', {
-          type: expectedType,
-          found: formulas[calleeName].type,
-        }),
-      )
-    }
-  }
-  return typeErrors
-}
-
-function getRootDataType(parsedTree: any): any {
-  // given a parse tree, return the data type of it
-  if (parsedTree.type === JSEPNode.CALL_EXP) {
-    return formulas[parsedTree.callee.name.toUpperCase()].type
-  } else if (parsedTree.type === JSEPNode.IDENTIFIER) {
-    const col = supportedColumns.value.find((c) => c.title === parsedTree.name) as Record<string, any>
-    if (col?.uidt === UITypes.Formula) {
-      return getRootDataType(jsep(col?.formula_raw))
-    } else {
-      switch (col?.uidt) {
-        // string
-        case UITypes.SingleLineText:
-        case UITypes.LongText:
-        case UITypes.MultiSelect:
-        case UITypes.SingleSelect:
-        case UITypes.PhoneNumber:
-        case UITypes.Email:
-        case UITypes.URL:
-          return formulaTypes.STRING
-
-        // numeric
-        case UITypes.Year:
-        case UITypes.Number:
-        case UITypes.Decimal:
-        case UITypes.Rating:
-        case UITypes.Count:
-        case UITypes.AutoNumber:
-          return formulaTypes.NUMERIC
-
-        // date
-        case UITypes.Date:
-        case UITypes.DateTime:
-        case UITypes.CreateTime:
-        case UITypes.LastModifiedTime:
-          return formulaTypes.DATE
-
-        // not supported
-        case UITypes.ForeignKey:
-        case UITypes.Attachment:
-        case UITypes.ID:
-        case UITypes.Time:
-        case UITypes.Currency:
-        case UITypes.Percent:
-        case UITypes.Duration:
-        case UITypes.Rollup:
-        case UITypes.Lookup:
-        case UITypes.Barcode:
-        case UITypes.Button:
-        case UITypes.Checkbox:
-        case UITypes.Collaborator:
-        case UITypes.QrCode:
-        default:
-          return 'N/A'
-      }
-    }
-  } else if (parsedTree.type === JSEPNode.BINARY_EXP || parsedTree.type === JSEPNode.UNARY_EXP) {
-    return formulaTypes.NUMERIC
-  } else if (parsedTree.type === JSEPNode.LITERAL) {
-    return typeof parsedTree.value
-  } else {
-    return 'N/A'
-  }
-}
-
 function isCurlyBracketBalanced() {
   // count number of opening curly brackets and closing curly brackets
   const cntCurlyBrackets = (formulaRef.value.$el.value.match(/\{|}/g) || []).reduce(
@@ -796,10 +253,6 @@ setAdditionalValidations({
 onMounted(() => {
   jsep.plugins.register(jsepCurlyHook)
 })
-
-// const predictFunction = async () => {
-//   await _predictFunction(formState, meta, supportedColumns, suggestionsList, vModel)
-// }
 </script>
 
 <template>
diff --git a/packages/nc-gui/utils/formulaUtils.ts b/packages/nc-gui/utils/formulaUtils.ts
index 8449d27da7..ecc5c3aad4 100644
--- a/packages/nc-gui/utils/formulaUtils.ts
+++ b/packages/nc-gui/utils/formulaUtils.ts
@@ -1,624 +1,5 @@
 import type { Input as AntInput } from 'ant-design-vue'
-
-const formulaTypes = {
-  NUMERIC: 'numeric',
-  STRING: 'string',
-  DATE: 'date',
-  LOGICAL: 'logical',
-  COND_EXP: 'conditional_expression',
-}
-
-const formulas: Record<string, any> = {
-  AVG: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Average of input parameters',
-    syntax: 'AVG(value1, [value2, ...])',
-    examples: ['AVG(10, 5) => 7.5', 'AVG({column1}, {column2})', 'AVG({column1}, {column2}, {column3})'],
-  },
-  ADD: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Sum of input parameters',
-    syntax: 'ADD(value1, [value2, ...])',
-    examples: ['ADD(5, 5) => 10', 'ADD({column1}, {column2})', 'ADD({column1}, {column2}, {column3})'],
-  },
-  DATEADD: {
-    type: formulaTypes.DATE,
-    validation: {
-      args: {
-        rqd: 3,
-      },
-    },
-    description: 'Adds a "count" units to Datetime.',
-    syntax: 'DATEADD(date | datetime, value, ["day" | "week" | "month" | "year"])',
-    examples: [
-      'DATEADD({column1}, 2, "day")',
-      'DATEADD({column1}, -2, "day")',
-      'DATEADD({column1}, 2, "week")',
-      'DATEADD({column1}, -2, "week")',
-      'DATEADD({column1}, 2, "month")',
-      'DATEADD({column1}, -2, "month")',
-      'DATEADD({column1}, 2, "year")',
-      'DATEADD({column1}, -2, "year")',
-    ],
-  },
-  DATETIME_DIFF: {
-    type: formulaTypes.DATE,
-    validation: {
-      args: {
-        min: 2,
-        max: 3,
-      },
-    },
-    description: 'Calculate the difference of two given date / datetime in specified units.',
-    syntax:
-      'DATETIME_DIFF(date | datetime, date | datetime, ["milliseconds" | "ms" | "seconds" | "s" | "minutes" | "m" | "hours" | "h" | "days" | "d" | "weeks" | "w" | "months" | "M" | "quarters" | "Q" | "years" | "y"])',
-    examples: [
-      'DATEDIFF({column1}, {column2})',
-      'DATEDIFF({column1}, {column2}, "seconds")',
-      'DATEDIFF({column1}, {column2}, "s")',
-      'DATEDIFF({column1}, {column2}, "years")',
-      'DATEDIFF({column1}, {column2}, "y")',
-      'DATEDIFF({column1}, {column2}, "minutes")',
-      'DATEDIFF({column1}, {column2}, "m")',
-      'DATEDIFF({column1}, {column2}, "days")',
-      'DATEDIFF({column1}, {column2}, "d")',
-    ],
-  },
-  AND: {
-    type: formulaTypes.COND_EXP,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'TRUE if all expr evaluate to TRUE',
-    syntax: 'AND(expr1, [expr2, ...])',
-    examples: ['AND(5 > 2, 5 < 10) => 1', 'AND({column1} > 2, {column2} < 10)'],
-  },
-  OR: {
-    type: formulaTypes.COND_EXP,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'TRUE if at least one expr evaluates to TRUE',
-    syntax: 'OR(expr1, [expr2, ...])',
-    examples: ['OR(5 > 2, 5 < 10) => 1', 'OR({column1} > 2, {column2} < 10)'],
-  },
-  CONCAT: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Concatenated string of input parameters',
-    syntax: 'CONCAT(str1, [str2, ...])',
-    examples: ['CONCAT("AA", "BB", "CC") => "AABBCC"', 'CONCAT({column1}, {column2}, {column3})'],
-  },
-  TRIM: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Remove trailing and leading whitespaces from input parameter',
-    syntax: 'TRIM(str)',
-    examples: ['TRIM("         HELLO WORLD  ") => "HELLO WORLD"', 'TRIM({column1})'],
-  },
-  UPPER: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Upper case converted string of input parameter',
-    syntax: 'UPPER(str)',
-    examples: ['UPPER("nocodb") => "NOCODB"', 'UPPER({column1})'],
-  },
-  LOWER: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Lower case converted string of input parameter',
-    syntax: 'LOWER(str)',
-    examples: ['LOWER("NOCODB") => "nocodb"', 'LOWER({column1})'],
-  },
-  LEN: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Input parameter character length',
-    syntax: 'LEN(value)',
-    examples: ['LEN("NocoDB") => 6', 'LEN({column1})'],
-  },
-  MIN: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Minimum value amongst input parameters',
-    syntax: 'MIN(value1, [value2, ...])',
-    examples: ['MIN(1000, 2000) => 1000', 'MIN({column1}, {column2})'],
-  },
-  MAX: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Maximum value amongst input parameters',
-    syntax: 'MAX(value1, [value2, ...])',
-    examples: ['MAX(1000, 2000) => 2000', 'MAX({column1}, {column2})'],
-  },
-  CEILING: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Rounded next largest integer value of input parameter',
-    syntax: 'CEILING(value)',
-    examples: ['CEILING(1.01) => 2', 'CEILING({column1})'],
-  },
-  FLOOR: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Rounded largest integer less than or equal to input parameter',
-    syntax: 'FLOOR(value)',
-    examples: ['FLOOR(3.1415) => 3', 'FLOOR({column1})'],
-  },
-  ROUND: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-        max: 2,
-      },
-    },
-    description: 'Rounded number to a specified number of decimal places or the nearest integer if not specified',
-    syntax: 'ROUND(value, precision), ROUND(value)',
-    examples: ['ROUND(3.1415) => 3', 'ROUND(3.1415, 2) => 3.14', 'ROUND({column1}, 3)'],
-  },
-  MOD: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'Remainder after integer division of input parameters',
-    syntax: 'MOD(value1, value2)',
-    examples: ['MOD(1024, 1000) => 24', 'MOD({column}, 2)'],
-  },
-  REPEAT: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'Specified copies of the input parameter string concatenated together',
-    syntax: 'REPEAT(str, count)',
-    examples: ['REPEAT("A", 5) => "AAAAA"', 'REPEAT({column}, 5)'],
-  },
-  LOG: {
-    type: formulaTypes.NUMERIC,
-    validation: {},
-    description: 'Logarithm of input parameter to the base (default = e) specified',
-    syntax: 'LOG([base], value)',
-    examples: ['LOG(2, 1024) => 10', 'LOG(2, {column1})'],
-  },
-  EXP: {
-    type: formulaTypes.NUMERIC,
-    validation: {},
-    description: 'Exponential value of input parameter (e ^ power)',
-    syntax: 'EXP(power)',
-    examples: ['EXP(1) => 2.718281828459045', 'EXP({column1})'],
-  },
-  POWER: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'base to the exponent power, as in base ^ exponent',
-    syntax: 'POWER(base, exponent)',
-    examples: ['POWER(2, 10) => 1024', 'POWER({column1}, 10)'],
-  },
-  SQRT: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Square root of the input parameter',
-    syntax: 'SQRT(value)',
-    examples: ['SQRT(100) => 10', 'SQRT({column1})'],
-  },
-  ABS: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Absolute value of the input parameter',
-    syntax: 'ABS(value)',
-    examples: ['ABS({column1})'],
-  },
-  NOW: {
-    type: formulaTypes.DATE,
-    validation: {
-      args: {
-        rqd: 0,
-      },
-    },
-    description: 'Returns the current time and day',
-    syntax: 'NOW()',
-    examples: ['NOW() => 2022-05-19 17:20:43'],
-  },
-  REPLACE: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 3,
-      },
-    },
-    description: 'String, after replacing all occurrences of srchStr with rplcStr',
-    syntax: 'REPLACE(str, srchStr, rplcStr)',
-    examples: ['REPLACE("AABBCC", "AA", "BB") => "BBBBCC"', 'REPLACE({column1}, {column2}, {column3})'],
-  },
-  SEARCH: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'Index of srchStr specified if found, 0 otherwise',
-    syntax: 'SEARCH(str, srchStr)',
-    examples: ['SEARCH("HELLO WORLD", "WORLD") => 7', 'SEARCH({column1}, "abc")'],
-  },
-  INT: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Integer value of input parameter',
-    syntax: 'INT(value)',
-    examples: ['INT(3.1415) => 3', 'INT({column1})'],
-  },
-  RIGHT: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'n characters from the end of input parameter',
-    syntax: 'RIGHT(str, n)',
-    examples: ['RIGHT("HELLO WORLD", 5) => WORLD', 'RIGHT({column1}, 3)'],
-  },
-  LEFT: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'n characters from the beginning of input parameter',
-    syntax: 'LEFT(str, n)',
-    examples: ['LEFT({column1}, 2)', 'LEFT("ABCD", 2) => "AB"'],
-  },
-  SUBSTR: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        min: 2,
-        max: 3,
-      },
-    },
-    description: 'Substring of length n of input string from the postition specified',
-    syntax: '	SUBTR(str, position, [n])',
-    examples: ['SUBSTR("HELLO WORLD", 7) => WORLD', 'SUBSTR("HELLO WORLD", 7, 3) => WOR', 'SUBSTR({column1}, 7, 5)'],
-  },
-  MID: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 3,
-      },
-    },
-    description: 'Alias for SUBSTR',
-    syntax: 'MID(str, position, [count])',
-    examples: ['MID("NocoDB", 3, 2) => "co"', 'MID({column1}, 3, 2)'],
-  },
-  IF: {
-    type: formulaTypes.COND_EXP,
-    validation: {
-      args: {
-        min: 2,
-        max: 3,
-      },
-    },
-    description: 'SuccessCase if expr evaluates to TRUE, elseCase otherwise',
-    syntax: 'IF(expr, successCase, elseCase)',
-    examples: ['IF(5 > 1, "YES", "NO") => "YES"', 'IF({column} > 1, "YES", "NO")'],
-  },
-  SWITCH: {
-    type: formulaTypes.COND_EXP,
-    validation: {
-      args: {
-        min: 3,
-      },
-    },
-    description: 'Switch case value based on expr output',
-    syntax: 'SWITCH(expr, [pattern, value, ..., default])',
-    examples: [
-      'SWITCH(1, 1, "One", 2, "Two", "N/A") => "One""',
-      'SWITCH(2, 1, "One", 2, "Two", "N/A") => "Two"',
-      'SWITCH(3, 1, "One", 2, "Two", "N/A") => "N/A"',
-      'SWITCH({column1}, 1, "One", 2, "Two", "N/A")',
-    ],
-  },
-  URL: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Convert to a hyperlink if it is a valid URL',
-    syntax: 'URL(str)',
-    examples: ['URL("https://github.com/nocodb/nocodb")', 'URL({column1})'],
-  },
-  WEEKDAY: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-        max: 2,
-      },
-    },
-    description: 'Returns the day of the week as an integer between 0 and 6 inclusive starting from Monday by default',
-    syntax: 'WEEKDAY(date, [startDayOfWeek])',
-    examples: ['WEEKDAY("2021-06-09")', 'WEEKDAY(NOW(), "sunday")'],
-  },
-
-  TRUE: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        max: 0,
-      },
-    },
-    description: 'Returns 1',
-    syntax: 'TRUE()',
-    examples: ['TRUE()'],
-  },
-
-  FALSE: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        max: 0,
-      },
-    },
-    description: 'Returns 0',
-    syntax: 'FALSE()',
-    examples: ['FALSE()'],
-  },
-
-  REGEX_MATCH: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'Returns 1 if the input text matches a regular expression or 0 if it does not.',
-    syntax: 'REGEX_MATCH(string, regex)',
-    examples: ['REGEX_MATCH({title}, "abc.*")'],
-  },
-
-  REGEX_EXTRACT: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 2,
-      },
-    },
-    description: 'Returns the first match of a regular expression in a string.',
-    syntax: 'REGEX_EXTRACT(string, regex)',
-    examples: ['REGEX_EXTRACT({title}, "abc.*")'],
-  },
-  REGEX_REPLACE: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 3,
-      },
-    },
-    description: 'Replaces all matches of a regular expression in a string with a replacement string',
-    syntax: 'REGEX_MATCH(string, regex, replacement)',
-    examples: ['REGEX_EXTRACT({title}, "abc.*", "abcd")'],
-  },
-  BLANK: {
-    type: formulaTypes.STRING,
-    validation: {
-      args: {
-        rqd: 0,
-      },
-    },
-    description: 'Returns a blank value(null)',
-    syntax: 'BLANK()',
-    examples: ['BLANK()'],
-  },
-  XOR: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Returns true if an odd number of arguments are true, and false otherwise.',
-    syntax: 'XOR(expression, [exp2, ...])',
-    examples: ['XOR(TRUE(), FALSE(), TRUE())'],
-  },
-  EVEN: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Returns the nearest even integer that is greater than or equal to the specified value',
-    syntax: 'EVEN(value)',
-    examples: ['EVEN({column})'],
-  },
-  ODD: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description: 'Returns the nearest odd integer that is greater than or equal to the specified value',
-    syntax: 'ODD(value)',
-    examples: ['ODD({column})'],
-  },
-  RECORD_ID: {
-    validation: {
-      args: {
-        rqd: 0,
-      },
-    },
-    description: 'Returns the record id of the current record',
-    syntax: 'RECORD_ID()',
-    examples: ['RECORD_ID()'],
-  },
-  COUNTA: {
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Counts the number of non-empty arguments',
-    syntax: 'COUNTA(value1, [value2, ...])',
-    examples: ['COUNTA({field1}, {field2})'],
-  },
-  COUNT: {
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Count the number of arguments that are numbers',
-    syntax: 'COUNT(value1, [value2, ...])',
-    examples: ['COUNT({field1}, {field2})'],
-  },
-  COUNTALL: {
-    validation: {
-      args: {
-        min: 1,
-      },
-    },
-    description: 'Counts the number of arguments',
-    syntax: 'COUNTALL(value1, [value2, ...])',
-    examples: ['COUNTALL({field1}, {field2})'],
-  },
-  ROUNDDOWN: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-        max: 2,
-      },
-    },
-    description:
-      'Round down the value after the decimal point to the number of decimal places given by "precision"(default is 0)',
-    syntax: 'ROUNDDOWN(value, [precision])',
-    examples: ['ROUNDDOWN({field1})', 'ROUNDDOWN({field1}, 2)'],
-  },
-  ROUNDUP: {
-    type: formulaTypes.NUMERIC,
-    validation: {
-      args: {
-        min: 1,
-        max: 2,
-      },
-    },
-    description: 'Round up the value after the decimal point to the number of decimal places given by "precision"(default is 0)',
-    syntax: 'ROUNDUP(value, [precision])',
-    examples: ['ROUNDUP({field1})', 'ROUNDUP({field1}, 2)'],
-  },
-  VALUE: {
-    validation: {
-      args: {
-        rqd: 1,
-      },
-    },
-    description:
-      'Extract the numeric value from a string, if `%` or `-` is present, it will handle it accordingly and return the numeric value',
-    syntax: 'VALUE(value)',
-    examples: ['VALUE({field})', 'VALUE("abc10000%")', 'VALUE("$10000")'],
-  },
-  // Disabling these functions for now; these act as alias for CreatedAt & UpdatedAt fields;
-  // Issue: Error noticed if CreatedAt & UpdatedAt fields are removed from the table after creating these formulas
-  //
-  // CREATED_TIME: {
-  //   validation: {
-  //     args: {
-  //       rqd: 0,
-  //     },
-  //   },
-  //   description: 'Returns the created time of the current record if it exists',
-  //   syntax: 'CREATED_TIME()',
-  //   examples: ['CREATED_TIME()'],
-  // },
-  // LAST_MODIFIED_TIME: {
-  //   validation: {
-  //     args: {
-  //       rqd: 0,
-  //     },
-  //   },
-  //   description: 'Returns the last modified time of the current record if it exists',
-  //   syntax: ' LAST_MODIFIED_TIME()',
-  //   examples: [' LAST_MODIFIED_TIME()'],
-  // },
-}
+import { formulas } from 'nocodb-sdk'
 
 const formulaList = Object.keys(formulas)
 
@@ -671,4 +52,4 @@ function GetCaretPosition(ctrl: typeof AntInput) {
   return CaretPos
 }
 
-export { formulaList, formulas, formulaTypes, getWordUntilCaret, insertAtCursor }
+export { formulaList, formulas, getWordUntilCaret, insertAtCursor }
diff --git a/packages/nocodb-sdk/jest.config.js b/packages/nocodb-sdk/jest.config.js
new file mode 100644
index 0000000000..b413e106db
--- /dev/null
+++ b/packages/nocodb-sdk/jest.config.js
@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};
\ No newline at end of file
diff --git a/packages/nocodb-sdk/package.json b/packages/nocodb-sdk/package.json
index 0491c12b60..7fc374634f 100644
--- a/packages/nocodb-sdk/package.json
+++ b/packages/nocodb-sdk/package.json
@@ -30,6 +30,7 @@
     "fix:prettier": "prettier \"src/**/*.ts\" --write",
     "fix:lint": "eslint src --ext .ts --fix",
     "test": "run-s build test:*",
+    "test:unit": "ENV_FILE=./config/.env.test jest",
     "test:lint": "eslint src --ext .ts",
     "test:prettier": "prettier \"src/**/*.ts\" --list-different",
     "test:spelling": "cspell \"{README.md,.github/*.md,src/**/*.ts}\"",
@@ -45,6 +46,7 @@
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^6.14.0",
     "@typescript-eslint/parser": "^6.14.0",
+    "@types/jest": "^29.5.2",
     "cspell": "^4.2.8",
     "eslint": "^8.54.0",
     "eslint-config-prettier": "^8.10.0",
@@ -56,7 +58,8 @@
     "prettier": "^2.8.8",
     "rimraf": "^5.0.5",
     "tsc-alias": "^1.8.8",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "ts-jest": "^29.1.1"
   },
   "files": [
     "build/main",
@@ -70,4 +73,4 @@
   "prettier": {
     "singleQuote": true
   }
-}
\ No newline at end of file
+}
diff --git a/packages/nocodb-sdk/src/lib/Api.ts b/packages/nocodb-sdk/src/lib/Api.ts
index 0a777d4326..f74c5f0fe9 100644
--- a/packages/nocodb-sdk/src/lib/Api.ts
+++ b/packages/nocodb-sdk/src/lib/Api.ts
@@ -3341,7 +3341,7 @@ export class Api<
       }),
 
     /**
- * @description Regenerate user refresh token
+ * @description Creates a new refresh token and JWT auth token for the user. The refresh token is sent as a cookie, while the JWT auth token is included in the response body.
  * 
  * @tags Auth
  * @name TokenRefresh
@@ -3349,7 +3349,7 @@ export class Api<
  * @request POST:/api/v1/auth/token/refresh
  * @response `200` `{
   \**
-   * New access token for user
+   * New JWT auth token for user
    * @example 96751db2d53fb834382b682268874a2ea9ee610e4d904e688d1513f11d3c30d62d36d9e05dec0d63
    *\
   token?: string,
@@ -3365,7 +3365,7 @@ export class Api<
       this.request<
         {
           /**
-           * New access token for user
+           * New JWT auth token for user
            * @example 96751db2d53fb834382b682268874a2ea9ee610e4d904e688d1513f11d3c30d62d36d9e05dec0d63
            */
           token?: string;
diff --git a/packages/nocodb-sdk/src/lib/formulaHelpers.spec.ts b/packages/nocodb-sdk/src/lib/formulaHelpers.spec.ts
new file mode 100644
index 0000000000..da6c0e7294
--- /dev/null
+++ b/packages/nocodb-sdk/src/lib/formulaHelpers.spec.ts
@@ -0,0 +1,77 @@
+import {
+  FormulaDataTypes,
+  validateFormulaAndExtractTreeWithType,
+} from './formulaHelpers';
+import UITypes from './UITypes';
+
+describe('Formula parsing and type validation', () => {
+  it('Simple formula', async () => {
+    const result = await validateFormulaAndExtractTreeWithType({
+      formula: '1 + 2',
+      columns: [],
+      clientOrSqlUi: 'mysql2',
+      getMeta: async () => ({}),
+    });
+
+    expect(result.dataType).toEqual(FormulaDataTypes.NUMERIC);
+  });
+
+  it('Formula with IF condition', async () => {
+    const result = await validateFormulaAndExtractTreeWithType({
+      formula: 'IF({column}, "Found", BLANK())',
+      columns: [
+        {
+          id: 'cid',
+          title: 'column',
+          uidt: UITypes.Number,
+        },
+      ],
+      clientOrSqlUi: 'mysql2',
+      getMeta: async () => ({}),
+    });
+
+    expect(result.dataType).toEqual(FormulaDataTypes.STRING);
+  });
+  it('Complex formula', async () => {
+    const result = await validateFormulaAndExtractTreeWithType({
+      formula:
+        'SWITCH({column2},"value1",IF({column1}, "Found", BLANK()),"value2", 2)',
+      columns: [
+        {
+          id: 'id1',
+          title: 'column1',
+          uidt: UITypes.Number,
+        },
+        {
+          id: 'id2',
+          title: 'column2',
+          uidt: UITypes.SingleLineText,
+        },
+      ],
+      clientOrSqlUi: 'mysql2',
+      getMeta: async () => ({}),
+    });
+
+    expect(result.dataType).toEqual(FormulaDataTypes.STRING);
+
+    const result1 = await validateFormulaAndExtractTreeWithType({
+      formula: 'SWITCH({column2},"value1",IF({column1}, 1, 2),"value2", 2)',
+      columns: [
+        {
+          id: 'id1',
+          title: 'column1',
+          uidt: UITypes.Number,
+        },
+        {
+          id: 'id2',
+          title: 'column2',
+          uidt: UITypes.SingleLineText,
+        },
+      ],
+      clientOrSqlUi: 'mysql2',
+      getMeta: async () => ({}),
+    });
+
+    expect(result1.dataType).toEqual(FormulaDataTypes.NUMERIC);
+  });
+});
diff --git a/packages/nocodb-sdk/src/lib/formulaHelpers.ts b/packages/nocodb-sdk/src/lib/formulaHelpers.ts
index 5a28417d84..1f4735ff6b 100644
--- a/packages/nocodb-sdk/src/lib/formulaHelpers.ts
+++ b/packages/nocodb-sdk/src/lib/formulaHelpers.ts
@@ -1,45 +1,73 @@
 import jsep from 'jsep';
 
-import { ColumnType } from './Api';
+import { ColumnType, LinkToAnotherRecordType, RollupType } from './Api';
+import UITypes from './UITypes';
+import dayjs from 'dayjs';
+import { MssqlUi, MysqlUi, PgUi, SnowflakeUi, SqlUiFactory } from './sqlUi';
+import { dateFormats } from './dateTimeHelper';
+
+// opening and closing string code
+const OCURLY_CODE = 123; // '{'
+const CCURLY_CODE = 125; // '}'
 
 export const jsepCurlyHook = {
   name: 'curly',
   init(jsep) {
-    jsep.hooks.add('gobble-token', function gobbleCurlyLiteral(env) {
-      const OCURLY_CODE = 123; // {
-      const CCURLY_CODE = 125; // }
-      let start = -1;
-      const { context } = env;
-      if (
-        !jsep.isIdentifierStart(context.code) &&
-        context.code === OCURLY_CODE
-      ) {
-        if (start == -1) {
-          start = context.index;
-        }
-        context.index += 1;
-        context.gobbleExpressions(CCURLY_CODE);
-        if (context.code === CCURLY_CODE) {
-          context.index += 1;
-          env.node = {
-            type: jsep.IDENTIFIER,
-            name: /{{(.*?)}}/.test(context.expr)
-              ? // start would be the position of the first curly bracket
-                // add 2 to point to the first character for expressions like {{col1}}
-                context.expr.slice(start + 2, context.index - 1)
-              : // start would be the position of the first curly bracket
-                // add 1 to point to the first character for expressions like {col1}
-                context.expr.slice(start + 1, context.index - 1),
-          };
-          return env.node;
-        } else {
-          context.throwError('Unclosed }');
+    // Match identifier in following pattern: {abc-cde}
+    jsep.hooks.add('gobble-token', function escapedIdentifier(env) {
+      // check if the current token is an opening curly bracket
+      if (this.code === OCURLY_CODE) {
+        const patternIndex = this.index;
+        // move to the next character until we find a closing curly bracket
+        while (this.index < this.expr.length) {
+          ++this.index;
+          if (this.code === CCURLY_CODE) {
+            let identifier = this.expr.slice(patternIndex, ++this.index);
+
+            // if starting with double curley brace then check for ending double curley brace
+            // if found include with the identifier
+            if (
+              identifier.startsWith('{{') &&
+              this.expr.slice(patternIndex, this.index + 1).endsWith('}')
+            ) {
+              identifier = this.expr.slice(patternIndex, ++this.index);
+            }
+            env.node = {
+              type: jsep.IDENTIFIER,
+              name: /^{{.*}}$/.test(identifier)
+                ? // start would be the position of the first curly bracket
+                  // add 2 to point to the first character for expressions like {{col1}}
+                  identifier.slice(2, -2)
+                : // start would be the position of the first curly bracket
+                  // add 1 to point to the first character for expressions like {col1}
+                  identifier.slice(1, -1),
+              raw: identifier,
+            };
+
+            // env.node = this.gobbleTokenProperty(env.node);
+            return env.node;
+          }
         }
+        this.throwError('Unclosed }');
       }
     });
   },
 } as jsep.IPlugin;
 
+function validateDateWithUnknownFormat(v: string) {
+  for (const format of dateFormats) {
+    if (dayjs(v, format, true).isValid() as any) {
+      return true;
+    }
+    for (const timeFormat of ['HH:mm', 'HH:mm:ss', 'HH:mm:ss.SSS']) {
+      if (dayjs(v, `${format} ${timeFormat}`, true).isValid() as any) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 export async function substituteColumnAliasWithIdInFormula(
   formula,
   columns: ColumnType[]
@@ -72,6 +100,21 @@ export async function substituteColumnAliasWithIdInFormula(
   return jsepTreeToFormula(parsedFormula);
 }
 
+export enum FormulaErrorType {
+  NOT_AVAILABLE = 'NOT_AVAILABLE',
+  NOT_SUPPORTED = 'NOT_SUPPORTED',
+  MIN_ARG = 'MIN_ARG',
+  MAX_ARG = 'MAX_ARG',
+  TYPE_MISMATCH = 'TYPE_MISMATCH',
+  INVALID_ARG = 'INVALID_ARG',
+  INVALID_ARG_TYPE = 'INVALID_ARG_TYPE',
+  INVALID_ARG_VALUE = 'INVALID_ARG_VALUE',
+  INVALID_ARG_COUNT = 'INVALID_ARG_COUNT',
+  CIRCULAR_REFERENCE = 'CIRCULAR_REFERENCE',
+  INVALID_FUNCTION_NAME = 'INVALID_FUNCTION_NAME',
+  INVALID_COLUMN = 'INVALID_COLUMN',
+}
+
 export function substituteColumnIdWithAliasInFormula(
   formula,
   columns: ColumnType[],
@@ -143,7 +186,7 @@ export function jsepTreeToFormula(node, isCallExpId = false) {
 
   if (node.type === 'Literal') {
     if (typeof node.value === 'string') {
-      return String.raw`"${escapeLiteral(node.value)}"`;
+      return String.raw`"${escapeLiteral(node.raw.slice(1, -1))}"`;
     }
     return '' + node.value;
   }
@@ -152,13 +195,17 @@ export function jsepTreeToFormula(node, isCallExpId = false) {
     return (
       jsepTreeToFormula(node.callee, true) +
       '(' +
-      node.arguments.map(jsepTreeToFormula).join(', ') +
+      node.arguments.map((argPt) => jsepTreeToFormula(argPt)).join(', ') +
       ')'
     );
   }
 
   if (node.type === 'ArrayExpression') {
-    return '[' + node.elements.map(jsepTreeToFormula).join(', ') + ']';
+    return (
+      '[' +
+      node.elements.map((elePt) => jsepTreeToFormula(elePt)).join(', ') +
+      ']'
+    );
   }
 
   if (node.type === 'Compound') {
@@ -181,11 +228,1528 @@ export function jsepTreeToFormula(node, isCallExpId = false) {
 function escapeLiteral(v: string) {
   return (
     v
-      // replace \ to \\
-      .replace(/\\/g, `\\\\`)
+      // replace \ to \\, escape only unescaped \
+      .replace(/([^\\]|^)\\(?!\\)/g, `$1\\\\`)
       // replace " to \"
-      .replace(/"/g, `\\"`)
+      .replace(/([^\\]|^)"/g, `$1\\"`)
       // replace ' to \'
-      .replace(/'/g, `\\'`)
+      .replace(/([^\\]|^)'/g, `$1\\'`)
+  );
+}
+
+export enum FormulaDataTypes {
+  NUMERIC = 'numeric',
+  STRING = 'string',
+  DATE = 'date',
+  LOGICAL = 'logical',
+  COND_EXP = 'conditional_expression',
+  NULL = 'null',
+  BOOLEAN = 'boolean',
+  UNKNOWN = 'unknown',
+}
+
+export enum JSEPNode {
+  COMPOUND = 'Compound',
+  IDENTIFIER = 'Identifier',
+  MEMBER_EXP = 'MemberExpression',
+  LITERAL = 'Literal',
+  THIS_EXP = 'ThisExpression',
+  CALL_EXP = 'CallExpression',
+  UNARY_EXP = 'UnaryExpression',
+  BINARY_EXP = 'BinaryExpression',
+  ARRAY_EXP = 'ArrayExpression',
+}
+
+interface FormulaMeta {
+  validation?: {
+    args?: {
+      min?: number;
+      max?: number;
+      rqd?: number;
+
+      type?: FormulaDataTypes;
+    };
+    custom?: (args: FormulaDataTypes[], parseTree: any) => void;
+  };
+  description?: string;
+  syntax?: string;
+  examples?: string[];
+  returnType?: ((args: any[]) => FormulaDataTypes) | FormulaDataTypes;
+}
+
+export const formulas: Record<string, FormulaMeta> = {
+  AVG: {
+    validation: {
+      args: {
+        min: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Average of input parameters',
+    syntax: 'AVG(value1, [value2, ...])',
+    examples: [
+      'AVG(10, 5) => 7.5',
+      'AVG({column1}, {column2})',
+      'AVG({column1}, {column2}, {column3})',
+    ],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  ADD: {
+    validation: {
+      args: {
+        min: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Sum of input parameters',
+    syntax: 'ADD(value1, [value2, ...])',
+    examples: [
+      'ADD(5, 5) => 10',
+      'ADD({column1}, {column2})',
+      'ADD({column1}, {column2}, {column3})',
+    ],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  DATEADD: {
+    validation: {
+      args: {
+        rqd: 3,
+        type: FormulaDataTypes.DATE,
+      },
+      custom: (_argTypes: FormulaDataTypes[], parsedTree: any) => {
+        if (parsedTree.arguments[0].type === JSEPNode.LITERAL) {
+          if (!validateDateWithUnknownFormat(parsedTree.arguments[0].value)) {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.firstParamDateAddHaveDate' },
+              'First parameter of DATEADD should be a date'
+            );
+          }
+        }
+
+        if (parsedTree.arguments[1].type === JSEPNode.LITERAL) {
+          if (typeof parsedTree.arguments[1].value !== 'number') {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.secondParamDateAddHaveNumber' },
+              'Second parameter of DATEADD should be a number'
+            );
+          }
+        }
+        if (parsedTree.arguments[2].type === JSEPNode.LITERAL) {
+          if (
+            !['day', 'week', 'month', 'year'].includes(
+              parsedTree.arguments[2].value
+            )
+          ) {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.thirdParamDateAddHaveDate' },
+              "Third parameter of DATEADD should be one of 'day', 'week', 'month', 'year'"
+            );
+          }
+        }
+      },
+    },
+    description: 'Adds a "count" units to Datetime.',
+    syntax:
+      'DATEADD(date | datetime, value, ["day" | "week" | "month" | "year"])',
+    examples: [
+      'DATEADD({column1}, 2, "day")',
+      'DATEADD({column1}, -2, "day")',
+      'DATEADD({column1}, 2, "week")',
+      'DATEADD({column1}, -2, "week")',
+      'DATEADD({column1}, 2, "month")',
+      'DATEADD({column1}, -2, "month")',
+      'DATEADD({column1}, 2, "year")',
+      'DATEADD({column1}, -2, "year")',
+    ],
+    returnType: FormulaDataTypes.DATE,
+  },
+  DATESTR: {
+    validation: {
+      args: {
+        rqd: 1,
+      },
+    },
+    description: 'Formats a datetime into a string (YYYY-MM-DD)',
+    examples: ['DATESTR({column1})'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  DAY: {
+    validation: {
+      args: {
+        rqd: 1,
+      },
+    },
+    description: 'Extract day from a date(1-31)',
+    examples: ['DAY({column1})'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  MONTH: {
+    validation: {
+      args: {
+        rqd: 1,
+      },
+    },
+    description: 'Extract month from a date(1-12)',
+    examples: ['MONTH({column1})'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  HOUR: {
+    validation: {
+      args: {
+        rqd: 1,
+      },
+    },
+    description: 'Extract hour from a datetime(0-23)',
+    examples: ['HOUR({column1})'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  DATETIME_DIFF: {
+    validation: {
+      args: {
+        min: 2,
+        max: 3,
+        type: FormulaDataTypes.DATE,
+      },
+      custom: (_argTypes: FormulaDataTypes[], parsedTree: any) => {
+        if (parsedTree.arguments[0].type === JSEPNode.LITERAL) {
+          if (!validateDateWithUnknownFormat(parsedTree.arguments[0].value)) {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.firstParamDateDiffHaveDate' },
+              'First parameter of DATETIME_DIFF should be a date'
+            );
+          }
+        }
+
+        if (parsedTree.arguments[1].type === JSEPNode.LITERAL) {
+          if (!validateDateWithUnknownFormat(parsedTree.arguments[1].value)) {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.secondParamDateDiffHaveDate' },
+              'Second parameter of DATETIME_DIFF should be a date'
+            );
+          }
+        }
+        if (
+          parsedTree.arguments[2] &&
+          parsedTree.arguments[2].type === JSEPNode.LITERAL
+        ) {
+          if (
+            ![
+              'milliseconds',
+              'ms',
+              'seconds',
+              's',
+              'minutes',
+              'm',
+              'hours',
+              'h',
+              'days',
+              'd',
+              'weeks',
+              'w',
+              'months',
+              'M',
+              'quarters',
+              'Q',
+              'years',
+              'y',
+            ].includes(parsedTree.arguments[2].value)
+          ) {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.thirdParamDateDiffHaveDate' },
+              "Third parameter of DATETIME_DIFF should be one of 'milliseconds', 'ms', 'seconds', 's', 'minutes', 'm', 'hours', 'h', 'days', 'd', 'weeks', 'w', 'months', 'M', 'quarters', 'Q', 'years', 'y'"
+            );
+          }
+        }
+      },
+    },
+    description:
+      'Calculate the difference of two given date / datetime in specified units.',
+    syntax:
+      'DATETIME_DIFF(date | datetime, date | datetime, ["milliseconds" | "ms" | "seconds" | "s" | "minutes" | "m" | "hours" | "h" | "days" | "d" | "weeks" | "w" | "months" | "M" | "quarters" | "Q" | "years" | "y"])',
+    examples: [
+      'DATEDIFF({column1}, {column2})',
+      'DATEDIFF({column1}, {column2}, "seconds")',
+      'DATEDIFF({column1}, {column2}, "s")',
+      'DATEDIFF({column1}, {column2}, "years")',
+      'DATEDIFF({column1}, {column2}, "y")',
+      'DATEDIFF({column1}, {column2}, "minutes")',
+      'DATEDIFF({column1}, {column2}, "m")',
+      'DATEDIFF({column1}, {column2}, "days")',
+      'DATEDIFF({column1}, {column2}, "d")',
+    ],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  AND: {
+    validation: {
+      args: {
+        min: 1,
+      },
+    },
+    description: 'TRUE if all expr evaluate to TRUE',
+    syntax: 'AND(expr1, [expr2, ...])',
+    examples: ['AND(5 > 2, 5 < 10) => 1', 'AND({column1} > 2, {column2} < 10)'],
+    returnType: FormulaDataTypes.COND_EXP,
+  },
+  OR: {
+    validation: {
+      args: {
+        min: 1,
+      },
+    },
+    description: 'TRUE if at least one expr evaluates to TRUE',
+    syntax: 'OR(expr1, [expr2, ...])',
+    examples: ['OR(5 > 2, 5 < 10) => 1', 'OR({column1} > 2, {column2} < 10)'],
+    returnType: FormulaDataTypes.COND_EXP,
+  },
+  CONCAT: {
+    validation: {
+      args: {
+        min: 1,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Concatenated string of input parameters',
+    syntax: 'CONCAT(str1, [str2, ...])',
+    examples: [
+      'CONCAT("AA", "BB", "CC") => "AABBCC"',
+      'CONCAT({column1}, {column2}, {column3})',
+    ],
+    returnType: FormulaDataTypes.STRING,
+  },
+  TRIM: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Remove trailing and leading whitespaces from input parameter',
+    syntax: 'TRIM(str)',
+    examples: [
+      'TRIM("         HELLO WORLD  ") => "HELLO WORLD"',
+      'TRIM({column1})',
+    ],
+    returnType: FormulaDataTypes.STRING,
+  },
+  UPPER: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Upper case converted string of input parameter',
+    syntax: 'UPPER(str)',
+    examples: ['UPPER("nocodb") => "NOCODB"', 'UPPER({column1})'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  LOWER: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Lower case converted string of input parameter',
+    syntax: 'LOWER(str)',
+    examples: ['LOWER("NOCODB") => "nocodb"', 'LOWER({column1})'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  LEN: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Input parameter character length',
+    syntax: 'LEN(value)',
+    examples: ['LEN("NocoDB") => 6', 'LEN({column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  MIN: {
+    validation: {
+      args: {
+        min: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Minimum value amongst input parameters',
+    syntax: 'MIN(value1, [value2, ...])',
+    examples: ['MIN(1000, 2000) => 1000', 'MIN({column1}, {column2})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  MAX: {
+    validation: {
+      args: {
+        min: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Maximum value amongst input parameters',
+    syntax: 'MAX(value1, [value2, ...])',
+    examples: ['MAX(1000, 2000) => 2000', 'MAX({column1}, {column2})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  CEILING: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Rounded next largest integer value of input parameter',
+    syntax: 'CEILING(value)',
+    examples: ['CEILING(1.01) => 2', 'CEILING({column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  FLOOR: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description:
+      'Rounded largest integer less than or equal to input parameter',
+    syntax: 'FLOOR(value)',
+    examples: ['FLOOR(3.1415) => 3', 'FLOOR({column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  ROUND: {
+    validation: {
+      args: {
+        min: 1,
+        max: 2,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description:
+      'Rounded number to a specified number of decimal places or the nearest integer if not specified',
+    syntax: 'ROUND(value, precision), ROUND(value)',
+    examples: [
+      'ROUND(3.1415) => 3',
+      'ROUND(3.1415, 2) => 3.14',
+      'ROUND({column1}, 3)',
+    ],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  MOD: {
+    validation: {
+      args: {
+        rqd: 2,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Remainder after integer division of input parameters',
+    syntax: 'MOD(value1, value2)',
+    examples: ['MOD(1024, 1000) => 24', 'MOD({column}, 2)'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  REPEAT: {
+    validation: {
+      args: {
+        rqd: 2,
+
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description:
+      'Specified copies of the input parameter string concatenated together',
+    syntax: 'REPEAT(str, count)',
+    examples: ['REPEAT("A", 5) => "AAAAA"', 'REPEAT({column}, 5)'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  LOG: {
+    validation: {
+      args: {
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description:
+      'Logarithm of input parameter to the base (default = e) specified',
+    syntax: 'LOG([base], value)',
+    examples: ['LOG(2, 1024) => 10', 'LOG(2, {column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  EXP: {
+    validation: {
+      args: {
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Exponential value of input parameter (e ^ power)',
+    syntax: 'EXP(power)',
+    examples: ['EXP(1) => 2.718281828459045', 'EXP({column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  POWER: {
+    validation: {
+      args: {
+        rqd: 2,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'base to the exponent power, as in base ^ exponent',
+    syntax: 'POWER(base, exponent)',
+    examples: ['POWER(2, 10) => 1024', 'POWER({column1}, 10)'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  SQRT: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Square root of the input parameter',
+    syntax: 'SQRT(value)',
+    examples: ['SQRT(100) => 10', 'SQRT({column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  ABS: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Absolute value of the input parameter',
+    syntax: 'ABS(value)',
+    examples: ['ABS({column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  NOW: {
+    validation: {
+      args: {
+        rqd: 0,
+        type: FormulaDataTypes.DATE,
+      },
+    },
+    description: 'Returns the current time and day',
+    syntax: 'NOW()',
+    examples: ['NOW() => 2022-05-19 17:20:43'],
+    returnType: FormulaDataTypes.DATE,
+  },
+  REPLACE: {
+    validation: {
+      args: {
+        rqd: 3,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description:
+      'String, after replacing all occurrences of srchStr with rplcStr',
+    syntax: 'REPLACE(str, srchStr, rplcStr)',
+    examples: [
+      'REPLACE("AABBCC", "AA", "BB") => "BBBBCC"',
+      'REPLACE({column1}, {column2}, {column3})',
+    ],
+    returnType: FormulaDataTypes.STRING,
+  },
+  SEARCH: {
+    validation: {
+      args: {
+        rqd: 2,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Index of srchStr specified if found, 0 otherwise',
+    syntax: 'SEARCH(str, srchStr)',
+    examples: [
+      'SEARCH("HELLO WORLD", "WORLD") => 7',
+      'SEARCH({column1}, "abc")',
+    ],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  INT: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description: 'Integer value of input parameter',
+    syntax: 'INT(value)',
+    examples: ['INT(3.1415) => 3', 'INT({column1})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  RIGHT: {
+    validation: {
+      args: {
+        rqd: 2,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'n characters from the end of input parameter',
+    syntax: 'RIGHT(str, n)',
+    examples: ['RIGHT("HELLO WORLD", 5) => WORLD', 'RIGHT({column1}, 3)'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  LEFT: {
+    validation: {
+      args: {
+        rqd: 2,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'n characters from the beginning of input parameter',
+    syntax: 'LEFT(str, n)',
+    examples: ['LEFT({column1}, 2)', 'LEFT("ABCD", 2) => "AB"'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  SUBSTR: {
+    validation: {
+      args: {
+        min: 2,
+        max: 3,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description:
+      'Substring of length n of input string from the postition specified',
+    syntax: '	SUBTR(str, position, [n])',
+    examples: [
+      'SUBSTR("HELLO WORLD", 7) => WORLD',
+      'SUBSTR("HELLO WORLD", 7, 3) => WOR',
+      'SUBSTR({column1}, 7, 5)',
+    ],
+    returnType: FormulaDataTypes.STRING,
+  },
+  MID: {
+    validation: {
+      args: {
+        rqd: 3,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Alias for SUBSTR',
+    syntax: 'MID(str, position, [count])',
+    examples: ['MID("NocoDB", 3, 2) => "co"', 'MID({column1}, 3, 2)'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  IF: {
+    validation: {
+      args: {
+        min: 2,
+        max: 3,
+      },
+    },
+    description: 'SuccessCase if expr evaluates to TRUE, elseCase otherwise',
+    syntax: 'IF(expr, successCase, elseCase)',
+    examples: [
+      'IF(5 > 1, "YES", "NO") => "YES"',
+      'IF({column} > 1, "YES", "NO")',
+    ],
+    returnType: (argTypes: FormulaDataTypes[]) => {
+      // extract all return types except NULL, since null can be returned by any type
+      const returnValueTypes = new Set(
+        argTypes.slice(1).filter((type) => type !== FormulaDataTypes.NULL)
+      );
+      // if there are more than one return types or if there is a string return type
+      // return type as string else return the type
+      if (
+        returnValueTypes.size > 1 ||
+        returnValueTypes.has(FormulaDataTypes.STRING)
+      ) {
+        return FormulaDataTypes.STRING;
+      } else if (returnValueTypes.has(FormulaDataTypes.NUMERIC)) {
+        return FormulaDataTypes.NUMERIC;
+      } else if (returnValueTypes.has(FormulaDataTypes.BOOLEAN)) {
+        return FormulaDataTypes.BOOLEAN;
+      } else if (returnValueTypes.has(FormulaDataTypes.DATE)) {
+        return FormulaDataTypes.DATE;
+      }
+
+      // if none of the above conditions are met, return the first return argument type
+      return argTypes[1];
+    },
+  },
+  SWITCH: {
+    validation: {
+      args: {
+        min: 3,
+      },
+      custom: (_argTypes: any[], _parseTree) => {
+        // Todo: Add validation for switch
+      },
+    },
+    description: 'Switch case value based on expr output',
+    syntax: 'SWITCH(expr, [pattern, value, ..., default])',
+    examples: [
+      'SWITCH(1, 1, "One", 2, "Two", "N/A") => "One""',
+      'SWITCH(2, 1, "One", 2, "Two", "N/A") => "Two"',
+      'SWITCH(3, 1, "One", 2, "Two", "N/A") => "N/A"',
+      'SWITCH({column1}, 1, "One", 2, "Two", "N/A")',
+    ],
+    returnType: (argTypes: FormulaDataTypes[]) => {
+      // extract all return types except NULL, since null can be returned by any type
+      const returnValueTypes = new Set(
+        argTypes.slice(2).filter((_, i) => i % 2 === 0)
+      );
+
+      // if there are more than one return types or if there is a string return type
+      // return type as string else return the type
+      if (
+        returnValueTypes.size > 1 ||
+        returnValueTypes.has(FormulaDataTypes.STRING)
+      ) {
+        return FormulaDataTypes.STRING;
+      } else if (returnValueTypes.has(FormulaDataTypes.NUMERIC)) {
+        return FormulaDataTypes.NUMERIC;
+      } else if (returnValueTypes.has(FormulaDataTypes.BOOLEAN)) {
+        return FormulaDataTypes.BOOLEAN;
+      } else if (returnValueTypes.has(FormulaDataTypes.DATE)) {
+        return FormulaDataTypes.DATE;
+      }
+
+      // if none of the above conditions are met, return the first return argument type
+      return argTypes[1];
+    },
+  },
+  URL: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Convert to a hyperlink if it is a valid URL',
+    syntax: 'URL(str)',
+    examples: ['URL("https://github.com/nocodb/nocodb")', 'URL({column1})'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  WEEKDAY: {
+    validation: {
+      args: {
+        min: 1,
+        max: 2,
+        type: FormulaDataTypes.NUMERIC,
+      },
+      custom(_argTypes: FormulaDataTypes[], parsedTree: any) {
+        if (parsedTree.arguments[0].type === JSEPNode.LITERAL) {
+          if (!validateDateWithUnknownFormat(parsedTree.arguments[0].value)) {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.firstParamWeekDayHaveDate' },
+              'First parameter of WEEKDAY should be a date'
+            );
+          }
+        }
+
+        // if second argument is present and literal then validate it
+        if (
+          parsedTree.arguments[1] &&
+          parsedTree.arguments[1].type === JSEPNode.LITERAL
+        ) {
+          const value = parsedTree.arguments[1].value;
+          if (
+            typeof value !== 'string' ||
+            ![
+              'sunday',
+              'monday',
+              'tuesday',
+              'wednesday',
+              'thursday',
+              'friday',
+              'saturday',
+            ].includes(value.toLowerCase())
+          ) {
+            throw new FormulaError(
+              FormulaErrorType.TYPE_MISMATCH,
+              { key: 'msg.formula.secondParamWeekDayHaveDate' },
+              'Second parameter of WEEKDAY should be day of week string'
+            );
+          }
+        }
+      },
+    },
+    description:
+      'Returns the day of the week as an integer between 0 and 6 inclusive starting from Monday by default',
+    syntax: 'WEEKDAY(date, [startDayOfWeek])',
+    examples: ['WEEKDAY("2021-06-09")', 'WEEKDAY(NOW(), "sunday")'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+
+  TRUE: {
+    validation: {
+      args: {
+        max: 0,
+      },
+    },
+    description: 'Returns 1',
+    syntax: 'TRUE()',
+    examples: ['TRUE()'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+
+  FALSE: {
+    validation: {
+      args: {
+        max: 0,
+      },
+    },
+    description: 'Returns 0',
+    syntax: 'FALSE()',
+    examples: ['FALSE()'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+
+  REGEX_MATCH: {
+    validation: {
+      args: {
+        rqd: 2,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description:
+      'Returns 1 if the input text matches a regular expression or 0 if it does not.',
+    syntax: 'REGEX_MATCH(string, regex)',
+    examples: ['REGEX_MATCH({title}, "abc.*")'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+
+  REGEX_EXTRACT: {
+    validation: {
+      args: {
+        rqd: 2,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description: 'Returns the first match of a regular expression in a string.',
+    syntax: 'REGEX_EXTRACT(string, regex)',
+    examples: ['REGEX_EXTRACT({title}, "abc.*")'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  REGEX_REPLACE: {
+    validation: {
+      args: {
+        rqd: 3,
+        type: FormulaDataTypes.STRING,
+      },
+    },
+    description:
+      'Replaces all matches of a regular expression in a string with a replacement string',
+    syntax: 'REGEX_MATCH(string, regex, replacement)',
+    examples: ['REGEX_EXTRACT({title}, "abc.*", "abcd")'],
+    returnType: FormulaDataTypes.STRING,
+  },
+  BLANK: {
+    validation: {
+      args: {
+        rqd: 0,
+      },
+    },
+    description: 'Returns a blank value(null)',
+    syntax: 'BLANK()',
+    examples: ['BLANK()'],
+    returnType: FormulaDataTypes.NULL,
+  },
+  XOR: {
+    validation: {
+      args: {
+        min: 1,
+      },
+      // todo: validation for boolean
+    },
+    description:
+      'Returns true if an odd number of arguments are true, and false otherwise.',
+    syntax: 'XOR(expression, [exp2, ...])',
+    examples: ['XOR(TRUE(), FALSE(), TRUE())'],
+    returnType: FormulaDataTypes.BOOLEAN,
+  },
+  EVEN: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description:
+      'Returns the nearest even integer that is greater than or equal to the specified value',
+    syntax: 'EVEN(value)',
+    examples: ['EVEN({column})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  ODD: {
+    validation: {
+      args: {
+        rqd: 1,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description:
+      'Returns the nearest odd integer that is greater than or equal to the specified value',
+    syntax: 'ODD(value)',
+    examples: ['ODD({column})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  RECORD_ID: {
+    validation: {
+      args: {
+        rqd: 0,
+      },
+    },
+    description: 'Returns the record id of the current record',
+    syntax: 'RECORD_ID()',
+    examples: ['RECORD_ID()'],
+
+    // todo: resolve return type based on the args
+    returnType: () => {
+      return FormulaDataTypes.STRING;
+    },
+  },
+  COUNTA: {
+    validation: {
+      args: {
+        min: 1,
+      },
+    },
+    description: 'Counts the number of non-empty arguments',
+    syntax: 'COUNTA(value1, [value2, ...])',
+    examples: ['COUNTA({field1}, {field2})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  COUNT: {
+    validation: {
+      args: {
+        min: 1,
+      },
+    },
+    description: 'Count the number of arguments that are numbers',
+    syntax: 'COUNT(value1, [value2, ...])',
+    examples: ['COUNT({field1}, {field2})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  COUNTALL: {
+    validation: {
+      args: {
+        min: 1,
+      },
+    },
+    description: 'Counts the number of arguments',
+    syntax: 'COUNTALL(value1, [value2, ...])',
+    examples: ['COUNTALL({field1}, {field2})'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  ROUNDDOWN: {
+    validation: {
+      args: {
+        min: 1,
+        max: 2,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description:
+      'Round down the value after the decimal point to the number of decimal places given by "precision"(default is 0)',
+    syntax: 'ROUNDDOWN(value, [precision])',
+    examples: ['ROUNDDOWN({field1})', 'ROUNDDOWN({field1}, 2)'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  ROUNDUP: {
+    validation: {
+      args: {
+        min: 1,
+        max: 2,
+        type: FormulaDataTypes.NUMERIC,
+      },
+    },
+    description:
+      'Round up the value after the decimal point to the number of decimal places given by "precision"(default is 0)',
+    syntax: 'ROUNDUP(value, [precision])',
+    examples: ['ROUNDUP({field1})', 'ROUNDUP({field1}, 2)'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  VALUE: {
+    validation: {
+      args: {
+        rqd: 1,
+      },
+    },
+    description:
+      'Extract the numeric value from a string, if `%` or `-` is present, it will handle it accordingly and return the numeric value',
+    syntax: 'VALUE(value)',
+    examples: ['VALUE({field})', 'VALUE("abc10000%")', 'VALUE("$10000")'],
+    returnType: FormulaDataTypes.NUMERIC,
+  },
+  // Disabling these functions for now; these act as alias for CreatedAt & UpdatedAt fields;
+  // Issue: Error noticed if CreatedAt & UpdatedAt fields are removed from the table after creating these formulas
+  //
+  // CREATED_TIME: {
+  //   validation: {
+  //     args: {
+  //       rqd: 0,
+  //     },
+  //   },
+  //   description: 'Returns the created time of the current record if it exists',
+  //   syntax: 'CREATED_TIME()',
+  //   examples: ['CREATED_TIME()'],
+  // },
+  // LAST_MODIFIED_TIME: {
+  //   validation: {
+  //     args: {
+  //       rqd: 0,
+  //     },
+  //   },
+  //   description: 'Returns the last modified time of the current record if it exists',
+  //   syntax: ' LAST_MODIFIED_TIME()',
+  //   examples: [' LAST_MODIFIED_TIME()'],
+  // },
+};
+
+export class FormulaError extends Error {
+  public type: FormulaErrorType;
+  public extra: Record<string, any>;
+
+  constructor(
+    type: FormulaErrorType,
+    extra: {
+      [key: string]: any;
+    },
+    message: string = 'Formula Error'
+  ) {
+    super(message);
+    this.type = type;
+    this.extra = extra;
+  }
+}
+
+async function extractColumnIdentifierType({
+  col,
+  columns,
+  getMeta,
+  clientOrSqlUi,
+}: {
+  col: Record<string, any>;
+  columns: ColumnType[];
+  getMeta: (tableId: string) => Promise<any>;
+  clientOrSqlUi:
+    | 'mysql'
+    | 'pg'
+    | 'sqlite3'
+    | 'mssql'
+    | 'mysql2'
+    | 'oracledb'
+    | 'mariadb'
+    | 'sqlite'
+    | 'snowflake'
+    | typeof MysqlUi
+    | typeof MssqlUi
+    | typeof SnowflakeUi
+    | typeof PgUi;
+}) {
+  const res: {
+    dataType?: FormulaDataTypes;
+    errors?: Set<string>;
+    [p: string]: any;
+  } = {};
+  const sqlUI =
+    typeof clientOrSqlUi === 'string'
+      ? SqlUiFactory.create({ client: clientOrSqlUi })
+      : clientOrSqlUi;
+
+  switch (col?.uidt) {
+    // string
+    case UITypes.SingleLineText:
+    case UITypes.LongText:
+    case UITypes.MultiSelect:
+    case UITypes.SingleSelect:
+    case UITypes.PhoneNumber:
+    case UITypes.Email:
+    case UITypes.URL:
+      res.dataType = FormulaDataTypes.STRING;
+      break;
+    // numeric
+    case UITypes.Year:
+    case UITypes.Number:
+    case UITypes.Decimal:
+    case UITypes.Rating:
+    case UITypes.Count:
+    case UITypes.AutoNumber:
+      res.dataType = FormulaDataTypes.NUMERIC;
+      break;
+    // date
+    case UITypes.Date:
+    case UITypes.DateTime:
+    case UITypes.CreateTime:
+    case UITypes.LastModifiedTime:
+      res.dataType = FormulaDataTypes.DATE;
+      break;
+
+    case UITypes.Currency:
+    case UITypes.Percent:
+    case UITypes.Duration:
+    case UITypes.Links:
+      res.dataType = FormulaDataTypes.NUMERIC;
+      break;
+
+    case UITypes.Rollup:
+      {
+        const rollupFunction = col.colOptions.rollup_function;
+        if (
+          [
+            'count',
+            'avg',
+            'sum',
+            'countDistinct',
+            'sumDistinct',
+            'avgDistinct',
+          ].includes(rollupFunction)
+        ) {
+          // these functions produce a numeric value, which can be used in numeric functions
+          res.dataType = FormulaDataTypes.NUMERIC;
+        } else {
+          const relationColumnOpt = columns.find(
+            (column) =>
+              column.id === (<RollupType>col.colOptions).fk_relation_column_id
+          );
+
+          // the value is based on the foreign rollup column type
+          const refTableMeta = await getMeta(
+            (<LinkToAnotherRecordType>relationColumnOpt.colOptions)
+              .fk_related_model_id
+          );
+
+          const refTableColumns = refTableMeta.columns;
+          const childFieldColumn = refTableColumns.find(
+            (column: ColumnType) =>
+              column.id === col.colOptions.fk_rollup_column_id
+          );
+
+          // extract type and add to res
+          Object.assign(
+            res,
+            await extractColumnIdentifierType({
+              col: childFieldColumn,
+              columns: refTableColumns,
+              getMeta,
+              clientOrSqlUi,
+            })
+          );
+        }
+      }
+      break;
+
+    case UITypes.Attachment:
+      res.dataType = FormulaDataTypes.STRING;
+      break;
+    case UITypes.Checkbox:
+      res.dataType = FormulaDataTypes.NUMERIC;
+      break;
+    case UITypes.ID:
+    case UITypes.ForeignKey:
+    case UITypes.SpecificDBType:
+      {
+        if (sqlUI) {
+          const abstractType = sqlUI.getAbstractType(col);
+          if (['integer', 'float', 'decimal'].includes(abstractType)) {
+            res.dataType = FormulaDataTypes.NUMERIC;
+          } else if (['boolean'].includes(abstractType)) {
+            res.dataType = FormulaDataTypes.BOOLEAN;
+          } else if (
+            ['date', 'datetime', 'time', 'year'].includes(abstractType)
+          ) {
+            res.dataType = FormulaDataTypes.DATE;
+          } else {
+            res.dataType = FormulaDataTypes.STRING;
+          }
+        } else {
+          res.dataType = FormulaDataTypes.UNKNOWN;
+        }
+      }
+      break;
+    // not supported
+    case UITypes.Time:
+    case UITypes.Lookup:
+    case UITypes.Barcode:
+    case UITypes.Button:
+    case UITypes.Collaborator:
+    case UITypes.QrCode:
+    default:
+      res.dataType = FormulaDataTypes.UNKNOWN;
+      break;
+  }
+
+  return res;
+}
+
+export async function validateFormulaAndExtractTreeWithType({
+  formula,
+  column,
+  columns,
+  clientOrSqlUi,
+  getMeta,
+}: {
+  formula: string;
+  columns: ColumnType[];
+  clientOrSqlUi:
+    | 'mysql'
+    | 'pg'
+    | 'sqlite3'
+    | 'mssql'
+    | 'mysql2'
+    | 'oracledb'
+    | 'mariadb'
+    | 'sqlite'
+    | 'snowflake'
+    | typeof MysqlUi
+    | typeof MssqlUi
+    | typeof SnowflakeUi
+    | typeof PgUi;
+  column?: ColumnType;
+  getMeta: (tableId: string) => Promise<any>;
+}) {
+  const sqlUI =
+    typeof clientOrSqlUi === 'string'
+      ? SqlUiFactory.create({ client: clientOrSqlUi })
+      : clientOrSqlUi;
+
+  const colAliasToColMap = {};
+  const colIdToColMap = {};
+
+  for (const col of columns) {
+    colAliasToColMap[col.title] = col;
+    colIdToColMap[col.id] = col;
+  }
+
+  const validateAndExtract = async (parsedTree: any) => {
+    const res: {
+      dataType?: FormulaDataTypes;
+      errors?: Set<string>;
+      [key: string]: any;
+    } = { ...parsedTree };
+
+    if (parsedTree.type === JSEPNode.CALL_EXP) {
+      const calleeName = parsedTree.callee.name.toUpperCase();
+      // validate function name
+      if (!formulas[calleeName] || sqlUI?.getUnsupportedFnList().includes(calleeName)) {
+        throw new FormulaError(
+          FormulaErrorType.INVALID_FUNCTION_NAME,
+          {},
+          `Function ${calleeName} is not available`
+        );
+      }
+
+      // validate arguments
+      const validation =
+        formulas[calleeName] && formulas[calleeName].validation;
+      if (validation && validation.args) {
+        if (
+          validation.args.rqd !== undefined &&
+          validation.args.rqd !== parsedTree.arguments.length
+        ) {
+          throw new FormulaError(
+            FormulaErrorType.INVALID_ARG,
+            {
+              key: 'msg.formula.requiredArgumentsFormula',
+              requiredArguments: validation.args.rqd,
+              calleeName,
+            },
+            'Required arguments missing'
+          );
+        } else if (
+          validation.args.min !== undefined &&
+          validation.args.min > parsedTree.arguments.length
+        ) {
+          throw new FormulaError(
+            FormulaErrorType.MIN_ARG,
+            {
+              key: 'msg.formula.minRequiredArgumentsFormula',
+              minRequiredArguments: validation.args.min,
+              calleeName,
+            },
+            'Minimum arguments required'
+          );
+        } else if (
+          validation.args.max !== undefined &&
+          validation.args.max < parsedTree.arguments.length
+        ) {
+          throw new FormulaError(
+            FormulaErrorType.INVALID_ARG,
+            {
+              key: 'msg.formula.maxRequiredArgumentsFormula',
+              maxRequiredArguments: validation.args.max,
+              calleeName,
+            },
+            'Maximum arguments missing'
+          );
+        }
+      }
+      // get args type and validate
+      const validateResult = (res.arguments = await Promise.all(
+        parsedTree.arguments.map((arg) => {
+          return validateAndExtract(arg);
+        })
+      ));
+
+      const argTypes = validateResult.map((v: any) => v.dataType);
+
+      // if validation function is present, call it
+      if (formulas[calleeName].validation?.custom) {
+        formulas[calleeName].validation?.custom(argTypes, parsedTree);
+      }
+      // validate against expected arg types if present
+      else if (formulas[calleeName].validation?.args?.type) {
+        const expectedArgType = formulas[calleeName].validation.args.type;
+
+        for (const argPt of validateResult) {
+          if (
+            argPt.dataType !== expectedArgType &&
+            argPt.dataType !== FormulaDataTypes.NULL &&
+            argPt.dataType !== FormulaDataTypes.UNKNOWN
+          ) {
+            if (argPt.type === JSEPNode.IDENTIFIER) {
+              throw new FormulaError(
+                FormulaErrorType.INVALID_ARG,
+                {
+                  key: 'msg.formula.columnWithTypeFoundButExpected',
+                  columnName: parsedTree.name,
+                  columnType: parsedTree.dataType,
+                  expectedType: expectedArgType,
+                },
+                `Field ${parsedTree.name} with ${parsedTree.dataType} type is found but ${expectedArgType} type is expected`
+              );
+            } else {
+              let key = '',
+                message = 'Invalid argument type';
+
+              if (expectedArgType === FormulaDataTypes.NUMERIC) {
+                key = 'msg.formula.numericTypeIsExpected';
+                message = 'Numeric type is expected';
+              } else if (expectedArgType === FormulaDataTypes.STRING) {
+                key = 'msg.formula.stringTypeIsExpected';
+                message = 'String type is expected';
+              } else if (expectedArgType === FormulaDataTypes.BOOLEAN) {
+                key = 'msg.formula.booleanTypeIsExpected';
+                message = 'Boolean type is expected';
+              } else if (expectedArgType === FormulaDataTypes.DATE) {
+                key = 'msg.formula.dateTypeIsExpected';
+                message = 'Date type is expected';
+              }
+
+              throw new FormulaError(
+                FormulaErrorType.INVALID_ARG,
+                {
+                  key,
+                  calleeName,
+                },
+                message
+              );
+            }
+          }
+        }
+      }
+
+      if (typeof formulas[calleeName].returnType === 'function') {
+        res.dataType = (formulas[calleeName].returnType as any)?.(
+          argTypes
+        ) as FormulaDataTypes;
+      } else if (formulas[calleeName].returnType) {
+        res.dataType = formulas[calleeName].returnType as FormulaDataTypes;
+      }
+    } else if (parsedTree.type === JSEPNode.IDENTIFIER) {
+      const col = (colIdToColMap[parsedTree.name] ||
+        colAliasToColMap[parsedTree.name]) as Record<string, any>;
+
+      if (!col) {
+        throw new FormulaError(
+          FormulaErrorType.INVALID_COLUMN,
+          {
+            key: 'msg.formula.columnNotAvailable',
+            columnName: parsedTree.name,
+          },
+          `Invalid column name/id ${JSON.stringify(parsedTree.name)} in formula`
+        );
+      }
+
+      res.name = col.id;
+
+      if (col?.uidt === UITypes.Formula) {
+        if (column) {
+          // check for circular reference when column is present(only available when calling root formula)
+          checkForCircularFormulaRef(column, parsedTree, columns);
+        }
+        const formulaRes =
+          col.colOptions?.parsed_tree ||
+          (await validateFormulaAndExtractTreeWithType(
+            // formula may include double curly brackets in previous version
+            // convert to single curly bracket here for compatibility
+            {
+              formula: col.colOptions.formula
+                .replaceAll('{{', '{')
+                .replaceAll('}}', '}'),
+              columns,
+              clientOrSqlUi,
+              getMeta,
+            }
+          ));
+
+        res.dataType = (formulaRes as any)?.dataType;
+      } else {
+        // extract type and add to res
+        Object.assign(
+          res,
+          await extractColumnIdentifierType({
+            col,
+            columns,
+            getMeta,
+            clientOrSqlUi,
+          })
+        );
+      }
+    } else if (parsedTree.type === JSEPNode.LITERAL) {
+      if (typeof parsedTree.value === 'number') {
+        res.dataType = FormulaDataTypes.NUMERIC;
+      } else if (typeof parsedTree.value === 'string') {
+        res.dataType = FormulaDataTypes.STRING;
+      } else if (typeof parsedTree.value === 'boolean') {
+        res.dataType = FormulaDataTypes.BOOLEAN;
+      } else {
+        res.dataType = FormulaDataTypes.STRING;
+      }
+    } else if (parsedTree.type === JSEPNode.UNARY_EXP) {
+      throw new FormulaError(
+        FormulaErrorType.NOT_SUPPORTED,
+        {},
+        'Unary expression is not supported'
+      );
+    } else if (parsedTree.type === JSEPNode.BINARY_EXP) {
+      res.left = await validateAndExtract(parsedTree.left);
+      res.right = await validateAndExtract(parsedTree.right);
+
+      if (['==', '<', '>', '<=', '>=', '!='].includes(parsedTree.operator)) {
+        res.dataType = FormulaDataTypes.COND_EXP;
+      } else if (parsedTree.operator === '+') {
+        res.dataType = FormulaDataTypes.NUMERIC;
+        // if any side is string/date/other type, then the result will be concatenated string
+        // e.g. 1 + '2' = '12'
+        if (
+          [res.left, res.right].some(
+            (r) =>
+              ![
+                FormulaDataTypes.NUMERIC,
+                FormulaDataTypes.BOOLEAN,
+                FormulaDataTypes.NULL,
+                FormulaDataTypes.UNKNOWN,
+              ].includes(r.dataType)
+          )
+        ) {
+          res.dataType = FormulaDataTypes.STRING;
+        }
+      } else {
+        res.dataType = FormulaDataTypes.NUMERIC;
+      }
+    }
+
+    return res;
+  };
+
+  // register jsep curly hook
+  jsep.plugins.register(jsepCurlyHook);
+  const parsedFormula = jsep(formula);
+  const result = await validateAndExtract(parsedFormula);
+  return result;
+}
+
+function checkForCircularFormulaRef(formulaCol, parsedTree, columns) {
+  // check circular reference
+  // e.g. formula1 -> formula2 -> formula1 should return circular reference error
+
+  // get all formula columns excluding itself
+  const formulaPaths = columns
+    .filter((c) => c.id !== formulaCol?.id && c.uidt === UITypes.Formula)
+    .reduce((res: Record<string, any>[], c: Record<string, any>) => {
+      // in `formula`, get all the (unique) target neighbours
+      // i.e. all column id (e.g. cxxxxxxxxxxxxxx) with formula type
+      const neighbours = [
+        ...new Set(
+          (c.colOptions.formula.match(/c_?\w{14,15}/g) || []).filter(
+            (colId: string) =>
+              columns.filter(
+                (col: ColumnType) =>
+                  col.id === colId && col.uidt === UITypes.Formula
+              ).length
+          )
+        ),
+      ];
+      if (neighbours.length > 0) {
+        // e.g. formula column 1 -> [formula column 2, formula column3]
+        res.push({ [c.id]: neighbours });
+      }
+      return res;
+    }, []);
+
+  // include target formula column (i.e. the one to be saved if applicable)
+  const targetFormulaCol = columns.find(
+    (c: ColumnType) => c.title === parsedTree.name && c.uidt === UITypes.Formula
   );
+
+  if (targetFormulaCol && formulaCol?.id) {
+    formulaPaths.push({
+      [formulaCol?.id as string]: [targetFormulaCol.id],
+    });
+  }
+  const vertices = formulaPaths.length;
+  if (vertices > 0) {
+    // perform kahn's algo for cycle detection
+    const adj = new Map();
+    const inDegrees = new Map();
+    // init adjacency list & indegree
+
+    for (const [_, v] of Object.entries(formulaPaths)) {
+      const src = Object.keys(v)[0];
+      const neighbours = v[src];
+      inDegrees.set(src, inDegrees.get(src) || 0);
+      for (const neighbour of neighbours) {
+        adj.set(src, (adj.get(src) || new Set()).add(neighbour));
+        inDegrees.set(neighbour, (inDegrees.get(neighbour) || 0) + 1);
+      }
+    }
+    const queue: string[] = [];
+    // put all vertices with in-degree = 0 (i.e. no incoming edges) to queue
+    inDegrees.forEach((inDegree, col) => {
+      if (inDegree === 0) {
+        // in-degree = 0 means we start traversing from this node
+        queue.push(col);
+      }
+    });
+    // init count of visited vertices
+    let visited = 0;
+    // BFS
+    while (queue.length !== 0) {
+      // remove a vertex from the queue
+      const src = queue.shift();
+      // if this node has neighbours, increase visited by 1
+      const neighbours = adj.get(src) || new Set();
+      if (neighbours.size > 0) {
+        visited += 1;
+      }
+      // iterate each neighbouring nodes
+      neighbours.forEach((neighbour: string) => {
+        // decrease in-degree of its neighbours by 1
+        inDegrees.set(neighbour, inDegrees.get(neighbour) - 1);
+        // if in-degree becomes 0
+        if (inDegrees.get(neighbour) === 0) {
+          // then put the neighboring node to the queue
+          queue.push(neighbour);
+        }
+      });
+    }
+    // vertices not same as visited = cycle found
+    if (vertices !== visited) {
+      throw new FormulaError(
+        FormulaErrorType.CIRCULAR_REFERENCE,
+        {
+          key: 'msg.formula.cantSaveCircularReference',
+        },
+        'Circular reference detected'
+      );
+    }
+  }
 }
diff --git a/packages/nocodb-sdk/src/lib/sqlUi/MssqlUi.ts b/packages/nocodb-sdk/src/lib/sqlUi/MssqlUi.ts
index 630805770c..2600945349 100644
--- a/packages/nocodb-sdk/src/lib/sqlUi/MssqlUi.ts
+++ b/packages/nocodb-sdk/src/lib/sqlUi/MssqlUi.ts
@@ -919,6 +919,7 @@ export class MssqlUi {
       'COUNT',
       'ROUNDDOWN',
       'ROUNDUP',
+      'DATESTR',
     ];
   }
 }
diff --git a/packages/nocodb-sdk/src/lib/sqlUi/MysqlUi.ts b/packages/nocodb-sdk/src/lib/sqlUi/MysqlUi.ts
index b6c5ca0199..1fcf85e641 100644
--- a/packages/nocodb-sdk/src/lib/sqlUi/MysqlUi.ts
+++ b/packages/nocodb-sdk/src/lib/sqlUi/MysqlUi.ts
@@ -1289,6 +1289,6 @@ export class MysqlUi {
   }
 
   static getUnsupportedFnList() {
-    return ['COUNTA', 'COUNT'];
+    return ['COUNTA', 'COUNT', 'DATESTR'];
   }
 }
diff --git a/packages/nocodb-sdk/src/lib/sqlUi/OracleUi.ts b/packages/nocodb-sdk/src/lib/sqlUi/OracleUi.ts
index fb4ee5ac1a..b32bc730f9 100644
--- a/packages/nocodb-sdk/src/lib/sqlUi/OracleUi.ts
+++ b/packages/nocodb-sdk/src/lib/sqlUi/OracleUi.ts
@@ -948,6 +948,7 @@ export class OracleUi {
       'COUNT',
       'ROUNDDOWN',
       'ROUNDUP',
+      'DATESTR',
     ];
   }
 }
diff --git a/packages/nocodb-sdk/src/lib/sqlUi/SnowflakeUi.ts b/packages/nocodb-sdk/src/lib/sqlUi/SnowflakeUi.ts
index 676a912274..6a5998d298 100644
--- a/packages/nocodb-sdk/src/lib/sqlUi/SnowflakeUi.ts
+++ b/packages/nocodb-sdk/src/lib/sqlUi/SnowflakeUi.ts
@@ -980,6 +980,7 @@ export class SnowflakeUi {
       'VALUE',
       'COUNTA',
       'COUNT',
+      'DATESTR',
     ];
   }
 }
diff --git a/packages/nocodb-sdk/src/lib/sqlUi/SqliteUi.ts b/packages/nocodb-sdk/src/lib/sqlUi/SqliteUi.ts
index bb616eee5d..d5f08d6093 100644
--- a/packages/nocodb-sdk/src/lib/sqlUi/SqliteUi.ts
+++ b/packages/nocodb-sdk/src/lib/sqlUi/SqliteUi.ts
@@ -882,7 +882,10 @@ export class SqliteUi {
       'COUNT',
       'ROUNDDOWN',
       'ROUNDUP',
-
+      'DATESTR',
+      'DAY',
+      'MONTH',
+      'HOUR',
     ];
   }
 }
diff --git a/packages/nocodb-sdk/tsconfig.json b/packages/nocodb-sdk/tsconfig.json
index 8af501e5e0..86fdaa2404 100644
--- a/packages/nocodb-sdk/tsconfig.json
+++ b/packages/nocodb-sdk/tsconfig.json
@@ -38,7 +38,7 @@
     // "emitDecoratorMetadata": true /* Enables experimental support for emitting type metadata for decorators. */,
 
     "lib": ["es2017","dom"],
-    "types": [],
+    "types": ["jest"],
     "typeRoots": ["node_modules/@types", "src/types"],
     "baseUrl": "./src",
     "paths": {
diff --git a/packages/nocodb/src/db/formulav2/formulaQueryBuilderv2.ts b/packages/nocodb/src/db/formulav2/formulaQueryBuilderv2.ts
index 390c733025..1c7a6df4f5 100644
--- a/packages/nocodb/src/db/formulav2/formulaQueryBuilderv2.ts
+++ b/packages/nocodb/src/db/formulav2/formulaQueryBuilderv2.ts
@@ -1,23 +1,26 @@
 import jsep from 'jsep';
 import {
+  FormulaDataTypes,
   jsepCurlyHook,
   UITypes,
   validateDateWithUnknownFormat,
+  validateFormulaAndExtractTreeWithType,
 } from 'nocodb-sdk';
+import { Logger } from '@nestjs/common';
 import mapFunctionName from '../mapFunctionName';
 import genRollupSelectv2 from '../genRollupSelectv2';
-import type Column from '~/models/Column';
-import type Model from '~/models/Model';
 import type RollupColumn from '~/models/RollupColumn';
 import type LinkToAnotherRecordColumn from '~/models/LinkToAnotherRecordColumn';
 import type LookupColumn from '~/models/LookupColumn';
 import type { BaseModelSqlv2 } from '~/db/BaseModelSqlv2';
+import type Column from '~/models/Column';
+import Model from '~/models/Model';
 import NocoCache from '~/cache/NocoCache';
 import { CacheGetType, CacheScope } from '~/utils/globals';
 import { convertDateFormatForConcat } from '~/helpers/formulaFnHelper';
 import FormulaColumn from '~/models/FormulaColumn';
 
-// todo: switch function based on database
+const logger = new Logger('FormulaQueryBuilderv2');
 
 // @ts-ignore
 const getAggregateFn: (fnName: string) => (args: { qb; knex?; cn }) => any = (
@@ -59,17 +62,56 @@ async function _formulaQueryBuilder(
   model: Model,
   aliasToColumn: Record<string, () => Promise<{ builder: any }>> = {},
   tableAlias?: string,
+  parsedTree?: any,
+  column: Column = null,
 ) {
   const knex = baseModelSqlv2.dbDriver;
 
-  // formula may include double curly brackets in previous version
-  // convert to single curly bracket here for compatibility
-  const tree = jsep(_tree.replaceAll('{{', '{').replaceAll('}}', '}'));
+  const columns = await model.getColumns();
+
+  let tree = parsedTree;
+  if (!tree) {
+    // formula may include double curly brackets in previous version
+    // convert to single curly bracket here for compatibility
+    // const _tree1 = jsep(_tree.replaceAll('{{', '{').replaceAll('}}', '}'));
+    tree = await validateFormulaAndExtractTreeWithType({
+      formula: _tree.replaceAll('{{', '{').replaceAll('}}', '}'),
+      columns,
+      column,
+      clientOrSqlUi: baseModelSqlv2.clientType as
+        | 'mysql'
+        | 'pg'
+        | 'sqlite3'
+        | 'mssql'
+        | 'mysql2'
+        | 'oracledb'
+        | 'mariadb'
+        | 'sqlite'
+        | 'snowflake',
+      getMeta: async (modelId) => {
+        const model = await Model.get(modelId);
+        await model.getColumns();
+        return model;
+      },
+    });
+
+    // populate and save parsedTree to column if not exist
+    if (column) {
+      FormulaColumn.update(column.id, { parsed_tree: tree }).then(
+        () => {
+          // ignore
+        },
+        (err) => {
+          logger.error(err);
+        },
+      );
+    }
+  }
 
   const columnIdToUidt = {};
 
   // todo: improve - implement a common solution for filter, sort, formula, etc
-  for (const col of await model.getColumns()) {
+  for (const col of columns) {
     columnIdToUidt[col.id] = col.uidt;
     if (col.id in aliasToColumn) continue;
     switch (col.uidt) {
@@ -84,6 +126,7 @@ async function _formulaQueryBuilder(
               model,
               { ...aliasToColumn, [col.id]: null },
               tableAlias,
+              formulOption.getParsedTree(),
             );
             builder.sql = '(' + builder.sql + ')';
             return {
@@ -404,6 +447,7 @@ async function _formulaQueryBuilder(
                     '',
                     lookupModel,
                     aliasToColumn,
+                    formulaOption.getParsedTree(),
                   );
                   if (isMany) {
                     const qb = selectQb;
@@ -792,8 +836,48 @@ async function _formulaQueryBuilder(
         );
       }
 
+      // if operator is + and expected return type is string, convert to concat
+      if (pt.operator === '+' && pt.dataType === FormulaDataTypes.STRING) {
+        return fn(
+          {
+            type: 'CallExpression',
+            arguments: [pt.left, pt.right],
+            callee: {
+              type: 'Identifier',
+              name: 'CONCAT',
+            },
+          },
+          alias,
+          prevBinaryOp,
+        );
+      }
+
       if (pt.operator === '==') {
         pt.operator = '=';
+        // if left/right is of different type, convert to string and compare
+        if (
+          pt.left.dataType !== pt.right.dataType &&
+          [pt.left.dataType, pt.right.dataType].every(
+            (type) => type !== FormulaDataTypes.NULL,
+          )
+        ) {
+          pt.left = {
+            type: 'CallExpression',
+            arguments: [pt.left],
+            callee: {
+              type: 'Identifier',
+              name: 'STRING',
+            },
+          };
+          pt.right = {
+            type: 'CallExpression',
+            arguments: [pt.right],
+            callee: {
+              type: 'Identifier',
+              name: 'STRING',
+            },
+          };
+        }
       }
 
       if (pt.operator === '/') {
@@ -947,6 +1031,7 @@ export default async function formulaQueryBuilderv2(
   aliasToColumn = {},
   tableAlias?: string,
   validateFormula = false,
+  parsedTree?: any,
 ) {
   const knex = baseModelSqlv2.dbDriver;
   // register jsep curly hook once only
@@ -959,6 +1044,10 @@ export default async function formulaQueryBuilderv2(
     model,
     aliasToColumn,
     tableAlias,
+    parsedTree ??
+      (await column
+        ?.getColOptions<FormulaColumn>()
+        .then((formula) => formula?.getParsedTree())),
   );
 
   if (!validateFormula) return qb;
diff --git a/packages/nocodb/src/db/functionMappings/commonFns.ts b/packages/nocodb/src/db/functionMappings/commonFns.ts
index 547f65796e..e2ab573a91 100644
--- a/packages/nocodb/src/db/functionMappings/commonFns.ts
+++ b/packages/nocodb/src/db/functionMappings/commonFns.ts
@@ -1,33 +1,107 @@
+import { FormulaDataTypes } from 'nocodb-sdk';
 import type { MapFnArgs } from '../mapFunctionName';
 import { NcError } from '~/helpers/catchError';
 
+async function treatArgAsConditionalExp(
+  args: MapFnArgs,
+  argument = args.pt?.arguments?.[0],
+) {
+  const condArg = (await args.fn(argument)).builder.toQuery();
+
+  let cond = condArg;
+
+  // based on the data type of the argument, we need to handle the condition
+  // if string - value is not null and not empty then true
+  // if number - value is not null and not 0 then true
+  // if boolean - value is not null and not false then true
+  // if date - value is not null then true
+  switch (argument.dataType as FormulaDataTypes) {
+    case FormulaDataTypes.NUMERIC:
+      cond = `(${condArg}) IS NOT NULL AND (${condArg}) != 0`;
+      break;
+    case FormulaDataTypes.STRING:
+      cond = `(${condArg}) IS NOT NULL AND (${condArg}) != ''`;
+      break;
+    case FormulaDataTypes.BOOLEAN:
+      cond = `(${condArg}) IS NOT NULL AND (${condArg}) != false`;
+      break;
+    case FormulaDataTypes.DATE:
+      cond = `(${condArg}) IS NOT NULL`;
+      break;
+  }
+  return { builder: args.knex.raw(cond) };
+}
+
 export default {
   // todo: handle default case
   SWITCH: async (args: MapFnArgs) => {
     const count = Math.floor((args.pt.arguments.length - 1) / 2);
     let query = '';
 
+    const returnArgsType = new Set(
+      args.pt.arguments
+        .filter(
+          (type, i) => i > 1 && i % 2 === 0 && type !== FormulaDataTypes.NULL,
+        )
+        .map((type) => type.dataType),
+    );
+
+    // if else case present then push that to types
+    if (args.pt.arguments.length % 2 === 0) {
+      returnArgsType.add(
+        args.pt.arguments[args.pt.arguments.length - 1].dataType,
+      );
+    }
+
     const switchVal = (await args.fn(args.pt.arguments[0])).builder.toQuery();
 
     for (let i = 0; i < count; i++) {
+      let val;
+      // cast to string if the return value types are different
+      if (returnArgsType.size > 1) {
+        val = (
+          await args.fn({
+            type: 'CallExpression',
+            arguments: [args.pt.arguments[i * 2 + 2]],
+            callee: {
+              type: 'Identifier',
+              name: 'STRING',
+            },
+          } as any)
+        ).builder.toQuery();
+      } else {
+        val = (await args.fn(args.pt.arguments[i * 2 + 2])).builder.toQuery();
+      }
+
       query += args.knex
         .raw(
           `\n\tWHEN ${(
             await args.fn(args.pt.arguments[i * 2 + 1])
-          ).builder.toQuery()} THEN ${(
-            await args.fn(args.pt.arguments[i * 2 + 2])
-          ).builder.toQuery()}`,
+          ).builder.toQuery()} THEN ${val}`,
         )
         .toQuery();
     }
     if (args.pt.arguments.length % 2 === 0) {
-      query += args.knex
-        .raw(
-          `\n\tELSE ${(
-            await args.fn(args.pt.arguments[args.pt.arguments.length - 1])
-          ).builder.toQuery()}`,
-        )
-        .toQuery();
+      let val;
+      // cast to string if the return value types are different
+      if (returnArgsType.size > 1) {
+        val = (
+          await args.fn({
+            type: 'CallExpression',
+            arguments: [args.pt.arguments[args.pt.arguments.length - 1]],
+            callee: {
+              type: 'Identifier',
+              name: 'STRING',
+            },
+          } as any)
+        ).builder.toQuery();
+      } else {
+        val = (
+          await args.fn(args.pt.arguments[args.pt.arguments.length - 1])
+        ).builder.toQuery();
+      }
+
+      query += `\n\tELSE ${val}`;
     }
     return {
       builder: args.knex.raw(
@@ -36,24 +110,52 @@ export default {
     };
   },
   IF: async (args: MapFnArgs) => {
-    let query = args.knex
-      .raw(
-        `\n\tWHEN ${(
-          await args.fn(args.pt.arguments[0])
-        ).builder.toQuery()} THEN ${(
-          await args.fn(args.pt.arguments[1])
-        ).builder.toQuery()}`,
-      )
-      .toQuery();
+    const cond = (await treatArgAsConditionalExp(args)).builder;
+    let thenArg;
+    let elseArg;
+    const returnArgsType = new Set(
+      [args.pt.arguments[1].dataType, args.pt.arguments[2].dataType].filter(
+        (type) => type !== FormulaDataTypes.NULL,
+      ),
+    );
+    // cast to string if the return value types are different
+    if (returnArgsType.size > 1) {
+      thenArg = (
+        await args.fn({
+          type: 'CallExpression',
+          arguments: [args.pt.arguments[1]],
+          callee: {
+            type: 'Identifier',
+            name: 'STRING',
+          },
+        } as any)
+      ).builder;
+      elseArg = (
+        await args.fn({
+          type: 'CallExpression',
+          arguments: [args.pt.arguments[2]],
+          callee: {
+            type: 'Identifier',
+            name: 'STRING',
+          },
+        } as any)
+      ).builder;
+    } else {
+      thenArg = (await args.fn(args.pt.arguments[1])).builder.toQuery();
+      elseArg = (await args.fn(args.pt.arguments[2])).builder.toQuery();
+    }
+
+    let query = args.knex.raw(`\n\tWHEN ${cond} THEN ${thenArg}`).toQuery();
     if (args.pt.arguments[2]) {
-      query += args.knex
-        .raw(
-          `\n\tELSE ${(await args.fn(args.pt.arguments[2])).builder.toQuery()}`,
-        )
-        .toQuery();
+      query += args.knex.raw(`\n\tELSE ${elseArg}`).toQuery();
     }
     return { builder: args.knex.raw(`CASE ${query}\n END${args.colAlias}`) };
   },
+  // used only for casting to string internally, this one is dummy function
+  // and will work as fallback for dbs which don't support/implemented CAST
+  STRING(args: MapFnArgs) {
+    return args.fn(args.pt?.arguments?.[0]);
+  },
   AND: async (args: MapFnArgs) => {
     return {
       builder: args.knex.raw(
@@ -62,7 +164,7 @@ export default {
             `${(
               await Promise.all(
                 args.pt.arguments.map(async (ar) =>
-                  (await args.fn(ar)).builder.toQuery(),
+                  (await treatArgAsConditionalExp(args, ar)).builder.toQuery(),
                 ),
               )
             ).join(' AND ')}`,
@@ -80,7 +182,7 @@ export default {
             `${(
               await Promise.all(
                 args.pt.arguments.map(async (ar) =>
-                  (await args.fn(ar)).builder.toQuery(),
+                  (await treatArgAsConditionalExp(args, ar)).builder.toQuery(),
                 ),
               )
             ).join(' OR ')}`,
@@ -124,7 +226,7 @@ export default {
     const query = (await args.fn(args.pt.arguments[0])).builder;
     return {
       builder: args.knex.raw(
-        `CASE WHEN ${query} % 2 = 0 THEN CEIL(${query})\nELSE CEIL(${query} / 2.0) * 2\n END${args.colAlias}`,
+        `CASE WHEN ${query} >= 0 THEN CEIL((${query}) / 2.0) * 2 \n ELSE FLOOR((${query} + 2) / 2.0) * 2 - 2\n END${args.colAlias}`,
       ),
     };
   },
@@ -201,7 +303,7 @@ export default {
 
     return {
       builder: knex.raw(
-        `ROUND(FLOOR((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder}))${colAlias}`,
+        `(FLOOR((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder}))${colAlias}`,
       ),
     };
   },
@@ -215,7 +317,7 @@ export default {
 
     return {
       builder: knex.raw(
-        `ROUND(CEIL((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder}))${colAlias}`,
+        `(CEIL((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder}))${colAlias}`,
       ),
     };
   },
diff --git a/packages/nocodb/src/db/functionMappings/mysql.ts b/packages/nocodb/src/db/functionMappings/mysql.ts
index 8026806876..93d798bde3 100644
--- a/packages/nocodb/src/db/functionMappings/mysql.ts
+++ b/packages/nocodb/src/db/functionMappings/mysql.ts
@@ -125,7 +125,9 @@ const mysql2 = {
     const source = (await fn(pt.arguments[0])).builder;
     const pattern = (await fn(pt.arguments[1])).builder;
     return {
-      builder: knex.raw(`REGEXP_SUBSTR(${source}, ${pattern}) ${colAlias}`),
+      builder: knex.raw(
+        `REGEXP_SUBSTR(${source}, ${pattern}, 1, 1, 'c') ${colAlias}`,
+      ),
     };
   },
   REGEX_REPLACE: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
@@ -134,7 +136,7 @@ const mysql2 = {
     const replacement = (await fn(pt.arguments[2])).builder;
     return {
       builder: knex.raw(
-        `REGEXP_REPLACE(${source}, ${pattern}, ${replacement}) ${colAlias}`,
+        `REGEXP_REPLACE(${source}, ${pattern}, ${replacement}, 1, 0, 'c') ${colAlias}`,
       ),
     };
   },
@@ -160,6 +162,15 @@ END) ${colAlias}`,
       ),
     };
   },
+  STRING: async (args: MapFnArgs) => {
+    return {
+      builder: args.knex.raw(
+        `CAST(${(await args.fn(args.pt.arguments[0])).builder} AS CHAR) ${
+          args.colAlias
+        }`,
+      ),
+    };
+  },
 };
 
 export default mysql2;
diff --git a/packages/nocodb/src/db/functionMappings/pg.ts b/packages/nocodb/src/db/functionMappings/pg.ts
index a26180ab34..f6fa76b3da 100644
--- a/packages/nocodb/src/db/functionMappings/pg.ts
+++ b/packages/nocodb/src/db/functionMappings/pg.ts
@@ -1,4 +1,5 @@
 import dayjs from 'dayjs';
+import { FormulaDataTypes } from 'nocodb-sdk';
 import commonFns from './commonFns';
 import type { MapFnArgs } from '../mapFunctionName';
 import { convertUnits } from '~/helpers/convertUnits';
@@ -57,9 +58,9 @@ const pg = {
   DATEADD: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
     return {
       builder: knex.raw(
-        `${(await fn(pt.arguments[0])).builder} + (${
-          (await fn(pt.arguments[1])).builder
-        } || 
+        `(${(await fn(pt.arguments[0])).builder})${
+          pt.arguments[0].dataType !== FormulaDataTypes.DATE ? '::DATE' : ''
+        } + (${(await fn(pt.arguments[1])).builder} || 
       '${String((await fn(pt.arguments[2])).builder).replace(
         /["']/g,
         '',
@@ -134,6 +135,42 @@ const pg = {
       ),
     };
   },
+  DATESTR: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
+    return {
+      builder: knex.raw(
+        `TO_CHAR((${
+          (await fn(pt?.arguments[0])).builder
+        }), 'YYYY-MM-DD')::text ${colAlias}`,
+      ),
+    };
+  },
+  DAY: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
+    return {
+      builder: knex.raw(
+        `EXTRACT('Day' FROM ((${
+          (await fn(pt?.arguments[0])).builder
+        })::TIMESTAMP)) ${colAlias}`,
+      ),
+    };
+  },
+  MONTH: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
+    return {
+      builder: knex.raw(
+        `EXTRACT('Month' FROM ((${
+          (await fn(pt?.arguments[0])).builder
+        })::TIMESTAMP)) ${colAlias}`,
+      ),
+    };
+  },
+  HOUR: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
+    return {
+      builder: knex.raw(
+        `EXTRACT('Hour' FROM ((${
+          (await fn(pt?.arguments[0])).builder
+        })::TIMESTAMP)) ${colAlias}`,
+      ),
+    };
+  },
   AND: async (args: MapFnArgs) => {
     return {
       builder: args.knex.raw(
@@ -191,15 +228,17 @@ const pg = {
   },
   REGEX_MATCH: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
     const source = (await fn(pt.arguments[0])).builder;
+
     const pattern = (await fn(pt.arguments[1])).builder;
     return {
       builder: knex.raw(
-        `CASE WHEN (${source}::TEXT ~ ${pattern}::TEXT) THEN 1 ELSE 0 END ${colAlias}`,
+        `CASE WHEN REGEXP_MATCH(${source}::TEXT, ${pattern}::TEXT) IS NULL THEN 0 ELSE 1 END ${colAlias}`,
       ),
     };
   },
   REGEX_EXTRACT: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
     const source = (await fn(pt.arguments[0])).builder;
+
     const pattern = (await fn(pt.arguments[1])).builder;
     return {
       builder: knex.raw(
@@ -212,6 +251,7 @@ const pg = {
   REGEX_REPLACE: async ({ fn, knex, pt, colAlias }: MapFnArgs) => {
     const source = (await fn(pt.arguments[0])).builder;
     const pattern = (await fn(pt.arguments[1])).builder;
+
     const replacement = (await fn(pt.arguments[2])).builder;
     return {
       builder: knex.raw(
@@ -263,11 +303,11 @@ const pg = {
 
     return {
       builder: knex.raw(
-        `ROUND(CASE 
+        `CASE 
   WHEN ${value} IS NULL OR REGEXP_REPLACE(${value}::TEXT, '[^\\d.]+', '', 'g') IN ('.', '') OR LENGTH(REGEXP_REPLACE(${value}::TEXT, '[^.]+', '', 'g')) > 1 THEN NULL
   WHEN LENGTH(REGEXP_REPLACE(${value}::TEXT, '[^%]', '','g')) > 0 THEN POW(-1, LENGTH(REGEXP_REPLACE(${value}::TEXT, '[^-]','', 'g'))) * (REGEXP_REPLACE(${value}::TEXT, '[^\\d.]+', '', 'g'))::NUMERIC / 100
   ELSE POW(-1, LENGTH(REGEXP_REPLACE(${value}::TEXT, '[^-]', '', 'g'))) * (REGEXP_REPLACE(${value}::TEXT, '[^\\d.]+', '', 'g'))::NUMERIC
-END) ${colAlias}`,
+END ${colAlias}`,
       ),
     };
   },
@@ -281,7 +321,7 @@ END) ${colAlias}`,
 
     return {
       builder: knex.raw(
-        `ROUND((FLOOR((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder})::numeric(30,${precisionBuilder})))${colAlias}`,
+        `(FLOOR((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder})::numeric(30,${precisionBuilder}))${colAlias}`,
       ),
     };
   },
@@ -295,7 +335,16 @@ END) ${colAlias}`,
 
     return {
       builder: knex.raw(
-        `ROUND((CEIL((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder}))::numeric(30,${precisionBuilder}))${colAlias}`,
+        `(CEIL((${valueBuilder}) * POWER(10, ${precisionBuilder})) / POWER(10, ${precisionBuilder})::numeric(30,${precisionBuilder}))${colAlias}`,
+      ),
+    };
+  },
+  STRING: async (args: MapFnArgs) => {
+    return {
+      builder: args.knex.raw(
+        `(${(await args.fn(args.pt.arguments[0])).builder})::text ${
+          args.colAlias
+        }`,
       ),
     };
   },
diff --git a/packages/nocodb/src/meta/migrations/XcMigrationSourcev2.ts b/packages/nocodb/src/meta/migrations/XcMigrationSourcev2.ts
index 6dedcf2843..643f5c4d0a 100644
--- a/packages/nocodb/src/meta/migrations/XcMigrationSourcev2.ts
+++ b/packages/nocodb/src/meta/migrations/XcMigrationSourcev2.ts
@@ -24,6 +24,7 @@ import * as nc_034_erd_filter_and_notification from '~/meta/migrations/v2/nc_034
 import * as nc_035_add_username_to_users from '~/meta/migrations/v2/nc_035_add_username_to_users';
 import * as nc_036_base_deleted from '~/meta/migrations/v2/nc_036_base_deleted';
 import * as nc_037_rename_project_and_base from '~/meta/migrations/v2/nc_037_rename_project_and_base';
+import * as nc_038_formula_parsed_tree_column from '~/meta/migrations/v2/nc_038_formula_parsed_tree_column';
 
 // Create a custom migration source class
 export default class XcMigrationSourcev2 {
@@ -59,6 +60,7 @@ export default class XcMigrationSourcev2 {
       'nc_035_add_username_to_users',
       'nc_036_base_deleted',
       'nc_037_rename_project_and_base',
+      'nc_038_formula_parsed_tree_column',
     ]);
   }
 
@@ -120,6 +122,8 @@ export default class XcMigrationSourcev2 {
         return nc_036_base_deleted;
       case 'nc_037_rename_project_and_base':
         return nc_037_rename_project_and_base;
+      case 'nc_038_formula_parsed_tree_column':
+        return nc_038_formula_parsed_tree_column;
     }
   }
 }
diff --git a/packages/nocodb/src/meta/migrations/v2/nc_038_formula_parsed_tree_column.ts b/packages/nocodb/src/meta/migrations/v2/nc_038_formula_parsed_tree_column.ts
new file mode 100644
index 0000000000..5e50af058c
--- /dev/null
+++ b/packages/nocodb/src/meta/migrations/v2/nc_038_formula_parsed_tree_column.ts
@@ -0,0 +1,16 @@
+import type { Knex } from 'knex';
+import { MetaTable } from '~/utils/globals';
+
+const up = async (knex: Knex) => {
+  await knex.schema.alterTable(MetaTable.COL_FORMULA, (table) => {
+    table.text('parsed_tree');
+  });
+};
+
+const down = async (knex: Knex) => {
+  await knex.schema.alterTable(MetaTable.COL_FORMULA, (table) => {
+    table.dropColumn('parsed_tree');
+  });
+};
+
+export { up, down };
diff --git a/packages/nocodb/src/models/Column.ts b/packages/nocodb/src/models/Column.ts
index 484ae6579b..2d76ed8860 100644
--- a/packages/nocodb/src/models/Column.ts
+++ b/packages/nocodb/src/models/Column.ts
@@ -308,6 +308,7 @@ export default class Column<T = any> implements ColumnType {
             fk_column_id: colId,
             formula: column.formula,
             formula_raw: column.formula_raw,
+            parsed_tree: column.parsed_tree,
           },
           ncMeta,
         );
@@ -713,7 +714,11 @@ export default class Column<T = any> implements ColumnType {
             title: col?.title,
           })
         )
-          await FormulaColumn.update(formulaCol.id, formula, ncMeta);
+          await FormulaColumn.update(
+            formulaCol.id,
+            formula as FormulaColumn & { parsed_tree?: any },
+            ncMeta,
+          );
       }
     }
 
diff --git a/packages/nocodb/src/models/FormulaColumn.ts b/packages/nocodb/src/models/FormulaColumn.ts
index 955d480b11..f807737286 100644
--- a/packages/nocodb/src/models/FormulaColumn.ts
+++ b/packages/nocodb/src/models/FormulaColumn.ts
@@ -2,19 +2,23 @@ import Noco from '~/Noco';
 import NocoCache from '~/cache/NocoCache';
 import { extractProps } from '~/helpers/extractProps';
 import { CacheGetType, CacheScope, MetaTable } from '~/utils/globals';
+import { parseMetaProp, stringifyMetaProp } from '~/utils/modelUtils';
 
 export default class FormulaColumn {
   formula: string;
   formula_raw: string;
   fk_column_id: string;
   error: string;
+  private parsed_tree?: any;
 
-  constructor(data: Partial<FormulaColumn>) {
-    Object.assign(this, data);
+  constructor(data: Partial<FormulaColumn> & { parsed_tree?: any }) {
+    const { parsed_tree, ...rest } = data;
+    this.parsed_tree = parsed_tree;
+    Object.assign(this, rest);
   }
 
   public static async insert(
-    formulaColumn: Partial<FormulaColumn>,
+    formulaColumn: Partial<FormulaColumn> & { parsed_tree?: any },
     ncMeta = Noco.ncMeta,
   ) {
     const insertObj = extractProps(formulaColumn, [
@@ -22,11 +26,16 @@ export default class FormulaColumn {
       'formula_raw',
       'formula',
       'error',
+      'parsed_tree',
     ]);
+
+    insertObj.parsed_tree = stringifyMetaProp(insertObj, 'parsed_tree');
+
     await ncMeta.metaInsert2(null, null, MetaTable.COL_FORMULA, insertObj);
 
     return this.read(formulaColumn.fk_column_id, ncMeta);
   }
+
   public static async read(columnId: string, ncMeta = Noco.ncMeta) {
     let column =
       columnId &&
@@ -41,7 +50,10 @@ export default class FormulaColumn {
         MetaTable.COL_FORMULA,
         { fk_column_id: columnId },
       );
-      await NocoCache.set(`${CacheScope.COL_FORMULA}:${columnId}`, column);
+      if (column) {
+        column.parsed_tree = parseMetaProp(column, 'parsed_tree');
+        await NocoCache.set(`${CacheScope.COL_FORMULA}:${columnId}`, column);
+      }
     }
 
     return column ? new FormulaColumn(column) : null;
@@ -51,7 +63,7 @@ export default class FormulaColumn {
 
   static async update(
     id: string,
-    formula: Partial<FormulaColumn>,
+    formula: Partial<FormulaColumn> & { parsed_tree?: any },
     ncMeta = Noco.ncMeta,
   ) {
     const updateObj = extractProps(formula, [
@@ -59,7 +71,11 @@ export default class FormulaColumn {
       'formula_raw',
       'fk_column_id',
       'error',
+      'parsed_tree',
     ]);
+
+    updateObj.parsed_tree = stringifyMetaProp(updateObj, 'parsed_tree');
+
     // get existing cache
     const key = `${CacheScope.COL_FORMULA}:${id}`;
     let o = await NocoCache.get(key, CacheGetType.TYPE_OBJECT);
@@ -71,4 +87,8 @@ export default class FormulaColumn {
     // set meta
     await ncMeta.metaUpdate(null, null, MetaTable.COL_FORMULA, updateObj, id);
   }
+
+  public getParsedTree() {
+    return this.parsed_tree;
+  }
 }
diff --git a/packages/nocodb/src/services/columns.service.ts b/packages/nocodb/src/services/columns.service.ts
index 09cecbd6e6..d0753f54f2 100644
--- a/packages/nocodb/src/services/columns.service.ts
+++ b/packages/nocodb/src/services/columns.service.ts
@@ -6,6 +6,7 @@ import {
   substituteColumnAliasWithIdInFormula,
   substituteColumnIdWithAliasInFormula,
   UITypes,
+  validateFormulaAndExtractTreeWithType,
 } from 'nocodb-sdk';
 import { pluralize, singularize } from 'inflection';
 import hash from 'object-hash';
@@ -184,6 +185,7 @@ export class ColumnsService {
     let colBody = { ...param.column } as Column & {
       formula?: string;
       formula_raw?: string;
+      parsed_tree?: any;
     };
     if (
       [
@@ -208,6 +210,17 @@ export class ColumnsService {
             colBody.formula_raw || colBody.formula,
             table.columns,
           );
+          colBody.parsed_tree = await validateFormulaAndExtractTreeWithType({
+            formula: colBody.formula || colBody.formula_raw,
+            columns: table.columns,
+            column,
+            clientOrSqlUi: source.type,
+            getMeta: async (modelId) => {
+              const model = await Model.get(modelId);
+              await model.getColumns();
+              return model;
+            },
+          });
 
           try {
             const baseModel = await reuseOrSave('baseModel', reuse, async () =>
@@ -227,6 +240,7 @@ export class ColumnsService {
               {},
               null,
               true,
+              colBody.parsed_tree,
             );
           } catch (e) {
             console.error(e);
@@ -931,6 +945,17 @@ export class ColumnsService {
                       ]);
                     await FormulaColumn.update(c.id, {
                       formula_raw: new_formula_raw,
+                      parsed_tree: await validateFormulaAndExtractTreeWithType({
+                        formula: new_formula_raw,
+                        columns: table.columns,
+                        column,
+                        clientOrSqlUi: source.type,
+                        getMeta: async (modelId) => {
+                          const model = await Model.get(modelId);
+                          await model.getColumns();
+                          return model;
+                        },
+                      }),
                     });
                   }
                 }
@@ -992,6 +1017,17 @@ export class ColumnsService {
                       ]);
                     await FormulaColumn.update(c.id, {
                       formula_raw: new_formula_raw,
+                      parsed_tree: await validateFormulaAndExtractTreeWithType({
+                        formula: new_formula_raw,
+                        columns: table.columns,
+                        column,
+                        clientOrSqlUi: source.type,
+                        getMeta: async (modelId) => {
+                          const model = await Model.get(modelId);
+                          await model.getColumns();
+                          return model;
+                        },
+                      }),
                     });
                   }
                 }
@@ -1197,6 +1233,22 @@ export class ColumnsService {
           colBody.formula_raw || colBody.formula,
           table.columns,
         );
+        colBody.parsed_tree = await validateFormulaAndExtractTreeWithType({
+          // formula may include double curly brackets in previous version
+          // convert to single curly bracket here for compatibility
+          formula: colBody.formula,
+          column: {
+            ...colBody,
+            colOptions: colBody,
+          },
+          columns: table.columns,
+          clientOrSqlUi: source.type,
+          getMeta: async (modelId) => {
+            const model = await Model.get(modelId);
+            await model.getColumns();
+            return model;
+          },
+        });
 
         try {
           const baseModel = await reuseOrSave('baseModel', reuse, async () =>
diff --git a/packages/nocodb/tests/unit/factory/column.ts b/packages/nocodb/tests/unit/factory/column.ts
index 21740b1bc9..0b88dc1fc2 100644
--- a/packages/nocodb/tests/unit/factory/column.ts
+++ b/packages/nocodb/tests/unit/factory/column.ts
@@ -386,6 +386,23 @@ const updateViewColumn = async (
   return updatedColumn;
 };
 
+const updateColumn = async (
+  context,
+  { table, column, attr }: { column: Column; table: Model; attr: any },
+) => {
+  const res = await request(context.app)
+    .patch(`/api/v2/meta/columns/${column.id}`)
+    .set('xc-auth', context.token)
+    .send({
+      ...attr,
+    });
+
+  const updatedColumn: Column = (await table.getColumns()).find(
+    (column) => column.id === column.id,
+  );
+  return updatedColumn;
+};
+
 export {
   customColumns,
   defaultColumns,
@@ -396,4 +413,5 @@ export {
   createLookupColumn,
   createLtarColumn,
   updateViewColumn,
+  updateColumn,
 };
diff --git a/packages/nocodb/tests/unit/rest/index.test.ts b/packages/nocodb/tests/unit/rest/index.test.ts
index 0eb63c4506..f14c76c4e3 100644
--- a/packages/nocodb/tests/unit/rest/index.test.ts
+++ b/packages/nocodb/tests/unit/rest/index.test.ts
@@ -10,6 +10,7 @@ import attachmentTests from './tests/attachment.test';
 import filterTest from './tests/filter.test';
 import newDataApisTest from './tests/newDataApis.test';
 import groupByTest from './tests/groupby.test';
+import formulaTests from './tests/formula.test';
 
 let workspaceTest = () => {};
 if (process.env.EE === 'true') {
@@ -31,6 +32,7 @@ function restTests() {
   newDataApisTest();
   groupByTest();
   workspaceTest();
+  formulaTests();
 
   // Enable for dashboard feature
   // widgetTest();
diff --git a/packages/nocodb/tests/unit/rest/tests/formula.test.ts b/packages/nocodb/tests/unit/rest/tests/formula.test.ts
new file mode 100644
index 0000000000..c00167cb80
--- /dev/null
+++ b/packages/nocodb/tests/unit/rest/tests/formula.test.ts
@@ -0,0 +1,125 @@
+import 'mocha';
+import { UITypes } from 'nocodb-sdk';
+import { expect } from 'chai';
+import init from '../../init';
+import { createProject } from '../../factory/base';
+import { createTable } from '../../factory/table';
+import { createBulkRows, listRow, rowMixedValue } from '../../factory/row';
+import { updateColumn } from '../../factory/column';
+import type Model from '../../../../src/models/Model';
+import type Base from '~/models/Base';
+
+let context;
+let base: Base;
+let table: Model;
+let columns: any[];
+let unfilteredRecords: any[] = [];
+
+function formulaRegExpBased() {
+  // prepare data for test cases
+  beforeEach(async function () {
+    context = await init();
+    base = await createProject(context);
+    table = await createTable(context, base, {
+      table_name: 'sampleTable',
+      title: 'sampleTable',
+      columns: [
+        {
+          column_name: 'Id',
+          title: 'Id',
+          uidt: UITypes.ID,
+        },
+        {
+          column_name: 'Title',
+          title: 'Title',
+          uidt: UITypes.SingleLineText,
+        },
+        {
+          column_name: 'formula',
+          title: 'formula',
+          uidt: UITypes.Formula,
+          formula: '20',
+        },
+      ],
+    });
+
+    columns = await table.getColumns();
+
+    const rowAttributes = [];
+    for (let i = 0; i < 100; i++) {
+      const row = {
+        Title: rowMixedValue(columns[1], i),
+      };
+      rowAttributes.push(row);
+    }
+
+    await createBulkRows(context, {
+      base,
+      table,
+      values: rowAttributes,
+    });
+    unfilteredRecords = await listRow({ base, table });
+
+    // verify length of unfiltered records to be 800
+    expect(unfilteredRecords.length).to.equal(100);
+  });
+
+  it('Type: REGEX_MATCH ', async () => {
+    // if not pg or mysql, skip regex test since it is not implemented for other databases
+    if (!['pg', 'mysql2', 'mysql'].includes(base.sources[0].type)) {
+      return;
+    }
+
+    const formulaList = [
+      `REGEX_MATCH("123-45-6789", "\\d{3}-\\d{2}-\\d{4}")`,
+      'REGEX_MATCH("123-45-6789", "\\d{3}-\\d{2}-\\d{4}")',
+      'REGEX_MATCH("123-45-6789", "\\d{3}-\\d{2}-\\d{4}")',
+      'REGEX_MATCH("ABC-45-6789", "\\w{3}-\\d{2}-\\d{4}")',
+      'REGEX_MATCH("123-XY-6789", "\\d{3}-\\D{2}-\\d{4}")',
+      'REGEX_MATCH("123-45-$#@!", "123-45-[\\s\\S]{4}")',
+      'REGEX_MATCH("123456789", "1?2?3?-?4?5-?6?7?8?9?")',
+      'REGEX_MATCH("123-456789", "\\d{3}-?\\d{2}-?\\d{4}")',
+      'REGEX_MATCH("123-45-6789", "123-\\d{2}-6789")',
+      'REGEX_MATCH("abc123", "[a-z]{3}\\d{3}")',
+      'REGEX_MATCH("A1B2C3", "[A-Z]\\d[A-Z]\\d[A-Z]\\d")',
+      'REGEX_MATCH("hello123world", "\\w{5}\\d{3}\\w{5}")',
+      'REGEX_MATCH("email@example.com", "[a-zA-Z]+@[a-zA-Z]+\\.[a-zA-Z]+")',
+      'REGEX_MATCH("2023-12-14", "\\d{4}-\\d{2}-\\d{2}")',
+      'REGEX_MATCH("USD 100.50", "USD \\d+\\.\\d{2}")',
+      'REGEX_MATCH("http://www.example.com", "https?://[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")',
+      'REGEX_MATCH("555-1234", "\\d{3}-\\d{4}")',
+      'REGEX_MATCH("username123", "[a-zA-Z]+\\d{3}")',
+      'REGEX_MATCH("apple, orange, banana", "\\w+, \\w+, \\w+")',
+      'REGEX_MATCH("aaaabbcc", "(\\w{2})\\1")',
+      'REGEX_MATCH("1234567890", "\\d{10}")',
+      'REGEX_MATCH("12.34", "\\d+\\.\\d{2}")',
+      'REGEX_MATCH("123 Main St, City", "\\d+ [a-zA-Z]+ St, [a-zA-Z]+")',
+      'REGEX_MATCH("X1Y2Z3", "[A-Z]\\d[A-Z]\\d[A-Z]\\d")',
+      'REGEX_MATCH("555-555-5555", "\\d{3}-\\d{3}-\\d{4}")',
+      'REGEX_MATCH("password123", "^(?=.*\\d)(?=.*[a-zA-Z]).{8,}$")',
+      'REGEX_MATCH("12345", "^[0-9]{5}$")',
+      'REGEX_MATCH("abc123!@#", "[a-zA-Z0-9!@#]+")',
+      'REGEX_MATCH("12-December-2023", "\\d{2}-[a-zA-Z]+-\\d{4}")',
+    ];
+
+    for (let i = 0; i < formulaList.length; i++) {
+      await updateColumn(context, {
+        table,
+        column: columns[2],
+        attr: {
+          formula: formulaList[i],
+          formula_raw: formulaList[i],
+          title: 'formula',
+          uidt: UITypes.Formula,
+        },
+      });
+
+      unfilteredRecords = await listRow({ base, table });
+      expect(unfilteredRecords[0].formula).to.equal(1);
+    }
+  });
+}
+
+export default function () {
+  describe('Formula: REGEXP based', formulaRegExpBased);
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3473a7b913..8ec7d5fc7d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -29,16 +29,16 @@ importers:
     dependencies:
       '@braks/revue-draggable':
         specifier: ^0.4.3
-        version: 0.4.3(vue@3.3.11)
+        version: 0.4.3(vue@3.3.13)
       '@ckpack/vue-color':
         specifier: ^1.5.0
-        version: 1.5.0(vue@3.3.11)
+        version: 1.5.0(vue@3.3.13)
       '@iconify/vue':
         specifier: ^4.1.1
-        version: 4.1.1(vue@3.3.11)
+        version: 4.1.1(vue@3.3.13)
       '@pinia/nuxt':
         specifier: ^0.4.11
-        version: 0.4.11(vue@3.3.11)
+        version: 0.4.11(vue@3.3.13)
       '@tiptap/extension-link':
         specifier: 2.0.4
         version: 2.0.4(@tiptap/core@2.1.13)(@tiptap/pm@2.1.13)
@@ -59,28 +59,28 @@ importers:
         version: 2.1.13(@tiptap/pm@2.1.13)
       '@tiptap/vue-3':
         specifier: 2.0.4
-        version: 2.0.4(@tiptap/core@2.1.13)(@tiptap/pm@2.1.13)(vue@3.3.11)
+        version: 2.0.4(@tiptap/core@2.1.13)(@tiptap/pm@2.1.13)(vue@3.3.13)
       '@vue-flow/additional-components':
         specifier: ^1.3.3
-        version: 1.3.3(@vue-flow/core@1.26.0)(vue@3.3.11)
+        version: 1.3.3(@vue-flow/core@1.26.0)(vue@3.3.13)
       '@vue-flow/core':
         specifier: ^1.26.0
-        version: 1.26.0(vue@3.3.11)
+        version: 1.26.0(vue@3.3.13)
       '@vuelidate/core':
         specifier: ^2.0.3
-        version: 2.0.3(vue@3.3.11)
+        version: 2.0.3(vue@3.3.13)
       '@vuelidate/validators':
         specifier: ^2.0.4
-        version: 2.0.4(vue@3.3.11)
+        version: 2.0.4(vue@3.3.13)
       '@vueuse/core':
         specifier: ^10.2.1
-        version: 10.2.1(vue@3.3.11)
+        version: 10.2.1(vue@3.3.13)
       '@vueuse/integrations':
         specifier: ^10.2.1
-        version: 10.2.1(fuse.js@6.6.2)(jwt-decode@3.1.2)(qrcode@1.5.3)(sortablejs@1.15.1)(vue@3.3.11)
+        version: 10.2.1(fuse.js@6.6.2)(jwt-decode@3.1.2)(qrcode@1.5.3)(sortablejs@1.15.1)(vue@3.3.13)
       ant-design-vue:
         specifier: ^3.2.20
-        version: 3.2.20(vue@3.3.11)
+        version: 3.2.20(vue@3.3.13)
       chart.js:
         specifier: ^4.4.1
         version: 4.4.1
@@ -101,7 +101,7 @@ importers:
         version: 1.1.9
       emoji-mart-vue-fast:
         specifier: ^15.0.0
-        version: 15.0.0(vue@3.3.11)
+        version: 15.0.0(vue@3.3.13)
       file-saver:
         specifier: ^2.0.5
         version: 2.0.5
@@ -149,7 +149,7 @@ importers:
         version: 1.0.2
       pinia:
         specifier: ^2.1.7
-        version: 2.1.7(vue@3.3.11)
+        version: 2.1.7(vue@3.3.13)
       qrcode:
         specifier: ^1.5.3
         version: 1.5.3
@@ -188,22 +188,22 @@ importers:
         version: 1.0.3
       vue-chartjs:
         specifier: ^5.2.0
-        version: 5.2.0(chart.js@4.4.1)(vue@3.3.11)
+        version: 5.2.0(chart.js@4.4.1)(vue@3.3.13)
       vue-dompurify-html:
         specifier: ^3.0.0
-        version: 3.0.0(vue@3.3.11)
+        version: 3.0.0(vue@3.3.13)
       vue-github-button:
         specifier: ^3.1.0
         version: 3.1.0
       vue-i18n:
         specifier: ^9.2.2
-        version: 9.2.2(vue@3.3.11)
+        version: 9.2.2(vue@3.3.13)
       vue-qrcode-reader:
         specifier: 3.1.8
         version: 3.1.8
       vue3-calendar-heatmap:
         specifier: ^2.0.5
-        version: 2.0.5(tippy.js@6.3.7)(vue@3.3.11)
+        version: 2.0.5(tippy.js@6.3.7)(vue@3.3.13)
       vue3-contextmenu:
         specifier: ^0.2.12
         version: 0.2.12
@@ -212,10 +212,10 @@ importers:
         version: 1.0.6
       vue3-text-clamp:
         specifier: ^0.1.2
-        version: 0.1.2(resize-detector@0.3.0)(vue@3.3.11)
+        version: 0.1.2(resize-detector@0.3.0)(vue@3.3.13)
       vuedraggable:
         specifier: ^4.1.0
-        version: 4.1.0(vue@3.3.11)
+        version: 4.1.0(vue@3.3.13)
       xlsx:
         specifier: ^0.18.5
         version: 0.18.5
@@ -348,10 +348,10 @@ importers:
         version: 3.3.11
       '@vue/test-utils':
         specifier: ^2.0.2
-        version: 2.0.2(vue@3.3.11)
+        version: 2.0.2(vue@3.3.13)
       '@vueuse/nuxt':
         specifier: ^10.2.1
-        version: 10.2.1(nuxt@3.8.2)(vue@3.3.11)
+        version: 10.2.1(nuxt@3.8.2)(vue@3.3.13)
       '@windicss/plugin-animations':
         specifier: ^1.0.9
         version: 1.0.9
@@ -393,7 +393,7 @@ importers:
         version: 0.14.15(@vue/compiler-sfc@3.3.11)
       unplugin-vue-components:
         specifier: ^0.22.12
-        version: 0.22.12(vue@3.3.11)
+        version: 0.22.12(vue@3.3.13)
       vite-plugin-monaco-editor:
         specifier: ^1.1.0
         version: 1.1.0(monaco-editor@0.33.0)
@@ -915,6 +915,9 @@ importers:
         specifier: ^1.3.8
         version: 1.3.8
     devDependencies:
+      '@types/jest':
+        specifier: ^29.5.2
+        version: 29.5.11
       '@typescript-eslint/eslint-plugin':
         specifier: ^6.14.0
         version: 6.14.0(@typescript-eslint/parser@6.14.0)(eslint@8.54.0)(typescript@5.3.2)
@@ -951,6 +954,9 @@ importers:
       rimraf:
         specifier: ^5.0.5
         version: 5.0.5
+      ts-jest:
+        specifier: ^29.1.1
+        version: 29.1.1(jest@29.5.0)(typescript@5.3.2)
       tsc-alias:
         specifier: ^1.8.8
         version: 1.8.8
@@ -1126,14 +1132,14 @@ packages:
     resolution: {integrity: sha512-4QBZg8ccyC6LPIRii7A0bZUk3+lEDCLnhB+FVsflGdcWPPmV+j3fire4AwwoqHV/BibgvBmR9ZIo4s867smv+g==}
     dev: false
 
-  /@ant-design/icons-vue@6.1.0(vue@3.3.11):
+  /@ant-design/icons-vue@6.1.0(vue@3.3.13):
     resolution: {integrity: sha512-EX6bYm56V+ZrKN7+3MT/ubDkvJ5rK/O2t380WFRflDcVFgsvl3NLH7Wxeau6R8DbrO5jWR6DSTC3B6gYFp77AA==}
     peerDependencies:
       vue: latest
     dependencies:
       '@ant-design/colors': 6.0.0
       '@ant-design/icons-svg': 4.3.1
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /@antfu/eslint-config-basic@0.26.3(@typescript-eslint/parser@5.62.0)(eslint@8.33.0):
@@ -3313,7 +3319,7 @@ packages:
     engines: {node: '>=8.9'}
     dev: false
 
-  /@braks/revue-draggable@0.4.3(vue@3.3.11):
+  /@braks/revue-draggable@0.4.3(vue@3.3.13):
     resolution: {integrity: sha512-wmsfNHJQgSX0HFA726r+cm6ixYs+z/KLxfg1cx6xZ1PBGeZsuQCACdNdoKckyr/IH8FgIbBoIH0/6QiSbW3tEQ==}
     peerDependencies:
       '@vue/composition-api': ^1.0.0-rc.1
@@ -3322,12 +3328,12 @@ packages:
       '@vue/composition-api':
         optional: true
     dependencies:
-      '@vueuse/core': 7.7.1(vue@3.3.11)
-      vue: 3.3.11
-      vue-demi: 0.14.6(vue@3.3.11)
+      '@vueuse/core': 7.7.1(vue@3.3.13)
+      vue: 3.3.13
+      vue-demi: 0.14.6(vue@3.3.13)
     dev: false
 
-  /@ckpack/vue-color@1.5.0(vue@3.3.11):
+  /@ckpack/vue-color@1.5.0(vue@3.3.13):
     resolution: {integrity: sha512-dj1zXVyay2m4LdlLJCQSdIS2FYwUl77BZqyKmUXiehyqjCP0bGYnPcL38lrShzYUc2FdkYQX8ANZZjRahd4PQw==}
     engines: {node: '>=12'}
     peerDependencies:
@@ -3335,7 +3341,7 @@ packages:
     dependencies:
       '@ctrl/tinycolor': 3.6.1
       material-colors: 1.2.6
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /@clickhouse/client@0.0.14:
@@ -4387,13 +4393,13 @@ packages:
       - supports-color
     dev: true
 
-  /@iconify/vue@4.1.1(vue@3.3.11):
+  /@iconify/vue@4.1.1(vue@3.3.13):
     resolution: {integrity: sha512-RL85Bm/DAe8y6rT6pux7D2FJSiUEM/TPfyK7GrbAOfTSwrhvwJW+S5yijdGcmtXouA8MtuH9C7l4hiSE4mLMjg==}
     peerDependencies:
       vue: latest
     dependencies:
       '@iconify/types': 2.0.0
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /@interactjs/actions@1.10.18(@interactjs/core@1.10.18)(@interactjs/utils@1.10.18):
@@ -4509,7 +4515,7 @@ packages:
       magic-string: 0.30.5
       mlly: 1.4.2
       source-map-js: 1.0.2
-      vue-i18n: 9.2.2(vue@3.3.11)
+      vue-i18n: 9.2.2(vue@3.3.13)
       yaml-eslint-parser: 0.3.2
     dev: true
 
@@ -4579,7 +4585,7 @@ packages:
       picocolors: 1.0.0
       source-map-js: 1.0.2
       unplugin: 1.5.0
-      vue-i18n: 9.2.2(vue@3.3.11)
+      vue-i18n: 9.2.2(vue@3.3.13)
     transitivePeerDependencies:
       - rollup
       - supports-color
@@ -5981,7 +5987,7 @@ packages:
   /@nuxt/ui-templates@1.3.1:
     resolution: {integrity: sha512-5gc02Pu1HycOVUWJ8aYsWeeXcSTPe8iX8+KIrhyEtEoOSkY0eMBuo0ssljB8wALuEmepv31DlYe5gpiRwkjESA==}
 
-  /@nuxt/vite-builder@3.8.2(eslint@8.33.0)(sass@1.69.5)(vue@3.3.11):
+  /@nuxt/vite-builder@3.8.2(eslint@8.33.0)(sass@1.69.5)(vue@3.3.13):
     resolution: {integrity: sha512-l/lzDDTbd3M89BpmWqjhVLgLVRqfkKp0tyYgV5seJQjj3SX+IeqI7k6k8+dMEifdeO34jUajVWptNpITXQryyg==}
     engines: {node: ^14.18.0 || >=16.10.0}
     peerDependencies:
@@ -5989,8 +5995,8 @@ packages:
     dependencies:
       '@nuxt/kit': 3.8.2
       '@rollup/plugin-replace': 5.0.5(rollup@4.5.0)
-      '@vitejs/plugin-vue': 4.5.0(vite@4.5.0)(vue@3.3.11)
-      '@vitejs/plugin-vue-jsx': 3.1.0(vite@4.5.0)(vue@3.3.11)
+      '@vitejs/plugin-vue': 4.5.0(vite@4.5.0)(vue@3.3.13)
+      '@vitejs/plugin-vue-jsx': 3.1.0(vite@4.5.0)(vue@3.3.13)
       autoprefixer: 10.4.16(postcss@8.4.31)
       clear: 0.1.0
       consola: 3.2.3
@@ -6019,7 +6025,7 @@ packages:
       vite: 4.5.0(@types/node@20.3.1)(sass@1.69.5)
       vite-node: 0.33.0(sass@1.69.5)
       vite-plugin-checker: 0.6.2(eslint@8.33.0)(vite@4.5.0)
-      vue: 3.3.11
+      vue: 3.3.13
       vue-bundle-renderer: 2.0.0
     transitivePeerDependencies:
       - '@types/node'
@@ -6443,11 +6449,11 @@ packages:
       '@parcel/watcher-win32-x64': 2.3.0
     dev: true
 
-  /@pinia/nuxt@0.4.11(vue@3.3.11):
+  /@pinia/nuxt@0.4.11(vue@3.3.13):
     resolution: {integrity: sha512-bhuNFngJpmBCdAqWguezNJ/oJFR7wvKieqiZrmmdmPR07XjsidAw8RLXHMZE9kUm32M9E6T057OBbG/22jERTg==}
     dependencies:
       '@nuxt/kit': 3.7.0
-      pinia: 2.1.7(vue@3.3.11)
+      pinia: 2.1.7(vue@3.3.13)
     transitivePeerDependencies:
       - '@vue/composition-api'
       - rollup
@@ -8226,7 +8232,7 @@ packages:
       - '@tiptap/pm'
     dev: false
 
-  /@tiptap/vue-3@2.0.4(@tiptap/core@2.1.13)(@tiptap/pm@2.1.13)(vue@3.3.11):
+  /@tiptap/vue-3@2.0.4(@tiptap/core@2.1.13)(@tiptap/pm@2.1.13)(vue@3.3.13):
     resolution: {integrity: sha512-XfoFl1RKCElYIoloGoqMC2iG4RalEtaGvwSAmqqNGdITCdwnuDhLlCvGAjnVbIR4d3Y0NRPyXZzGWfWSi4bbHg==}
     peerDependencies:
       '@tiptap/core': ^2.0.0
@@ -8237,7 +8243,7 @@ packages:
       '@tiptap/extension-bubble-menu': 2.1.12(@tiptap/core@2.1.13)(@tiptap/pm@2.1.13)
       '@tiptap/extension-floating-menu': 2.1.12(@tiptap/core@2.1.13)(@tiptap/pm@2.1.13)
       '@tiptap/pm': 2.1.13
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /@tootallnate/once@1.1.2:
@@ -8704,7 +8710,7 @@ packages:
   /@types/splitpanes@2.2.6:
     resolution: {integrity: sha512-3dV5sO1Ht74iER4jJU03mreL3f+Q2h47ZqXS6Sfbqc6hkCvsDrX1GA0NbYWRdNvZemPyTDzUoApWKeoGbALwkQ==}
     dependencies:
-      vue: 3.3.11
+      vue: 3.3.13
     transitivePeerDependencies:
       - typescript
     dev: true
@@ -8763,7 +8769,7 @@ packages:
   /@types/vue-barcode-reader@0.0.3:
     resolution: {integrity: sha512-klrzMKXdc1eHFnMQXl5QwTGuKki09hh+hxV0AlNjg72VpMRifEbW+roGbDK0LHCK+LTcz13Ebx2/bMKgQr0Ovw==}
     dependencies:
-      vue: 3.3.11
+      vue: 3.3.13
     transitivePeerDependencies:
       - typescript
     dev: true
@@ -8807,7 +8813,7 @@ packages:
       '@eslint-community/regexpp': 4.8.0
       '@typescript-eslint/parser': 5.62.0(eslint@8.33.0)
       '@typescript-eslint/scope-manager': 5.62.0
-      '@typescript-eslint/type-utils': 5.62.0(eslint@8.33.0)
+      '@typescript-eslint/type-utils': 5.62.0(eslint@8.33.0)(typescript@5.3.2)
       '@typescript-eslint/utils': 5.62.0(eslint@8.33.0)(typescript@5.3.2)
       debug: 4.3.4(supports-color@5.5.0)
       eslint: 8.33.0
@@ -9020,25 +9026,6 @@ packages:
       '@typescript-eslint/visitor-keys': 6.14.0
     dev: true
 
-  /@typescript-eslint/type-utils@5.62.0(eslint@8.33.0):
-    resolution: {integrity: sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: '*'
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.3.2)
-      '@typescript-eslint/utils': 5.62.0(eslint@8.33.0)(typescript@5.3.2)
-      debug: 4.3.4(supports-color@5.5.0)
-      eslint: 8.33.0
-      tsutils: 3.21.0(typescript@5.3.2)
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /@typescript-eslint/type-utils@5.62.0(eslint@8.33.0)(typescript@5.3.2):
     resolution: {integrity: sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -9401,7 +9388,7 @@ packages:
       '@unhead/shared': 1.8.5
     dev: true
 
-  /@unhead/vue@1.8.5(vue@3.3.11):
+  /@unhead/vue@1.8.5(vue@3.3.13):
     resolution: {integrity: sha512-m8Q1U1JJvn5LKI5tGRh6f0Of0R64szZN7AXfRN8zTumf6HuOAdg6bHEX+lUX3wtRLUAPzrM9Oz4r0nTqIa9Oow==}
     peerDependencies:
       vue: latest
@@ -9410,7 +9397,7 @@ packages:
       '@unhead/shared': 1.8.5
       hookable: 5.5.3
       unhead: 1.8.5
-      vue: 3.3.11
+      vue: 3.3.13
     dev: true
 
   /@unocss/astro@0.51.13(vite@4.5.0):
@@ -9667,7 +9654,7 @@ packages:
       - supports-color
     dev: true
 
-  /@vitejs/plugin-vue-jsx@3.1.0(vite@4.5.0)(vue@3.3.11):
+  /@vitejs/plugin-vue-jsx@3.1.0(vite@4.5.0)(vue@3.3.13):
     resolution: {integrity: sha512-w9M6F3LSEU5kszVb9An2/MmXNxocAnUb3WhRr8bHlimhDrXNt6n6D2nJQR3UXpGlZHh/EsgouOHCsM8V3Ln+WA==}
     engines: {node: ^14.18.0 || >=16.0.0}
     peerDependencies:
@@ -9678,12 +9665,12 @@ packages:
       '@babel/plugin-transform-typescript': 7.23.4(@babel/core@7.23.3)
       '@vue/babel-plugin-jsx': 1.1.5(@babel/core@7.23.3)
       vite: 4.5.0(@types/node@20.3.1)(sass@1.69.5)
-      vue: 3.3.11
+      vue: 3.3.13
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@vitejs/plugin-vue@4.5.0(vite@4.5.0)(vue@3.3.11):
+  /@vitejs/plugin-vue@4.5.0(vite@4.5.0)(vue@3.3.13):
     resolution: {integrity: sha512-a2WSpP8X8HTEww/U00bU4mX1QpLINNuz/2KMNpLsdu3BzOpak3AGI1CJYBTXcc4SPhaD0eNRUp7IyQK405L5dQ==}
     engines: {node: ^14.18.0 || >=16.0.0}
     peerDependencies:
@@ -9691,7 +9678,7 @@ packages:
       vue: latest
     dependencies:
       vite: 4.5.0(@types/node@20.3.1)(sass@1.69.5)
-      vue: 3.3.11
+      vue: 3.3.13
     dev: true
 
   /@vitest/expect@0.30.1:
@@ -9739,33 +9726,33 @@ packages:
       pretty-format: 27.5.1
     dev: true
 
-  /@vue-flow/additional-components@1.3.3(@vue-flow/core@1.26.0)(vue@3.3.11):
+  /@vue-flow/additional-components@1.3.3(@vue-flow/core@1.26.0)(vue@3.3.13):
     resolution: {integrity: sha512-AZhz0diM7VIN7MGKODiuqiu+xiujFQSs2UdiThgNI5vGSwwizd0g9dGzB+LK0Dt4FCRJ1g64xzxqbrAFFfzuFw==}
     peerDependencies:
       '@vue-flow/core': ^1.0.0
       vue: latest
     dependencies:
-      '@vue-flow/core': 1.26.0(vue@3.3.11)
+      '@vue-flow/core': 1.26.0(vue@3.3.13)
       d3-selection: 3.0.0
       d3-zoom: 3.0.0
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
-  /@vue-flow/core@1.26.0(vue@3.3.11):
+  /@vue-flow/core@1.26.0(vue@3.3.13):
     resolution: {integrity: sha512-/sHe8Cx+KapjP1PdYsJwMgtCXN1kD2/+8We5/VAoQlfiKj3h+WgRJ5BGnluMwSpoaFOTRPhBuynF4r3N4uXJDA==}
     peerDependencies:
       vue: latest
     dependencies:
-      '@vueuse/core': 10.6.1(vue@3.3.11)
+      '@vueuse/core': 10.6.1(vue@3.3.13)
       d3-drag: 3.0.0
       d3-selection: 3.0.0
       d3-zoom: 3.0.0
-      vue: 3.3.11
+      vue: 3.3.13
     transitivePeerDependencies:
       - '@vue/composition-api'
     dev: false
 
-  /@vue-macros/common@1.8.0(vue@3.3.11):
+  /@vue-macros/common@1.8.0(vue@3.3.13):
     resolution: {integrity: sha512-auDJJzE0z3uRe3867e0DsqcseKImktNf5ojCZgUKqiVxb2yTlwlgOVAYCgoep9oITqxkXQymSvFeKhedi8PhaA==}
     engines: {node: '>=16.14.0'}
     peerDependencies:
@@ -9776,11 +9763,11 @@ packages:
     dependencies:
       '@babel/types': 7.23.4
       '@rollup/pluginutils': 5.0.5(rollup@4.5.0)
-      '@vue/compiler-sfc': 3.3.11
+      '@vue/compiler-sfc': 3.3.13
       ast-kit: 0.11.2
       local-pkg: 0.4.3
       magic-string-ast: 0.3.0
-      vue: 3.3.11
+      vue: 3.3.13
     transitivePeerDependencies:
       - rollup
     dev: true
@@ -9815,12 +9802,28 @@ packages:
       '@vue/shared': 3.3.11
       estree-walker: 2.0.2
       source-map-js: 1.0.2
+    dev: true
+
+  /@vue/compiler-core@3.3.13:
+    resolution: {integrity: sha512-bwi9HShGu7uaZLOErZgsH2+ojsEdsjerbf2cMXPwmvcgZfVPZ2BVZzCVnwZBxTAYd6Mzbmf6izcUNDkWnBBQ6A==}
+    dependencies:
+      '@babel/parser': 7.23.5
+      '@vue/shared': 3.3.13
+      estree-walker: 2.0.2
+      source-map-js: 1.0.2
 
   /@vue/compiler-dom@3.3.11:
     resolution: {integrity: sha512-zoAiUIqSKqAJ81WhfPXYmFGwDRuO+loqLxvXmfUdR5fOitPoUiIeFI9cTTyv9MU5O1+ZZglJVTusWzy+wfk5hw==}
     dependencies:
       '@vue/compiler-core': 3.3.11
       '@vue/shared': 3.3.11
+    dev: true
+
+  /@vue/compiler-dom@3.3.13:
+    resolution: {integrity: sha512-EYRDpbLadGtNL0Gph+HoKiYqXLqZ0xSSpR5Dvnu/Ep7ggaCbjRDIus1MMxTS2Qm0koXED4xSlvTZaTnI8cYAsw==}
+    dependencies:
+      '@vue/compiler-core': 3.3.13
+      '@vue/shared': 3.3.13
 
   /@vue/compiler-sfc@3.3.11:
     resolution: {integrity: sha512-U4iqPlHO0KQeK1mrsxCN0vZzw43/lL8POxgpzcJweopmqtoYy9nljJzWDIQS3EfjiYhfdtdk9Gtgz7MRXnz3GA==}
@@ -9835,12 +9838,34 @@ packages:
       magic-string: 0.30.5
       postcss: 8.4.32
       source-map-js: 1.0.2
+    dev: true
+
+  /@vue/compiler-sfc@3.3.13:
+    resolution: {integrity: sha512-DQVmHEy/EKIgggvnGRLx21hSqnr1smUS9Aq8tfxiiot8UR0/pXKHN9k78/qQ7etyQTFj5em5nruODON7dBeumw==}
+    dependencies:
+      '@babel/parser': 7.23.5
+      '@vue/compiler-core': 3.3.13
+      '@vue/compiler-dom': 3.3.13
+      '@vue/compiler-ssr': 3.3.13
+      '@vue/reactivity-transform': 3.3.13
+      '@vue/shared': 3.3.13
+      estree-walker: 2.0.2
+      magic-string: 0.30.5
+      postcss: 8.4.32
+      source-map-js: 1.0.2
 
   /@vue/compiler-ssr@3.3.11:
     resolution: {integrity: sha512-Zd66ZwMvndxRTgVPdo+muV4Rv9n9DwQ4SSgWWKWkPFebHQfVYRrVjeygmmDmPewsHyznCNvJ2P2d6iOOhdv8Qg==}
     dependencies:
       '@vue/compiler-dom': 3.3.11
       '@vue/shared': 3.3.11
+    dev: true
+
+  /@vue/compiler-ssr@3.3.13:
+    resolution: {integrity: sha512-d/P3bCeUGmkJNS1QUZSAvoCIW4fkOKK3l2deE7zrp0ypJEy+En2AcypIkqvcFQOcw3F0zt2VfMvNsA9JmExTaw==}
+    dependencies:
+      '@vue/compiler-dom': 3.3.13
+      '@vue/shared': 3.3.13
 
   /@vue/devtools-api@6.5.0:
     resolution: {integrity: sha512-o9KfBeaBmCKl10usN4crU53fYtC1r7jJwdGKjPT24t348rHxgfpZ0xL3Xm/gLUYnc0oTp8LAmrxOeLyu6tbk2Q==}
@@ -9853,50 +9878,64 @@ packages:
       '@vue/shared': 3.3.11
       estree-walker: 2.0.2
       magic-string: 0.30.5
+    dev: true
 
-  /@vue/reactivity@3.3.11:
-    resolution: {integrity: sha512-D5tcw091f0nuu+hXq5XANofD0OXnBmaRqMYl5B3fCR+mX+cXJIGNw/VNawBqkjLNWETrFW0i+xH9NvDbTPVh7g==}
+  /@vue/reactivity-transform@3.3.13:
+    resolution: {integrity: sha512-oWnydGH0bBauhXvh5KXUy61xr9gKaMbtsMHk40IK9M4gMuKPJ342tKFarY0eQ6jef8906m35q37wwA8DMZOm5Q==}
     dependencies:
-      '@vue/shared': 3.3.11
+      '@babel/parser': 7.23.5
+      '@vue/compiler-core': 3.3.13
+      '@vue/shared': 3.3.13
+      estree-walker: 2.0.2
+      magic-string: 0.30.5
 
-  /@vue/runtime-core@3.3.11:
-    resolution: {integrity: sha512-g9ztHGwEbS5RyWaOpXuyIVFTschclnwhqEbdy5AwGhYOgc7m/q3NFwr50MirZwTTzX55JY8pSkeib9BX04NIpw==}
+  /@vue/reactivity@3.3.13:
+    resolution: {integrity: sha512-fjzCxceMahHhi4AxUBzQqqVhuA21RJ0COaWTbIBl1PruGW1CeY97louZzLi4smpYx+CHfFPPU/CS8NybbGvPKQ==}
     dependencies:
-      '@vue/reactivity': 3.3.11
-      '@vue/shared': 3.3.11
+      '@vue/shared': 3.3.13
 
-  /@vue/runtime-dom@3.3.11:
-    resolution: {integrity: sha512-OlhtV1PVpbgk+I2zl+Y5rQtDNcCDs12rsRg71XwaA2/Rbllw6mBLMi57VOn8G0AjOJ4Mdb4k56V37+g8ukShpQ==}
+  /@vue/runtime-core@3.3.13:
+    resolution: {integrity: sha512-1TzA5TvGuh2zUwMJgdfvrBABWZ7y8kBwBhm7BXk8rvdx2SsgcGfz2ruv2GzuGZNvL1aKnK8CQMV/jFOrxNQUMA==}
     dependencies:
-      '@vue/runtime-core': 3.3.11
-      '@vue/shared': 3.3.11
-      csstype: 3.1.2
+      '@vue/reactivity': 3.3.13
+      '@vue/shared': 3.3.13
 
-  /@vue/server-renderer@3.3.11(vue@3.3.11):
-    resolution: {integrity: sha512-AIWk0VwwxCAm4wqtJyxBylRTXSy1wCLOKbWxHaHiu14wjsNYtiRCSgVuqEPVuDpErOlRdNnuRgipQfXRLjLN5A==}
+  /@vue/runtime-dom@3.3.13:
+    resolution: {integrity: sha512-JJkpE8R/hJKXqVTgUoODwS5wqKtOsmJPEqmp90PDVGygtJ4C0PtOkcEYXwhiVEmef6xeXcIlrT3Yo5aQ4qkHhQ==}
+    dependencies:
+      '@vue/runtime-core': 3.3.13
+      '@vue/shared': 3.3.13
+      csstype: 3.1.3
+
+  /@vue/server-renderer@3.3.13(vue@3.3.13):
+    resolution: {integrity: sha512-vSnN+nuf6iSqTL3Qgx/9A+BT+0Zf/VJOgF5uMZrKjYPs38GMYyAU1coDyBNHauehXDaP+zl73VhwWv0vBRBHcg==}
     peerDependencies:
       vue: latest
     dependencies:
-      '@vue/compiler-ssr': 3.3.11
-      '@vue/shared': 3.3.11
-      vue: 3.3.11
+      '@vue/compiler-ssr': 3.3.13
+      '@vue/shared': 3.3.13
+      vue: 3.3.13
 
   /@vue/shared@3.3.11:
     resolution: {integrity: sha512-u2G8ZQ9IhMWTMXaWqZycnK4UthG1fA238CD+DP4Dm4WJi5hdUKKLg0RMRaRpDPNMdkTwIDkp7WtD0Rd9BH9fLw==}
+    dev: true
+
+  /@vue/shared@3.3.13:
+    resolution: {integrity: sha512-/zYUwiHD8j7gKx2argXEMCUXVST6q/21DFU0sTfNX0URJroCe3b1UF6vLJ3lQDfLNIiiRl2ONp7Nh5UVWS6QnA==}
 
   /@vue/shared@3.3.8:
     resolution: {integrity: sha512-8PGwybFwM4x8pcfgqEQFy70NaQxASvOC5DJwLQfpArw1UDfUXrJkdxD3BhVTMS+0Lef/TU7YO0Jvr0jJY8T+mw==}
     dev: true
 
-  /@vue/test-utils@2.0.2(vue@3.3.11):
+  /@vue/test-utils@2.0.2(vue@3.3.13):
     resolution: {integrity: sha512-E2P4oXSaWDqTZNbmKZFVLrNN/siVN78YkEqs7pHryWerrlZR9bBFLWdJwRoguX45Ru6HxIflzKl4vQvwRMwm5g==}
     peerDependencies:
       vue: latest
     dependencies:
-      vue: 3.3.11
+      vue: 3.3.13
     dev: true
 
-  /@vuelidate/core@2.0.3(vue@3.3.11):
+  /@vuelidate/core@2.0.3(vue@3.3.13):
     resolution: {integrity: sha512-AN6l7KF7+mEfyWG0doT96z+47ljwPpZfi9/JrNMkOGLFv27XVZvKzRLXlmDPQjPl/wOB1GNnHuc54jlCLRNqGA==}
     peerDependencies:
       '@vue/composition-api': ^1.0.0-rc.1
@@ -9905,11 +9944,11 @@ packages:
       '@vue/composition-api':
         optional: true
     dependencies:
-      vue: 3.3.11
-      vue-demi: 0.13.11(vue@3.3.11)
+      vue: 3.3.13
+      vue-demi: 0.13.11(vue@3.3.13)
     dev: false
 
-  /@vuelidate/validators@2.0.4(vue@3.3.11):
+  /@vuelidate/validators@2.0.4(vue@3.3.13):
     resolution: {integrity: sha512-odTxtUZ2JpwwiQ10t0QWYJkkYrfd0SyFYhdHH44QQ1jDatlZgTh/KRzrWVmn/ib9Gq7H4hFD4e8ahoo5YlUlDw==}
     peerDependencies:
       '@vue/composition-api': ^1.0.0-rc.1
@@ -9918,34 +9957,34 @@ packages:
       '@vue/composition-api':
         optional: true
     dependencies:
-      vue: 3.3.11
-      vue-demi: 0.13.11(vue@3.3.11)
+      vue: 3.3.13
+      vue-demi: 0.13.11(vue@3.3.13)
     dev: false
 
-  /@vueuse/core@10.2.1(vue@3.3.11):
+  /@vueuse/core@10.2.1(vue@3.3.13):
     resolution: {integrity: sha512-c441bfMbkAwTNwVRHQ0zdYZNETK//P84rC01aP2Uy/aRFCiie9NE/k9KdIXbno0eDYP5NPUuWv0aA/I4Unr/7w==}
     dependencies:
       '@types/web-bluetooth': 0.0.17
       '@vueuse/metadata': 10.2.1
-      '@vueuse/shared': 10.2.1(vue@3.3.11)
-      vue-demi: 0.14.5(vue@3.3.11)
+      '@vueuse/shared': 10.2.1(vue@3.3.13)
+      vue-demi: 0.14.5(vue@3.3.13)
     transitivePeerDependencies:
       - '@vue/composition-api'
       - vue
 
-  /@vueuse/core@10.6.1(vue@3.3.11):
+  /@vueuse/core@10.6.1(vue@3.3.13):
     resolution: {integrity: sha512-Pc26IJbqgC9VG1u6VY/xrXXfxD33hnvxBnKrLlA2LJlyHII+BSrRoTPJgGYq7qZOu61itITFUnm6QbacwZ4H8Q==}
     dependencies:
       '@types/web-bluetooth': 0.0.20
       '@vueuse/metadata': 10.6.1
-      '@vueuse/shared': 10.6.1(vue@3.3.11)
-      vue-demi: 0.14.6(vue@3.3.11)
+      '@vueuse/shared': 10.6.1(vue@3.3.13)
+      vue-demi: 0.14.6(vue@3.3.13)
     transitivePeerDependencies:
       - '@vue/composition-api'
       - vue
     dev: false
 
-  /@vueuse/core@7.7.1(vue@3.3.11):
+  /@vueuse/core@7.7.1(vue@3.3.13):
     resolution: {integrity: sha512-PRRgbATMpoeUmkCEBtUeJgOwtew8s+4UsEd+Pm7MhkjL2ihCNrSqxNVtM6NFE4uP2sWnkGcZpCjPuNSxowJ1Ow==}
     peerDependencies:
       '@vue/composition-api': ^1.1.0
@@ -9956,12 +9995,12 @@ packages:
       vue:
         optional: true
     dependencies:
-      '@vueuse/shared': 7.7.1(vue@3.3.11)
-      vue: 3.3.11
-      vue-demi: 0.14.6(vue@3.3.11)
+      '@vueuse/shared': 7.7.1(vue@3.3.13)
+      vue: 3.3.13
+      vue-demi: 0.14.6(vue@3.3.13)
     dev: false
 
-  /@vueuse/integrations@10.2.1(fuse.js@6.6.2)(jwt-decode@3.1.2)(qrcode@1.5.3)(sortablejs@1.15.1)(vue@3.3.11):
+  /@vueuse/integrations@10.2.1(fuse.js@6.6.2)(jwt-decode@3.1.2)(qrcode@1.5.3)(sortablejs@1.15.1)(vue@3.3.13):
     resolution: {integrity: sha512-FDP5lni+z9FjHE9H3xuvwSjoRV9U8jmDvJpmHPCBjUgPGYRynwb60eHWXCFJXLUtb4gSIHy0e+iaEbrKdalCkQ==}
     peerDependencies:
       async-validator: '*'
@@ -10002,13 +10041,13 @@ packages:
       universal-cookie:
         optional: true
     dependencies:
-      '@vueuse/core': 10.2.1(vue@3.3.11)
-      '@vueuse/shared': 10.2.1(vue@3.3.11)
+      '@vueuse/core': 10.2.1(vue@3.3.13)
+      '@vueuse/shared': 10.2.1(vue@3.3.13)
       fuse.js: 6.6.2
       jwt-decode: 3.1.2
       qrcode: 1.5.3
       sortablejs: 1.15.1
-      vue-demi: 0.14.5(vue@3.3.11)
+      vue-demi: 0.14.5(vue@3.3.13)
     transitivePeerDependencies:
       - '@vue/composition-api'
       - vue
@@ -10021,17 +10060,17 @@ packages:
     resolution: {integrity: sha512-qhdwPI65Bgcj23e5lpGfQsxcy0bMjCAsUGoXkJ7DsoeDUdasbZ2DBa4dinFCOER3lF4gwUv+UD2AlA11zdzMFw==}
     dev: false
 
-  /@vueuse/nuxt@10.2.1(nuxt@3.8.2)(vue@3.3.11):
+  /@vueuse/nuxt@10.2.1(nuxt@3.8.2)(vue@3.3.13):
     resolution: {integrity: sha512-01iDXnjZFDaGZnEL0nvlmSTNV0EG6WY+VSFyWnBji9lbxdQwOn4DHvLou3ePe8ipaoQVtY58WcL0OHIFa4+fBA==}
     peerDependencies:
       nuxt: ^3.0.0
     dependencies:
       '@nuxt/kit': 3.7.0
-      '@vueuse/core': 10.2.1(vue@3.3.11)
+      '@vueuse/core': 10.2.1(vue@3.3.13)
       '@vueuse/metadata': 10.2.1
       local-pkg: 0.4.3
       nuxt: 3.8.2(eslint@8.33.0)(sass@1.69.5)(vite@4.5.0)
-      vue-demi: 0.14.5(vue@3.3.11)
+      vue-demi: 0.14.5(vue@3.3.13)
     transitivePeerDependencies:
       - '@vue/composition-api'
       - rollup
@@ -10039,24 +10078,24 @@ packages:
       - vue
     dev: true
 
-  /@vueuse/shared@10.2.1(vue@3.3.11):
+  /@vueuse/shared@10.2.1(vue@3.3.13):
     resolution: {integrity: sha512-QWHq2bSuGptkcxx4f4M/fBYC3Y8d3M2UYyLsyzoPgEoVzJURQ0oJeWXu79OiLlBb8gTKkqe4mO85T/sf39mmiw==}
     dependencies:
-      vue-demi: 0.14.6(vue@3.3.11)
+      vue-demi: 0.14.6(vue@3.3.13)
     transitivePeerDependencies:
       - '@vue/composition-api'
       - vue
 
-  /@vueuse/shared@10.6.1(vue@3.3.11):
+  /@vueuse/shared@10.6.1(vue@3.3.13):
     resolution: {integrity: sha512-TECVDTIedFlL0NUfHWncf3zF9Gc4VfdxfQc8JFwoVZQmxpONhLxFrlm0eHQeidHj4rdTPL3KXJa0TZCk1wnc5Q==}
     dependencies:
-      vue-demi: 0.14.6(vue@3.3.11)
+      vue-demi: 0.14.6(vue@3.3.13)
     transitivePeerDependencies:
       - '@vue/composition-api'
       - vue
     dev: false
 
-  /@vueuse/shared@7.7.1(vue@3.3.11):
+  /@vueuse/shared@7.7.1(vue@3.3.13):
     resolution: {integrity: sha512-rN2qd22AUl7VdBxihagWyhUNHCyVk9IpvBTTfHoLH9G7rGE552X1f+zeCfehuno0zXif13jPw+icW/wn2a0rnQ==}
     peerDependencies:
       '@vue/composition-api': ^1.1.0
@@ -10067,8 +10106,8 @@ packages:
       vue:
         optional: true
     dependencies:
-      vue: 3.3.11
-      vue-demi: 0.14.6(vue@3.3.11)
+      vue: 3.3.13
+      vue-demi: 0.14.6(vue@3.3.13)
     dev: false
 
   /@webassemblyjs/ast@1.11.6:
@@ -10568,14 +10607,14 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /ant-design-vue@3.2.20(vue@3.3.11):
+  /ant-design-vue@3.2.20(vue@3.3.13):
     resolution: {integrity: sha512-YWpMfGaGoRastIXEYfCoJiaRiDHk4chqtYhlKQM5GqPt6NfvrM1Vg2e60yHtjxlZjed91wCMm0rAmyUr7Hwzdg==}
     engines: {node: '>=12.22.0'}
     peerDependencies:
       vue: latest
     dependencies:
       '@ant-design/colors': 6.0.0
-      '@ant-design/icons-vue': 6.1.0(vue@3.3.11)
+      '@ant-design/icons-vue': 6.1.0(vue@3.3.13)
       '@babel/runtime': 7.22.11
       '@ctrl/tinycolor': 3.6.1
       '@simonwep/pickr': 1.8.2
@@ -10589,8 +10628,8 @@ packages:
       resize-observer-polyfill: 1.5.1
       scroll-into-view-if-needed: 2.2.31
       shallow-equal: 1.2.1
-      vue: 3.3.11
-      vue-types: 3.0.2(vue@3.3.11)
+      vue: 3.3.13
+      vue-types: 3.0.2(vue@3.3.13)
       warning: 4.0.3
     dev: false
 
@@ -12734,8 +12773,8 @@ packages:
       rrweb-cssom: 0.6.0
     dev: false
 
-  /csstype@3.1.2:
-    resolution: {integrity: sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ==}
+  /csstype@3.1.3:
+    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
 
   /d3-array@3.2.4:
     resolution: {integrity: sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==}
@@ -13353,14 +13392,14 @@ packages:
     engines: {node: '>=10'}
     dev: false
 
-  /emoji-mart-vue-fast@15.0.0(vue@3.3.11):
+  /emoji-mart-vue-fast@15.0.0(vue@3.3.13):
     resolution: {integrity: sha512-3BzkDrs60JyT00dLHMAxWKbpFhbyaW9C+q1AjtqGovSxTu8TC2mYAGsvTmXNYKm39IRRAS56v92TihOcB98IsQ==}
     peerDependencies:
       vue: latest
     dependencies:
       '@babel/runtime': 7.22.11
       core-js: 3.32.1
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /emoji-regex@8.0.0:
@@ -13938,7 +13977,7 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/type-utils': 5.62.0(eslint@8.33.0)
+      '@typescript-eslint/type-utils': 5.62.0(eslint@8.33.0)(typescript@5.3.2)
       '@typescript-eslint/utils': 5.62.0(eslint@8.33.0)(typescript@5.3.2)
       deepmerge-ts: 5.1.0
       escape-string-regexp: 4.0.0
@@ -16832,7 +16871,7 @@ packages:
       eslint: '*'
       typescript: latest
     dependencies:
-      '@typescript-eslint/type-utils': 5.62.0(eslint@8.33.0)
+      '@typescript-eslint/type-utils': 5.62.0(eslint@8.33.0)(typescript@5.3.2)
       eslint: 8.33.0
     transitivePeerDependencies:
       - supports-color
@@ -20188,10 +20227,10 @@ packages:
       '@nuxt/schema': 3.8.2
       '@nuxt/telemetry': 2.5.2
       '@nuxt/ui-templates': 1.3.1
-      '@nuxt/vite-builder': 3.8.2(eslint@8.33.0)(sass@1.69.5)(vue@3.3.11)
+      '@nuxt/vite-builder': 3.8.2(eslint@8.33.0)(sass@1.69.5)(vue@3.3.13)
       '@unhead/dom': 1.8.5
       '@unhead/ssr': 1.8.5
-      '@unhead/vue': 1.8.5(vue@3.3.11)
+      '@unhead/vue': 1.8.5(vue@3.3.13)
       '@vue/shared': 3.3.8
       acorn: 8.11.2
       c12: 1.5.1
@@ -20231,12 +20270,12 @@ packages:
       unenv: 1.7.4
       unimport: 3.5.0(rollup@4.5.0)
       unplugin: 1.5.1
-      unplugin-vue-router: 0.7.0(vue-router@4.2.5)(vue@3.3.11)
+      unplugin-vue-router: 0.7.0(vue-router@4.2.5)(vue@3.3.13)
       untyped: 1.4.0
-      vue: 3.3.11
+      vue: 3.3.13
       vue-bundle-renderer: 2.0.0
       vue-devtools-stub: 0.1.0
-      vue-router: 4.2.5(vue@3.3.11)
+      vue-router: 4.2.5(vue@3.3.13)
     transitivePeerDependencies:
       - '@azure/app-configuration'
       - '@azure/cosmos'
@@ -21133,7 +21172,7 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /pinia@2.1.7(vue@3.3.11):
+  /pinia@2.1.7(vue@3.3.13):
     resolution: {integrity: sha512-+C2AHFtcFqjPih0zpYuvof37SFxMQ7OEG2zV9jRI12i9BOy3YQVAHwdKtyyc8pDcDyIc33WCIsZaCFWU7WWxGQ==}
     peerDependencies:
       '@vue/composition-api': ^1.4.0
@@ -21146,8 +21185,8 @@ packages:
         optional: true
     dependencies:
       '@vue/devtools-api': 6.5.0
-      vue: 3.3.11
-      vue-demi: 0.14.6(vue@3.3.11)
+      vue: 3.3.13
+      vue-demi: 0.14.6(vue@3.3.13)
     dev: false
 
   /pinkie-promise@1.0.0:
@@ -24221,6 +24260,39 @@ packages:
       yargs-parser: 21.1.1
     dev: true
 
+  /ts-jest@29.1.1(jest@29.5.0)(typescript@5.3.2):
+    resolution: {integrity: sha512-D6xjnnbP17cC85nliwGiL+tpoKN0StpgE0TeOjXQTU6MVCfsB4v7aW05CgQ/1OywGb0x/oy9hHFnN+sczTiRaA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+    hasBin: true
+    peerDependencies:
+      '@babel/core': '>=7.0.0-beta.0 <8'
+      '@jest/types': ^29.0.0
+      babel-jest: ^29.0.0
+      esbuild: '*'
+      jest: ^29.0.0
+      typescript: latest
+    peerDependenciesMeta:
+      '@babel/core':
+        optional: true
+      '@jest/types':
+        optional: true
+      babel-jest:
+        optional: true
+      esbuild:
+        optional: true
+    dependencies:
+      bs-logger: 0.2.6
+      fast-json-stable-stringify: 2.1.0
+      jest: 29.5.0(@types/node@20.3.3)(ts-node@10.9.2)
+      jest-util: 29.6.3
+      json5: 2.2.3
+      lodash.memoize: 4.1.2
+      make-error: 1.3.6
+      semver: 7.5.4
+      typescript: 5.3.2
+      yargs-parser: 21.1.1
+    dev: true
+
   /ts-loader@9.4.4(typescript@5.3.2)(webpack@5.89.0):
     resolution: {integrity: sha512-MLukxDHBl8OJ5Dk3y69IsKVFRA/6MwzEqBgh+OXMPB/OD01KQuWPFd1WAQP8a5PeSCAxfnkhiuWqfmFJzJQt9w==}
     engines: {node: '>=12.0.0'}
@@ -24820,7 +24892,7 @@ packages:
       - supports-color
     dev: true
 
-  /unplugin-vue-components@0.22.12(vue@3.3.11):
+  /unplugin-vue-components@0.22.12(vue@3.3.13):
     resolution: {integrity: sha512-FxyzsuBvMCYPIk+8cgscGBQ345tvwVu+qY5IhE++eorkyvA4Z1TiD/HCiim+Kbqozl10i4K+z+NCa2WO2jexRA==}
     engines: {node: '>=14'}
     peerDependencies:
@@ -24840,13 +24912,13 @@ packages:
       minimatch: 5.1.6
       resolve: 1.22.4
       unplugin: 1.4.0
-      vue: 3.3.11
+      vue: 3.3.13
     transitivePeerDependencies:
       - rollup
       - supports-color
     dev: true
 
-  /unplugin-vue-router@0.7.0(vue-router@4.2.5)(vue@3.3.11):
+  /unplugin-vue-router@0.7.0(vue-router@4.2.5)(vue@3.3.13):
     resolution: {integrity: sha512-ddRreGq0t5vlSB7OMy4e4cfU1w2AwBQCwmvW3oP/0IHQiokzbx4hd3TpwBu3eIAFVuhX2cwNQwp1U32UybTVCw==}
     peerDependencies:
       vue-router: ^4.1.0
@@ -24856,7 +24928,7 @@ packages:
     dependencies:
       '@babel/types': 7.23.4
       '@rollup/pluginutils': 5.0.5(rollup@4.5.0)
-      '@vue-macros/common': 1.8.0(vue@3.3.11)
+      '@vue-macros/common': 1.8.0(vue@3.3.13)
       ast-walker-scope: 0.5.0
       chokidar: 3.5.3
       fast-glob: 3.3.1
@@ -24866,7 +24938,7 @@ packages:
       pathe: 1.1.1
       scule: 1.1.0
       unplugin: 1.5.1
-      vue-router: 4.2.5(vue@3.3.11)
+      vue-router: 4.2.5(vue@3.3.13)
       yaml: 2.3.4
     transitivePeerDependencies:
       - rollup
@@ -25332,7 +25404,7 @@ packages:
       '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.23.3)
       '@babel/plugin-transform-typescript': 7.22.15(@babel/core@7.23.3)
       '@vue/babel-plugin-jsx': 1.1.5(@babel/core@7.23.3)
-      '@vue/compiler-dom': 3.3.11
+      '@vue/compiler-dom': 3.3.13
       kolorist: 1.8.0
       magic-string: 0.30.5
       vite: 4.5.0(@types/node@20.3.1)(sass@1.69.5)
@@ -25567,17 +25639,17 @@ packages:
       ufo: 1.3.2
     dev: true
 
-  /vue-chartjs@5.2.0(chart.js@4.4.1)(vue@3.3.11):
+  /vue-chartjs@5.2.0(chart.js@4.4.1)(vue@3.3.13):
     resolution: {integrity: sha512-d3zpKmGZr2OWHQ1xmxBcAn5ShTG917+/UCLaSpaCDDqT0U7DBsvFzTs69ZnHCgKoXT55GZDW8YEj9Av+dlONLA==}
     peerDependencies:
       chart.js: ^4.1.1
       vue: latest
     dependencies:
       chart.js: 4.4.1
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
-  /vue-demi@0.13.11(vue@3.3.11):
+  /vue-demi@0.13.11(vue@3.3.13):
     resolution: {integrity: sha512-IR8HoEEGM65YY3ZJYAjMlKygDQn25D5ajNFNoKh9RSDMQtlzCxtfQjdQgv9jjK+m3377SsJXY8ysq8kLCZL25A==}
     engines: {node: '>=12'}
     hasBin: true
@@ -25589,10 +25661,10 @@ packages:
       '@vue/composition-api':
         optional: true
     dependencies:
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
-  /vue-demi@0.14.5(vue@3.3.11):
+  /vue-demi@0.14.5(vue@3.3.13):
     resolution: {integrity: sha512-o9NUVpl/YlsGJ7t+xuqJKx8EBGf1quRhCiT6D/J0pfwmk9zUwYkC7yrF4SZCe6fETvSM3UNL2edcbYrSyc4QHA==}
     engines: {node: '>=12'}
     hasBin: true
@@ -25604,9 +25676,9 @@ packages:
       '@vue/composition-api':
         optional: true
     dependencies:
-      vue: 3.3.11
+      vue: 3.3.13
 
-  /vue-demi@0.14.6(vue@3.3.11):
+  /vue-demi@0.14.6(vue@3.3.13):
     resolution: {integrity: sha512-8QA7wrYSHKaYgUxDA5ZC24w+eHm3sYCbp0EzcDwKqN3p6HqtTCGR/GVsPyZW92unff4UlcSh++lmqDWN3ZIq4w==}
     engines: {node: '>=12'}
     hasBin: true
@@ -25618,19 +25690,19 @@ packages:
       '@vue/composition-api':
         optional: true
     dependencies:
-      vue: 3.3.11
+      vue: 3.3.13
 
   /vue-devtools-stub@0.1.0:
     resolution: {integrity: sha512-RutnB7X8c5hjq39NceArgXg28WZtZpGc3+J16ljMiYnFhKvd8hITxSWQSQ5bvldxMDU6gG5mkxl1MTQLXckVSQ==}
     dev: true
 
-  /vue-dompurify-html@3.0.0(vue@3.3.11):
+  /vue-dompurify-html@3.0.0(vue@3.3.13):
     resolution: {integrity: sha512-S6PMeJU7S3w0TnxMWWd4iydc7oPdOER1GmW9rsgiRwHvcw+nUi2v6BgERcFBULlM+x6PXsfu5P/Rm4reVvWH5A==}
     peerDependencies:
       vue: latest
     dependencies:
       dompurify: 2.4.7
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /vue-eslint-parser@9.3.1(eslint@8.33.0):
@@ -25657,7 +25729,7 @@ packages:
       github-buttons: 2.27.0
     dev: false
 
-  /vue-i18n@9.2.2(vue@3.3.11):
+  /vue-i18n@9.2.2(vue@3.3.13):
     resolution: {integrity: sha512-yswpwtj89rTBhegUAv9Mu37LNznyu3NpyLQmozF3i1hYOhwpG8RjcjIFIIfnu+2MDZJGSZPXaKWvnQA71Yv9TQ==}
     engines: {node: '>= 14'}
     peerDependencies:
@@ -25667,7 +25739,7 @@ packages:
       '@intlify/shared': 9.2.2
       '@intlify/vue-devtools': 9.2.2
       '@vue/devtools-api': 6.5.0
-      vue: 3.3.11
+      vue: 3.3.13
 
   /vue-qrcode-reader@3.1.8:
     resolution: {integrity: sha512-WUsq3YamW8FFprcZPoyvEgXCDhvopvI0v2sGuRKbID16gdg3CIq1xJeYw5AsM8HnzVS5uEiqrEv+TDzsZt/JCg==}
@@ -25675,32 +25747,32 @@ packages:
       barcode-detector: 1.0.4
       callforth: 0.3.1
       core-js: 3.32.1
-      vue: 3.3.11
+      vue: 3.3.13
       webrtc-adapter: 7.7.0
     transitivePeerDependencies:
       - typescript
     dev: false
 
-  /vue-router@4.2.5(vue@3.3.11):
+  /vue-router@4.2.5(vue@3.3.13):
     resolution: {integrity: sha512-DIUpKcyg4+PTQKfFPX88UWhlagBEBEfJ5A8XDXRJLUnZOvcpMF8o/dnL90vpVkGaPbjvXazV/rC1qBKrZlFugw==}
     peerDependencies:
       vue: latest
     dependencies:
       '@vue/devtools-api': 6.5.0
-      vue: 3.3.11
+      vue: 3.3.13
     dev: true
 
-  /vue-types@3.0.2(vue@3.3.11):
+  /vue-types@3.0.2(vue@3.3.13):
     resolution: {integrity: sha512-IwUC0Aq2zwaXqy74h4WCvFCUtoV0iSWr0snWnE9TnU18S66GAQyqQbRf2qfJtUuiFsBf6qp0MEwdonlwznlcrw==}
     engines: {node: '>=10.15.0'}
     peerDependencies:
       vue: latest
     dependencies:
       is-plain-object: 3.0.1
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
-  /vue3-calendar-heatmap@2.0.5(tippy.js@6.3.7)(vue@3.3.11):
+  /vue3-calendar-heatmap@2.0.5(tippy.js@6.3.7)(vue@3.3.13):
     resolution: {integrity: sha512-qvveNQlTS5Aw7AvRLs0zOyu3uP5iGJlXJAnkrkG2ElDdyQ8H1TJhQ8rL702CROjAg16ezIveUY10nCO7lqZ25w==}
     engines: {node: '>=16'}
     peerDependencies:
@@ -25708,7 +25780,7 @@ packages:
       vue: latest
     dependencies:
       tippy.js: 6.3.7
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /vue3-contextmenu@0.2.12:
@@ -25716,7 +25788,7 @@ packages:
     dependencies:
       core-js: 3.32.1
       mitt: 2.1.0
-      vue: 3.3.11
+      vue: 3.3.13
     transitivePeerDependencies:
       - typescript
     dev: false
@@ -25737,37 +25809,37 @@ packages:
       mitt: 3.0.1
     dev: false
 
-  /vue3-text-clamp@0.1.2(resize-detector@0.3.0)(vue@3.3.11):
+  /vue3-text-clamp@0.1.2(resize-detector@0.3.0)(vue@3.3.13):
     resolution: {integrity: sha512-896tGhkwaDObKL4gUv9KhR6GQQYzIzut77P2jmfUoTaJ5lJP6kLMfCUEKwGQWbDgXXkqDcoE/QV/UtP4Jn7r3Q==}
     peerDependencies:
       resize-detector: ^0.3.0
       vue: latest
     dependencies:
       resize-detector: 0.3.0
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
-  /vue@3.3.11:
-    resolution: {integrity: sha512-d4oBctG92CRO1cQfVBZp6WJAs0n8AK4Xf5fNjQCBeKCvMI1efGQ5E3Alt1slFJS9fZuPcFoiAiqFvQlv1X7t/w==}
+  /vue@3.3.13:
+    resolution: {integrity: sha512-LDnUpQvDgsfc0u/YgtAgTMXJlJQqjkxW1PVcOnJA5cshPleULDjHi7U45pl2VJYazSSvLH8UKcid/kzH8I0a0Q==}
     peerDependencies:
       typescript: latest
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@vue/compiler-dom': 3.3.11
-      '@vue/compiler-sfc': 3.3.11
-      '@vue/runtime-dom': 3.3.11
-      '@vue/server-renderer': 3.3.11(vue@3.3.11)
-      '@vue/shared': 3.3.11
+      '@vue/compiler-dom': 3.3.13
+      '@vue/compiler-sfc': 3.3.13
+      '@vue/runtime-dom': 3.3.13
+      '@vue/server-renderer': 3.3.13(vue@3.3.13)
+      '@vue/shared': 3.3.13
 
-  /vuedraggable@4.1.0(vue@3.3.11):
+  /vuedraggable@4.1.0(vue@3.3.13):
     resolution: {integrity: sha512-FU5HCWBmsf20GpP3eudURW3WdWTKIbEIQxh9/8GE806hydR9qZqRRxRE3RjqX7PkuLuMQG/A7n3cfj9rCEchww==}
     peerDependencies:
       vue: latest
     dependencies:
       sortablejs: 1.14.0
-      vue: 3.3.11
+      vue: 3.3.13
     dev: false
 
   /w3c-keyname@2.2.8:
diff --git a/tests/playwright/tests/db/columns/columnFormula.spec.ts b/tests/playwright/tests/db/columns/columnFormula.spec.ts
index 6e3105b39a..b8b0ee4dd6 100644
--- a/tests/playwright/tests/db/columns/columnFormula.spec.ts
+++ b/tests/playwright/tests/db/columns/columnFormula.spec.ts
@@ -127,11 +127,11 @@ const formulaDataByDbType = (context: NcContext, index: number) => {
 
       {
         formula: 'ROUNDDOWN({CityId} + 2.49, 1)',
-        result: ['3', '4', '5', '6', '7'],
+        result: ['3.4', '4.4', '5.4', '6.4', '7.4'],
       },
       {
         formula: 'ROUNDUP({CityId} + 2.49, 1)',
-        result: ['4', '5', '6', '7', '8'],
+        result: ['3.5', '4.5', '5.5', '6.5', '7.5'],
       },
       {
         formula: 'RECORD_ID()',