@dataloop-ai/components 0.16.64 → 0.17.1

package/src/utils/parse-smart-query.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-empty */
 
-import { isFinite } from 'lodash'
+import { isFinite, isObject, isString } from 'lodash'
 
 export const parseSmartQuery = (query: string) => {
     const queryArr = query.split(' OR ')
@@ -85,3 +85,111 @@ export const parseSmartQuery = (query: string) => {
 
     return builtQuery
 }
+
+export const stringifySmartQuery = (query: { [key: string]: any }) => {
+    let result = ''
+
+    for (const key in query) {
+        if (query.hasOwnProperty(key)) {
+            const value = query[key]
+
+            if (key === '$or') {
+                if (Array.isArray(value)) {
+                    const subQueries = value.map(
+                        (subQuery: { [key: string]: any }) =>
+                            stringifySmartQuery(subQuery)
+                    )
+                    result += subQueries.join(' OR ')
+                }
+                continue
+            }
+
+            if (result.length) {
+                result += ' AND '
+            }
+
+            if (isObject(value)) {
+                for (const operator in value) {
+                    if (value.hasOwnProperty(operator)) {
+                        let operatorValue = (
+                            value as {
+                                [key: string]:
+                                    | string
+                                    | number
+                                    | string[]
+                                    | number[]
+                            }
+                        )[operator]
+                        switch (operator) {
+                            case '$eq':
+                                result += `${key} = ${
+                                    isString(operatorValue)
+                                        ? `'${operatorValue}'`
+                                        : operatorValue
+                                }`
+                                break
+                            case '$ne':
+                                result += `${key} != ${
+                                    isString(operatorValue)
+                                        ? `'${operatorValue}'`
+                                        : operatorValue
+                                }`
+                                break
+                            case '$gt':
+                                result += `${key} > ${operatorValue}`
+                                break
+                            case '$gte':
+                                result += `${key} >= ${operatorValue}`
+                                break
+                            case '$lt':
+                                result += `${key} < ${operatorValue}`
+                                break
+                            case '$lte':
+                                result += `${key} <= ${operatorValue}`
+                                break
+                            case '$in':
+                                if (!Array.isArray(operatorValue)) {
+                                    operatorValue = [operatorValue] as
+                                        | string[]
+                                        | number[]
+                                }
+
+                                const inValues: string = (
+                                    operatorValue as any[]
+                                )
+                                    .map((x: string | number) =>
+                                        isString(x) ? `'${x}'` : x
+                                    )
+                                    .join(', ')
+                                result += `${key} IN ${inValues} `
+                                break
+                            case '$nin':
+                                if (!Array.isArray(operatorValue)) {
+                                    operatorValue = [operatorValue] as
+                                        | string[]
+                                        | number[]
+                                }
+
+                                const ninValues: string = (
+                                    operatorValue as any[]
+                                )
+                                    .map((x: string | number) =>
+                                        isString(x) ? `'${x}'` : x
+                                    )
+                                    .join(', ')
+
+                                result += `${key} NOT-IN ${ninValues}`
+                                break
+                            default:
+                                throw new Error(`Invalid operator: ${operator}`)
+                        }
+                    }
+                }
+            } else {
+                result += `${key} = '${value}'`
+            }
+        }
+    }
+
+    return result
+}