@sap/cds-compiler 3.5.4 → 3.6.0

package/lib/model/csnUtils.js

@@ -8,7 +8,7 @@ const {
   cloneCsnDictionary: _cloneCsnDictionary,
   cloneAnnotationValue: _cloneAnnotationValue,
 } = require('../json/to-csn');
-const { ModelError } = require('../base/error');
+const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
 const { version } = require('../../package.json');
@@ -44,6 +44,7 @@ const { version } = require('../../package.json');
  * @param {CSN.Model} model (Compact) CSN model
  */
 function getUtils( model, universalReady ) {
+  const special$self = !model?.definitions?.$self && '$self';
   const _csnRefs = csnRefs(model, universalReady);
   const { artifactRef } = _csnRefs;
   /** Cache for getFinalBaseTypeWithProps(). Specific to the current model. */
@@ -53,13 +54,11 @@ function getUtils( model, universalReady ) {
     getCsnDef,
     isStructured,
     getFinalType,
-    getFinalTypeDef,
     isManagedAssociation,
     isAssocOrComposition,
     isAssociation,
     isComposition,
     getArtifactDatabaseNameOf,
-    getNamespaceOfArtifact,
     getContextOfArtifact,
     addStringAnnotationTo,
     getServiceName,
@@ -219,31 +218,6 @@ function getUtils( model, universalReady ) {
     return undefined;
   }
 
-
-  /**
-   * Create an object to track visited objects identified by a unique string.
-   * @param {string} [initialId] Initial entry (optional)
-   */
-  function createVisited( initialId ) {
-    const visited = Object.create(null);
-    check(initialId);
-    return { check };
-
-    /**
-     * Check if an identifier has already been visited and
-     * add it to the list of visited identifiers.
-     * @param {string} id unique identifier
-     */
-    function check( id ) {
-      if (!id)
-        return;
-      if (visited[id])
-        throw new ModelError('Circular dependency');
-
-      visited[id] = true;
-    }
-  }
-
   /**
    * Get the CSN definition for an artifact name.
    * @param {string} defName Absolute name of the artifact
@@ -265,41 +239,15 @@ function getUtils( model, universalReady ) {
     return !!(obj.elements || (obj.type && getFinalBaseTypeWithProps(obj.type)?.elements));
   }
 
-  /**
-   * Resolves typedefs to its final typedef which is returned.
-   * If the artifact for typename isn't a typedef, the name itself is returned.
-   *
-   * @param {string} typeName Absolute type name
-   * @returns {object}
-   */
-  function getFinalTypeDef( typeName ) {
-    const visited = createVisited(typeName);
-    let type = model.definitions[typeName];
-    if (!type)
-      return typeName;
-
-    for (let nextType = type; nextType;) {
-      type = nextType;
-      visited.check(type.type);
-      nextType = model.definitions[nextType.type];
-    }
-    return type;
-  }
-
   /**
    * Resolves typedefs to its final type (name) which is returned.
-   * @param {string} typeName Absolute type name
-   * @returns {string}
+   * @param {string|object} typeName Absolute type name or type ref ({ref: [...]}).
+   * @returns {string|object}
    */
   function getFinalType( typeName ) {
-    const visited = createVisited(typeName);
-    let type = model.definitions[typeName];
-    while (type && type.type) {
-      typeName = type.type;
-      visited.check(typeName);
-      type = model.definitions[typeName];
-    }
-    return typeName;
+    if (!typeName)
+      return typeName;
+    return getFinalBaseTypeWithProps(typeName)?.type || null;
   }
 
   // Return true if 'node' is a managed association element
@@ -309,77 +257,33 @@ function getUtils( model, universalReady ) {
   }
 
   /**
-   * Returns if a type is an association or a composition or a typedef
-   * to any of them.
+   * Returns if a type is an association or a composition (possibly via type chain).
+   *
    * @param {string} typeName Absolute type name
    */
   function isAssocOrComposition( typeName ) {
-    if (typeName === 'cds.Association' || typeName === 'cds.Composition')
-      return true;
-    const visited = createVisited(typeName);
-    let type = model.definitions[typeName];
-    while (type) {
-      if (type.type === 'cds.Association' || type.type === 'cds.Composition')
-        return true;
-      visited.check(type.type);
-      type = model.definitions[type.type];
-    }
-    return false;
+    const finalType = getFinalType( typeName );
+    return (finalType === 'cds.Association' || finalType === 'cds.Composition');
   }
 
   /**
-   * Returns if a type is an association or a typedef to it.
+   * Returns true if a type is an association (possibly via type chain).
+   *
    * @param {string} typeName Absolute type name
    */
   function isAssociation( typeName ) {
-    if (typeName === 'cds.Association')
-      return true;
-    const visited = createVisited(typeName);
-    let type = model.definitions[typeName];
-    while (type) {
-      if (type.type === 'cds.Association')
-        return true;
-      visited.check(type.type);
-      type = model.definitions[type.type];
-    }
-    return false;
+    const finalType = getFinalType( typeName );
+    return (finalType === 'cds.Association');
   }
 
   /**
-   * Returns if a type is an composition or a typedef to it.
+   * Returns if a type is a composition (possibly via type chain).
+   *
    * @param {string} typeName Absolute type name
    */
   function isComposition( typeName ) {
-    if (typeName === 'cds.Composition')
-      return true;
-    const visited = createVisited(typeName);
-    let type = model.definitions[typeName];
-    while (type) {
-      if (type.type === 'cds.Composition')
-        return true;
-      visited.check(type.type);
-      type = model.definitions[type.type];
-    }
-    return false;
-  }
-
-  /**
-   * Return the namespace part of the artifact name.
-   * @param {string} name Absolute name of artifact
-   */
-  function getNamespaceOfArtifact( name ) {
-    let lastDotIdx = name.lastIndexOf('.');
-    if (lastDotIdx === -1)
-      return undefined;
-    while (model.definitions[name]) {
-      if (model.definitions[name].kind === 'namespace')
-        return name;
-      lastDotIdx = name.lastIndexOf('.');
-      if (lastDotIdx === -1)
-        return undefined;
-      name = name.substring(0, lastDotIdx);
-    }
-    return name;
+    const finalType = getFinalType( typeName );
+    return (finalType === 'cds.Composition');
   }
 
   /**
@@ -409,7 +313,7 @@ function getUtils( model, universalReady ) {
   function addStringAnnotationTo( absoluteName, theValue, node ) {
     // Sanity check
     if (!absoluteName.startsWith('@'))
-      throw Error(`Annotation name should start with "@": ${ absoluteName }`);
+      throw new CompilerAssertion(`Annotation name should start with "@": ${ absoluteName }`);
 
     // Only overwrite if undefined or null
     if (node[absoluteName] === undefined || node[absoluteName] === null) {
@@ -488,12 +392,6 @@ 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, etc.
    * Input is a fully qualified type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
@@ -501,30 +399,32 @@ function getUtils( model, universalReady ) {
    * 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.
+   * properties, or an object with `type` and `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
+   *    `getUtils()` 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!
    *
+   * @todo Rename to e.g. getFinalTypeInfo()
+   *
    * @param {string|object} type Type as string or type ref, i.e. `{ ref: [...] }`
    * @returns {object|null}
    */
   function getFinalBaseTypeWithProps( type ) {
-    type = _normalizeTypeRef(type);
+    type = normalizeTypeRef(type);
     if (!type)
       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 }`;
+    // Need to take care of clashes:
+    //  - r({ref: ['\\', '\\', '\\\\'] }) != r({ref: ['\\', '\\\\', '\\'] })
+    //  - r({ref: ['\\', '\\', '\\\\'] }) != r({ref: ['\\', '\\\\2:\\\\'] })
+    const resolvedKey = (typeof type === 'object')
+      ? `ref[${ type.ref.length }]:${ type.ref.map((val, i) => `${ i }:${ val }`).join('\\') }`
+      : `type:${ type }`;
 
     if (finalBaseTypeCache[resolvedKey]) {
       if (finalBaseTypeCache[resolvedKey] === true)
@@ -532,8 +432,12 @@ function getUtils( model, universalReady ) {
       return finalBaseTypeCache[resolvedKey];
     }
 
+    // Nothing to copy from builtin type name.
+    if (typeof type === 'string' && (isBuiltinType( type ) || type === special$self))
+      return _cacheResolved({ type });
+
     const typeRef = artifactRef(type); // throws if not found
-    const isNonScalar = _cacheNonScalar(typeRef);
+    const isNonScalar = _cacheNonScalar({ ...typeRef, type });
     if (isNonScalar)
       return finalBaseTypeCache[resolvedKey];
 
@@ -541,7 +445,8 @@ function getUtils( model, universalReady ) {
     _copyTypeProps(props, typeRef);
 
     // If the resolved type is a builtin, stop and use its type arguments.
-    type = _normalizeTypeRef(typeRef.type);
+    type = normalizeTypeRef(typeRef.type);
+    props.type = type;
     if (typeof type === 'string' && isBuiltinType(type))
       return _cacheResolved(props);
 
@@ -552,11 +457,13 @@ function getUtils( model, universalReady ) {
     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.
+    props.type = finalBase.type;
     _copyTypeProps(props, finalBase);
     _cacheResolved(props);
     return props;
@@ -578,10 +485,6 @@ function getUtils( model, universalReady ) {
      * @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;
-      }
       if (obj.elements || obj.items) {
         _cacheResolved(obj);
         return true;
@@ -690,20 +593,10 @@ function forEachMember( construct, callback, path = [], ignoreIgnore = true, ite
   if (ignoreIgnore && construct._ignore)
     return;
 
-
   // `items` itself is a structure that can contain "elements", and more.
   if (construct.items)
     forEachMember( construct.items, callback, [ ...path, 'items' ], ignoreIgnore, iterateOptions, constructCallback );
 
-
-  // Unlike XSN, we don't make "returns" a "params" in the callback.
-  // Backends rely on the fact that `forEachElement` also goes through all
-  // `elements` of the return type (if structured).
-  // TODO: `returns` should be handled like a parameter just like XSN (maybe with different prop name)
-  if (construct.returns && !iterateOptions.elementsOnly)
-    forEachMember( construct.returns, callback, [ ...path, 'returns' ], ignoreIgnore, iterateOptions, constructCallback );
-
-
   path = [ ...path ]; // Copy
   const propsWithMembers = (iterateOptions.elementsOnly ? [ 'elements' ] : [ 'elements', 'enum', 'actions', 'params' ]);
   propsWithMembers.forEach((prop) => {
@@ -715,6 +608,19 @@ function forEachMember( construct, callback, path = [], ignoreIgnore = true, ite
         constructCallback(construct, prop, path);
     }
   });
+
+  if (construct.returns) {
+    if (construct.returns.items || construct.returns.elements) {
+      if (!iterateOptions.elementsOnly)
+        forEachMember(construct.returns, callback, [ ...path, 'returns' ], ignoreIgnore, iterateOptions, constructCallback);
+    }
+    else if (Array.isArray(callback)) {
+      callback.forEach(cb => cb(construct.returns, '', 'params', [ ...path, 'returns' ], construct));
+    }
+    else {
+      callback(construct.returns, '', 'params', [ ...path, 'returns' ], construct);
+    }
+  }
 }
 
 /**
@@ -965,10 +871,10 @@ function getArtifactDatabaseNameOf( artifactName, sqlMapping, csn, sqlDialect =
     else if (sqlMapping === 'plain')
       return artifactName.replace(/\./g, '_').toUpperCase();
 
-    throw new Error(`Unknown naming mode: ${ sqlMapping }`);
+    throw new CompilerAssertion(`Unknown naming mode: ${ sqlMapping }`);
   }
   else {
-    throw new Error('A valid CSN model is required to correctly calculate the database name of an artifact.');
+    throw new CompilerAssertion('A valid CSN model is required to correctly calculate the database name of an artifact.');
   }
 }
 
@@ -1054,7 +960,7 @@ function getUnderscoredName( startIndex, parts, csn ) {
 
 function isValidMappingDialectCombi( sqlDialect, sqlMapping ) {
   if (sqlMapping === 'hdbcds' && sqlDialect !== 'hana')
-    throw new Error(`sqlMapping "hdbcds" must only be used with sqlDialect "hana" - found: ${ sqlDialect }`);
+    throw new CompilerAssertion(`sqlMapping "hdbcds" must only be used with sqlDialect "hana" - found: ${ sqlDialect }`);
   return true;
 }
 
@@ -1087,7 +993,7 @@ function getElementDatabaseNameOf( elemName, sqlMapping, sqlDialect = 'plain' )
   else if (sqlMapping === 'quoted')
     return elemName.replace(/\./g, '_');
 
-  throw new Error(`Unknown naming mode: ${ sqlMapping }`);
+  throw new CompilerAssertion(`Unknown naming mode: ${ sqlMapping }`);
 }
 
 const _dependencies = Symbol('_dependencies');
@@ -1220,6 +1126,19 @@ function getNormalizedQuery( art ) {
   return art;
 }
 
+/**
+ * If `art.type` is an object with `ref` of length 1, normalize it to
+ * just the type reference string, e.g. `{ ref: [ 'T'] }` becomes `'T'`.
+ *
+ * @param {string|object} type
+ * @return {string|object}
+ */
+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;
+}
+
 /**
 * 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.
@@ -1390,36 +1309,46 @@ function hasValidSkipOrExists( artifact ) {
 }
 
 /**
- * Get the namespace part of the artifact name - not the whole prefix, just the part caused by namespaces.
- *
- * @param {CSN.Model} csn CSN model
- * @param {string} artifactName artifact name to get the namespace for
- * @returns {string | null} The namespace name
- */
-function getNamespace( csn, artifactName ) {
-  const parts = artifactName.split('.');
-  let seen = parts[0];
-  const art = csn.definitions[seen];
-
-  // First step is not a namespace (we faked those in the CSN)
-  // No subsequent step can be a namespace then
-  if (art && art.kind !== 'namespace')
-    return null;
-
-
-  for (let i = 1; i < parts.length; i++) {
-    // This was definitely a namespace so far
-    const previousArtifactName = seen;
-    seen = `${ seen }.${ parts[i] }`;
-    // This might not be - if it isn't, return the result.
-    const currentArtifact = csn.definitions[seen];
-    if (currentArtifact && currentArtifact.kind !== 'namespace')
-      return previousArtifactName;
+   * Return the namespace part of the artifact name.
+   *
+   * Return the longest undefined prefix path.
+   * If the first path segment is defined (that is name has
+   * no dots and is defined), return undefined.
+   *
+   * Example:
+   * model.definitions {
+   *   a.b: 1,
+   *   a.b.c.d: 1
+   * }
+   * getNamespace('foo.bar') = 'foo.bar'
+   * getNamespace('a.b.c.d') = 'a'
+   *
+   * model.definitions {
+   *   a: 1,
+   *   a.b.c.d: 1
+   * }
+   * getNamespace('a.b.c.d') = undefined
+   *
+   * @param {string} name Absolute name of artifact
+   * @param {CSN.Model} csn CSN model
+   * @param {any} ns default namespace return value
+   * @returns {any} The namespace or the value of ns
+   */
+function getNamespace( csn, name, ns = undefined ) {
+  let dotpos = -1;
+  while (dotpos < name.length) {
+    for (dotpos++; dotpos < name.length && name[dotpos] !== '.'; dotpos++)
+      ;
+    const tns = name.substring(0, dotpos);
+    if (csn.definitions[tns] === undefined)
+      ns = tns;
+    else
+      return ns;
   }
-  // We came till here - so the full artifactName is a namespace
-  return artifactName;
+  return ns;
 }
 
+
 /**
  * Sorts the definition dictionary in tests mode.
  *
@@ -1577,6 +1506,7 @@ module.exports = {
   getRootArtifactName,
   getLastPartOfRef,
   getLastPartOf,
+  normalizeTypeRef,
   copyAnnotations,
   copyAnnotationsAndDoc,
   isAspect,

package/lib/model/enrichCsn.js

@@ -41,6 +41,8 @@
 
 const { csnRefs, artifactProperties } = require('./csnRefs');
 const { locationString } = require('../base/location');
+const { CompilerAssertion } = require('../base/error');
+const shuffleGen = require('../base/shuffle');
 
 function enrichCsn( csn, options = {} ) {
   const transformers = {
@@ -64,6 +66,7 @@ function enrichCsn( csn, options = {} ) {
   // options.enrichCsn = 'DEBUG';
   let $$cacheObjectNumber = 0;   // for debugging
   const debugLocationInfo = options.enrichCsn === 'DEBUG' && Object.create(null);
+  const special$self = !csn.definitions.$self && '$self';
 
   setLocations( csn, false, null );
   const {
@@ -74,6 +77,7 @@ function enrichCsn( csn, options = {} ) {
     // eslint-disable-next-line camelcase
     __getCache_forEnrichCsnDebugging,
   } = csnRefs( csn, true );
+  const { shuffleArray } = shuffleGen( options.testMode );
 
   const csnPath = [];
   if (csn.definitions)
@@ -93,7 +97,8 @@ function enrichCsn( csn, options = {} ) {
       obj.forEach( (n, i) => standard( obj, i, n ) );
     }
     else {
-      for (const name of Object.getOwnPropertyNames( obj )) {
+      // no shuffle here; we would need to sort the new properties otherwise
+      for (const name of Object.getOwnPropertyNames( obj ) ) {
         const trans = transformers[name] || transformers[name.charAt(0)] || standard;
         trans( obj, name, obj[name] );
       }
@@ -116,13 +121,13 @@ function enrichCsn( csn, options = {} ) {
     if (!dict)                  // value null for inheritance interruption
       return;
     csnPath.push( prop );
-    for (const name of Object.getOwnPropertyNames( dict )) {
+    for (const name of shuffleArray( Object.getOwnPropertyNames( dict ) )) {
       if (prop === 'definitions')
         initDefinition( dict[name] );
       definition( dict, name, dict[name] );
     }
     if (!Object.prototype.propertyIsEnumerable.call( parent, prop ))
-      parent[`$${ prop }`] = dict;
+      parent[`$${ prop }`] = dict; // for $elements of sub queries in client-CSN
     csnPath.pop();
   }
 
@@ -133,7 +138,7 @@ function enrichCsn( csn, options = {} ) {
           ? `<illegal ref = ${ art }>`
           : `<illegal ref: ${ typeof art }>`;
       }
-      throw new Error( 'Illegal reference' );
+      throw new CompilerAssertion( 'Illegal reference' );
     }
     else if (art.$location) {
       return art.$location;
@@ -141,7 +146,7 @@ function enrichCsn( csn, options = {} ) {
 
     if (!options.testMode)
       return `<${ Object.keys( art ).join('+') }+!$location>`;
-    throw new Error( 'Reference to object without $location' );
+    throw new CompilerAssertion( 'Reference to object without $location' );
   }
 
   function simpleRef( parent, prop, ref ) {
@@ -151,7 +156,7 @@ function enrichCsn( csn, options = {} ) {
       parent[`_${ prop }`] = ref.map( r => refLocation( artifactRef( r, notFound ) ) );
     }
     else if (typeof ref === 'string') {
-      if (!ref.startsWith( 'cds.'))
+      if (!ref.startsWith( 'cds.') && ref !== special$self)
         parent[`_${ prop }`] = refLocation( artifactRef( ref, notFound ) );
     }
     else if (!ref.elements) {
@@ -201,7 +206,7 @@ function enrichCsn( csn, options = {} ) {
     }
 
     csnPath.push( prop );
-    path.forEach( function step( s, i ) {
+    path.forEach( function step( s, i ) { // no shuffle, need index
       if (s && typeof s === 'object') {
         csnPath.push( i );
         if (s.args)
@@ -289,7 +294,7 @@ function enrichCsn( csn, options = {} ) {
 
   function debugLocation( loc, userProvided ) {
     if (debugLocationInfo && !userProvided) {
-      loc = loc.replace( /\([0-9]+\)\^/, '^' );
+      loc = loc.replace( /\(\d+\)\^/, '^' );
       debugLocationInfo[loc] = (debugLocationInfo[loc] || 0) + 1;
       loc = `${ loc }(${ debugLocationInfo[loc] })`;
     }

package/lib/model/revealInternalProperties.js

@@ -12,6 +12,7 @@
 'use strict';
 
 const msg = require('../base/messages');
+const { CompilerAssertion } = require('../base/error');
 
 const $inferred = Symbol.for('cds.$inferred');
 const $location = Symbol.for('cds.$location');
@@ -132,7 +133,7 @@ function revealInternalProperties( model, nameOrPath ) {
     if (path.length === 1) {
       const def = xsn.definitions?.[path[0]] || xsn.vocabularies?.[path[0]];
       if (!def)
-        throw new Error(`reveal xsn: Unknown definition: “${ path[0] }”`);
+        throw new CompilerAssertion(`reveal xsn: Unknown definition: “${ path[0] }”`);
       return reveal( def );
     }
 
@@ -143,7 +144,7 @@ function revealInternalProperties( model, nameOrPath ) {
       if (xsn[segment])
         xsn = xsn[segment];
       else if (segment)         // huh, this should be a call error
-        throw new Error(`Raw Output: Path segment "${ segment }" could not be found. Path: ${ JSON.stringify(path) }!"`);
+        throw new CompilerAssertion(`Raw Output: Path segment "${ segment }" could not be found. Path: ${ JSON.stringify(path) }!"`);
     }
     const propName = path[path.length > 1 ? path.length - 2 : 0];
     const obj = {};
@@ -369,7 +370,7 @@ function primOrString( node ) {
 
 function quoted( name, undef = '‹undefined›' ) {
   if (typeof name === 'number')
-    return name;
+    return String(name);
   return (name ? `“${ name }”` : undef);
 }