@sap/cds-compiler 5.8.2 → 5.9.2

package/lib/transform/forRelationalDB.js

@@ -167,14 +167,17 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   if(csn.meta?.[featureFlags]?.$calculatedElements)
     rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
 
+  timetrace.start('Where-Exists handling');
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
+  timetrace.stop('Where-Exists handling');
 
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
   // If errors are detected, throwWithAnyError() will return from further processing
 
+  timetrace.start('Expand Structures (expressions + refs)');
   // If this function is ever undefined, we have a bug in our logic.
   // @ts-ignore
   expandStructsInExpression(csn, { drillRef: true });
@@ -194,6 +197,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     bindCsnReference();
   }
 
+  timetrace.stop('Expand Structures (expressions + refs)');
 
   // Remove properties attached by validator - they do not "grow" as the model grows.
   applyTransformations(csn, {
@@ -211,6 +215,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   bindCsnReferenceOnly();
 
+  timetrace.start('Flattening (refs + elements)');
   // TODO: Instead of 3 separate applyTransformations, we could have each of them just return the "listeners", merge them into
   // one big listener that then gets passed into one single applyTransformations. Each listener would then have to return an array of callbacks to call.
   // With that, we could still ensure the processing order (assuming we don't run into problems with scoping).
@@ -229,6 +234,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // For to.hdbcds with naming mode hdbcds we also need to resolve the types
     flattening.resolveTypeReferences(csn, options, messageFunctions, new WeakMap(), pathDelimiter);
   }
+  timetrace.stop('Flattening (refs + elements)');
 
   // With flattening errors, it makes little sense to continue.
   throwWithAnyError();
@@ -635,6 +641,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   }
 
   function handleAssocToJoins() {
+    timetrace.start('A2J');
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
     forEachDefinition(csn, (art) => {
@@ -650,18 +657,18 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
     // restore all (non-enumerable) properties that wouldn't survive reaugmentation/compactification into the new compact model
     forEachDefinition(csn, (art, artName) => {
-      if(art['$tableConstraints']) {
+      if (art['$tableConstraints']) {
         newCsn.definitions[artName].$tableConstraints = art['$tableConstraints'];
       }
       if (art.technicalConfig)
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
-
     });
 
     // To ensure we preserve feature flags
     newCsn.meta = csn.meta;
 
     csn = newCsn;
+    timetrace.stop('A2J');
   }
 
 
@@ -768,9 +775,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
    * Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.
 
    * @param {*} node
-   * @param {*} nodeName
-   * @param {*} model
-   * @param {*} path
+   * @param {CSN.Artifact} artifact
+   * @param {CSN.Path} path
    */
   function checkTypeParameters(node, artifact, path) {
     if (node.type && !node.virtual) {

package/lib/transform/localized.js

@@ -93,6 +93,8 @@ const annoPersistenceSkip = '@cds.persistence.skip';
  * @param {boolean} [options.fewerLocalizedViews]
  *     Default: true
  *
+ * @param {boolean} [options.testMode]
+ *
  * @param {object} config
  *     Configuration for creating convenience views.  Non-user visible options.
  *

package/lib/transform/odata/adaptAnnotationRefs.js

@@ -8,20 +8,21 @@ const { transformAnnotationExpression, implicitAs, } = require('../../model/csnU
  * key declared in the scope, we replace it with referencing the foreign key itself. If a reference is a $self reference,
  * we do nothing and if a ref points to a structure/managed association, an error is thrown
  *
- * @param {Array[object]||Array[]} generatedForeignKeys 
- * @param {object} csnUtils 
- * @param {object} messageFunctions 
+ * @param {object[]|string[][]} generatedForeignKeys
+ * @param {object} csnUtils
+ * @param {object} messageFunctions
+ * @param {CSN.Path} elementPath
  */
 function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, elementPath) {
-  if(Array.isArray(generatedForeignKeys && generatedForeignKeys[0])) {
+  if(Array.isArray(generatedForeignKeys?.[0])) {
     // ensure we are always called with an array of objects. TODO: Cleanup fk creation in for.effective to create array of objects
-    adaptAnnotationsRefs(remapToArrayOfObjects(generatedForeignKeys), csnUtils, { error }, elementPath); 
+    adaptAnnotationsRefs(remapToArrayOfObjects(generatedForeignKeys), csnUtils, { error }, elementPath);
   } else {
     const reportedErrorsForAnnoPath = {};
     generatedForeignKeys.forEach((gfk, index) => {
       Object.entries(gfk.foreignKey).forEach(([key, value]) => {
         if (key[0] !== '@') return;
-  
+
         transformAnnotationExpression(gfk.foreignKey, key, {
           ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
             // if the reference is a $self reference, we do nothing,
@@ -30,8 +31,8 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
             // if annotation was not propagated from the keys array during foreign keys creation,
             // means that it is not a candidate for foreign key substitution
             if (gfk.keyAnnotations !== null && !gfk.keyAnnotations.includes(key)) return;
-  
-            const art = gfk.originalKey._art || 
+
+            const art = gfk.originalKey._art ||
             csnUtils.inspectRef(elementPath ? path : getOriginatingKeyPath(gfk, path)).art; // OData uses getOriginatingKeyPath - as it relies on $path
             if (csnUtils.isManagedAssociation(art)) {
               if (!reportedErrorsForAnnoPath[path]) {
@@ -42,7 +43,7 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
               const gfkForRef = findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref);
               if (gfkForRef.length === 1) {
                 ref[0] = gfkForRef[0].prefix;
-  
+
                 if (ctx?.annoExpr?.['=']) {
                   ctx.annoExpr['='] = true;
                 }

package/lib/transform/parseExpr.js

@@ -12,7 +12,7 @@
  * Multiplication/Division:    '*', '/'
  * Addition/Subtraction:       '+', '-'
  * Concatenation:              '||'
- * Relational:                 '=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in', 'exists', 'between and'
+ * Relational:                 '=', '<>', '>', '>=', '<', '<=', '==', '!=', 'like', 'in', 'exists', 'between and'
  * Unary:                      'is [not] null', 'not'
  * Conditional:                'case [when then]+ [else]? end', 'and', 'or'
  *
@@ -245,7 +245,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
       }
     }
     return binaryExpr(xpr, (xpr, s, e) => {
-      const token = ['=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in'];
+      const token = ['=', '<>', '>', '>=', '<', '<=', '==', '!=', 'like', 'in'];
       while(s < e && !token.includes(xpr[s])) s++;
       if(s < e) {
         if(xpr[s-1] === 'not' && (xpr[s] === 'in' || xpr[s] === 'like'))

package/lib/transform/transformUtils.js

@@ -16,7 +16,7 @@ const { cloneCsnNonDict, cloneCsnDict } = require('../model/cloneCsn');
 const { addTenantFieldToArt } = require('./addTenantFields');
 
 const RestrictedOperators = ['<', '>', '>=', '<='];
-const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
+const RelationalOperators = ['=', '<>', '==', '!=', 'is' /*, 'like'*/,...RestrictedOperators];
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
 // 'model' is compacted new style CSN
@@ -196,7 +196,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         '@odata.Collation': 1,
         '@odata.Unicode': 1,
       } : {};
-      
+
       copyAnnotations(elem, flatElem, false, excludes);
 
       // Copy selected type properties
@@ -220,15 +220,15 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    *  [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
    *  [ (Entity), (struct1_struct2_assoc), (elem) ]
    *
-   * @param {string[]} ref
+   * @param {CSN.Ref} ref
    * @param {CSN.Path} path CSN path to the ref
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
    * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
-   * @param {bool} [suspend] suspend flattening by caller until association path step
-   * @param {int} [suspendPos] suspend if starting pos is lower or equal to suspendPos and suspend is true
-   * @param {bool} [revokeAtSuspendPos] revoke suspension after suspendPos (binding parameter path use case)
-   * @param {bool} [flattenParameters] Whether to flatten references into structured parameters. OData flattens parameters, SQL/for.effective does not.
+   * @param {boolean} [suspend] suspend flattening by caller until association path step
+   * @param {number} [suspendPos] suspend if starting pos is lower or equal to suspendPos and suspend is true
+   * @param {boolean} [revokeAtSuspendPos] revoke suspension after suspendPos (binding parameter path use case)
+   * @param {boolean} [flattenParameters] Whether to flatten references into structured parameters. OData flattens parameters, SQL/for.effective does not.
    *
    * @todo: Refactor to take config object instead of N boolean arguments.
    * @returns [string[], bool]
@@ -1028,6 +1028,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       Flattening stops on all non-structured types.
     */
     function expand(expr, location) {
+      if (!Array.isArray(expr))
+        return expr; // don't traverse strings, etc.
       const rc = [];
       for(let i = 0; i < expr.length; i++)
       {

package/lib/transform/translateAssocsToJoins.js

@@ -25,7 +25,6 @@ function translateAssocsToJoinsCSN(csn, options){
   timetrace.start('A2J: Translating associations to joins');
   translateAssocsToJoins(model, options);
   timetrace.stop('A2J: Translating associations to joins');
-  timetrace.start('A2J: Post-processing columns');
   // Use the effective elements list as columns
   forEachDefinition(model, art => {
     if (art.$queries) {
@@ -40,7 +39,6 @@ function translateAssocsToJoinsCSN(csn, options){
       }
     }
   });
-  timetrace.stop('A2J: Post-processing columns');
 
   if (options.messages) {
     // Make sure that we don't complain twice about the same things

package/lib/transform/universalCsn/coreComputed.js

@@ -81,7 +81,7 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
       const origin = getOrigin(element);
       if (origin)
         return origin;
-      throw new CompilerAssertion(`Could not find ancestor for ${JSON.stringify(element)} named ${name}`);
+      throw new CompilerAssertion(`Could not find ancestor for ${ JSON.stringify(element) } named ${ name }`);
     }
 
     /**
@@ -114,7 +114,7 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
         return checkJoinSources(base.args, name);
       }
 
-      throw new CompilerAssertion(`Element “${name}” not found in: ${JSON.stringify(base)}`);
+      throw new CompilerAssertion(`Element “${ name }” not found in: ${ JSON.stringify(base) }`);
     }
 
     /**

package/lib/utils/moduleResolve.js

@@ -567,9 +567,9 @@ function packageCdsMain( pkg ) {
  * @param {object} dep
  * @param {string} realpath
  * @param {string} nativeRealpath
- * @param {Function} warning
+ * @param {object} messageFunctions
  */
-function checkFileCase( dep, realpath, nativeRealpath, { warning } ) {
+function checkFileCase( dep, realpath, nativeRealpath, messageFunctions ) {
   if (realpath === nativeRealpath)
     return;
   if (realpath.toLowerCase() !== nativeRealpath.toLowerCase()) {
@@ -578,6 +578,7 @@ function checkFileCase( dep, realpath, nativeRealpath, { warning } ) {
     return;
   }
   for (const using of dep.usingFroms) {
+    const { warning } = messageFunctions;
     warning('file-unexpected-case-mismatch', [ using.location, using ], {},
             // eslint-disable-next-line @stylistic/js/max-len
             'The imported filename differs on the filesystem; ensure that capitalization matches the actual file\'s name');
@@ -589,9 +590,10 @@ function checkFileCase( dep, realpath, nativeRealpath, { warning } ) {
  * @property {string[]} lookupDirs
  *     Directories to look in for modules, e.g. node_modules/.
  * @property {string[]} extensions
- * @property {(path: string, callback: (err, foundAndIsFile) => void) => void} isFile
- * @property {(path: string, encoding, callback: (err, content) => void) => void} readFile
- * @property {(path: string, callback: (err, realpath) => void) => void} realpath
+ * @property {(path: string, callback: (err, foundAndIsFile: boolean) => void) => void} isFile
+ * @property {(path: string, encoding: string, callback:
+ *              (err, content: string) => void) => void} readFile
+ * @property {(path: string, callback: (err, realpath: string) => void) => void} realpath
  *   used to read `package.json` files.
  */
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.8.2",
+  "version": "5.9.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",

package/share/messages/def-upcoming-virtual-change.md

@@ -0,0 +1,55 @@
+# def-upcoming-virtual-change
+
+The behavior of `@sap/cds-compiler` v6 will change for a selected element.
+
+## Example
+
+Erroneous code example:
+
+```cds
+entity Source {
+  key ID : String;
+  a : String;
+};
+
+entity Proj as projection on Source {
+  ID,
+  virtual a, // ❌ behavior will change in v6
+};
+```
+
+In `@sap/cds-compiler` v5 and earlier, element `Proj:a` is a reference
+to element `Source:a`, which was marked virtual.
+
+In `@sap/cds-compiler` v6 and later, it will instead of a _new_ element,
+without any reference to `Source:a`.
+
+This may or may not affect your runtime coding, hence the warning.
+
+
+## How to Fix
+
+If the v6 behavior works for you, there is nothing you need to do.
+
+However, if you want to keep a reference to `Source:a` in CSN, for example
+because you use the reference at runtime, then you can keep the old behavior
+by either:
+
+1. prepending a table alias to the reference
+2. adding a column alias
+
+```cds
+// (1) prepend a table alias
+entity V as projection on E {
+  ID,
+  virtual E.a, // ok
+};
+```
+
+```cds
+// (2) add an alias
+entity V as projection on E {
+  ID,
+  virtual a as a, // ok
+};
+```

package/share/messages/file-unexpected-case-mismatch.md

@@ -0,0 +1,61 @@
+# file-unexpected-case-mismatch
+
+The filename of a `using` statement does not match
+the file's actual name on disk.
+
+To avoid operating-system dependent issues, the compiler checks if the name of
+an imported file matches the name of the file in the filesystem / on disk.
+For example, by default macOS uses a case-insensitive file system.
+Hence, a file named `model.cds` will also be loaded by `using from './Model.cds'`
+on such systems.
+
+However, on other filesystems that are case-sensitive, e.g. when building your
+application in another environment, the file will not be found.
+
+Hence, the `using` statement needs to be adapted.
+
+## Example
+
+Erroneous code example:
+
+```cds
+// index.cds
+using from './Model';
+```
+
+using following directory tree:
+
+```
+├── index.cds
+└── model.cds
+```
+
+On case-insensitive systems, the file can be loaded, but the compiler will warn
+about the mismatch.
+On case-sensitive file systems, compilation will fail, as the imported file
+can't be found.
+
+While in this case, compilation will fail on case-sensitive systems, it could
+instead end up with semantic changes, too.
+Given the same `index.cds`, but a different directory tree:
+
+```
+├── index.cds
+├── Model
+│   └── index.cds
+└── model.cds
+```
+
+On case-sensitive systems, `./Model/index.cds` will be loaded.
+On case-insensitive systems, however, `model.cds` will be loaded,
+as the compiler first tries to load `Model.cds`, before looking for
+`Model/index.cds`.
+
+
+## How to Fix
+
+Adapt the filename in your `using` statement.
+
+If you have both `model.cds` and `Model/index.cds`, but don't want to use
+a `.cds` suffix, use `using from './Model/'`, i.e. add a trailing slash to
+indicate that you want to load from the folder `Model`.

package/share/messages/message-explanations.json

@@ -6,8 +6,10 @@
     "check-proper-type-of",
     "def-duplicate-autoexposed",
     "def-missing-type",
+    "def-upcoming-virtual-change",
     "extend-repeated-intralayer",
     "extend-unrelated-layer",
+    "file-unexpected-case-mismatch",
     "redirected-to-ambiguous",
     "redirected-to-complex",
     "redirected-to-unrelated",

package/lib/transform/braceExpression.js

@@ -1,77 +0,0 @@
-// Currently unused, but may become useful again if HDBCDS -> HDBTABLE
-// handover becomes more prominent.  Historically used with the no longer
-// existent option `--compatibility`.
-// If necessary, more complex expressions could be parsed with parseExpr.js
-// and then stringified with parentheses again.
-
-'use strict';
-
-function isAlreadyBraced(expression, start, end){
-  return start - 1 > -1 &&
-    end + 1 < expression.length &&
-    expression[start-1] === '(' &&
-    expression[end+1] === ')';
-}
-
-function binarycomparison(expression, token, index){
-  if(!isAlreadyBraced(expression, index-1, index+1)){
-    expression.splice(index+2 > expression.length ? expression.length : index +2 ,0,')');
-    expression.splice(index-1 > -1 ? index - 1 : 0,0,'(');
-  }
-
-  return index + 3;
-}
-
-function between(expression, token, index){
-  let start = index-1, end = index+4;
-  if(expression[index-1] === 'not'){
-    start -= 1;
-  }
-
-  if(!isAlreadyBraced(expression, start, end)){
-    expression.splice(end > expression.length ? expression.length : end ,0,')');
-    expression.splice(start > -1 ? start : 0,0,'(');
-  }
-
-  return index + 4;
-}
-
-function like(expression, token, index){
-  let start = index-1, end = index+2;
-  if(expression[index-1] === 'not'){
-    start -= 1;
-  }
-
-  if(!isAlreadyBraced(expression, start, end)){
-    expression.splice(end > expression.length ? expression.length : end ,0,')');
-    expression.splice(start > -1 ? start : 0,0,'(');
-  }
-
-  return index + 3;
-}
-
-const bracers = {
-  '=' : binarycomparison,
-  '>' : binarycomparison,
-  '<' : binarycomparison,
-  '>=': binarycomparison,
-  '<=': binarycomparison,
-  '!=': binarycomparison,
-  'between': between,
-  'like': like
-}
-
-function braceExpression(expr){
-  for(let i = 0; i < expr.length; i++){
-    const token = expr[i];
-    if(token && token.xpr){
-      token.xpr = braceExpression(token.xpr);
-    }
-    if(bracers[token]){
-      i = bracers[token](expr, token, i);
-    }
-  }
-
-  return expr;
-}
-module.exports = braceExpression;