@sap/cds-compiler 5.8.0 → 5.9.0

package/lib/edm/edmPreprocessor.js

@@ -23,7 +23,7 @@ const NavResAnno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
 const capabilities = Object.keys(require('../gen/Dictionary.json')
   .types['Capabilities.NavigationPropertyRestriction'].Properties)
   .filter(c => ![ 'NavigationProperty', 'Navigability' ].includes(c))
-  .map(c => `@Capabilities.${c}`);
+  .map(c => `@Capabilities.${ c }`);
 
 /**
  *  edmPreprocessor warms up the model so that it can be converted into an EDM document and
@@ -126,7 +126,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
   // sort schemas in reverse order to allow longest match in whatsMySchemaName function
   schemaNames.sort((a, b) => b.length - a.length);
   function whatsMySchemaName( n ) {
-    return schemaNames.reduce((rc, sn) => (!rc && n && n.startsWith(`${sn}.`) ? sn : rc), undefined);
+    return schemaNames.reduce((rc, sn) => (!rc && n && n.startsWith(`${ sn }.`) ? sn : rc), undefined);
   }
 
   if (schemaNames.length) {
@@ -231,7 +231,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       const p = artName.split('.');
       return p.length === 2 && p[0] === fbSchemaName;
     }))
-      fbSchemaName = `root${i++}`;
+      fbSchemaName = `root${ i++ }`;
 
 
     return [
@@ -239,7 +239,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       srootNames,
       fbSchemaName,
       // whatsMyServiceRootName
-      ( n, self = true ) => srootNames.reduce((rc, sn) => (!rc && n && n.startsWith(`${sn}.`) || (n === sn && self) ? sn : rc), undefined),
+      ( n, self = true ) => srootNames.reduce((rc, sn) => (!rc && n && n.startsWith(`${ sn }.`) || (n === sn && self) ? sn : rc), undefined),
     ];
   }
 
@@ -274,7 +274,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         // if this definition has a root def and the root def is not the service/schema name
         // => service C { type D.E }, replace the prefix dots with underscores
         if (rootDef && defName !== rootDef && rootDef !== edmUtils.getSchemaPrefix(defName)) {
-          const newDefName = `${rootDef}.${defName.replace(`${rootDef}.`, '').replace(/\./g, '_')}`;
+          const newDefName = `${ rootDef }.${ defName.replace(`${ rootDef }.`, '').replace(/\./g, '_') }`;
           // store renamed types in correlation maps for later renaming
           if (def.kind === 'entity')
             dotEntityNameMap[defName] = newDefName;
@@ -390,7 +390,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             if (!target.$sources)
               setProp(target, '$sources', Object.create(null));
 
-            target.$sources[`${struct.name}.${name}`] = element;
+            target.$sources[`${ struct.name }.${ name }`] = element;
           }
         }
         else {
@@ -506,8 +506,8 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     //             Backlink Navigation Property "Parameters" to <ViewName>Parameters
 
     // this code can be extended for aggregated views
-    const typeEntityName = `${entityName}Type`;
-    const typeEntitySetName = `${entityName}Set`;
+    const typeEntityName = `${ entityName }Type`;
+    const typeEntitySetName = `${ entityName }Set`;
     const typeToParameterAssocName = 'Parameters';
     const hasBacklink = true;
 
@@ -554,7 +554,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
   }
 
   function createParameterEntity( entityCsn, entityName, isProxy ) {
-    const parameterEntityName = `${entityName}Parameters`;
+    const parameterEntityName = `${ entityName }Parameters`;
     const parameterToTypeAssocName = 'Set';
 
     // Construct the parameter entity
@@ -902,7 +902,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
               warning('odata-unexpected-cardinality', element.$path, {
                 value: srcMult,
                 othervalue: newMult,
-                name: `${partnerCsn._parent.name}/${partnerCsn.name}`,
+                name: `${ partnerCsn._parent.name }/${ partnerCsn.name }`,
               }, 'Explicit source cardinality $(VALUE) of $(NAME) conflicts with target cardinality $(OTHERVALUE)' );
             }
           }
@@ -931,8 +931,8 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     if (options.odataXServiceRefs && options.isV4()) {
       serviceRootNames.forEach((srn) => {
         schemaNames.forEach((fqSchemaName) => {
-          if (fqSchemaName.startsWith(`${srn}.`)) {
-            const targetSchemaName = fqSchemaName.replace(`${srn}.`, '');
+          if (fqSchemaName.startsWith(`${ srn }.`)) {
+            const targetSchemaName = fqSchemaName.replace(`${ srn }.`, '');
             if (serviceRootNames.includes(targetSchemaName)) {
               // remove all definitions starting with < fqSchemaName >. and add a schema reference
               forEachKey(csn.definitions, (dn) => {
@@ -1081,7 +1081,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     }
 
     function createSchemaRefFor( targetSchemaName ) {
-      let ref = csn.definitions[`${globalSchemaPrefix}.${targetSchemaName}`];
+      let ref = csn.definitions[`${ globalSchemaPrefix }.${ targetSchemaName }`];
       if (!ref)
         ref = edmUtils.createSchemaRef(serviceRoots, targetSchemaName);
 
@@ -1101,12 +1101,12 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       // 1) construct the proxy definition
       // proxyDefinitionName: strip the serviceName and replace '.' with '_'
       const defName
-        = `${assoc._target.name.replace(`${proxySchemaName}.`, '').replace(/\./g, '_')}`;
+        = `${ assoc._target.name.replace(`${ proxySchemaName }.`, '').replace(/\./g, '_') }`;
 
       // fullName: Prepend serviceName and if in same service add '_proxy'
       const proxy = isParamProxy
-        ? createParameterEntity(assoc._target, `${proxySchemaName}.${defName}`, true)
-        : { name: `${proxySchemaName}.${defName}`, kind: 'entity', elements: Object.create(null) };
+        ? createParameterEntity(assoc._target, `${ proxySchemaName }.${ defName }`, true)
+        : { name: `${ proxySchemaName }.${ defName }`, kind: 'entity', elements: Object.create(null) };
 
       // Final proxyShortName for all further processing
       const proxyShortName = defName + (isParamProxy ? 'Parameters' : '');
@@ -1177,7 +1177,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
                 // argument proxySchemaName forces an anonymous type definition for newElt into the
                 // proxy schema. If omitted, this exposure defaults to 'root', in case API flavor
                 // of the day changes...
-                exposeStructTypeForProxyOf(newElt, `${proxy.$proxyShortName}_${newElt.name}`,
+                exposeStructTypeForProxyOf(newElt, `${ proxy.$proxyShortName }_${ newElt.name }`,
                                            proxy.$mySchemaName, newElt.key, !!(newElt.key && newElt.elements));
               }
               if (newElt.key)
@@ -1225,11 +1225,11 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             if (node.type) {
               // same as for proxies, use schema or namespace, 'root' is last resort
               typeSchemaName = typeDef.$mySchemaName || edmUtils.getSchemaPrefix(node.type);
-              typeId = node.type.replace(`${typeSchemaName}.`, '').replace(/\./g, '_');
+              typeId = node.type.replace(`${ typeSchemaName }.`, '').replace(/\./g, '_');
               // strip the service root of that type (if any)
               const myServiceRootName = whatsMyServiceRootName(typeSchemaName);
               if (myServiceRootName)
-                typeSchemaName = typeSchemaName.replace(`${myServiceRootName}.`, '');
+                typeSchemaName = typeSchemaName.replace(`${ myServiceRootName }.`, '');
             }
 
             if (edmUtils.isStructuredArtifact(typeDef)) {
@@ -1237,7 +1237,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
               // only toplevel nodes (elements) can be key
               forceToNotNull = !!(forceToNotNull && isKey && node.elements && !node.type);
 
-              typeClone = cloneStructTypeForProxy(`${typeSchemaName}.${typeId}`);
+              typeClone = cloneStructTypeForProxy(`${ typeSchemaName }.${ typeId }`);
               if (typeClone) {
                 // Recurse into elements of 'type' (if any)
                 if (typeClone.elements) {
@@ -1249,7 +1249,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
                     // TODO: expose types of assoc.keys and don't rely on exposed foreign keys
                     if (!elem['@odata.foreignKey4'] ||
                       (elem['@odata.foreignKey4'] && !typeClone.elements[elem['@odata.foreignKey4']].$exposed)) {
-                      exposeStructTypeForProxyOf(elem, `${typeId}_${elemName}`,
+                      exposeStructTypeForProxyOf(elem, `${ typeId }_${ elemName }`,
                                                  typeSchemaName, isKey, forceToNotNull);
                     }
                   });
@@ -1446,7 +1446,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       setProp(proxy, '$globalSchemaPrefix', globalSchemaPrefix);
       setProp(proxy, '$origin', element);
 
-      const fqProxyName = `${proxy.$globalSchemaPrefix}.${proxy.name}`;
+      const fqProxyName = `${ proxy.$globalSchemaPrefix }.${ proxy.name }`;
 
       if (!element._target.$cachedProxy)
         edmUtils.assignProp(element._target, '$cachedProxy', Object.create(null));
@@ -1465,8 +1465,8 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
   function mergeProxiesIntoModel() {
     proxyCache.forEach((proxy) => {
-      const fqProxyName = `${proxy.$globalSchemaPrefix}.${proxy.name}`;
-      const fqSchemaName = `${proxy.$globalSchemaPrefix}.${proxy.$mySchemaName}`;
+      const fqProxyName = `${ proxy.$globalSchemaPrefix }.${ proxy.name }`;
+      const fqSchemaName = `${ proxy.$globalSchemaPrefix }.${ proxy.$mySchemaName }`;
 
       if (proxy.kind === 'entity') {
         finalizeProxyContainments(proxy);
@@ -1478,7 +1478,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         // followed by all namespaces that are potentially exposed by the exposed types
         // don't forget to prepend the global namespace prefix
         // schemas are ordered in csn2edm.js for each service
-        forEachKey(proxy.$exposedTypes, t => schemaSet.add(`${proxy.$globalSchemaPrefix}.${edmUtils.getSchemaPrefix(t)}`));
+        forEachKey(proxy.$exposedTypes, t => schemaSet.add(`${ proxy.$globalSchemaPrefix }.${ edmUtils.getSchemaPrefix(t) }`));
         schemaSet.forEach((schemaName) => {
           if (!schemas[schemaName]) {
             schemas[schemaName] = { kind: 'schema', name: schemaName };
@@ -1491,7 +1491,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           reqDefs.definitions[fqProxyName] = proxy;
           setProp(proxy, '$path', [ 'definitions', fqProxyName ]);
           forEach(proxy.$exposedTypes, ( tn, v ) => {
-            const fqtn = `${proxy.$globalSchemaPrefix}.${tn}`;
+            const fqtn = `${ proxy.$globalSchemaPrefix }.${ tn }`;
             if (csn.definitions[fqtn] === undefined) {
               csn.definitions[fqtn] = v;
               reqDefs.definitions[fqtn] = v;
@@ -1621,7 +1621,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             if (newRefs.length) {
               keyPaths.push(...newRefs);
               // check path step key for spec violations
-              const pathSegment = `${prefix}/${eltName}`;
+              const pathSegment = `${ prefix }/${ eltName }`;
               checkKeySpecViolations(elt, location, pathSegment);
             }
             delete elt.$visited;
@@ -1646,7 +1646,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           let art = eltCsn._target || csnUtils.getCsnDef(eltCsn.target);
           for (const ps of k.ref) {
             art = art.elements[ps];
-            pathSegment += `/${art.name}`;
+            pathSegment += `/${ art.name }`;
             checkKeySpecViolations(art, location, pathSegment);
             if (art.type && !isBuiltinType(art.type))
               art = art._type || csnUtils.getCsnDef(art.type);
@@ -1844,7 +1844,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
                 // if own struct and target have a set they either are in the same $mySchemaName or not
                 // if target is in another schema, target the full qualified entity set
                 path = (elt._target.$mySchemaName === def.$mySchemaName)
-                  ? [ baseName ] : [ `${elt._target.$mySchemaName}.EntityContainer`, baseName ];
+                  ? [ baseName ] : [ `${ elt._target.$mySchemaName }.EntityContainer`, baseName ];
               }
               if (path) {
                 // if own struct and target have a set they either are in the same $mySchemaName or not
@@ -1875,7 +1875,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         }
       }
       npbs.forEach((p) => {
-        p.Path = `${prefix}/${p.Path}`;
+        p.Path = `${ prefix }/${ p.Path }`;
       });
       return npbs;
     }
@@ -2299,7 +2299,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           eltPath = absPath.slice(2).join('/');
         }
       }
-      const proxyDict = `$${scope}AnnoProxies`;
+      const proxyDict = `$${ scope }AnnoProxies`;
 
       xprANames.forEach((xprAName) => {
         isSubTreeSpan = true;
@@ -2337,7 +2337,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           }
           proxyCarrier[xprAName] = carrier[xprAName];
           carrier[xprAName] = null;
-          nxprANames.filter(an => an.startsWith(`${xprAName}.`)).forEach((nxprAName) => {
+          nxprANames.filter(an => an.startsWith(`${ xprAName }.`)).forEach((nxprAName) => {
             proxyCarrier[nxprAName] = carrier[nxprAName];
             carrier[nxprAName] = null;
           });

package/lib/edm/edmUtils.js

@@ -138,7 +138,7 @@ function resolveOnConditionAndPrepareConstraints( csn, assocCsn, messageFunction
           // Partnership is ambiguous
           setProp(originAssocCsn, '$noPartner', true);
           info('odata-unexpected-comparison', [ 'definitions', parentName, 'elements', assocCsn.name ], {
-            name: `${originParentName}:${partnerPath.join('.')}`,
+            name: `${ originParentName }:${ partnerPath.join('.') }`,
             target: originAssocCsn._target.name,
             id: '$self',
             alias: parentName,
@@ -168,12 +168,12 @@ function resolveOnConditionAndPrepareConstraints( csn, assocCsn, messageFunction
               key id : Integer;
               toMe: association to E on toMe.id = $self; };
             */
-          throw new CompilerAssertion(`Backlink association element is not an association or composition: "${originAssocCsn.name}`);
+          throw new CompilerAssertion(`Backlink association element is not an association or composition: "${ originAssocCsn.name }`);
         }
       }
       else {
         warning(null, [ 'definitions', parentName ],
-                { partner: `${assocCsn._target.name}/${partnerPath}`, name: `${parentName}/${assocCsn.name}` },
+                { partner: `${ assocCsn._target.name }/${ partnerPath }`, name: `${ parentName }/${ assocCsn.name }` },
                 'Can\'t resolve backlink to $(PARTNER) from $(NAME)');
       }
     });
@@ -476,7 +476,7 @@ function determineMultiplicity( csn ) {
 function getEffectiveTargetCardinality( csn ) {
   const rc = { min: 0, max: 1 };
   if (!csn._constraints || !csn._constraints.$finalized)
-    throw new CompilerAssertion(`_constraints missing or not finalized: "${csn.name}`);
+    throw new CompilerAssertion(`_constraints missing or not finalized: "${ csn.name }`);
   // partner (forward) cardinality has precedence
   if (csn._constraints._partnerCsn) {
     if (csn._constraints._partnerCsn.cardinality?.srcmin)
@@ -746,7 +746,7 @@ function escapeStringForText( str ) {
  */
 function encodeNonCharacters( codePoint ) {
   const hex = codePoint.toString(16).toUpperCase();
-  return `&#x${hex};`;
+  return `&#x${ hex };`;
 }
 
 // return the path prefix of a given name or if no prefix available 'root'
@@ -778,9 +778,9 @@ function mergeIntoNavPropEntry( annoPrefix, navPropEntry, prefix, props ) {
   let newEntry = false;
 
   // Filter properties with prefix and reduce them into a new dictionary
-  const o = props.filter(p => p[0].startsWith(`${annoPrefix}.`)).reduce((a, c) => {
+  const o = props.filter(p => p[0].startsWith(`${ annoPrefix }.`)).reduce((a, c) => {
     // clone the annotation value to avoid side effects with rewritten paths
-    a[c[0].replace(`${annoPrefix}.`, '')] = cloneAnnotationValue(c[1]);
+    a[c[0].replace(`${ annoPrefix }.`, '')] = cloneAnnotationValue(c[1]);
     return a;
   }, { });
 
@@ -877,7 +877,7 @@ function createSchemaRef( serviceRoots, targetSchemaName ) {
     return ( // generate one from the service's name
       last
         .replace(/Service$/, '')     // > CatalogService --> Catalog
-        .replace(/([a-z0-9])([A-Z])/g, (_, c, C) => `${c}-${C.toLowerCase()}`)  // > ODataFooBarX9 --> odata-foo-bar-x9
+        .replace(/([a-z0-9])([A-Z])/g, (_, c, C) => `${ c }-${ C.toLowerCase() }`)  // > ODataFooBarX9 --> odata-foo-bar-x9
         .replace(/_/g, '-')  // > foo_bar_baz --> foo-bar-baz
         .toLowerCase()      // > FOO --> foo
     );

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-f2ee15363af822d120947887515d2414
+226c8854e08665b3eaae3ae1a1276db7