@sap/cds 8.4.2 → 8.5.1

package/lib/i18n/localize.js

@@ -1,271 +1,135 @@
-const cds = require('..')
-const {existsSync, readdirSync} = require ('fs')
-const {join,dirname,resolve,parse,sep} = require ('path')
-
-const DEBUG = cds.debug('i18n')
-const _node_modules = cds.env.cdsc.moduleLookupDirectories.map(d => sep+d.slice(0, -1))
-
-module.exports = Object.assign (localize, {
-  localize, lookup, bundles4, folders4, folder4, bundle4, files4, allLocales4
-})
-
-/**
- * Can be used like that:
- * @example cds.i18n.lookup('CreatedAt','de')
- */
-function lookup (key, locale, model = cds.context?.model || cds.model) {
-  let bundle = bundle4 (model, locale)
-  return bundle?.[key]
-}
+const cds = require('..'), {i18n} = cds
 
 /**
- * Can be used like that:
- * @example cds.localize(edmx,'de')
+ * Fluent API to localize {i18n>...} placeholders in arbitrary strings.
+ * - All fluent methods are optional and can be chained in any order.
+ * @example
+ * let all = cds.localize ('<b>{i18n>CreatedBy}:</b> ...')
+ *   .from (cds.model)
+ *   .for ('de','en')
+ *   .with (cds.i18n.labels)
+ *   .with (cds.i18n.labels.translations4('de','en'))
+ *   .using (s => s)
+ * [...all] //> [ [ 'de', '<b>Angelegt von:</b> ...' ], [ 'en', '<b>Created By:</b> ...' ] ]
  */
-function localize (aString, locale, model = cds.context?.model || cds.model, ext={}) {
+class Localize {
 
-  // support for legacy signature
-  if (typeof aString === 'object') [ aString, model ] = [ model, aString ]
-
-  // in case of multiple locales, return a generator
-  if (Array.isArray(locale) || locale == 'all' || locale == '*') return (function*(){
-    let localized, bundles = bundles4 (model, locale)
-    if (bundles?.[Symbol.iterator]) for (let [lang,each] of bundles) {
-      localized = _localize_with (each)
-      yield [ localized, {lang} ]
-    }
-    if (!localized) yield [ aString, {lang:''} ]
-  })()
+  constructor (input) {
+    if (input) this.input = input
+  }
 
-  // otherwise return a single localized string
-  let bundle = bundle4 (model, locale)
-  return _localize_with (bundle)
+  from (model) {
+    this.model = model
+    return this
+  }
 
-  function _localize_with (bundle) {
-    if (!bundle || !aString) return aString
-    if (typeof aString === 'object') aString = JSON.stringify(aString)
-    const escape = aString.startsWith('<?xml') ? escapeXmlAttr : /^[{[]/.test(aString) ? escapeJson : v=>v
-    return aString.replace (/{i18n>([^}]+)}/g, (_, key) => {
-      const val = ext[key] || bundle[key]
-      return !val ? key : escape(val)
-    })
+  for (...locales) {
+    this.locales = Array.isArray(locales[0]) ? locales[0] : locales
+    return this
   }
-}
 
+  with (bundle, overlay) {
+    if (overlay) this.overlay = overlay
+    this.bundle = bundle
+    return this
+  }
 
+  using (replacer) {
+    this.replacer = replacer
+    return this
+  }
 
-/**
- * Returns all property bundles, i.e. one for each available translation language,
- * for the given model.
- */
-function bundles4 (model, locales = cds.env.i18n.languages) {
+  *[Symbol.iterator]() {
+    const { input, bundle = i18n.bundle4(this.model), overlay={}, replacer=s=>s } = this
+    const all = Object.entries (bundle.translations4?.(this.locales||'all') ?? bundle)
+    const placeholders = /{i18n>([^}]+)}/g
+    if (all.length) for (let [ lang, texts ] of all) yield [
+      lang, input.replace (placeholders, (_,k) => overlay[k] || replacer(texts[k]) || k)
+    ]
+    else yield [ '', input ]
+  }
+}
 
-  const folders = folders4 (model); if (folders.length === 0) return
-  const {i18n} = cds.env
 
-  if (locales.split) locales = locales.split(',')
-  if (locales == 'all' || locales == '*') { // NOTE: using == to match 'all' as well as ['all']
-    locales = allLocales4 (folders); if (!locales) return {}
-    if (!locales.includes(i18n.fallback_bundle))  locales.push (i18n.fallback_bundle)
-  }
+// -----------------------------------------------------------------------------------------------
+// Facade API
 
-  DEBUG?.('Languages:', locales)
+module.exports = exports = localize
 
-  return (function*(){
-    for (let each of locales) {
-      let bundle = bundle4 (model, each); if(!bundle) continue
-      DEBUG?.(bundle)
-      yield [ each, bundle ]
-    }
-  })()
+function localize (input) {
+  if (arguments.length > 1) return exports.legacy (...arguments)
+  return new Localize (input)
 }
 
-
-function files4 (folders_or_model) {
-  const {i18n} = cds.env
-  const folders = folders_or_model.map ? folders_or_model : folders4(folders_or_model)
-  const files = folders.map (folder => readdirSync(folder)
-    .filter (e => e.startsWith(i18n.file))
-    .map(i18nFile => join (folder, i18nFile))
-  ).flat()
-  if (files.length === 0) {
-    DEBUG?.('No languages for folders:', folders)
-    return null
+exports.edmx4 = service => new class extends Localize { get input(){
+  const model = this.model || cds.context?.model || cds.model
+  return super.input = cds.compile.to.edmx (model,{service})
+}}
+
+exports.edmx = edmx => {
+  if (typeof edmx === 'object') edmx = cds.compile.to.edmx (edmx)
+  const _xml_escapes = {
+    '"'  : '&quot;',
+    '<'  : '&lt;',
+    '>'  : '&gt;',
+    '&'  : '&amp;', // if not followed by amp; quot; lt; gt; apos; or #
+    '\n' : '&#xa;',
+    '\r' : '',
   }
-  return files
+  const _2b_escaped = /["<>\n\r]|&(?!quot;|amp;|lt;|gt;|apos;|#)/g
+  const _xml_replacer = s => s?.replace (_2b_escaped, m => _xml_escapes[m])
+  return localize (edmx) .using (_xml_replacer)
 }
 
-/**
- * Return locales for all bundles found in given folders derived from .json, .properties or .csv files.
- *
- * TODO - .csv file handling seems to be questionable - do we need to check all .csv files additionally for locales ???
- */
-function allLocales4 (folders_or_model) {
-  const files = files4(folders_or_model)
-  if (!files) return null
-  if (files[0].endsWith('.csv')) {
-    return cds.load.csv (files[0])[0].slice(1)
-  } else {
-    const locales = new Set()
-    files.forEach(file => {
-      const parsed = parse(file)
-      if (parsed.ext === '.json') {
-        Object.keys(require(file)).forEach(locale => locales.add(locale))
-      }
-      else if (parsed.ext === '.properties') {
-        const match = /_(\w+)$/.exec(parsed.name)
-        if (match)  locales.add(match[1])
-      }
-    })
-    return Array.from(locales)
-  }
+exports.json = json => {
+  if (typeof json === 'object') json = JSON.stringify(json)
+  const _json_replacer = s => s?.replace(/"/g, '\\"')
+  return localize(json) .using (_json_replacer)
 }
 
-/**
- * Returns the effective bundle stack for the given language and model folders.
- * Expected bundle stack for languages en and '' + 2 model layers:
-    [en]   model/_i18n
-      []   model/_i18n
-        [en]   model/node_modules/reuse-model/_i18n
-          []   model/node_modules/reuse-model/_i18n
- */
-function bundle4 (model, locale) {
 
-  if (typeof model === 'string') [ model, locale ] = [ cds.context?.model || cds.model, model ]
 
-  const bundles = model.texts || Object.defineProperty (model,'texts',{value:{}}).texts
-  if (locale in bundles) return bundles[locale]
+// -----------------------------------------------------------------------------------------------
+// Legacy API, not used anymore in @sap/cds...
 
-  const folders = folders4(model)
-  if (!folders.length) return bundles[locale] = {}
+/** @deprecated */ exports.legacy = function (input, locales, model, ext) {
 
-  const {i18n} = cds.env
-  let bundle = Object.create(null)
-  bundle.toJSON = jsonWithAllProps // allows JSON.stringify with all inherited props
+  // Support for legacy params signature with model as first argument, and edm string as third
+  if (typeof input === 'object') [ input, model ] = [ model, input ]; if (!input) return
+  if (typeof input !== 'string') input = JSON.stringify (input)
+  if (locales == '*') locales = 'all' // NOTE: '*' is deprecated; using == to match '*' and ['*']
 
-  let locales = (
-    locale === i18n.fallback_bundle ? [ i18n.fallback_bundle ] :
-    locale === i18n.default_language ? [ i18n.fallback_bundle, i18n.default_language ] :
-    [ i18n.fallback_bundle, i18n.default_language, locale ]
+  // Construct fluent API instance from arguments
+  const fluent = (
+    input[0] === '<' ? exports.edmx (input) :
+    input[0] === '{' ? exports.json (input) :
+    localize (input)
   )
-  for (let each of locales) {
-    const b = bundle = Object.create(bundle)
-    for (let folder of folders) {
-      const file = join (folder, i18n.file), suffix = each ? '_' + each : ''
-      const next = bundle4[file + suffix] ??= (
-        loadFromJSON (file, each)  ||
-        cds.load.properties (file + suffix.replace('-','_')) ||  // e.g. en-UK --> en_UK
-        cds.load.properties (file + suffix.match(/\w+/)) ||  // e.g. en_UK --> en
-        loadFromCSV (file, each)
-      )
-      Object.assign (b, next)
-    }
-  }
-
-  return bundles[locale] = bundle
-}
-
-/**
- * Returns an array of all existing _i18n folders for the models
- * that are merged into the given one..
- */
-function folders4 (model) {
-  if (model._i18nfolders)  return model._i18nfolders
-  // Order of model.$sources is expected to be sorted along usage levels, e.g.
-  //   foo/bar.cds
-  //   foo/node_modules/reuse-level-1/model.cds
-  //   foo/node_modules/reuse-level-2/model.cds
-  const folders = [] // using an array here to not screw up the folder order
-  const srcFolders = new Set ((model.$sources||[]).map(dirname))
-  srcFolders.forEach(src => {
-    const folder = folder4 (src)
-    if (folder && !folders.includes(folder)) {
-      folders.push(folder)
-    }
-  })
-  Object.defineProperty (model, '_i18nfolders', {value:folders.reverse()})
-  return folders
-}
-
-/**
- * Returns the location of an existing _i18n folder next to or in the
- * folder hierarchy above the given path, if any.
- */
-function folder4 (loc) {
-  // already cached from a former lookup?
-  if (loc in folder4)  return folder4[loc]
-  // check whether a <loc>/_i18n exists
-  const {i18n} = cds.env
-  for (let each of i18n.folders) {
-    const f = join (loc, each)
-    if (existsSync(f)) return folder4[loc] = f
-  }
-  //> no --> search up the folder hierarchy up to cds.root, cds.home, or some .../node_modules/<package>
-  let next = dirname(loc)
-  if (_node_modules.some(m => next.includes(m))) {
-    if (_node_modules.some(m => next.endsWith(m))) return folder4[loc] = null
-  } else {
-    if (!(
-      next.startsWith(cds.root) ||
-      next.startsWith(cds.home) ||
-      i18n.root && next.startsWith(i18n.root)
-    )) return folder4[loc] = null
-  }
-  if (!next || next === loc) return folder4[loc] = null
-  // console.debug(next)
-  return folder4[loc] = folder4(next)
+  if (locales) fluent.locales = locales
+  if (model) fluent.model = model
+  if (ext) fluent.overlay = ext
+
+  // Return the first result if a single locale was requested, otherwise return all
+  if (!Array.isArray(locales) && locales != 'all')
+    for (let [,txt] of fluent) return txt
+  else return function*(){
+    for (let [lang,txt] of fluent) yield [ txt, {lang}]
+  }()
 }
 
-
-function loadFromJSON (res, lang=cds.env.i18n.default_language) {
-  let cached = loadFromJSON[res]
-  if (!cached) try {
-    cached = loadFromJSON[res] = require (resolve (cds.root,res+'.json'))
-  } catch(e) {
-    if (e.code !== 'MODULE_NOT_FOUND') throw e
-    else cached = loadFromJSON[res] = {}
-  }
-  return cached[lang] || cached[lang.match(/\w+/)?.[0]]
+/** @deprecated */ exports.bundles4 = function (model, locales = cds.env.i18n.languages) {
+  const b = i18n.bundle4 (model)
+  const all = b.translations4 (locales)
+  return Object.entries (all)
 }
 
-function loadFromCSV (res, lang=cds.env.i18n.default_language) {
-  let csv = cds.load.csv(res+'.csv'); if (!csv) return
-  let [header, ...rows] = csv
-  if (lang === '*') return header.slice(1).reduce ((all,lang,i) => {
-    all[lang] = _bundle(i); return all
-  },{})
-  let col = header.indexOf (lang)
-  if (col < 0)  col = header.indexOf ((lang.match(/\w+/)||[])[0])
-  if (col > 0) return _bundle (col)
-  function _bundle (col) {
-    const b={}; for (let row of rows) if (row[col])  b[row[0]] = row[col]
-    return Object.defineProperty (b, '_source', {value:res+'.csv'+'#'+lang})
-  }
-}
-
-// TODO use compiler API for XML escaping
-function escapeXmlAttr (str) {
-  // first regex: replace & if not followed by apos; or quot; or gt; or lt; or amp; or #
-  // Do not always escape > as it is a marker for {i18n>...} translated string values
-  let result = str;
-  if (typeof str === 'string') {
-    result = str.replace(/&(?!(?:apos|quot|[gl]t|amp);|#)/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/"/g, '&quot;')
-      .replace(/\r\n|\n/g, '&#xa;');
-    if (!result.startsWith('{i18n>')) result = result.replace(/>/g, '&gt;')
-  }
-  return result;
+/** @deprecated */ exports.bundle4 = function (model, locale) {
+  if (typeof model === 'string') [ model, locale ] = [ cds.context?.model || cds.model, model ]
+  const b = i18n.bundle4 (model)
+  return b.texts4 (locale)
 }
 
-const escapeJson = str => str.replace(/"/g, '\\"')
-
-function jsonWithAllProps() {
-  const res = {}
-  for (let key in this) {
-    if (typeof this[key] !== 'function') {
-      res[key] = this[key]
-    }
-  }
-  return res
+/** @deprecated */ exports.folders4 = function (model) {
+  const b = i18n.bundle4 (model)
+  return Object.keys (b.files)
 }

package/lib/i18n/resources.js

@@ -0,0 +1,150 @@
+const cds = require('..'), { path } = cds.utils
+const LOG = cds.log('i18n')
+
+/**
+ * Instances of this class are used to fetch and read i18n resources from the file system.
+ */
+class I18nResources {
+
+  constructor (options) {
+    for (let each in options) super[each] = options[each]
+  }
+
+
+  /**
+   * The folders to search for i18n files in. By default a shortcut to i18n.folders
+   * config but can be specified in constructor.
+   */
+  get folders() {
+    return super.folders = cds.env.i18n.folders
+  }
+
+
+  /**
+   * Returns the files basename to read properties from; default is `'i18n'`.
+   * @returns {string}
+   */
+  get file() {
+    return super.file ??= cds.env.i18n.file
+  }
+
+
+  /**
+   * Fetches all i18n files matching {@link file basename} in {@link folders} up to {@link roots}.
+   * @returns {Record<string,string[]>} a dictionary of files by folders.
+   */
+  get files() {
+
+    // prepare the things we need below...
+    const { existsSync: exists, readdirSync: readdir } = cds.utils.fs
+    const _folders = I18nResources.folders ??= {}
+    const _entries = I18nResources.entries ??= {}
+    const basename = RegExp(`${this.file}[._]`)
+    const files_by_folders = {} // the result to be returned
+
+    // fetch relatively specified i18n.folders in the neighborhood of sources...
+    const relative_folders = this.folders.filter (f => f[0] !== '/')
+    if (relative_folders.length) {
+      const visited = {}, roots = this.roots, $sources = this.model?.$sources
+      const $sourcedirs = $sources ? [ ...new Set($sources.map(path.dirname)) ].reverse() : [ cds.home, cds.root ]
+      $sourcedirs.forEach (function _visit (dir) {
+        if (dir in visited) return; else visited[dir] = true
+        LOG.debug ('searching for i18n files in the neighborhood of', dir)
+        // is there an i18n folder in the currently visited directory?
+        for (let each of relative_folders) {
+          const f = path.join(dir,each), _exists = _folders[f] ??= exists(f)
+          if (_exists && _add_entries4(f)) return // stop at first match from i18n.folders
+        }
+        // else recurse up the folder hierarchy till reaching package roots ...
+        if (roots.includes(dir) || exists(path.join(dir,'package.json'))) return
+        else _visit (path.dirname(dir))
+      })
+    }
+
+    // fetch fully specified i18n.folders, i.e., those starting with /
+    const specific_folders = this.folders.filter (f => f[0] === '/')
+    for (let f of specific_folders) {
+      const _exists = _folders[f] ??= exists(f)
+      _add_entries4 (_exists ? f : path.join(cds.root,f))
+    }
+
+    // helper to add matching files from found folder, if any
+    function _add_entries4 (f) {
+      const files = (_entries[f] ??= readdir(f)) .filter (f => f.match(basename))
+      if (files.length) return files_by_folders[f] = files
+    }
+
+    // finally return the collected files by folders
+    super.folders = Object.keys (files_by_folders)
+    return super.files = files_by_folders
+  }
+
+
+  /**
+   * The root directories up to which to search for {@link files `i18n.files`}.
+   */
+  get roots() {
+    return super.roots = [ cds.env.i18n.root || cds.root ]
+  }
+
+
+  /**
+   * Returns all locales for which translations are available in this.{@link files}.
+   * @returns {string[]}
+   */
+  get locales() {
+    const unique_locales = new Set(), {path} = cds.utils
+    for (let [folder,files] of Object.entries(this.files)) {
+      for (let file of files) {
+        const { name, ext } = path.parse (file); switch (ext) {
+          case '.properties': unique_locales.add(/(?:_(\w+))?$/.exec(name)?.[1]||''); break
+          case '.json': for (let locale in _load_json(path.join(folder,file))) unique_locales.add(locale); break
+          case '.csv': return _load_csv (path.join(folder,file))[0].slice(1)
+        }
+      }
+    }
+    return super.locales = [...unique_locales]
+  }
+
+
+  /**
+   * Loads content from all files for the given locale.
+   * @returns {entries[]} An array of entries, one for each file found.
+   */
+  content4 (locale, suffix = locale?.replace(/-/g,'_')) {
+    const content = [], { file, files } = this
+    for (let folder in files) {
+      const all = this.content4[folder] ??= _load('json',folder) || _load('csv',folder)
+      if (all) { if (locale in all) content.push (all[locale]); continue }
+      const props = _load ('properties', folder, file + (suffix ? '_'+suffix : ''))
+      if (props) content.push (props)
+    }
+    function _load (kind, folder, basename = file) {
+      const entry = `${basename}.${kind}`; if (!files[folder].includes(entry)) return
+      const file = path.join (folder, entry)
+      try { switch (kind) {
+        case 'properties': return _load_properties (file)
+        case 'json': return _load_json (file)
+        case 'csv': return _load_csv (file)
+      }} finally {
+        LOG.debug ('read:', file)
+      }
+    }
+    return content
+  }
+}
+
+
+const _load_properties = cds.load.properties
+const _load_json = require
+const _load_csv = file => {
+  const csv = cds.load.csv(file); if (!csv) return
+  const [ header, ...rows ] = csv, all = {}
+  header.slice(1).forEach ((lang,i) => {
+    const entries = all[lang] = {}
+    for (let row of rows) if (row[i]) entries[row[0]] = row[i]
+  })
+  return all
+}
+
+module.exports = I18nResources

package/lib/index.js

@@ -34,6 +34,7 @@ const cds = module.exports = global.cds = new class cds extends EventEmitter {
   get extend()   { return super.extend = require('./compile/extend') }
   get deploy()   { return super.deploy = require('./dbs/cds-deploy') }
   get localize() { return super.localize = require('./i18n/localize') }
+  get i18n()     { return super.i18n = require('./i18n') }
 
   // Model Reflection, Builtin types and classes
   get entities()    { return this.db?.entities || this.model?.entities }

package/lib/log/format/aspects/cls.js

@@ -6,4 +6,9 @@ function cls_aspect(/* module, level, args, toLog */) {
 
 cls_aspect.cf = () => [...cds.env.log.cls_custom_fields]
 
-module.exports = process.env.VCAP_SERVICES?.match(/"label":\s*"cloud-logging"/) ? cls_aspect : () => {}
+const VCAP_SERVICES = process.env.VCAP_SERVICES ? JSON.parse(process.env.VCAP_SERVICES) : {}
+
+module.exports =
+  VCAP_SERVICES['cloud-logging'] || VCAP_SERVICES['user-provided']?.find(e => e.tags.includes('cloud-logging'))
+    ? cls_aspect
+    : () => {}

package/lib/log/format/json.js

@@ -22,7 +22,7 @@ const _is_custom_fields = (arg, custom_fields) => {
   return true
 }
 
-const _is_categories = arg => arg.categories && Array.isArray(arg.categories) && Object.keys(arg).length === 1
+const _is_categories = arg => arg?.categories && Array.isArray(arg.categories) && Object.keys(arg).length === 1
 
 const _extract_custom_fields_and_categories = (args, toLog, custom_fields) => {
   if (args.length) {

package/lib/ql/CREATE.js

@@ -1,5 +1,6 @@
 module.exports = class Query extends require('./Query') {
 
+  get kind() { return 'CREATE' }
   static _api() {
     return Object.assign((..._) => (new this).entity(..._), {
       entity: (..._) => (new this).entity(..._),

package/lib/ql/DELETE.js

@@ -2,6 +2,7 @@ const Whereable = require('./Whereable')
 
 module.exports = class Query extends Whereable {
 
+  get kind() { return 'DELETE' }
   static _api() {
     return Object.assign ((..._) => (new this).from(..._), {
       from: (..._) => (new this).from(..._),

package/lib/ql/DROP.js

@@ -1,4 +1,5 @@
 module.exports = class Query extends require('./Query') {
+  get kind() { return 'DROP' }
   static _api() {
     return Object.assign ((e)  => (new this).entity(e), {
       entity: (e) => (new this).entity(e),

package/lib/ql/INSERT.js

@@ -1,5 +1,6 @@
 module.exports = class Query extends require('./Query') {
 
+  get kind() { return 'INSERT' }
   static _api() {
     return Object.assign ((..._) => (new this).entries(..._), {
       into: (..._) => (new this).into(..._),
@@ -7,7 +8,7 @@ module.exports = class Query extends require('./Query') {
   }
 
   into (entity, ...data) {
-    this[this.cmd].into = this._target4 (...arguments) // supporting tts
+    this._.into = this._target4 (...arguments) // supporting tts
     if (data.length) this.entries(...data)
     return this
   }
@@ -15,21 +16,21 @@ module.exports = class Query extends require('./Query') {
   entries (...x) {
     if (!x.length) return this
     if (x[0].SELECT) return this.from(x[0])
-    this[this.cmd].entries = is_array(x[0]) ? x[0] : x
+    this._.entries = is_array(x[0]) ? x[0] : x
     return this
   }
   columns (...x) {
-    this[this.cmd].columns = is_array(x[0]) ? x[0] : x
+    this._.columns = is_array(x[0]) ? x[0] : x
     return this
   }
   values (...x) {
-    this[this.cmd].values = is_array(x[0]) ? x[0] : x
+    this._.values = is_array(x[0]) ? x[0] : x
     return this
   }
   rows (...rows) {
     if (is_array(rows[0]) && is_array(rows[0][0])) rows = rows[0]
     if (!is_array(rows[0])) this._expected `Arguments ${{rows}} to be an array of arrays`
-    this[this.cmd].rows = rows
+    this._.rows = rows
     return this
   }
 
@@ -39,7 +40,7 @@ module.exports = class Query extends require('./Query') {
       if (query.name || typeof query === 'string') query = SELECT.from(query)
       else this._expected `${{query}} to be a CQN {SELECT} query object`
     }
-    this[this.cmd].as = query // REVISIT: should we also change CSN spec, and adopt db service impls?
+    this._.as = query // REVISIT: should we also change CSN spec, and adopt db service impls?
     return this
   }
 
@@ -53,8 +54,8 @@ module.exports = class Query extends require('./Query') {
     return super.valueOf('INSERT INTO')
   }
 
-  get _target_ref(){ return this.INSERT.into }
+  get _target_ref(){ return this._.into }
 }
 
 const is_array = Array.isArray
-let INSERT_as_SELECT
+let INSERT_as_SELECT