@sap/cds-compiler 4.7.4 → 4.8.0

package/lib/json/csnVersion.js

@@ -8,8 +8,10 @@
 // (Note: the SQL name mapping mode is not reflected in the content of the csn, the version only
 // signals which default name mapping a backend has to use)
 // Historic versions:
-//  0.0.1  : Used by HANA CDS for its CSN output (incomplete, not well defined, quite different from CDX ...)
-//  0.0.2  : CDX in the initial versions with old-style CSN, default for SQL name mapping is 'quoted'
+//  0.0.1  : Used by SAP HANA CDS for its CSN output
+//           (incomplete, not well defined, quite different from CDX ...)
+//  0.0.2  : CDX in the initial versions with old-style CSN, default for SQL
+//           name mapping is 'quoted'
 //  0.0.99 : Like 0.0.2, but with new-style CSN
 // Versions that are currently produced by compiler:
 //  0.1.0  : Like 0.0.2, default for SQL name mapping is 'plain'
@@ -21,15 +23,16 @@
 const newCSNVersions = [ '0.1.99', '0.2', '0.2.0', '1.0', '2.0' ];
 
 // Check if new-style CSN is requested, i.e. versions >= 0.1.99
-function isNewCSN(csn, options) {
+function isNewCSN( csn, options ) {
   return !( options?.newCsn === false ||
         (csn.version && !newCSNVersions.includes(csn.version.csn)) ||
         (csn.$version && !newCSNVersions.includes(csn.$version)));
 }
 
-function checkCSNVersion(csn, options) {
+function checkCSNVersion( csn, options ) {
   if (!isNewCSN(csn, options)) {
     // the new transformer works only with new CSN
+    // eslint-disable-next-line global-require
     const { makeMessageFunction } = require('../base/messages');
     const { error, throwWithAnyError } = makeMessageFunction(csn, options);
 

package/lib/json/from-csn.js

@@ -119,10 +119,11 @@
  */
 
 const { dictAdd } = require('../base/dictionaries');
-// TODO: move parts of lib/compiler/builtins to some lib/base/…:
-const { isAnnotationExpression, quotedLiteralPatterns } = require('../compiler/builtins');
+const { quotedLiteralPatterns } = require('../compiler/builtins');
+const { isAnnotationExpression } = require('../base/builtins');
 const { CompilerAssertion } = require('../base/error');
-const { XsnSource, CsnLocation } = require('../compiler/classes');
+const { Location } = require('../base/location');
+const { XsnSource } = require('../compiler/xsn-model');
 
 const $location = Symbol.for('cds.$location');
 
@@ -1997,7 +1998,7 @@ function replaceZeroValue( spec, msgVariant, newValue ) {
 function location( enforceJsonPos ) {
   return !enforceJsonPos && dollarLocations.length &&
     dollarLocations[dollarLocations.length - 1] || {
-    __proto__: CsnLocation.prototype,
+    __proto__: Location.prototype,
     file: csnFilename,
     line: virtualLine,
     col: 0,
@@ -2010,7 +2011,7 @@ function pushLocation( obj ) {
   if (loc === undefined)
     return;
   if (loc && typeof loc === 'object' && !Array.isArray( loc )) {
-    dollarLocations.push( loc.line ? { __proto__: CsnLocation.prototype, ...loc } : null );
+    dollarLocations.push( loc.line ? { __proto__: Location.prototype, ...loc } : null );
     return;
   }
   else if (!loc || typeof loc !== 'string') {
@@ -2028,7 +2029,7 @@ function pushLocation( obj ) {
     const column = m[2] && Number( m[2] ) || 0;
     const file = loc.substring( 0, m.index );
     dollarLocations.push({
-      __proto__: CsnLocation.prototype, file, line, col: column,
+      __proto__: Location.prototype, file, line, col: column,
     } );
   }
 }
@@ -2123,7 +2124,7 @@ function parse( source, filename = 'csn.json', options = {}, messageFunctions =
       }
       column = end - eol + 1;
     }
-    const loc = new CsnLocation(
+    const loc = new Location(
       filename,
       line,
       column

package/lib/json/to-csn.js

@@ -232,13 +232,15 @@ function compactModel( model, options = model.options || {} ) {
     if (using.length)
       csn.requires = using;
   }
-  // 'namespace' for complete model is 'namespace' of first source
-  // (not a really useful property at all, avoids XSN inspection by Umbrella)
-  for (const first in srcDict) {
-    const { namespace } = srcDict[first];
-    if (namespace && namespace.path)
-      csn.namespace = pathName( namespace.path );
-    break;
+  if (!isBetaEnabled(options, 'v5preview')) {
+    // 'namespace' for complete model is 'namespace' of first source
+    // (not a really useful property at all, avoids XSN inspection by Umbrella)
+    for (const first in srcDict) {
+      const { namespace } = srcDict[first];
+      if (namespace?.path)
+        csn.namespace = pathName( namespace.path );
+      break;
+    }
   }
   set( 'definitions', csn, model );
   if (Object.keys(model.vocabularies || {}).length > 0)
@@ -1408,6 +1410,9 @@ function addElementAsColumn( elem, cols ) {
       setHidden( col, '$parens', parens.length );
     addLocation( (parens ? parens[parens.length - 1] : elem.value.location), col );
   }
+  else if (elem.name && !elem.name.$inferred) {
+    addLocation( elem.name.location, col );
+  }
   cols.push( extra( col, elem ) );
 }
 

package/lib/language/antlrParser.js

@@ -12,7 +12,7 @@ const antlr4 = require('antlr4');
 
 const { CompileMessage } = require('../base/messages');
 const errorStrategy = require('./errorStrategy');
-const { XsnSource } = require('../compiler/classes');
+const { XsnSource } = require('../compiler/xsn-model');
 
 const Parser = require('../gen/languageParser').default;
 const Lexer = require('../gen/languageLexer').default;

package/lib/language/genericAntlrParser.js

@@ -14,14 +14,13 @@ const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
 const { parseMultiLineStringLiteral } = require('./multiLineStringParser');
 const {
-  functionsWithoutParens,
   specialFunctions,
   quotedLiteralPatterns,
 } = require('../compiler/builtins');
+const { functionsWithoutParens } = require('../base/builtins');
+const { Location } = require('../base/location');
 const { pathName } = require('../compiler/utils');
-const {
-  XsnArtifact, XsnName, CsnLocation, XsnSource,
-} = require('../compiler/classes');
+const { XsnArtifact, XsnName, XsnSource } = require('../compiler/xsn-model');
 const { isBetaEnabled } = require('../base/model');
 const { weakLocation } = require('../base/location');
 const { normalizeNewLine, normalizeNumberString } = require('./textUtils');
@@ -500,10 +499,10 @@ function handleDuplicateExtension( ext, name, numDefines ) {
  * Return start location of `token`, or the first token matched by the current
  * rule if `token` is undefined
  *
- * @returns {CsnLocation}
+ * @returns {Location}
  */
 function startLocation( token = this._ctx.start ) {
-  return new CsnLocation(
+  return new Location(
     this.filename,
     token.line,
     token.column + 1
@@ -516,7 +515,7 @@ function startLocation( token = this._ctx.start ) {
  *
  * @param {object} token
  * @param {object} endToken
- * @return {CsnLocation}
+ * @return {Location}
  */
 function tokenLocation( token, endToken = null ) {
   if (!token)
@@ -528,7 +527,7 @@ function tokenLocation( token, endToken = null ) {
   const endLine = endToken.line;
   // after the last char (special for EOF?)
   const endCol = endToken.stop - endToken.start + endToken.column + 2;
-  const loc = new CsnLocation( this.filename, token.line, token.column + 1, endLine, endCol );
+  const loc = new Location( this.filename, token.line, token.column + 1, endLine, endCol );
 
   // This check is done for performance reason. No need to access a token's
   // data if we know that it spans only one single line.
@@ -629,7 +628,7 @@ function secureParens( expr ) {
   return {
     op: { val: 'xpr', location: this.startLocation() },
     args: [ expr ],
-    location: { __proto__: CsnLocation.prototype, ...expr.location },
+    location: { __proto__: Location.prototype, ...expr.location },
     $parens,
   };
 }
@@ -1346,7 +1345,7 @@ function argsExpression( args, nary ) {
     return args[0];
   const $parens = args[0]?.$parens;
   const loc = ($parens) ? $parens[$parens.length - 1] : args[0]?.location;
-  const location = loc ? { __proto__: CsnLocation.prototype, ...loc } : this.startLocation();
+  const location = loc ? { __proto__: Location.prototype, ...loc } : this.startLocation();
   // console.log('AE:',args);
   const op = {
     // eslint-disable-next-line no-nested-ternary

package/lib/language/multiLineStringParser.js

@@ -6,7 +6,7 @@ const {
   cdlNewLineRegEx,
 } = require('./textUtils');
 const { CompilerAssertion } = require('../base/error');
-const { CsnLocation } = require('../compiler/classes');
+const { Location } = require('../base/location');
 
 /**
  * Strips and counts the indentation from the given string.
@@ -463,7 +463,7 @@ class MultiLineStringParser {
    */
   _locationForCharacters(i, width) {
     return {
-      __proto__: CsnLocation.prototype,
+      __proto__: Location.prototype,
       file: this.parser.filename,
       line: this.token.line + this._lineInString,
       endLine: this.token.line + this._lineInString,

package/lib/language/textUtils.js

@@ -45,7 +45,7 @@ function isWhitespaceCharacterNoNewline( char ) {
  * @return {string}
  */
 function normalizeNewLine( str ) {
-  // Note: cdlNewLineRegEx does not have `g` flag and we can't use replaceAll in Node 14.
+  // Note: cdlNewLineRegEx does not have `g`.
   return str.replace(new RegExp(cdlNewLineRegEx, 'ug'), '\n');
 }
 

package/lib/main.d.ts

@@ -246,6 +246,15 @@ declare namespace compiler {
      * @see service
      */
     serviceNames?: string[]
+    /**
+     * If set, certain OData errors that are not relevant for OpenAPI generation
+     * are downgraded to warnings when generating EDM JSON.
+     *
+     * @default true
+     * @since v4.8.0
+     * @private
+     */
+    edm4OpenAPI?: boolean
   }
 
   /**
@@ -951,6 +960,20 @@ declare namespace compiler {
          */
         const keywords: string[];
       }
+      namespace h2 {
+        /**
+         * Immutable list of reserved keywords for H2. The list is used by {@link to.sql}.
+         * Taken from <http://www.h2database.com/html/advanced.html#keywords>.
+         */
+        const keywords: string[];
+      }
+      namespace postgres {
+        /**
+         * Immutable list of reserved keywords for PostgreSQL. The list is used by {@link to.sql}.
+         * Taken from <https://www.postgresql.org/docs/current/sql-keywords-appendix.html>.
+         */
+        const keywords: string[];
+      }
 
       /**
        * If the given `name` requires quoting for SQL dialect `dialect`,

package/lib/main.js

@@ -26,7 +26,7 @@ const parseLanguage = lazyload('./language/antlrParser');
 const compiler = lazyload('./compiler');
 const shared = lazyload('./compiler/shared');
 const define = lazyload('./compiler/define');
-const builtins = lazyload('./compiler/builtins');
+const builtins = lazyload('./base/builtins');
 const base = lazyload('./compiler/base');
 const finalizeParseCdl = lazyload('./compiler/finalize-parse-cdl');
 
@@ -126,6 +126,7 @@ module.exports = {
   // SNAPI
   for: {
     odata: (...args) => snapi.odata(...args),
+    java: (...args) => snapi.java(...args),
     effective: (...args) => snapi.for_effective(...args),
   },
   to: {
@@ -141,6 +142,12 @@ module.exports = {
       sqlite: {
         keywords: Object.freeze([ ...keywords.sqlite ] )
       },
+      postgres: {
+        keywords: Object.freeze([ ...keywords.postgres ] )
+      },
+      h2: {
+        keywords: Object.freeze([ ...keywords.h2 ] )
+      },
       smartId: (...args) => sqlIdentifier.smartId(...args),
       smartFunctionId: (...args) => sqlIdentifier.smartFuncId(...args),
       delimitedId: (...args) => sqlIdentifier.delimitedId(...args),

package/lib/model/cloneCsn.js

@@ -3,7 +3,7 @@
 const { csnPropertyOrder } = require('../json/to-csn');
 const { ModelError } = require('../base/error');
 const { setHidden } = require('../utils/objectUtils');
-const { isAnnotationExpression } = require('../compiler/builtins');
+const { isAnnotationExpression } = require('../base/builtins');
 
 const csnDictionaries = [
   'args',
@@ -21,16 +21,22 @@ function shallowCopy( val, _options, _sort ) {
 }
 
 const internalCsnProps = {
+  __proto__: null,
   $sources: shallowCopy,
   $location: shallowCopy,
   $path: shallowCopy,
   $paths: shallowCopy,
   elements: cloneCsnDict,
   $tableConstraints: shallowCopy,
+  $default: shallowCopy, // used for HANA CSN migrations
+  $notNull: shallowCopy, // used for HANA CSN migrations
+};
+const internalEnumerableCsnProps = {
+  __proto__: null,
+  $tableConstraints: shallowCopy, // enumerable for HANA CSN for migrations
 };
 const internalCsnPropertyNames = Object.keys(internalCsnProps);
 
-
 /**
  * Deeply clone the given CSN model and return it.
  * In testMode (or with testSortCsn), definitions are sorted.
@@ -58,18 +64,21 @@ function cloneCsn( csn, options, sort ) {
   const r = {};
   for (const n of keys) {
     const val = csn[n];
-    if (!val || typeof val !== 'object') {
-      r[n] = val;
-    }
-    else if (n.charAt(0) === '@') {
+    if (n.charAt(0) === '@') {
       r[n] = cloneAnnotationValue(val, options, false); // TODO: pass 'sort'
     }
+    else if (!val || typeof val !== 'object') {
+      r[n] = val;
+    }
     else if (csnDictionaries.includes(n) && !Array.isArray(val)) {
       const sortDict = n === 'definitions' &&
         (!options || options.testMode || options.testSortCsn);
       // Array check for property `args` which may either be a dictionary or an array.
       r[n] = cloneCsnDict(val, options, sort, sortDict);
     }
+    else if (n in internalEnumerableCsnProps) {
+      r[n] = internalEnumerableCsnProps[n](val, options, sort);
+    }
     else {
       r[n] = cloneCsn(val, options, sort);
     }

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
@@ -244,11 +244,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 +277,7 @@ function csnRefs( csn, universalReady ) {
     initDefinition,
     dropDefinitionCache,
     targetAspect,
+    msgLocations,
     __getCache_forEnrichCsnDebugging: obj => cache.get( obj ),
   };
 
@@ -324,9 +327,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 +343,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 +369,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 +379,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 +401,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 ) {
@@ -437,9 +435,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 +480,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 +652,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_;
           }
         }
@@ -734,6 +736,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`).
@@ -1021,16 +1127,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')
+  if (csnPath.length < 2 || head !== 'definitions' && head !== 'vocabularies')
     throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet');
-  const art = csn[csnPath[0]][csnPath[1]];
+  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 +1149,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 +1157,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

@@ -7,7 +7,7 @@ const {
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
 } = 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');
@@ -1414,9 +1414,6 @@ function findAnnotationExpression( node, prop ) {
 
 module.exports = {
   getUtils,
-  isBuiltinType,
-  isMagicVariable,
-  isAnnotationExpression,
   applyAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,