@sap/cds 5.5.5 → 5.6.0

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

@@ -1,29 +1,11 @@
 const cds = require('../../cds')
 
 const { ensureNoDraftsSuffix } = require('./draft')
-const { getFlatArray } = require('../../db/utils/deep')
 
 const getEtagElement = entity => {
   return Object.values(entity.elements).find(element => element['@odata.etag'])
 }
 
-const _isBacklink = (assoc, parent, target) => {
-  const comps = Object.values(target.associations || {})
-    .filter(assoc => assoc._isCompositionEffective)
-    .filter(assoc => assoc.target === parent.name)
-  if (comps.length === 0) return false
-
-  let backlink = false
-  for (const comp of comps) {
-    const on = comp.on.find(ele => typeof ele === 'object' && ele.ref[0] !== '$self')
-    if (on.ref.length === 2 && on.ref[on.ref.length - 1] === assoc.name) {
-      backlink = true
-      break
-    }
-  }
-  return backlink
-}
-
 const _isDependent = (assoc, parent, target) => {
   return (
     assoc._isAssociationStrict &&
@@ -33,7 +15,7 @@ const _isDependent = (assoc, parent, target) => {
     assoc['@assert.integrity'] !== false &&
     parent['@assert.integrity'] !== false &&
     (!parent._service || parent._service['@assert.integrity'] !== false) &&
-    !_isBacklink(assoc, parent, target)
+    !assoc._isCompositionBacklink
   )
 }
 
@@ -65,18 +47,14 @@ const getDependents = (entity, model) => {
   return entity.set('__dependents', dependents)
 }
 
-const _getUps = (entity, model, previous = []) => {
+const _getUps = (entity, model) => {
   const ups = []
   for (const def of Object.values(model.definitions)) {
     if (def.kind !== 'entity') continue
     if (!def.associations) continue
-    for (const assoc of Object.values(def.associations)) {
-      if (assoc.target !== entity.name) continue
-      ups.push({
-        entity: assoc.parent,
-        assoc: assoc,
-        previous
-      })
+    for (const element of Object.values(def.associations)) {
+      if (element.target !== entity.name || element._isBacklink) continue
+      ups.push(element)
     }
   }
   return ups
@@ -86,31 +64,35 @@ const _ifDataSubject = (entity, role) => {
   return entity['@PersonalData.EntitySemantics'] === 'DataSubject' && entity['@PersonalData.DataSubjectRole'] === role
 }
 
-const getDataSubject = (entity, model, role) => {
-  const hash = '__dataSubject4' + role
-  if (entity.own(hash)) return entity[hash]
-
-  if (_ifDataSubject(entity, role)) return entity.set(hash, { entity: entity, assoc: [], previous: [] })
-
-  let dataSubject
-  let ups = _getUps(entity, model)
-  while (!dataSubject) {
-    for (const { entity, assoc, previous } of ups) {
-      if (_ifDataSubject(entity, role)) dataSubject = { entity, assoc, previous }
+const _getDataSubjectUp = (role, model, element, first = element) => {
+  const upElements = _getUps(element.parent, model)
+  for (const element of upElements) {
+    if (_ifDataSubject(element.parent, role)) {
+      return { element: first, up: { element }, entity: element.parent }
+    }
+    // dfs is a must here
+    const dataSubject = _getDataSubjectUp(role, model, element, first)
+    if (dataSubject) {
+      dataSubject.up = { element, up: dataSubject.up }
+      return dataSubject
     }
-    if (dataSubject) break
-    ups = getFlatArray([
-      ...ups.map(up => [..._getUps(up.entity, model, up.previous.concat({ entity: up.entity, assoc: up.assoc }))])
-    ])
   }
+}
 
-  return entity.set(hash, dataSubject)
+const getDataSubject = (entity, model, role, element) => {
+  const hash = '__dataSubject4' + role
+  if (entity.own(hash)) return entity[hash]
+  if (_ifDataSubject(element.parent, role)) return entity.set(hash, { element, entity: element.parent })
+  return entity.set(hash, _getDataSubjectUp(role, model, element))
 }
 
-const _findRootEntity = (entities, edmName) => {
+const _resolve = (name, model, namespace) =>
+  model.entities(namespace)[name] || model.definitions[`${namespace}.${name}`]
+
+const _findRootEntity = (model, edmName, namespace) => {
   const parts = edmName.split('_')
   let csnName = parts.shift()
-  let target = entities[csnName]
+  let target = _resolve(csnName, model, namespace)
   const len = parts.length
   // try to find a correct entity "greedy" and count leftovers (x4 case below)
   // e.g. we have 2 entities: 'C_root_' and dependant 'C_root_.kid_'
@@ -124,10 +106,10 @@ const _findRootEntity = (entities, edmName) => {
      * if target in entities connect with .
      * if target not in entities connect with _
      */
-    csnName = `${csnName}${entities[csnName] ? '.' : '_'}${parts[i]}`
+    csnName = `${csnName}${_resolve(csnName, model, namespace) ? '.' : '_'}${parts[i]}`
     ++acc
-    if (entities[csnName]) {
-      target = entities[csnName]
+    if (_resolve(csnName, model, namespace)) {
+      target = _resolve(csnName, model, namespace)
       left -= acc
       acc = 0
     }
@@ -145,12 +127,13 @@ const findCsnTargetFor = (edmName, model, namespace) => {
 
   if (mapping[edmName]) return mapping[edmName]
 
-  const entities = model.entities(namespace)
   // simple cases
-  let target = entities[edmName] || entities[edmName.replace(/_/g, '.')]
+  let target = _resolve(edmName, model, namespace) || _resolve(edmName.replace(/_/g, '.'), model, namespace)
+
+  // hard cases
   if (!target) {
     // probably, a combination of '_' and '.', resolving
-    const finding = _findRootEntity(entities, edmName)
+    const finding = _findRootEntity(model, edmName, namespace)
     target = finding.target
     // something left in navigation path => x4 navigation
     // resolving within found entity
@@ -203,11 +186,26 @@ const isRootEntity = (definitions, entityName) => {
   return true
 }
 
+function alias2ref(service, edm) {
+  const defs = edm[service.definition.name]
+  for (const each of Object.values(service.entities)) {
+    const def = defs[each.name.replace(service.definition.name + '.', '').replace(/\./g, '_')]
+    if (!def || !def.$Key || def.$Key.every(ele => typeof ele === 'string')) continue
+    each._alias2ref = {}
+    for (const mapping of def.$Key.filter(ele => typeof ele !== 'string')) {
+      for (const [key, value] of Object.entries(mapping)) {
+        each._alias2ref[key] = value.split('/')
+      }
+    }
+  }
+}
+
 module.exports = {
   getEtagElement,
   findCsnTargetFor,
   getElementDeep,
   getDependents,
   isRootEntity,
-  getDataSubject
+  getDataSubject,
+  alias2ref
 }

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

@@ -1,93 +1,6 @@
-const cds = require('../../cds')
-
-const _generateParentField = (foreignKeyPropagations, row) => {
-  if (
-    foreignKeyPropagations.parentFieldName &&
-    !row[foreignKeyPropagations.parentFieldName] &&
-    foreignKeyPropagations.autoGenerate
-  ) {
-    row[foreignKeyPropagations.parentFieldName] = cds.utils.uuid()
-  }
-}
-
-const _generateChildField = (foreignKeyPropagations, childRow) => {
-  if (foreignKeyPropagations.deep) {
-    const deep = foreignKeyPropagations.deep
-    _generateChildField(deep.propagation, childRow[deep.targetName])
-  } else if (childRow && !childRow[foreignKeyPropagations.childFieldName] && foreignKeyPropagations.autoGenerate) {
-    childRow[foreignKeyPropagations.childFieldName] = cds.utils.uuid()
-  }
-}
-
-const _getNestedVal = (row, prefix) => {
-  let val = row
-  const splitted = prefix.split('_')
-  let k = ''
-
-  while (splitted.length > 0) {
-    k += splitted.shift()
-    if (k in val) {
-      val = val[k]
-      k = ''
-    } else {
-      k += '_'
-    }
-  }
-
-  return val
-}
-
-const _propagateToChid = (foreignKeyPropagation, row, childRow) => {
-  const { parentFieldName, childFieldName, prefix, parentFieldValue } = foreignKeyPropagation
-
-  if (parentFieldName) {
-    if (prefix) {
-      const nested = _getNestedVal(row, prefix)
-      childRow[childFieldName] = nested[parentFieldName]
-    } else {
-      childRow[childFieldName] = row[parentFieldName]
-    }
-  } else if (parentFieldValue !== undefined) {
-    childRow[childFieldName] = parentFieldValue
-  }
-}
-
-const _propagateToParent = (foreignKeyPropagations, childRow, row) => {
-  if (foreignKeyPropagations.deep) {
-    const deep = foreignKeyPropagations.deep
-    _propagateToParent(deep.propagation, childRow[deep.targetName], childRow)
-  }
-
-  if (childRow && Object.prototype.hasOwnProperty.call(childRow, foreignKeyPropagations.childFieldName)) {
-    row[foreignKeyPropagations.parentFieldName] = childRow[foreignKeyPropagations.childFieldName]
-  }
-}
-
-const propagateForeignKeys = (tKey, row, foreignKeyPropagations, opts = {}) => {
-  const childRows = Array.isArray(row[tKey]) ? row[tKey] : [row[tKey]]
-
-  for (const childRow of childRows) {
-    if (!childRow) return
-
-    for (const foreignKeyPropagation of foreignKeyPropagations) {
-      if (foreignKeyPropagation.fillChild) {
-        _generateParentField(foreignKeyPropagation, row)
-        if (opts.onlyWriteCompositionEffective && !foreignKeyPropagations._element._isCompositionEffective) {
-          delete row[tKey]
-        } else {
-          _propagateToChid(foreignKeyPropagation, row, childRow)
-        }
-      } else {
-        _generateChildField(foreignKeyPropagation, childRow)
-        _propagateToParent(foreignKeyPropagation, childRow, row)
-      }
-    }
-  }
-}
-
-const _getSubOns = on => {
+const _getSubOns = element => {
   // this only works for on conds with `and`, once we support `or` this needs to be adjusted
-  const newOn = on.filter(e => e !== '(' && e !== ')')
+  const newOn = element.on ? element.on.filter(e => e !== '(' && e !== ')') : []
   const subOns = []
   let currArr = []
 
@@ -108,8 +21,6 @@ const _getSubOns = on => {
   return subOns
 }
 
-const _autoGenerate = el => el && el.type === 'cds.UUID' && el.key
-
 const _parentFieldsFromSimpleOnCond = (element, subOn) => {
   const idxChildField = subOn.findIndex(o => o.ref && o.ref[0] === element.name)
   if (idxChildField === -1 || subOn[1] !== '=') return
@@ -124,26 +35,20 @@ const _parentFieldsFromSimpleOnCond = (element, subOn) => {
     if (idxChildInParent > -1) parentRef.splice(idxChildInParent, 1)
     parentRef = [parentRef.join('_')]
   }
+  const parentElement = parentRef && element.parent.elements[parentRef[0]]
 
   if (!childElement) {
     // update on view with key in parent
-
-    return [
-      {
-        fillChild: false,
-        childFieldName,
-        parentFieldName: parentRef[0],
-        autoGenerate: _autoGenerate(element.parent.elements[parentRef[0]])
-      }
-    ]
+    return [{ fillChild: false, parentElement, childElement }]
   }
 
-  if (!childElement.on && parentRef && parentRef.length === 1) {
-    return _foreignKeyPropagationsFromToManyOn(element, parentRef, childFieldName)
+  if (!childElement.on) {
+    if (element._isSelfManaged) return _foreignKeyPropagationsFromToManyOn(element, childFieldName)
+    if (parentElement) return [{ fillChild: true, parentElement, childElement }]
   }
 
   if ('val' in subOn[idxParentField]) {
-    return _foreignKeyPropagationsFromStaticOn(childFieldName, idxParentField, subOn)
+    return [{ fillChild: true, parentFieldValue: subOn[idxParentField].val, childElement }]
   }
 
   if (childElement._isAssociationStrict && childElement.on) {
@@ -151,40 +56,19 @@ const _parentFieldsFromSimpleOnCond = (element, subOn) => {
   }
 }
 
-const _foreignKeyPropagationsFromStaticOn = (childFieldName, idxParentField, subOn) => {
-  if (childFieldName) {
-    return [{ fillChild: true, parentFieldValue: subOn[idxParentField].val, childFieldName }]
-  }
-}
-
-const _foreignKeyPropagationsFromToManyOn = (element, parentRef, childFieldName) => {
-  const parentFieldName = parentRef[0]
-  if (parentFieldName === '$self') {
-    const foreignKeys = _foreignKeysForTarget(element, childFieldName)
-
-    // REVISIT foreignKeys is empty if we have deep operations where a sub element is annotated with persistence skip
-    if (foreignKeys && foreignKeys.length) {
-      const parentKeys = _parentKeys(element)
-
-      return resolvedKeys(parentKeys, foreignKeys, true)
-    }
-
-    return []
+const _foreignKeyPropagationsFromToManyOn = (element, childFieldName) => {
+  const foreignKeys = _foreignKeysForTarget(element, childFieldName)
+  // REVISIT foreignKeys is empty if we have deep operations where a sub element is annotated with persistence skip
+  if (foreignKeys && foreignKeys.length) {
+    const parentKeys = _parentKeys(element)
+    return _resolvedKeys(parentKeys, foreignKeys, true)
   }
-
-  return [
-    {
-      fillChild: true,
-      childFieldName,
-      parentFieldName,
-      autoGenerate: _autoGenerate(element.parent.elements[parentFieldName])
-    }
-  ]
+  return []
 }
 
 const _foreignKeyPropagationsFromCustomBacklink = (element, childElement) => {
   const foreignKeyPropagations = []
-  const subOns = _getSubOns(childElement.on)
+  const subOns = _getSubOns(childElement)
 
   for (const subOn of subOns) {
     if (subOn[1] === '=') {
@@ -192,20 +76,26 @@ const _foreignKeyPropagationsFromCustomBacklink = (element, childElement) => {
       const otherFieldIdx = parentFieldIdx === 0 ? 2 : 0
       const otherField = subOn[otherFieldIdx]
 
-      if (otherField.ref && otherField.ref.length === 1) {
+      if (parentFieldIdx === -1 && subOn[otherFieldIdx === 0 ? 2 : 0].val !== undefined) {
+        const parentField = subOn[otherFieldIdx === 0 ? 2 : 0]
+        foreignKeyPropagations.push({
+          fillChild: false,
+          parentFieldValue: parentField.val,
+          childElement: element._target.elements[otherField.ref[0]]
+        })
+      } else if (otherField.ref && otherField.ref.length === 1) {
         const parentFieldName = subOn[parentFieldIdx].ref[1]
         foreignKeyPropagations.push({
           fillChild: true,
-          parentFieldName,
-          childFieldName: otherField.ref[0],
-          autoGenerate: _autoGenerate(element.parent.elements[parentFieldName])
+          parentElement: element.parent.elements[parentFieldName],
+          childElement: element._target.elements[otherField.ref[0]]
         })
       } else if (otherField.val !== undefined) {
         const parentFieldName = subOn[parentFieldIdx] && subOn[parentFieldIdx].ref[1]
         const parentField = subOn[otherFieldIdx === 2 ? 0 : 2]
         foreignKeyPropagations.push({
           fillChild: true,
-          parentFieldName,
+          parentElement: element.parent.elements[parentFieldName],
           parentFieldValue: parentField.val,
           childFieldValue: otherField.val
         })
@@ -216,8 +106,8 @@ const _foreignKeyPropagationsFromCustomBacklink = (element, childElement) => {
   return foreignKeyPropagations
 }
 
-const _foreignKeyPropagationsFromOn = (element, on) => {
-  const subOns = _getSubOns(on)
+const _foreignKeyPropagationsFromOn = element => {
+  const subOns = _getSubOns(element)
   const foreignKeyPropagations = []
 
   for (const subOn of subOns) {
@@ -265,10 +155,9 @@ const _resolve4struct = (others, struct, fkps, fillChild, childIsStruct, i) => {
 
       // push propagation
       fkps.push({
-        childFieldName: childIsStruct ? current.name : other.name,
-        parentFieldName: childIsStruct ? other.name : current.name,
+        childElement: childIsStruct ? current : other,
+        parentElement: childIsStruct ? other : current,
         fillChild,
-        autoGenerate: _autoGenerate(other),
         prefix,
         deep: !fillChild && _resolveTargetForeignKey(childIsStruct ? current : other)
       })
@@ -285,11 +174,11 @@ const _resolveTargetForeignKey = targetKey => {
   const targetName = targetKey['@odata.foreignKey4']
   if (!targetName) return
   const _foreignKeyProps = foreignKeyPropagations(targetKey.parent.elements[targetName])
-  const propagation = _foreignKeyProps.find(_fkp => targetKey.name === _fkp.parentFieldName)
+  const propagation = _foreignKeyProps.find(_fkp => _fkp.parentElement && targetKey.name === _fkp.parentElement.name)
   return { targetName, propagation }
 }
 
-const resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
+const _resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
   const foreignKeyPropagations = []
 
   for (let i = 0; i < foreignKeys.length; i++) {
@@ -302,9 +191,8 @@ const resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
     } else {
       foreignKeyPropagations.push({
         fillChild,
-        childFieldName: tk.name,
-        autoGenerate: _autoGenerate(tk),
-        parentFieldName: fk.name,
+        parentElement: fk,
+        childElement: tk,
         // needed only for child -> parent propagation since template loops in other direction
         deep: !fillChild && _resolveTargetForeignKey(tk)
       })
@@ -314,32 +202,23 @@ const resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
   return foreignKeyPropagations
 }
 
-const _foreignKeyPropagations = element => {
+const foreignKeyPropagations = element => {
   if (element.is2many && element.on) {
-    return _foreignKeyPropagationsFromOn(element, element.on)
+    return _foreignKeyPropagationsFromOn(element)
   }
-
   if (element.is2one) {
     if (!element.on) {
       const foreignKeys = _foreignKeys(element)
-
       if (foreignKeys) {
         const targetKeys = _targetKeys(element)
-        return resolvedKeys(foreignKeys, targetKeys)
+        return _resolvedKeys(foreignKeys, targetKeys)
       }
-
-      return []
     } else {
       // It's a link through a backlink
-      return _foreignKeyPropagationsFromOn(element, element.on)
+      return _foreignKeyPropagationsFromOn(element)
     }
   }
-}
-
-const foreignKeyPropagations = element => {
-  const foreignKeyProps = _foreignKeyPropagations(element)
-  if (foreignKeyProps) foreignKeyProps._element = element
-  return foreignKeyProps
+  return []
 }
 
 const _foreignKeys = csnElement => {
@@ -365,20 +244,6 @@ const _parentKeys = csnElement => {
   )
 }
 
-const _structPrefix = csnElement => {
-  if (csnElement.parent && csnElement.parent._isStructured) {
-    const prefix = _structPrefix(csnElement.parent)
-    if (!prefix) return csnElement.parent.name + '_'
-    return prefix + csnElement.parent.name + '_'
-  }
-
-  return ''
-}
-
 module.exports = {
-  foreignKeyPropagations,
-  propagateForeignKeys,
-  _foreignKeys,
-  _targetKeys,
-  _structPrefix
+  foreignKeyPropagations
 }

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

@@ -1,26 +1,23 @@
-const { foreignKeyPropagations } = require('./foreignKeyPropagations')
-const { _structPrefix } = require('./foreignKeyPropagations')
-
 const _toRef = (alias, column) => {
   if (Array.isArray(column)) column = column.join('_')
   return { ref: alias ? [alias, column] : [column] }
 }
 
-const _adaptOnConditionElements = (onCond, associationName, selectAlias, joinAlias) => {
+const _adaptRefs = (onCond, path, { select, join }) => {
   const adaptedOnCondition = onCond.map(el => {
     const ref = el.ref
 
     if (ref) {
-      if (ref[0] === associationName.join('_') && ref[1]) {
-        return _toRef(selectAlias, ref.slice(1))
+      if (ref[0] === path.join('_') && ref[1]) {
+        return _toRef(select, ref.slice(1))
       }
 
       // no alias for special $user of canonical localized association
-      if (ref[0] === '$user' && associationName[0] === 'localized') {
+      if (ref[0] === '$user' && path[0] === 'localized') {
         return _toRef(undefined, ref.slice(0))
       }
 
-      return _toRef(joinAlias, ref.slice(0))
+      return _toRef(join, ref.slice(0))
     }
 
     return el
@@ -29,8 +26,7 @@ const _adaptOnConditionElements = (onCond, associationName, selectAlias, joinAli
   return adaptedOnCondition
 }
 
-const _args = (csnElement, options) => {
-  const { associationNames, csn, aliases } = options
+const _args = (csnElement, path, aliases) => {
   const onCond = csnElement.on
 
   if (!onCond || !onCond.length) {
@@ -41,86 +37,60 @@ const _args = (csnElement, options) => {
     return onCond
   }
 
-  if ((onCond[0].ref && onCond[0].ref[0] === '$self') || (onCond[2].ref && onCond[2].ref[0] === '$self')) {
-    const target =
-      onCond[0].ref[0] === '$self' ? onCond[2].ref[onCond[2].ref.length - 1] : onCond[0].ref[onCond[0].ref.length - 1]
-
-    const oc = getOnCondNew(csn.definitions[csnElement.target].elements[target], {
-      associationNames: target,
-      csn,
-      // revert join and select aliases because of backlink
-      aliases: { select: aliases.join, join: aliases.select }
-    })
-
-    if (onCond.some(ele => ele === 'and')) {
-      const and = _adaptOnConditionElements(
-        onCond.slice(onCond.findIndex(ele => ele === 'and') + 1),
-        associationNames,
-        aliases.select,
-        aliases.join
-      )
-      oc.push('and', ...and)
-    }
+  if (!csnElement._isSelfManaged) return _adaptRefs(onCond, path, aliases)
+
+  // revert join and select aliases because of backlink
+  const oc = _newOnConditions(csnElement._backlink, [csnElement._backlink.name], {
+    select: aliases.join,
+    join: aliases.select
+  })
 
-    return oc
+  if (onCond.some(e => e === 'and')) {
+    // managed with ON-conditions must contain `$self`, which we replace with `oc`
+    const onCondWithouSelf = _adaptRefs(_onCondWithout$self(onCond), path, aliases)
+    oc.push('and', ...onCondWithouSelf)
   }
 
-  return _adaptOnConditionElements(onCond, associationNames, aliases.select, aliases.join)
+  return oc
 }
 
-const _foreignToOn = (csnElement, options) => {
-  const { aliases } = options
-  const on = []
-  const foreignKeys = foreignKeyPropagations(csnElement)
+const _isSelfRef = e => e && e.ref && e.ref[0] === '$self'
 
-  // for external services, there might be no foreign keys
-  if (!foreignKeys) return on
+const _onCondWithout$self = onCond => {
+  const onCondWithoutSelf = [...onCond]
+  const selfIndex = onCondWithoutSelf.findIndex((e, i, on) => {
+    if (e === 'and') return _isSelfRef(on[i + 1]) || _isSelfRef(on[i + 3])
+    return on[i + 1] === '=' && (_isSelfRef(e) || _isSelfRef(on[i + 2]))
+  })
+  onCondWithoutSelf.splice(selfIndex, 4)
+  return onCondWithoutSelf
+}
 
-  for (const key of foreignKeys) {
+const _foreignToOn = (csnElement, path, { select, join }) => {
+  // this is only for 2one managed w/o ON-conditions i.e. no static values are possible
+  const on = []
+  for (const key of csnElement._foreignKeys) {
     if (on.length !== 0) {
       on.push('and')
     }
-
-    // TODO static values possible here?
-
-    const ref1 = _toRef(aliases.select, key.prefix ? `${key.prefix}_${key.childFieldName}` : key.childFieldName)
-    const structPrefix = _structPrefix(csnElement)
-    const ref2 = _toRef(aliases.join, `${structPrefix}${key.parentFieldName}`)
+    const ref1 = _toRef(select, key.prefix ? `${key.prefix}_${key.childElement.name}` : key.childElement.name)
+    const structPrefix = path.length > 1 ? path.slice(0, -1) : []
+    const ref2 = _toRef(join, [...structPrefix, key.parentElement.name])
     on.push(ref1, '=', ref2)
   }
-
   return on
 }
 
-/**
- * Gets the `ON` conditions in CQN format based on the CSN.
- *
- * @param {object} csnElement
- * @param {import('../../types/api').ONConditionOptions} [options]
- * @returns {Array}
- * @private
- */
-function getOnCondNew(csnElement, options) {
-  const defaultOptions = {
-    aliases: {},
-    resolveView: true
-  }
-  options = { ...defaultOptions, ...options }
-  const { associationNames } = options
-
-  if (!Array.isArray(associationNames)) {
-    options.associationNames = [associationNames]
-  }
-
+const _newOnConditions = (csnElement, path, aliases) => {
   if (csnElement.keys) {
-    return _foreignToOn(csnElement, options)
+    return _foreignToOn(csnElement, path, aliases)
   }
 
-  return _args(csnElement, options)
+  return _args(csnElement, path, aliases)
 }
 
-const getOnCond = (...args) => {
-  return ['(', ...getOnCondNew(...args), ')']
+const getOnCond = (csnElement, path = [], aliases = { select: '', join: '' }) => {
+  return ['(', ..._newOnConditions(csnElement, path, aliases), ')']
 }
 
 module.exports = {