@sap/cds-compiler 5.4.4 → 5.5.2

package/lib/transform/forRelationalDB.js

@@ -17,7 +17,7 @@ const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../tran
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { createDict, forEach } = require('../utils/objectUtils');
-const handleExists = require('./db/transformExists');
+const handleExists = require('./db/assocsToQueries/transformExists');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('./db/rewriteCalculatedElements');
 const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
@@ -32,7 +32,7 @@ const temporal = require('./db/temporal');
 const associations = require('./db/associations');
 const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
-const { featureFlags } = require('./db/featureFlags');
+const { featureFlags } = require('./featureFlags');
 const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
 const { processSqlServices } = require('./db/processSqlServices');
 
@@ -126,7 +126,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   /** @type {object} */
   let csnUtils;
   /** @type {object} */
-  let message, error, warning; // message functions
+  let error; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
   // transformUtils
@@ -156,7 +156,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   timetrace.start('Validate');
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
-  const cleanup = validate.forRelationalDB(csn, {
+  validate.forRelationalDB(csn, {
     ...messageFunctions, csnUtils, ...csnUtils, csn, options, isAspect
   });
   timetrace.stop('Validate');
@@ -194,8 +194,20 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     bindCsnReference();
   }
 
+
   // Remove properties attached by validator - they do not "grow" as the model grows.
-  cleanup();
+  applyTransformations(csn, {
+    _art: killProp,
+    _links: killProp,
+    _element: killProp,
+    _column: killProp,
+    _from: killProp,
+    _type: killProp,
+    _target: killProp,
+    $env: killProp,
+    $path: killProp,
+    $scope: killProp,
+  });
 
   bindCsnReferenceOnly();
 
@@ -305,21 +317,14 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   else
     addLocalizationViews(csn, options);
 
-  !doA2J && forEachDefinition(csn, (definition, artName, prop, path) => {
-    if (definition.query && isPersistedOnDatabase(definition)) {
-      // reject managed association and structure publishing for to-hdbcds.hdbcds
-      const that = { csnUtils, options, error };
-      rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
-    }
-  });
-
   forEachDefinition(csn, [
-    // For generating DB stuff:
-    // - table-entity with parameters: not allowed
-    // - view with parameters: ok on HANA, not allowed otherwise
-    // (don't complain about action/function with parameters)
-    handleChecksForWithParameters,
-    checkAssocsWithParams,
+    (definition, artName, prop, path) => {
+      if (!doA2J && definition.query && isPersistedOnDatabase(definition)) {
+        // reject managed association and structure publishing for to-hdbcds.hdbcds
+        const that = { csnUtils, options, error };
+        rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
+      }
+    },
     // (170) Transform '$self' in backlink associations to appropriate key comparisons
     // Must happen before draft processing because the artificial ON-conditions in generated
     // draft shadow entities have crooked '_artifact' links, confusing the backlink processing.
@@ -355,25 +360,39 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions);
   forEachDefinition(csn, transformViews);
 
-  const checkConstraintIdentifiers = (artifact, artifactName, prop, path) => {
-    assertConstraintIdentifierUniqueness(artifact, artifactName, path, error);
-  };
 
-  // TODO: Could we maybe merge this with the final applyTransformations?
-  forEachDefinition(csn, [
-    /* assert that there will be no conflicting unique- and foreign key constraint identifiers */
-    checkConstraintIdentifiers,
-    /* Check Type Parameters (precision, scale, length ...) */
-    checkTypeParameters,
-    // (200) Strip 'key' property from type elements
-    removeKeyPropInType,
-  ]);
+  if(!doA2J) {
+    forEachDefinition(csn, [
+      // (200) Strip 'key' property from type elements
+      removeKeyPropInType,
+      (artifact, artifactName) => {
+        if(artifact.kind === 'type') {
+          forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
+            // Check type parameters (length, precision, scale ...)
+            if (!member.$ignore) {
+              if (member.type)
+                checkTypeParameters(member, artifact, path);
+              if (member.items?.type)
+                checkTypeParameters(member.items, artifact, path.concat([ 'items' ]));
+            }
+          }, [ 'definitions', artifactName ]);
+        }
+      }
+    ]);
+  }
 
   // TODO: Might have to do this earlier if we want special rendering for projections?
   const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && csn.meta?.[featureFlags]?.$sqlService ? processSqlServices(csn): () => {}
 
   // TODO: Could we maybe merge this with the final applyTransformations?
   applyTransformations(csn, {
+    type: (parent, prop, type, path) => {
+      checkTypeParameters(parent, csn.definitions[path[1]], path);
+    },
+    $tableConstraints: (parent, prop, tableConstraints, path) => {
+      /* assert that there will be no conflicting unique- and foreign key constraint identifiers */
+      assertConstraintIdentifierUniqueness(parent, path[1], path, error);
+    },
     elements: (parent, prop, elements, path) => {
       // Attach @cds.persistence.name to elements, replace enums by their base value
       const artifact = csn.definitions[path[1]];
@@ -485,7 +504,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   function bindCsnReference(){
     messageFunctions.setModel(csn);
-    ({ error, warning, message, throwWithAnyError } = messageFunctions);
+    ({ error, throwWithAnyError } = messageFunctions);
 
     ({ flattenStructuredElement,
       flattenStructStepsInRef,
@@ -614,79 +633,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   }
 
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function checkAssocsWithParams(artifact, artifactName) {
-    if(options.transformation === 'hdbcds') {
-      forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
-        // Report an error on
-        // - view with parameters that has an element of type association/composition
-        // - association that points to entity with parameters
-        if (member.target && csnUtils.isAssocOrComposition(member)) {
-          if (artifact.params) {
-            // HANA does not allow 'WITH ASSOCIATIONS' on something with parameters:
-            // SAP DBTech JDBC: [7]: feature not supported: parameterized sql view cannot support association: line 1 col 1 (at pos 0)
-            message('def-unexpected-paramview-assoc', path, { '#': 'source' });
-          }
-          else if(artifact['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
-            // UDF/CVs w/o params don't support 'WITH ASSOCIATIONS'
-            const anno = artifact['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
-            message('def-unexpected-calcview-assoc', path, { '#': 'source', anno });
-          }
-          if (csn.definitions[member.target].params) {
-            // HANA does not allow association targets with parameters or to UDFs/CVs w/o parameters:
-            // SAP DBTech JDBC: [7]: feature not supported: cannot support create association to a parameterized view
-            message('def-unexpected-paramview-assoc', path, { '#': 'target' });
-          }
-          else if(csn.definitions[member.target]['@cds.persistence.udf'] || csn.definitions[member.target]['@cds.persistence.calcview']) {
-            // HANA won't check the assoc target but when querying an association with target UDF, this is the error:
-            // SAP DBTech JDBC: [259]: invalid table name: target object SYSTEM.UDF does not exist: line 3 col 6 (at pos 43)
-            // CREATE TABLE F (id INTEGER NOT NULL);
-            // CREATE FUNCTION UDF RETURNS TABLE (ID INTEGER) LANGUAGE SQLSCRIPT SQL SECURITY DEFINER AS BEGIN RETURN SELECT ID FROM F; END;
-            // CREATE TABLE Y (  id INTEGER NOT NULL,  toUDF_id INTEGER) WITH ASSOCIATIONS (MANY TO ONE JOIN UDF AS toUDF ON (toUDF.id = toUDF_id));
-            // CREATE VIEW U AS SELECT  id, toUDF.a FROM Y;
-            const anno = csn.definitions[member.target]['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
-            message('def-unexpected-calcview-assoc', path, { '#': 'target', anno });
-          }
-        }
-      }, [ 'definitions', artifactName ]);
-    }
-
-  }
-
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function handleChecksForWithParameters(artifact, artifactName) {
-    if (!artifact.$ignore && artifact.params && (artifact.kind === 'entity')) {
-      if (!artifact.query) { // table entity with params
-        // Allow with plain
-        error(null, [ 'definitions', artifactName ], { '#': options.toSql ? 'sql' : 'std' }, {
-          std: 'Table-like entities with parameters are not supported for conversion to SAP HANA CDS',
-          sql: 'Table-like entities with parameters are not supported for conversion to SQL',
-        });
-      }
-      else if (options.sqlDialect === 'sqlite') { // view with params
-        // Allow with plain
-        error(null, [ 'definitions', artifactName ], 'SQLite does not support entities with parameters');
-      }
-      else {
-        for (const pname in artifact.params) {
-          if (pname.match(/\W/g) || pname.match(/^\d/) || pname.match(/^_/)) { // parameter name must be regular SQL identifier
-            warning(null, [ 'definitions', artifactName, 'params', pname ], 'Expecting regular SQL-Identifier');
-          }
-          else if (options.sqlMapping !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
-            warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.sqlMapping },
-                   'Expecting parameter to be uppercase in naming mode $(NAME)');
-          }
-        }
-      }
-    }
-  }
-
   function handleAssocToJoins() {
     // 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
@@ -806,105 +752,92 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   }
 
-
-
-
   /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   * @todo can we do this earlier? Together with another forEachMemberRecursively?
+   * 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 
    */
-  function checkTypeParameters(artifact, artifactName) {
-    forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
-      // Check type parameters (length, precision, scale ...)
-      if (!member.$ignore) {
-        if (member.type)
-          _check(member, memberName, csn, path);
-        if (member.items?.type)
-          _check(member.items, memberName, csn, path.concat([ 'items' ]));
-      }
-    }, [ 'definitions', artifactName ]);
-
-    // Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.
-    function _check(node, nodeName, model, path) {
-      if (node.type && !node.virtual) {
-        const absolute = node.type;
-        switch (absolute) {
-          case 'cds.String':
-          case 'cds.Binary':
-          case 'cds.hana.VARCHAR': {
-            checkTypeParamValue(node, 'length', { min: 1, max: 5000 }, path);
-            break;
-          }
-          case 'cds.Decimal': {
-            // Don't check with "plain"?
-            if (node.precision || node.scale) {
-              checkTypeParamValue(node, 'precision', { max: 38 }, path);
-              checkTypeParamValue(node, 'scale', { max: node.precision }, path);
-            }
-            break;
+  function checkTypeParameters(node, artifact, path) {
+    if (node.type && !node.virtual) {
+      const absolute = node.type;
+      switch (absolute) {
+        case 'cds.String':
+        case 'cds.Binary':
+        case 'cds.hana.VARCHAR': {
+          checkTypeParamValue(node, 'length', { min: 1, max: 5000 }, path);
+          break;
+        }
+        case 'cds.Decimal': {
+          // Don't check with "plain"?
+          if (node.precision || node.scale) {
+            checkTypeParamValue(node, 'precision', { max: 38 }, path);
+            checkTypeParamValue(node, 'scale', { max: node.precision }, path);
           }
+          break;
+        }
 
-          case 'cds.hana.BINARY':
-          case 'cds.hana.NCHAR':
-          case 'cds.hana.CHAR': {
-            checkTypeParamValue(node, 'length', { min: 1, max: 2000 }, path);
-            break;
-          }
-          case 'cds.hana.ST_POINT':
-          case 'cds.hana.ST_GEOMETRY': {
-            checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
-            break;
-          }
-          case 'cds.Map': {
-            if (options.sqlDialect === 'plain')
-              error('ref-unsupported-type', path, { '#': 'dialect', type: node.type, value: 'plain' });
-            else if (options.transformation === 'hdbcds')
-              error('ref-unsupported-type', path, {'#': 'hdbcds', type: node.type, value: options.sqlDialect });
-            break;
+        case 'cds.hana.BINARY':
+        case 'cds.hana.NCHAR':
+        case 'cds.hana.CHAR': {
+          checkTypeParamValue(node, 'length', { min: 1, max: 2000 }, path);
+          break;
+        }
+        case 'cds.hana.ST_POINT':
+        case 'cds.hana.ST_GEOMETRY': {
+          checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
+          break;
+        }
+        case 'cds.Map': {
+          if (options.sqlDialect === 'plain')
+            error('ref-unsupported-type', path, { '#': 'dialect', type: node.type, value: 'plain' });
+          else if (options.transformation === 'hdbcds')
+            error('ref-unsupported-type', path, {'#': 'hdbcds', type: node.type, value: options.sqlDialect });
+          break;
+        }
+        case 'cds.Vector': {
+          if (options.sqlDialect !== 'hana') {
+            error('ref-unsupported-type', path, {
+              '#': 'hana', type: node.type, value: 'hana',
+              othervalue: options.sqlDialect
+            });
           }
-          case 'cds.Vector': {
-            if (options.sqlDialect !== 'hana') {
-              error('ref-unsupported-type', path, {
-                '#': 'hana', type: node.type, value: 'hana',
-                othervalue: options.sqlDialect
-              });
-            }
-            else if (options.transformation === 'hdbcds') {
-              error('ref-unsupported-type', path, {
-                '#': 'hdbcds', type: node.type, value: options.sqlDialect
-              });
-            }
-            break;
+          else if (options.transformation === 'hdbcds') {
+            error('ref-unsupported-type', path, {
+              '#': 'hdbcds', type: node.type, value: options.sqlDialect
+            });
           }
+          break;
         }
       }
+    }
 
-      // Check that the value of the type property `paramName` (e.g. length, precision, scale ...) is of `expectedType`
-      // (which can currently only be 'positiveInteger') and (optional) the value is in a given range
-      function checkTypeParamValue(node, paramName, range = null, path = null) {
-        const paramValue = node[paramName];
-        if (paramValue == null) {
-          if(options.toSql || artifact.query || !['cds.Binary','cds.hana.BINARY', 'cds.hana.NCHAR','cds.hana.CHAR'].includes(node.type)) {
-            return true;
-          } else {
-            return error('type-missing-argument', path, { name: paramName, id: node.type, $reviewed: false });
-          }
+    // Check that the value of the type property `paramName` (e.g. length, precision, scale ...) is of `expectedType`
+    // (which can currently only be 'positiveInteger') and (optional) the value is in a given range
+    function checkTypeParamValue(node, paramName, range = null, path = null) {
+      const paramValue = node[paramName];
+      if (paramValue == null) {
+        if(options.toSql || artifact.query || !['cds.Binary','cds.hana.BINARY', 'cds.hana.NCHAR','cds.hana.CHAR'].includes(node.type)) {
+          return true;
+        } else {
+          return error('type-missing-argument', path, { name: paramName, id: node.type, $reviewed: false });
         }
-        if (range) {
-          if (isMaxParameterLengthRestricted(node.type) && range.max && paramValue > range.max) {
-            error('type-unexpected-argument', path,
-              { '#': 'max', prop: paramName, type: node.type, number: range.max, $reviewed: false });
-            return false;
-          }
-          if (range.min && paramValue < range.min) {
-            error('type-unexpected-argument', path,
-              { '#': 'min', prop: paramName, type: node.type, number: range.min, $reviewed: false });
-            return false;
-          }
+      }
+      if (range) {
+        if (isMaxParameterLengthRestricted(node.type) && range.max && paramValue > range.max) {
+          error('type-unexpected-argument', path,
+            { '#': 'max', prop: paramName, type: node.type, number: range.max, $reviewed: false });
+          return false;
+        }
+        if (range.min && paramValue < range.min) {
+          error('type-unexpected-argument', path,
+            { '#': 'min', prop: paramName, type: node.type, number: range.min, $reviewed: false });
+          return false;
         }
-        return true;
       }
+      return true;
     }
   }
 

package/lib/transform/transformUtils.js

@@ -39,7 +39,6 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     resolvePath,
     flattenPath,
     addDefaultTypeFacets,
-    createForeignKeyElement,
     getForeignKeyArtifact,
     flattenStructuredElement,
     flattenStructStepsInRef,
@@ -153,56 +152,6 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     return [ foreignKeyElementName, createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName) ];
   }
 
-  // (1) Create an artificial foreign key element for association 'assoc' (possibly part
-  // of nested struct, i.e. containing dots) in 'artifact', using foreign key info
-  // from 'foreignKey'.
-  // (2) Inserting it into 'elements' of 'artifact'.
-  // (3) Add a property '$generatedFieldName' to the corresponding 'foreignKey' of the assoc.
-  //
-  // Note that this must happen after struct flattening(flattenStructuredElement) - both fot elements and foreign keys.
-  // Return the newly generated foreign key element.
-  function createForeignKeyElement(assoc, assocName, foreignKey, artifact, artifactName, path) {
-    const result = {};
-
-    // FIXME: Duplicate code (postfix is added herein, can this be optimized?)
-    // Assemble foreign key element name from assoc name, '_' and foreign key name/alias
-    const foreignKeyElementName = `${assocName.replace(/\./g, pathDelimiter)}${pathDelimiter}${foreignKey.as || foreignKey.ref.join(pathDelimiter)}`;
-
-
-    const fkArtifact = inspectRef(path).art;
-    newForeignKey(fkArtifact, foreignKeyElementName);
-
-    function processAssociationOrComposition(fkArtifact,foreignKeyElementName) {
-      fkArtifact.keys.forEach(iKey => {
-        const iKeyArtifact = inspectRef(iKey.$path).art;
-        if(iKey.ref.length>1)
-          throw new CompilerAssertion(`createForeignKeyElement(${artifactName},${assocName},${iKey.$path.join('/')}) unexpected reference: `+ iKey.ref)
-        newForeignKey(iKeyArtifact,foreignKeyElementName+'_'+iKey.ref[0])
-      })
-    }
-
-    // compose new foreign key out of 'fkArtifact' named 'foreignKeyElementName'
-    function newForeignKey(fkArtifact, foreignKeyElementName) {
-      if (fkArtifact.type === 'cds.Association' || fkArtifact.type === 'cds.Composition') {
-        processAssociationOrComposition(fkArtifact, foreignKeyElementName)
-        return;
-      }
-
-      const foreignKeyElement = createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName);
-
-      // FIXME: must this code go into createRealFK?
-      // Not present in getForeignKeyArtifact
-      if (artifact.items) // proceed to items of such
-        artifact = artifact.items;
-
-      // Insert artificial element into artifact, with all cross-links
-      artifact.elements[foreignKeyElementName] = foreignKeyElement;
-
-      result[foreignKeyElementName] = foreignKeyElement;
-    } // function newForeignKey
-    return result;
-  }
-
   // For a structured element 'elem', return a dictionary of flattened elements to
   // replace it, flattening names with pathDelimiter's value and propagating all annotations and the
   // type properties 'key', 'notNull', 'virtual', 'masked' to the flattened elements.

package/lib/utils/objectUtils.js

@@ -83,6 +83,18 @@ function setHidden( obj, prop, val ) {
   } );
 }
 
+/**
+ * Check if the given object has the property as non-enumerable
+ *
+ * @param {Object} object
+ * @param {string} propertyName
+ * @returns {boolean}
+ */
+function hasNonEnumerable( object, propertyName ) {
+  return Object.prototype.hasOwnProperty.call( object, propertyName ) &&
+    !Object.prototype.propertyIsEnumerable.call( object, propertyName );
+}
+
 module.exports = {
   copyPropIfExist,
   createDict,
@@ -90,4 +102,5 @@ module.exports = {
   forEachValue,
   forEachKey,
   setHidden,
+  hasNonEnumerable,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.4.4",
+  "version": "5.5.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -15,7 +15,7 @@
   "types": "lib/main.d.ts",
   "scripts": {
     "download": "node scripts/downloadANTLR.js",
-    "gen": "node ./scripts/build.js && node scripts/genGrammarChecksum.js && node ./redepage/bin/redepage --pretty --compile lib/gen/CdlParser.js --copy-base-parser lib/parsers/CdlGrammar.g4",
+    "gen": "node ./scripts/build.js && node scripts/genGrammarChecksum.js && node ./redepage/bin/redepage --compile lib/gen/CdlParser.js --copy-base-parser lib/parsers/CdlGrammar.g4",
     "xmakeAfterInstall": "npm run gen",
     "xmakePrepareRelease": "echo \"$(node scripts/stripReadme.js README.md)\" > README.md && node scripts/assertSnapshotVersioning.js && node scripts/assertChangelog.js && node scripts/cleanup.js --remove-dev",
     "test": "npm run test:piper",

package/lib/transform/db/featureFlags.js

@@ -1,5 +0,0 @@
-'use strict';
-
-const featureFlags = Symbol.for('Feature flags forRelationalDb');
-
-module.exports = { featureFlags };