@sap/cds-compiler 5.3.0 → 5.4.0

package/lib/compiler/shared.js

@@ -481,6 +481,7 @@ function fns( model ) {
           artifact[par] = args[i];
       }
       args = args.slice( parameters.length );
+      // TODO: we could issue syntax-unexpected-argument here
     }
     else if (args.length > 0 && !typeArtifact?.builtin) {
       // One or two arguments are interpreted as either length or precision/scale.
@@ -503,13 +504,10 @@ function fns( model ) {
     // Warn about left-over arguments.
     if (args.length > 0) {
       const loc = [ args[0].location, user ];
-      if (typeArtifact?.builtin) {
+      if (typeArtifact?.builtin)
         message( 'type-ignoring-argument', loc, { art: typeArtifact } );
-      }
-      else if (options.testMode) {
-        // Ensure: parser reports error and sets $typeArgs to undefined if more than 2 parameter
-        throw new CompilerAssertion( 'More than 2 type arguments set by parser' );
-      }
+      // when the parser exits rule unsuccessfully/prematurely, $typeArgs might
+      // still have a length > 2 → no testMode dump
     }
     artifact.$typeArgs = undefined;
   }
@@ -751,9 +749,10 @@ function fns( model ) {
       }
       case '$parameters': {
         // TODO: if ref.scope='param' is handled, test that here, too ?
-        const { id } = path[1];
-        message( 'ref-obsolete-parameters', [ head.location, user ],
-                 { code: `$parameters.${ id }`, newcode: `:${ id }` },
+        const id = path[1]?.id;
+        const code = id ? `$parameters.${ id }` : '$parameters';
+        const newcode = id ? `:${ id }` : ':‹param›';
+        message( 'ref-obsolete-parameters', [ head.location, user ], { code, newcode },
                  'Obsolete $(CODE) - replace by $(NEWCODE)' );
         return art;
       }
@@ -1632,7 +1631,7 @@ function fns( model ) {
 
     for (let set = query._main.query; set.op; set = set.args[0]) {
       const right = set.args[1];
-      if (query.name.id >= (right._leadingQuery || right).name.id)
+      if (query.name.id >= ((right._leadingQuery || right).name?.id ?? 0))
         return { txt: 'setQuery', op: set.op.val };
     }
     throw new CompilerAssertion( 'Did we pass the leading query as argument?' );

package/lib/compiler/xpr-rewrite.js

@@ -152,6 +152,7 @@ const {
 } = require('./utils');
 const { CompilerAssertion } = require('../base/error');
 const { isBetaEnabled } = require('../base/model');
+const { isSimpleCdlIdentifier } = require('../parsers/identifiers');
 
 // Config object passed around all "rewrite" functions.
 class AnnoRewriteConfig {
@@ -319,6 +320,16 @@ function xprRewriteFns( model ) {
       }
     }
 
+    if (expr.$tokenTexts === true) {
+      // TODO: do not do with Universal-CSN (and gensrc, but that does not matter)
+      // We rewrite the string value for backward compatibility with "old-school" tools that
+      // only understand the string representation.  But we only do so for simple strings, which
+      // is the case if this path expression has $tokenTexts. It then is of the form `@a: (path)`.
+      const isSimpleStep = step => !step.where && !step.args && isSimpleCdlIdentifier( step.id );
+      if (expr.path.every(isSimpleStep))
+        expr.$tokenTexts = expr.path.map( step => step.id ).join('.');
+    }
+
     if (model.options.testMode) {
       // re-resolve the modified path; all paths steps must match what we rewrote
       const ref = { ...expr, path: [ ...expr.path.map(item => ({ ...item })) ] };

package/lib/compiler/xsn-model.js

@@ -19,7 +19,7 @@
 
 'use strict';
 
-class XsnSource {
+class XsnSource {               // TODO: should be subclass of XsnArtifact
   kind = 'source';
   location;
   usings = [];

package/lib/edm/csn2edm.js

@@ -328,6 +328,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
       href._jsonOnlyAttributes['Edm.String'] = 'https://cap.cloud.sap';
       const watermark = new Edm.Annotation(v, 'Core.Links', new Edm.Collection(v, new Edm.Record(v, rel, href)));
       // watermark._edmAttributes['Qualifier'] = 'CAP';
+      if (options.isV2())
+        watermark._xmlOnlyAttributes.xmlns = 'http://docs.oasis-open.org/odata/ns/edm';
       return watermark;
     }
 

package/lib/edm/edm.js

@@ -1239,7 +1239,8 @@ function getEdm( options, messageFunctions ) {
   class Annotations extends AnnotationBase {
     constructor(version, target) {
       super(version, { Target: target });
-      this.setXml( { xmlns: this.v2 ? 'http://docs.oasis-open.org/odata/ns/edm' : undefined } );
+      if (this.v2)
+        this._xmlOnlyAttributes.xmlns = 'http://docs.oasis-open.org/odata/ns/edm';
     }
 
     toJSONattributes(json) {

package/lib/edm/edmPreprocessor.js

@@ -107,9 +107,19 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
   /*
     Enrich the CSN by de-anonymizing and exposing types that are required to make the service self contained.
   */
+  // add cds.Map structured type into definitions to allow types exposure to pull in this type
+  if (options.isV4() && csn.definitions['cds.Map'] == null) {
+    const cdsMap = { '@open': true, elements: Object.create(null) };
+    setProp(cdsMap, '$emtpyMapType', true);
+    csn.definitions['cds.Map'] = cdsMap;
+  }
+
   const schemas = typesExposure(csn, whatsMyServiceRootName, requestedServiceNames,
                                 fallBackSchemaName, options, csnUtils, { error });
 
+  if (options.isV4() && csn.definitions['cds.Map']?.$emptyMapType)
+    csn.definitions['cds.Map'] = undefined;
+
   // Get an overview about all schemas (including the services)
   const schemaNames = [ ...serviceRootNames ];
   schemaNames.push(...Object.keys(schemas));
@@ -2159,7 +2169,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
 
   function mapCdsToEdmProp( obj ) {
-    if (obj.type && isBuiltinType(obj.type) && !obj.target && !obj.targetAspect) {
+    if (edmUtils.convertMapToOpenStruct(obj, _options.odataVersion === 'v4')) {
+      return;
+    }
+    else if (obj.type && isBuiltinType(obj.type) && !obj.target && !obj.targetAspect) {
       const edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }

package/lib/edm/edmUtils.js

@@ -92,6 +92,7 @@ function isParameterizedEntity( artifact ) {
 // Return true if 'artifact' is structured (i.e. has elements, like a structured type or an entity)
 function isStructuredArtifact( artifact ) {
   // FIXME: No derived types etc yet
+  // FIXME: Don't forget cds.Map; maybe use csnUtils.isStructured()?
   return (artifact.items && artifact.items.elements || artifact.elements);
 }
 
@@ -553,8 +554,10 @@ function mapCdsToEdmType( csn, messageFunctions, isV2 = false, isMediaType = fal
     */
   }[cdsType];
   if (!edmType) {
-    error('ref-unsupported-type', location, { type: cdsType, '#': 'odata' });
-    edmType = 'Edm.PrimitiveType';
+    error('ref-unsupported-type', location,
+          { type: cdsType, version: (isV2 ? '2.0' : '4.0'), '#': 'odata' });
+    // return a version compatible type to avoid later compatibility failures
+    edmType = isV2 ? 'Edm.String' : 'Edm.PrimitiveType';
   }
 
 
@@ -873,8 +876,20 @@ function createSchemaRef( serviceRoots, targetSchemaName ) {
   }
 }
 
+// convert cds.Map without elements into empty open struct for a (type) definition
+function convertMapToOpenStruct( node, isV4 ) {
+  const typeDef = node.items || node;
+  if (node.kind && isV4 && typeDef.type === 'cds.Map' && typeDef.elements == null) {
+    typeDef.elements = Object.create(null);
+    typeDef.type = undefined;
+    assignAnnotation(node, '@open', true);
+    return true;
+  }
+  return false;
+}
 
 module.exports = {
+  convertMapToOpenStruct,
   assignAnnotation,
   assignProp,
   createSchemaRef,