@sap/cds-compiler 3.9.2 → 4.0.0

package/lib/render/utils/common.js

@@ -139,6 +139,7 @@ function getParentContextName( csn, artifactName ) {
  *
  * Context A.B will be created by addIntermediateContexts
  *
+ * @param {CSN.Model} csn
  * @param {Function[]} killList Array to add cleanup functions to
  */
 function addContextMarkers( csn, killList ) {
@@ -171,7 +172,7 @@ function addContextMarkers( csn, killList ) {
   *
   * A and A.B.C.D -> A.B and A.B.C are possible candidates
   *
-  *
+  * @param {CSN.Model} csn
   * @param {string} parentName Name of the parent context
   * @param {string} artifactName Name of the current context
   * @returns {string[]} All possible context names inbetween
@@ -311,6 +312,25 @@ const cdsToHdbcdsTypes = {
   'cds.Int64': 'cds.Integer64',
 };
 
+/**
+ * Default lengths for CDS types.
+ */
+const sqlDefaultLengths = {
+  hana: {
+    'cds.String': 5000,
+  },
+  default: {
+    'cds.String': 255,
+    'cds.Binary': 5000,
+  },
+};
+
+function getDefaultTypeLengths( sqlDialect ) {
+  if (!sqlDefaultLengths[sqlDialect])
+    return sqlDefaultLengths.default;
+  return { ...sqlDefaultLengths.default, ...sqlDefaultLengths[sqlDialect] };
+}
+
 /**
  * Get the element matching the column
  *
@@ -467,9 +487,10 @@ function withoutCast( xpr ) {
  * (no trailing LF, don't indent if inline)
  *
  * @param {ExpressionConfiguration} rendererBase
+ * @param {boolean} [adaptPath] If true, `env.path` will be adapted for lists and subExpr.
  * @returns {ExpressionRenderer} Expression rendering utility
  */
-function createExpressionRenderer( rendererBase ) {
+function createExpressionRenderer( rendererBase, adaptPath = false ) {
   const renderer = Object.create(rendererBase);
   renderer.visitExpr = visitExpr;
   /**
@@ -484,6 +505,7 @@ function createExpressionRenderer( rendererBase ) {
     // are nested.  This information is used for adding parentheses around
     // expressions (see `this.xpr()`).
     renderObj.isNestedXpr = false;
+    renderObj.adaptPath = adaptPath;
     return renderObj.visitExpr(x);
   };
   /**
@@ -495,6 +517,7 @@ function createExpressionRenderer( rendererBase ) {
     const renderObj = Object.create(renderer);
     renderObj.env = env || this?.env;
     renderObj.isNestedXpr = true;
+    renderObj.adaptPath = adaptPath;
     return renderObj.visitExpr(x);
   };
 
@@ -519,7 +542,14 @@ function visitExpr( x ) {
     // Compound expression, e.g. for on- or where-conditions.
     // If xpr is part of an array, it's always a nested xpr,
     // e.g. CSN for `(1=1 or 2=2) and 3=3`.
-    const tokens = x.map(item => this.renderSubExpr(item));
+    const tokens = x.map((item, i) => {
+      if (this.adaptPath) {
+      // We want to keep the prototype of the original env.
+        const env = Object.assign(Object.create(Object.getPrototypeOf(this.env || {})), this.env, { path: [ ...this.env.path, i ] });
+        return this.renderSubExpr(item, env);
+      }
+      return this.renderSubExpr(item);
+    });
     return beautifyExprArray(tokens);
   }
   else if (typeof x !== 'object' || x === null) {
@@ -531,7 +561,14 @@ function visitExpr( x ) {
   }
   else if (x.list) {
     // Render as non-nested expr.
-    return `(${x.list.map(item => this.renderExpr(item)).join(', ')})`;
+    return `(${x.list.map((item, i) => {
+      if (this.adaptPath) {
+      // We want to keep the prototype of the original env.
+        const env = Object.assign(Object.create(Object.getPrototypeOf(this.env || {})), this.env, { path: [ ...this.env.path, 'list', i ] });
+        return this.renderExpr(item, env);
+      }
+      return this.renderExpr(item);
+    }).join(', ')})`;
   }
   else if (x.val !== undefined) {
     return this.val(x);
@@ -581,4 +618,5 @@ module.exports = {
   funcWithoutParen,
   getSqlSnippets,
   withoutCast,
+  getDefaultTypeLengths,
 };

package/lib/render/utils/delta.js

@@ -24,7 +24,7 @@ class DeltaRenderer {
     // TODO: May also include 'RENAME' at a later stage
     const alterEnv = this.scopedFunctions.activateAlterMode(env);
     const elements = Object.entries(elementsObj)
-      .map(([ name, elt ]) => this.scopedFunctions.renderElement(artifactName, name, elt, duplicateChecker, null, alterEnv))
+      .map(([ name, elt ]) => this.scopedFunctions.renderElement(name, elt, duplicateChecker, null, alterEnv))
       .filter(s => s !== '');
 
     if (elements.length)

package/lib/render/utils/sql.js

@@ -42,7 +42,7 @@ function renderReferentialConstraint( constraint, indent, toUpperCase, csn, opti
     const onDeleteRemark = constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : '';
 
     // omit 'RESTRICT' action for ON UPDATE / ON DELETE, because it interferes with deferred constraint check
-    if (sqlDialect === 'sqlite') {
+    if (sqlDialect === 'sqlite' || sqlDialect === 'postgres') {
       if (constraint.onDelete === 'CASCADE' )
         result += `${indent}ON DELETE ${constraint.onDelete}${onDeleteRemark}\n`;
     }
@@ -57,8 +57,8 @@ function renderReferentialConstraint( constraint, indent, toUpperCase, csn, opti
     result += `${indent}${!constraint.validated ? 'NOT ' : ''}VALIDATED\n`;
     result += `${indent}${!constraint.enforced ? 'NOT ' : ''}ENFORCED\n`;
   }
-  // for sqlite, the DEFERRABLE keyword is required
-  result += `${indent}${sqlDialect === 'sqlite' ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
+  // for sqlite and postgreSQL, the DEFERRABLE keyword is required
+  result += `${indent}${sqlDialect === 'sqlite' || sqlDialect === 'postgres' ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
   return result;
 }
 

package/lib/transform/braceExpression.js

@@ -22,7 +22,7 @@ function binarycomparison(expression, token, index){
   return index + 3;
 }
 
-function beetween(expression, token, index){
+function between(expression, token, index){
   let start = index-1, end = index+4;
   if(expression[index-1] === 'not'){
     start -= 1;
@@ -57,7 +57,7 @@ const bracers = {
   '>=': binarycomparison,
   '<=': binarycomparison,
   '!=': binarycomparison,
-  'between': beetween,
+  'between': between,
   'like': like
 }
 

package/lib/transform/db/.eslintrc.json

@@ -1,7 +1,7 @@
 {
   "root": true,
   "plugins": ["sonarjs", "jsdoc"],
-  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
+  "extends": ["plugin:jsdoc/recommended", "../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
   "rules": {
     "prefer-const": "error",
     "quotes": ["error", "single", "avoid-escape"],

package/lib/transform/db/applyTransformations.js

@@ -60,7 +60,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
         !{}.propertyIsEnumerable.call( _parent, _prop ) ||
         (typeof _prop === 'string' && _prop.startsWith('@')) ||
         (options.skipIgnore && node._ignore) ||
-        (options.skipStandard && options.skipStandard[_prop])
+        options.skipStandard?.[_prop]
     )
       return;
 
@@ -137,17 +137,17 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     csnPath.push( _prop );
     _path.forEach( ( s, i ) => {
       if (s && typeof s === 'object') {
-        csnPath.push( i );
         if (options.drillRef) {
           standard(_path, i, s);
         }
         else {
+          csnPath.push( i );
           if (s.args)
             standard( s, 'args', s.args );
           if (s.where)
             standard( s, 'where', s.where );
+          csnPath.pop();
         }
-        csnPath.pop();
       }
     } );
     csnPath.pop();

package/lib/transform/db/associations.js

@@ -118,7 +118,10 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter ) {
    * Loop over all elements and for all unmanaged associations translate
    * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
    *
-   * Or in other words: Allow using the foreign keys of managed associations in on-conditions
+   * Or in other words: Allow using the foreign keys of managed associations in
+   * on-conditions / calculated elements on-write.
+   *
+   * Expects that flattening has already been performed.
    *
    * @param {CSN.Artifact} artifact Artifact to check
    * @param {string} artifactName Name of the artifact
@@ -130,6 +133,7 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter ) {
         if (ref.length > 1) {
           const { links } = inspectRef(path);
           if (links) {
+            let fkAlias = '';
             // eslint-disable-next-line for-direction
             for (let i = links.length - 1; i >= 0; i--) {
               const link = links[i];
@@ -137,19 +141,25 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter ) {
               if (link.art && link.art.target && link.art.keys &&
                     // Doesn't work when ref-target (filter condition) or similar is used
                     !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
-                // We join the managed assoc with everything following it
-                const sourceElementName = ref.slice(i).join(pathDelimiter);
-                const source = findSource(links, i - 1) || artifact;
-                // allow specifying managed assoc on the source side
-                const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
-                if (fks && fks.length >= 1) {
-                  const fk = fks[0];
-                  const managedAssocStepName = refOwner.ref[i];
-                  const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
-                  if (source && source.elements[fkName])
-                    refOwner.ref = [ ...ref.slice(0, i), fkName ];
+                const fkRef = ref[i + 1];
+                const fkName = (!fkAlias ? fkRef : `${fkRef}${pathDelimiter}${fkAlias}`);
+                const fks = link.art.keys.filter(key => key.ref[0] === fkName);
+
+                if (fks.length >= 1) { // after flattening, at most one FK will remain.
+                  // `.as` is set for SQL, but not for OData -> fall back to implicit alias
+                  fkAlias = fks[0].as || fks[0].ref[fks[0].ref.length - 1];
+                  const source = findSource(links, i - 1) || artifact;
+                  const managedAssocStepName = ref[i];
+                  const newFkName = `${managedAssocStepName}${pathDelimiter}${fkAlias}`;
+                  if (source?.elements[newFkName])
+                    refOwner.ref = [ ...ref.slice(0, i), newFkName ];
                 }
               }
+              else {
+                fkAlias = '';
+                // Ignore last path step and unmanaged associations.
+                // Structures should have been already flattened.
+              }
             }
           }
         }
@@ -160,6 +170,8 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter ) {
       // The association is an unmanaged one
       if (!elem.keys && elem.target && elem.on)
         applyTransformationsOnNonDictionary(elem, 'on', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+      else if (elem.value?.stored)
+        applyTransformationsOnNonDictionary(elem, 'value', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
     }
 
     if (artifact.query || artifact.projection) {

package/lib/transform/db/expansion.js

@@ -59,14 +59,14 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
 
   /**
    * Turn .expand/.inline into normal refs. @cds.persistence.skip .expand with to-many (and all transitive views).
-   * For such skipped things, error for usage of assoc pointing to them and and ignore publishing of assoc pointing to them.
+   * For such skipped things, error for usage of assoc pointing to them and ignore publishing of assoc pointing to them.
    */
   function rewriteExpandInline() {
     let cleanup = [];
     let _dependents;
 
     const entity = findAnEntity();
-    const toDummyfy = [];
+    const toDummify = [];
 
     applyTransformations(csn, {
       columns: (parent, name, columns, path) => {
@@ -110,7 +110,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
     if (options.transformation !== 'odata') {
       applyTransformations(csn, {
         target: (parent, name, target, path) => {
-          if (toDummyfy.indexOf(target) !== -1) {
+          if (toDummify.indexOf(target) !== -1) {
             publishing.push({
               parent, name, target, path: [ ...path ],
             });
@@ -161,7 +161,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
 
           const pathStep = obj.ref[j].id ? obj.ref[j].id : obj.ref[j];
           const target = art.target ? art.target : pathStep;
-          if (toDummyfy.indexOf(target) !== -1) {
+          if (toDummify.indexOf(target) !== -1) {
             error( null, obj.$path, {
               id: pathStep, elemref: obj, name,
             }, 'Unexpected “@cds.persistence.skip” annotation on Association target $(NAME) of $(ID) in path $(ELEMREF) was skipped because of .expand in conjunction with to-many');
@@ -174,7 +174,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           if (art) {
             const pathStep = obj.ref[obj.ref.length - 1].id ? obj.ref[obj.ref.length - 1].id : obj.ref[obj.ref.length - 1];
             const target = art.target ? art.target : pathStep;
-            if (toDummyfy.indexOf(target) !== -1)
+            if (toDummify.indexOf(target) !== -1)
               kill.push(i);
           }
         }
@@ -221,7 +221,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
             stack.push([ dependent, dependentName ]);
           });
         }
-        toDummyfy.push(n);
+        toDummify.push(n);
       }
     }
 
@@ -229,7 +229,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
      * Replace the artifacts in `toDummify` with simple dummy views as produced by createDummyView.
      */
     function dummyfy() {
-      for (const artifactName of [ ...new Set(toDummyfy) ])
+      for (const artifactName of [ ...new Set(toDummify) ])
         csn.definitions[artifactName] = createDummyView(entity);
     }
 
@@ -366,7 +366,8 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         }
         else { // preserve stuff like .cast for redirection
           const thing = base[currentAlias[currentAlias.length - 1]];
-          if (current?._art?.value || thing?.value)
+          const value = current?._art?.value || thing?.value;
+          if (value && !value.stored)
             error('query-unsupported-calc', current.$path || col.$path, { '#': 'inside' });
           expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
         }
@@ -396,7 +397,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
      * With a .cast.on  or .on in a .expand/.inline, we need to change the references,
      * since we change the overall scope of things (by "heaving" them up into "normal refs").
      *
-     * So anything that does not have a $self/$projection infron get's the so-far-traveled alias,
+     * So anything that does not have a $self/$projection infront gets the so-far-traveled alias,
      * since after the transformation it will basically be in "top-level".
      *
      * @param {object} parent
@@ -529,7 +530,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
       if (col.ref && col.$scope !== '$magic') {
         const _art = col._art || inspectRef(path.concat(i)).art;
         if (_art && isStructured(_art))
-          newThing.push(...expandRef(_art, col.ref, col.as, col.key || false, withAlias));
+          newThing.push(...expandRef(_art, col, withAlias));
 
         else
           newThing.push(col);
@@ -552,16 +553,14 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
    * Iterative, to not run into stack overflow.
    *
    * @param {CSN.Element} art
-   * @param {Array} ref
-   * @param {Array} alias
-   * @param {boolean} isKey True if the ref obj has property key: true
+   * @param {object} root Column, ref in order by, etc.
    * @param {boolean} withAlias
    * @returns {Array}
    */
-  function expandRef( art, ref, alias, isKey, withAlias ) {
+  function expandRef( art, root, withAlias ) {
     const expanded = [];
     /** @type {Array<[CSN.Element, any[], any[]]>} */
-    const stack = [ [ art, ref, [ alias || ref[ref.length - 1] ] ] ];
+    const stack = [ [ art, root.ref, [ root.as || implicitAs(root.ref) ] ] ];
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
       if (isStructured(current)) {
@@ -569,16 +568,16 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           stack.push([ e, currentRef.concat(n), currentAlias.concat(n) ]);
       }
       else {
-        const obj = { ref: currentRef };
+        const obj = { ...root, ...{ ref: currentRef } };
         if (withAlias) {
           const newAlias = currentAlias.join(pathDelimiter);
           // if (alias !== undefined) // explicit alias
           obj.as = newAlias;
           // alias was implicit - to later distinguish expanded s -> s.a from explicitly written s.a
-          if (alias === undefined)
+          if (root.as === undefined)
             setProp(obj, '$implicitAlias', true);
         }
-        if (isKey)
+        if (root.key)
           obj.key = true;
         expanded.push(obj);
       }

package/lib/transform/db/flattening.js

@@ -90,38 +90,31 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
         return;
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
         toFinalBaseType(parent, resolved, true);
+
+        if (parent.items) // items could have unresolved types
+          toFinalBaseType(parent.items, resolved, true);
+
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
-        if (parent.elements) {
-          const stack = [ parent.elements ];
+        let nextElements = parent.elements || parent.items?.elements;
+        if (nextElements) {
+          const stack = [ nextElements ];
           while (stack.length > 0) {
             const elements = stack.pop();
             for (const e of Object.values(elements)) {
               if (e.type && !isBuiltinType(e.type))
                 toFinalBaseType(e, resolved, true);
-
-              if (e.elements)
-                stack.push(e.elements);
+              nextElements = e.elements || e.items?.elements;
+              if (nextElements)
+                stack.push(nextElements);
             }
           }
         }
+
         const directLocalized = parent.localized || false;
         if (!directLocalized && !options.toOdata)
           removeLocalized(parent);
       }
-      // HANA/SQLite do not support array-of - turn into CLOB/Text
-      if (parent.items && !options.toOdata) {
-        parent.type = 'cds.LargeString';
-        delete parent.items;
-      }
-    },
-    // HANA/SQLite do not support array-of - turn into CLOB/Text
-    items: (parent) => {
-      // OData has no LargeString substitution and doesn't expand types under items
-      if (!options.toOdata) {
-        parent.type = 'cds.LargeString';
-        delete parent.items;
-      }
     },
   }, [ (definitions, artifactName, artifact) => {
     // Replace events, actions and functions with simple dummies - they don't have effect on forRelationalDB stuff
@@ -520,7 +513,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
           setProp(assoc.keys[i], inferredAlias, true);
           if (!(options.toOdata && assoc.keys[i].ref.length === 1))
           // In OData backend there are no aliases assigned when the same as the ref
-          // TODO: remove the if after the new flattening in OData has been compleated
+          // TODO: remove the if after the new flattening in OData has been completed
             assoc.keys[i].as = assoc.keys[i].ref[assoc.keys[i].ref.length - 1];
           collector.push(assoc.keys[i]);
         }
@@ -699,13 +692,16 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
     }
     else {
       // unwind a derived type chain to a scalar type
-      while (finalElement.type && !isBuiltinType(finalElement.type)) {
+      while (finalElement?.type && !isBuiltinType(finalElement?.type)) {
         finalTypeName = finalElement.type;
         finalElement = csn.definitions[finalElement.type];
       }
     }
   }
 
+  if (!finalElement)
+    return [];
+
   if (finalElement.target && !finalElement.on) {
     const hasKeys = !!finalElement.keys;
     if (!hasKeys) {
@@ -741,7 +737,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
     });
   }
   // we have reached a leaf element, create a foreign key
-  else if (finalElement && (finalElement.type == null || isBuiltinType(finalElement.type))) {
+  else if (finalElement.type == null || isBuiltinType(finalElement.type)) {
     const newFk = Object.create(null);
     for (const prop of [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type' ]) {
       // copy props from original element to preserve derived types!