@sap/cds-compiler 5.9.4 → 6.0.12

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,41 +1167,35 @@ 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];
-            const optional
-              = (facet.optional !== undefined)
-                ? (Array.isArray(facet.optional)
-                  ? facet.optional.includes(edmType)
-                  : facet.optional)
-                : false;
+            const optional = (facet.optional !== undefined) &&
+              (Array.isArray(facet.optional)
+                ? facet.optional.includes(edmType)
+                : facet.optional);
 
             // facet is not in attributes
             // 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.
@@ -633,17 +633,17 @@ function getEdm( options, messageFunctions ) {
       this._typeName = typeName;
       this._scalarType = undefined;
       if (this._edmAttributes[typeName] === undefined) {
-        const typecsn = csn.type ? csn : (csn.items && csn.items.type ? csn.items : csn);
+        const typeCsn = csn.items?.type ? csn.items : csn;
         // Complex/EntityType are derived from TypeBase
         // but have no type attribute in their CSN
-        if (typecsn.type) { // this thing has a type
+        if (typeCsn.type) { // this thing has a type
           // check whether this is a scalar type (or array of scalar type) or a named type
-          if (typecsn.items && typecsn.items.type &&
-            isBuiltinType(typecsn.items.type))
-            this._scalarType = typecsn.items;
+          if (typeCsn.items?.type &&
+            isBuiltinType(typeCsn.items.type))
+            this._scalarType = typeCsn.items;
 
-          else if (isBuiltinType(typecsn.type))
-            this._scalarType = typecsn;
+          else if (isBuiltinType(typeCsn.type))
+            this._scalarType = typeCsn;
 
           if (this._scalarType) {
             this._edmAttributes[typeName] = csn._edmType;
@@ -658,7 +658,7 @@ function getEdm( options, messageFunctions ) {
           }
           else {
             // it's either _edmType or type (_edmType only used for explicit binding param)
-            this._edmAttributes[typeName] = typecsn._edmType || typecsn.type;
+            this._edmAttributes[typeName] = typeCsn._edmType || typeCsn.type;
           }
         }
         // CDXCORE-245:
@@ -666,7 +666,7 @@ function getEdm( options, messageFunctions ) {
         // optionally add @odata { MaxLength, Precision, Scale, SRID }
         // but only in combination with @odata.Type
         // Allow to override type only on scalar and undefined types
-        if ((this._scalarType || typecsn.type == null) && !csn.elements) {
+        if ((this._scalarType || typeCsn.type == null) && !csn.elements) {
           const odataType = csn['@odata.Type'];
           if (odataType) {
             const td = EdmPrimitiveTypeMap[odataType];
@@ -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);
@@ -1052,15 +1053,15 @@ function getEdm( options, messageFunctions ) {
           delete this._edmAttributes.Nullable;
         }
         // we have exactly one selfReference or the default partner
-        const partner
-          = !csn.$noPartner
-            ? csn._selfReferences.length === 1
-              ? csn._selfReferences[0]
-              : csn._constraints._partnerCsn
-            : undefined;
-        if (partner && partner['@odata.navigable'] !== false && this._csn._edmParentCsn.kind !== 'type') {
-          // $abspath[0] is main entity
-          this._edmAttributes.Partner = partner.$abspath.slice(1).join('/');
+
+        if ( !csn.$noPartner) {
+          const partner = csn._selfReferences.length === 1
+            ? csn._selfReferences[0]
+            : csn._constraints._partnerCsn;
+          if (partner && partner['@odata.navigable'] !== false && this._csn._edmParentCsn.kind !== 'type') {
+            // $abspath[0] is main entity
+            this._edmAttributes.Partner = partner.$abspath.slice(1).join('/');
+          }
         }
 
         /*
@@ -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
@@ -1211,8 +1212,11 @@ function getEdm( options, messageFunctions ) {
         /* short notation for Edm.Boolean, Edm.String and Edm.Float, see internal project:
            edmx2csn-npm/edm-converters/blob/835d92a1aa6b0be25c56cef85e260c9188187429/lib/edmxV40ToJsonV40/README.md
         */
-        if (inline[0] === 'Edm.Boolean')
-          return (v === 'true' ? true : (v === 'false' ? false : v));
+        if (inline[0] === 'Edm.Boolean') {
+          if (v === 'true')
+            return true;
+          return (v === 'false') ? false : v;
+        }
         return v;
       }
 
@@ -1291,7 +1295,8 @@ function getEdm( options, messageFunctions ) {
     }
 
     getJsonFQTermName() {
-      return `@${ this._edmAttributes.Term }${ this._edmAttributes.Qualifier ? `#${ this._edmAttributes.Qualifier }` : '' }`;
+      const qualifier = this._edmAttributes.Qualifier ? `#${ this._edmAttributes.Qualifier }` : '';
+      return `@${ this._edmAttributes.Term }${ qualifier }`;
     }
   }
 
@@ -1340,7 +1345,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;

package/lib/edm/edmInboundChecks.js

@@ -117,13 +117,13 @@ function inboundQualificationChecks( csn, options, messageFunctions,
             i++;
         }
         if (i > 1) {
-          message('chained-array-of', path);
+          message('type-invalid-items', path, { '#': 'nested', prop: 'items' });
           return;
         }
 
         const itemsType = csnUtils.effectiveType(memberType.items);
         if (itemsType.items)
-          message('chained-array-of', path);
+          message('type-invalid-items', path, { '#': 'chained-service', prop: 'items' });
       }
     }