@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/model/csnRefs.js

@@ -171,15 +171,14 @@
 //   hierarchy, query number, table aliases and links from a column to its
 //   respective inferred element.
 
-// TODO: some `name` property would be useful (also set with `initDefinition`)
-
 // Properties in cache:
 //
 // - _effectiveType on def/member/items: cached result of effectiveType()
 // - _origin on def/member/items: the "prototype"
 // - $origin on def/member/items: whether implicit _origin refs have been set for direct members
 // - _parent: currently just use to allow ref to `up_` in anonymous aspect
-//   for managed compositions
+//   for managed compositions;
+//   in queries always the main artifact (see `$next` for name resolution)
 // - _env on non-string path item: environment provided by the ref so far,
 //    next path item is element in it
 // - _ref on non-string `type` or `from` ref, or on alias: the referred def/elem
@@ -193,10 +192,11 @@
 
 'use strict';
 
+
 const BUILTIN_TYPE = {};
-const { locationString } = require('../base/location');
+const { SemanticLocation, locationString } = require('../base/location');
 const { ModelError, CompilerAssertion } = require('../base/error');
-const { isAnnotationExpression } = require('../compiler/builtins');
+const { isAnnotationExpression } = require('../base/builtins');
 
 // Properties in which artifact or members are defined - next property in the
 // "csnPath" is the name or index of that property; 'args' (its value can be a
@@ -230,7 +230,8 @@ const referenceSemantics = {
   orderBy_ref: { lexical: query => query, dynamic: 'query' },
   orderBy_expr: { lexical: query => query, dynamic: 'source' }, // ref in ORDER BY expression
   orderBy_set_ref: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
-  // refs in ORDER BY expr in UNION not really allowed - only with table alias (of outer queries) or $self
+  // refs in ORDER BY expr in UNION not really allowed
+  // only with table alias (of outer queries) or $self
   orderBy_set_expr: { lexical: query => query.$next, dynamic: false },
   // default: { lexical: query => query, dynamic: 'source' }
 };
@@ -244,11 +245,13 @@ function justDollar() {
  * @param {boolean|string} [universalReady]
  */
 function csnRefs( csn, universalReady ) {
+  // some users exchange the dict while using csn-refs !?! see test/testDraft.js
+  // const { definitions } = csn;
   const cache = new WeakMap();
   setCache( BUILTIN_TYPE, '_origin', null );
   if (universalReady === 'init-all') {
-    for (const art of Object.values( csn.definitions || {}))
-      initDefinition( art );
+    for (const name of Object.keys( csn.definitions || {}))
+      initDefinition( name );
   }
   // Functions which set the new `baseEnv`:
   resolveRef.expandInline = function resolveExpandInline( ref, ...args ) {
@@ -275,6 +278,7 @@ function csnRefs( csn, universalReady ) {
     initDefinition,
     dropDefinitionCache,
     targetAspect,
+    msgLocations,
     __getCache_forEnrichCsnDebugging: obj => cache.get( obj ),
   };
 
@@ -324,9 +328,7 @@ function csnRefs( csn, universalReady ) {
     const target = (staticAssoc ? targetAspect( env ) : env.target || env.targetAspect);
     if (typeof target !== 'string')
       return target || env;
-    const def = csn.definitions[target];
-    initDefinition( def );
-    return def;
+    return initDefinition( target );
   }
 
   /**
@@ -342,18 +344,19 @@ function csnRefs( csn, universalReady ) {
     if (typeof ref === 'string') {
       const main = csn.definitions[ref];
       if (main)
-        return initDefinition( main );
+        return initDefinition( ref );
+      // notFound only meant for builtins and $self
+      if (notFound !== undefined)
+        return notFound;
     }
     else {
       const art = cached( ref, '_ref', artifactPathRef );
       if (art)
         return art;
+      // Backend bug workaround, TODO: delete next 2 lines
+      if (notFound !== undefined)
+        return notFound;
     }
-    if (notFound !== undefined && typeof ref === 'string')
-      return notFound;          // is only meant for builtins and $self
-    // Backend bug workaround, TODO: delete next 2 lines
-    if (notFound !== undefined)
-      return notFound;
     throw new ModelError( `Unknown artifact reference: ${ typeof ref !== 'string' ? JSON.stringify(ref.ref) : ref }` );
   }
 
@@ -367,8 +370,7 @@ function csnRefs( csn, universalReady ) {
 
   function artifactPathRef( ref ) {
     const [ head, ...tail ] = ref.ref;
-    let art = csn.definitions[pathId( head )];
-    initDefinition( art );
+    let art = initDefinition( pathId( head ) );
     for (const elem of tail) {
       const env = navigationEnv( art );
       art = env.elements[pathId( elem )];
@@ -378,8 +380,7 @@ function csnRefs( csn, universalReady ) {
 
   function artifactFromRef( ref, noLast ) {
     const [ head, ...tail ] = ref.ref;
-    let art = csn.definitions[pathId( head )];
-    initDefinition( art );
+    let art = initDefinition( pathId( head ) );
     for (const elem of tail) {
       const env = navigationEnv( art );
       art = env.elements[pathId( elem )];
@@ -401,9 +402,7 @@ function csnRefs( csn, universalReady ) {
     const targetName = refCtx !== 'keys_origin' && art.target ||
                     art.$origin && art.$origin.target ||
                     art.cast.target;
-    const target = csn.definitions[targetName];
-    initDefinition( target );
-    return target;
+    return initDefinition( targetName );
   }
 
   function getOrigin( art ) {
@@ -411,8 +410,11 @@ function csnRefs( csn, universalReady ) {
   }
 
   function getOriginRaw( art ) {
-    if (art.type)               // TODO: make robust against "linked" = only direct
-      return artifactRef( art.type, BUILTIN_TYPE );
+    if (art.type) {               // TODO: make robust against "linked" = only direct
+      return (art.type !== '$self' || csn.definitions.$self)
+        ? artifactRef( art.type, BUILTIN_TYPE )
+        : getCache( boundActionOrMain( art ), '_parent' );
+    }
     if (typeof art.$origin === 'object') // null, […], {…}
       return getOriginExplicit( art.$origin );
 
@@ -437,9 +439,8 @@ function csnRefs( csn, universalReady ) {
     if (!Array.isArray( $origin )) // anonymous prototype in $origin
       return getOriginExplicit( $origin.$origin );
     const [ head, ...tail ] = $origin;
-    const main = csn.definitions[head];
     // if (!main) throw Error(JSON.stringify({$origin,csn}))
-    initDefinition( main );
+    const main = initDefinition( head );
     return tail.reduce( originNavigation, main );
   }
 
@@ -483,8 +484,13 @@ function csnRefs( csn, universalReady ) {
   }
 
   function initDefinition( main ) {
+    const name = typeof main === 'string' && main;
+    if (name) {
+      main = csn.definitions[name];
+      setCache( main, '$name', name );
+    }
     // TODO: some --test-mode check that the argument is in ‹csn›.definitions ?
-    if (getCache( main, '$queries' ) !== undefined) // already computed
+    if (!main || getCache( main, '$queries' ) !== undefined) // already computed
       return main;
     traverseDef( main, null, null, null, initNode );
     const queries = cached( main, '$queries', allQueries );
@@ -650,7 +656,7 @@ function csnRefs( csn, universalReady ) {
           const up = getCache( parent, '_parent' );
           const target = up && typeof up.target === 'string' && csn.definitions[up.target];
           if (target && target.elements) {
-            initDefinition( target );
+            initDefinition( up.target );
             art = target.elements.up_;
           }
         }
@@ -696,7 +702,8 @@ function csnRefs( csn, universalReady ) {
     const links = path.map( (_v, idx) => ({ idx }) );
     // TODO: backends should be changed to enable uncommenting:
     // if (!art)    // does not work with test3/Associations/KeylessManagedAssociation/
-    //   throw new ModelError( `Path item 0=${ pathId( path[0] ) } refers to nothing, scope: ${ scope }`);
+    //   throw new ModelError( `Path item 0=${ pathId( path[0] )
+    //       } refers to nothing, scope: ${ scope }`);
     links[0].art = art;
     for (let i = 1; i < links.length; ++i) { // yes, starting at 1, links[0] is set above
       parent = navigationEnv( art, staticAssoc );
@@ -734,6 +741,110 @@ function csnRefs( csn, universalReady ) {
       };
   }
 
+  /**
+   * Return [ Location, SemanticLocation ] from `csnPath`.
+   */
+  function msgLocations( csnPath ) {
+    let location = csn?.$location;
+    const artifact = new SemanticLocation();
+    let obj = csn;
+    let index = 0;
+    let inlinePathIndex = null;
+    if (typeof csnPath[0] === 'object')
+      startPath( csnPath[0] );
+
+    /* eslint-disable no-return-assign */
+    const pathFunctions = {
+      definitions: name => absolute( name, 'type' ),
+      vocabularies: name => absolute( name, 'annotation' ),
+      extensions,
+      projection,
+      SELECT: projection,
+      // TODO: alias
+      mixin: name => nameInProp( name, 'mixin' ),
+      actions: name => nameInProp( name, 'action' ),
+      params: name => nameInProp( name, 'param' ),
+      returns: () => (artifact.param = ''),
+      elements: name => elements( name, artifact.select == null ? null : 'element' ),
+      columns: elements,
+      expand: elements,
+      inline: elements,
+      keys: pos => elements( pos, 'key' ),
+      enum: name => elements( name, 'enum' ),
+      item: () => (artifact.innerKind = 'item'),
+      // targetAspect: () => (artifact.innerKind = 'aspect')
+      '@': suffix,
+    }; /* eslint-enable no-return-assign */
+
+    while (obj && index < csnPath.length) {
+      const step = csnPath[index++];
+      obj = obj[step];
+      const fn = pathFunctions[step] || pathFunctions[step.charAt( 0 )];
+      if (fn)
+        fn( csnPath[index] );
+      if (obj?.$location)
+        location = obj.$location;
+    }
+    return [ location, artifact ];
+
+    function startPath( art ) {
+      const parent = getCache( art, '_parent' );
+      if (parent) {
+        if (!art.SELECT && !art.projection)
+          throw new CompilerAssertion( 'CSN path starts with object other than def or query' );
+      }
+      obj = csn.definitions;
+      absolute( getCache( parent || art, '$name' ), 'type' );
+      obj = art;
+      location = art.$location || parent?.$location || csn.$location;
+    }
+
+    function absolute( name, defaultKind ) {
+      obj = obj[name];
+      artifact.mainKind = obj.kind || defaultKind;
+      artifact.absolute = name;
+      ++index;
+    }
+    function extensions( pos ) {
+      obj = obj[pos];
+      artifact.mainKind = obj.annotate ? 'annotate' : 'extend';
+      artifact.absolute = obj.annotate || obj.extend;
+      ++index;
+    }
+    function projection() {
+      let select = getCache( obj, '$queryNumber' );
+      if (select === 1) {
+        const parent = getCache( obj, '_parent' );
+        if (parent && getCache( parent, '$queries' )?.length === 1)
+          select = 0;
+      }
+      artifact.select = select;
+    }
+    function nameInProp( name, prop ) {
+      obj = obj[name];
+      artifact[prop] = name;
+      ++index;
+    }
+    function elements( name, kind ) {
+      obj = obj[name];
+      const elem = (typeof name === 'string') ? name : !obj.inline && columnAlias( obj );
+      if (obj.inline) {         // inline
+        inlinePathIndex ??= artifact.element.length;
+      }
+      else if (inlinePathIndex != null) { // inline before: remove inline col indexes
+        if (elem)
+          artifact.element.length = inlinePathIndex;
+        inlinePathIndex = null;
+      }
+      artifact.element.push( elem || name + 1);
+      artifact.innerKind = kind || undefined;
+      ++index;
+    }
+    function suffix( prop ) {
+      artifact.suffix = prop;
+      obj = null;               // stop
+    }
+  }
   /**
    * Get the array of all (sub-)queries (value of the `SELECT`/`projection`
    * property) inside the given `main` artifact (of `main.query`).
@@ -904,8 +1015,8 @@ function queryOrMain( query, main ) {
  * - NOT on a `join` node inside `from`.
  *
  * @param {CSN.Query} query
- * @param {CSN.QuerySelect} fromSelect: for query in `from`
- * @param {CSN.Query} parentQuery: for a sub query (ex those in `from`)
+ * @param {CSN.QuerySelect} fromSelect for query in `from`
+ * @param {CSN.Query} parentQuery for a sub query (ex those in `from`)
  * @param {(query: CSN.Query&CSN.QueryFrom, select: CSN.QuerySelectEnriched, parentQuery: CSN.Query) => void} callback
  */
 function traverseQuery( query, fromSelect, parentQuery, callback ) {
@@ -1021,16 +1132,18 @@ function implicitAs( ref ) {
 function startCsnPath( csnPath, csn ) {
   const head = csnPath[0];
   if (typeof head !== 'string') {
-    const { main, parent, art } = head;
+    const {
+      main, parent, art, query,
+    } = head;
     return {
-      index: 1, main, parent, art,
+      index: 1, main, parent, art, query,
     };
   }
-  if (csnPath.length < 2 || csnPath[0] !== 'definitions' && csnPath[0] !== 'vocabularies')
-    throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet');
-  const art = csn[csnPath[0]][csnPath[1]];
+  if (csnPath.length < 2 || head !== 'definitions' && head !== 'vocabularies')
+    throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet' );
+  const art = csn[head][csnPath[1]];
   return {
-    index: 2, main: art, parent: art, art,
+    index: 2, main: art, parent: art, art, query: null,
   };
 }
 
@@ -1041,8 +1154,6 @@ function startCsnPath( csnPath, csn ) {
  * @param {any} resolve
  */
 function analyseCsnPath( csnPath, csn, resolve ) {
-  /** @type {object} */
-  let query = null;
   /** @type {any} */
   let refCtx = null;
   /** @type {boolean|string|number} */
@@ -1051,7 +1162,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
   let baseCtx = null;
   let baseEnv = null;
   let {
-    index, main, parent, art,
+    index, main, parent, art, query,
   } = startCsnPath( csnPath, csn );
   let obj = art;
 

package/lib/model/csnUtils.js

@@ -6,8 +6,9 @@ const {
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
+  mergeTransformers,
 } = require('../transform/db/applyTransformations');
-const { isBuiltinType, isMagicVariable, isAnnotationExpression } = require('../compiler/builtins.js');
+const { isBuiltinType, isAnnotationExpression } = require('../base/builtins');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
@@ -134,7 +135,8 @@ function getUtils( model, universalReady ) {
       }
       else if (arg.ref) {
         const art = artifactRef.from(arg);
-        elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || implicitAs(arg.ref), implicitAs(arg.ref) || arg.as);
+        elements = mergeElementsIntoMap(elements, art.elements, art.$location,
+                                        arg.as || implicitAs(arg.ref), implicitAs(arg.ref) || arg.as);
       }
       else if (arg.SELECT || arg.SET) {
         elements = mergeElementMaps(elements, getSources(arg, true));
@@ -670,11 +672,13 @@ function isEdmPropertyRendered( elementCsn, options ) {
   // V4 struct: on/off
   if (elementCsn == null)
     return false;
-  const renderForeignKey = (options.odataVersion === '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 ||
-     elementCsn['@odata.navigable'] !== undefined && (elementCsn['@odata.navigable'] === null || elementCsn['@odata.navigable'] === true)) : true;
+     elementCsn['@odata.navigable'] !== undefined &&
+      (elementCsn['@odata.navigable'] === null || elementCsn['@odata.navigable'] === true)) : true;
   // Foreign Keys can be ignored
   if (elementCsn['@odata.foreignKey4'])
     return isNotIgnored && renderForeignKey;
@@ -1124,7 +1128,7 @@ function moveAnnotationsAndDoc( sourceNode, targetNode, overwrite = false ) {
  *       override: Whether to ignore existing annotations.
  *       filter:   Positive filter. If it returns true, annotations for the referenced artifact
  *                 will be applied.
- *       applyToElements: Wether to apply annotations to elements or only to artifacts
+ *       applyToElements: Whether to apply annotations to elements or only to artifacts
  */
 function applyAnnotationsFromExtensions( csn, config ) {
   if (!csn.extensions)
@@ -1189,7 +1193,8 @@ function isAspect( node ) {
  */
 function hasValidSkipOrExists( artifact ) {
   return artifact.kind === 'entity' &&
-         (hasAnnotationValue(artifact, '@cds.persistence.exists', true) || hasAnnotationValue(artifact, '@cds.persistence.skip', true));
+         (hasAnnotationValue(artifact, '@cds.persistence.exists', true) ||
+          hasAnnotationValue(artifact, '@cds.persistence.skip', true));
 }
 
 /**
@@ -1368,7 +1373,8 @@ function functionList( functions, thisArg ) {
  * @returns {boolean}
  */
 function isDollarSelfOrProjectionOperand( arg ) {
-  return arg.ref && arg.ref.length === 1 && (arg.ref[0] === '$self' || arg.ref[0] === '$projection');
+  return arg.ref && arg.ref.length === 1 &&
+    (arg.ref[0] === '$self' || arg.ref[0] === '$projection');
 }
 
 /**
@@ -1408,15 +1414,11 @@ function findAnnotationExpression( node, prop ) {
       },
     });
   }
-
   return isExpr;
 }
 
 module.exports = {
   getUtils,
-  isBuiltinType,
-  isMagicVariable,
-  isAnnotationExpression,
   applyAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,
@@ -1433,6 +1435,7 @@ module.exports = {
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
+  mergeTransformers,
   setDependencies,
   isPersistedOnDatabase,
   isPersistedAsView,

package/lib/model/enrichCsn.js

@@ -42,7 +42,7 @@
 const { csnRefs, artifactProperties } = require('./csnRefs');
 const { locationString } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
-const { isAnnotationExpression } = require('../compiler/builtins');
+const { isAnnotationExpression } = require('../base/builtins');
 const shuffleGen = require('../base/shuffle');
 
 function enrichCsn( csn, options = {} ) {
@@ -207,7 +207,9 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function pathRef( parent, prop, path, inspectionPath = csnPath ) {
-    const inspection = handleError( err => ((err) ? { scope: err.toString() } : inspectRef( inspectionPath )));
+    const inspection = handleError( err => ((err)
+      ? { scope: err.toString() }
+      : inspectRef( inspectionPath )));
     const {
       links, art, scope, $env,
     } = inspection;

package/lib/model/revealInternalProperties.js

@@ -38,7 +38,8 @@ const kindsRepresentedAsLinks = {
   // represent table alias in from / join-args property as link:
   $tableAlias: tableAliasAsLink,
   // represent "navigation elements" in _combined as links:
-  $navElement: (art, parent) => art._parent && parent !== art._parent.elements && art._parent.kind !== 'aspect',
+  $navElement: (art, parent) => art._parent && parent !== art._parent.elements &&
+    art._parent.kind !== 'aspect',
   // represent mixin in $tableAliases as link:
   mixin: tableAliasAsLink,
   // represent $projection as link, as it is just another search name for $self:

package/lib/model/sortViews.js

@@ -5,8 +5,11 @@ const { ModelError } = require('../base/error');
 
 /**
  * @typedef {Object} Layers
- * @property {Array[]} layers - An array of arrays, each subarray encompassing one Layer - L0 being layers[0].
- * @property {CSN.Artifact[]} leftover - Any artifacts not sorted into a layer due to unmet dependencies - points to there being some error.
+ * @property {Array[]} layers
+ *   An array of arrays, each subarray encompassing one Layer - L0 being layers[0].
+ * @property {CSN.Artifact[]} leftover
+ *   Any artifacts not sorted into a layer due to unmet dependencies.
+ *   Points to there being some error.
  */
 
 /**
@@ -22,7 +25,8 @@ const { ModelError } = require('../base/error');
  */
 function sortTopologically( csn, _dependents, _dependencies ) {
   const layers = [];
-  let { zero, nonZero } = _calculateDepth(Object.entries(csn.definitions), _dependents, _dependencies);
+  let { zero, nonZero } = _calculateDepth(Object.entries(csn.definitions),
+                                          _dependents, _dependencies);
   while (zero.length !== 0) {
     const currentLayer = [];
     zero.forEach(([ artifactName, artifact ]) => {
@@ -87,8 +91,10 @@ function _findWithXPointers( definitionsArray, x, _dependents, _dependencies ) {
  * For ordering, only the FROM clause of views is checked - this requires A2J to
  * be run beforehand to resolve association usages.
  *
- * @param {{sql: string, csn: CSN.Model}} arg sql: Map of <object name>: "CREATE STATEMENT", csn: Model
- * @returns {{name: string, sql: string}[]} Sorted array of artifact name / "CREATE STATEMENTS" pairs
+ * @param {{sql: string, csn: CSN.Model}} arg
+ *   sql: Map of <object name>: "CREATE STATEMENT", csn: Model
+ * @returns {{name: string, sql: string}[]}
+ *   Sorted array of artifact name / "CREATE STATEMENTS" pairs
  */
 module.exports = function sortViews({ sql, csn }) {
   const { cleanup, _dependents, _dependencies } = setDependencies(csn);
@@ -98,7 +104,9 @@ module.exports = function sortViews({ sql, csn }) {
 
   const result = [];
   // keep the "artifact name" - needed for to.hdi sorting
-  layers.forEach(layer => layer.forEach(objName => result.push({ name: objName, sql: sql[objName], dependents: csn.definitions[objName][_dependents] })));
+  layers.forEach(layer => layer.forEach(objName => result.push({
+    name: objName, sql: sql[objName], dependents: csn.definitions[objName][_dependents],
+  })));
   // attach sql artifacts which are not considered during the view sorting algorithm
   // --> this is the case for "ALTER TABLE ADD CONSTRAINT" statements,
   //     because their identifiers are not part of the csn.definitions