@budibase/shared-core 2.3.21-alpha.2 → 2.4.8-alpha.0

package/package.json

@@ -1,19 +1,23 @@
 {
   "name": "@budibase/shared-core",
-  "version": "2.3.21-alpha.2",
+  "version": "2.4.8-alpha.0",
   "description": "Shared data utils",
   "main": "dist/src/index.js",
+  "module": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "author": "Budibase",
   "license": "GPL-3.0",
   "scripts": {
-    "build": "tsc",
-    "dev:builder": "tsc --watch"
+    "prebuild": "rimraf dist/",
+    "build": "tsc -p tsconfig.build.json",
+    "build:dev": "yarn prebuild && tsc --build --watch --preserveWatchOutput",
+    "dev:builder": "tsc -p tsconfig.build.json --watch"
   },
   "dependencies": {
-    "@budibase/types": "2.3.21-alpha.2"
+    "@budibase/types": "2.4.5-alpha.0"
   },
   "devDependencies": {
-    "typescript": "4.7.3"
+    "typescript": "4.7.3",
+    "rimraf": "3.0.2"
   }
 }

package/src/filters.ts

@@ -1,5 +1,6 @@
-import { SortDirection } from "@budibase/types"
+import { Datasource, FieldType, SortDirection, SortType } from "@budibase/types"
 import { OperatorOptions, SqlNumberTypeRangeMap } from "./constants"
+import { deepGet } from "./helpers"
 
 const HBS_REGEX = /{{([^{].*?)}}/g
 
@@ -8,9 +9,9 @@ const HBS_REGEX = /{{([^{].*?)}}/g
  * @param type the data type
  */
 export const getValidOperatorsForType = (
-  type: string,
+  type: FieldType,
   field: string,
-  datasource: { tableId: string | string[]; type: string }
+  datasource: Datasource & { tableId: any } // TODO: is this table id ever populated?
 ) => {
   const Op = OperatorOptions
   const stringOps = [
@@ -31,7 +32,10 @@ export const getValidOperatorsForType = (
     Op.NotEmpty,
     Op.In,
   ]
-  let ops: any[] = []
+  let ops: {
+    value: string
+    label: string
+  }[] = []
   if (type === "string") {
     ops = stringOps
   } else if (type === "number") {
@@ -74,13 +78,13 @@ export const NoEmptyFilterStrings = [
   OperatorOptions.NotEquals.value,
   OperatorOptions.Contains.value,
   OperatorOptions.NotContains.value,
-]
+] as (keyof QueryFields)[]
 
 /**
  * Removes any fields that contain empty strings that would cause inconsistent
  * behaviour with how backend tables are filtered (no value means no filter).
  */
-const cleanupQuery = (query: { [x: string]: { [x: string]: any } }) => {
+const cleanupQuery = (query: Query) => {
   if (!query) {
     return query
   }
@@ -88,9 +92,10 @@ const cleanupQuery = (query: { [x: string]: { [x: string]: any } }) => {
     if (!query[filterField]) {
       continue
     }
-    for (let [key, value] of Object.entries(query[filterField])) {
+
+    for (let [key, value] of Object.entries(query[filterField]!)) {
       if (value == null || value === "") {
-        delete query[filterField][key]
+        delete query[filterField]![key]
       }
     }
   }
@@ -118,21 +123,52 @@ type Filter = {
   externalType: keyof typeof SqlNumberTypeRangeMap
 }
 
-type Query = {
-  string: Record<string, any>
-  fuzzy: Record<string, any>
-  range: Record<string, { low: string | number; high: string | number }>
-  equal: Record<string, true>
-  notEqual: Record<string, true>
-  empty: Record<string, any>
-  notEmpty: Record<string, any>
-  contains: Record<string, any>
-  notContains: Record<string, any>
-  oneOf: Record<string, any>
-  containsAny: Record<string, any>
+type Query = QueryFields & QueryConfig
+type QueryFields = {
+  string?: {
+    [key: string]: string
+  }
+  fuzzy?: {
+    [key: string]: string
+  }
+  range?: {
+    [key: string]: {
+      high: number | string
+      low: number | string
+    }
+  }
+  equal?: {
+    [key: string]: any
+  }
+  notEqual?: {
+    [key: string]: any
+  }
+  empty?: {
+    [key: string]: any
+  }
+  notEmpty?: {
+    [key: string]: any
+  }
+  oneOf?: {
+    [key: string]: any[]
+  }
+  contains?: {
+    [key: string]: any[]
+  }
+  notContains?: {
+    [key: string]: any[]
+  }
+  containsAny?: {
+    [key: string]: any[]
+  }
+}
+
+type QueryConfig = {
   allOr?: boolean
 }
 
+type QueryFieldsType = keyof QueryFields
+
 /**
  * Builds a lucene JSON query from the filter structure generated in the builder
  * @param filter the builder filter structure
@@ -194,7 +230,7 @@ export const buildLuceneQuery = (filter: Filter[]) => {
       ) {
         value = value.split(",")
       }
-      if (operator.startsWith("range")) {
+      if (operator.startsWith("range") && query.range) {
         const minint =
           SqlNumberTypeRangeMap[externalType]?.min || Number.MIN_SAFE_INTEGER
         const maxint =
@@ -220,14 +256,18 @@ export const buildLuceneQuery = (filter: Filter[]) => {
           // "equals false" needs to be "not equals true"
           // "not equals false" needs to be "equals true"
           if (operator === "equal" && value === false) {
+            query.notEqual = query.notEqual || {}
             query.notEqual[field] = true
           } else if (operator === "notEqual" && value === false) {
+            query.equal = query.equal || {}
             query.equal[field] = true
           } else {
-            query[operator][field] = value
+            query[operator] = query[operator] || {}
+            query[operator]![field] = value
           }
         } else {
-          query[operator][field] = value
+          query[operator] = query[operator] || {}
+          query[operator]![field] = value
         }
       }
     })
@@ -235,29 +275,12 @@ export const buildLuceneQuery = (filter: Filter[]) => {
   return query
 }
 
-const deepGet = (obj: { [x: string]: any }, key: string) => {
-  if (!obj || !key) {
-    return null
-  }
-  if (Object.prototype.hasOwnProperty.call(obj, key)) {
-    return obj[key]
-  }
-  const split = key.split(".")
-  for (let i = 0; i < split.length; i++) {
-    obj = obj?.[split[i]]
-  }
-  return obj
-}
-
 /**
  * Performs a client-side lucene search on an array of data
  * @param docs the data
  * @param query the JSON lucene query
  */
-export const runLuceneQuery = (
-  docs: any[],
-  query?: { [x: string]: any; sheet?: string }
-) => {
+export const runLuceneQuery = (docs: any[], query?: Query) => {
   if (!docs || !Array.isArray(docs)) {
     return []
   }
@@ -270,7 +293,10 @@ export const runLuceneQuery = (
 
   // Iterates over a set of filters and evaluates a fail function against a doc
   const match =
-    (type: string, failFn: (docValue: any, testValue: any) => boolean) =>
+    (
+      type: QueryFieldsType,
+      failFn: (docValue: any, testValue: any) => boolean
+    ) =>
     (doc: any) => {
       const filters = Object.entries(query![type] || {})
       for (let i = 0; i < filters.length; i++) {
@@ -399,9 +425,9 @@ export const runLuceneQuery = (
  */
 export const luceneSort = (
   docs: any[],
-  sort: string | number,
+  sort: string,
   sortOrder: SortDirection,
-  sortType = "string"
+  sortType = SortType.STRING
 ) => {
   if (!sort || !sortOrder || !sortType) {
     return docs
@@ -427,7 +453,7 @@ export const luceneSort = (
  * @param docs the data
  * @param limit the number of docs to limit to
  */
-export const luceneLimit = (docs: string | any[], limit: string) => {
+export const luceneLimit = (docs: any[], limit: string) => {
   const numLimit = parseFloat(limit)
   if (isNaN(numLimit)) {
     return docs

package/src/helpers.ts

@@ -0,0 +1,23 @@
+/**
+ * Gets a key within an object. The key supports dot syntax for retrieving deep
+ * fields - e.g. "a.b.c".
+ * Exact matches of keys with dots in them take precedence over nested keys of
+ * the same path - e.g. getting "a.b" from { "a.b": "foo", a: { b: "bar" } }
+ * will return "foo" over "bar".
+ * @param obj the object
+ * @param key the key
+ * @return {*|null} the value or null if a value was not found for this key
+ */
+export const deepGet = (obj: { [x: string]: any }, key: string) => {
+  if (!obj || !key) {
+    return null
+  }
+  if (Object.prototype.hasOwnProperty.call(obj, key)) {
+    return obj[key]
+  }
+  const split = key.split(".")
+  for (let i = 0; i < split.length; i++) {
+    obj = obj?.[split[i]]
+  }
+  return obj
+}

package/src/index.ts

@@ -1,2 +1,4 @@
 export * from "./constants"
 export * as dataFilters from "./filters"
+export * as helpers from "./helpers"
+export * as utils from "./utils"

package/src/utils.ts

@@ -0,0 +1,6 @@
+export function unreachable(
+  value: never,
+  message = `No such case in exhaustive switch: ${value}`
+) {
+  throw new Error(message)
+}

package/tsconfig.build.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "es6",
-    "module": "commonjs",
+    "moduleResolution": "node",
     "lib": ["es2020"],
     "strict": true,
     "noImplicitAny": true,

package/tsconfig.json

@@ -1,6 +1,11 @@
 {
   "extends": "./tsconfig.build.json",
   "compilerOptions": {
-    "composite": true
-  }
+    "composite": true,
+    "baseUrl": ".",
+    "paths": {
+      "@budibase/types": ["../types/src"]
+    }
+  },
+  "references": [{ "path": "../types" }]
 }