budibase/packages/core/src/common/index.js

import {
  head,
  tail,
  findIndex,
  startsWith,
  dropRight,
  flow,
  takeRight,
  trim,
  replace,
} from "lodash"
import {
  some,
  reduce,
  isEmpty,
  isArray,
  join,
  isString,
  isInteger,
  isDate,
  toNumber,
  isUndefined,
  isNaN,
  isNull,
  constant,
  split,
  includes,
  filter,
} from "lodash/fp"
import { events, eventsList } from "./events"
import { apiWrapper } from "./apiWrapper"
import { getLock, NO_LOCK, isNolock } from "./lock"
import crypto from "./nodeCrypto"

// this is the combinator function
export const $$ = (...funcs) => arg => flow(funcs)(arg)

// this is the pipe function
export const $ = (arg, funcs) => $$(...funcs)(arg)

export const keySep = "/"
const trimKeySep = str => trim(str, keySep)
const splitByKeySep = str => split(keySep)(str)
export const safeKey = key =>
  replace(`${keySep}${trimKeySep(key)}`, `${keySep}${keySep}`, keySep)
export const joinKey = (...strs) => {
  const paramsOrArray = (strs.length === 1) & isArray(strs[0]) ? strs[0] : strs
  return $(paramsOrArray, [
    filter(s => !isUndefined(s) && !isNull(s) && s.toString().length > 0),
    join(keySep),
    safeKey,
  ])
}
export const splitKey = $$(trimKeySep, splitByKeySep)
export const getDirFomKey = $$(splitKey, dropRight, p => joinKey(...p))
export const getFileFromKey = $$(splitKey, takeRight, head)

export const configFolder = `${keySep}.config`
export const fieldDefinitions = joinKey(configFolder, "fields.json")
export const templateDefinitions = joinKey(configFolder, "templates.json")
export const appDefinitionFile = joinKey(configFolder, "appDefinition.json")
export const dirIndex = folderPath =>
  joinKey(configFolder, "dir", ...splitKey(folderPath), "dir.idx")
export const getIndexKeyFromFileKey = $$(getDirFomKey, dirIndex)

export const ifExists = (val, exists, notExists) =>
  isUndefined(val)
    ? isUndefined(notExists)
      ? (() => {})()
      : notExists()
    : exists()

export const getOrDefault = (val, defaultVal) =>
  ifExists(
    val,
    () => val,
    () => defaultVal
  )

export const not = func => val => !func(val)
export const isDefined = not(isUndefined)
export const isNonNull = not(isNull)
export const isNotNaN = not(isNaN)

export const allTrue = (...funcArgs) => val =>
  reduce(
    (result, conditionFunc) =>
      (isNull(result) || result == true) && conditionFunc(val),
    null
  )(funcArgs)

export const anyTrue = (...funcArgs) => val =>
  reduce(
    (result, conditionFunc) => result == true || conditionFunc(val),
    null
  )(funcArgs)

export const insensitiveEquals = (str1, str2) =>
  str1.trim().toLowerCase() === str2.trim().toLowerCase()

export const isSomething = allTrue(isDefined, isNonNull, isNotNaN)
export const isNothing = not(isSomething)
export const isNothingOrEmpty = v => isNothing(v) || isEmpty(v)
export const somethingOrGetDefault = getDefaultFunc => val =>
  isSomething(val) ? val : getDefaultFunc()
export const somethingOrDefault = (val, defaultVal) =>
  somethingOrGetDefault(constant(defaultVal))(val)

export const mapIfSomethingOrDefault = (mapFunc, defaultVal) => val =>
  isSomething(val) ? mapFunc(val) : defaultVal

export const mapIfSomethingOrBlank = mapFunc =>
  mapIfSomethingOrDefault(mapFunc, "")

export const none = predicate => collection => !some(predicate)(collection)

export const all = predicate => collection =>
  none(v => !predicate(v))(collection)

export const isNotEmpty = ob => !isEmpty(ob)
export const isAsync = fn => fn.constructor.name === "AsyncFunction"
export const isNonEmptyArray = allTrue(isArray, isNotEmpty)
export const isNonEmptyString = allTrue(isString, isNotEmpty)
export const tryOr = failFunc => (func, ...args) => {
  try {
    return func.apply(null, ...args)
  } catch (_) {
    return failFunc()
  }
}

export const tryAwaitOr = failFunc => async (func, ...args) => {
  try {
    return await func.apply(null, ...args)
  } catch (_) {
    return await failFunc()
  }
}

export const defineError = (func, errorPrefix) => {
  try {
    return func()
  } catch (err) {
    err.message = `${errorPrefix} : ${err.message}`
    throw err
  }
}

export const tryOrIgnore = tryOr(() => {})
export const tryAwaitOrIgnore = tryAwaitOr(async () => {})
export const causesException = func => {
  try {
    func()
    return false
  } catch (e) {
    return true
  }
}

export const executesWithoutException = func => !causesException(func)

export const handleErrorWith = returnValInError =>
  tryOr(constant(returnValInError))

export const handleErrorWithUndefined = handleErrorWith(undefined)

export const switchCase = (...cases) => value => {
  const nextCase = () => head(cases)[0](value)
  const nextResult = () => head(cases)[1](value)

  if (isEmpty(cases)) return // undefined
  if (nextCase() === true) return nextResult()
  return switchCase(...tail(cases))(value)
}

export const isValue = val1 => val2 => val1 === val2
export const isOneOf = (...vals) => val => includes(val)(vals)
export const defaultCase = constant(true)
export const memberMatches = (member, match) => obj => match(obj[member])

export const StartsWith = searchFor => searchIn =>
  startsWith(searchIn, searchFor)

export const contains = val => array => findIndex(array, v => v === val) > -1

export const getHashCode = s => {
  let hash = 0
  let i
  let char
  let l
  if (s.length == 0) return hash
  for (i = 0, l = s.length; i < l; i++) {
    char = s.charCodeAt(i)
    hash = (hash << 5) - hash + char
    hash |= 0 // Convert to 32bit integer
  }

  // converting to string, but dont want a "-" prefixed
  if (hash < 0) {
    return `n${(hash * -1).toString()}`
  }
  return hash.toString()
}

// thanks to https://blog.grossman.io/how-to-write-async-await-without-try-catch-blocks-in-javascript/
export const awEx = async promise => {
  try {
    const result = await promise
    return [undefined, result]
  } catch (error) {
    return [error, undefined]
  }
}

export const isSafeInteger = n =>
  isInteger(n) &&
  n <= Number.MAX_SAFE_INTEGER &&
  n >= 0 - Number.MAX_SAFE_INTEGER

export const toDateOrNull = s =>
  isNull(s) ? null : isDate(s) ? s : new Date(s)
export const toBoolOrNull = s => (isNull(s) ? null : s === "true" || s === true)
export const toNumberOrNull = s => (isNull(s) ? null : toNumber(s))

export const isArrayOfString = opts => isArray(opts) && all(isString)(opts)

export const pushAll = (target, items) => {
  for (let i of items) target.push(i)
}

export const pause = async duration =>
  new Promise(res => setTimeout(res, duration))

export const retry = async (fn, retries, delay, ...args) => {
  try {
    return await fn(...args)
  } catch (err) {
    if (retries > 1) {
      return await pause(delay).then(
        async () => await retry(fn, retries - 1, delay, ...args)
      )
    }
    throw err
  }
}

export { events } from "./events"
export { apiWrapper, apiWrapperSync } from "./apiWrapper"
export { getLock, NO_LOCK, releaseLock, extendLock, isNolock } from "./lock"
export { crypto }

export default {
  ifExists,
  getOrDefault,
  isDefined,
  isNonNull,
  isNotNaN,
  allTrue,
  isSomething,
  mapIfSomethingOrDefault,
  mapIfSomethingOrBlank,
  configFolder,
  fieldDefinitions,
  isNothing,
  not,
  switchCase,
  defaultCase,
  StartsWith,
  contains,
  templateDefinitions,
  handleErrorWith,
  handleErrorWithUndefined,
  tryOr,
  tryOrIgnore,
  tryAwaitOr,
  tryAwaitOrIgnore,
  dirIndex,
  keySep,
  $,
  $$,
  getDirFomKey,
  getFileFromKey,
  splitKey,
  somethingOrDefault,
  getIndexKeyFromFileKey,
  joinKey,
  somethingOrGetDefault,
  appDefinitionFile,
  isValue,
  all,
  isOneOf,
  memberMatches,
  defineError,
  anyTrue,
  isNonEmptyArray,
  causesException,
  executesWithoutException,
  none,
  getHashCode,
  awEx,
  apiWrapper,
  events,
  eventsList,
  isNothingOrEmpty,
  isSafeInteger,
  toNumber,
  toDate: toDateOrNull,
  toBool: toBoolOrNull,
  isArrayOfString,
  getLock,
  NO_LOCK,
  isNolock,
  insensitiveEquals,
  pause,
  retry,
  pushAll,
}