@sap/cds-compiler 6.7.3 → 6.9.0

package/lib/gen/Dictionary.json

@@ -170,6 +170,8 @@
       "Type": "Core.Tag"
     },
     "Capabilities.BatchContinueOnErrorSupported": {
+      "$deprecated": true,
+      "$deprecationText": "Deprecated in favor of the [`ContinueOnErrorSupported`](#BatchSupportType) property from the [`BatchSupport`](#BatchSupport) term",
       "AppliesTo": [
         "EntityContainer"
       ],
@@ -1167,13 +1169,15 @@
     },
     "Communication.IsEmailAddress": {
       "AppliesTo": [
-        "Property"
+        "Property",
+        "Parameter"
       ],
       "Type": "Core.Tag"
     },
     "Communication.IsPhoneNumber": {
       "AppliesTo": [
-        "Property"
+        "Property",
+        "Parameter"
       ],
       "Type": "Core.Tag"
     },
@@ -1863,7 +1867,6 @@
           }
         }
       },
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"
@@ -2106,7 +2109,8 @@
     "UI.Placeholder": {
       "AppliesTo": [
         "Property",
-        "Parameter"
+        "Parameter",
+        "Record"
       ],
       "Type": "Edm.String"
     },
@@ -2145,7 +2149,11 @@
       "AppliesTo": [
         "EntityType"
       ],
-      "Type": "Edm.ComplexType"
+      "DerivedTypeConstraint": [
+        "Edm.ComplexType",
+        "Edm.EntityType"
+      ],
+      "Type": "Edm.Untyped"
     },
     "UI.SelectionFields": {
       "AppliesTo": [
@@ -2847,6 +2855,36 @@
         "TypecastSegmentSupported": "Edm.Boolean"
       }
     },
+    "Capabilities.ExpandByKeyRestrictionsBase": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.ExpandRestrictionsBase",
+      "Properties": {
+        "Expandable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "StreamsExpandable": "Edm.Boolean"
+      }
+    },
+    "Capabilities.ExpandByKeyRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.ExpandByKeyRestrictionsBase",
+      "Properties": {
+        "Expandable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "NonExpandableProperties": "Collection(Edm.NavigationPropertyPath)",
+        "NonExpandableStreamProperties": "Collection(Edm.PropertyPath)",
+        "StreamsExpandable": "Edm.Boolean"
+      }
+    },
+    "Capabilities.ExpandCollectionRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.ExpandRestrictionsBase",
+      "Properties": {
+        "ExpandByKeyRestrictions": "Capabilities.ExpandByKeyRestrictionsBase",
+        "Expandable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "StreamsExpandable": "Edm.Boolean"
+      }
+    },
     "Capabilities.ExpandRestrictionsBase": {
       "$kind": "ComplexType",
       "Properties": {
@@ -2857,8 +2895,9 @@
     },
     "Capabilities.ExpandRestrictionsType": {
       "$kind": "ComplexType",
-      "BaseType": "Capabilities.ExpandRestrictionsBase",
+      "BaseType": "Capabilities.ExpandCollectionRestrictionsType",
       "Properties": {
+        "ExpandByKeyRestrictions": "Capabilities.ExpandByKeyRestrictionsBase",
         "Expandable": "Edm.Boolean",
         "MaxLevels": "Edm.Int32",
         "NonExpandableProperties": "Collection(Edm.NavigationPropertyPath)",
@@ -4463,7 +4502,28 @@
         "CriticalityRepresentation": "UI.CriticalityRepresentationType",
         "IconUrl": "Edm.String",
         "Label": "Edm.String",
-        "Value": "Edm.Untyped"
+        "Value": {
+          "DerivedTypeConstraint": [
+            "Edm.PrimitiveType",
+            "Collection(Edm.Binary)",
+            "Collection(Edm.Boolean)",
+            "Collection(Edm.Byte)",
+            "Collection(Edm.Date)",
+            "Collection(Edm.DateTimeOffset)",
+            "Collection(Edm.Decimal)",
+            "Collection(Edm.Double)",
+            "Collection(Edm.Duration)",
+            "Collection(Edm.Guid)",
+            "Collection(Edm.Int16)",
+            "Collection(Edm.Int32)",
+            "Collection(Edm.Int64)",
+            "Collection(Edm.SByte)",
+            "Collection(Edm.Single)",
+            "Collection(Edm.String)",
+            "Collection(Edm.TimeOfDay)"
+          ],
+          "Type": "Edm.Untyped"
+        }
       }
     },
     "UI.DataFieldAbstract": {

package/lib/json/from-csn.js

@@ -115,9 +115,9 @@
  * @returns {any} XSN property (e.g. string, object, ...)
  */
 
-const { dictAdd } = require('../base/dictionaries');
+const { dictAdd } = require('../compiler/dictionaries');
 const { quotedLiteralPatterns } = require('../compiler/builtins');
-const { isAnnotationExpression } = require('../base/builtins');
+const { exprProperties } = require('../base/builtins');
 const { CompilerAssertion } = require('../base/error');
 const { Location } = require('../base/location');
 const { XsnSource } = require('../compiler/xsn-model');
@@ -141,11 +141,6 @@ const typeProperties = [
   'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull', 'default',
   'keys', 'on',                 // only with 'target'
 ];
-const exprProperties = [
-  // do not include CSN v0.1.0 properties here:
-  'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET', // Core Compiler checks SELECT/SET
-  'param', 'literal', 'args', 'cast', // only with 'ref'/'ref'/'val'/'func'
-];
 
 // Groups of properties which cannot be used together:
 const xorGroups = {
@@ -619,16 +614,16 @@ const schema = compileSchema( {
     optional: exprProperties,
   },
   where: {
-    class: 'condition',
+    class: 'condition', inKind: [ 'extend' ],
   },
   groupBy: {
-    arrayOf: expr, optional: exprProperties,
+    arrayOf: expr, optional: exprProperties, inKind: [ 'extend' ],
   },
   having: {
-    class: 'condition',
+    class: 'condition', inKind: [ 'extend' ],
   },
   orderBy: {
-    arrayOf: expr, optional: [ 'sort', 'nulls', ...exprProperties ],
+    arrayOf: expr, optional: [ 'sort', 'nulls', ...exprProperties ], inKind: [ 'extend' ],
   },
   sort: {
     type: stringVal,
@@ -637,7 +632,7 @@ const schema = compileSchema( {
     type: stringVal,            // TODO: test for valid ones?
   },
   limit: {
-    type: object, requires: 'rows', optional: [ 'rows', 'offset' ],
+    type: object, requires: 'rows', optional: [ 'rows', 'offset' ], inKind: [ 'extend' ],
   },
   rows: {
     class: 'expression',
@@ -752,7 +747,7 @@ const schema = compileSchema( {
     type: namespace,
   },
   meta: {                       // meta information
-    type: ignore,               // TODO: should we test s/th here?
+    type: meta,                 // TODO: should we test s/th here?
   },
   version: {                    // deprecated top-level property
     type: ignore,
@@ -904,6 +899,11 @@ function arrayOf( fn, filter = undefined ) {
 
 // Generic functions, objects (std signature) --------------------------------
 
+function meta( obj ) {
+  ignore( obj );
+  return obj;
+}
+
 function ignore( obj ) {
   if (obj && typeof obj === 'object') {
     const array = (Array.isArray( obj )) ? obj : Object.values( obj );
@@ -1462,7 +1462,7 @@ function annoValue( val, spec ) {
       ++virtualLine;
       return r;
     }
-    else if (isAnnotationExpression( val )) {
+    else if (exprProperties.some( prop => val[prop] !== undefined )) {
       const s = schema['@'].schema['-expr'];
       const r = { location: location() };
       Object.assign( r, object( val, s ) );

package/lib/json/to-csn.js

@@ -12,7 +12,7 @@
 'use strict';
 
 const { locationString } = require('../base/messages');
-const { isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/specialOptions');
 const { pathName } = require('../compiler/utils');
 const { CompilerAssertion } = require('../base/error');
 
@@ -234,11 +234,11 @@ function compactModel( model, options = model.options || {} ) {
   }
   // '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 first = Object.keys( srcDict )[0];
+  if (first) {
     const { namespace } = srcDict[first];
     if (namespace?.name?.path)
       csn.namespace = pathName( namespace.name.path );
-    break;
   }
   set( 'definitions', csn, model );
   if (Object.keys(model.vocabularies || {}).length > 0)
@@ -249,21 +249,38 @@ function compactModel( model, options = model.options || {} ) {
   set( 'i18n', csn, model );
   set( 'sources', csn, model );
   // Set $location, use $extra properties of first source as resulting $extra properties
-  for (const first in srcDict) {
-    const loc = srcDict[first].location;
+  const firstSourceName = Object.keys( srcDict )[0];
+  if (firstSourceName) {
+    const firstSource = srcDict[firstSourceName];
+    const loc = firstSource.location;
     if (loc && loc.file) {
       Object.defineProperty( csn, '$location', {
         value: { file: loc.file }, configurable: true, writable: true, enumerable: withLocations,
       } );
     }
-    set( '$extra', csn, srcDict[first] );
-    break;
-  }
-
+    set( '$extra', csn, firstSource );
+  }
+
+  const srcNames = Object.keys( srcDict );
+  const firstMeta = srcDict[srcNames[0]].meta;
+  const meta = srcNames.length === 1 && firstMeta ? { ...firstMeta } : undefined;
+  if (meta?.flavor)
+    delete meta.flavor; // not supported, compilerCsnFlavor is used instead
+  const flavorMap = {
+    client: 'inferred',
+    gensrc: 'xtended',
+    universal: 'universal',
+  };
+  const compilerCsnFlavor = flavorMap[options.csnFlavor] ||
+                            (options.parseCdl ? 'parsed' : 'inferred');
   if (!options.testMode) {
-    csn.meta = Object.assign( {}, model.meta, { creator } );
+    csn.meta = Object.assign( {}, model.meta, meta,
+                              { creator, compilerVersion, compilerCsnFlavor } );
     csn.$version = csnVersion;
   }
+  else if (meta !== undefined) {
+    csn.meta = Object.assign( {}, meta );
+  }
   return csn;
 }
 
@@ -307,16 +324,11 @@ function usings( srcDict ) {
 function extensions( node, csn, model ) {
   if (model.kind && model.kind !== 'source')
     return undefined;
-  const exts = node.map( definition );
-  if (gensrcFlavor) {
-    for (const name of Object.getOwnPropertyNames( model.definitions || {} ).sort()) {
-      const art = model.definitions[name];
-      // From definitions (without redefinitions) with potential inferred elements:
-      const result = { annotate: Object.create(null) };
-      attachAnnotations( result, 'annotate', { [name]: art }, art.$inferred );
-      if (result.annotate[name])
-        exts.push( { annotate: name, ...result.annotate[name] } );
-    }
+  let exts = node.map( definition );
+  if (gensrcFlavor && model.definitions) {
+    const gensrc = { annotate: Object.create( null ), extend: Object.create( null ) };
+    attachAnnotations( gensrc, null, model.definitions, null );
+    exts = exts.concat( Object.values( gensrc.annotate ), Object.values( gensrc.extend ) );
   }
   return exts.sort(             // TODO: really sort with parse.cdl?
     (a, b) => (a.annotate || a.extend).localeCompare( b.annotate || b.extend )
@@ -363,36 +375,64 @@ function sources( srcDict, csn, model ) {
   }
 }
 
-function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
-  const annoDict = Object.create( dictionaryPrototype );
+// create annotate and extend statements for CSN flavor gensrc
+// TODO: rename this function - also refactor
+function attachAnnotations( annotate, prop, dict, inferred, withExtend, insideReturns = false ) {
+  const annoDict = prop && Object.create( dictionaryPrototype );
   const names = Object.keys( dict );
   if (strictMode)
     names.sort();
   for (const name of names) {
     const entry = dict[name];
     const inf = inferred || entry.$inferred; // is probably always inferred if parent was
-    const sub = (inf) ? annotationsAndDocComment( entry ) : {};
-    if (entry.$expand === 'annotate') {
+    const withExt = withExtend || entry.$expand === 'extend';
+    const extProp = (entry.$expand === 'extend') ? 'extend' : 'annotate';
+    if (withExt && !entry.$inferred && entry.kind === 'enum') {
+      // currently just added enum - test for safety
+      if (dict[$inferred])
+        annoDict[name] = definition( entry );
+      continue;
+    }
+    let sub = {};
+    if (inf)
+      annotationsAndDocComment( entry, sub );
+
+    if (entry.$expand === 'annotate' || entry.$expand === 'extend') {
       if (entry.actions)
         attachAnnotations( sub, 'actions', entry.actions, inf );
       else if (entry.params)
         attachAnnotations( sub, 'params', entry.params, inf );
+
+      if (entry.$expand === 'extend' && (sub.actions || sub.params)) {
+        // there is only `annotate` with actions/params
+        annotate.annotate[name] = { annotate: name, ...sub };
+        sub = {};
+      }
+
       const obj = entry.returns || entry;
-      const many = obj.items || obj;
+      const many = obj.items || obj; // TODO: many many?
       const elems = (many.targetAspect || many).elements;
-      if (elems)
-        attachAnnotations( sub, 'elements', elems, inf, entry.returns );
-      else if (many.enum)       // make 'enum' annotations appear in 'elements' annotate
-        attachAnnotations( sub, 'elements', many.enum, inf, entry.returns );
-      else if (entry.foreignKeys) // make 'foreignKeys' annotations appear in 'elements' annotate
-        attachAnnotations( sub, 'elements', entry.foreignKeys, inf );
+      if (elems) {
+        attachAnnotations( sub, 'elements', elems, inf, withExt, entry.returns );
+      }
+      else if (many.enum) { // make 'enum' annotations appear in 'elements' annotate
+        attachAnnotations( sub, (withExt ? 'enum' : 'elements'),
+                           many.enum, inf, withExt, entry.returns );
+      }
+      else if (entry.foreignKeys) { // make 'foreignKeys' annotations appear in 'elements' annotate
+        attachAnnotations( sub, 'elements', entry.foreignKeys, inf, withExt );
+      }
+    }
+    if (Object.keys( sub ).length > 0) {
+      if (prop)
+        annoDict[name] = (withExt) ? { kind: 'extend', ...sub } : sub;
+      else
+        annotate[extProp][name] = { [extProp]: name, ...sub };
     }
-    if (Object.keys( sub ).length)
-      annoDict[name] = sub;
   }
-  if (Object.keys( annoDict ).length) {
+  if (prop && Object.keys( annoDict ).length) {
     if (insideReturns)
-      annotate.returns = { elements: annoDict };
+      annotate.returns = { [prop]: annoDict };
     else
       annotate[prop] = annoDict;
   }
@@ -509,7 +549,7 @@ function enumerableQueryElements( select ) {
   return (universalCsn && select !== select._main._leadingQuery);
 }
 
-// Should we render the elements?  (and items?)
+// Should we render the elements?  (and enum, items?)
 function keepElements( node, line ) {
   if (universalCsn)
     // $expand = null/undefined: not elements not via expansion
@@ -547,8 +587,7 @@ function keepElements( node, line ) {
  *
  * @param {object} node
  */
-function annotationsAndDocComment( node ) {
-  const csn = {};
+function annotationsAndDocComment( node, csn = {} ) {
   const transformer = transformers['@'];
   const keys = Object.keys( node ).filter( a => a.charAt(0) === '@' ).sort();
   for (const prop of keys) {

package/lib/main.js

@@ -14,13 +14,13 @@
 
 'use strict';
 
-const lazyload = require('./base/lazyload')( module );
+const lazyload = require('./utils/lazyload')( module );
 
-const { traceApi } = require('./api/trace');
+const { traceApi } = require('./base/trace');
 
 const snapi = lazyload('./api/main');
 const csnUtils = lazyload('./model/csnUtils');
-const modelApi = lazyload('./model/api');
+const modelApi = lazyload('./base/model-api');
 const messages = lazyload('./base/messages');
 const sqlIdentifier = lazyload('./sql-identifier');
 const keywords = lazyload( './base/keywords' );

package/lib/model/csnUtils.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { csnRefs, implicitAs, pathId } = require('./csnRefs');
+const { csnRefs, implicitAs, pathId } = require('../base/csnRefs');
 const {
   transformExpression,
   transformAnnotationExpression,
@@ -13,7 +13,7 @@ const { isBuiltinType, isAnnotationExpression } = require('../base/builtins');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
-const { cloneAnnotationValue } = require('./cloneCsn');
+const { cloneAnnotationValue } = require('../base/cloneCsn');
 
 // Low-level utility functions to work with compact CSN.
 

package/lib/modelCompare/compare.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 const {
   forEachDefinition,
   forEachMember,

package/lib/modelCompare/utils/filter.js

@@ -148,6 +148,7 @@ const defaultAllowedTypeChanges = {
   'cds.Integer': [ 'cds.Int32', 'cds.Int64', 'cds.Integer64' ],
   'cds.Integer64': [ 'cds.Int64' ],
   'cds.Int64': [ 'cds.Integer64' ],
+  'cds.String': [ 'cds.LargeString' ],
 };
 
 const allowedTypeChanges = {