@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/common/utils/data.js

@@ -1,16 +0,0 @@
-// REVISIT: remove once not needed anymore
-const getDataFromCQN = query => (query.INSERT && query.INSERT.entries) || (query.UPDATE && query.UPDATE.data)
-
-// REVISIT: remove once not needed anymore
-const setDataFromCQN = req => {
-  if (Array.isArray(req.data)) {
-    req.data = req.query.INSERT && req.query.INSERT.entries
-  } else {
-    req.data = (req.query.INSERT && req.query.INSERT.entries[0]) || (req.query.UPDATE && req.query.UPDATE.data)
-  }
-}
-
-module.exports = {
-  getDataFromCQN,
-  setDataFromCQN
-}

package/libx/_runtime/common/utils/dollar.js

@@ -1,27 +0,0 @@
-const cds = require('../../cds')
-
-module.exports = (entryOrRow, keyOrIndex, user, timestamp) => {
-  const v = entryOrRow[keyOrIndex]
-  if (!v) return
-
-  // REVISIT: shouldn't be necessary, but sql builder default for user currently cannot be an object (test issue?)
-  // normalize user (object vs. string)
-  user = user && user.id ? user : { id: user || 'anonymous' }
-
-  if (v === '$user') entryOrRow[keyOrIndex] = user.id
-  else if (v === '$now') entryOrRow[keyOrIndex] = timestamp
-  else if (v === '$uuid') entryOrRow[keyOrIndex] = cds.utils.uuid()
-  else if (typeof v === 'string') {
-    // NOTE: with xsuaa, user attributes are always arrays
-    const attr = v.match(/^\$user\.(.*)/)
-    if (attr) {
-      const val = (user.attr && user.attr[attr[1]]) || null
-      if (Array.isArray(val)) {
-        if (val.length > 1) entryOrRow[keyOrIndex] = JSON.stringify(val)
-        else entryOrRow[keyOrIndex] = val.length > 0 ? val[0] : null
-      } else {
-        entryOrRow[keyOrIndex] = val
-      }
-    }
-  }
-}

package/libx/_runtime/common/utils/generateOnCond.js

@@ -1,127 +0,0 @@
-const { prefixForStruct } = require('./csn')
-
-const _toRef = (alias, column) => {
-  if (Array.isArray(column)) column = column.join('_')
-  return { ref: alias ? [alias, column] : [column] }
-}
-
-const _adaptRefs = (onCond, path, { select, join }) => {
-  const _adaptEl = el => {
-    const ref = el.ref
-
-    if (ref) {
-      if (ref[0] === path.join('_') && ref[1]) {
-        return _toRef(select, ref.slice(1))
-      }
-
-      // no alias for special $user of canonical localized association
-      if (ref[0] === '$user' && path[0] === 'localized') {
-        return _toRef(undefined, ref.slice(0))
-      }
-
-      return _toRef(join, ref.slice(0))
-    }
-
-    if (el.xpr) return { xpr: el.xpr.map(_adaptEl) }
-    return el
-  }
-
-  return onCond.map(_adaptEl)
-}
-
-const replace$selfAndAliasOnCond = (xpr, csnElement, aliases, path) => {
-  const selfIndex = xpr.findIndex(({ ref }) => ref?.[0] === '$self')
-  if (selfIndex != -1) {
-    let backLinkIndex
-    if (xpr[selfIndex + 1] && xpr[selfIndex + 1] === '=') backLinkIndex = selfIndex + 2
-    if (xpr[selfIndex - 1] && xpr[selfIndex - 1] === '=') backLinkIndex = selfIndex - 2
-    if (backLinkIndex != null) {
-      const ref = xpr[backLinkIndex].ref
-      const backlinkName = ref[ref.length - 1]
-      const mutOnCond = _newOnConditions(csnElement._backlink, [backlinkName], {
-        select: aliases.join,
-        join: aliases.select
-      })
-
-      xpr.splice(Math.min(backLinkIndex, selfIndex), 3, ...mutOnCond)
-    }
-  }
-
-  for (let i = 0; i < xpr.length; i++) {
-    const element = xpr[i]
-    if (element.xpr) {
-      replace$selfAndAliasOnCond(element.xpr, csnElement, aliases, path)
-      continue
-    }
-
-    if (element.ref) {
-      if (element.ref[0] === path.join('_') && element.ref[1]) {
-        element.ref = _toRef(aliases.select, element.ref.slice(1)).ref
-        continue
-      }
-
-      // no alias for special $user of canonical localized association
-      if (element.ref[0] === '$user' && path[0] === 'localized') {
-        element.ref = _toRef(undefined, element.ref.slice(0)).ref
-        continue
-      }
-      //no alias for special $now variable
-      if (element.ref[0] === '$now') {
-        continue
-      }
-
-      if (element.ref[0] === aliases.join || element.ref[0] === aliases.select) {
-        // nothing todo here, as already right alias
-        continue
-      }
-
-      element.ref = _toRef(aliases.join, element.ref.slice(0)).ref
-    }
-  }
-}
-
-const _args = (csnElement, path, aliases) => {
-  const onCond = csnElement.on
-  if (!onCond || onCond.length === 0) return []
-  if (onCond.length < 3 && !onCond[0]?.xpr) return onCond
-  if (!csnElement._isSelfManaged) return _adaptRefs(onCond, path, aliases)
-
-  const onCondCopy = JSON.parse(JSON.stringify(onCond))
-  replace$selfAndAliasOnCond(onCondCopy, csnElement, aliases, path)
-
-  return onCondCopy
-}
-
-// this is only for 2one managed w/o on-conditions, i.e. no static values are possible
-const _foreignToOn = (csnElement, path, { select, join }) => {
-  const on = []
-
-  for (const key of csnElement._foreignKeys) {
-    if (on.length !== 0) {
-      on.push('and')
-    }
-
-    const prefixChild = prefixForStruct(key.childElement)
-    const ref1 = _toRef(select, prefixChild + key.childElement.name)
-    const structPrefix = path.length > 1 ? path.slice(0, -1) : []
-    const ref2 = _toRef(join, [...structPrefix, key.parentElement.name])
-    on.push(ref1, '=', ref2)
-  }
-
-  return on
-}
-
-const _newOnConditions = (csnElement, path, aliases) => {
-  if (csnElement.keys) {
-    return _foreignToOn(csnElement, path, aliases)
-  }
-
-  return _args(csnElement, path, aliases)
-}
-
-const getOnCond = (csnElement, path = [], aliases = { select: '', join: '' }) => {
-  const onCond = _newOnConditions(csnElement, path, aliases)
-  return [{ xpr: onCond }]
-}
-
-module.exports = { getOnCond }

package/libx/_runtime/common/utils/onlyKeysRemain.js

@@ -1,10 +0,0 @@
-module.exports = req => {
-  // if custom handlers uses only expression like {col: {'+=': 1}},
-  // req.data will only contain the keys
-  if (req.query.UPDATE.with && Object.keys(req.query.UPDATE.with).length > 0) {
-    return false
-  }
-
-  const keys = Object.keys(req.target.keys || {})
-  return !Object.keys(req.data).some(k => !keys.includes(k))
-}

package/libx/_runtime/common/utils/path.js

@@ -1,20 +0,0 @@
-const { ensureNoDraftsSuffix } = require('./draft')
-
-/*
- * returns the target entity for the given path
- */
-const getEntityFromPath = (path, def) => {
-  let current = def.definitions ? { elements: def.definitions } : def
-
-  let id
-  for (const segment of path.ref) {
-    id = ensureNoDraftsSuffix(segment.id || segment)
-    current = current?.elements[id] || current
-    if (current && current.target) current = current._target
-  }
-  return current
-}
-
-module.exports = {
-  getEntityFromPath
-}

package/libx/_runtime/common/utils/quotingStyles.js

@@ -1,29 +0,0 @@
-const cds = require('../../cds')
-
-const { smartId } = cds.compiler.to.sql
-
-let _dialect
-
-const _isQuoted = s => s.match(/^".*"$/)
-const _slugify = s => s.replace(/\./g, '_')
-const _smartId = s => smartId(_slugify(s), _dialect || 'plain')
-
-module.exports = {
-  plain: s => {
-    // set _dialect and _reserved once cds.db.kind is set
-    if (!_dialect && cds.db && cds.db.kind) {
-      _dialect = cds.db.options.dialect || cds.db.kind
-    }
-
-    if (typeof s !== 'string') throw new Error(`string expected but ${typeof s} received`)
-
-    // * or already quoted?
-    if (s === '*' || _isQuoted(s)) return s
-
-    return _smartId(s)
-  },
-  quoted: s => `"${s}"`,
-  bracketed: s => `[${s}]`,
-  'all-upper': s => `"${_slugify(s.toUpperCase())}"`,
-  'all-lower': s => `"${_slugify(s.toLowerCase())}"`
-}

package/libx/_runtime/common/utils/restrictions.js

@@ -1,67 +0,0 @@
-// CLEANUP: This is only used in our Okra-based stuff now -> should move over there
-const cds = require('../../cds')
-
-const $cache = Symbol('service contains any restrictions cache')
-
-/** @param {import('../../../../lib/srv/cds.Service')} srv */
-const containsAnyRestrictions = srv => {
-  let { model } = srv
-  if (srv.isExtensible) model = cds.context?.model || srv.model // REVISIT: extensions are not allowed to add or change restrictions, are they?
-
-  if (!model[$cache]) model[$cache] = new Map() // REVIST: reuse model._cached instead of introducing a separate one
-  const cache = model[$cache]
-
-  if (cache.has(srv.name)) return cache.get(srv.name)
-
-  cache.set(srv.name, false)
-
-  const accessRestrictions = getAccessRestrictions(model.definitions[srv.definition.name])
-  if (accessRestrictions.length > 1 || accessRestrictions[0] !== 'any') {
-    cache.set(srv.name, true)
-  } else {
-    // REVISIT: Use srv.definiton.entities instead
-    const entities = Object.keys(model.definitions).filter(k => {
-      const d = model.definitions[k]
-      return d.kind === 'entity' && d.name.startsWith(srv.definition.name + '.')
-    })
-    // REVISIT: Use srv.definiton.actions instead
-    const operations = Object.keys(model.definitions).filter(k => {
-      const d = model.definitions[k]
-      return (d.kind === 'action' || d.kind === 'function') && d.name.startsWith(srv.definition.name + '.')
-    })
-    // REVISIT: @requires and @restrict on single entities or operations DOES NOT mean that all service is restricted !
-    cache.set(
-      srv.name,
-      !!(
-        entities.some(ek => model.definitions[ek]['@requires'] || model.definitions[ek]['@restrict']) ||
-        entities.some(ek => {
-          const actions = model.definitions[ek].actions
-          actions && Object.keys(actions).some(action => actions[action]['@requires'] || actions[action]['@restrict'])
-        }) ||
-        operations.some(ok => model.definitions[ok]['@requires'] || model.definitions[ok]['@restrict'])
-      )
-    )
-  }
-
-  return cache.get(srv.name)
-}
-
-// REVISIT: this is the legacy variant of HttpAdapter.early_access_check4, isn't it?
-const getAccessRestrictions = srv => {
-  const srvDefinition = srv.definition || srv
-
-  let restrictions = srvDefinition['@restrict'] || srvDefinition['@requires']
-  if (restrictions) {
-    if (typeof restrictions === 'string') return [restrictions]
-    return restrictions.map(r => r.to || r).flat()
-  } else {
-    if (cds.env.requires.auth.restrict_all_services === false) return ['any']
-    if (process.env.NODE_ENV !== 'production') return ['any']
-    return ['authenticated-user']
-  }
-}
-
-module.exports = {
-  containsAnyRestrictions,
-  getAccessRestrictions
-}

package/libx/_runtime/common/utils/search2cqn4sql.js

@@ -1,37 +0,0 @@
-const { computeColumnsToBeSearched } = require('./columns')
-const searchToLike = require('./searchToLike')
-const { getEntityNameFromCQN } = require('./entityFromCqn')
-
-const _targetFrom = (cqn, options) => {
-  if (options && options.entityName) return options
-  return getEntityNameFromCQN(cqn)
-}
-
-// convert $search system query option to WHERE/HAVING clause using
-// the operator LIKE or CONTAINS
-const search2cqn4sql = (query, model, options = {}) => {
-  const cqnSearchPhrase = query.SELECT.search
-  if (!cqnSearchPhrase) return
-
-  const { search2cqn4sql } = options
-  const { entityName, alias } = _targetFrom(query.SELECT.from, options)
-  const entity = model.definitions[entityName]
-  const aggregated = query._aggregated || /* new parser */ query.SELECT.groupBy
-
-  // Call custom (optimized search to cqn for sql implementation) that tries
-  // to optimize the search behavior for a specific database service.
-  if (typeof search2cqn4sql === 'function' && entity?.associations?.localized && !aggregated) {
-    const search2cqnOptions = { columns: computeColumnsToBeSearched(query, entity), locale: options.locale }
-    return search2cqn4sql(query, entity, search2cqnOptions)
-  }
-
-  const columnsToBeSearched = computeColumnsToBeSearched(query, entity, alias)
-  const expression = columnsToBeSearched?.length
-    ? searchToLike(cqnSearchPhrase, columnsToBeSearched)
-    : [{ val: '0' }, '=', { val: '1' }]
-
-  // REVISIT: find out here if where or having must be used
-  aggregated ? query.having(expression) : query.where(expression)
-}
-
-module.exports = search2cqn4sql

package/libx/_runtime/common/utils/searchToLike.js

@@ -1,56 +0,0 @@
-const _createLikeComparison = (searchXpr, columns, excludeSearch) => {
-  const likeExpression = { xpr: [] }
-
-  columns.forEach((column, index, columns) => {
-    // if negated search, we need to add is null check
-    let currentExpression = likeExpression
-    if (excludeSearch) {
-      currentExpression = { xpr: [column, 'IS NULL', 'OR'] }
-    }
-
-    const searchStringEscaped = searchXpr.val.toLowerCase().replace(/(\^|_|%)/g, '^$1')
-
-    currentExpression.xpr.push(
-      { func: 'lower', args: [column] },
-      excludeSearch ? 'NOT LIKE' : 'LIKE',
-      { val: `%${searchStringEscaped}%` },
-      'ESCAPE',
-      "'^'"
-    )
-
-    if (excludeSearch) {
-      likeExpression.xpr.push(currentExpression)
-    }
-
-    if (index !== columns.length - 1) {
-      likeExpression.xpr.push(excludeSearch ? 'AND' : 'OR')
-    }
-  })
-
-  return likeExpression
-}
-
-// Computes a LIKE expression for a search query.
-const searchToLike = (cqnSearchPhrase, columns, expression = []) => {
-  cqnSearchPhrase.forEach((element, index) => {
-    if (element === 'not') return
-
-    if (element === 'or' || element === 'and') {
-      expression.push(element)
-      return
-    }
-
-    if (element.xpr) {
-      expression.push({ xpr: searchToLike(element.xpr, columns) })
-      return
-    }
-
-    const excludeSearch = cqnSearchPhrase[index - 1] === 'not'
-    const likeComparison = _createLikeComparison(element, columns, excludeSearch)
-    expression.push(likeComparison)
-  })
-
-  return expression
-}
-
-module.exports = searchToLike

package/libx/_runtime/common/utils/stream.js

@@ -1,103 +0,0 @@
-const cds = require('../../cds')
-const LOG = cds.log('odata')
-const { SELECT } = cds.ql
-const { deepCopy } = require('./copy')
-
-const _getStreamProperties = (req, query) => {
-  // new odata parser sets streaming property in SELECT.from
-  const ref = (query.SELECT.columns && query.SELECT.columns[0].ref) || query.SELECT.from.ref
-  const propertyName = ref[ref.length - 1]
-  let mediaTypeProperty
-  for (let key in req.target.elements) {
-    const val = req.target.elements[key]
-    if (val['@Core.MediaType'] && val.name === propertyName) {
-      mediaTypeProperty = val
-      break
-    }
-  }
-
-  // REVISIT: workaround for read after write
-  // if (!mediaTypeProperty) return {}
-
-  let contentType, contentDispositionFilename
-  const columns = []
-  if (typeof mediaTypeProperty['@Core.MediaType'] === 'object') {
-    let contentTypeProperty = mediaTypeProperty['@Core.MediaType']['='].replaceAll(/\./g, '_')
-    if (!req.target.elements[contentTypeProperty]) {
-      LOG._warn &&
-        LOG.warn(
-          `@Core.MediaType in entity "${req.target.name}" points to property "${contentTypeProperty}" which was renamed or is not part of the projection. You must update the annotation value.`
-        )
-      const mapping = cds.ql.resolve.transitions(req.query, cds.db).mapping
-      const key = [...mapping.entries()].find(({ 1: val }) => val.ref[0] === contentTypeProperty)
-      contentTypeProperty = key && key.length && key[0]
-    }
-    if (!req.target.elements[contentTypeProperty]) {
-      LOG._warn && LOG.warn(`MediaType ${contentTypeProperty} not found in entity "${req.target.name}".`)
-    } else {
-      columns.push({ ref: [contentTypeProperty], as: 'contentType' })
-    }
-  } else {
-    contentType = mediaTypeProperty['@Core.MediaType']
-  }
-  if (mediaTypeProperty['@Core.ContentDisposition.Filename']) {
-    if (typeof mediaTypeProperty['@Core.ContentDisposition.Filename'] === 'object') {
-      let contentDispositionProperty = mediaTypeProperty['@Core.ContentDisposition.Filename']['='].replaceAll(
-        /\./g,
-        '_'
-      )
-      if (!req.target.elements[contentDispositionProperty]) {
-        LOG._warn &&
-          LOG.warn(
-            `@Core.ContentDisposition.Filename in entity "${req.target.name}" points to property "${contentDispositionProperty}" which was renamed or is not part of the projection. You must update the annotation value.`
-          )
-        const mapping = cds.ql.resolve.transitions(req.query, cds.db).mapping
-        const key = [...mapping.entries()].find(({ 1: val }) => val.ref[0] === contentDispositionProperty)
-        contentDispositionProperty = key && key.length && key[0]
-      }
-      if (!req.target.elements[contentDispositionProperty]) {
-        LOG._warn &&
-          LOG.warn(`ContentDisposition ${contentDispositionProperty} not found in entity "${req.target.name}".`)
-      } else {
-        columns.push({ ref: [contentDispositionProperty], as: 'contentDispositionFilename' })
-      }
-    } else {
-      contentDispositionFilename = mediaTypeProperty['@Core.ContentDisposition.Filename']
-    }
-  }
-  const contentDispositionType = mediaTypeProperty['@Core.ContentDisposition.Type']
-
-  if (columns.length && cds.db && !req.target._hasPersistenceSkip) {
-    // used cloned path
-    let select = SELECT.one.from({ ref: deepCopy(query.SELECT.from.ref), as: query.SELECT.from.as }).columns(columns)
-    if (query.SELECT.where?.length) select.SELECT.where = query.SELECT.where
-
-    return cds
-      .tx(req)
-      .run(select)
-      .then(res => ({
-        contentType: (res && res.contentType) || contentType,
-        contentDispositionFilename: (res && res.contentDispositionFilename) || contentDispositionFilename,
-        contentDispositionType
-      }))
-  }
-
-  return Promise.resolve({ contentType, contentDispositionFilename, contentDispositionType })
-}
-
-const enhanceStreamResult = async (req, query, result, model) => {
-  if (result.$mediaContentType || result.$mediaContentDispositionFilename || result.$mediaContentDispositionType) return
-
-  const { contentType, contentDispositionFilename, contentDispositionType } = await _getStreamProperties(
-    req,
-    query,
-    model
-  )
-  if (contentType) result.$mediaContentType = contentType
-  if (contentDispositionFilename) {
-    result.$mediaContentDispositionFilename = contentDispositionFilename
-    if (contentDispositionType) result.$mediaContentDispositionType = contentDispositionType
-  }
-}
-
-module.exports = { enhanceStreamResult }

package/libx/_runtime/common/utils/ucsn.js

@@ -1,119 +0,0 @@
-const cds = require('../../cds')
-const getError = require('../error')
-const getTemplate = require('./template')
-const IS_PROXY = Symbol('flat2structProxy')
-
-const proxifyIfFlattened = (definition, payload) => {
-  if (!definition || !definition._flat2struct || payload == null || payload[IS_PROXY]) return payload
-  return Object.setPrototypeOf(
-    payload,
-    new Proxy(
-      {},
-      {
-        get: function (_, k, cur) {
-          if (k === IS_PROXY) return true
-          if (!definition._flat2struct[k]) return Reflect.get(...arguments)
-          const segments = definition._flat2struct[k]
-          for (let i = 0; i < segments.length - 1; i++) {
-            cur = cur[segments[i]]
-            if (!cur) return cur
-          }
-          return cur[segments[segments.length - 1]]
-        },
-        set: function (_, k, v, o) {
-          let cur = o
-          if (definition._flat2struct[k]) {
-            const segments = definition._flat2struct[k]
-            for (let i = 0; i < segments.length - 1; i++) {
-              if (!cur[segments[i]]) {
-                cur[segments[i]] = {}
-              }
-              cur = cur[segments[i]]
-            }
-            cur[segments[segments.length - 1]] = v
-          } else if (k === IS_PROXY) {
-            // do nothing
-          } else {
-            Reflect.set(...arguments)
-          }
-          return o
-        }
-      }
-    )
-  )
-}
-
-const _picker = element => {
-  if (Array.isArray(element)) return { category: 'flat leaf' }
-  if (element.isAssociation) return { category: 'node' }
-}
-
-const _processor = ({ row, key, plain: { category }, element }) => {
-  if (!(key in row)) return
-  if (category === 'node') {
-    row[key] = Array.isArray(row[key])
-      ? row[key].map(data => proxifyIfFlattened(element._target, data))
-      : proxifyIfFlattened(element._target, row[key])
-  } else if (category === 'flat leaf') {
-    const data = row[key]
-    delete row[key]
-    row[key] = data
-  }
-}
-
-const _cleanup = (row, definition, cleanupNull, cleanupStruct, errors, prefix = []) => {
-  if (!row || !definition) return
-  const elements = definition.elements || definition.params
-  for (const key of Object.keys(row)) {
-    if (definition['@open']) continue
-    const element = elements[key] || (cleanupStruct && elements[`${prefix.join('_')}_${key}`])
-    if (!element) {
-      if (cleanupStruct && typeof row[key] === 'object' && !Array.isArray(row[key])) {
-        _cleanup(row[key], definition, cleanupNull, cleanupStruct, errors, [...prefix, key])
-      } else {
-        if (errors) {
-          errors.push(getError(400, `Property "${key}" does not exist in ${definition.name}`))
-        }
-        delete row[key]
-      }
-      continue
-    }
-    if (!row[key]) continue
-    if (element.isAssociation) {
-      if (element.is2many) {
-        for (const r of row[key]) {
-          _cleanup(r, element._target, cleanupNull, cleanupStruct, errors, [])
-        }
-      } else {
-        _cleanup(row[key], element._target, cleanupNull, cleanupStruct, errors, [])
-      }
-    } else if (element.elements) {
-      _cleanup(row[key], element, cleanupNull, cleanupStruct, errors, prefix)
-      if (!Object.keys(row).length) {
-        delete row[key]
-      }
-      if (cleanupNull && Object.values(row[key]).every(v => v == null)) row[key] = null
-    }
-  }
-}
-
-// REVISIT: when needed?
-function convertStructured(service, definition, data, { cleanupNull = false, cleanupStruct = false, errors } = {}) {
-  if (!definition) return
-  // REVISIT check `structs` mode only for now as uCSN is not yet available
-  const flatAccess = cds.env.features.compat_flat_access
-  const template = getTemplate('universal-input', service, definition, { pick: _picker, flatAccess })
-  const arrayData = Array.isArray(data) ? data : [data]
-  if (template && template.elements.size) {
-    const _data = arrayData.map(d => proxifyIfFlattened(definition, d))
-    template.process(_data, _processor)
-  }
-  for (const row of arrayData) {
-    _cleanup(row, definition, cleanupNull, cleanupStruct, errors)
-  }
-}
-
-module.exports = {
-  convertStructured,
-  proxifyIfFlattened
-}

package/libx/_runtime/common/utils/union.js

@@ -1,31 +0,0 @@
-const CQN_TEMPLATE_STRING = JSON.stringify(require('./unionCqnTemplate'))
-
-function getCQNUnionFrom(columns, active, draft, keys, user) {
-  let cqn = CQN_TEMPLATE_STRING
-
-  const activeCols = []
-  const draftCols = []
-  for (const col of columns) {
-    activeCols.push(`{ "ref": ["${col}"] }`)
-    draftCols.push(`{ "ref": ["${draft}", "${col}"] }`)
-  }
-  cqn = cqn.replace(/"%%ACTIVE_COLUMNS%%"/g, activeCols.join(', '))
-  cqn = cqn.replace(/"%%DRAFT_COLUMNS%%"/g, draftCols.join(', '))
-
-  cqn = cqn.replace(/%%ACTIVE%%/g, active)
-  cqn = cqn.replace(/%%DRAFT%%/g, draft)
-
-  const keyCondition = []
-  for (const key of keys) {
-    keyCondition.push(`{ "ref": ["${active}", "${key}"] }, "=", { "ref": ["${draft}", "${key}"] }`)
-  }
-  cqn = cqn.replace(/"%%KEYS%%"/g, keyCondition.join(', "and", '))
-
-  cqn = cqn.replace(/%%USER%%/g, user)
-
-  return JSON.parse(cqn)
-}
-
-module.exports = {
-  getCQNUnionFrom
-}