@sap/cds-compiler 4.2.2 → 4.3.0

package/lib/checks/existsExpressionsOnlyForeignKeys.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { requireForeignKeyAccess } = require('../checks/onConditions');
+
+/**
+ * Check that associations in filters (in an exists expression) are only fk-accesses. Everything else is forbidden.
+ *
+ * @param {CSN.Artifact} parent
+ * @param {string} name
+ * @param {Array} expr
+ */
+function forbidAssocInExists( parent, name, expr ) {
+  for (let i = 0; i < expr.length - 1; i++) {
+    if (expr[i] === 'exists' && expr[i + 1].ref) {
+      i++;
+      const current = expr[i];
+
+      const { _links } = expr[i];
+
+      const assocs = _links.filter(link => link.art?.target).map(link => current.ref[link.idx]);
+
+      checkForInvalidAssoc.call(this, assocs);
+    }
+  }
+}
+
+/**
+ * Check that associations in filters (in an exists expression) are only fk-accesses. Everything else is forbidden.
+ *
+ * @param {object[]} assocs Array of refs of assocs - possibly with a .where to check
+ */
+function checkForInvalidAssoc( assocs ) {
+  for (const assoc of assocs) {
+    if (assoc.where) {
+      for (let i = 0; i < assoc.where.length; i++) {
+        const part = assoc.where[i];
+
+        if (part._links && !(assoc.where[i - 1] && assoc.where[i - 1] === 'exists')) {
+          for (const link of part._links) {
+            if (link.art && link.art.target) {
+              if (link.art.keys) { // managed - allow FK access
+                const next = part._links[link.idx + 1];
+                if (next !== undefined) { // there is a next path step - check if it is a fk
+                  requireForeignKeyAccess(part, i, (errorIndex) => {
+                    const { ref } = assoc.where[part.$path[part.$path.length - 1]];
+                    this.error('ref-expecting-foreign-key', part.$path, { alias: ref[errorIndex], id: assoc.id, name: ref[link.idx] });
+                  });
+                }
+                else { // no traversal, ends on managed
+                  this.error('ref-unexpected-assoc', part.$path, { '#': 'managed-filter', id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] });
+                }
+              }
+              else { // unmanaged - always wrong
+                this.error('ref-unexpected-assoc', part.$path, { '#': 'unmanaged-filter', id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] });
+              }
+              // Recursively drill down if the assoc-step has a filter
+              if (part.ref[link.idx].where)
+                checkForInvalidAssoc.call(this, [ part.ref[link.idx] ]);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  having: forbidAssocInExists,
+  where: forbidAssocInExists,
+  xpr: forbidAssocInExists,
+};

package/lib/checks/existsMustEndInAssoc.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * A path following an “exists” predicate must always end in an association.
+ *
+ * @param {object} parent
+ * @param {string} prop
+ * @param {Array} expression
+ * @param {CSN.Path} path
+ */
+function existsMustEndInAssoc( parent, prop, expression, path ) {
+  for (let i = 0; i < expression?.length - 1; i++) {
+    if (expression[i] === 'exists') {
+      const next = expression[i + 1];
+      const { _art } = next;
+      const errorPath = path.concat([ prop, i ]);
+      if (!next.SELECT && !_art?.target)
+        this.error('ref-expecting-assoc', errorPath, { elemref: next, type: _art.type });
+    }
+  }
+}
+
+module.exports = {
+  having: existsMustEndInAssoc,
+  where: existsMustEndInAssoc,
+  xpr: existsMustEndInAssoc,
+};

package/lib/checks/onConditions.js

@@ -172,8 +172,16 @@ function validateOnCondition( member, memberName, property, path ) {
  *     If a fk-step is missing, `errorIndex` will be `> parent.ref.length`.
  */
 function requireForeignKeyAccess( parent, refIndex, noForeignKeyCallback ) {
-  const { ref, _links } = parent;
+  const { _links } = parent;
+  const ref = [ ...parent.ref ]; // copy so the original ref stays untouched
   const assoc = _links[refIndex].art;
+  const nextLink = _links[refIndex + 1]?.art;
+
+  if (nextLink?.value) {
+    const resolved = resolveCalculatedElementRef(nextLink);
+    if (resolved)
+      ref.splice(refIndex + 1, 1, ...resolved);
+  }
 
   const next = pathId(ref[refIndex + 1]);
   let possibleKeys = next && assoc.keys.filter(r => r.ref[0] === next);
@@ -219,4 +227,42 @@ function validateMixinOnCondition( query, path ) {
     forEachGeneric( query.SELECT, 'mixin', validateOnCondition.bind(this), path );
 }
 
+/**
+ * As calculated elements are only resolved in a later transformation step,
+ * we must provide a way to check whether a calc element references e.g.
+ * a foreign key somewhere down the line.
+ *
+ * In the following example, `G:indirect` is eventually a foreign key of `G:toG`,
+ * hence it is allowed to be used in e.g. an infix filter:
+ * @example
+ *  ```
+ *  entity G {
+ *      key id  : Integer;
+ *          idx : Integer;
+ *          toG: Association to G { idx };
+ *          cidx = idx;
+ *          indirect = cidx;
+ *   }
+ *
+ *   view V as select from G where exists toG[toG.indirect = 1];
+ *                                                ^^^^^^^^
+ *   ```
+ *
+ * @param {CSN.Element} calculatedElement
+ * @returns {CSN.ArtifactReference} the resolved element or the calculated element itself if it is complex
+ */
+function resolveCalculatedElementRef( calculatedElement ) {
+  if (calculatedElement.value.ref) {
+    const { _links } = calculatedElement.value;
+    const leaf = _links[_links.length - 1];
+    // TODO: once #11538 is available, checking the leaf for `.value`
+    // is not enough anymore.
+    if (leaf.art.value)
+      return resolveCalculatedElementRef(leaf.art);
+    return calculatedElement.value.ref;
+  }
+
+  return null;
+}
+
 module.exports = { validateOnCondition, validateMixinOnCondition, requireForeignKeyAccess };

package/lib/checks/validator.js

@@ -39,6 +39,9 @@ const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
+const existsMustEndInAssoc = require('./existsMustEndInAssoc');
+const forbidAssocInExists = require('./existsExpressionsOnlyForeignKeys');
+const checkPathsInStoredCalcElement = require('./checkPathsInStoredCalcElement');
 const managedWithoutKeys = require('./managedWithoutKeys');
 const {
   checkSqlAnnotationOnArtifact,
@@ -72,7 +75,13 @@ const forRelationalDBArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forRelationalDBCsnValidators = [ nonexpandableStructuredInExpression, navigationIntoMany ];
+const forRelationalDBCsnValidators = [
+  existsMustEndInAssoc,
+  forbidAssocInExists,
+  nonexpandableStructuredInExpression,
+  navigationIntoMany,
+  checkPathsInStoredCalcElement,
+];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */

package/lib/compiler/assert-consistency.js

@@ -192,17 +192,17 @@ function assertConsistency( model, stage ) {
     $magicVariables: {
       // $magicVariables contains "builtin" artifacts that differ from
       // "normal artifacts" and therefore have a custom schema
-      requires: [ 'kind', 'artifacts' ],
+      requires: [ 'kind', 'elements' ],
       schema: {
         kind: { test: isString, enum: [ '$magicVariables' ] },
-        artifacts: {
+        elements: {
           // Do not use "normal" definitions spec because of these artifacts
           // are missing the location property
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
           optional: [
             'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
-            '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
+            '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps', '_parent',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -239,7 +239,9 @@ function assertConsistency( model, stage ) {
       optional: [ 'name', 'extern', 'usings', 'fileDep' ],
     },
     extern: {
-      requires: [ 'location', 'path' ],
+      kind: [ 'using' ],
+      requires: [ 'location' ],
+      optional: [ 'location', 'path', 'id' ],
       schema: { path: { inherits: 'path', optional: [ '$delimited' ] } },
     },
     elements: { kind: true, inherits: 'definitions', also: [ 0 ] }, // 0 for cyclic expansions
@@ -344,9 +346,9 @@ function assertConsistency( model, stage ) {
     $inlines: { test: TODO },
     type: {
       kind: true,
-      requires: [ 'location', 'path' ],
+      requires: [ 'location' ],
       optional: [
-        'scope', '_artifact', '$inferred', '$parens',
+        'path', 'scope', '_artifact', '$inferred', '$parens',
       ],
     },
     targetAspect: {
@@ -516,13 +518,13 @@ function assertConsistency( model, stage ) {
       kind: true,
       instanceOf: 'ignore', // TODO: XsnName,
       schema: {
-        select: { test: TODO },
+        id: { test: isStringOrNumber },
+        select: { test: TODO }, // TODO: remove
       }, // TODO: rename query prop in name
       requires: [ 'location' ],
       optional: [
         'path', 'id', '$delimited', 'variant', // TODO: req path, opt id for main, req id for member
         '_artifact', '$inferred',
-        'absolute', 'select', 'alias', 'element', 'action', 'param',
       ],
     },
     absolute: { test: isString },
@@ -665,6 +667,7 @@ function assertConsistency( model, stage ) {
         '$internal', // compiler internal; must not reach CSN output
         '*', // inferred from query wildcard
         'as', // query alias name
+        'path-prefix',          // using declaration for `entity path.prefix.E`
         'aspect-composition',
         'autoexposed', // for auto-exposed entities (they can't be referred to)
         'cast', // type from cast() function
@@ -676,7 +679,7 @@ function assertConsistency( model, stage ) {
         'keys',
         'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
         'localized-entity', // `.texts` entity
-        'nav', // only used for MASKED, TODO(v4): Remove
+        'nav', // only used for MASKED, TODO(v5): Remove
         'none', // only used in ensureColumnName(): Used in object representing empty alias
         'query', // inferred query properties, e.g. `key`
         'rewrite', // on-conditions or FKeys are rewritten
@@ -759,7 +762,7 @@ function assertConsistency( model, stage ) {
     if (parent.kind !== 'namespace')
       throw new InternalConsistencyError(`Property '${ prop }' must be inside artifact that is a namespace but was '${ parent.kind }'${ at( [ node, parent ], prop, name ) }` );
 
-    const parentName = parent.name && parent.name.absolute;
+    const parentName = parent.name?.id;
     if (parentName !== 'cds' && parentName !== 'localized')
       throw new InternalConsistencyError(`Property '${ prop }' must be inside namespace 'cds' or 'localized' but was '${ parentName }'${ at( [ node, parent ], prop, name ) }` );
   }
@@ -968,6 +971,11 @@ function assertConsistency( model, stage ) {
     };
   }
 
+  function isStringOrNumber( node, parent, prop, spec ) {
+    if (typeof node !== 'number')
+      isString( node, parent, prop, spec );
+  }
+
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
       throw new InternalConsistencyError( `Expected string but found ${ typeof node }${ at( [ node, parent ], prop ) }` );
@@ -1005,12 +1013,12 @@ function assertConsistency( model, stage ) {
       if (prop === 'artifacts')
         standard( art, parent, prop, spec, name );
     }
-    else if (!art.name.absolute ||
-             !model.definitions[art.name.absolute] &&
-             !(model.vocabularies && model.vocabularies[art.name.absolute])) {
+    else if (!art.name.id ||
+             !model.definitions[art.name.id] &&
+             !model.vocabularies?.[art.name.id]) {
       // TODO: sign ignored artifacts with $inferred = 'IGNORED'
-      if (parent.kind === 'source' ||
-          art.name.absolute && art.name.absolute.startsWith( 'localized.' ))
+      if (parent.kind === 'source' || art.kind === 'using' ||
+          art.name.id?.startsWith?.( 'localized.' ))
         standard( art, parent, prop, spec, name );
       else
         throw new InternalConsistencyError( `Expected definition${ at( [ art, parent ], prop, name ) }` );

package/lib/compiler/base.js

@@ -61,8 +61,8 @@ const kindProperties = {
   annotate: {
     noDep: 'special', elements: true, enum: true, actions: true, params: true,
   },
-  builtin: {},                  // = CURRENT_DATE, TODO: improve
-  $parameters: {},              // $parameters in query entities
+  builtin: { normalized: 'element' }, // = $now, $user.id, …
+  $parameters: {},              // $parameters in query entities - TODO: normalized: 'alias'?
 };
 
 function propExists( prop, parent ) {
@@ -79,26 +79,43 @@ function propExists( prop, parent ) {
  * @returns {XSN.Name}
  */
 function getArtifactName( art ) {
-  if (!art.name || art.name.absolute) // no name or “old style”
-    return art.name;
-  // extend and annotate statements as members already have "sparse" names → calculate old one
+  const { name } = art;
+  if (!name)                    // no name
+    return name;
+  if (!art.kind)                // annotation assignments
+    return { ...art.name, absolute: art.name.id };
+  if (art.kind === 'using')
+    return { ...art.name, absolute: art.extern.id };
+
   const namePath = [];
-  let parent = art;
-  while (parent._main) { // until we hit the main artifact
-    namePath.push( parent );
+  let parent = art._outer || art;
+  while (parent._main || parent.kind === 'builtin') { // until we hit the main artifact
+    if (parent.name.$inferred !== '$internal' || parent.kind === '$inline')
+      namePath.push( parent );
+    if (parent.kind === 'select')
+      break;
     parent = parent._parent;
+    parent = parent._outer || parent; // for anonymous aspect and items
   }
   namePath.reverse();
   // start with id/location of art.name, and absolute of art._main
-  const name = { id: art.name.id, location: art.name.location, absolute: parent.name.absolute };
+  const dot = (art._main || typeof name.id !== 'string') ? -1 : name.id.lastIndexOf( '.' );
+  const rname = (!parent?.name) ? { id: name.id } : {
+    id: (dot < 0 ? name.id : name.id.substring( dot + 1)),
+    location: name.location,
+    absolute: (parent._main || parent).name.id,
+  };
+  if (name.path !== undefined)
+    rname.path = name.path;
   for (const np of namePath) {
     const prop = getMemberNameProp( np, np.kind );
-    name[prop] = (name[prop]) ? `${ name[prop] }.${ np.name.id }` : np.name.id;
+    rname[prop] = (rname[prop]) ? `${ rname[prop] }.${ np.name.id }` : np.name.id;
+  }
+  if (name._artifact !== undefined) {
+    Object.defineProperty( rname, '_artifact',
+                           { value: name._artifact, configurable: true, writable: true } );
   }
-  const link = art.name._artifact;
-  if (link !== undefined)
-    Object.defineProperty( name, '_artifact', { value: link, configurable: true, writable: true } );
-  return name;
+  return rname;
 }
 
 // TODO: probably store this prop in name

package/lib/compiler/builtins.js

@@ -119,7 +119,7 @@ const specialFunctions = compileFunctions( {
   MAX: 'COUNT',
   SUM: 'COUNT',
   AVG: 'COUNT',
-  STDDDEV: 'COUNT',
+  STDDEV: 'COUNT',
   VAR: 'COUNT',
   LOCATE_REGEXPR: [
     {
@@ -441,7 +441,7 @@ function initBuiltins( model ) {
     const art = {
       kind: 'namespace',
       // builtin namespaces don't have a cds file, so no location available
-      name: { absolute: name, location: builtinLocation() },
+      name: { id: name, location: builtinLocation() },
       blocks: [],
       builtin,
       location: builtinLocation(),
@@ -462,10 +462,10 @@ function initBuiltins( model ) {
   function env( builtins, prefix, parent ) {
     const artifacts = Object.create( null );
     for (const name of Object.keys( builtins )) {
-      const absolute = prefix + name;
+      const id = prefix + name;
       // TODO: reconsider whether to set a type to itself - looks wrong
       const art = {
-        kind: 'type', builtin: true, name: { absolute },
+        kind: 'type', builtin: true, name: { id },
       };
       if (parent)
         parent._subArtifacts[name] = art;
@@ -475,21 +475,23 @@ function initBuiltins( model ) {
       Object.assign( art, builtins[name] );
       if (!art.internal)
         artifacts[name] = art;
-      model.definitions[absolute] = art;
+      model.definitions[id] = art;
     }
     return artifacts;
   }
 
   function setMagicVariables( builtins ) {
-    const artifacts = Object.create( null );
-    for (const name in builtins) {
-      const magic = builtins[name];
+    const elements = Object.create( null );
+    model.$magicVariables = { kind: '$magicVariables', elements };
+    for (const id in builtins) {
+      const magic = builtins[id];
       // TODO: rename to $builtinFunction
       const art = {
-        kind: 'builtin',
-        name: { id: name, absolute: '', element: name },
+        kind: 'builtin',        // TODO: $var
+        name: { id },
       };
-      artifacts[name] = art;
+      elements[id] = art;
+      setProp( art, '_parent', model.$magicVariables );
 
       if (magic.$autoElement)
         art.$autoElement = magic.$autoElement;
@@ -499,11 +501,10 @@ function initBuiltins( model ) {
         art.$requireElementAccess = magic.$requireElementAccess;
 
       createMagicElements( art, magic.elements );
-      if (options.variableReplacements?.[name])
-        createMagicElements( art, options.variableReplacements[name] );
+      if (options.variableReplacements?.[id])
+        createMagicElements( art, options.variableReplacements[id] );
       // setProp( art, '_effectiveType', art );
     }
-    model.$magicVariables = { kind: '$magicVariables', artifacts };
   }
 
   function createMagicElements( art, elements ) {
@@ -514,20 +515,20 @@ function initBuiltins( model ) {
     if (names.length > 0 && !art.elements)
       art.elements = Object.create( null );
 
-    for (const n of names) {
+    for (const id of names) {
       const magic = {
-        kind: 'builtin',        // TODO: '$variable'
-        name: { id: n, absolute: '', element: `${ art.name.element }.${ n }` },
+        kind: 'builtin',        // TODO: '$var'
+        name: { id },
       };
       // Propagate this property so that it is available for sub-elements.
       if (art.$uncheckedElements)
         magic.$uncheckedElements = art.$uncheckedElements;
       setProp( magic, '_parent', art );
       // setProp( magic, '_effectiveType', magic );
-      if (elements[n] && typeof elements[n] === 'object')
-        createMagicElements( magic, elements[n] );
+      if (elements[id] && typeof elements[id] === 'object')
+        createMagicElements( magic, elements[id] );
 
-      art.elements[n] = magic;
+      art.elements[id] = magic;
     }
   }
 }