@sap/cds 8.9.4 → 9.0.3

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

@@ -3,8 +3,6 @@ let LOG = cds.log('app')
 
 const { rewriteAsterisks } = require('../../common/utils/rewriteAsterisks')
 
-const getError = require('../error')
-
 const _setInverseTransition = (mapping, ref, mapped) => {
   const existing = mapping.get(ref)
   if (!existing) mapping.set(ref, mapped)
@@ -232,69 +230,57 @@ const _newInsertColumns = (columns = [], transition) => {
 }
 
 // REVISIT: this hard-coding on ref indexes does not support path expressions
-const _newWhereRef = (newWhereElement, transition, alias, tableName) => {
-  const newRef = Array.isArray(newWhereElement.ref) ? [...newWhereElement.ref] : [newWhereElement.ref]
-
-  const [firstRef, secondRef] = [newRef[0].id || newRef[0], newRef[1]?.id || newRef[1]]
+const _newWhereRef = (newWhereElement, transition, tableName, options) => {
+  let newRef = Array.isArray(newWhereElement.ref) ? [...newWhereElement.ref] : [newWhereElement.ref]
 
-  const updateRef = (index, value) => {
-    // REVISIT: this should be done instead of ignoring where for a ref step
-    //          --> there are no transitions calculated for infix filters though
-    // if (newRef[index].id) {
-    //   newRef[index].id = value;
-    // } else {
-    //   newRef[index] = value;
-    // }
-
-    newRef[index] = value
-  }
-
-  if (secondRef) {
-    if (firstRef === alias) {
-      const mapped = transition.mapping.get(secondRef)
-      if (mapped) updateRef(1, mapped.ref.join('_'))
-    } else if (firstRef === tableName) {
-      updateRef(0, transition.target.name)
-
-      const mapped = transition.mapping.get(secondRef)
-      if (mapped) updateRef(1, mapped.ref.join('_'))
+  if (newRef.length === 1 && typeof newRef[0] === 'string') {
+    const mapped = transition.mapping.get(newRef[0])
+    if (mapped) {
+      newRef[0] = mapped.ref.join('_')
     }
-  } else if (newRef.length === 1) {
-    const mapped = transition.mapping.get(firstRef)
-    if (mapped) updateRef(0, mapped.ref.join('_'))
+  } else {
+    // REVISIT: aliases in sub selects not yet supported
+    if (newRef[0] !== tableName) options.previousEntity = transition.queryTarget
+    const nestedTransitions = _entityTransitionsForTarget(
+      newWhereElement,
+      options.model,
+      options.service,
+      options
+    ).filter(nT => nT?.target)
+    newRef = _rewriteQueryPath(newWhereElement, [transition, ...nestedTransitions], options)
   }
-
   newWhereElement.ref = newRef
 }
 
 const _newEntries = (entries = [], transition, service, options) =>
   entries.map(entry => _newData(entry, transition, false, service, options))
 
-const _newWhere = (where = [], transition, tableName, alias, isSubselect = false) => {
+const _newWhere = (where = [], transition, tableName, alias, isSubselect = false, options) => {
   const newWhere = where.map(whereElement => {
     if (whereElement.xpr) {
-      return { xpr: _newWhere(whereElement.xpr, transition, tableName, alias, isSubselect) }
+      return { xpr: _newWhere(whereElement.xpr, transition, tableName, alias, isSubselect, options) }
     }
 
     if (whereElement.list) {
-      return { list: _newWhere(whereElement.list, transition, tableName, alias, isSubselect) }
+      return { list: _newWhere(whereElement.list, transition, tableName, alias, isSubselect, options) }
     }
 
     const newWhereElement = { ...whereElement }
     if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
 
     if (whereElement.SELECT && whereElement.SELECT.where && !whereElement._doNotResolve) {
-      newWhereElement.SELECT.where = _newWhere(whereElement.SELECT.where, transition, tableName, alias, true)
+      newWhereElement.SELECT.where = _newWhere(whereElement.SELECT.where, transition, tableName, alias, true, options)
       return newWhereElement
     }
 
     if (newWhereElement.ref) {
-      _newWhereRef(newWhereElement, transition, alias, tableName)
+      options.alias = alias
+      _newWhereRef(newWhereElement, transition, tableName, options)
       return newWhereElement
     }
 
     if (newWhereElement.func) {
-      newWhereElement.args = _newWhere(newWhereElement.args, transition, tableName, alias)
+      newWhereElement.args = _newWhere(newWhereElement.args, transition, tableName, alias, undefined, options)
       return newWhereElement
     }
 
@@ -319,10 +305,18 @@ const _initialColumns = transition => {
   return columns
 }
 
-const _rewriteQueryPath = (path, transitions) => {
+const _rewriteQueryPath = (path, transitions, options) => {
+  const alias = options?.alias
+  let hasAlias = false
+  let target = options?.previousEntity
   return path.ref.map((f, i) => {
+    if (f === alias) {
+      hasAlias = true
+      return alias
+    }
+    if (options?.previousEntity && !hasAlias) i++
     if (i === 0) {
-      const target = transitions[0].target
+      target = transitions[0].target
 
       if (typeof f === 'string') {
         return target.name
@@ -331,20 +325,23 @@ const _rewriteQueryPath = (path, transitions) => {
       if (f.id) {
         return {
           id: target.name,
-          where: _newWhere(f.where, transitions[0], f.id)
+          where: _newWhere(f.where, transitions[0], f.id, undefined, undefined, options)
         }
       }
     } else {
-      if (typeof f === 'string') {
-        const transitionMapping = transitions[i - 1].mapping.get(f)
-        return (transitionMapping && transitionMapping.ref && transitionMapping.ref[0]) || f
-      }
+      // REVISIT: alias in sub selects not yet supported
+      if (transitions[i - 1]) {
+        if (typeof f === 'string') {
+          const transitionMapping = transitions[i - 1].mapping.get(f)
+          return (transitionMapping && transitionMapping.ref && transitionMapping.ref[0]) || f
+        }
 
-      if (f.id) {
-        const transitionMapping = transitions[i - 1].mapping.get(f.id)
-        return {
-          id: (transitionMapping && transitionMapping.ref && transitionMapping.ref[0]) || f.id,
-          where: _newWhere(f.where, transitions[i], f.id)
+        if (f.id) {
+          const transitionMapping = transitions[i - 1].mapping.get(f.id)
+          return {
+            id: (transitionMapping && transitionMapping.ref && transitionMapping.ref[0]) || f.id,
+            where: _newWhere(f.where, transitions[i], f.id, undefined, undefined, options)
+          }
         }
       }
 
@@ -353,7 +350,7 @@ const _rewriteQueryPath = (path, transitions) => {
   })
 }
 
-const _newUpdate = (query, transitions, service, options) => {
+const _newUpdate = (query, transitions, options) => {
   const targetTransition = transitions.at(-1)
   const targetName = targetTransition.target.name
   const newUpdate = Object.create(query.UPDATE)
@@ -361,33 +358,32 @@ const _newUpdate = (query, transitions, service, options) => {
   newUpdate.entity = newUpdate.entity.ref
     ? {
         ...newUpdate.entity,
-        ref: _rewriteQueryPath(query.UPDATE.entity, transitions)
+        ref: _rewriteQueryPath(query.UPDATE.entity, transitions, options)
       }
     : targetName
-  if (newUpdate.data) newUpdate.data = _newData(newUpdate.data, targetTransition, false, service, options)
-  if (newUpdate.with) newUpdate.with = _newData(newUpdate.with, targetTransition, false, service, options)
+  if (newUpdate.data) newUpdate.data = _newData(newUpdate.data, targetTransition, false, options.service, options)
+  if (newUpdate.with) newUpdate.with = _newData(newUpdate.with, targetTransition, false, options.service, options)
   if (newUpdate.where) {
     newUpdate.where = _newWhere(
       newUpdate.where,
       targetTransition,
-      cds.infer(query, service.model.definitions).name,
-      query.UPDATE.entity.as
+      query._target.name,
+      query.UPDATE.entity.as,
+      undefined,
+      options
     )
   }
-  Object.defineProperty(newUpdate, '_transitions', {
-    enumerable: false,
-    value: transitions
-  })
 
   return newUpdate
 }
 
-const _newSelect = (query, transitions, service, options) => {
+const _newSelect = (query, transitions, options) => {
+  const service = options.service
   const targetTransition = transitions.at(-1)
   const newSelect = Object.create(query.SELECT)
   newSelect.from = {
     ...newSelect.from,
-    ref: _rewriteQueryPath(query.SELECT.from, transitions)
+    ref: _rewriteQueryPath(query.SELECT.from, transitions, options)
   }
 
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
@@ -416,20 +412,17 @@ const _newSelect = (query, transitions, service, options) => {
       newSelect.where,
       targetTransition,
       query.SELECT.from && query.SELECT.from.ref[0],
-      query.SELECT.from && query.SELECT.from.as
+      query.SELECT.from && query.SELECT.from.as,
+      undefined,
+      options
     )
   }
 
-  Object.defineProperty(newSelect, '_transitions', {
-    enumerable: false,
-    value: transitions
-  })
-
   return newSelect
 }
 
-const _newInsert = (query, transitions, service, options) => {
-  const targetTransition = transitions[transitions.length - 1]
+const _newInsert = (query, transitions, options) => {
+  const targetTransition = transitions.at(-1)
   const targetName = targetTransition.target.name
   const newInsert = Object.create(query.INSERT)
 
@@ -437,7 +430,7 @@ const _newInsert = (query, transitions, service, options) => {
     const refObject = newInsert.into.ref ? newInsert.into : { ref: [query.INSERT.into] }
     newInsert.into = {
       ...refObject,
-      ref: _rewriteQueryPath(refObject, transitions)
+      ref: _rewriteQueryPath(refObject, transitions, options)
     }
     if (!query.INSERT.into.ref) newInsert.into = newInsert.into.ref[0] // leave as string
   } else {
@@ -445,37 +438,29 @@ const _newInsert = (query, transitions, service, options) => {
   }
 
   if (newInsert.columns) newInsert.columns = _newInsertColumns(newInsert.columns, targetTransition)
-  if (newInsert.entries) newInsert.entries = _newEntries(newInsert.entries, targetTransition, service, options)
-  Object.defineProperty(newInsert, '_transitions', {
-    enumerable: false,
-    value: transitions
-  })
+  if (newInsert.entries) newInsert.entries = _newEntries(newInsert.entries, targetTransition, options.service, options)
 
   return newInsert
 }
 
-const _newUpsert = (query, transitions, service, options) => {
-  const targetTransition = transitions[transitions.length - 1]
+const _newUpsert = (query, transitions, options) => {
+  const targetTransition = transitions.at(-1)
   const targetName = targetTransition.target.name
   const newUpsert = Object.create(query.UPSERT)
 
   newUpsert.into = newUpsert.into.ref
     ? {
         ...newUpsert.into,
-        ref: _rewriteQueryPath(query.UPSERT.into, transitions)
+        ref: _rewriteQueryPath(query.UPSERT.into, transitions, options)
       }
     : targetName
   if (newUpsert.columns) newUpsert.columns = _newInsertColumns(newUpsert.columns, targetTransition)
-  if (newUpsert.entries) newUpsert.entries = _newEntries(newUpsert.entries, targetTransition, service, options)
-  Object.defineProperty(newUpsert, '_transitions', {
-    enumerable: false,
-    value: transitions
-  })
+  if (newUpsert.entries) newUpsert.entries = _newEntries(newUpsert.entries, targetTransition, options.service, options)
 
   return newUpsert
 }
 
-const _newDelete = (query, transitions) => {
+const _newDelete = (query, transitions, options) => {
   const targetTransition = transitions[transitions.length - 1]
   const targetName = targetTransition.target.name
   const newDelete = Object.create(query.DELETE)
@@ -483,20 +468,15 @@ const _newDelete = (query, transitions) => {
   newDelete.from = newDelete.from.ref
     ? {
         ...newDelete.from,
-        ref: _rewriteQueryPath(query.DELETE.from, transitions)
+        ref: _rewriteQueryPath(query.DELETE.from, transitions, options)
       }
     : targetName
 
   if (newDelete.where) {
     const from = typeof query.DELETE.from === 'string' ? query.DELETE.from : query.DELETE.from.ref[0]
-    newDelete.where = _newWhere(newDelete.where, targetTransition, from, query.DELETE.from.as)
+    newDelete.where = _newWhere(newDelete.where, targetTransition, from, query.DELETE.from.as, undefined, options)
   }
 
-  Object.defineProperty(newDelete, '_transitions', {
-    enumerable: false,
-    value: transitions
-  })
-
   return newDelete
 }
 
@@ -580,9 +560,7 @@ const _checkForForbiddenViews = (queryTarget, event) => {
 
   if (select) {
     if (!select.from || select.from.join || select.from.length > 1) {
-      throw getError({
-        code: 501,
-        message: `${event || 'INSERT|UPDATE|DELETE'} on views with join and/or union is not supported`,
+      throw cds.error(501, `${event || 'INSERT|UPDATE|DELETE'} on views with join and/or union is not supported`, {
         target: queryTarget.name
       })
     }
@@ -645,7 +623,7 @@ const getTransition = (queryTarget, service, skipForbiddenViewCheck, event, opti
 }
 
 const _entityTransitionsForTarget = (from, model, service, options) => {
-  let previousEntity
+  let previousEntity = options.previousEntity
 
   if (typeof from === 'string') {
     return (
@@ -657,8 +635,9 @@ const _entityTransitionsForTarget = (from, model, service, options) => {
 
   return from.ref.map((f, i) => {
     const element = f.id || f
+    if (element === options.alias) return
 
-    if (i === 0) {
+    if (i === 0 && !previousEntity) {
       const entity = model.definitions[element]
       if (entity) {
         previousEntity = entity
@@ -685,67 +664,52 @@ const _entityTransitionsForTarget = (from, model, service, options) => {
   })
 }
 
-const _newQuery = (query, model, service, options) => {
-  const { event } = options
+const resolveView = (query, model, service, abort) => {
+  // swap logger
+  const _LOG = LOG
+  LOG = cds.log(service.kind) // REVISIT: Avoid obtaining loggers per request!
+
+  // If the query is a projection, one must follow it
+  // to let the underlying service know its true entity.
+  // prettier-ignore
+  const kind = query.kind || (
+    query.SELECT ? 'SELECT' :
+    query.INSERT ? 'INSERT' :
+    query.UPSERT ? 'UPSERT' :
+    query.UPDATE ? 'UPDATE' :
+    query.DELETE ? 'DELETE' :
+    undefined
+  )
+
   const [_prop, _func] = {
     SELECT: ['from', _newSelect],
     INSERT: ['into', _newInsert],
     UPSERT: ['into', _newUpsert],
     UPDATE: ['entity', _newUpdate],
     DELETE: ['from', _newDelete]
-  }[event]
-  const newQuery = Object.create(query)
-  const transitions = _entityTransitionsForTarget(query[event][_prop], model, service, options)
-  if (!service.isDatabaseService && cds.env.features.restrict_service_scope !== false && transitions.some(t => !t))
-    return undefined
-  newQuery[event] = (transitions?.[0] && _func(newQuery, transitions, service, options)) || { ...query[event] }
-  return newQuery
-}
+  }[kind]
 
-const resolveView = (query, model, service, abort) => {
-  // swap logger
-  const _LOG = LOG
-  LOG = cds.log(service.kind) // REVISIT: Avoid obtaining loggers per request!
+  const options = { abort, event: kind, service, model }
+  const transitions = _entityTransitionsForTarget(query[kind][_prop], model, service, options)
+  if (!service.isDatabaseService && cds.env.features.restrict_service_scope !== false && transitions.some(t => !t))
+    return
 
-  // If the query is a projection, one must follow it
-  // to let the underlying service know its true entity.
-  let event
-  if (query.kind) event = query.kind
-  else if (query.SELECT) event = 'SELECT'
-  else if (query.INSERT) event = 'INSERT'
-  else if (query.UPSERT) event = 'UPSERT'
-  else if (query.UPDATE) event = 'UPDATE'
-  else if (query.DELETE) event = 'DELETE'
+  const newQuery = Object.create(query)
+  newQuery[kind] = (transitions?.[0] && _func(newQuery, transitions, options)) || { ...query[kind] }
 
-  const newQuery = _newQuery(query, model, service, { abort, event: event })
+  const target = transitions?.at(-1)?.target || query._target //> IMPORtANT!
+  Object.defineProperties(newQuery, {
+    _target: { value: target, enumerable: false, writable: true },
+    _transitions: { value: transitions }
+  })
 
   // restore logger
-  LOG = _LOG
+  LOG = _LOG // REVISIT: Don't do such global variables juggling !!!
 
   return newQuery
 }
 
-/**
- * Retrieves the actual query target by evaluating the created transitions.
- * @param {*} q - the resolved query
- * @returns {*} csn entity or undefined
- */
-const findQueryTarget = q => {
-  return q.SELECT && q.SELECT._transitions
-    ? q.SELECT._transitions[q.SELECT._transitions.length - 1].target
-    : q.INSERT
-      ? q.INSERT._transitions[q.INSERT._transitions.length - 1].target
-      : q.UPDATE
-        ? q.UPDATE._transitions[q.UPDATE._transitions.length - 1].target
-        : q.UPSERT
-          ? q.UPSERT._transitions[q.UPSERT._transitions.length - 1].target
-          : q.DELETE
-            ? q.DELETE._transitions[q.DELETE._transitions.length - 1].target
-            : undefined
-}
-
 module.exports = {
-  findQueryTarget,
   getDBTable,
   resolveView,
   getTransition,

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

@@ -1,9 +1,43 @@
 const { getNavigationIfStruct } = require('./structured')
-const getColumns = require('../../db/utils/columns')
 const { ensureNoDraftsSuffix } = require('./draft')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 const cds = require('../../../../lib')
 
+const resolveStructured = require('./resolveStructured')
+
+const _isStreamProperty = element => {
+  return element.type === 'cds.LargeBinary' || (element['@Core.MediaType'] && element['@Core.IsURL'])
+}
+
+/**
+ * This method gets all columns for an entity.
+ * It includes the generated foreign keys from managed associations, structured elements and complex and custom types.
+ * As well, it provides the annotations starting with '@' for each column.
+ *
+ * @param entity - the csn entity
+ * @returns {Array} - array of columns
+ */
+const getColumns = (entity, { omitStream } = { omitStream: false }) => {
+  // REVISIT is this correct or just a problem that occurs because of new structure we do not deal with yet?
+  if (!(entity && entity.elements)) return []
+  const columnNames = []
+  // REVISIT!!!
+  const { structs = cds.env.features.ucsn_struct_conversion } = cds.env.effective.odata
+  const elements = entity.elements
+  for (const elementName in elements) {
+    const element = elements[elementName]
+    if (element['@cds.api.ignore']) continue
+    if (omitStream && _isStreamProperty(element)) continue
+    if (element.isAssociation) continue
+    if (structs && element.elements) {
+      columnNames.push(...resolveStructured({ element, structProperties: [] }, false))
+      continue
+    }
+    columnNames.push(elementName)
+  }
+  return columnNames.map(name => elements[name] || { name })
+}
+
 const isAsteriskColumn = col => col === '*' || (col.ref && col.ref[0] === '*' && !col.expand)
 
 const isDuplicate = newColumn => column => {
@@ -14,11 +48,10 @@ const isDuplicate = newColumn => column => {
   return newColumn.ref ? newColumn.ref.join('_') === column.ref.join('_') : newColumn === column.ref.join('_')
 }
 
-const _expandColumn = (column, target, _4db) => {
+const _expandColumn = (column, target) => {
   if (!(column.ref && column.expand)) return
   const nextTarget = getNavigationIfStruct(target, column.ref)
-  if (nextTarget && nextTarget._target && nextTarget._target.elements)
-    _rewriteAsterisks(column, nextTarget._target, _4db)
+  if (nextTarget && nextTarget._target && nextTarget._target.elements) _rewriteAsterisks(column, nextTarget._target)
   return column
 }
 
@@ -65,25 +98,25 @@ const rewriteExpandAsterisk = (columns, target) => {
   }
 }
 
-const _rewriteAsterisk = (columns, target, _4db, isRoot) => {
+const _rewriteAsterisk = (columns, target, isRoot) => {
   const asteriskColumnIndex = columns.findIndex(col => isAsteriskColumn(col))
   if (asteriskColumnIndex > -1) {
     columns.splice(
       asteriskColumnIndex,
       1,
-      ...getColumns(target, { _4db, omitStream: !cds.env.features.stream_compat })
+      ...getColumns(target, { omitStream: true })
         .map(c => ({ ref: [c.name] }))
         .filter(c => !columns.find(isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
     )
   }
 }
 
-const _rewriteAsterisks = (cqn, target, _4db, isRoot) => {
+const _rewriteAsterisks = (cqn, target, isRoot) => {
   const columns = cqn.expand || cqn.columns
-  _rewriteAsterisk(columns, target, _4db, isRoot)
+  _rewriteAsterisk(columns, target, isRoot)
   rewriteExpandAsterisk(columns, target)
   for (const column of columns) {
-    _expandColumn(column, target, _4db)
+    _expandColumn(column, target)
   }
   return columns
 }
@@ -119,7 +152,7 @@ const rewriteAsterisks = (query, model, options) => {
         for (const arg of query.SELECT.from.args) {
           const _targetName = arg.ref[0].id || arg.ref[0]
           const _target = model.definitions[ensureNoDraftsSuffix(_targetName)]
-          const columns = getColumns(_target, { _4db })
+          const columns = getColumns(_target, {})
             .filter(
               c =>
                 !query.SELECT.columns.some(
@@ -135,7 +168,7 @@ const rewriteAsterisks = (query, model, options) => {
         const target = _targetOfQueryIfNotDraft(query, model)
         if (!target) return
 
-        query.SELECT.columns = getColumns(target, { _4db, omitStream: !cds.env.features.stream_compat }).map(col => ({
+        query.SELECT.columns = getColumns(target, { omitStream: true }).map(col => ({
           ref: [col.name]
         }))
       }
@@ -148,7 +181,7 @@ const rewriteAsterisks = (query, model, options) => {
   if (!target) return
 
   // REVISIT: Also support JOINs/SETs here
-  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, _4db, true)
+  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, true)
 }
 
 module.exports = {

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

@@ -1,4 +1,3 @@
-const cds = require('../../cds')
 const { ensureNoDraftsSuffix, ensureUnlocalized } = require('./draft')
 const { isDuplicate } = require('./rewriteAsterisks')
 
@@ -53,18 +52,13 @@ const handleStreamProperties = (target, columns, model) => {
     const type = element && element.type
     const mediaType = element?.['@Core.MediaType']
 
-    // new adapter handles urls correctly and just returns them as they are, okra handles them wrongly due to wrong EDM generation by compiler
-    const ignoreMediaType = cds.env.features.odata_new_adapter && mediaType && element['@Core.IsURL']
+    const ignoreMediaType = mediaType && element['@Core.IsURL']
 
     if (col === '*') {
       _addColumns(target, columns)
     } else if (col.ref && (type === 'cds.LargeBinary' || (mediaType && !ignoreMediaType))) {
-      if (mediaType) {
-        if (!element.virtual) _addColumn(name, mediaType, columns, element['@Core.IsURL'], target)
-        columns.splice(index, 1)
-      } else if (!cds.env.features.stream_compat) {
-        columns.splice(index, 1)
-      }
+      if (mediaType && !element.virtual) _addColumn(name, mediaType, columns, element['@Core.IsURL'], target)
+      columns.splice(index, 1)
     } else if (col.expand && col.ref) {
       const tgt = target.elements[col.ref] && target.elements[col.ref].target
       tgt && handleStreamProperties(model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(tgt))], col.expand, model)

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

@@ -1,2 +1,14 @@
 const MAX_WAITING_TIME = 1480000
-module.exports = x => (x > 18 ? MAX_WAITING_TIME : (Math.pow(1.5, x) + Math.random()) * 1000)
+
+function expBkfRnd(x) {
+  return x > 18 ? MAX_WAITING_TIME : (Math.pow(1.5, x) + Math.random()) * 1000
+}
+
+function expBkfFix(x) {
+  return x > 18 ? MAX_WAITING_TIME : (Math.pow(1.5, x) - 1) * 1000
+}
+
+module.exports = {
+  expBkfRnd,
+  expBkfFix
+}