@sap/cds 6.3.2 → 6.4.1

package/libx/_runtime/hana/pool.js

@@ -7,6 +7,17 @@ const hana = require('./driver')
 const _require = require('../common/utils/require')
 const getError = require('../common/error')
 
+function multiTenantServiceManager() {
+  try {
+    // Make sure cds-mtxs APIs are loaded
+    require('@sap/cds-mtxs/lib') // eslint-disable-line cds/no-missing-dependencies
+  } catch (e) {
+    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
+}
+
 function multiTenantInstanceManager(config = cds.env.requires.db) {
   const { credentials } = config
 
@@ -63,10 +74,14 @@ async function credentials4(tenant, db) {
   if (!db._instance_manager) {
     const opts = db.options && db.options.credentials ? db.options : undefined
     db._instance_manager = cds.requires.multitenancy
-      ? await multiTenantInstanceManager(opts)
+      ? multiTenantServiceManager() ?? (await multiTenantInstanceManager(opts))
       : singleTenantInstanceManager(opts)
   }
 
+  if (cds.xt?.serviceManager && !cds.env.requires['cds.xt.DeploymentService']?.['old-instance-manager']) {
+    return (await db._instance_manager.get(tenant)).credentials
+  }
+
   return new Promise((resolve, reject) => {
     db._instance_manager.get(tenant, (err, res) => {
       if (err) return reject(err)

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

@@ -4,12 +4,13 @@ const _transform = o => ({ subdomain: o.subscribedSubdomain, tenant: o.subscribe
 const getTenantInfo = async tenant => {
   const provisioningServiceName = cds.mtx ? 'ProvisioningService' : 'cds.xt.SaasProvisioningService'
   const primaryKey = cds.mtx ? 'ID' : 'subscribedTenantId'
+  const path = cds.mtx ? 'tenant' : '/tenant' // HACK, otherwise the API doesn't work
 
   const provisioning = await cds.connect.to(provisioningServiceName)
   const tx = provisioning.tx({ user: new cds.User.Privileged() })
   try {
     const result = tenant
-      ? _transform(await tx.get(`tenant`, { [primaryKey]: tenant }))
+      ? _transform(await tx.get(path, { [primaryKey]: tenant }))
       : (await tx.read('tenant')).map(o => _transform(o))
     await tx.commit()
     return result

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

@@ -72,7 +72,7 @@ class EndpointRegistry {
         const tenantId = getTenant(authInfo)
         const other = authInfo
           ? {
-              _: { req: { authInfo, headers: {}, query: {} } }, // for messaging to retrieve subdomain
+              _: { req, res }, // For `cds.context.http`
               tenant: tenantId
             }
           : {}

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

@@ -33,8 +33,7 @@ const _multitenancyEnabled = () => cds.requires.multitenancy || _oldMtx()
 // REVISIT: It's bad to have to rely on the subdomain.
 // For all interactions where we perform the token exchange ourselves,
 // we will be able to use the zoneId instead of the subdomain.
-const _subdomainFromContext = context =>
-  context && context._ && context._.req && context._.req.authInfo && context._.req.authInfo.getSubdomain()
+const _subdomainFromContext = context => context?.http.req?.authInfo?.getSubdomain()
 
 class EnterpriseMessaging extends AMQPWebhookMessaging {
   init() {
@@ -102,7 +101,6 @@ class EnterpriseMessaging extends AMQPWebhookMessaging {
         return res
       })
       deploymentSrv.on('unsubscribe', async (req, next) => {
-        const res = await next()
         const { tenant } = req.data
         let subdomain
         try {
@@ -112,6 +110,7 @@ class EnterpriseMessaging extends AMQPWebhookMessaging {
           this.LOG.error("'unsubscribe' is not yet implemented for @sap/cds-mtxs")
           throw e
         }
+        const res = await next()
         try {
           const management = await this.getManagement(subdomain).waitUntilReady()
           await management.undeploy()

package/libx/_runtime/messaging/outbox/utils.js

@@ -42,29 +42,48 @@ const isUnrecoverable = (service, error) => {
   return unrecoverable || isStandardError(error)
 }
 
-const _processSingleMessage = async (service, message, succeededMessages) => {
-  const msg = _safeJSONParse(message.msg)
-  if (!msg) return
-  const userId = msg[cdsUser]
-  delete msg[cdsUser]
-  // Promise resolve is necessary because we want to set `cds.context` only
-  // inside this call
-  return Promise.resolve().then(async () => {
-    if (userId) cds.context = { user: new cds.User.Privileged(userId) }
+const processDefault = async (messages, { toBeDeleted, toBeUpdated, options, service }) => {
+  /** throws if an emit failed due to a programming error
+   * returns false if an emit failed due to temporary issues **/
+  const run = async ({ ID, process }) => {
     try {
-      service._emitImmediate && (await service._emitImmediate(msg))
-      succeededMessages.push(message.ID)
+      await process()
+      toBeDeleted.push(ID)
     } catch (e) {
-      const failedMessage = {
-        event: msg.event,
-        ID: message.ID,
-        attempts: message.attempts,
-        error: e,
-        unrecoverable: isUnrecoverable(service, e)
+      if (isStandardError(e)) {
+        LOG.error(`${service.name}: Programming error detected:`, e)
+        toBeDeleted.push(ID)
+        throw new Error(`${service.name}: Programming error detected.`)
+      }
+      if (e.unrecoverable) {
+        LOG.error(`${service.name}: Unrecoverable error:`, e)
+        if (options.maxAttempts) {
+          const _msg = { ID, attempts: options.maxAttempts }
+          if (options.storeLastError !== false) _msg.lastError = e
+          toBeUpdated.push(_msg)
+        } else toBeDeleted.push(ID)
+      } else {
+        LOG.error(`${service.name}: Emit failed:`, e)
+        const _msg = { ID }
+        if (options.storeLastError !== false) _msg.lastError = e
+        toBeUpdated.push(_msg)
+        return false
       }
-      throw Object.assign(new Error('processing failed'), { failedMessage })
     }
-  })
+  }
+  if (options.parallel) {
+    const first = messages.next()?.value // First try to see if message can be emitted
+    if (first && (await run(first)) === false) return // No need to process the rest if the emit failed
+    const res = await Promise.allSettled([...messages].map(run))
+    const errors = res.filter(r => r.status === 'rejected').map(r => r.reason)
+    if (errors.length) {
+      throw new Error(`${service.name}: Programming errors detected.`)
+    }
+  } else {
+    for (const msg of messages) {
+      if ((await run(msg)) === false) break
+    }
+  }
 }
 
 // Note: This function can also run for each tenant on startup
@@ -89,15 +108,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
       } catch (e) {
         // could potentially be a timeout
         const _waitingTime = waitingTime(opts.attempt)
-        LOG.error(
-          'Outbox SELECT FOR UPDATE failed',
-          opts.attempt > 0
-            ? ''
-            : {
-                cause: e
-              },
-          `Retrying in ${Math.round(_waitingTime / 1000)} s`
-        )
+        LOG.error(`${name}: Message retrieval failed`, e, `Retrying in ${Math.round(_waitingTime / 1000)} s`)
         outboxRunner.schedule(
           {
             name,
@@ -108,57 +119,85 @@ const processMessages = async (service, tenant, _opts = {}) => {
         )
         return
       }
-      const messagesToBeDeleted = []
-      let error
-      for (const m of messages) {
-        try {
-          await _processSingleMessage(service, m, messagesToBeDeleted)
-        } catch (e) {
-          error = e
-          break
+      let currMaxAttempts = 0
+      const messagesGen = function* () {
+        for (const _message of messages) {
+          const msg = _safeJSONParse(_message.msg)
+          const userId = msg[cdsUser]
+          delete msg[cdsUser]
+          currMaxAttempts = Math.max(_message.attempts || 0, currMaxAttempts)
+          const user = new cds.User.Privileged(userId)
+          if (!msg) continue
+          const res = {
+            process: () =>
+              Promise.resolve().then(async () => {
+                if (userId) cds.context = { user }
+                try {
+                  return service._emitImmediate && (await service._emitImmediate(msg))
+                } catch (e) {
+                  if (isUnrecoverable(service, e)) e.unrecoverable = true
+                  throw e
+                }
+              }),
+            ID: _message.ID,
+            msg,
+            user,
+            opts
+          }
+          yield res
         }
       }
-      if (error && error.failedMessage.unrecoverable) {
-        // opts.crashOnError is not official!!!
+
+      const process = service.outbox?.process || this.process || processDefault
+      const toBeDeleted = []
+      const toBeUpdated = []
+      try {
+        await process(messagesGen(), {
+          toBeDeleted,
+          toBeUpdated,
+          service,
+          emit: service._emitImmediate.bind(service),
+          options: opts
+        })
+      } catch (e) {
         if (opts.crashOnError !== false) letAppCrash = true
-        messagesToBeDeleted.push(error.failedMessage.ID)
       }
-      if (messagesToBeDeleted.length) await DELETE.from(messagesEntity).where('ID in', messagesToBeDeleted)
-      if (error) {
-        if (!error.failedMessage.unrecoverable) {
-          const _waitingTime = waitingTime(error.failedMessage.attempts)
-          const info = { service: name, event: error.failedMessage.event }
-          if (error.failedMessage.attempts > 0) info.cause = error.failedMessage.error
-          LOG.error('Emit failed', info, `Retrying in ${Math.round(_waitingTime / 1000)} s`)
+
+      const queries = []
+      const _waitingTime = waitingTime(currMaxAttempts)
+      if (toBeDeleted.length) queries.push(DELETE.from(messagesEntity).where('ID in', toBeDeleted))
+      if (toBeUpdated.length) {
+        for (const toBeUpdatedMsg of toBeUpdated) {
+          if (toBeDeleted.includes(toBeUpdatedMsg.ID)) continue
           const data = {
             attempts: { '+=': 1 }
           }
-          if (opts.storeLastError) {
-            data.lastError = util.inspect(error.failedMessage.error)
-          }
-          await UPDATE(messagesEntity).where({ ID: error.failedMessage.ID }).set(data)
-          outboxRunner.schedule(
-            {
-              name,
-              tenant,
-              waitingTime: _waitingTime
-            },
-            () => processMessages(service, tenant, opts)
-          )
-        } else {
-          LOG.error(
-            'Emit failed',
-            { service: name, event: error.failedMessage.event, cause: error.failedMessage.error },
-            'Unrecoverable, outbox entry deleted'
-          )
+          Object.assign(data, toBeUpdatedMsg)
+          if (data.lastError && typeof data.lastError !== 'string') data.lastError = util.inspect(data.lastError)
+          queries.push(UPDATE(messagesEntity).where({ ID: toBeUpdatedMsg.ID }).set(data))
         }
+      }
+
+      await Promise.all(queries)
+
+      if (letAppCrash) return
+
+      if (toBeUpdated.length) {
+        LOG.error(`${name}: Some messages could not be emitted, retrying in ${Math.round(_waitingTime / 1000)} s`)
+        return outboxRunner.schedule(
+          {
+            name,
+            tenant,
+            waitingTime: _waitingTime
+          },
+          () => processMessages(service, tenant, opts)
+        )
+      }
+      outboxRunner.success({ name, tenant })
+      if (toBeDeleted.length === opts.chunkSize) {
+        processMessages(service, tenant, opts) // We only processed max. opts.chunkSize, so there might be more
       } else {
-        outboxRunner.success({ name, tenant })
-        if (messages.length === opts.chunkSize) {
-          processMessages(service, tenant, opts) // We only processed max. opts.chunkSize, so there might be more
-        } else {
-          LOG._trace && LOG.trace(`All persistent-outbox messages processed for service '${service.name}'`)
-        }
+        LOG._trace && LOG.trace(`${name}: All messages processed`)
       }
     }, config)
     spawn.on('done', () => {

package/libx/_runtime/messaging/service.js

@@ -4,6 +4,7 @@ const OutboxService = require('./Outbox')
 const ExtendedModels = require('../../../lib/srv/srv-models')
 
 const appId = require('./common-utils/appId')
+const { context } = require('../../../lib/core/classes')
 
 const _topic = declared => declared['@topic'] || declared.name
 
@@ -81,14 +82,22 @@ class MessagingService extends OutboxService {
     const _msg = typeof event === 'object' ? event : { event, data, headers }
     if (_msg instanceof cds.Event) return super.emit(_msg)
     if (_msg.inbound && !cds.context) {
-      return cds._context.run({ tenant: _msg.tenant, user: cds.User.privileged }, async () => {
-        if (cds.model) {
-          const ctx = cds.context
-          ctx.model = await ExtendedModels.model4(ctx.tenant, ctx.features)
+      return cds._context.run(
+        {
+          tenant: _msg.tenant,
+          user: cds.User.privileged,
+          ...(_msg._?.req && { req: _msg._.req }),
+          ...(_msg._?.res && { res: _msg._.res })
+        },
+        async () => {
+          if (cds.model) {
+            const ctx = cds.context
+            ctx.model = await ExtendedModels.model4(ctx.tenant, ctx.features)
+          }
+          const msg = new cds.Event(this.message4(_msg))
+          return super.emit(msg)
         }
-        const msg = new cds.Event(this.message4(_msg))
-        return super.emit(msg)
-      })
+      )
     }
     const msg = new cds.Event(this.message4(_msg))
     return super.emit(msg)

package/libx/_runtime/remote/Service.js

@@ -164,7 +164,7 @@ const resolvedTargetOfQuery = q => {
   const transitions = (typeof q === 'object' && (q.SELECT || q.INSERT || q.UPDATE || q.DELETE)._transitions) || []
   return transitions.length && [transitions.length - 1].target
 }
-
+let logged
 class RemoteService extends cds.Service {
   init() {
     if (!this.options.credentials) {
@@ -178,6 +178,17 @@ class RemoteService extends cds.Service {
       getDestination((this.definition && this.definition.name) || this.datasource, this.options.credentials)
     this.requestTimeout = this.options.credentials.requestTimeout
     if (this.requestTimeout == null) this.requestTimeout = 60000
+    if (cds.env.features.fetch_csrf && !logged) {
+      // for logging once for all remote services
+      logged = true
+      LOG._warn &&
+        LOG.warn(
+          '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: 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
     this.path = this.options.credentials.path
     this.kind = getKind(this.options) // TODO: Simplify
 
@@ -210,7 +221,9 @@ class RemoteService extends cds.Service {
         this.kind,
         resolvedTarget,
         returnType,
-        this.destinationOptions
+        this.destinationOptions,
+        this.csrf,
+        this.csrfInBatch
       )
 
       // hidden compat flag in order to suppress logging response body of failed request

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

@@ -22,7 +22,7 @@ const _sanitizeHeaders = headers => {
   return headers
 }
 
-const _executeHttpRequest = async ({ requestConfig, destination, destinationOptions, jwt }) => {
+const _executeHttpRequest = async ({ requestConfig, destination, destinationOptions, jwt, csrf, csrfInBatch }) => {
   const { executeHttpRequestWithOrigin } = cloudSdk()
   const destinationName = typeof destination === 'string' && destination
 
@@ -44,11 +44,7 @@ const _executeHttpRequest = async ({ requestConfig, destination, destinationOpti
 
   let requestOptions
   if (PPPD[requestConfig.method]) {
-    // For GET requests, one doesn't need to fetch CSRF tokens.
-    // Once we support batch requests (other than autoBatched GET requests),
-    // we must check the respective subrequests.
-    const csrfRequired = requestConfig._autoBatch ? false : cds.env.features.fetch_csrf === true
-    requestOptions = { fetchCsrfToken: csrfRequired }
+    requestOptions = { fetchCsrfToken: requestConfig._autoBatch ? csrfInBatch === true : csrf === true }
   }
 
   LOG._debug &&
@@ -282,11 +278,28 @@ const _getSanitizedError = (e, reqOptions, options = { suppressRemoteResponseBod
 // eslint-disable-next-line complexity
 const run = async (
   requestConfig,
-  { destination, jwt, kind, resolvedTarget, returnType, suppressRemoteResponseBody, destinationOptions }
+  {
+    destination,
+    jwt,
+    kind,
+    resolvedTarget,
+    returnType,
+    suppressRemoteResponseBody,
+    destinationOptions,
+    csrf,
+    csrfInBatch
+  }
 ) => {
   let response
   try {
-    response = await _executeHttpRequest({ requestConfig, destination, destinationOptions, jwt })
+    response = await _executeHttpRequest({
+      requestConfig,
+      destination,
+      destinationOptions,
+      jwt,
+      csrf,
+      csrfInBatch
+    })
   } catch (e) {
     // > axios received status >= 400 -> gateway error
     const msg = e?.response?.data?.error?.message?.value ?? e?.response?.data?.error?.message ?? e.message
@@ -466,7 +479,7 @@ const getReqOptions = (req, query, service) => {
 
   // forward all dwc-* headers
   if (service.options.forward_dwc_headers) {
-    const originalHeaders = (req.context && req.context._ && req.context._.req && req.context._.req.headers) || {}
+    const originalHeaders = req.context?.http.req.headers || {}
     for (const k in originalHeaders) if (k.match(/^dwc-/)) reqOptions.headers[k] = originalHeaders[k]
   }
 
@@ -516,9 +529,26 @@ const getReqOptions = (req, query, service) => {
   return reqOptions
 }
 
-const getAdditionalOptions = (req, destination, kind, resolvedTarget, returnType, destinationOptions) => {
+const getAdditionalOptions = (
+  req,
+  destination,
+  kind,
+  resolvedTarget,
+  returnType,
+  destinationOptions,
+  csrf,
+  csrfInBatch
+) => {
   const jwt = getJwt(req)
-  const additionalOptions = { destination, kind, resolvedTarget, returnType, destinationOptions }
+  const additionalOptions = {
+    destination,
+    kind,
+    resolvedTarget,
+    returnType,
+    destinationOptions,
+    csrf,
+    csrfInBatch
+  }
   if (jwt) additionalOptions.jwt = jwt
   return additionalOptions
 }

package/libx/_runtime/sqlite/Service.js

@@ -9,6 +9,7 @@ let _sqlite
  */
 const localized = require('./localized')
 const convertAssocToOneManaged = require('./convertAssocToOneManaged')
+const convertDraftAdminPathExpression = require('./convertDraftAdminPathExpression')
 
 /*
  * sqlite-specific execution
@@ -72,8 +73,10 @@ module.exports = class SQLiteDatabase extends DatabaseService {
 
   _registerBeforeHandlers() {
     this.before(['CREATE', 'UPDATE'], '*', this._input) // > has to run before rewrite
-    this.before(['CREATE', 'READ', 'UPDATE', 'DELETE'], '*', this._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)
     this.before('READ', '*', convertAssocToOneManaged)
     this.before('READ', '*', localized) // > has to run after rewrite
     this.before('READ', '*', this._virtual)

package/libx/_runtime/sqlite/convertDraftAdminPathExpression.js

@@ -0,0 +1,56 @@
+const cds = require('../cds')
+
+function sqliteConvertDraftAdminPathExpression(req) {
+  if (
+    !req.query?.SELECT ||
+    !req.query?._target?.name?.endsWith('.drafts') ||
+    req.query?.SELECT?.from?.args?.some(a => a.ref?.[0] === 'DRAFT_DraftAdministrativeData')
+  )
+    return
+  let hasDraftAdminPathExpression = false
+
+  const alias = req.query.SELECT.from.as
+
+  const _modifyCols = cols => {
+    return cols.map(col => {
+      if (col.ref?.length > 1 && col.ref[0] === 'DraftAdministrativeData') {
+        hasDraftAdminPathExpression = true
+        const newCol = { ...col }
+        newCol.ref = [...col.ref]
+        newCol.ref[0] = 'filterAdmin'
+        return newCol
+      } else if (col.ref?.length > 1 && alias && col.ref[0] === alias && col.ref[1] === 'DraftAdministrativeData') {
+        hasDraftAdminPathExpression = true
+        const newCol = { ...col }
+        newCol.ref = [...col.ref]
+        newCol.ref.shift()
+        newCol.ref[0] = 'filterAdmin'
+        return newCol
+      }
+      if (col.expand) {
+        const newCol = { ...col }
+        newCol.expand = _modifyCols(col.expand)
+        return newCol
+      }
+      return col
+    })
+  }
+
+  const clone = cds.ql.clone(req.query)
+
+  if (clone.SELECT.columns) clone.SELECT.columns = _modifyCols(req.query.SELECT.columns)
+  if (clone.SELECT.where) clone.SELECT.where = _modifyCols(req.query.SELECT.where)
+
+  if (hasDraftAdminPathExpression) {
+    clone
+      .join('DRAFT_DraftAdministrativeData', 'filterAdmin')
+      .on([
+        { ref: alias ? [alias, 'DraftAdministrativeData_DraftUUID'] : ['DraftAdministrativeData_DraftUUID'] },
+        '=',
+        { ref: ['filterAdmin', 'DraftUUID'] }
+      ])
+    req.query = clone
+  }
+}
+sqliteConvertDraftAdminPathExpression._initial = true
+module.exports = sqliteConvertDraftAdminPathExpression

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

@@ -0,0 +1,41 @@
+const InsertBuilder = require('../../db/sql-builder').InsertBuilder
+const getAnnotatedColumns = require('../../db/sql-builder/annotations')
+
+class CustomUpsertBuilder extends InsertBuilder {
+  annotatedColumns(entityName, csn) {
+    const { updateAnnotatedColumns } = getAnnotatedColumns(entityName, csn)
+
+    if (updateAnnotatedColumns?.size) {
+      this.managedCols = Array.from(updateAnnotatedColumns.keys())
+    }
+
+    return { insertAnnotatedColumns: updateAnnotatedColumns }
+  }
+
+  // REVISIT: We need to copy over the implementation for annotation handling
+  build() {
+    this._obj = { INSERT: this._obj.UPSERT, _target: this._obj._target }
+    super.build()
+    const csnKeys =
+      (this._obj._target ? this._obj._target.keys : this._csn.definitions[this._obj.INSERT.into].keys) || {}
+    const keys = Object.keys(csnKeys).filter(k => !csnKeys[k].isAssociation)
+    const updates = []
+    const columns = this._obj.INSERT.columns || Object.keys(this._obj.INSERT.entries[0])
+    if (this.managedCols) {
+      columns.push(...this.managedCols)
+    }
+
+    columns.forEach(col => {
+      const col_ = col.replace(/\./g, '_')
+      if (!keys.includes(col_)) updates.push(`${col_}=excluded.${col_}`)
+    })
+    const conflict = updates.length
+      ? ` ON CONFLICT(${keys}) DO UPDATE SET ` + updates.join(', ')
+      : ` ON CONFLICT(${keys}) DO NOTHING`
+
+    this._outputObj.sql = this._outputObj.sql + conflict
+    return this._outputObj
+  }
+}
+
+module.exports = CustomUpsertBuilder

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

@@ -23,6 +23,11 @@ const dependencies = {
     const CustomUpdateBuilder = require('./CustomUpdateBuilder')
     Object.defineProperty(dependencies, 'UpdateBuilder', { value: CustomUpdateBuilder })
     return CustomUpdateBuilder
+  },
+  get UpsertBuilder() {
+    const CustomUpsertBuilder = require('./CustomUpsertBuilder')
+    Object.defineProperty(dependencies, 'UpsertBuilder', { value: CustomUpsertBuilder })
+    return CustomUpsertBuilder
   }
 }
 

package/libx/_runtime/sqlite/execute.js

@@ -206,7 +206,7 @@ function executePlainSQL(dbc, sql, values, isOne, postMapper) {
     return executeSelectSQL(dbc, sql, values, isOne, postMapper)
   }
 
-  if (/^\s*insert/i.test(sql)) {
+  if (/^\s*insert/i.test(sql) || /^\s*upsert/i.test(sql)) {
     return executeInsertSQL(dbc, sql, values)
   }
 

package/libx/_runtime/types/api.js

@@ -48,8 +48,8 @@
 
 /**
  * @typedef {object} TemplateProcessorPathOptions
- * @property {object} [extraKeys]
- * @property {function} [rowKeysGenerator]
+ * @property {object} [draftKeys]
+ * @property {function} [rowUUIDGenerator]
  * @property {string[]} [segments=[]] - Path segments to relate the error message.
  * @property {boolean} [includeKeyValues=false] Indicates whether the key values are included in the path segments
  * The path segments are used to build the error target (a relative resource path)