@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/model/csnUtils.js

@@ -5,6 +5,8 @@ const { applyTransformations, applyTransformationsOnNonDictionary } = require('.
 const { isBuiltinType } = require('../compiler/builtins.js')
 const { sortCsn, cloneCsnDictionary: _cloneCsnDictionary } = require('../json/to-csn');
 const { ModelError } = require("../base/error");
+const { typeParameters } = require("../compiler/builtins");
+const { forEach } = require('../utils/objectUtils');
 const version = require('../../package.json').version;
 
 // Low-level utility functions to work with compact CSN.
@@ -34,11 +36,14 @@ const version = require('../../package.json').version;
  */
 
 /**
- * Get utility functions for a given CSN.
+ * Get utility functions for a given CSN. Re-exports functions of `csnRefs()`.
  * @param {CSN.Model} model (Compact) CSN model
  */
 function getUtils(model, universalReady) {
-  const { artifactRef, inspectRef, effectiveType, getOrigin, targetAspect, getColumn, getElement, initDefinition } = csnRefs(model, universalReady);
+  const _csnRefs = csnRefs(model, universalReady);
+  const { artifactRef } = _csnRefs;
+  /** Cache for getFinalBaseTypeWithProps(). Specific to the current model. */
+  const finalBaseTypeCache = Object.create(null);
 
   return {
     getCsnDef,
@@ -56,17 +61,10 @@ function getUtils(model, universalReady) {
     getServiceName,
     hasAnnotationValue,
     cloneWithTransformations,
-    getFinalBaseType,
-    inspectRef,
-    artifactRef,
-    effectiveType,
+    getFinalBaseTypeWithProps,
     get$combined,
-    getOrigin,
     getQueryPrimarySource,
-    targetAspect,
-    getColumn,
-    getElement,
-    initDefinition
+    ..._csnRefs,
   };
 
   /**
@@ -261,7 +259,7 @@ function getUtils(model, universalReady) {
    */
   function isStructured(obj) {
     return obj.elements ||
-      (obj.type && ((getFinalTypeDef(obj.type).elements) || (obj.type.ref && getFinalBaseType(obj.type).elements)));
+      (obj.type && ((getFinalTypeDef(obj.type).elements) || (obj.type.ref && getFinalBaseTypeWithProps(obj.type)?.elements)));
   }
 
   /**
@@ -486,97 +484,125 @@ function getUtils(model, universalReady) {
     }
   }
 
+  function _normalizeTypeRef(type) {
+    if (type && typeof type === 'object' && type.ref?.length === 1)
+      type = type.ref[0]; // simplify type: no element -> simple string can be used
+    return type;
+  }
 
   /**
-   * Resolve to the final type of a type, that means follow type chains, references to other types or
-   * elements a.s.o
-   * Works for all kinds of types, strings as well as type objects. Strings need to be absolute type names.
-   * Returns the final type as string (if it has a name, which is not always the case, think of embedded structures),
-   * else the type object itself is returned. If a type is structured, you can navigate into it by providing a path,
-   * e.g. given the following model
-   *     type bar: S.foo;
-   *     type s1 {
-   *       s: s2;
-   *     };
-   *     type s2 {
-   *       u: type of S.e:t;
-   *     }
-   *     service S {
-   *       type foo: type of S.e:i.j1;
-   *       entity e {
-   *         key i: { j1: Integer };
-   *         t: bar;
-   *         v: s1;
-   *         x: blutz.s.u;
-   *       };
-   *       type blutz: S.e.v;
-   *       view V as select from e {
-   *         1+1 as i: bar,
-   *       };
-   *       type tt: type of V:i;
-   *    }
-   * the following calls will all return 'cds.Integer'
-   *     getFinalBaseType('S.tt')
-   *     getFinalBaseType('S.e',['i','j1'])
-   *     getFinalBaseType('S.e',['t'])
-   *     getFinalBaseType('S.e',['x'])
-   *     getFinalBaseType('S.blutz',['s', 'u'])
-   * Types are always resolved as far as possible. A type name which has no further definition is simply returned.
-   * Composed types (structures, entities, views, ...) are returned as type objects, if not drilled down into
-   * the elements. Path steps that have no corresponding element lead to 'undefined'. Refs to something that has
-   * no type (e.g. expr in a view without explicit type) returns 'null'
+   * Resolve to the final type of a type, that means follow type chains, references, etc.
+   * Input is a fully qualified type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
+   *
+   * Returns `null` if the type can't be resolved or if the referenced element has no type,
+   * e.g. `typeof V:calculated`.
+   * Otherwise, if scalar, returns an object that has a `type` property and all collected type
+   * properties, or the type object with `elements` or `items` property if structured/arrayed.
+   *
+   * Notes:
+   *   - Caches type lookups.  If the CSN changes drastically, you will need to re-call
+   *    `csnUtils()` and use the newly returned `getFinalBaseTypeWithProps()`.
+   *   - Does _not_ return the underlying type definition! It is an object with all relevant
+   *     type properties collected while traversing the type chain!
    *
-   * @param {string|object} type Type - either string or ref
-   * @param {CSN.Path} path
-   * @param {WeakMap} [resolved=new WeakMap()] WeakMap containing already resolved refs - if a ref is not cached, it will be resolved JIT
-   * @param {object} [cycleCheck] Dictionary to remember already resolved types - to be cycle-safe
-   * @returns
+   * @param {string|object} type Type as string or type ref, i.e. `{ ref: [...] }`
+   * @returns {object|null}
    */
-  function getFinalBaseType(type, path = [], resolved = new WeakMap(), cycleCheck = undefined) {
+  function getFinalBaseTypeWithProps(type) {
+    type = _normalizeTypeRef(type);
     if (!type)
-      return type;
-    if (typeof(type) === 'string') {
-      if (isBuiltinType(type)) // built-in type
-        return type;
-      if (cycleCheck) {
-        let visited = path.length? type + ':' + path.join('.') : type;
-        if (cycleCheck[visited])
-          throw new ModelError('Circular type chain on type ' + type);
-        else
-          cycleCheck[visited] = true;
+      return null;
+
+    // Nothing to copy from builtin type name.
+    if (typeof type === 'string' && isBuiltinType( type )) {
+      return { type };
+    }
+
+    // We differentiate between ref and type to avoid collisions due to dict key.
+    // Delimiter chosen arbitrarily; just one that is rarely used.
+    const resolvedKey = (typeof type === 'object') ? `ref[${type.ref.length}]:${type.ref.join('\\')}` : `type:${type}`;
+
+    if (finalBaseTypeCache[resolvedKey]) {
+      if (finalBaseTypeCache[resolvedKey] === true)
+        throw new ModelError(`Detected circular type reference; can't resolve: ${resolvedKey}`);
+      return finalBaseTypeCache[resolvedKey];
+    }
+
+    let typeRef = artifactRef(type); // throws if not found
+    const isNonScalar = _cacheNonScalar(typeRef);
+    if (isNonScalar)
+      return finalBaseTypeCache[resolvedKey];
+
+    const props = {};
+    _copyTypeProps(props, typeRef);
+
+    // If the resolved type is a builtin, stop and use its type arguments.
+    type = _normalizeTypeRef(typeRef.type);
+    if (typeof type === 'string' && isBuiltinType(type))
+      return _cacheResolved(props);
+
+    // Set to true (before the recursive call) to avoid cyclic issues.
+    finalBaseTypeCache[resolvedKey] = true;
+
+    // Continue the search
+    const finalBase = getFinalBaseTypeWithProps(type);
+    if (!finalBase) // Reference has no proper type, e.g. due to `type of View:calculated`.
+      return _cacheResolved(null);
+    const nonScalar = _cacheNonScalar(finalBase);
+    if (nonScalar)
+      return finalBaseTypeCache[resolvedKey];
+
+    // If not a non-scalar, must be resolved type.
+    _copyTypeProps(props, finalBase);
+    _cacheResolved(props);
+    return props;
+
+    /**
+     * Cache/Store the type props under the current `resolvedKey` in the `resolved` cache.
+     *
+     * @param {object} typeProps
+     */
+    function _cacheResolved(typeProps) {
+      finalBaseTypeCache[resolvedKey] = typeProps;
+      return typeProps;
+    }
+
+    /**
+     * Structured or arrayed types are not followed further, so cache them.
+     *
+     * @param obj
+     * @returns {boolean} True, if structured/arrayed/invalid, false if scalar.
+     */
+    function _cacheNonScalar(obj) {
+      if (!obj) { // Reference has no proper type, e.g. due to `type of View:calculated`.
+        _cacheResolved(null);
+        return true;
       }
-      else {
-        cycleCheck = Object.create(null);
+      if (obj.elements || obj.items) {
+        _cacheResolved(obj);
+        return true;
       }
-      let definedType = model.definitions[type];
-      if (definedType && definedType.type)
-        return getFinalBaseType(definedType.type, path, resolved, cycleCheck);
-      else
-        return getFinalBaseType(definedType, path, resolved, cycleCheck);
+      return false;
     }
-    else if (typeof(type) === 'object') {
-      if (type.ref) {
-        // assert type.ref instanceof Array && type.ref.length >= 1
-        const ref = resolved.has(type) ? resolved.get(type).art : artifactRef(type);
-        return getFinalBaseType(ref, path, resolved, cycleCheck);
-      }
-      else if (type.elements) {
-        if (path.length) {
-          let [e, ...p] = path;
-          return getFinalBaseType(type.elements[e], p, resolved, cycleCheck);
+
+    /**
+     * Copy type properties from source to target.  Also copies `type`, `enum`,
+     * and `localized` (if keepLocalized is true).  Only copies from source,
+     * if target does not have them.
+     *
+     * @param {object} target
+     * @param {object} source
+     */
+    function _copyTypeProps(target, source) {
+      target.type = source.type;
+      const typeProps = [ ...typeParameters.list, 'enum', 'default', 'localized' ];
+      for (const param of typeProps) {
+        if (target[param] === undefined && source[param] !== undefined) {
+          target[param] = source[param];
         }
       }
-      else if (type.type)
-        return (getFinalBaseType(type.type, path, resolved, cycleCheck));
-      else if (type.items)
-        return type;
-      else
-        // TODO: this happens if we don't have a type, e.g. an expression in a select list
-        // in a view without explicit type. Instead of returning null we might want to return
-        // the object instead?
-        return null;
+      return target;
     }
-    return type;
   }
 }
 
@@ -763,32 +789,15 @@ function forEachGeneric( construct, prop, callback, path = [], iterateOptions =
     executeCallbacks( dictObj, name );
   }
   function executeCallbacks(o, name ) {
+    const p = iterateOptions.pathWithoutProp ? [ name ] : [ prop, name ];
+
     if (Array.isArray(callback))
-      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name]), construct ));
+      callback.forEach(cb => cb( o, name, prop, path.concat(p), construct ));
     else
-      callback( o, name, prop, path.concat([prop, name]), construct )
+      callback( o, name, prop, path.concat(p), construct )
   }
 }
 
-// Like Object.assign() but copies also non enumerable properties
-function assignAll(target, ...sources) {
-  sources.forEach(source => {
-    const descriptors = Object.getOwnPropertyNames(source).reduce((propertyDescriptors, current) => {
-      propertyDescriptors[current] = Object.getOwnPropertyDescriptor(source, current);
-      return propertyDescriptors;
-    }, {});
-    // by default, Object.assign copies enumerable Symbols too
-    Object.getOwnPropertySymbols(source).forEach(sym => {
-      const descriptor = Object.getOwnPropertyDescriptor(source, sym);
-      if (descriptor.enumerable) {
-        descriptors[sym] = descriptor;
-      }
-    });
-    Object.defineProperties(target, descriptors);
-  });
-  return target;
-}
-
 /**
  * @param {CSN.Query} mainQuery
  * @param {queryCallback|queryCallback[]} queryCallback
@@ -896,12 +905,10 @@ function hasAnnotationValue(artifact, annotationName, expected = true, caseInsen
  * @param {ODataOptions} options EDM specific options
  */
 function isEdmPropertyRendered(elementCsn, options) {
-  if(options.toOdata)
-    options = options.toOdata;
   // FKs are rendered in
   // V2/V4 flat: always on
   // V4 struct: on/off
-  const renderForeignKey = (options.version === 'v4' && options.odataFormat === 'structured') ? !!options.odataForeignKeys : true;
+  const renderForeignKey = (options.odataVersion === 'v4' && options.odataFormat === 'structured') ? !!options.odataForeignKeys : true;
   const isNotIgnored = !elementCsn.target ? !elementCsn['@cds.api.ignore'] : true;
   const isNavigable = elementCsn.target ?
     (elementCsn['@odata.navigable'] === undefined ||
@@ -924,16 +931,19 @@ function isEdmPropertyRendered(elementCsn, options) {
  * - For the 'plain' naming mode, it means converting all '.' to '_' and upper-casing.
  * - For the 'quoted' naming mode, this means correctly replacing some '.' with '_'.
  *
- * If the old function signature is used - with a namespace as the third argument - the result might be wrong,
- * since the '.' -> '_' conversion for quoted/hdbcds is missing.
+ * The above rules might differ for different SQL dialects.
+ * Exceptions will be listed below.
  *
  * @param {string} artifactName The fully qualified name of the artifact
- * @param {('plain'|'quoted'|'hdbcds')} sqlMapping The naming mode to use
- * @param {CSN.Model|string|undefined} csn
+ * @param {'plain'|'quoted'|'hdbcds'|string} sqlMapping The naming mode to use
+ * @param {CSN.Model} csn
+ * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming mode.
  */
-function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn) {
-  if(csn && typeof csn === 'object' && csn.definitions)
+// eslint-disable-next-line no-unused-vars
+function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn, sqlDialect='plain') {
+  if(csn && typeof csn === 'object' && csn.definitions) {
+    isValidMappingDialectCombi(sqlDialect, sqlMapping)
     if (sqlMapping === 'quoted' || sqlMapping === 'hdbcds') {
       return getResultingName(csn, sqlMapping, artifactName);
     }
@@ -942,24 +952,8 @@ function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn) {
     } else {
       throw new Error('Unknown naming mode: ' + sqlMapping);
     }
-  else {
-    console.error(`This invocation of "getArtifactCdsPersistenceName" is deprecated, as it doesn't produce correct output with definition names containing dots - please provide a CSN as the third parameter.`);
-    if (sqlMapping === 'hdbcds') {
-      if (csn) {
-        const namespace = String(csn);
-        return `${namespace}::${artifactName.substring(namespace.length + 1)}`;
-      }
-      return artifactName;
-    }
-    else if (sqlMapping === 'plain') {
-      return artifactName.replace(/\./g, '_').toUpperCase();
-    }
-    else if (sqlMapping === 'quoted') {
-      return artifactName;
-    }
-    else {
-      throw new Error('Unknown naming mode: ' + sqlMapping);
-    }
+  } else {
+    throw new Error('A valid CSN model is required to correctly calculate the database name of an artifact.');
   }
 }
 
@@ -1042,6 +1036,12 @@ function getUnderscoredName(startIndex, parts, csn) {
   return null;
 }
 
+function isValidMappingDialectCombi(sqlDialect, sqlMapping) {
+  if(sqlMapping === 'hdbcds' && sqlDialect !== 'hana')
+    throw new Error(`sqlMapping "hdbcds" must only be used with sqlDialect "hana" - found: ${sqlDialect}`);
+  return true;
+}
+
 
 /**
  *  Return the resulting database element name for 'elemName', depending on the current
@@ -1051,11 +1051,17 @@ function getUnderscoredName(startIndex, parts, csn) {
  *  - For the 'quoted' naming mode, it means converting all '.' to '_'.
  *  No other naming modes are accepted!
  *
+ *  The above rules might differ for different SQL dialects.
+ *  Exceptions will be listed below.
+ *
  * @param {string} elemName The name of the element
- * @param {('plain'|'quoted'|'hdbcds')} sqlMapping The naming mode to use
+ * @param {'plain'|'quoted'|'hdbcds'|string} sqlMapping The naming mode to use
+ * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database element name for 'elemName', depending on the current naming mode.
  */
-function getElementDatabaseNameOf(elemName, sqlMapping) {
+// eslint-disable-next-line no-unused-vars
+function getElementDatabaseNameOf(elemName, sqlMapping, sqlDialect='plain') {
+  isValidMappingDialectCombi(sqlDialect, sqlMapping)
   if (sqlMapping === 'hdbcds') {
     return elemName;
   }
@@ -1170,85 +1176,6 @@ function getNormalizedQuery(art) {
   return art;
 }
 
-/**
- * Merge multiple 'options' objects (from right to left, i.e. rightmost wins). Structured option values are
- * merged deeply. Structured option value from the right may override corresponding bool options on the left,
- * but no other combination of struct/scalar values is allowed. Array options are not merged, i.e. their
- * content is treated like scalars.
- * Returns a new options object.
- *
- * @param {...CSN.Options} optionsObjects
- * @return {CSN.Options}
- */
-function mergeOptions(...optionsObjects) {
-  let result = {};
-  for (const options of optionsObjects) {
-    if (options)
-      result = mergeTwo(result, options, 'options');
-  }
-
-  // Reverse the array to ensure that the rightmost option has priority
-  const reversedOptions = [...optionsObjects].reverse(); // de-structure and create a new array, so reverse doesn't impact optionsObject
-  const msgOptions = reversedOptions.find(opt => opt && Array.isArray(opt.messages));
-  if (msgOptions) {
-    result.messages = msgOptions.messages;
-  }
-
-  return result;
-
-  // Recursively used for scalars, too
-  function mergeTwo(left, right, name) {
-    let intermediateResult;
-    // Copy left as far as required
-    if (Array.isArray(left)) {
-      // Shallow-copy left array
-      intermediateResult = left.slice();
-    } else if (isObject(left)) {
-      // Deep-copy left object (unless empty)
-      intermediateResult = Object.keys(left).length ? mergeTwo({}, left, name) : {};
-    } else {
-      // Just use left scalar
-      intermediateResult = left;
-    }
-    // Check against improper overwriting
-    if (isObject(left) && !Array.isArray(left) && (Array.isArray(right) || isScalar(right))) {
-      throw new ModelError(`Cannot overwrite structured option "${name}" with array or scalar value`);
-    }
-    if ((isScalar(left) && typeof left !== 'boolean' || Array.isArray(left)) && isObject(right) && !Array.isArray(right)) {
-      throw new ModelError(`Cannot overwrite non-boolean scalar or array option "${name}" with structured value`);
-    }
-
-    // Copy or overwrite properties from right to left
-    if (Array.isArray(right)) {
-      // Shallow-copy right array
-      intermediateResult = right.slice();
-    } else if (isObject(right)) {
-      // Object overwrites undefined, scalars and arrays
-      if (intermediateResult === undefined || isScalar(intermediateResult) || Array.isArray(intermediateResult)) {
-        intermediateResult = {};
-      }
-      // Deep-copy right object into result
-      for (let key of Object.keys(right)) {
-        intermediateResult[key] = mergeTwo(intermediateResult[key], right[key], `${name}.${key}`);
-      }
-    } else {
-      // Right scalar wins (unless undefined)
-      intermediateResult = (right !== undefined) ? right : intermediateResult;
-    }
-    return intermediateResult;
-  }
-
-  // Return true if 'o' is a non-null object or array
-  function isObject(o) {
-    return typeof o === 'object' && o !== null
-  }
-
-  // Return true if 'o' is a non-undefined scalar
-  function isScalar(o) {
-    return o !== undefined && !isObject(o);
-  }
-}
-
 /**
 * If the artifact with the name given is part of a context (or multiple), return the top-most context.
 * Else, return the artifact itself. Namespaces are not of concern here.
@@ -1300,29 +1227,6 @@ function getLastPartOfRef(ref) {
   return getLastPartOf(lastPathStep.id || lastPathStep);
 }
 
-// Return the name of the parent artifact of the artifact 'name' or
-// '' if there is no parent.
-function getParentNameOf(name) {
-  return name.substring(0, name.lastIndexOf('.'));
-}
-
-// Return an array of parent names of 'name' (recursing into grand-parents)
-// Examples:
-//   'foo.bar.wiz' => [ 'foo.bar', 'foo' ]
-//   'foo' => []
-//   'foo::bar.wiz' => 'foo::bar'
-//   'foo::bar' => []
-function getParentNamesOf(name) {
-  let remainder = name.slice(0, -getLastPartOf(name).length);
-  if (remainder.endsWith('.')) {
-    let parentName = remainder.slice(0, -1);
-    return [parentName, ...getParentNamesOf(parentName)];
-  } else {
-    return [];
-  }
-}
-
-
 /**
  * Copy all annotations from 'fromNode' to 'toNode'.
  *
@@ -1373,49 +1277,63 @@ function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
 }
 
 /**
- * Applies annotations from `csn.extensions` to definitions, i.e. top-level artifacts.
- * Does _not_ apply element/param/action/... annotations.
+ * Applies annotations from `csn.extensions` to definitions and their elements.
+ *
  * `config.filter` can be used to only copy annotations for those definitions,
  * for which the filter returns true.
  *
+ * @todo Does _not_ apply param/action/... annotations.
+ *
  * @param {CSN.Model} csn
- * @param {{overwrite?: boolean, filter?: (name: string) => boolean}} config
+ * @param {{notFound?: (name: string, index: number) => void, override?: boolean, filter?: (name: string) => boolean}} config
+ *       notFound: Function that is called if the referenced definition can't be found.
+ *                 Second argument is index in `csn.extensions` array.
+ *       override: Whether to ignore existing annotations.
+ *       filter:   Positive filter. If it returns true, annotations for the referenced artifact
+ *                 will be applied.
  */
-function applyDefinitionAnnotationsFromExtensions(csn, config) {
+function applyAnnotationsFromExtensions(csn, config) {
   if (!csn.extensions)
     return;
 
   const filter = config.filter || ((_name) => true);
-  for (const ext of csn.extensions) {
+  for (let i = 0; i < csn.extensions.length; ++i) {
+    const ext = csn.extensions[i];
     const name = ext.annotate || ext.extend;
-    if (name && csn.definitions[name] && filter(name)) {
-      copyAnnotationsAndDoc(ext, csn.definitions[name], config.overwrite);
+    if (name && filter(name)) {
+      const def = csn.definitions[name];
+      if (def) {
+        copyAnnotationsAndDoc(ext, def, config.override);
+        applyAnnotationsToElements(ext, def);
+      } else if (config.notFound) {
+        config.notFound(name, i);
+      }
     }
   }
-}
 
-function isAspect(node) {
-  return node && node.kind === 'aspect';
-}
+  function applyAnnotationsToElements(ext, def) {
+    // Only the definition is arrayed but the extension is not since
+    // `items` is not expected in `extensions` by the CSN frontend and not
+    // generated by the CDL parser for `annotate E:arrayed.elem`.
+    if (def.items)
+      def = def.items;
 
-// For each property named 'path' in 'node' (recursively), call callback(path, node)
-function forEachPath(node, callback) {
-  if (node === null || typeof node !== 'object') {
-    // Primitive node
-    return;
-  }
-  for (let name in node) {
-    if (!Object.hasOwnProperty.call( node, name ))
-      continue;
-    // If path found within a non-dictionary, call callback
-    if (name === 'path' && Object.getPrototypeOf(node)) {
-      callback(node.path, node);
-    }
-    // Descend recursively
-    forEachPath(node[name], callback);
+    if (!ext.elements || !def.elements)
+      return;
+
+    forEach(ext.elements, (key, sourceElem) => {
+      const targetElem = def.elements[key];
+      if (targetElem) {
+        copyAnnotationsAndDoc(sourceElem, targetElem, config.override);
+        applyAnnotationsToElements(sourceElem, targetElem);
+      }
+    });
   }
 }
 
+function isAspect(node) {
+  return node && node.kind === 'aspect';
+}
 
 /**
  * Return true if the artifact has a valid, truthy persistence.exists/skip annotation
@@ -1492,16 +1410,6 @@ function getServiceNames(csn) {
   return result;
 }
 
-/**
- * Check whether the artifact is @cds.persistence.skip
- *
- * @param {CSN.Artifact} artifact
- * @returns {Boolean}
- */
-function isSkipped(artifact) {
-  return hasAnnotationValue(artifact, '@cds.persistence.skip', true)
-}
-
 /**
  * Walk path in the CSN and return the result.
  *
@@ -1589,8 +1497,7 @@ module.exports = {
   cloneCsnNonDict,
   cloneCsnDictionary,
   isBuiltinType,
-  assignAll,
-  applyDefinitionAnnotationsFromExtensions,
+  applyAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,
   forEachMember,
@@ -1610,21 +1517,16 @@ module.exports = {
   isPersistedOnDatabase,
   generatedByCompilerVersion,
   getNormalizedQuery,
-  mergeOptions,
   getRootArtifactName,
   getLastPartOfRef,
-  getParentNamesOf,
-  getParentNameOf,
   getLastPartOf,
   copyAnnotations,
   copyAnnotationsAndDoc,
   isAspect,
-  forEachPath,
   hasValidSkipOrExists,
   getNamespace,
   sortCsnDefinitionsForTests,
   getServiceNames,
-  isSkipped,
   walkCsnPath,
   getVariableReplacement,
   implicitAs,