@sap/cds 6.6.2 → 6.7.0

package/libx/_runtime/fiori/lean-draft.js

@@ -1,6 +1,7 @@
 const cds = require('../cds'),
   { Object_keys } = cds.utils
 const LOG = cds.log('fiori|drafts')
+const original = Symbol('original')
 
 const DRAFT_ELEMENTS = new Set([
   'IsActiveEntity',
@@ -69,12 +70,14 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
   if (
     !req.query ||
+    req.query.UPSERT || // skip UPSERTs (might have an additional INSERT)
     (!req.query.SELECT && !req.query.INSERT && !req.query.UPDATE && !req.query.DELETE) ||
     req.query._draftParams
   )
     return handle(req)
   const query = _cleansed(req.query, this.model)
-  _cleanseParams(req.params)
+  _cleanseParams(req.params, req.target)
+  if (req.data) _cleanseParams(req.data, req.target)
   const draftParams = query._draftParams
 
   const _newReq = (req, query, draftParams, event) => {
@@ -82,8 +85,11 @@ cds.ApplicationService.prototype.handle = async function (req) {
     query._target = undefined
     query._draftParams = draftParams
     cds.infer(query, this.model.definitions)
+
+    // REVISIT: This is extremely bad. We should be able to just create a copy without such hacks.
     const _req = cds.Request.for(req._) // REVISIT: this causes req._.data of WRITE reqs copied to READ reqs
-    if (query.SELECT) delete _req.data // which we fix here -> but this is an ugly workaround
+    // If we create a `READ` event based on a modifying request, we delete data
+    if (event === 'READ' && req.event !== 'READ') delete _req.data // which we fix here -> but this is an ugly workaround
     _req.query = query
     _req.event =
       event ||
@@ -93,19 +99,28 @@ cds.ApplicationService.prototype.handle = async function (req) {
       (query.DELETE && 'DELETE') ||
       req.event
     _req.target = query._target
+    _req._ = Object.assign({}, req._ || {}) // don't share the same `_` object
     _req._.params = req.params
     _req.params = req.params
     _req._.query = query
     _req._ = req._
-    _req.data = _req.query.UPDATE?.data || _req.query.INSERT?.entries?.[0]
+    _req._isRest = req._isRest
+    _req._isOData = req._isOData
+    _req.isConcurrentResource = req.isConcurrentResource
+    _req.isConditional = req.isConditional
+    _req.validateEtag = req.validateEtag
+    const cqnData = _req.query.UPDATE?.data || _req.query.INSERT?.entries?.[0]
+    if (cqnData) _req.data = cqnData // must point to the same object
 
     // Dirty hack: delegate messages to original request by binding the getter _messages to req
     let proto = req
     let _messagesDescr
     while (proto && !(_messagesDescr = Object.getOwnPropertyDescriptor(proto, '_messages')))
       proto = Object.getPrototypeOf(proto)
-    Object.defineProperty(_req, '_messages', { ..._messagesDescr, get: _messagesDescr.get.bind(req) })
+    if (_messagesDescr)
+      Object.defineProperty(_req, '_messages', { ..._messagesDescr, get: _messagesDescr.get.bind(req) })
 
+    if (req.tx) _req.tx = req.tx
     return _req
   }
 
@@ -196,7 +211,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
     const result = await run(
       HasActiveEntity ? UPDATE(req.target).data(res).where(targetWhere) : INSERT.into(req.target).entries(res)
     )
-    req?._?.odataRes.setStatusCode(201)
+    req?._?.odataRes?.setStatusCode(201)
 
     return Object.assign(result, { IsActiveEntity: true })
 
@@ -252,11 +267,20 @@ cds.ApplicationService.prototype.handle = async function (req) {
       const updateData = { ...req.data }
       delete updateData.IsActiveEntity
       await run(UPDATE({ ref: draftsRef }).data(updateData))
-      return Object.assign(req.data, { IsActiveEntity: false })
+      req.data.IsActiveEntity = false
+      return req.data
     }
   }
 
   if (req.event === 'READ') {
+    if (
+      !Object.keys(draftParams).length &&
+      !req.query._target.name?.endsWith('DraftAdministrativeData') &&
+      !req.query._target.drafts
+    ) {
+      req.query = query
+      return handle(req)
+    }
     const read = req.query._target.name.endsWith('.drafts')
       ? Read.ownDrafts
       : draftParams.IsActiveEntity === false && draftParams.SiblingEntity_IsActiveEntity === null
@@ -281,8 +305,34 @@ cds.ApplicationService.prototype.handle = async function (req) {
     return result
   }
 
-  const _req = _newReq(req, query, draftParams, req.event)
-  const result = await handle(_req)
+  req.query = query
+  const result = await handle(req)
+  return result
+}
+
+// REVISIT: It's not optimal to first calculate the whole result array and only later
+//          delete unrequested properties. However, as a first step, we do it that way,
+//          especially since the current db driver always adds those fields.
+//          Once we switch to the new driver, we'll adapt it.
+const _requested = (result, query) => {
+  const originalQuery = query[original]
+  if (!result || !originalQuery) return result
+  const all = ['HasActiveEntity', 'HasDraftEntity']
+
+  const ignoredCols = new Set(all.concat('DraftAdministrativeData'))
+  const _isODataV2 = cds.context?.http?.req?.headers?.['x-cds-odata-version'] === 'v2'
+  if (!_isODataV2) ignoredCols.add('DraftAdministrativeData_DraftUUID')
+  for (const col of originalQuery.SELECT.columns || ['*']) {
+    const name = col.as || col.ref?.[0] || col
+    if (all.includes(name) || name === 'DraftAdministrativeData' || name === 'DraftAdministrativeData_DraftUUID')
+      ignoredCols.delete(name)
+    if (name === '*') all.forEach(c => ignoredCols.delete(c))
+  }
+  if (!ignoredCols.size) return result
+  const resArray = Array.isArray(result) ? result : [result]
+  for (const row of resArray) {
+    for (const ignoredCol of ignoredCols) delete row[ignoredCol]
+  }
   return result
 }
 
@@ -291,6 +341,13 @@ const Read = {
     LOG.debug('List Editing Status: Only Active')
     // DraftAdministrativeData is only accessible via drafts
     if (query._target.name.endsWith('.DraftAdministrativeData')) return run(query._drafts)
+    if (!query._target._isDraftEnabled) return run(query)
+    if (query.SELECT.columns && !query.SELECT.columns.some(c => c === '*')) {
+      const keys = Object_keys(query._target.keys).filter(k => k !== 'IsActiveEntity')
+      for (const key of keys) {
+        if (!query.SELECT.columns.some(c => c.ref?.[0] === key)) query.SELECT.columns.push({ ref: [key] })
+      }
+    }
     const actives = await run(query)
     if (!actives || (Array.isArray(actives) && !actives.length) || !query._target.drafts) return actives
     let drafts
@@ -313,7 +370,7 @@ const Read = {
             DraftAdministrativeData_DraftUUID: null
           })
     )
-    return actives
+    return _requested(actives, query)
   },
   unchanged: async function (run, query) {
     LOG.debug('List Editing Status: Unchanged')
@@ -328,7 +385,7 @@ const Read = {
     const res = Read.onlyActives(run, query.where(Read.whereNotIn(query._target, drafts)), {
       ignoreDrafts: true
     })
-    return res
+    return _requested(res, query)
   },
   ownDrafts: async function (run, query) {
     LOG.debug('List Editing Status: Own Draft')
@@ -356,11 +413,11 @@ const Read = {
     const drafts = await run(draftsQuery)
     Read.merge(query._target, drafts, [], row =>
       Object.assign(row, {
-        IsActiveEntity: false,
-        HasDraftEntity: false
+        HasDraftEntity: false,
+        IsActiveEntity: false
       })
     )
-    return drafts
+    return _requested(drafts, query)
   },
   all: async function (run, query) {
     LOG.debug('List Editing Status: All')
@@ -391,6 +448,13 @@ const Read = {
       else ownNewDrafts.push(draft)
     }
 
+    // We can't properly calculate `count`:
+    //   - Not all actives are retrieved (e.g. top = 0), hence there could be more deletes if more actives are requested,
+    //     hence we cannot count deletions based on data.
+    //   - We can't rely on the fact that `HasActiveEntity` always has an active counterpart because the filter
+    //     is applied on draft and active data respectively (you could fetch a draft but not an active instance).
+    //     However, there's not much we can do, so we use use this as a best guess.
+
     const count = isFirstPage ? ownNewDrafts.length + (isCount ? actives[0]?.$count : actives.$count) : actives.$count
     if (isCount) return { $count: count }
 
@@ -423,7 +487,7 @@ const Read = {
     })
     const res = isFirstPage ? [...ownNewDrafts, ...ownEditDrafts, ...actives] : actives
     if (query.SELECT.count) res.$count = count
-    return res
+    return _requested(res, query)
   },
   activesFromDrafts: async function (run, query, { isLocked = true }) {
     const draftsQuery = query._drafts
@@ -450,7 +514,7 @@ const Read = {
         ? Object.assign(row, other, { IsActiveEntity: true, HasDraftEntity: true, HasActiveEntity: false })
         : Object.assign({ IsActiveEntity: true, HasDraftEntity: false, HasActiveEntity: false })
     )
-    return actives
+    return _requested(actives, query)
   },
   unsavedChangesByAnotherUser: async function (run, query) {
     LOG.debug('List Editing Status: Unsaved Changes by Another User')
@@ -529,29 +593,33 @@ const Read = {
   }
 }
 
-function _cleanseParams(params) {
+function _cleanseParams(params, target) {
+  if (!target?.drafts) return
   if (Array.isArray(params)) {
-    for (const param of params) _cleanseParams(param)
+    for (const param of params) _cleanseParams(param, target)
     return
   }
   if (typeof params === 'object') {
     for (const key in params) {
-      if (key === 'IsActiveEntity') delete params[key]
+      if (key === 'IsActiveEntity') {
+        const value = params[key]
+        delete params[key]
+        if (cds.env.fiori?.draft_compat) Object.defineProperty(params, key, { value, enumerable: false })
+      }
     }
   }
 }
 
-function _cleanseCols(columns, elements) {
-  if (typeof columns?.filter !== 'function') return columns
-  return (
-    columns &&
-    columns
-      .filter(c => !elements.has(c.ref?.[0]))
-      .map(c => {
-        if (c.expand) return { ...c, expand: _cleanseCols(c.expand, elements) }
-        return c
-      })
-  )
+function _cleanseCols(columns, elements, target) {
+  // TODO: sometimes target is undefined
+  if (!target || typeof columns?.filter !== 'function') return columns
+  const filtered = target?.drafts ? columns.filter(c => !elements.has(c.ref?.[0])) : columns
+  return filtered.map(c => {
+    if (c.expand && c.ref) {
+      return { ...c, expand: _cleanseCols(c.expand, elements, target.elements[c.ref[0]]?._target) }
+    }
+    return c
+  })
 }
 
 /**
@@ -559,10 +627,10 @@ function _cleanseCols(columns, elements) {
  */
 function _cleansed(query, model) {
   const draftParams = {} //> used to collect draft filter criteria
-  const q = _cleanseQuery(query, draftParams)
+  const q = _cleanseQuery(query, draftParams, model)
   if (query.SELECT) {
     const getDrafts = () => {
-      const draftsQuery = _cleanseQuery(query, {}) // could just clone `q` but the latter is ruined by database layer
+      const draftsQuery = _cleanseQuery(query, {}, model) // could just clone `q` but the latter is ruined by database layer
       draftsQuery._target = undefined
       const [root, ...tail] = draftsQuery.SELECT.from.ref
       const draft = model.definitions[root.id || root].drafts
@@ -572,7 +640,7 @@ function _cleansed(query, model) {
       cds.infer(draftsQuery, model.definitions)
       // draftsQuery._target = draftsQuery._target?.drafts || draftsQuery._target
       if (query.SELECT.columns && query._target.drafts)
-        draftsQuery.SELECT.columns = _cleanseCols(query.SELECT.columns, REDUCED_DRAFT_ELEMENTS)
+        draftsQuery.SELECT.columns = _cleanseCols(query.SELECT.columns, REDUCED_DRAFT_ELEMENTS, draft)
 
       if (draftsQuery._target.name.endsWith('.DraftAdministrativeData')) {
         draftsQuery.SELECT.columns = _tweakAdminCols(draftsQuery.SELECT.columns)
@@ -592,21 +660,30 @@ function _cleansed(query, model) {
   }
 
   Object.defineProperty(q, '_draftParams', { value: draftParams, enumerable: false })
+  q[original] = query
   return q
 
-  function _cleanseQuery(query, draftParams) {
+  function _cleanseQuery(query, draftParams, model) {
+    const target = query._target
     const q = cds.ql.clone(query)
 
     const ref = q.SELECT?.from.ref || q.UPDATE?.entity.ref || q.INSERT?.into.ref || q.DELETE?.from.ref
     const cqn = q.SELECT || q.UPDATE || q.INSERT || q.DELETE
 
     if (ref) {
-      const cleansedRef = ref.map(r => (r.where ? { ...r, where: _cleanseWhere(r.where, draftParams) } : r))
+      let entity
+      const cleansedRef = ref.map(r => {
+        entity = (entity && entity.elements[r.id || r]._target) || model.definitions[r.id || r]
+        if (!entity?.drafts) return r
+        return r.where ? { ...r, where: _cleanseWhere(r.where, draftParams) } : r
+      })
       if (q.SELECT) q.SELECT.from = { ...q.SELECT.from, ref: cleansedRef }
       else if (q.DELETE) q.DELETE.from = { ...q.DELETE.from, ref: cleansedRef }
       else if (q.UPDATE) q.UPDATE.entity = { ...q.UPDATE.entity, ref: cleansedRef }
       else if (q.INSERT) q.INSERT.into = { ...q.INSERT.into, ref: cleansedRef }
 
+      // This only works for simple cases of `SiblingEntity`, e.g. `root(ID=1,IsActiveEntity=false)/SiblingEntity`
+      // , check if there are more complicated use cases
       const siblingIdx = cleansedRef.findIndex(r => r === 'SiblingEntity')
       if (siblingIdx !== -1) {
         cleansedRef.splice(siblingIdx, 1)
@@ -614,10 +691,9 @@ function _cleansed(query, model) {
       }
     }
 
-    if (cqn.where) cqn.where = _cleanseWhere(cqn.where, draftParams)
-    if (cqn.columns) cqn.columns = _cleanseCols(q.SELECT.columns, DRAFT_ELEMENTS)
-    if (cqn.orderBy) cqn.orderBy = _cleanseWhere(cqn.orderBy, {})
-
+    if (target.drafts && cqn.where) cqn.where = _cleanseWhere(cqn.where, draftParams)
+    if (target.drafts && cqn.orderBy) cqn.orderBy = _cleanseWhere(cqn.orderBy, {})
+    if (cqn.columns) cqn.columns = _cleanseCols(cqn.columns, DRAFT_ELEMENTS, target)
     return q
   }
 
@@ -740,7 +816,10 @@ function expandStarStar(target, recursion = new Map()) {
 
 async function onNew(req) {
   LOG.debug('new draft')
-  const isRoot = typeof req.query.INSERT.into === 'string'
+  const isRoot = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
+  // Only allowed for pseudo draft roots (entities with this action)
+  if (isRoot && !req.target.actives['@Common.DraftRoot.ActivationAction'])
+    req.reject(403, 'DRAFT_MODIFICATION_ONLY_VIA_ROOT')
   let DraftUUID
   if (isRoot) DraftUUID = cds.utils.uuid()
   else {
@@ -777,10 +856,21 @@ async function onNew(req) {
         })
         .where({ DraftUUID })
 
-  const draftData = Object.assign(
-    { DraftAdministrativeData_DraftUUID: DraftUUID, HasActiveEntity: false },
-    req.query.INSERT.entries[0]
-  )
+  const _assignDraftData = (obj, target) => {
+    const newObj = Object.assign({ DraftAdministrativeData_DraftUUID: DraftUUID, HasActiveEntity: false }, obj)
+    if (!target) return newObj
+
+    // Also support deep insertions
+    for (const key in newObj) {
+      if (typeof newObj[key] === 'object' && target.elements[key]?.isComposition) {
+        newObj[key] = _assignDraftData(newObj[key], target.elements[key]._target)
+      }
+    }
+
+    return newObj
+  }
+
+  const draftData = _assignDraftData(req.query.INSERT.entries[0], req.target)
 
   delete draftData.IsActiveEntity
   const draftCQN = INSERT.into(req.target).entries(draftData)
@@ -794,7 +884,7 @@ async function onEdit(req) {
   LOG.debug('edit active')
   const draftParams = req.query._draftParams
   if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== true) {
-    req.reject(400, 'Action "draftEdit" can only be called on the root entity')
+    req.reject(400, 'Action "draftEdit" can only be called on the root active entity')
   }
   const targetWhere = req.query.SELECT.from.ref[0].where
 
@@ -823,8 +913,10 @@ async function onEdit(req) {
   // prevent service to check for own user
   Object.defineProperty(draftsCheck, '_draftParams', { value: draftParams, enumerable: false })
 
+  const activeCQN = SELECT.one.from(req.target).columns(cols).where(targetWhere).forUpdate({ wait: 0 })
+  activeCQN._suppressLocalization = true // in the future we should be able to just set activeCQN.SELECT.localized = false
   const [res, draft] = await Promise.all([
-    this.run(SELECT.one.from(req.target).columns(cols).where(targetWhere).forUpdate({ wait: 0 })),
+    this.run(activeCQN),
     // no user check must be done here...
     this.run(draftsCheck)
   ])
@@ -862,7 +954,7 @@ async function onEdit(req) {
 
   // REVISIT: we need to use okra API here because it must be set in the batched request
   // status code must be set in handler to allow overriding for FE V2
-  req?._?.odataRes.setStatusCode(201)
+  req?._?.odataRes?.setStatusCode(201)
 
   return { ...res, IsActiveEntity: false } // REVISIT: Flatten?
 }

package/libx/_runtime/hana/execute.js

@@ -225,7 +225,9 @@ function _processExpand(model, dbc, cqn, user, locale, txTimestamp) {
 function executeSelectCQN(model, dbc, query, user, locale, txTimestamp) {
   if (hasExpand(query)) {
     // expand: '**' or '*3' is handled by new impl
-    if (query.SELECT.columns.some(c => c.expand && typeof c.expand === 'string' && /^\*{1}[\d|*]+/.test(c.expand))) {
+    if (
+      query.SELECT.columns.some(c => c.expand && typeof c.expand[0] === 'string' && /^\*{1}[\d|*]+/.test(c.expand[0]))
+    ) {
       return expandV2(model, dbc, query, user, locale, txTimestamp, executeSelectCQN)
     }
     return _processExpand(model, dbc, query, user, locale, txTimestamp)

package/libx/_runtime/hana/pool.js

@@ -1,3 +1,5 @@
+// REVISIT: Remove @sap/instance-manager compat with CDS 7
+
 const cds = require('../cds')
 const LOG = cds.log('pool|db')
 
@@ -15,7 +17,10 @@ function multiTenantServiceManager() {
     if (e.code === 'MODULE_NOT_FOUND') return null
     else throw e
   }
-  return cds.env.requires['cds.xt.DeploymentService']?.['old-instance-manager'] ? null : cds.xt?.serviceManager
+  const oldIm =
+    cds.requires.multitenancy?.['old-instance-manager'] ??
+    cds.env.requires?.['cds.xt.DeploymentService']?.['old-instance-manager']
+  return oldIm ? null : cds.xt?.serviceManager
 }
 
 function multiTenantInstanceManager(config = cds.env.requires.db) {
@@ -78,7 +83,10 @@ async function credentials4(tenant, db) {
       : singleTenantInstanceManager(opts)
   }
 
-  if (cds.xt?.serviceManager && !cds.env.requires['cds.xt.DeploymentService']?.['old-instance-manager']) {
+  const oldIm =
+    cds.requires.multitenancy?.['old-instance-manager'] ??
+    cds.env.requires?.['cds.xt.DeploymentService']?.['old-instance-manager']
+  if (cds.xt?.serviceManager && !oldIm) {
     return (await db._instance_manager.get(tenant, { disableCache: true })).credentials
   }
 

package/libx/_runtime/messaging/common-utils/AMQPClient.js

@@ -31,7 +31,12 @@ const emit = ({ data, event: topic, headers = {} }, stream, prefix, LOG) =>
   new Promise((resolve, reject) => {
     LOG._info && LOG.info('Emit', { topic })
     const message = { ...headers, data }
-    const payload = { chunks: [Buffer.from(JSON.stringify(message))], type: 'application/json' }
+    const payload = {
+      chunks: [Buffer.from(JSON.stringify(message))],
+      type: ['id', 'source', 'specversion', 'type'].every(el => el in headers)
+        ? 'application/cloudevents+json'
+        : 'application/json'
+    }
     const msg = {
       done: resolve,
       failed: e => {

package/libx/_runtime/messaging/enterprise-messaging.js

@@ -82,6 +82,7 @@ class EnterpriseMessaging extends AMQPWebhookMessaging {
 
   // New mtx based on @sap/cds-mtxs
   async addMTXSHandlers() {
+    // REVISIT: Is that tested with MTX services in sidecar?
     const deploymentSrv = await cds.connect.to('cds.xt.DeploymentService')
     const provisioningSrv = await cds.connect.to('cds.xt.SaasProvisioningService')
     deploymentSrv.impl(() => {

package/libx/_runtime/remote/Service.js

@@ -1,19 +1,6 @@
 const cds = require('../cds')
 const LOG = cds.log('remote')
 
-// REVISIT: use cds.log's logger in cloud sdk
-
-// disable sdk logger if not in debug mode
-if (!LOG._debug) {
-  try {
-    // eslint-disable-next-line cds/no-missing-dependencies -- needs to be added by app dev
-    const sdkUtils = require('@sap-cloud-sdk/util')
-    sdkUtils.setGlobalLogLevel('error')
-  } catch (err) {
-    /* might fail in cds repl due to winston's exception handler, see cap/issues#10134 */
-  }
-}
-
 const { resolveView, getTransition, restoreLink, findQueryTarget } = require('../common/utils/resolveView')
 const { postProcess } = require('../common/utils/postProcessing')
 const { getKind, run, getDestination, getAdditionalOptions, getReqOptions } = require('./utils/client')
@@ -165,6 +152,7 @@ const resolvedTargetOfQuery = q => {
   return transitions.length && [transitions.length - 1].target
 }
 let logged
+let sdkLoggerDisabled
 class RemoteService extends cds.Service {
   init() {
     if (!this.options.credentials) {
@@ -186,6 +174,21 @@ class RemoteService extends cds.Service {
           'Configuration option "cds.env.features.fetch_csrf" is deprecated.\n Please use "csrf"/"csrfInBatch" as described in https://cap.cloud.sap/docs/node.js/remote-services'
         )
     }
+
+    // REVISIT: use cds.log's logger in cloud sdk
+
+    // disable sdk logger if not in debug mode
+    if (!LOG._debug && !sdkLoggerDisabled) {
+      try {
+        // eslint-disable-next-line cds/no-missing-dependencies -- needs to be added by app dev
+        const sdkUtils = require('@sap-cloud-sdk/util')
+        sdkUtils.setGlobalLogLevel('error')
+        // disable sdk logger once
+        sdkLoggerDisabled = true
+      } catch (err) {
+        /* might fail in cds repl due to winston's exception handler, see cap/issues#10134 */
+      }
+    }
     // REVISIT: remove cds.env.features.fetch_csrf in next major ^7
     this.csrf = cds.env.features.fetch_csrf || this.options.csrf
     this.csrfInBatch = this.options.csrfInBatch

package/libx/_runtime/remote/utils/client.js

@@ -483,7 +483,12 @@ const getReqOptions = (req, query, service) => {
     for (const k in originalHeaders) if (k.match(/^dwc-/)) reqOptions.headers[k] = originalHeaders[k]
   }
 
-  if (reqOptions.data && reqOptions.method !== 'GET' && reqOptions.method !== 'HEAD') {
+  if (
+    reqOptions.data &&
+    reqOptions.method !== 'GET' &&
+    reqOptions.method !== 'HEAD' &&
+    !(reqOptions.data instanceof require('stream').Readable)
+  ) {
     if (typeof reqOptions.data === 'object' && !Buffer.isBuffer(reqOptions.data)) {
       reqOptions.headers['content-type'] = 'application/json'
       reqOptions.headers['content-length'] = Buffer.byteLength(JSON.stringify(reqOptions.data))

package/libx/_runtime/sqlite/Service.js

@@ -75,8 +75,7 @@ module.exports = class SQLiteDatabase extends DatabaseService {
     this.before(['CREATE', 'UPDATE'], '*', this._input) // > has to run before rewrite
     this.before(['CREATE', 'READ', 'UPDATE', 'DELETE', 'UPSERT'], '*', this._rewrite)
 
-    if (cds.env.features.lean_draft && cds.db?.kind !== 'better-sqlite')
-      this.before('READ', '*', convertDraftAdminPathExpression)
+    if (cds.env.fiori.lean_draft && !cds.db?.cqn2sql) this.before('READ', '*', convertDraftAdminPathExpression)
     this.before('READ', '*', convertAssocToOneManaged)
     this.before('READ', '*', localized) // > has to run after rewrite
     this.before('READ', '*', this._virtual)
@@ -103,6 +102,9 @@ module.exports = class SQLiteDatabase extends DatabaseService {
   }
 
   getDbUrl(tenant) {
+    return this.url4(tenant)
+  }
+  url4(tenant) {
     const credentials = this.options.credentials || this.options || {}
     let dbUrl = credentials.database || credentials.url || credentials.host || ':memory:'
 
@@ -123,7 +125,7 @@ module.exports = class SQLiteDatabase extends DatabaseService {
     const tenant = isMultitenant && arg && (typeof arg === 'string' ? arg : arg.tenant || (arg.user && arg.user.tenant))
     let dbc = this.dbcs.get(tenant)
     if (!dbc) {
-      const dbUrl = this.getDbUrl(tenant)
+      const dbUrl = this.url4(tenant)
 
       dbc = await _new(dbUrl)
 
@@ -152,62 +154,6 @@ module.exports = class SQLiteDatabase extends DatabaseService {
     else dbc._busy = false
   }
 
-  /*
-   * deploy
-   */
-  // REVISIT: make tenant aware
-  async deploy(model, options = {}) {
-    let createEntities = cds.compile.to.sql(model, options)
-    if (createEntities.length === 0) return // > nothing to deploy
-
-    let dropViews = []
-    let dropTables = []
-    for (const each of createEntities) {
-      const [, table, entity] = each.match(/^CREATE (?:(TABLE)|VIEW)\s+"?([^\s"(]+)"?/im) || []
-      if (table) dropTables.push({ DROP: { entity } })
-      else dropViews.push({ DROP: { view: entity } })
-    }
-
-    // H2 is picky on the order
-    dropTables.reverse()
-    dropViews.reverse()
-
-    if (options.dry) {
-      // do not use cds.log() here!
-      const log = console.log // eslint-disable-line no-console
-      for (const {
-        DROP: { view }
-      } of dropViews) {
-        log('DROP VIEW IF EXISTS ' + view + ';')
-      }
-      log()
-      for (const {
-        DROP: { entity }
-      } of dropTables) {
-        log('DROP TABLE IF EXISTS ' + entity + ';')
-      }
-      log()
-      for (const each of createEntities) log(each + '\n')
-      return
-    }
-
-    await this.run(async tx => {
-      // This starts a new transaction if called from CLI, while joining
-      // existing root tx, e.g. when called from DeploymenrService
-      const [ext] = await tx.run(`SELECT 1 from sqlite_master where name='cds_xt_Extensions'`)
-      if (ext) {
-        // Poor man's schema evolution for MTX upgrade operations
-        createEntities = createEntities.filter(ct => !ct.match(/^CREATE TABLE cds_xt_Extensions/im))
-        dropTables = dropTables.filter(dt => dt.DROP.entity !== 'cds_xt_Extensions')
-      }
-      await tx.run(dropViews)
-      await tx.run(dropTables)
-      await tx.run(createEntities)
-    })
-
-    return true
-  }
-
   async disconnect(tenant) {
     this.dbcs.delete(tenant)
   }

package/libx/_runtime/sqlite/convertDraftAdminPathExpression.js

@@ -1,6 +1,7 @@
 const cds = require('../cds')
 
 function sqliteConvertDraftAdminPathExpression(req) {
+  if (req.query?.SELECT?.from?.SET) return // not supported, won't happen in draft
   if (
     !req.query?.SELECT ||
     !req.query?._target?.name?.endsWith('.drafts') ||

package/libx/_runtime/sqlite/customBuilder/CustomUpsertBuilder.js

@@ -31,8 +31,8 @@ class CustomUpsertBuilder extends InsertBuilder {
       if (!keys.includes(col_)) updates.push(`${sqlColumn}=excluded.${sqlColumn}`)
     })
     const conflict = updates.length
-      ? ` ON CONFLICT(${keys}) DO UPDATE SET ` + updates.join(', ')
-      : ` ON CONFLICT(${keys}) DO NOTHING`
+      ? ` ON CONFLICT (${keys}) DO UPDATE SET ` + updates.join(', ')
+      : ` ON CONFLICT (${keys}) DO NOTHING`
 
     this._outputObj.sql = this._outputObj.sql + conflict
     return this._outputObj

package/libx/_runtime/sqlite/execute.js

@@ -109,7 +109,9 @@ function _processExpand(model, dbc, cqn, user, locale, txTimestamp) {
 function executeSelectCQN(model, dbc, query, user, locale, txTimestamp) {
   if (hasExpand(query)) {
     // expand: '**' or '*3' is handled by new impl
-    if (query.SELECT.columns.some(c => c.expand && typeof c.expand === 'string' && /^\*{1}[\d|*]+/.test(c.expand))) {
+    if (
+      query.SELECT.columns.some(c => c.expand && typeof c.expand[0] === 'string' && /^\*{1}[\d|*]+/.test(c.expand[0]))
+    ) {
       return expandV2(model, dbc, query, user, locale, txTimestamp, executeSelectCQN)
     }
     return _processExpand(model, dbc, query, user, locale, txTimestamp)