@sap/cds-compiler 6.2.2 → 6.3.4

package/lib/gen/Dictionary.json

@@ -808,7 +808,6 @@
       "Type": "Core.Tag"
     },
     "Common.IsTimezone": {
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"
@@ -1035,7 +1034,6 @@
       "Type": "Edm.DateTimeOffset"
     },
     "Common.Timezone": {
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"

package/lib/json/to-csn.js

@@ -31,6 +31,7 @@ const normalizedKind = {
 let gensrcFlavor = true;       // good enough here...
 let universalCsn = false;
 let strictMode = false;        // whether to dump with unknown properties (in standard)
+/** @type {boolean|string} */
 let withLocations = false;
 let withDocComments = false;
 let structXpr = false;
@@ -252,7 +253,7 @@ function compactModel( model, options = model.options || {} ) {
     const loc = srcDict[first].location;
     if (loc && loc.file) {
       Object.defineProperty( csn, '$location', {
-        value: { file: loc.file }, configurable: true, writable: true, enumerable: withLocations,
+        value: { file: loc.file }, configurable: true, writable: true, enumerable: !!withLocations,
       } );
     }
     set( '$extra', csn, srcDict[first] );
@@ -611,7 +612,7 @@ function addLocation( loc, csn ) {
       val.endCol = loc.endCol;
     }
     Object.defineProperty( csn, '$location', {
-      value: val, configurable: true, writable: true, enumerable: withLocations,
+      value: val, configurable: true, writable: true, enumerable: !!withLocations,
     } );
   }
   return csn;

package/lib/model/csnRefs.js

@@ -250,10 +250,9 @@ function csnRefs( csn, universalReady ) {
   // const { definitions } = csn;
   const cache = new WeakMap();
   setCache( BUILTIN_TYPE, '_origin', null );
-  if (universalReady === 'init-all') {
-    for (const name of Object.keys( csn.definitions || {}))
-      initDefinition( name );
-  }
+  if (universalReady === 'init-all')
+    initAllDefinitions();
+
   // Functions which set the new `baseEnv`:
   resolveRef.expandInline = function resolveExpandInline( ref, ...args ) {
     return cached( ref, '_env', () => navigationEnv( resolveRef( ref, ...args ).art ) );
@@ -278,6 +277,7 @@ function csnRefs( csn, universalReady ) {
     getColumnName: col => getCache( col, '$as' ),
     $getQueries: def => getCache( def, '$queries' ), // unstable API
     initDefinition,
+    initAllDefinitions,
     dropDefinitionCache,
     targetAspect,
     msgLocations,
@@ -489,6 +489,11 @@ function csnRefs( csn, universalReady ) {
     return query && cache.get( query.projection || query );
   }
 
+  function initAllDefinitions() {
+    for (const name of Object.keys( csn.definitions || {}))
+      initDefinition( name );
+  }
+
   function initDefinition( main ) {
     const name = typeof main === 'string' && main;
     if (name) {

package/lib/model/csnUtils.js

@@ -64,6 +64,7 @@ function getUtils( model, universalReady ) {
     addStringAnnotationTo,
     getServiceName,
     getFinalTypeInfo,
+    resolvePath,
     get$combined,
     getQueryPrimarySource,
     ..._csnRefs,
@@ -448,6 +449,71 @@ function getUtils( model, universalReady ) {
       return target;
     }
   }
+
+
+  /**
+   * Resolve the type of an artifact
+   * If art is undefined, stop
+   * If art has elements or items.elements, stop
+   * If art has a type and the type is scalar, stop
+   * If art has a named type or a type ref, resolve it
+   */
+  function resolveType( art ) {
+    while (art &&
+      !((art.items && art.items.elements) || art.elements) &&
+      (art.type &&
+        ((!art.type.ref && !isBuiltinType(art.type)) || art.type.ref))) {
+      if (art.type.ref)
+        art = resolvePath(art.type);
+      else
+        art = model.definitions[art.type];
+    }
+    return art;
+  }
+
+  /**
+   * Path resolution, attach artifact to each path step, if found,
+   * Dereference types and follow associations.
+   *
+   * @param {any} path ref object
+   * @param {any} art start environment
+   * @returns {any} path with resolved artifacts or artifact
+   * (if called with simple ref paths)
+   */
+  function resolvePath( path, art = undefined ) {
+    let notFound = false;
+    for (let i = 0; i < path.ref.length && !notFound; i++) {
+      const ps = path.ref[i];
+      const id = ps.id || ps;
+      if (art) {
+        if (art.target)
+          art = model.definitions[art.target].elements[id];
+        else if (art.items && art.items.elements || art.elements)
+          art = (art.items && art.items.elements || art.elements)[id];
+
+        else
+          art = undefined;
+      }
+      else {
+        art = model.definitions[id];
+      }
+      art = resolveType(art);
+
+      // if path step has id, store art
+      if (ps.id && art)
+        ps._art = art;
+      notFound = !art;
+    }
+    // if resolve was called on constraint path, path has id.
+    // Store art and return path, if called recursively for model ref paths,
+    // return artifact only
+    if (path.ref[0].id) {
+      if (art)
+        path._art = art;
+      return path;
+    }
+    return art;
+  }
 }
 
 
@@ -1248,7 +1314,6 @@ function walkCsnPath( csn, path ) {
   for (const segment of path)
     obj = obj[segment];
 
-
   return obj;
 }
 
@@ -1356,7 +1421,7 @@ function functionList( functions, thisArg ) {
  * @returns {boolean}
  */
 function isDollarSelfOrProjectionOperand( arg ) {
-  return arg.ref && arg.ref.length === 1 &&
+  return arg.ref?.length === 1 &&
     (arg.ref[0] === '$self' || arg.ref[0] === '$projection');
 }
 

package/lib/optionProcessor.js

@@ -265,7 +265,7 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-vocabularies <list>')
   .option('    --odata-no-creator')
   .option('    --draft-messages')
-  .option('    --add-annotation-AddressViaNavigationPath')
+  .option('    --draft-user-description')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', { valid: [ 'flat', 'structured' ] })
   .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
@@ -301,8 +301,7 @@ optionProcessor.command('O, toOdata')
                                    { prefix: { alias, ns, uri }, ... }
        --odata-no-creator          Omit creator identification in API
        --draft-messages            Add draft messages as part of the draft creation
-       --add-annotation-AddressViaNavigationPath Add annotation "@Common.AddressViaNavigationPath" to the services
-                                                 containing draft enabled entitties
+       --draft-user-description    Add user description fields to the DraftAdministrativeData entity
        -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores

package/lib/parsers/AstBuildingParser.js

@@ -49,7 +49,6 @@ const PRECEDENCE_OF_EQUAL = 10;
 class AstBuildingParser extends BaseParser {
   leanConditions = {
     afterBrace: true,
-    atRightParen: true,
     fail: true,
   };
 
@@ -203,6 +202,10 @@ class AstBuildingParser extends BaseParser {
   }
 
   addTokenToSet_( set, tokenName, val, collectKeywordsOnly ) {
+    if (!this.dynamic_.call) {
+      super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
+      return;
+    }
     const token = parserTokens[tokenName];
     // TODO: use lower-case in specialFunctions
     const realTokens = token && this.dynamic_.generic?.[token];
@@ -215,7 +218,7 @@ class AstBuildingParser extends BaseParser {
       // Works, since `DeleteStarFromSet` comes after `*` (length-sorted):
       delete set['*'];
     }
-    else {
+    else if (!token) {
       super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
     }
   }
@@ -489,10 +492,6 @@ class AstBuildingParser extends BaseParser {
     // token is not on a new line?
   }
 
-  atRightParen() {
-    return this.l() !== ')';
-  }
-
   /**
    * For annotations at the beginning of columns outside parentheses
    */
@@ -868,7 +867,7 @@ class AstBuildingParser extends BaseParser {
     // if (args.length !== 1) throw new CompilerAssertion()
     const sign = ixpr.args[0];
     const nval
-          = (sign.val === '-' &&
+      = (sign.val === '-' &&
              expr && // expr may be null if `-` rule can't be parsed
              expr.literal === 'number' &&
              sign.location.endLine === expr.location.line &&
@@ -1167,10 +1166,12 @@ class AstBuildingParser extends BaseParser {
   secureParens( expr ) {
     const op = expr?.op?.val;
     const $parens = expr?.$parens;
-    if (!$parens || expr.query || op && op !== 'call' && op !== 'cast')
+    if (!$parens || expr.query || op && op !== 'call' && op !== 'cast' && op !== 'list')
       return expr;
-    // ensure that references, literals and functions keep their surrounding parentheses
-    // (is for expressions the case anyway)
+    // Ensure that references, literals, functions and lists keep their
+    // surrounding parentheses (is for expressions the case anyway).
+    // (Remark: as opposed to product types in type theory, a 1-tupel of an
+    // n-tupel in SQL is different from an n-tupel → keep parens around `list`.)
     const location = $parens.pop();
     if (!$parens.length)
       delete expr.$parens;
@@ -1356,7 +1357,7 @@ class AstBuildingParser extends BaseParser {
 
       if (def.kind !== 'annotate') {
         const numDefines
-              = def.$duplicates.reduce( addOneForDefinition, addOneForDefinition( 0, def ) );
+          = def.$duplicates.reduce( addOneForDefinition, addOneForDefinition( 0, def ) );
         this.handleDuplicateExtension( def, name, numDefines );
         for (const dup of def.$duplicates)
           this.handleDuplicateExtension( dup, name, numDefines );

package/lib/render/toCdl.js

@@ -796,10 +796,15 @@ class CsnToCdl {
     }
 
     // Top-level annotations of the artifact
-    let result = this.renderAnnotationAssignmentsAndDocComment(ext, env);
+    const topLevelAnnotations = this.renderAnnotationAssignmentsAndDocComment(ext, env.withIncreasedIndent());
+
     // Note: Not renderDefinitionReference, because we don't care if there
     //       are annotations to unknown things. That's allowed!
-    result += `${ env.indent }annotate ${ this.renderArtifactName(ext.annotate, env) }`;
+    let result = `${ env.indent }annotate ${ this.renderArtifactName(ext.annotate, env) }`;
+
+    if (topLevelAnnotations)
+      result += ` with\n${ topLevelAnnotations }`;
+
 
     if (ext.params)
       result += this.renderAnnotateParamsInParentheses(ext, env);
@@ -1368,7 +1373,7 @@ class CsnToCdl {
   }
 
   /**
-   * Render the given columns.
+   * Render the given columns / select items.
    *
    * @param {CSN.Extension | CSN.QuerySelect} art
    * @param {object} elements
@@ -1459,6 +1464,7 @@ class CsnToCdl {
 
     const isAnonymousExpand = (obj.expand && !obj.ref);
 
+
     // s as alias { * }
     if (obj.as && !isAnonymousExpand)
       result += this.renderAlias(obj.as, env);
@@ -1483,7 +1489,7 @@ class CsnToCdl {
     const childEnv = env.withIncreasedIndent();
     const expandInline = obj.expand || obj.inline;
     result += expandInline //
-      .map(elm => this.renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + this.renderInlineExpand(elm, childEnv))
+      .map(elm => this.renderViewColumn(elm, childEnv))
       .join(',\n');
     result += `\n${ env.indent }}`;
 

package/lib/render/utils/common.js

@@ -305,10 +305,12 @@ const cdsToSqlTypes = {
   h2: {
     'cds.Binary': 'VARBINARY', // same as for plain
     'cds.LargeBinary': 'BINARY LARGE OBJECT', // BLOB would require a length!
-    'cds.DecimalFloat': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
+    // 'cds.Decimal': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
+    'cds.DecimalFloat': 'DECFLOAT',
     'cds.DateTime': 'TIMESTAMP(0)',
     'cds.Timestamp': 'TIMESTAMP(7)',
     'cds.Map': 'JSON',
+    'cds.UInt8': 'SMALLINT', // See #13870; not equivalent, but smallint can hold >byte
   },
   postgres: {
     // See <https://www.postgresql.org/docs/current/datatype.html>
@@ -317,7 +319,7 @@ const cdsToSqlTypes = {
     'cds.LargeBinary': 'BYTEA',
     'cds.Binary': 'BYTEA',
     'cds.Double': 'FLOAT8',
-    'cds.UInt8': 'INTEGER', // Not equivalent
+    'cds.UInt8': 'SMALLINT', // See #13870; not equivalent, but smallint can hold >byte
     'cds.Vector': 'VARCHAR', // Not supported; see #11725
     'cds.Map': 'JSONB',
   },

package/lib/transform/db/assertUnique.js

@@ -20,7 +20,8 @@ const { pathName } = require('../../compiler/utils');
  * @returns {Function} forEachDefinition callback
  */
 function processAssertUnique( csn, options, messageFunctions ) {
-  const { resolvePath, flattenPath } = getTransformers(csn, options, messageFunctions);
+  const { csnUtils, flattenPath } = getTransformers(csn, options, messageFunctions);
+  const { resolvePath } = csnUtils;
   const { error, info } = messageFunctions;
 
   return handleAssertUnique;

package/lib/transform/db/associations.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  transformAnnotationExpression,
   applyTransformationsOnNonDictionary,
   applyTransformations,
   implicitAs,
@@ -106,18 +107,40 @@ function attachOnConditions( csn, csnUtils, pathDelimiter, iterateOptions = {},
 
 /**
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  * @param {object} csnUtils
  * @param {string} pathDelimiter
  * @param {boolean} [processOnInQueries=false] Wether to process on-conditions in queries (joins and mixins)
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries = false ) {
+function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnInQueries = false ) {
   const {
     inspectRef,
   } = csnUtils;
 
   return handleManagedAssocSteps;
 
+  /**
+   *
+   * @param {object} obj Object with annotations.
+   * @param {object} transformer Annotation expression transformers.
+   * @param {CSN.Path} path CSN path for locations.
+   */
+  function processRefsInAnnotations(obj, transformer, path) {
+    Object.keys(obj)
+      .filter(pn => pn.startsWith('@') && obj[pn])
+      .forEach((anno) => {
+      // TODO: Ensure we only do processing here for annotations that have refs, to save time
+        const annoBefore = JSON.stringify(obj[anno]);
+        transformAnnotationExpression(obj, anno, transformer, path);
+        if (obj[anno].ref)
+          transformer.ref(obj[anno], 'ref', obj[anno].ref, path.concat(anno));
+        const annoAfter = JSON.stringify(obj[anno]);
+        if (annoBefore !== annoAfter)
+          obj[anno]['='] = true;
+      });
+  }
+
   /**
    * Loop over all elements and for all unmanaged associations translate
    * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
@@ -133,6 +156,11 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
   function handleManagedAssocSteps( artifact, artifactName ) {
     const transformer = getTransformer();
     const inColumnsTransformer = getTransformer(true);
+
+    if (options.transformation === 'effective')
+      processRefsInAnnotations(artifact, transformer, [ 'definitions', artifactName ]);
+
+
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
       // The association is an unmanaged one
@@ -140,6 +168,10 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
         applyTransformationsOnNonDictionary(elem, 'on', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
       else if (elem.value?.stored)
         applyTransformationsOnNonDictionary(elem, 'value', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+
+      // TODO: Is this enough? I suppose that these annotations can be in places that are not an element.
+      if (options.transformation === 'effective')
+        processRefsInAnnotations(elem, transformer, [ 'definitions', artifactName, 'elements', elemName ]);
     }
 
     if (artifact.query || artifact.projection) {
@@ -165,6 +197,10 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
         };
         queryTransformers.on = transform;
       }
+
+      if (options.transformation === 'effective' || options.transformation === 'odata')
+        queryTransformers.xpr = transform;
+
       applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, { drillRef: true }, [ 'definitions', artifactName ]);
     }
 

package/lib/transform/db/assocsToQueries/transformExists.js

@@ -26,30 +26,29 @@ const { getHelpers } = require('./utils');
  *   + Is it part of the source side: <path> is turned into <query source>.<path> - a leading $self is stripped-off
  *   + Is it something else: Don't touch it, leave as is
  *
- * Given that `assoc` from above has the on-condition assoc.id = id, we would generate the following:
+ * Given that `assoc` from above has the on-condition `assoc.id = id`, we would generate the following:
  * - F.id = E.id
  *
- * The final subselect looks like (select 1 as dummy from E where F.id = E.id and filter = 100).
+ * The final subselect looks like `(select 1 as dummy from E where F.id = E.id and filter = 100)`.
  *
  * For a $self backlink:
  * - For $self = <assoc>.<another-assoc>, we do the following for each foreign key of <another-assoc>
  *   + <assoc>.<another-assoc>.<fk> -> <assoc.target>.<another-assoc>.<fk>
- *   + Afterwards, we get the corresponding key from the source side: <query-source>.<fk>
+ *   + Afterward, we get the corresponding key from the source side: <query-source>.<fk>
  *   + And turn this into a comparison: <assoc.target>.<another-assoc>.<fk> = <query-source>.<fk>
  *
  * So for the sample above, given an on-condition like $self = assoc.backToE, we would generate:
  * - F.backToE.id = E.id
  *
- * The final subselect looks like (select 1 as dummy from E where F.backToE.id = E.id and filter = 100).
+ * The final subselect looks like `(select 1 as dummy from E where F.backToE.id = E.id and filter = 100)`.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param {Function} error
- * @param {Function} inspectRef
- * @param {Function} initDefinition
- * @param {Function} dropDefinitionCache
+ * @param {object} messageFunctions
+ * @param {object} csnUtils
  */
-function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
+function handleExists( csn, options, messageFunctions, csnUtils ) {
+  const { error } = messageFunctions;
   const {
     getBase,
     firstLinkIsEntityOrQuerySource,
@@ -57,17 +56,12 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     translateManagedAssocToWhere,
     getQuerySources,
     translateUnmanagedAssocToWhere,
-  } = getHelpers(csn, inspectRef, error);
+  } = getHelpers(csn, csnUtils.inspectRef, error);
+
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
-    // drop cache: Otherwise, the projection/query hack below won't work, because csnRefs
-    // thinks that the artifact was already initialized (including all queries).
-    dropDefinitionCache(artifact);
-    if (artifact.projection) // do the same hack we do for the other stuff...
-      artifact.query = { SELECT: artifact.projection };
-
-    if (artifact.query) {
-      forAllQueries(artifact.query, function handleExistsQuery(query, path) {
+    if (artifact.query || artifact.projection) {
+      forAllQueries(artifact.query || { SELECT: artifact.projection }, function handleExistsQuery(query, path) {
         if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
           if (query.SELECT?.where?.length > 1)
@@ -90,8 +84,8 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           while (toProcess.length > 0) {
             const [ queryPath, exprPath ] = toProcess.pop();
             // Re-init caches for this artifact
-            dropDefinitionCache(artifact);
-            initDefinition(artifact);
+            csnUtils.dropDefinitionCache(artifact);
+            csnUtils.initDefinition(artifact);
             // leftovers can happen with nested exists - we then need to drill down into the created SELECT
             // to check for further exists
             const { result, leftovers } = processExists(queryPath, exprPath);
@@ -100,16 +94,10 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
             toProcess.push(...leftovers); // any leftovers - schedule for further processing
           }
           // Make sure we leave csnRefs usable
-          dropDefinitionCache(artifact);
-          initDefinition(artifact);
+          csnUtils.dropDefinitionCache(artifact);
+          csnUtils.initDefinition(artifact);
         }
-      }, [ 'definitions', artifactName, 'query' ]);
-    }
-
-    if (artifact.projection) { // undo our hack
-      artifact.projection = artifact.query.SELECT;
-
-      delete artifact.query;
+      }, [ 'definitions', artifactName, artifact.projection ? 'projection' : 'query' ]);
     }
   });
 
@@ -168,7 +156,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       }
     }
     const stack = [ [ null, startAssoc, startRest, startIndex ] ];
-    const { links } = inspectRef(path);
+    const { links } = csnUtils.inspectRef(path);
     while (stack.length > 0) {
       // previous: to nest "up" if the previous assoc did not originally have a filter
       // assoc: the assoc path step
@@ -258,8 +246,9 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     const newExpr = [];
     const query = walkCsnPath(csn, queryPath);
     const expr = walkCsnPath(csn, exprPath);
-    const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref) : null;
-    const sources = getQuerySources(query.SELECT);
+    const select = query.projection ?? query.SELECT;
+    const queryBase = select?.from?.ref ? (select.from.as || select.from.ref) : null;
+    const sources = getQuerySources(select);
 
     for (let i = 0; i < expr.length; i++) {
       if (i < expr.length - 1 && expr[i] === 'exists' && expr[i + 1].ref) {

package/lib/transform/db/assocsToQueries/utils.js

@@ -430,7 +430,7 @@ function getHelpers( csn, inspectRef, error ) {
   }
 
   /**
-   * Use cacjed _links and _art or calculate via inspectRef
+   * Use cached _links and _art or calculate via inspectRef
    * @param {object} obj
    * @param {CSN.Path} objPath
    * @returns {object}

package/lib/transform/db/cdsPersistence.js

@@ -125,7 +125,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
 
       recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
         // All elements must have a type for this to work
-        if (!member.$ignore && !member.kind && !member.type) {
+        if (!member.$ignore && !member.kind && !member.type && !member.elements) { // .items? Probably resolved at this point
           error(null, path, { anno: '@cds.persistence.table' },
                 'Expecting element to have a type if view is annotated with $(ANNO)');
         }