@sap/cds 5.8.4 → 5.9.2

package/libx/_runtime/db/utils/normalizeTimeData.js

@@ -4,7 +4,7 @@ const { ensureNoDraftsSuffix } = require('../../common/utils/draft.js')
 
 const _convertDateTimeElement = (value, element) => {
   value = new Date(value).toISOString()
-  if (element.type === 'cds.DateTime') value = value.replace(/\.\d\d\d/, '')
+  if (element._type === 'cds.DateTime') value = value.replace(/\.\d\d\d/, '')
   return value
 }
 
@@ -38,7 +38,7 @@ const _convertColumns = (data, elements, model, queryColumns) => {
   // check all columns
   for (let i = 0, length = queryColumns.length; i < length; i++) {
     const col = queryColumns[i]
-    if (elements[col] && _isToConvert(elements[col].type)) {
+    if (elements[col] && _isToConvert(elements[col]._type)) {
       const dataArray = Array.isArray(data[0]) ? data : [data]
       for (const d of dataArray) {
         const elementValue = d[i]

package/libx/_runtime/db/utils/propagateForeignKeys.js

@@ -1,6 +1,8 @@
 const cds = require('../../cds')
 
-const _autoGenerate = e => e && e.type === 'cds.UUID' && e.key
+const { prefixForStruct } = require('../../common/utils/csn')
+
+const _autoGenerate = e => e && e.isUUID && e.key
 
 const _generateParentField = ({ parentElement }, row) => {
   if (_autoGenerate(parentElement) && !row[parentElement.name]) {
@@ -19,6 +21,7 @@ const _generateChildField = ({ deep, childElement }, childRow) => {
 const _getNestedVal = (row, prefix) => {
   let val = row
   const splitted = prefix.split('_')
+  splitted.pop() // remove last `_`
   let k = ''
 
   while (splitted.length > 0) {
@@ -34,9 +37,10 @@ const _getNestedVal = (row, prefix) => {
   return val
 }
 
-const _propagateToChid = ({ parentElement, childElement, prefix, parentFieldValue }, row, childRow) => {
+const _propagateToChid = ({ parentElement, childElement, parentFieldValue }, row, childRow) => {
   if (!childElement) return
   if (parentElement) {
+    const prefix = prefixForStruct(parentElement)
     if (prefix) {
       const nested = _getNestedVal(row, prefix)
       childRow[childElement.name] = nested[parentElement.name]

package/libx/_runtime/extensibility/mps/index.js

@@ -0,0 +1,5 @@
+const cds = require('../../cds')
+if (cds.requires.db && !(cds.model && 'cds_r.ModelProviderService' in cds.model.definitions)) {
+  const model = require('path').join(__dirname, '../../../..', 'srv/mps.cds')
+  module.exports = cds.serve(model, { silent: true }).in(cds.app)
+}

package/libx/_runtime/extensibility/mps/service.js

@@ -0,0 +1,111 @@
+const fs = require('fs')
+const path = require('path')
+
+const cds = require('../../cds')
+const { exists } = require('./utils')
+const { supplementaryFiles } = require('./tar')
+
+const { BASE_TENANT } = require('../../common/utils/extensibilityUtils')
+
+const _getAllFeatures = async function () {
+  const features = path.join(global.cds.root, 'fts')
+  if (await exists(features)) {
+    return (await fs.promises.readdir(features, { withFileTypes: true })).map(dir => path.join(features, dir.name))
+  }
+
+  return []
+}
+
+const _addExtensions = async function (csn, tenant) {
+  const rs = await cds.tx({ tenant }, tx => tx.run(SELECT.from('cds_r.Extensions')))
+
+  if (rs.length !== 0) {
+    const extensions = []
+    const definitions = {}
+    rs.forEach(row => {
+      const csn = JSON.parse(row.csn)
+      if (csn.extensions) extensions.push(...csn.extensions)
+      if (csn.definitions) {
+        Object.keys(csn.definitions).forEach(key => {
+          definitions[key] = csn.definitions[key]
+        })
+      }
+    })
+    const extCsn = cds.compile({
+      'base.csn': cds.compile.to.json(csn),
+      'ext.csn': cds.compile.to.json({ extensions, definitions })
+    })
+    // Sources are used to load resources like i18n
+    extCsn.$sources = csn.$sources
+    extCsn.$location = csn.$location
+
+    return extCsn
+  }
+
+  return csn
+}
+
+const _isExtended = async function (req) {
+  const rs = await cds.tx({ tenant: req.data.tenant }, tx => tx.run('SELECT * from cds_r_Extensions'))
+  return rs.length !== 0
+}
+
+const _csn4 = async function (req, _flavor) {
+  let { tenant, toggles, flavor = _flavor } = req.data
+  if (!tenant) tenant = BASE_TENANT
+
+  let features = []
+  // Star is only for deployment - not a valid DwC protocol configuration.
+  if (toggles && toggles.includes('*')) {
+    features = await _getAllFeatures()
+  } else if (toggles) {
+    features = toggles.map(t => path.join(global.cds.root, 'fts', t))
+  }
+
+  let csn = await cds.load(['*', ...features]).then(cds.minify)
+
+  if (cds.requires.extensibility && !(cds.requires.multitenancy && tenant === BASE_TENANT))
+    csn = await _addExtensions(csn, tenant)
+
+  if (flavor) csn = cds.compile.for[flavor](csn)
+
+  return csn
+}
+
+const _edmx4 = async function (req) {
+  const csn = await _csn4(req)
+  const { serviceName, locale, odataFlavor } = req.data
+
+  return cds.localize(csn, locale, cds.compile.to.edmx(csn, { service: serviceName, version: odataFlavor }))
+}
+
+module.exports = function (srv) {
+  srv.on('getCsn', async function (req) {
+    return await _csn4(req)
+  })
+
+  // REVISIT: Replace by getCsn(..., flavor=node/java)
+  srv.on('getOdataCsn', async function (req) {
+    return await _csn4(req, 'java')
+  })
+
+  srv.on('getEdmx', async function (req) {
+    return await _edmx4(req)
+  })
+
+  srv.after('getEdmx', function (result, req, res) {
+    req._.res && req._.res.set('Content-Type', 'application/xml')
+  })
+
+  srv.on('isExtended', async function (req) {
+    return await _isExtended(req)
+  })
+
+  srv.on('getResources', async function (req) {
+    return await supplementaryFiles(req)
+  })
+
+  srv.after('getResources', function (_, req) {
+    req._.res && req._.res.set('content-type', 'application/octet-stream; charset=binary')
+  })
+}

package/libx/_runtime/extensibility/mps/tar.js

@@ -0,0 +1,42 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../cds')
+const { TAR_CLI, findCsvFiles, collectCsvFiles, packTarArchive } = require('../../../../lib/utils/resources')
+const { exists } = require('./utils')
+
+// REVISIT: resource folder and file to be defined
+const RESOURCE_FILE = 'to_be_defined/to_be_defined.tgz'
+
+const supplementaryFiles = async req => {
+  // first look for files in the resource folder
+  const resource = path.join(global.cds.root, RESOURCE_FILE)
+  if (await exists(resource)) {
+    return fs.promises.readFile(resource, 'binary')
+  }
+
+  // check if collected in sdc folder
+  // REVISIT: to be deleted
+  let files
+  const sdc = path.join(global.cds.root, 'sdc')
+  if (await exists(sdc)) {
+    files = await findCsvFiles(sdc, true)
+  }
+
+  // if not collected, then collect
+  if (!files || !files.length) {
+    const features = (cds.env.features && cds.env.features.folders) || 'fts/*'
+    const csn = await cds.load(['*', features])
+    files = await collectCsvFiles(csn.$sources)
+  }
+
+  if (!files.length) {
+    req.reject(404)
+  }
+
+  return await packTarArchive(files, global.cds.root, req.data.flat, TAR_CLI)
+}
+
+module.exports = {
+  TAR_CLI,
+  supplementaryFiles
+}

package/libx/_runtime/extensibility/mps/utils.js

@@ -0,0 +1,11 @@
+const fs = require('fs')
+
+const exists = async fileOrDir => {
+  try {
+    return await fs.promises.stat(fileOrDir)
+  } catch (_) {
+    return false
+  }
+}
+
+module.exports = { exists }

package/libx/_runtime/{fiori → extensibility}/uiflex/handler/transformRESULT.js

@@ -7,15 +7,27 @@ const _pick = element => {
   return element['@cds.extension']
 }
 
+// The problem here are the extended columss, which are in SELECT.column, but not in the backpack.
+// Otherwise all backpack values could be inserted for row at once.
 const _processorFn = ({ row, key }) => {
   if (row[EXT_BACK_PACK]) {
     const extensions = JSON.parse(row[EXT_BACK_PACK])
-    Object.keys(extensions).forEach(field => {
-      row[field] = extensions[field]
-    })
-
-    delete row[EXT_BACK_PACK]
+    if (extensions[key]) {
+      row[key] = extensions[key]
+      delete extensions[key]
+      if (Object.keys(extensions).length === 0) {
+        delete row[EXT_BACK_PACK]
+      } else {
+        row[EXT_BACK_PACK] = JSON.stringify(extensions)
+      }
+
+      return
+    }
   }
+
+  // Extended fields are not in SELECT.columns.
+  // Workaround for fields not from backpack: provide them all
+  row[key] = null
 }
 
 function transformExtendedFieldsRESULT(result, req) {

package/libx/_runtime/{fiori → extensibility}/uiflex/handler/transformWRITE.js

@@ -22,6 +22,7 @@ const _processorFn = ({ row, key }) => {
 
 function transformExtendedFieldsCREATE(req) {
   if (!req.target) return
+  if (!req.query.INSERT.entries) return // REVISIT: breaks at cds.deploy -> should anyways not kick in during cds.deploy
 
   const target = getTargetWrite(req.target, this.model)
   const template = getTemplate('transform-write', this, target, { pick: _pick })

package/libx/_runtime/extensibility/uiflex/index.js

@@ -0,0 +1,54 @@
+module.exports = (async () => {
+  const cds = require('../../cds')
+  const path = require('path')
+
+  if (!cds.requires.db) return
+  if (cds.db) return // avoid duplicates
+
+  // do not add extensions in case of multitenancy
+  if (!cds.requires.multitenancy) {
+    // add extensions
+    if (cds.requires.db.credentials && cds.requires.db.credentials.database !== ':memory:') {
+      const db = await cds.connect.to({ ...cds.requires.db, model: null, silent: true })
+      const rs = await db.read('cds_r.Extensions')
+      if (rs.length !== 0) {
+        const extensions = []
+        rs.forEach(row => extensions.push(...JSON.parse(row.csn).extensions))
+        cds.once('loaded', csn => {
+          if (cds.model) return // extend cds.model only
+          const extended = cds.compile({
+            'base.csn': cds.compile.to.json(csn),
+            'ext.csn': cds.compile.to.json({ extensions })
+          })
+          csn.definitions = extended.definitions
+        })
+      }
+      await db.disconnect()
+    }
+
+    cds.on('connect', async srv => {
+      if (srv.name !== 'db') return
+
+      // deploy in case of in-memory
+      if (cds.requires.db.credentials && cds.requires.db.credentials.database === ':memory:') {
+        const mf = await cds.load(path.join(__dirname, '../../../..', 'srv/flex.cds'))
+        await cds.deploy(mf).to(srv)
+      }
+    })
+  }
+
+  cds.once('served', async () => {
+    const { transformExtendedFieldsCREATE, transformExtendedFieldsUPDATE } = require('./handler/transformWRITE')
+    const { transformExtendedFieldsREAD } = require('./handler/transformREAD')
+    const { transformExtendedFieldsRESULT } = require('./handler/transformRESULT')
+    cds.db
+      .before('CREATE', transformExtendedFieldsCREATE)
+      .before('UPDATE', transformExtendedFieldsUPDATE)
+      .before('READ', transformExtendedFieldsREAD)
+      .after('READ', transformExtendedFieldsRESULT)
+    if ('cds_r.ExtensibilityService' in cds.services) return
+    await require('../mps')
+    const model = require('path').join(__dirname, '../../../..', 'srv/flex.cds')
+    return cds.serve(model, { silent: true }).in(cds.app)
+  })
+})()

package/libx/_runtime/extensibility/uiflex/service.js

@@ -0,0 +1,276 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../cds')
+const { ensureDraftsSuffix } = require('../../common/utils/draft')
+const { BASE_TENANT, channelName } = require('../../common/utils/extensibilityUtils')
+const { EXT_BACK_PACK } = require('./utils')
+const TMP_DIR = fs.realpathSync(require('os').tmpdir())
+
+const _getDraftTable = view => {
+  return cds.model.definitions[view]._isDraftEnabled ? ensureDraftsSuffix(view) : undefined
+}
+
+const _addAnnotation = extension => {
+  Object.values(extension.elements).forEach(el => {
+    el['@cds.extension'] = true
+  })
+}
+
+const _isProjection = target => target && target.query && target.query._target
+
+const _resolveViews = (target, views_ = []) => {
+  if (_isProjection(target)) {
+    views_.push(target)
+    return _resolveViews(target.query._target, views_)
+  }
+
+  return target
+}
+
+const _getCsn = req => {
+  const csn = {
+    extensions: req.data.extensions.map(ext => JSON.parse(ext))
+  }
+
+  return csn
+}
+
+const _addViews = csn => {
+  csn.extensions.forEach(extension => {
+    const target = cds.model.definitions[extension.extend]
+    const views_ = []
+    const view = _resolveViews(target, views_)
+    extension.extend = view && view.name
+    _addAnnotation(extension)
+
+    // All projection views leading to the db entity are extended with back pack in case view columns are explicitly listed.
+    // The views using projections with '*' obtain the back pack automatically.
+    views_.forEach(view => {
+      if (!view.projection || (view.projection.columns && !view.projection.columns.some(col => col === '*'))) {
+        csn.extensions.push({
+          extend: view.name,
+          columns: Object.keys(extension.elements).map(key => {
+            return { ref: [key] }
+          })
+        })
+      }
+    })
+  })
+}
+
+const _needsQuotations = t => t instanceof cds.builtin.classes.string || t instanceof cds.builtin.classes.date
+
+const _handleDefaults = async (extension, dbEntity, draftEntity) => {
+  const ext = Object.keys(extension.elements)
+    .filter(key => extension.elements[key].default)
+    .map(key => {
+      const element = extension.elements[key]
+      // .type as ui flex extensions are not linked
+      const t = cds.model.definitions[element.type] || cds.builtin.types[element.type]
+      const value = t && _needsQuotations(t) ? `"${element.default.val}"` : element.default.val
+      return `"${key}":${value}`
+    })
+
+  if (ext.length !== 0) {
+    const extStr = ext.join(',')
+    const changed = `'{${extStr},' || substr(${EXT_BACK_PACK}, 2, length(${EXT_BACK_PACK})-1)`
+    const assign = `${EXT_BACK_PACK} = CASE WHEN ${EXT_BACK_PACK} IS NULL THEN '{${extStr}}' ELSE ${changed} END`
+    await UPDATE(dbEntity).with(assign)
+    if (draftEntity) await UPDATE(draftEntity).with(assign)
+  }
+}
+
+const _validateCsn = (csn, req) => {
+  if (!csn) req.reject(400, 'Missing extension')
+  if (!csn.extensions) return
+
+  csn.extensions.forEach(extension => {
+    if (!extension.extend || !cds.model.definitions[extension.extend]) {
+      req.reject(400, 'Invalid extension. Parameter "extend" missing or malformed')
+    }
+
+    if (!extension.elements) {
+      req.reject(400, 'Invalid extension. Missing parameter "elements"')
+    }
+  })
+}
+
+const _validateExtensionFields = (csn, req) => {
+  if (!csn.extensions) return
+
+  csn.extensions.forEach(extension => {
+    if (extension.elements) {
+      Object.keys(extension.elements).forEach(name => {
+        if (!/^[A-Za-z]\w*$/.test(name)) {
+          req.reject(400, `Invalid extension. Bad element name "${name}"`)
+        }
+
+        if (Object.keys(cds.model.definitions[extension.extend].elements).includes(name)) {
+          req.reject(400, `Invalid extension. Element "${name}" already exists`)
+        }
+      })
+    }
+  })
+}
+
+const _getCompilerError = messages => {
+  const defaultMsg = 'Error while compiling extension'
+  if (!messages) return defaultMsg
+
+  for (const msg of messages) {
+    if (msg.severity === 'Error') return msg.message
+  }
+
+  return defaultMsg
+}
+
+const _validateExtension = async (ext, req) => {
+  try {
+    const { 'cds_r.ModelProviderService': mps } = cds.services
+    const csn = await mps.getCsn(req.tenant, ['*'])
+    const extCsn = cds.compile.to.json(ext)
+    await cds.compile.to.csn({ 'base.csn': JSON.stringify(csn), 'ext.csn': extCsn })
+  } catch (err) {
+    console.trace(err) // eslint-disable-line no-console
+    req.reject(400, _getCompilerError(err.messages))
+  }
+}
+
+const _addExtension = async function (req) {
+  // validate extension
+  const csn = _getCsn(req)
+  _validateCsn(csn, req)
+  await _validateExtensionFields(csn, req)
+  _addViews(csn, cds)
+  await _validateExtension(csn, req)
+
+  // save extension
+  const ID = cds.utils.uuid()
+  await INSERT.into('cds_r.Extensions').entries([{ ID, csn: JSON.stringify(csn), activated: false }])
+
+  // defaults
+  for (const ext of req.data.extensions) {
+    const extension = JSON.parse(ext)
+    const draft = _getDraftTable(extension.extend)
+    const target = cds.model.definitions[extension.extend]
+    const dbEntity = _resolveViews(target).name
+    await _handleDefaults(extension, dbEntity, draft)
+  }
+
+  // update event
+  await this.redis.emit(channelName(), { tenant: req.tenant || BASE_TENANT })
+}
+
+const _activate = async function (req) {
+  // get extensions
+  const rs = await cds.tx({ tenant: req.tenant }, tx => tx.run(SELECT.from('cds_r.Extensions')))
+  rs.forEach(row => {
+    row.csn = row.csn.replace(/,"@cds.extension":true/g, '')
+    row.activated = true
+  })
+
+  // activate
+  const { MultitenancyService: mts } = cds.services
+  await mts.activateExtensions(req.data.tenant)
+
+  // restore extensions
+  await INSERT.into('cds_r.Extensions').entries(rs)
+
+  // update event
+  await this.redis.emit(channelName(), { tenant: req.tenant || BASE_TENANT })
+}
+
+const _exists = async fileOrDir => {
+  try {
+    return await fs.promises.stat(fileOrDir)
+  } catch (_) {
+    return false
+  }
+}
+
+const _compileProject = async function (extension, req) {
+  let csn, root
+  try {
+    root = await fs.promises.mkdtemp(`${TMP_DIR}${path.sep}extension-`)
+    const files = []
+    for (const ext of extension) {
+      if (ext.filename.indexOf('/') > -1) {
+        await fs.promises.mkdir(path.join(root, path.dirname(ext.filename)), { recursive: true })
+      }
+      const file = path.join(root, ext.filename)
+      await fs.promises.writeFile(file, ext.model)
+      files.push(file)
+    }
+    csn = await cds.compile(files, { flavor: 'parsed' })
+    if (csn.requires) delete csn.requires
+  } catch (err) {
+    // req.reject(400, _getCompilerError(err.messages))
+    if (err.messages) req.reject(400, _getCompilerError(err.messages))
+    else {
+      // eslint-disable-next-line no-console
+      console.error(err)
+      throw err
+    }
+  } finally {
+    if (await _exists(root)) {
+      await (fs.promises.rm || fs.promises.rmdir)(root, { recursive: true, force: true })
+    }
+  }
+
+  return csn
+}
+
+const _activateProject = async function (req) {
+  if (req.data.extension.length === 0) return
+
+  const csn = await _compileProject(req.data.extension, req)
+  await _validateExtension(csn, req)
+
+  // keep only extension to be activated
+  const ID = cds.utils.uuid()
+  let activated, notActivated
+  await cds.tx({ tenant: req.tenant }, async tx => {
+    activated = await tx.run(SELECT.from('cds_r.Extensions').where({ activated: true }))
+    notActivated = await tx.run(SELECT.from('cds_r.Extensions').where({ activated: false }))
+    await tx.run(DELETE.from('cds_r.Extensions').where({ activated: false }))
+    await tx.run(INSERT.into('cds_r.Extensions').entries([{ ID, csn: JSON.stringify(csn), activated: false }]))
+  })
+
+  // activate
+  const { MultitenancyService: mts } = cds.services
+  await mts.activateExtensions(req.data.tenant)
+
+  // restore extensions
+  await cds.tx({ tenant: req.tenant }, async tx => {
+    const inserted = await tx.run(SELECT.from('cds_r.Extensions').where({ ID }))
+    if (!inserted.length) {
+      if (activated.length !== 0) await tx.run(INSERT.into('cds_r.Extensions').entries(activated))
+      await tx.run(INSERT.into('cds_r.Extensions').entries([{ ID, csn: JSON.stringify(csn), activated: true }]))
+    }
+    if (notActivated.length !== 0) await tx.run(INSERT.into('cds_r.Extensions').entries(notActivated))
+  })
+
+  // default values for not activated extensions
+  for (const na of notActivated) {
+    for (const extension of JSON.parse(na.csn).extensions) {
+      const target = cds.model.definitions[extension.extend]
+      const dbEntity = _resolveViews(target).name
+
+      // only db entities
+      if (target.name !== dbEntity) continue
+
+      const draft = _getDraftTable(extension.extend)
+      await _handleDefaults(extension, dbEntity, draft)
+    }
+  }
+
+  // update event
+  await this.redis.emit(channelName(), { tenant: req.tenant || BASE_TENANT })
+}
+
+module.exports = async function () {
+  this.redis = await cds.connect.to('mtx-messaging')
+  this.on('addExtension', _addExtension)
+  this.on('activate', _activate)
+  this.on('activateProject', _activateProject)
+}

package/libx/_runtime/{fiori → extensibility}/uiflex/utils.js

@@ -24,8 +24,9 @@ const getTargetWrite = (target, model) => {
 }
 
 const isExtendedEntity = (entityName, model) => {
-  // REVISIT: Dass alle unsere und auch custom handlers immer die ensureUnlocalized + ensureNoDraftsSuffix schleife drehen müssen, kann nicht sein
   const entity = model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(entityName))]
+  if (!entity) return false
+
   return entity.elements[EXT_BACK_PACK] || Object.values(entity.elements).some(el => el['@cds.extension'])
 }
 
@@ -41,19 +42,33 @@ const _hasExtendedEntityArgs = (args, model) => {
   })
 }
 
+const _hasExtendedExpand = (columns, targetName, model) => {
+  for (const col of columns) {
+    if (col.ref && col.expand) {
+      const targetNameModel = ensureUnlocalized(ensureNoDraftsSuffix(targetName))
+      const expTargetName = model.definitions[targetNameModel].elements[col.ref[0]].target
+      if (isExtendedEntity(expTargetName, model)) return true
+      _hasExtendedExpand(col.expand, expTargetName, model)
+    }
+  }
+}
+
 const hasExtendedEntity = (req, model) => {
   if (!req.query.SELECT) return false
 
+  if (req.query.SELECT.columns && req.target && _hasExtendedExpand(req.query.SELECT.columns, req.target.name, model)) {
+    return true
+  }
+
   if (req.query.SELECT.from.join) {
-    // join
     return _hasExtendedEntityArgs(req.query.SELECT.from.args, model)
-  } else if (req.target.name.SET) {
-    // union
+  }
+
+  if (req.target.name.SET) {
     return isExtendedEntity(req.target.name.SET.args[0]._target.name, model)
-  } else {
-    // simple select
-    return isExtendedEntity(req.target.name, model)
   }
+
+  return isExtendedEntity(req.target.name, model)
 }
 
 const getExtendedFields = (entityName, model) => {

package/libx/_runtime/fiori/generic/activate.js

@@ -12,7 +12,7 @@ const { readAndDeleteKeywords, isActiveEntityRequested, getKeyData } = require('
 const { isDraftRootEntity } = require('../../fiori/utils/csn')
 const { getColumns } = require('../../cds-services/services/utils/columns')
 
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 const _getRootCQN = (context, requestActiveData) => {
   const keys = filterKeys(context.target.keys)
@@ -30,7 +30,7 @@ const _getExpandSubCqn = (model, parentEntityName, targets, isRoot = true) => {
 
   for (const element of Object.values(parentEntity.elements)) {
     const { name, target, cardinality } = element
-    if (DRAFT_COLUMNS.includes(name)) {
+    if (name in DRAFT_COLUMNS_MAP) {
       continue
     }