@budibase/shared-core 2.9.19-alpha.0 → 2.9.20

package/src/filters.ts

@@ -1,431 +0,0 @@
-import {
-  Datasource,
-  FieldType,
-  SearchFilter,
-  SearchQuery,
-  SearchQueryFields,
-  SortDirection,
-  SortType,
-} from "@budibase/types"
-import { OperatorOptions, SqlNumberTypeRangeMap } from "./constants"
-import { deepGet } from "./helpers"
-
-const HBS_REGEX = /{{([^{].*?)}}/g
-
-/**
- * Returns the valid operator options for a certain data type
- * @param type the data type
- */
-export const getValidOperatorsForType = (
-  type: FieldType,
-  field: string,
-  datasource: Datasource & { tableId: any } // TODO: is this table id ever populated?
-) => {
-  const Op = OperatorOptions
-  const stringOps = [
-    Op.Equals,
-    Op.NotEquals,
-    Op.StartsWith,
-    Op.Like,
-    Op.Empty,
-    Op.NotEmpty,
-    Op.In,
-  ]
-  const numOps = [
-    Op.Equals,
-    Op.NotEquals,
-    Op.MoreThan,
-    Op.LessThan,
-    Op.Empty,
-    Op.NotEmpty,
-    Op.In,
-  ]
-  let ops: {
-    value: string
-    label: string
-  }[] = []
-  if (type === "string") {
-    ops = stringOps
-  } else if (type === "number" || type === "bigint") {
-    ops = numOps
-  } else if (type === "options") {
-    ops = [Op.Equals, Op.NotEquals, Op.Empty, Op.NotEmpty, Op.In]
-  } else if (type === "array") {
-    ops = [Op.Contains, Op.NotContains, Op.Empty, Op.NotEmpty, Op.ContainsAny]
-  } else if (type === "boolean") {
-    ops = [Op.Equals, Op.NotEquals, Op.Empty, Op.NotEmpty]
-  } else if (type === "longform") {
-    ops = stringOps
-  } else if (type === "datetime") {
-    ops = numOps
-  } else if (type === "formula") {
-    ops = stringOps.concat([Op.MoreThan, Op.LessThan])
-  }
-
-  // Only allow equal/not equal for _id in SQL tables
-  const externalTable = datasource?.tableId?.includes("datasource_plus")
-  if (field === "_id" && externalTable) {
-    ops = [Op.Equals, Op.NotEquals, Op.In]
-  }
-
-  return ops
-}
-
-/**
- * Operators which do not support empty strings as values
- */
-export const NoEmptyFilterStrings = [
-  OperatorOptions.StartsWith.value,
-  OperatorOptions.Like.value,
-  OperatorOptions.Equals.value,
-  OperatorOptions.NotEquals.value,
-  OperatorOptions.Contains.value,
-  OperatorOptions.NotContains.value,
-] as (keyof SearchQueryFields)[]
-
-/**
- * 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: SearchQuery) => {
-  if (!query) {
-    return query
-  }
-  for (let filterField of NoEmptyFilterStrings) {
-    if (!query[filterField]) {
-      continue
-    }
-
-    for (let [key, value] of Object.entries(query[filterField]!)) {
-      if (value == null || value === "") {
-        delete query[filterField]![key]
-      }
-    }
-  }
-  return query
-}
-
-/**
- * Removes a numeric prefix on field names designed to give fields uniqueness
- */
-const removeKeyNumbering = (key: string) => {
-  if (typeof key === "string" && key.match(/\d[0-9]*:/g) != null) {
-    const parts = key.split(":")
-    parts.shift()
-    return parts.join(":")
-  } else {
-    return key
-  }
-}
-
-/**
- * Builds a lucene JSON query from the filter structure generated in the builder
- * @param filter the builder filter structure
- */
-export const buildLuceneQuery = (filter: SearchFilter[]) => {
-  let query: SearchQuery = {
-    string: {},
-    fuzzy: {},
-    range: {},
-    equal: {},
-    notEqual: {},
-    empty: {},
-    notEmpty: {},
-    contains: {},
-    notContains: {},
-    oneOf: {},
-    containsAny: {},
-  }
-  if (Array.isArray(filter)) {
-    filter.forEach(expression => {
-      let { operator, field, type, value, externalType } = expression
-      const isHbs =
-        typeof value === "string" && (value.match(HBS_REGEX) || []).length > 0
-      // Parse all values into correct types
-      if (operator === "allOr") {
-        query.allOr = true
-        return
-      }
-      if (
-        type === "datetime" &&
-        !isHbs &&
-        operator !== "empty" &&
-        operator !== "notEmpty"
-      ) {
-        // Ensure date value is a valid date and parse into correct format
-        if (!value) {
-          return
-        }
-        try {
-          value = new Date(value).toISOString()
-        } catch (error) {
-          return
-        }
-      }
-      if (type === "number" && typeof value === "string") {
-        if (operator === "oneOf") {
-          value = value.split(",").map(item => parseFloat(item))
-        } else if (!isHbs) {
-          value = parseFloat(value)
-        }
-      }
-      if (type === "boolean") {
-        value = `${value}`?.toLowerCase() === "true"
-      }
-      if (
-        ["contains", "notContains", "containsAny"].includes(operator) &&
-        type === "array" &&
-        typeof value === "string"
-      ) {
-        value = value.split(",")
-      }
-      if (operator.startsWith("range") && query.range) {
-        const minint =
-          SqlNumberTypeRangeMap[
-            externalType as keyof typeof SqlNumberTypeRangeMap
-          ]?.min || Number.MIN_SAFE_INTEGER
-        const maxint =
-          SqlNumberTypeRangeMap[
-            externalType as keyof typeof SqlNumberTypeRangeMap
-          ]?.max || Number.MAX_SAFE_INTEGER
-        if (!query.range[field]) {
-          query.range[field] = {
-            low: type === "number" ? minint : "0000-00-00T00:00:00.000Z",
-            high: type === "number" ? maxint : "9999-00-00T00:00:00.000Z",
-          }
-        }
-        if ((operator as any) === "rangeLow" && value != null && value !== "") {
-          query.range[field].low = value
-        } else if (
-          (operator as any) === "rangeHigh" &&
-          value != null &&
-          value !== ""
-        ) {
-          query.range[field].high = value
-        }
-      } else if (query[operator]) {
-        if (type === "boolean") {
-          // Transform boolean filters to cope with null.
-          // "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] = query[operator] || {}
-            query[operator]![field] = value
-          }
-        } else {
-          query[operator] = query[operator] || {}
-          query[operator]![field] = value
-        }
-      }
-    })
-  }
-  return query
-}
-
-/**
- * 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?: SearchQuery) => {
-  if (!docs || !Array.isArray(docs)) {
-    return []
-  }
-  if (!query) {
-    return docs
-  }
-
-  // Make query consistent first
-  query = cleanupQuery(query)
-
-  // Iterates over a set of filters and evaluates a fail function against a doc
-  const match =
-    (
-      type: keyof SearchQueryFields,
-      failFn: (docValue: any, testValue: any) => boolean
-    ) =>
-    (doc: any) => {
-      const filters = Object.entries(query![type] || {})
-      for (let i = 0; i < filters.length; i++) {
-        const [key, testValue] = filters[i]
-        const docValue = deepGet(doc, removeKeyNumbering(key))
-        if (failFn(docValue, testValue)) {
-          return false
-        }
-      }
-      return true
-    }
-
-  // Process a string match (fails if the value does not start with the string)
-  const stringMatch = match("string", (docValue: string, testValue: string) => {
-    return (
-      !docValue || !docValue?.toLowerCase().startsWith(testValue?.toLowerCase())
-    )
-  })
-
-  // Process a fuzzy match (treat the same as starts with when running locally)
-  const fuzzyMatch = match("fuzzy", (docValue: string, testValue: string) => {
-    return (
-      !docValue || !docValue?.toLowerCase().startsWith(testValue?.toLowerCase())
-    )
-  })
-
-  // Process a range match
-  const rangeMatch = match(
-    "range",
-    (
-      docValue: string | number | null,
-      testValue: { low: number; high: number }
-    ) => {
-      return (
-        docValue == null ||
-        docValue === "" ||
-        +docValue < testValue.low ||
-        +docValue > testValue.high
-      )
-    }
-  )
-
-  // Process an equal match (fails if the value is different)
-  const equalMatch = match(
-    "equal",
-    (docValue: any, testValue: string | null) => {
-      return testValue != null && testValue !== "" && docValue !== testValue
-    }
-  )
-
-  // Process a not-equal match (fails if the value is the same)
-  const notEqualMatch = match(
-    "notEqual",
-    (docValue: any, testValue: string | null) => {
-      return testValue != null && testValue !== "" && docValue === testValue
-    }
-  )
-
-  // Process an empty match (fails if the value is not empty)
-  const emptyMatch = match("empty", (docValue: string | null) => {
-    return docValue != null && docValue !== ""
-  })
-
-  // Process a not-empty match (fails is the value is empty)
-  const notEmptyMatch = match("notEmpty", (docValue: string | null) => {
-    return docValue == null || docValue === ""
-  })
-
-  // Process an includes match (fails if the value is not included)
-  const oneOf = match("oneOf", (docValue: any, testValue: any) => {
-    if (typeof testValue === "string") {
-      testValue = testValue.split(",")
-      if (typeof docValue === "number") {
-        testValue = testValue.map((item: string) => parseFloat(item))
-      }
-    }
-    return !testValue?.includes(docValue)
-  })
-
-  const containsAny = match("containsAny", (docValue: any, testValue: any) => {
-    return !docValue?.includes(...testValue)
-  })
-
-  const contains = match(
-    "contains",
-    (docValue: string | any[], testValue: any[]) => {
-      return !testValue?.every((item: any) => docValue?.includes(item))
-    }
-  )
-
-  const notContains = match(
-    "notContains",
-    (docValue: string | any[], testValue: any[]) => {
-      return testValue?.every((item: any) => docValue?.includes(item))
-    }
-  )
-
-  // Match a document against all criteria
-  const docMatch = (doc: any) => {
-    return (
-      stringMatch(doc) &&
-      fuzzyMatch(doc) &&
-      rangeMatch(doc) &&
-      equalMatch(doc) &&
-      notEqualMatch(doc) &&
-      emptyMatch(doc) &&
-      notEmptyMatch(doc) &&
-      oneOf(doc) &&
-      contains(doc) &&
-      containsAny(doc) &&
-      notContains(doc)
-    )
-  }
-
-  // Process all docs
-  return docs.filter(docMatch)
-}
-
-/**
- * Performs a client-side sort from the equivalent server-side lucene sort
- * parameters.
- * @param docs the data
- * @param sort the sort column
- * @param sortOrder the sort order ("ascending" or "descending")
- * @param sortType the type of sort ("string" or "number")
- */
-export const luceneSort = (
-  docs: any[],
-  sort: string,
-  sortOrder: SortDirection,
-  sortType = SortType.STRING
-) => {
-  if (!sort || !sortOrder || !sortType) {
-    return docs
-  }
-  const parse =
-    sortType === "string" ? (x: any) => `${x}` : (x: string) => parseFloat(x)
-  return docs
-    .slice()
-    .sort((a: { [x: string]: any }, b: { [x: string]: any }) => {
-      const colA = parse(a[sort])
-      const colB = parse(b[sort])
-      if (sortOrder.toLowerCase() === "descending") {
-        return colA > colB ? -1 : 1
-      } else {
-        return colA > colB ? 1 : -1
-      }
-    })
-}
-
-/**
- * Limits the specified docs to the specified number of rows from the equivalent
- * server-side lucene limit parameters.
- * @param docs the data
- * @param limit the number of docs to limit to
- */
-export const luceneLimit = (docs: any[], limit: string) => {
-  const numLimit = parseFloat(limit)
-  if (isNaN(numLimit)) {
-    return docs
-  }
-  return docs.slice(0, numLimit)
-}
-
-export const hasFilters = (query?: SearchQuery) => {
-  if (!query) {
-    return false
-  }
-  const skipped = ["allOr"]
-  for (let [key, value] of Object.entries(query)) {
-    if (skipped.includes(key) || typeof value !== "object") {
-      continue
-    }
-    if (Object.keys(value).length !== 0) {
-      return true
-    }
-  }
-  return false
-}

package/src/helpers/helpers.ts

@@ -1,85 +0,0 @@
-import { User } from "@budibase/types"
-
-/**
- * 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
-}
-
-/**
- * Gets the initials to show in a user avatar.
- * @param user the user
- */
-export const getUserInitials = (user: User) => {
-  if (!user) {
-    return "?"
-  }
-  let initials = ""
-  initials += user.firstName ? user.firstName[0] : ""
-  initials += user.lastName ? user.lastName[0] : ""
-  if (initials !== "") {
-    return initials
-  }
-  return user.email?.[0] || "U"
-}
-
-/**
- * Gets a deterministic colour for a particular user
- * @param user the user
- */
-export const getUserColor = (user: User) => {
-  let id = user?._id
-  if (!id) {
-    return "var(--spectrum-global-color-blue-400)"
-  }
-
-  // In order to generate the same color for global users as app users, we need
-  // to remove the app-specific table prefix
-  id = id.replace("ro_ta_users_", "")
-
-  // Generate a hue based on the ID
-  let hue = 1
-  for (let i = 0; i < id.length; i++) {
-    hue += id.charCodeAt(i)
-    hue = hue % 36
-  }
-  return `hsl(${hue * 10}, 50%, 40%)`
-}
-
-/**
- * Gets a friendly label to describe who a user is.
- * @param user the user
- */
-export const getUserLabel = (user: User) => {
-  if (!user) {
-    return ""
-  }
-  const { firstName, lastName, email } = user
-  if (firstName && lastName) {
-    return `${firstName} ${lastName}`
-  } else if (firstName) {
-    return firstName
-  } else if (lastName) {
-    return lastName
-  } else {
-    return email
-  }
-}

package/src/helpers/index.ts

@@ -1,2 +0,0 @@
-export * from "./helpers"
-export * from "./integrations"

package/src/helpers/integrations.ts

@@ -1,18 +0,0 @@
-import { Datasource, SourceName } from "@budibase/types"
-
-export function isGoogleSheets(type: SourceName) {
-  return type === SourceName.GOOGLE_SHEETS
-}
-
-export function isSQL(datasource: Datasource): boolean {
-  if (!datasource || !datasource.source) {
-    return false
-  }
-  const SQL = [
-    SourceName.POSTGRES,
-    SourceName.SQL_SERVER,
-    SourceName.MYSQL,
-    SourceName.ORACLE,
-  ]
-  return SQL.indexOf(datasource.source) !== -1
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "./constants"
-export * as dataFilters from "./filters"
-export * as helpers from "./helpers"
-export * as utils from "./utils"
-export * as sdk from "./sdk"

package/src/sdk/documents/applications.ts

@@ -1,35 +0,0 @@
-import { DocumentType, prefixed } from "@budibase/types"
-
-const APP_PREFIX = prefixed(DocumentType.APP)
-const APP_DEV_PREFIX = prefixed(DocumentType.APP_DEV)
-
-export function getDevAppID(appId: string) {
-  if (!appId) {
-    throw new Error("No app ID provided")
-  }
-  if (appId.startsWith(APP_DEV_PREFIX)) {
-    return appId
-  }
-  // split to take off the app_ element, then join it together incase any other app_ exist
-  const split = appId.split(APP_PREFIX)
-  split.shift()
-  const rest = split.join(APP_PREFIX)
-  return `${APP_DEV_PREFIX}${rest}`
-}
-
-/**
- * Convert a development app ID to a deployed app ID.
- */
-export function getProdAppID(appId: string) {
-  if (!appId) {
-    throw new Error("No app ID provided")
-  }
-  if (!appId.startsWith(APP_DEV_PREFIX)) {
-    return appId
-  }
-  // split to take off the app_dev element, then join it together incase any other app_ exist
-  const split = appId.split(APP_DEV_PREFIX)
-  split.shift()
-  const rest = split.join(APP_DEV_PREFIX)
-  return `${APP_PREFIX}${rest}`
-}

package/src/sdk/documents/index.ts

@@ -1,2 +0,0 @@
-export * as applications from "./applications"
-export * as users from "./users"

package/src/sdk/documents/users.ts

@@ -1,62 +0,0 @@
-import { ContextUser, User } from "@budibase/types"
-import { getProdAppID } from "./applications"
-
-// checks if a user is specifically a builder, given an app ID
-export function isBuilder(user: User | ContextUser, appId?: string): boolean {
-  if (!user) {
-    return false
-  }
-  if (user.builder?.global) {
-    return true
-  } else if (appId && user.builder?.apps?.includes(getProdAppID(appId))) {
-    return true
-  }
-  return false
-}
-
-export function isGlobalBuilder(user: User | ContextUser): boolean {
-  return (isBuilder(user) && !hasAppBuilderPermissions(user)) || isAdmin(user)
-}
-
-// alias for hasAdminPermission, currently do the same thing
-// in future whether someone has admin permissions and whether they are
-// an admin for a specific resource could be separated
-export function isAdmin(user: User | ContextUser): boolean {
-  if (!user) {
-    return false
-  }
-  return hasAdminPermissions(user)
-}
-
-export function isAdminOrBuilder(
-  user: User | ContextUser,
-  appId?: string
-): boolean {
-  return isBuilder(user, appId) || isAdmin(user)
-}
-
-// check if they are a builder within an app (not necessarily a global builder)
-export function hasAppBuilderPermissions(user?: User | ContextUser): boolean {
-  if (!user) {
-    return false
-  }
-  const appLength = user.builder?.apps?.length
-  const isGlobalBuilder = !!user.builder?.global
-  return !isGlobalBuilder && appLength != null && appLength > 0
-}
-
-// checks if a user is capable of building any app
-export function hasBuilderPermissions(user?: User | ContextUser): boolean {
-  if (!user) {
-    return false
-  }
-  return user.builder?.global || hasAppBuilderPermissions(user)
-}
-
-// checks if a user is capable of being an admin
-export function hasAdminPermissions(user?: User | ContextUser): boolean {
-  if (!user) {
-    return false
-  }
-  return !!user.admin?.global
-}

package/src/sdk/index.ts

@@ -1 +0,0 @@
-export * from "./documents"

package/src/utils.ts

@@ -1,45 +0,0 @@
-export function unreachable(
-  value: never,
-  message = `No such case in exhaustive switch: ${value}`
-) {
-  throw new Error(message)
-}
-
-export async function parallelForeach<T>(
-  items: T[],
-  task: (item: T) => Promise<void>,
-  maxConcurrency: number
-): Promise<void> {
-  const promises: Promise<void>[] = []
-  let index = 0
-
-  const processItem = async (item: T) => {
-    try {
-      await task(item)
-    } finally {
-      processNext()
-    }
-  }
-
-  const processNext = () => {
-    if (index >= items.length) {
-      // No more items to process
-      return
-    }
-
-    const item = items[index]
-    index++
-
-    const promise = processItem(item)
-    promises.push(promise)
-
-    if (promises.length >= maxConcurrency) {
-      Promise.race(promises).then(processNext)
-    } else {
-      processNext()
-    }
-  }
-  processNext()
-
-  await Promise.all(promises)
-}