@sap/cds 7.2.1 → 7.3.1

package/libx/_runtime/common/composition/update.js

@@ -1,3 +1,5 @@
+const parentDataSymbol = Symbol('parentData')
+const cqnSymbol = Symbol('cqn')
 const cds = require('../../cds')
 const { getCompositionTree } = require('./tree')
 const { getDeepInsertCQNs } = require('./insert')
@@ -138,7 +140,13 @@ function _addSubDeepUpdateCQNForUpdateInsert({ entity, entityName, data, selectD
       const oldData = ctUtils.cleanDeepData(entity, selectEntry)
       const diff = _diffData(newData, oldData, entity, entry, selectEntry, model)
       // empty updates will be removed later
-      updateCQNs.push({ UPDATE: { entity: entityName, data: diff, where: ctUtils.whereKey(key) } })
+      updateCQNs.push({
+        UPDATE: { entity: entityName, data: Object.assign({}, key, diff), where: ctUtils.whereKey(key) },
+        // We take tree information from data and store
+        // it in the `updateCQN` array (which itself is just a flat list)
+        parent: entry[parentDataSymbol]?.[cqnSymbol]
+      })
+      entry[cqnSymbol] = updateCQNs[updateCQNs.length - 1]
     } else {
       insertCQN.INSERT.entries.push(entry)
       // inserts are handled deep so they must not be put into deepUpdateData
@@ -189,7 +197,15 @@ const _addToData = (subData, entity, element, entry) => {
   const value = ctUtils.val(entry[element.name])
   const subDataEntries = ctUtils.array(value)
   const unwrappedSubData = subDataEntries.map(entry => _unwrapIfNotArray(entry))
-  for (const val of unwrappedSubData) subData.push(val)
+  for (const val of unwrappedSubData) {
+    if (val != null) {
+      // We need to conserve the tree information which gets
+      // lost because we're creating flat arrays of layers.
+      Object.defineProperty(val, parentDataSymbol, { value: entry })
+    }
+
+    subData.push(val)
+  }
 }
 
 async function _addSubDeepUpdateCQNRecursion({ model, compositionTree, entity, data, selectData, cqns, draft, req }) {

package/libx/_runtime/common/error/frontend.js

@@ -39,42 +39,48 @@ const _getFiltered = err => {
 }
 
 const _rewriteDBError = error => {
+  let { code, message } = error
+  code = String(code || 'null')
+
   // REVISIT: db stuff probably shouldn't be here
-  if (error.code === 'SQLITE_ERROR') {
+  if (code === 'SQLITE_ERROR') {
     error.code = 'null'
-  } else if (
-    (error.code.startsWith('SQLITE_CONSTRAINT') && error.message.match(/COMMIT/)) ||
-    (error.code.startsWith('SQLITE_CONSTRAINT') && error.message.match(/FOREIGN KEY/)) ||
-    (error.code === '155' && error.message.match(/fk constraint violation/))
+    return
+  }
+
+  if (
+    (code.startsWith('SQLITE_CONSTRAINT') && (message.match(/COMMIT/) || message.match(/FOREIGN KEY/))) ||
+    (code === '155' && message.match(/fk constraint violation/))
   ) {
     // > foreign key constaint violation no sqlite/ hana
     error.code = '400'
-    error.message = i18n('FK_CONSTRAINT_VIOLATION')
-  } else if (error.code.startsWith('ASSERT_')) {
+    error.message = 'FK_CONSTRAINT_VIOLATION'
+    return
+  }
+
+  if (code.startsWith('ASSERT_')) {
     error.code = '400'
+    return
   }
 }
 
-const _normalize = (err, locale, inner = false) => {
+const _normalize = (err, locale, formatterFn = _getFiltered) => {
+  // REVISIT: code and message rewriting
+  _rewriteDBError(err)
+
   // message (i18n)
   err.message = getErrorMessage(err, locale)
 
-  // only allowed properties
-  const error = _getFiltered(err)
-
   // ensure code is set and a string
-  error.code = String(error.code || 'null')
-
-  // REVISIT: code and message rewriting
-  _rewriteDBError(error)
+  err.code = String(err.code || 'null')
 
-  let statusCode = err.status || err.statusCode || (_isAllowedError(error.code) && error.code)
+  let statusCode = err.status || err.statusCode || (_isAllowedError(err.code) && err.code)
 
   // details
-  if (!inner && err.details) {
+  if (err.details) {
     const childErrorCodes = new Set()
-    error.details = err.details.map(ele => {
-      const { error: childError, statusCode: childStatusCode } = _normalize(ele, locale, true)
+    err.details = err.details.map(ele => {
+      const { error: childError, statusCode: childStatusCode } = _normalize(ele, locale, formatterFn)
       childErrorCodes.add(childStatusCode)
       return childError
     })
@@ -84,12 +90,13 @@ const _normalize = (err, locale, inner = false) => {
   // make sure it's a number if set, otherwise will be assigned as 500 in normalizeError
   statusCode = statusCode ? Number(statusCode) : undefined
 
+  // only allowed properties
+  const error = formatterFn(err)
+
   return { error, statusCode }
 }
 
-const _isAllowedError = errorCode => {
-  return errorCode >= 300 && errorCode < 505
-}
+const _isAllowedError = errorCode => errorCode >= 300 && errorCode < 505
 
 // - for one unique value, we use it
 // - if at least one 5xx exists, we use 500
@@ -100,32 +107,37 @@ const _statusCodeFromDetails = uniqueStatusCodes => {
   if ([...uniqueStatusCodes].some(s => s >= 400)) return 400
 }
 
-const normalizeError = (err, req) => {
+const _getSanitizedError = (statusCode, locale) => ({
+  error: { code: String(statusCode), message: i18n(statusCode, locale) },
+  statusCode
+})
+
+const normalizeError = (err, req, formatterFn) => {
   const locale = req.locale || (req.locale = localeFrom(req))
-  let { error, statusCode } = _normalize(err, locale)
+  let { error, statusCode } = _normalize(err, locale, formatterFn)
 
-  if ((!statusCode || (statusCode >= 500 && err._thrownByFramework)) && process.env.NODE_ENV === 'production') {
+  if (process.env.NODE_ENV === 'production') {
     // > return sanitized error to client
-    return {
-      error: { code: statusCode ? `${statusCode}` : '500', message: i18n(statusCode || 500, locale) },
-      statusCode: Number(statusCode) || 500
+
+    if (!statusCode) return _getSanitizedError(500, locale)
+
+    if (statusCode >= 500 && err._thrownByFramework) {
+      return _getSanitizedError(statusCode, locale)
     }
   }
 
   if (!statusCode) statusCode = 500
 
   // no top level null codes
-  if (error.code === 'null') {
-    error.code = String(statusCode)
-  }
+  if (error.code === 'null') error.code = String(statusCode)
 
   return { error, statusCode }
 }
 
 const _ensureSeverity = arg => {
-  if (typeof arg === 'number' && arg >= MIN_SEVERITY && arg <= MAX_SEVERITY) {
-    return arg
-  }
+  if (typeof arg !== 'number') return DEFAULT_SEVERITY
+
+  if (arg >= MIN_SEVERITY && arg <= MAX_SEVERITY) return arg
 
   return DEFAULT_SEVERITY
 }

package/libx/_runtime/common/generic/auth/capabilities.js

@@ -1,14 +1,14 @@
 const { cqnFrom } = require('./utils')
 const { RESTRICTIONS } = require('./constants')
 
-const _isRestricted = (req, capability, capabilityReadByKey) => {
-  if (capabilityReadByKey !== undefined && req.query.SELECT && req.query.SELECT.one) {
-    return capabilityReadByKey === false
+const _getRestriction = (req, capability, capabilityReadByKey) => {
+  if (capabilityReadByKey !== undefined && req.query.SELECT?.one) {
+    return capabilityReadByKey
   }
-  return capability === false
+  return capability
 }
 
-const _isNavigationRestricted = (target, path, annotation, req) => {
+const _getNavigationRestriction = (target, path, annotation, req) => {
   if (!target) return
   if (!Array.isArray(target['@Capabilities.NavigationRestrictions.RestrictedProperties'])) return
 
@@ -17,7 +17,7 @@ const _isNavigationRestricted = (target, path, annotation, req) => {
     // prefix check to support both notations: { InsertRestrictions: { Insertable: false } } and { InsertRestrictions.Insertable: false }
     if (r.NavigationProperty['='] === path && Object.keys(r).some(k => k.startsWith(restriction))) {
       const capability = r[annotation] ?? r[restriction]?.[operation]
-      return _isRestricted(req, capability, r.ReadRestrictions?.['ReadByKeyRestrictions.Readable'])
+      return _getRestriction(req, capability, r.ReadRestrictions?.['ReadByKeyRestrictions.Readable'])
     }
   }
 }
@@ -32,22 +32,41 @@ function handler(req) {
 
   const action = annotation.split('.').pop().toUpperCase()
   const from = cqnFrom(req)
-  const nav = (from && from.ref && from.ref.map(el => el.id || el)) || []
+  const nav = (from?.ref && from.ref.map(el => el.id || el)) || []
 
+  let navRestriction
   if (nav.length > 1) {
-    const path = nav.slice(1).join('.')
-    const target = this.model.definitions[nav[0]]
-    if (_isNavigationRestricted(target, path, annotation, req)) {
+    const navs = nav.slice(1)
+    let lastTarget, target, element, navigation, path
+    target = this.model.definitions[nav[0]]
+    for (let i = 0; i < navs.length && target; i++) {
+      element = !element || element.isAssociation ? target.elements[navs[i]] : element.elements[navs[i]]
+      if (element.isAssociation) {
+        navigation = path ? `${path}.${navs[i]}` : navs[i]
+        path = undefined
+        lastTarget = target
+        target = this.model.definitions[element.target]
+      } else {
+        path = path ? `${path}.${navs[i]}` : navs[i]
+      }
+    }
+    if (lastTarget && navigation) {
+      navRestriction = _getNavigationRestriction(lastTarget, navigation, annotation, req)
+    }
+    if (navRestriction === false) {
       // REVISIT: rework exception with using target
-      const trgt = `${_localName(target)}.${path}`
+      const trgt = `${_localName(lastTarget)}.${navs.join('.')}`
       req.reject(405, 'ENTITY_IS_NOT_CRUD_VIA_NAVIGATION', [_localName(req.target), action, trgt])
     }
-  } else if (
-    _isRestricted(
+  }
+
+  if (
+    !navRestriction &&
+    _getRestriction(
       req,
       req.target['@Capabilities.' + annotation],
       req.target['@Capabilities.' + RESTRICTIONS.READABLE_BY_KEY]
-    )
+    ) === false
   ) {
     req.reject(405, 'ENTITY_IS_NOT_CRUD', [_localName(req.target), action])
   }

package/libx/_runtime/common/generic/input.js

@@ -246,7 +246,7 @@ async function commonGenericInput(req) {
   if (boundAction) {
     const pathSegment = _getBoundActionBindingParameter(boundAction)
     if (pathSegment) pathOptions.pathSegmentsInfo.push(pathSegment)
-    const keys = req._?.params?.[0]
+    const keys = req.params?.[0]
     if (keys && 'IsActiveEntity' in keys) {
       pathOptions.draftKeys = { IsActiveEntity: keys.IsActiveEntity }
     }

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

@@ -729,9 +729,6 @@ const _convertSelect = (query, model, _options) => {
     }
   }
 
-  // lambda functions
-  convertWhereExists(query.SELECT, model, options)
-
   // add 'or is null' in case of not equal: '!=' or '<>'
   if (query.SELECT._4odata) {
     _convertNotEqual(query.SELECT, 'where')
@@ -739,6 +736,9 @@ const _convertSelect = (query, model, _options) => {
   }
 
   _convertPathExpression(query, model, options)
+
+  convertWhereExists(query.SELECT, model, options)
+
   rewriteAsterisks(query, model, options)
   const entity =
     (query.SELECT.from.ref && (query.SELECT.from.ref[0].id || query.SELECT.from.ref[0])) || query.SELECT.from

package/libx/_runtime/db/query/update.js

@@ -1,48 +1,64 @@
 const cds = require('../../cds')
-
+const preservedSymbol = Symbol('preserved')
 const { hasDeepUpdate, getDeepUpdateCQNs, selectDeepUpdateData } = require('../../common/composition')
 const { getFlatArray, processCQNs } = require('../utils/deep')
 const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
+const onlyKeysRemain = require('../../common/utils/onlyKeysRemain')
+
+const isMoreThanManaged = (cqn, entity) => {
+  return (
+    cqn[preservedSymbol] ||
+    Object.keys(cqn.UPDATE.data).some(
+      key =>
+        !(key in entity.keys) &&
+        (entity.elements[key]['@cds.on.update'] === undefined || !cqn.UPDATE.data[key]?.startsWith('$'))
+    )
+  )
+}
 
-const _includesCompositionTarget = (cqns, target) => {
-  return cqns.find(cqn => {
-    return (cqn.UPDATE && cqn.UPDATE.entity === target) || (cqn.DELETE && cqn.DELETE.from === target)
-  })
+const isManaged = (cqn, entity) => {
+  return Object.keys(cqn.UPDATE.data).some(
+    key => entity.elements[key]['@cds.on.update'] && cqn.UPDATE.data[key] !== undefined
+  )
 }
 
 const _getFilteredCqns = (cqns, model) => {
   // right to left processing necessary!
-  // no need to process first (= root)
   for (let i = cqns.length - 1; i > 0; i--) {
     const cqn = cqns[i]
 
     const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
-    if (!entity) continue
-
-    // do not filter if:
-    // - there is a property that is not managed or managed but filled by custom handler (i.e., its value doesn't start
-    // with $) a composition target is updated as well
-    let moreThanManaged = Object.keys(cqn.UPDATE.data).some(
-      key => entity.elements[key]['@cds.on.update'] === undefined || !cqn.UPDATE.data[key]?.startsWith('$')
-    )
+    if (!entity) {
+      Object.defineProperty(cqn, preservedSymbol, { value: true })
+      continue
+    }
 
-    if (moreThanManaged) continue
+    // do not filter if there is a property that is not a key or managed by us (its value starts with $)
+    let moreThanManaged = isMoreThanManaged(cqn, entity)
 
-    const comps = Object.values(entity.associations || {}).filter(assoc => assoc.isComposition)
-    for (const comp of comps) {
-      if (_includesCompositionTarget(cqns, comp.target)) {
-        moreThanManaged = true
-        break
+    if (moreThanManaged) {
+      Object.defineProperty(cqn, preservedSymbol, { value: true })
+      const parentEntity = cqn.parent?.UPDATE && model.definitions[cqn.parent.UPDATE.entity]
+      if (parentEntity && isManaged(cqn.parent, parentEntity)) {
+        Object.defineProperty(cqn.parent, preservedSymbol, { value: true })
       }
+      continue
     }
+  }
 
-    if (moreThanManaged) continue
-
-    // remove current cqn
-    cqns.splice(i, 1)
+  const rootCqn = cqns[0]
+  if (rootCqn) {
+    // no need to process first (= root)
+    Object.defineProperty(rootCqn, preservedSymbol, { value: true })
   }
 
-  return cqns
+  return cqns.filter(cqn => {
+    const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
+    if (entity && onlyKeysRemain({ query: cqn, target: entity, data: cqn.UPDATE.data })) {
+      return false
+    }
+    return cqn[preservedSymbol]
+  })
 }
 
 const update = executeUpdateCQN => async (model, dbc, req) => {
@@ -52,20 +68,22 @@ const update = executeUpdateCQN => async (model, dbc, req) => {
   if (model && hasDeepUpdate(model, query)) {
     // REVISIT: avoid additional read
     const selectData = await selectDeepUpdateData(cds.db, model, req)
-    let cqns = await getDeepUpdateCQNs(model, req, selectData)
+    const cqns = await getDeepUpdateCQNs(model, req, selectData)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []
     for (const each of cqns) chunks.push(each.filter(e => e.DELETE).length)
 
     // remove child queries that only want to update @cds.on.update properties
-    cqns = _getFilteredCqns(getFlatArray(cqns), model)
+    let _cqns = Array.from(cqns)
+    _cqns = getFlatArray(_cqns)
+    _cqns = _getFilteredCqns(_cqns, model)
 
-    if (cqns.length === 0) return 0
-    const results = await processCQNs(executeUpdateCQN, cqns, model, dbc, user, locale, isoTs, chunks)
+    if (_cqns.length === 0) return 0
+    const results = await processCQNs(executeUpdateCQN, _cqns, model, dbc, user, locale, isoTs, chunks)
 
     // return number of affected rows of "root cqn", if an update, 1 otherwise (as not update of root but its children)
-    if (cqns[0].UPDATE) return results[0]
+    if (_cqns[0].UPDATE) return results[0]
     return 1
   }
 

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

@@ -269,11 +269,10 @@ cds.ApplicationService.prototype.handle = async function (req) {
     delete res.DraftAdministrativeData
     const HasActiveEntity = res.HasActiveEntity
     delete res.HasActiveEntity
-    delete res.IsActiveEntity
     // First run the handlers as they might need access to DraftAdministrativeData or the draft entities
     const result = await run(
       HasActiveEntity ? UPDATE(req.target).data(res).where(targetWhere) : INSERT.into(req.target).entries(res),
-      { headers: { 'if-match': '*' } }
+      { headers: Object.assign({}, req.headers, { 'if-match': '*' }) }
     )
     await _promiseAll([
       DELETE.from(targetDraft).where(targetWhere),
@@ -1054,7 +1053,7 @@ async function onCancel(req) {
     )
   else
     queries.push(
-      UPDATE('Draft.DraftAdministrativeData')
+      UPDATE('DRAFT.DraftAdministrativeData')
         .data({
           InProcessByUser: cds.context.user.id,
           LastChangedByUser: cds.context.user.id,

package/libx/_runtime/hana/conversion.js

@@ -21,15 +21,16 @@ const convertInt64ToString = int64 => {
 const convertToISO = element => {
   if (!element) return null
 
+  let dateTime = element.replace(' ', 'T')
   if (cds.env.features.precise_timestamps) {
-    const dateTime = element.slice(0, 19).replace(' ', 'T')
+    dateTime = dateTime.slice(0, 19)
     let millis = element.slice(20)
     if (millis.at(-1) === 'Z') millis = millis.slice(0, -1)
     millis = millis.slice(0, 7).padEnd(7, '0')
     return dateTime + '.' + millis + 'Z'
   }
 
-  return new Date(element + 'Z').toISOString()
+  return new Date(dateTime + 'Z').toISOString()
 }
 
 const convertToISONoMillis = element => {

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

@@ -4,7 +4,7 @@ const _transform = o => ({ subdomain: o.subscribedSubdomain, tenant: o.subscribe
 // REVISIT: Looks ugly -> can we simplify that?
 const getTenantInfo = async tenant => {
   const provisioning = await cds.connect.to('cds.xt.SaasProvisioningService')
-  const tx = provisioning.tx({ user: new cds.User.Privileged() })
+  const tx = provisioning.tx({ user: cds.User.privileged })
   try {
     const result = tenant
       ? _transform(await tx.get('/tenant', { ['subscribedTenantId']: tenant }))

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

@@ -99,7 +99,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
 
   outboxRunner.run({ name, tenant }, () => {
     let letAppCrash = false
-    const config = tenant ? { tenant, user: new cds.User.Privileged() } : { user: new cds.User.Privileged() }
+    const config = tenant ? { tenant, user: cds.User.privileged } : { user: cds.User.privileged }
     const spawn = cds.spawn(async () => {
       let messages
       try {

package/libx/_runtime/remote/Service.js

@@ -34,6 +34,7 @@ const _setHeaders = (defaultHeaders, req) => {
 }
 
 const _setCorrectValue = (el, data, params, kind) => {
+  if (data[el] === undefined) return "'undefined'"
   return typeof data[el] === 'object' && kind !== 'odata-v2'
     ? JSON.stringify(data[el])
     : formatVal(data[el], el, { elements: params }, kind)
@@ -180,7 +181,6 @@ const resolvedTargetOfQuery = q => {
 }
 
 let logged
-let sdkLoggerDisabled
 
 const _resolveSelectionStrategy = options => {
   if (typeof options?.selectionStrategy !== 'string') return
@@ -228,22 +228,6 @@ 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 */
-        }
-      }
     } else if ([...this.entities].length || [...this.operations].length) {
       throw new Error(`No credentials configured for "${this.name}".`)
     }

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

@@ -427,13 +427,13 @@ const _stringToReqOptions = (query, data, target) => {
   return reqOptions
 }
 
-const _pathToReqOptions = (method, path, data, target, namespace) => {
+const _pathToReqOptions = (method, path, data, target, srvName) => {
   let url = path
   if (!url.startsWith('/')) {
     // extract entity name and instance identifier (either in "()" or after "/") from fully qualified path
     const parts = path.match(/([\w.]*)([\W.]*)(.*)/)
     if (!parts) url = '/' + path.match(/\w*$/)[0]
-    else if (url.startsWith(namespace)) url = '/' + parts[1].replace(namespace + '.', '') + parts[2] + parts[3]
+    else if (url.startsWith(srvName)) url = '/' + parts[1].replace(srvName + '.', '') + parts[2] + parts[3]
     else url = '/' + parts[1].match(/\w*$/)[0] + parts[2] + parts[3]
 
     // normalize in case parts[2] already starts with /
@@ -460,7 +460,7 @@ const getReqOptions = (req, query, service) => {
       ? _cqnToReqOptions(query, service, req)
       : typeof query === 'string'
       ? _stringToReqOptions(query, req.data, req.target)
-      : _pathToReqOptions(req.method, req.path, req.data, req.target, service.namespace)
+      : _pathToReqOptions(req.method, req.path, req.data, req.target, service.name)
 
   if (service.kind === 'odata-v2' && req.event === 'READ' && reqOptions.url?.match(/(\/any\()|(\/all\()/)) {
     req.reject(501, 'Lambda expressions are not supported in OData v2')

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

@@ -66,12 +66,9 @@ const _convertActionFuncResponse = (returnType, convertValueFn) => data => {
 
 // eslint-disable-next-line complexity
 const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, element) => {
-  if (value == null) {
-    return value
-  }
+  if (value == null) return value
 
   const type = _elementType(element)
-
   if (type === 'cds.Boolean') {
     if (value === 'true') {
       value = true
@@ -119,18 +116,19 @@ const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, elemen
 
   return value
 }
+
 const _PT = ([hh, mm, ss]) => `PT${hh}H${mm}M${ss}S`
 
 const _convertPayloadValue = (value, element) => {
-  const type = _elementType(element)
+  if (value == null) return value
 
   // see https://www.odata.org/documentation/odata-version-2-0/json-format/
-  if (value == null) return value
+  const type = _elementType(element)
   switch (type) {
     case 'cds.Time':
       return value.match(/^(PT)([H,M,S,0-9])*$/) ? value : _PT(value.split(':'))
     case 'cds.Decimal':
-      return typeof value === 'string' ? value : new String(value)
+      return typeof value === 'string' ? value : `${value}`
     case 'cds.Date':
     case 'cds.DateTime':
       return `/Date(${new Date(value).getTime()})/`

package/libx/odata/{grammar.pegjs → grammar.peggy}

@@ -33,7 +33,7 @@
     const stack = []
     let SELECT, count
     const TECHNICAL_OPTS = ['$value'] // odata parts to be handled somewhere else
-    // we keep that here to allow for usage in https://pegjs.org/online
+    // we keep that here to allow for usage in https://peggyjs.org/online
     const safeNumber =
       options.safeNumber ||
       function (str) {