@sap/cds-compiler 5.9.4 → 6.0.10

package/lib/edm/annotations/edmJson.js

@@ -83,7 +83,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     });
     delete parent[op];
   };
-  const noOp = () => (true);
+  const noOp = () => {};
   //----------------------------------
   // Create the transformer dictionary
   const transform = {
@@ -96,7 +96,6 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     isNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is null'),
     isNotNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is not null'),
     exists: notADynExpr,
-    '#': notADynExpr,
     SELECT: notADynExpr,
     SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
     like: notADynExpr,
@@ -312,8 +311,16 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     else
       parentparent[parentprop] = xpr;
   };
+  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentprop, txt) => {
+    if (parent['#'] && parent.val) // enum reference that was resolved by the compiler
+      delete parent['#'];
+    else
+      notADynExpr(parent, prop, xpr, csnPath, parentParent, parentprop, txt);
+  };
   transform.ref = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
-    if (xpr.some(ps => ps.args || ps.where)) {
+    // until empty filter syntax is introduced for the annotation expressions,
+    // we ignore the filters in order to generate EDMX
+    if (xpr.some(ps => ps.args/* || ps.where */)) {
       error('odata-anno-xpr-ref', location, {
         anno, elemref: parent, '#': 'args',
       });
@@ -492,12 +499,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
           const td = EdmPrimitiveTypeMap[typeDef];
           if (td) {
             if (td.v2 !== options.isV2() && td.v4 !== options.isV4()) {
-              message('odata-spec-violation-type', location,
+              message('odata-unexpected-edm-type', location,
                       {
                         anno,
                         type: typeDef,
                         version: (options.isV4() ? '4.0' : '2.0'),
-                        '#': 'incompatible_anno',
+                        '#': 'anno',
                       });
             }
             evalArgs(td, typeFacets, typeDef);
@@ -516,13 +523,13 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                 const facetArgs = typeFacets.filter(arg => arg.func === facetName || arg.func === `$${ facetName }`);
 
                 if (facetArgs.length === 0 && !optional && (options.isV2() === facetDef.v2 || options.isV4() === facetDef.v4)) {
-                  message('odata-spec-violation-type', location,
+                  message('odata-unexpected-edm-facet', location,
                           {
                             anno,
                             type: typeDef,
                             name: facetName,
                             version: (options.isV4() ? '4.0' : '2.0'),
-                            '#': 'facet_anno',
+                            '#': 'anno',
                           });
                 }
                 else if (facetArgs.length > 1) {
@@ -566,14 +573,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                 const precision = Number.parseInt(parent.$Precision, 10);
                 const scale = Number.parseInt(parent.$Scale, 10);
                 if (!Number.isNaN(precision) && !Number.isNaN(scale) && scale > precision) {
-                  message('odata-spec-violation-type', location,
-                          {
-                            anno,
-                            type: typeDef,
-                            number: scale,
-                            rawvalue: precision,
-                            '#': 'scale_anno',
-                          });
+                  message('odata-invalid-scale', location, {
+                    '#': 'anno',
+                    anno,
+                    number: scale,
+                    rawvalue: precision,
+                  });
                 }
               }
               if (options.isV2() && parent.$Scale === 'variable') {

package/lib/edm/annotations/genericTranslation.js

@@ -852,14 +852,13 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
       termNameWithoutQualifiers.split('.').forEach((id) => {
         if (!edmUtils.isODataSimpleIdentifier(id))
-          message('odata-spec-violation-id', msg.location, { id });
+          message('odata-invalid-name', msg.location, { id });
       });
       newAnno = new Edm.Annotation(v, termNameWithoutQualifiers);
       if (qualifier?.length) {
-        if (!edmUtils.isODataSimpleIdentifier(qualifier)) {
-          message('odata-spec-violation-id', msg.location,
-                  { id: qualifier, '#': 'qualifier' });
-        }
+        if (!edmUtils.isODataSimpleIdentifier(qualifier))
+          message('odata-invalid-qualifier', msg.location, { id: qualifier });
+
         newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
         newAnno.setEdmAttribute('Qualifier', qualifier);
       }
@@ -1428,7 +1427,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       //   in a record or term
       if (Array.isArray(value)) {
         message('odata-anno-value', msg.location,
-                { anno: msg.anno(), '#': 'nestedcollection' });
+                { anno: msg.anno(), '#': 'nestedCollection' });
       }
       else if (value && typeof value === 'object') {
         if (value['=']) {
@@ -1439,7 +1438,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         }
         else if (value['#']) {
           message('odata-anno-value', msg.location,
-                  { anno: msg.anno(), '#': 'enumincollection' });
+                  { anno: msg.anno(), '#': 'enuminCollection' });
         }
         else if (value.$edmJson) {
           newCollection.append(handleEdmJson(value.$edmJson, msg));
@@ -1774,7 +1773,7 @@ function mergeOdataVocabularies( options, message ) {
             defOk = false;
           }
           else if (name === 'Alias' && !edmUtils.isODataSimpleIdentifier(def[name])) {
-            message('odata-spec-violation-id', null, { id: name, value: def[name], '#': 'vocRefAlias' });
+            message('odata-invalid-vocabulary-alias', null, { id: name, value: def[name] });
             defOk = false;
           }
         });

package/lib/edm/csn2edm.js

@@ -79,7 +79,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
   const mergedVocabularies = translate.mergeOdataVocabularies(options, message);
 
-  const Edm = getEdm(options, messageFunctions);
+  const Edm = getEdm(options);
 
   const { v } = options;
   if (Object.keys(allServices).length === 0) {
@@ -304,14 +304,13 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
         const usages = UsedTypes[typeName].filter(u => !u.$NameClashReported);
         if (usages.length > 0 && def && !def.$isRendered && def['@cds.external']) {
-          message('odata-spec-violation-type', usages[0].$location,
+          message('odata-invalid-external-type', usages[0].$location,
                   {
                     type: typeName,
                     anno: '@cds.external',
                     name: serviceCsn.name,
                     code: def.elements ? 'Edm.ComplexType' : 'Edm.TypeDefinition',
                     version: options.isV4() ? '4.0' : '2.0',
-                    '#': 'external',
                   });
         }
       }
@@ -407,14 +406,14 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
       const reservedNames = [ 'Edm', 'odata', 'System', 'Transient' ];
       const loc = [ 'definitions', schema.name ];
       if (reservedNames.includes(schema.name))
-        message('odata-spec-violation-namespace', loc, { names: reservedNames });
+        message('odata-invalid-service-name', loc, { names: reservedNames });
       if (schema.name.length > 511) {
-        message('odata-spec-violation-namespace', loc, { '#': 'length' });
+        message('odata-invalid-service-name', loc, { '#': 'length' });
       }
       else {
         schema.name.split('.').forEach((id) => {
           if (!edmUtils.isODataSimpleIdentifier(id))
-            message('odata-spec-violation-id', loc, { id });
+            message('odata-invalid-name', loc, { id });
         });
       }
 
@@ -523,29 +522,31 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         // this especially covers: 'items: composition of one { data : String; }'
         // "keyless" composition targets in structured containment mode
         else if (entityCsn.$hasEntitySet && entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
-          message('odata-spec-violation-no-key', location);
+          message('odata-missing-key', location);
 
         if (!edmUtils.isODataSimpleIdentifier(EntityTypeName))
-          message('odata-spec-violation-id', location, { id: EntityTypeName });
+          message('odata-invalid-name', location, { id: EntityTypeName });
 
         properties.forEach((p) => {
           const pLoc = [ ...location, 'elements', p._edmAttributes.Name ];
           edmTypeCompatibilityCheck(p, pLoc);
           if (p._edmAttributes.Name === EntityTypeName)
-            message('odata-spec-violation-property-name', pLoc, { meta: entityCsn.kind });
+            message('odata-invalid-property-name', pLoc, { meta: entityCsn.kind });
 
           if (options.isV2() && p.$isCollection && !p._csn.target)
-            message('odata-spec-violation-array', pLoc, { version: '2.0' });
+            message('odata-unexpected-array', pLoc, { version: '2.0' });
 
           if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name)) {
-            message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
+            message('odata-invalid-name', pLoc, { id: p._edmAttributes.Name });
           }
           else if (options.isV2() && /^(_|\d)/.test(p._edmAttributes.Name)) {
             // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
-            message('odata-spec-violation-id', pLoc,
-                    {
-                      prop: p._edmAttributes.Name[0], id: p._edmAttributes.Name, version: '2.0', '#': 'v2firstChar',
-                    });
+            message('odata-invalid-name', pLoc, {
+              '#': 'v2firstChar',
+              prop: p._edmAttributes.Name[0],
+              id: p._edmAttributes.Name,
+              version: '2.0',
+            });
           }
         });
 
@@ -603,23 +604,23 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         const location = [ 'definitions', structuredTypeCsn.name ];
 
         if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', location, { id: attributes.Name });
+          message('odata-invalid-name', location, { id: attributes.Name });
 
         properties.forEach((p) => {
           const pLoc = [ ...location, ...(structuredTypeCsn.items ? [ 'items', 'elements' ] : [ 'elements' ]), p._edmAttributes.Name ];
           edmTypeCompatibilityCheck(p, pLoc);
           if (p._edmAttributes.Name === complexType._edmAttributes.Name)
-            message('odata-spec-violation-property-name', pLoc, { meta: structuredTypeCsn.kind });
+            message('odata-invalid-property-name', pLoc, { meta: structuredTypeCsn.kind });
 
           if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
-            message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
+            message('odata-invalid-name', pLoc, { id: p._edmAttributes.Name });
 
           if (options.isV2()) {
             if (p.$isCollection && !p._csn.target)
-              message('odata-spec-violation-array', pLoc, { version: '2.0' });
+              message('odata-unexpected-array', pLoc, { version: '2.0' });
 
             if (p._csn.target)
-              message('odata-spec-violation-assoc', pLoc, { version: '2.0' });
+              message('odata-unexpected-assoc', pLoc, { version: '2.0' });
           }
         });
 
@@ -713,7 +714,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         // derived types are already resolved to base types
         const attributes = { Name: typeCsn.name.replace(schemaNamePrefix, '') };
         if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', typeCsn.$path, { id: attributes.Name });
+          message('odata-invalid-name', typeCsn.$path, { id: attributes.Name });
 
         const typeDef = new Edm.TypeDefinition(v, attributes, typeCsn );
         edmTypeCompatibilityCheck(typeDef, typeCsn.$path);
@@ -732,7 +733,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
 
         if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', location, { id: attributes.Name });
+          message('odata-invalid-name', location, { id: attributes.Name });
 
         if (!iAmAnAction)
           attributes.IsComposable = false;
@@ -766,7 +767,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
                 setProp(firstParam, '_edmType', bpType);
             }
             if (!edmUtils.isODataSimpleIdentifier(bpName))
-              message('odata-spec-violation-id', [ ...location, 'params', bpName ], { id: bpName });
+              message('odata-invalid-name', [ ...location, 'params', bpName ], { id: bpName });
           }
         }
 
@@ -795,7 +796,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           }
 
           if (!edmUtils.isODataSimpleIdentifier(bpName))
-            message('odata-spec-violation-id', bpnAnnoLoc, { id: bpName });
+            message('odata-invalid-name', bpnAnnoLoc, { id: bpName });
           if (actionCsn.params && actionCsn.params[bpName])
             error('duplicate-definition', bpnAnnoLoc, { '#': 'param', name: bpName });
         }
@@ -839,7 +840,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
             const pLoc = [ ...location, 'params', p._edmAttributes.Name ];
             if (!edmUtils.isODataSimpleIdentifier(parameterName))
-              message('odata-spec-violation-id', pLoc, { id: parameterName });
+              message('odata-invalid-name', pLoc, { id: parameterName });
             collectUsedType(parameterCsn);
             edmTypeCompatibilityCheck(p, pLoc);
             actionNode.append(p);
@@ -880,7 +881,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           : [ 'definitions', actionCsn.name ];
 
         if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', location, { id: attributes.Name });
+          message('odata-invalid-name', location, { id: attributes.Name });
 
         const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
         if (rt) { // add EntitySet attribute only if return type is an entity
@@ -936,17 +937,17 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
               collectUsedType(parameterCsn);
               edmTypeCompatibilityCheck(param, pLoc);
               if (!edmUtils.isODataSimpleIdentifier(parameterName))
-                message('odata-spec-violation-id', pLoc, { id: parameterName });
+                message('odata-invalid-name', pLoc, { id: parameterName });
 
               // only scalar or structured type in V2 (not entity)
               if (param._type &&
-            !param._type.startsWith('Edm.') &&
-            csn.definitions[param._type] &&
-            !edmUtils.isStructuredType(csn.definitions[param._type]))
-                message('odata-spec-violation-param', pLoc, { version: '2.0' });
+                  !param._type.startsWith('Edm.') &&
+                  csn.definitions[param._type] &&
+                  !edmUtils.isStructuredType(csn.definitions[param._type]))
+                message('odata-invalid-param-type', pLoc, { version: '2.0' });
 
               if (param.$isCollection)
-                message('odata-spec-violation-array', pLoc, { version: '2.0' });
+                message('odata-unexpected-array', pLoc, { version: '2.0' });
 
               functionImport.append(param);
             }
@@ -966,27 +967,26 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             if (type) {
               collectUsedType(action.returns);
               if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
-                message('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
+                message('odata-invalid-return-type', returnsLoc, { kind: action.kind, version: '2.0' });
               }
               else if (isBuiltinType(type)) {
                 type = edmUtils.mapCdsToEdmType(returns, messageFunctions, _options);
                 if (type) {
                   const td = EdmPrimitiveTypeMap[type];
                   if (td && !td.v2) {
-                    message('odata-spec-violation-type', returnsLoc,
-                            { type, version: '2.0', '#': 'incompatible' });
+                    message('odata-unexpected-edm-type', returnsLoc,
+                            { type, version: '2.0' });
                   }
                 }
                 else {
-                  message('odata-spec-violation-type-unknown', returnsLoc, { type });
+                  message('odata-unknown-edm-type', returnsLoc, { type });
                 }
               }
               if (action.returns.$isCollection)
                 type = `Collection(${ type })`;
             }
             else {
-              // type is missing
-              message('odata-spec-violation-type', returnsLoc);
+              message('odata-missing-type', returnsLoc);
             }
           }
           return type;
@@ -1159,7 +1159,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
     function edmTypeCompatibilityCheck( p, pLoc ) {
       const edmType = p._type;
       if (!edmType) {
-        message('odata-spec-violation-type', pLoc);
+        message('odata-missing-type', pLoc);
       }
       else if (p._scalarType) {
         const td = EdmPrimitiveTypeMap[edmType];
@@ -1167,8 +1167,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           // The renderer/type mapper doesn't/shouldn't produce incompatible types and facets.
           // Only the unknown type warning may be triggered by an unknown @odata.Type override.
           if (td.v2 !== p.v2 && td.v4 !== p.v4) {
-            message('odata-spec-violation-type', pLoc,
-                    { type: edmType, version: (p.v4 ? '4.0' : '2.0'), '#': 'incompatible' });
+            message('odata-unexpected-edm-type', pLoc,
+                    { type: edmType, version: (p.v4 ? '4.0' : '2.0') });
           }
           EdmTypeFacetNames.forEach((name) => {
             const facet = EdmTypeFacetMap[name];
@@ -1183,25 +1183,21 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             // facet is member of type definition and mandatory
             // node and facet version match
             if (!p._edmAttributes[name] && td[name] && !optional && (p.v2 === facet.v2 || p.v4 === facet.v4)) {
-              message('odata-spec-violation-type', pLoc,
-                      {
-                        type: edmType, name, version: (p.v4 ? '4.0' : '2.0'), '#': 'facet',
-                      });
+              message('odata-unexpected-edm-facet', pLoc,
+                      { type: edmType, name, version: (p.v4 ? '4.0' : '2.0') });
             }
           });
           if (edmType === 'Edm.Decimal') {
             const precision = Number.parseInt(p._edmAttributes.Precision, 10);
             const scale = Number.parseInt(p._edmAttributes.Scale, 10);
             if (!Number.isNaN(precision) && !Number.isNaN(scale) && scale > precision) {
-              message('odata-spec-violation-type', pLoc,
-                      {
-                        type: edmType, number: scale, rawvalue: precision, '#': 'scale',
-                      });
+              message('odata-invalid-scale', pLoc,
+                      { number: scale, rawvalue: precision });
             }
           }
         }
         else {
-          message('odata-spec-violation-type-unknown', pLoc, { type: edmType });
+          message('odata-unknown-edm-type', pLoc, { type: edmType });
         }
       }
     }

package/lib/edm/edm.js

@@ -8,9 +8,9 @@ const {
   EdmTypeFacetNames,
   EdmPrimitiveTypeMap,
 } = require('./EdmPrimitiveTypeDefinitions.js');
+const { CompilerAssertion } = require('../base/error');
 
-function getEdm( options, messageFunctions ) {
-  const { error } = messageFunctions || { error: () => true, warning: () => true };
+function getEdm( options ) {
   class Node {
     /**
      * @param {boolean[]} version Versions in the form of [<v2>, <v4>].
@@ -19,11 +19,11 @@ function getEdm( options, messageFunctions ) {
      */
     constructor(version, attributes = Object.create(null), csn = undefined) {
       if (!attributes || typeof attributes !== 'object')
-        error(null, 'Debug me: attributes must be a dictionary');
+        throw new CompilerAssertion('Debug me: attributes must be a dictionary');
       if (!Array.isArray(version))
-        error(null, `Debug me: v is either undefined or not an array: ${ version }`);
+        throw new CompilerAssertion(`Debug me: v is either undefined or not an array: ${ version }`);
       if (version.filter(v => v).length !== 1)
-        error(null, 'Debug me: exactly one version must be set');
+        throw new CompilerAssertion('Debug me: exactly one version must be set');
 
       // Common attributes of JSON and XML.
       // Note: Can't assign attributes directly, due to the input object being modified.
@@ -741,6 +741,7 @@ function getEdm( options, messageFunctions ) {
         this._edmAttributes.OpenType = true;
     }
   }
+
   class EntityType extends ComplexType {
     constructor(version, details, properties, csn) {
       super(version, details, csn);
@@ -1142,7 +1143,7 @@ function getEdm( options, messageFunctions ) {
             json.$OnDelete = c._edmAttributes.Action;
             break;
           default:
-            error(null, `Debug me: Unhandled NavProp child: ${ c.kind }`);
+            throw new CompilerAssertion(`Debug me: Unhandled NavProp child: ${ c.kind }`);
         }
       });
       // TODO Annotations
@@ -1340,7 +1341,7 @@ function getEdm( options, messageFunctions ) {
             break;
           }
           default:
-            error(null, `Pease debug me: Unhandled Record child: ${ c.kind }`);
+            throw new CompilerAssertion(`Debug me: Unhandled Record child: ${ c.kind }`);
         }
       });
       return json;