@sap/cds-compiler 4.3.0 → 4.4.0

package/lib/compiler/tweak-assocs.js

@@ -6,7 +6,7 @@ const {
   forEachGeneric,
   forEachInOrder,
 } = require('../base/model');
-const { dictLocation, weakLocation } = require('../base/location');
+const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
 const {
   setLink,
@@ -42,7 +42,7 @@ function tweakAssocs( model ) {
   // Phase 5: rewrite associations
   model._entities.forEach( rewriteArtifact );
   // Think hard whether an on condition rewrite can lead to a new cyclic
-  // dependency.  If so, we need other messages anyway.  TODO: probably do
+  // dependency.  If so, we need other messages anyway.  TODO: probably dox
   // another cyclic check with testMode.js
   forEachUserArtifact( model, 'definitions', function check( art ) {
     checkOnCondition( art.on, (art.kind !== 'mixin' ? 'on' : 'mixin-on'), art );
@@ -73,7 +73,7 @@ function tweakAssocs( model ) {
       } );
     }
     if (art._service)
-      forEachGeneric( art, 'elements', excludeAssociation );
+      forEachGeneric( art, 'elements', complainAboutTargetOutsideService );
 
     traverseQueryPost( art.query, false, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociationCheck );
@@ -95,12 +95,14 @@ function tweakAssocs( model ) {
   //   } );
   // }
 
-  function excludeAssociation( elem ) {
+  function complainAboutTargetOutsideService( elem ) {
     const target = elem.target && elem.target._artifact;
     if (!target || target._service) // assoc to other service is OK
       return;
-    if (!elem.$inferred) {      // && !elem.target.$inferred
-      info( 'assoc-target-not-in-service', [ elem.target.location, elem ],
+    const loc = [ elem.target.location, elem ];
+    const main = elem._main || elem;
+    if (!elem.$inferred && !main.$inferred) {
+      info( 'assoc-target-not-in-service', loc,
             { target, '#': (elem._main.query ? 'select' : 'define') }, {
               std: 'Target $(TARGET) of association is outside any service', // not used
               // eslint-disable-next-line max-len
@@ -110,10 +112,13 @@ function tweakAssocs( model ) {
             } );
     }
     else {
+      const text = main.$inferred === 'autoexposed' ? 'exposed' : 'std';
       // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
-      info( 'assoc-outside-service', [ elem.target.location, elem ],
-            { target },
-            'Association target $(TARGET) is outside any service' );
+      info( 'assoc-outside-service', loc, { '#': text, target, service: main._service }, {
+        std: 'Association target $(TARGET) is outside any service',
+        // eslint-disable-next-line max-len
+        exposed: 'If association is published in service $(SERVICE), its target $(TARGET) is outside any service',
+      } );
     }
   }
 
@@ -257,10 +262,36 @@ function tweakAssocs( model ) {
         rewriteCondition( art, elem );
       else if (elem.foreignKeys)
         rewriteKeys( art, elem );
+
+      if (art.on)
+        removeManagedPropsFromUnmanaged( art );
+
       elem = art;
     }
   }
 
+  /**
+   * Remove properties from unmanaged association `elem` that are only valid
+   * on managed associations.  Only set to `NULL` (special value for propagator),
+   * if necessary, i.e. the value is set on the `_origin`-chain.
+   */
+  function removeManagedPropsFromUnmanaged( elem ) {
+    removeProp( 'notNull' );
+    removeProp( 'default' );
+
+    function removeProp( prop ) {
+      let origin = elem;
+      while (origin) {
+        if (origin[prop]) { // regardless of the value, reset the property
+          const location = weakLocation( elem.name.location );
+          elem[prop] = { $inferred: 'NULL', val: undefined, location };
+          break;
+        }
+        origin = origin._origin;
+      }
+    }
+  }
+
   function originTarget( elem ) {
     const assoc = !elem.expand && getOrigin( elem );
     const ftype = assoc && effectiveType( assoc );
@@ -276,13 +307,13 @@ function tweakAssocs( model ) {
     // already in Phase 2: redirectImplicitly()
     // console.log(message( null, elem.location, elem, {art:assoc,target:assoc.target},
     //  'Info','FK').toString())
+    elem.foreignKeys = Object.create(null); // set already here (also for zero foreign keys)
     forEachInOrder( assoc, 'foreignKeys', ( orig, name ) => {
-      const fk = linkToOrigin( orig, name, elem, 'foreignKeys', elem.location );
+      const location = weakRefLocation( elem.target );
+      const fk = linkToOrigin( orig, name, elem, 'foreignKeys', location );
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
-      // TODO: re-check for case that foreign key is managed association
-      if (orig._effectiveType !== undefined)
-        setLink( fk, '_effectiveType', orig._effectiveType );
-      const te = copyExpr( orig.targetElement, elem.location );
+      setLink( fk, '_effectiveType', fk );
+      const te = copyExpr( orig.targetElement, location );
       if (elem._redirected) {
         const i = te.path[0];   // TODO: or also follow path like for ON?
         const state = rewriteItem( elem, i, i.id, elem, true );
@@ -325,12 +356,9 @@ function tweakAssocs( model ) {
     // `cond` still points to the original condition; does not include possible assoc filter
     elem.on.$inferred = 'copy';
 
-    // console.log(message( null, elem.location, elem, {art:assoc,target:assoc.target},
-    //   'Info','ON').toString(), nav)
     const { navigation } = nav;
     if (!navigation) // TODO: what about $projection.assoc as myAssoc ?
       return;                 // should not happen: $projection, $magic, or ref to const
-    // console.log(message( null, elem.location, elem, {art:assoc}, 'Info','D').toString())
     // Currently, having an unmanaged association inside a struct is not
     // supported by this function:
     if (navigation !== assoc && navigation._origin !== assoc) { // TODO: re-check
@@ -428,8 +456,13 @@ function tweakAssocs( model ) {
         setLink( expr.path[0], '_artifact', elem );
         // _navigation link not necessary because this condition is not rewritten
         // inside the same view (would otherwise be needed for mixins).
+
+        if (elem.name.id.charAt(0) === '$')
+          prependSelfToPath( expr.path, elem );
       }
     } );
+
+    checkOnCondition( cond, 'on', elem );
     return cond;
   }
 
@@ -465,6 +498,9 @@ function tweakAssocs( model ) {
       setLink( lhs.path[0], '_artifact', elem ); // different to rhs!
       setLink( lhs, '_artifact', lhs.path[lhs.path.length - 1] );
 
+      if (elem.name.id.charAt(0) === '$')
+        prependSelfToPath( lhs.path, elem );
+
       const rhs = {
         path: [
           // use origin's name; elem could have alias
@@ -587,11 +623,12 @@ function tweakAssocs( model ) {
 
   function rewritePath( ref, item, assoc, elem, location ) {
     const { path } = ref;
-    let root = path[0];
+    const root = path[0];
     if (!elem) {
       if (location) {
+        const elemref = root._navigation?.kind === '$self' ? path.slice(1) : path;
         error( 'rewrite-not-projected', [ location, assoc ], {
-          name: assoc.name.id, art: item._artifact, elemref: { ref: path },
+          name: assoc.name.id, art: item._artifact, elemref: { ref: elemref },
         }, {
           std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
           element: 'Projected association $(NAME) uses non-projected element $(ELEMREF) of $(ART)',
@@ -614,10 +651,7 @@ function tweakAssocs( model ) {
       }
     }
     else if (elem.name.id.charAt(0) === '$') {
-      root = { id: '$self', location: item.location };
-      path.unshift( root );
-      setLink( root, '_navigation', assoc._parent.$tableAliases.$self );
-      setArtifactLink( root, assoc._parent );
+      prependSelfToPath( path, assoc );
     }
     else {
       setLink( root, '_navigation', elem );
@@ -644,6 +678,13 @@ function tweakAssocs( model ) {
       setArtifactLink( ref, state );
   }
 
+  function prependSelfToPath( path, elem ) {
+    const root = { id: '$self', location: path[0].location };
+    path.unshift( root );
+    setLink( root, '_navigation', elem._parent.$tableAliases.$self );
+    setArtifactLink( root, elem._parent );
+  }
+
   function rewriteItem( elem, item, name, assoc, forKeys ) {
     if (!elem._redirected)
       return true;

package/lib/compiler/utils.js

@@ -11,6 +11,7 @@
 'use strict';
 
 const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
+const { weakLocation } = require('../base/location');
 const { XsnName, XsnArtifact, CsnLocation } = require('./classes');
 
 const $inferred = Symbol.for( 'cds.$inferred' );
@@ -89,10 +90,11 @@ function setArtifactLink( obj, value ) {
 }
 
 function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
+  location ||= weakLocation( origin.name.location ); // not ??=
   const elem = {
-    name: { location: location || origin.name.location, id: name },
+    name: { location, id: origin.name.id },
     kind: origin.kind,
-    location: location || origin.location,
+    location,
   };
   if (origin.name.$inferred)
     elem.name.$inferred = origin.name.$inferred;
@@ -101,6 +103,7 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   setLink( elem, '_origin', origin );
   // TODO: should we use silent dependencies also for other things, like
   // included elements?  (Currently for $inferred: 'expanded' only)
+  // TODO: shouldn't we always use silent dependencies in this function?
   if (silentDep)
     dependsOnSilent( elem, origin );
   else
@@ -241,11 +244,11 @@ function augmentPath( location, ...args ) {
   return { path: args.map( id => ({ id, location }) ), location };
 }
 
-function copyExpr( expr, location, skipUnderscored, rewritePath ) {
+function copyExpr( expr, location ) {
   if (!expr || typeof expr !== 'object')
     return expr;
   else if (Array.isArray( expr ))
-    return expr.map( e => copyExpr( e, location, skipUnderscored, rewritePath ) );
+    return expr.map( e => copyExpr( e, location ) );
 
   const proto = Object.getPrototypeOf( expr );
   if (proto && proto !== Object.prototype && proto !== XsnName.prototype &&
@@ -255,23 +258,17 @@ function copyExpr( expr, location, skipUnderscored, rewritePath ) {
   const r = Object.create( proto );
   for (const prop of Object.getOwnPropertyNames( expr )) {
     const pd = Object.getOwnPropertyDescriptor( expr, prop );
-    if (!pd.enumerable) { // should include all properties starting with _
-      if (!skipUnderscored ||
-          prop === '_artifact' || prop === '_navigation' || prop === '_effectiveType')
-        Object.defineProperty( r, prop, pd );
-    }
-    else if (!proto) {
-      r[prop] = copyExpr( pd.value, location, skipUnderscored, rewritePath );
-    }
-    else if (prop === 'location') {
-      r[prop] = location || pd.value;
-    }
-    else if (prop.charAt(0) !== '$' || prop === '$inferred') {
-      r[prop] = copyExpr( pd.value, location, skipUnderscored, rewritePath );
-    }
-    else if (!skipUnderscored) {  // skip $ properties
+    if (!proto)
+      r[prop] = copyExpr( pd.value, location );
+
+    else if (!pd.enumerable || prop.charAt(0) === '$')
       Object.defineProperty( r, prop, pd );
-    }
+
+    else if (prop === 'location')
+      r[prop] = location || pd.value;
+
+    else
+      r[prop] = copyExpr( pd.value, location );
   }
   return r;
 }
@@ -558,8 +555,26 @@ function setExpandStatusAnnotate( elem, status ) {
 }
 
 function isDirectComposition( art ) {
-  const type = art.type && art.type.path;
-  return type && type[0] && type[0].id === 'cds.Composition';
+  const path = art.type?.path;
+  return path?.length === 1 && path[0].id === 'cds.Composition';
+}
+
+function targetCantBeAspect( elem, calledForTargetAspectProp ) {
+  // Remark: we do not check `on` and `keys` here - the error should complain
+  // at the `on`/`keys`, not the aspect
+  if (!isDirectComposition( elem ) || elem.targetAspect && !calledForTargetAspectProp)
+    return (elem.type && !elem.type.$inferred) ? 'std' : 'redirected';
+  if (!elem._main)
+    return elem.kind;           // type or annotation
+  // TODO: extra for "in many"?
+  let art = elem;
+  while (art.kind === 'element')
+    art = art._parent;
+  if (![ 'entity', 'aspect', 'event' ].includes( art.kind ))
+    return (art.kind !== 'mixin') ? art.kind : 'select';
+  return ((art.query || art.kind === 'event') && !(calledForTargetAspectProp && elem.target))
+    ? art.kind
+    : elem._parent.kind === 'element' && 'sub';
 }
 
 function userQuery( user ) {
@@ -648,7 +663,8 @@ function artifactRefLocation( ref ) {
 }
 
 function compositionTextVariant( art, composition, association = 'std' ) {
-  return (getUnderlyingBuiltinType( art )?.name.absolute === 'cds.Composition')
+  const builtin = getUnderlyingBuiltinType( art );
+  return (!builtin._main && builtin.name.id === 'cds.Composition')
     ? composition
     : association;
 }
@@ -683,6 +699,7 @@ module.exports = {
   setExpandStatus,
   setExpandStatusAnnotate,
   isDirectComposition,
+  targetCantBeAspect,
   userQuery,
   pathStartsWithSelf,
   columnRefStartsWithSelf,

package/lib/edm/.eslintrc.json

@@ -5,6 +5,8 @@
   "plugins": ["sonarjs"],
   "extends": ["../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
   "rules": {
+    "cds-compiler/message-no-quotes": "off",
+    "cds-compiler/message-template-string": "off",
     "prefer-const": "error",
     "quotes": ["error", "single", "avoid-escape"],
     "prefer-template": "error",

package/lib/edm/EdmPrimitiveTypeDefinitions.js

@@ -0,0 +1,252 @@
+'use strict';
+
+// facet definitions, optional could either be true or array of edm types
+// remove indicates wether or not the canonic facet shall be removed when applying @odata.Type
+const EdmTypeFacetMap = {
+  MaxLength: {
+    v2: true, v4: true, remove: true, optional: true,
+  },
+  Precision: {
+    v2: true, v4: true, remove: true, optional: true,
+  },
+  Scale: {
+    v2: true, v4: true, remove: true, optional: true, extra: 'sap:variable-scale',
+  },
+  SRID: { v4: true, remove: true, optional: true },
+  // 'FixedLength': { v2: true },
+  // 'Collation': { v2: true },
+  // 'Unicode': { v2: true, v4: true },
+};
+const EdmTypeFacetNames = Object.keys(EdmTypeFacetMap);
+
+// Merged primitive type map with descriptions taken from V4 spec and filled up with V2 spec
+const EdmPrimitiveTypeMap = {
+  'Edm.Binary': {
+    v2: true,
+    v4: true,
+    MaxLength: true,
+    FixedLength: true,
+    max: 1,
+    desc: 'Binary data',
+  },
+  'Edm.Boolean': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'Binary-valued logic',
+  },
+  'Edm.Byte': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'Unsigned 8-bit integer',
+  },
+  'Edm.Date': {
+    v4: true,
+    exact: 0,
+    desc: 'Date without a time-zone offset',
+  },
+  'Edm.DateTime': {
+    v2: true,
+    Precision: true,
+    max: 1,
+    desc: 'Date and time with values ranging from 12:00:00 midnight, January 1, 1753 A.D. through 11:59:59 P.M, December 31, 9999 A.D.',
+  },
+  'Edm.DateTimeOffset': {
+    v2: true,
+    v4: true,
+    Precision: true,
+    max: 1,
+    desc: 'Date and time with a time-zone offset, no leap seconds',
+  },
+  'Edm.Decimal': {
+    v2: true,
+    v4: true,
+    Precision: true,
+    Scale: true,
+    max: 2,
+    desc: 'Numeric values with decimal representation',
+  },
+  'Edm.Double': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'IEEE 754 binary64 floating-point number (15-17 decimal digits)',
+  },
+  'Edm.Duration': {
+    v4: true,
+    Precision: true,
+    max: 1,
+    desc: 'Signed duration in days, hours, minutes, and (sub)seconds',
+  },
+  'Edm.Guid': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: '16-byte (128-bit) unique identifier',
+  },
+  'Edm.Int16': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'Signed 16-bit integer',
+  },
+  'Edm.Int32': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'Signed 32-bit integer',
+  },
+  'Edm.Int64': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'Signed 64-bit integer',
+  },
+  'Edm.SByte': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'Signed 8-bit integer',
+  },
+  'Edm.Single': {
+    v2: true,
+    v4: true,
+    exact: 0,
+    desc: 'IEEE 754 binary32 floating-point number (6-9 decimal digits)',
+  },
+  'Edm.Stream': {
+    v4: true,
+    MaxLength: true,
+    max: 1,
+    desc: 'Binary data stream',
+  },
+  'Edm.String': {
+    v2: true,
+    v4: true,
+    MaxLength: true,
+    FixedLength: true,
+    Collation: true,
+    Unicode: true,
+    max: 1,
+    desc: 'Sequence of characters',
+  },
+  'Edm.Time': {
+    v2: true,
+    Precision: true,
+    max: 1,
+    desc: 'time of day with values ranging from 0:00:00.x to 23:59:59.y, where x and y depend upon the precision',
+  },
+  'Edm.TimeOfDay': {
+    v4: true,
+    Precision: true,
+    max: 1,
+    desc: 'Clock time 00:00-23:59:59.999999999999',
+  },
+  'Edm.Geography': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Abstract base type for all Geography types',
+  },
+  'Edm.GeographyPoint': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'A point in a round-earth coordinate system',
+  },
+  'Edm.GeographyLineString': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Line string in a round-earth coordinate system',
+  },
+  'Edm.GeographyPolygon': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Polygon in a round-earth coordinate system',
+  },
+  'Edm.GeographyMultiPoint': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of points in a round-earth coordinate system',
+  },
+  'Edm.GeographyMultiLineString': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of line strings in a round-earth coordinate system',
+  },
+  'Edm.GeographyMultiPolygon': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of polygons in a round-earth coordinate system',
+  },
+  'Edm.GeographyCollection': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of arbitrary Geography values',
+  },
+  'Edm.Geometry': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Abstract base type for all Geometry types',
+  },
+  'Edm.GeometryPoint': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Point in a flat-earth coordinate system',
+  },
+  'Edm.GeometryLineString': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Line string in a flat-earth coordinate system',
+  },
+  'Edm.GeometryPolygon': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    descr: 'Polygon in a flat-earth coordinate system',
+  },
+  'Edm.GeometryMultiPoint': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of points in a flat-earth coordinate system',
+  },
+  'Edm.GeometryMultiLineString': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of line strings in a flat-earth coordinate system',
+  },
+  'Edm.GeometryMultiPolygon': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of polygons in a flat-earth coordinate system',
+  },
+  'Edm.GeometryCollection': {
+    v4: true,
+    SRID: true,
+    max: 1,
+    desc: 'Collection of arbitrary Geometry values',
+  },
+  'Edm.PrimitiveType': {
+    v4: true,
+    exact: 0,
+    desc: 'Abstract meta type',
+  },
+  // 'Edm.Untyped': { v4: true, desc: 'Abstract void type' },
+};
+
+module.exports = {
+  EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap,
+};