@budibase/string-templates 3.2.4 → 3.2.6

package/src/helpers/index.ts

@@ -1,103 +0,0 @@
-import Helper from "./Helper"
-import Handlebars from "handlebars"
-import * as externalHandlebars from "./external"
-import { processJS } from "./javascript"
-import {
-  HelperFunctionNames,
-  HelperFunctionBuiltin,
-  LITERAL_MARKER,
-} from "./constants"
-
-export { getJsHelperList } from "./list"
-
-const HTML_SWAPS = {
-  "<": "&lt;",
-  ">": "&gt;",
-}
-
-function isObject(value: string | any[]) {
-  if (value == null || typeof value !== "object") {
-    return false
-  }
-  return (
-    value.toString() === "[object Object]" ||
-    (value.length > 0 && typeof value[0] === "object")
-  )
-}
-
-const HELPERS = [
-  // external helpers
-  new Helper(HelperFunctionNames.OBJECT, (value: any) => {
-    return new Handlebars.SafeString(JSON.stringify(value))
-  }),
-  // javascript helper
-  new Helper(HelperFunctionNames.JS, processJS, false),
-  // this help is applied to all statements
-  new Helper(
-    HelperFunctionNames.ALL,
-    (value: string, inputs: { __opts: any }) => {
-      const { __opts } = inputs
-      if (isObject(value)) {
-        return new Handlebars.SafeString(JSON.stringify(value))
-      }
-      // null/undefined values produce bad results
-      if (__opts && __opts.onlyFound && value == null) {
-        return __opts.input
-      }
-      if (value == null || typeof value !== "string") {
-        return value == null ? "" : value
-      }
-      // TODO: check, this should always be false
-      if (value && (value as any).string) {
-        value = (value as any).string
-      }
-      let text: any = value
-      if (__opts && __opts.escapeNewlines) {
-        text = value.replace(/\n/g, "\\n")
-      }
-      text = new Handlebars.SafeString(text.replace(/&amp;/g, "&"))
-      if (text == null || typeof text !== "string") {
-        return text
-      }
-      return text.replace(/[<>]/g, (tag: string) => {
-        return HTML_SWAPS[tag as keyof typeof HTML_SWAPS] || tag
-      })
-    }
-  ),
-  // adds a note for post-processor
-  new Helper(HelperFunctionNames.LITERAL, (value: any) => {
-    if (value === undefined) {
-      return ""
-    }
-    const type = typeof value
-    const outputVal = type === "object" ? JSON.stringify(value) : value
-    return `{{${LITERAL_MARKER} ${type}-${outputVal}}}`
-  }),
-]
-
-export function HelperNames() {
-  return Object.values(HelperFunctionNames).concat(
-    HelperFunctionBuiltin,
-    externalHandlebars.externalHelperNames
-  )
-}
-
-export function registerMinimum(handlebars: typeof Handlebars) {
-  for (let helper of HELPERS) {
-    helper.register(handlebars)
-  }
-}
-
-export function registerAll(handlebars: typeof Handlebars) {
-  registerMinimum(handlebars)
-  // register imported helpers
-  externalHandlebars.registerAll(handlebars)
-}
-
-export function unregisterAll(handlebars: any) {
-  for (let helper of HELPERS) {
-    helper.unregister(handlebars)
-  }
-  // unregister all imported helpers
-  externalHandlebars.unregisterAll(handlebars)
-}

package/src/helpers/javascript.ts

@@ -1,168 +0,0 @@
-import { atob, isBackendService, isJSAllowed } from "../utilities"
-import { LITERAL_MARKER } from "../helpers/constants"
-import { getJsHelperList } from "./list"
-import { iifeWrapper } from "../iife"
-import { JsTimeoutError, UserScriptError } from "../errors"
-import { cloneDeep } from "lodash/fp"
-
-// The method of executing JS scripts depends on the bundle being built.
-// This setter is used in the entrypoint (either index.js or index.mjs).
-let runJS: ((js: string, context: Record<string, any>) => any) | undefined =
-  undefined
-export const setJSRunner = (runner: typeof runJS) => (runJS = runner)
-
-export const removeJSRunner = () => {
-  runJS = undefined
-}
-
-let onErrorLog: (message: Error) => void
-export const setOnErrorLog = (delegate: typeof onErrorLog) =>
-  (onErrorLog = delegate)
-
-// Helper utility to strip square brackets from a value
-const removeSquareBrackets = (value: string) => {
-  if (!value || typeof value !== "string") {
-    return value
-  }
-  const regex = /\[+(.+)]+/
-  const matches = value.match(regex)
-  if (matches && matches[1]) {
-    return matches[1]
-  }
-  return value
-}
-
-const isReservedKey = (key: string) =>
-  key === "snippets" ||
-  key === "helpers" ||
-  key.startsWith("snippets.") ||
-  key.startsWith("helpers.")
-
-// Our context getter function provided to JS code as $.
-// Extracts a value from context.
-const getContextValue = (path: string, context: any) => {
-  // We populate `snippets` ourselves, don't allow access to it.
-  if (isReservedKey(path)) {
-    return undefined
-  }
-  const literalStringRegex = /^(["'`]).*\1$/
-  let data = context
-  // check if it's a literal string - just return path if its quoted
-  if (literalStringRegex.test(path)) {
-    return path.substring(1, path.length - 1)
-  }
-  path.split(".").forEach(key => {
-    if (data == null || typeof data !== "object") {
-      return null
-    }
-    data = data[removeSquareBrackets(key)]
-  })
-
-  return data
-}
-
-// Evaluates JS code against a certain context
-export function processJS(handlebars: string, context: any) {
-  if (!isJSAllowed() || !runJS) {
-    throw new Error("JS disabled in environment.")
-  }
-  try {
-    // Wrap JS in a function and immediately invoke it.
-    // This is required to allow the final `return` statement to be valid.
-    const js = iifeWrapper(atob(handlebars))
-
-    // Transform snippets into an object for faster access, and cache previously
-    // evaluated snippets
-    let snippetMap: any = {}
-    let snippetCache: any = {}
-    for (let snippet of context.snippets || []) {
-      snippetMap[snippet.name] = snippet.code
-    }
-
-    let clonedContext: Record<string, any>
-    if (isBackendService()) {
-      // On the backned, values are copied across the isolated-vm boundary and
-      // so we don't need to do any cloning here. This does create a fundamental
-      // difference in how JS executes on the frontend vs the backend, e.g.
-      // consider this snippet:
-      //
-      //   $("array").push(2)
-      //   return $("array")[1]
-      //
-      // With the context of `{ array: [1] }`, the backend will return
-      // `undefined` whereas the frontend will return `2`. We should fix this.
-      clonedContext = context
-    } else {
-      clonedContext = cloneDeep(context)
-    }
-
-    const sandboxContext = {
-      $: (path: string) => getContextValue(path, clonedContext),
-      helpers: getJsHelperList(),
-
-      // Proxy to evaluate snippets when running in the browser
-      snippets: new Proxy(
-        {},
-        {
-          get: function (_, name) {
-            if (!(name in snippetCache)) {
-              snippetCache[name] = eval(iifeWrapper(snippetMap[name]))
-            }
-            return snippetCache[name]
-          },
-        }
-      ),
-    }
-
-    // Create a sandbox with our context and run the JS
-    const res = { data: runJS(js, sandboxContext) }
-    return `{{${LITERAL_MARKER} js_result-${JSON.stringify(res)}}}`
-  } catch (error: any) {
-    onErrorLog && onErrorLog(error)
-
-    const { noThrow = true } = context.__opts || {}
-
-    // The error handling below is quite messy, because it has fallen to
-    // string-templates to handle a variety of types of error specific to usages
-    // above it in the stack. It would be nice some day to refactor this to
-    // allow each user of processStringSync to handle errors in the way they see
-    // fit.
-
-    // This is to catch the error vm.runInNewContext() throws when the timeout
-    // is exceeded.
-    if (error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
-      return "Timed out while executing JS"
-    }
-
-    // This is to catch the JsRequestTimeoutError we throw when we detect a
-    // timeout across an entire request in the backend. We use a magic string
-    // because we can't import from the backend into string-templates.
-    if (error.code === "JS_REQUEST_TIMEOUT_ERROR") {
-      return error.message
-    }
-
-    // This is to catch the JsTimeoutError we throw when we detect a timeout in
-    // a single JS execution.
-    if (error.code === JsTimeoutError.code) {
-      return JsTimeoutError.message
-    }
-
-    // This is to catch the error that happens if a user-supplied JS script
-    // throws for reasons introduced by the user.
-    if (error.code === UserScriptError.code) {
-      if (noThrow) {
-        return error.userScriptError.toString()
-      }
-      throw error
-    }
-
-    if (error.name === "SyntaxError") {
-      if (noThrow) {
-        return error.toString()
-      }
-      throw error
-    }
-
-    return "Error while executing JS"
-  }
-}

package/src/helpers/list.ts

@@ -1,72 +0,0 @@
-import { date, duration } from "./date"
-
-/* 
-@budibase/handlebars-helpers is not treeshakeable, so we can't use the barrel files. 
-Otherwise, we have issues when generating the isolated-vm bundle because of the treeshaking
-*/
-/* eslint-disable local-rules/no-budibase-imports */
-// @ts-expect-error
-import math from "@budibase/handlebars-helpers/lib/math"
-// @ts-expect-error
-import array from "@budibase/handlebars-helpers/lib/array"
-// @ts-expect-error
-import number from "@budibase/handlebars-helpers/lib/number"
-// @ts-expect-error
-import url from "@budibase/handlebars-helpers/lib/url"
-// @ts-expect-error
-import string from "@budibase/handlebars-helpers/lib/string"
-// @ts-expect-error
-import comparison from "@budibase/handlebars-helpers/lib/comparison"
-// @ts-expect-error
-import object from "@budibase/handlebars-helpers/lib/object"
-// @ts-expect-error
-import regex from "@budibase/handlebars-helpers/lib/regex"
-// @ts-expect-error
-import uuid from "@budibase/handlebars-helpers/lib/uuid"
-/* eslint-enable local-rules/no-budibase-imports */
-
-// https://github.com/evanw/esbuild/issues/56
-const externalCollections = {
-  math,
-  array,
-  number,
-  url,
-  string,
-  comparison,
-  object,
-  regex,
-  uuid,
-}
-
-export const helpersToRemoveForJs = ["sortBy"]
-
-const addedHelpers = {
-  date: date,
-  duration: duration,
-}
-
-let helpers: Record<string, any>
-
-export function getJsHelperList() {
-  if (helpers) {
-    return helpers
-  }
-
-  helpers = {}
-  for (let collection of Object.values(externalCollections)) {
-    for (let [key, func] of Object.entries<any>(collection)) {
-      // Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it
-      helpers[key] = (...props: any) => func(...props, {})
-    }
-  }
-  helpers = {
-    ...helpers,
-    ...addedHelpers,
-  }
-
-  for (const toRemove of helpersToRemoveForJs) {
-    delete helpers[toRemove]
-  }
-  Object.freeze(helpers)
-  return helpers
-}

package/src/iife.ts

@@ -1,3 +0,0 @@
-export const iifeWrapper = (script: string) => {
-  return `(function(){\n${script}\n})();`
-}