@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/transform/draft/db.js

@@ -5,7 +5,7 @@ const {
   getResultingName, forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
-const { getTransformers } = require('../transformUtilsNew');
+const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const draftAnnotation = '@odata.draft.enabled';
 const booleanBuiltin = 'cds.Boolean';
@@ -124,16 +124,18 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
         error(null, path, 'Expecting element to have a type when used in a draft-enabled artifact');
       if (elt.key && elt.key === true && !elt.virtual)
         keys.push(elt);
-    }, [ 'definitions', artifactName ], true, { elementsOnly: true });
+    }, [ 'definitions', artifactName ], false, { elementsOnly: true });
 
     // In contrast to EDM, the DB entity may have more than one technical keys but should have ideally exactly one key of type cds.UUID
-    if (keys.length !== 1)
-      warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have exactly one key element');
-
-    const uuidCount = keys.reduce((acc, k) => ((k.type === 'cds.String' && k.$renamed === 'cds.UUID' && k.length === 36) ? acc + 1 : acc), 0);
-    if (uuidCount === 0)
-      warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have one key element of type “cds.UUID”');
-
+    if (keys.length !== 1) {
+      warning(null, [ 'definitions', artifactName ], { count: keys.length },
+              'Entity annotated with “@odata.draft.enabled” should have exactly one key element, but found $(COUNT)');
+    }
+    else {
+      const uuidCount = keys.reduce((acc, k) => ((k.type === 'cds.String' && k.$renamed === 'cds.UUID' && k.length === 36) ? acc + 1 : acc), 0);
+      if (uuidCount === 0)
+        warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have one key element of type “cds.UUID”');
+    }
 
     // Ignore boolean return value. We know that we're inside a service or else we wouldn't have reached this code.
     const matchingService = getMatchingService(artifactName) || '';

package/lib/transform/draft/odata.js

@@ -3,7 +3,7 @@
 const { forEachDefinition, getServiceNames } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
-const { getTransformers } = require('../transformUtilsNew');
+const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const { makeMessageFunction } = require('../../base/messages');
 

package/lib/transform/{forOdataNew.js → forOdata.js}

@@ -2,7 +2,7 @@
 
 const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
-const transformUtils = require('./transformUtilsNew');
+const transformUtils = require('./transformUtils');
 const { cloneCsnNonDict,
         forEachDefinition,
         forEachMemberRecursively,
@@ -392,11 +392,11 @@ function transform4odataWithCsn(inputModel, options) {
       if (node['@mandatory']&& node['@Common.FieldControl'] === undefined) {
         setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
       }
-      if (node['@assert.range'] != null) {
-        if (Array.isArray(node['@assert.range']) && node['@assert.range'].length === 2) {
-          setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
-          setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
-        }
+      if (node['@assert.range'] != null &&
+          (Array.isArray(node['@assert.range']) &&
+           node['@assert.range'].length === 2)) {
+        setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
+        setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
       }
     }
   }

package/lib/transform/forRelationalDB.js

@@ -7,7 +7,7 @@ const { cloneCsnNonDict,
         isAspect, walkCsnPath, isPersistedOnDatabase,
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
-const transformUtils = require('./transformUtilsNew');
+const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
 const { csnRefs, pathId, traverseQuery } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
@@ -26,7 +26,7 @@ const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
 const generateDrafts = require('./draft/db');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
-const { getViewTransformer } = require('./db/views');
+const { getViewTransformer, ensureColumnNames } = require('./db/views');
 const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
 const associations = require('./db/associations')
@@ -98,17 +98,17 @@ function forEachDefinition(csn, cb) {
  * - (250) Remove name space definitions again (only in forRelationalDB). Maybe we can omit inserting namespace definitions
  *         completely (TODO)
  *
- * @param {CSN.Model}   inputModel
+ * @param {CSN.Model}   csn
  * @param {CSN.Options} options
  * @param {string}      moduleName The calling compiler module name, e.g. `to.hdi` or `to.hdbcds`.
  */
-function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
+function transformForRelationalDBWithCsn(csn, options, moduleName) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
 
   timetrace.start('Clone CSN');
   /** @type {CSN.Model} */
-  let csn = cloneCsnNonDict(inputModel, options);
+  csn = cloneCsnNonDict(csn, options);
   timetrace.stop('Clone CSN');
 
   checkCSNVersion(csn, options);
@@ -117,20 +117,13 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   // There is also an explicit default length via options.defaultStringLength
   const implicitDefaultLengths = getDefaultTypeLengths(options.sqlDialect);
 
+  /** @type {object} */
   let csnUtils;
+  /** @type {object} */
+  let messageFunctions;
   let message, error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
-  // csnUtils
-  let artifactRef,
-    inspectRef,
-    effectiveType,
-    initDefinition,
-    dropDefinitionCache,
-    get$combined,
-    getCsnDef,
-    isAssocOrComposition,
-    addStringAnnotationTo;
   // transformUtils
   let addDefaultTypeFacets,
     expandStructsInExpression,
@@ -148,6 +141,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     bindCsnReference();
   }
 
+  ensureColumnNames(csn, options, csnUtils);
+
   const dialect = options.sqlDialect;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
@@ -159,14 +154,14 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   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, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils, csn, options, isAspect
+    ...messageFunctions, csnUtils, ...csnUtils, csn, options, isAspect
   });
   timetrace.stop('Validate');
 
-  rewriteCalculatedElementsInViews(csn, options, pathDelimiter, error);
+  rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
-  handleExists(csn, options, error, inspectRef, initDefinition, dropDefinitionCache);
+  handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
 
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
@@ -179,19 +174,17 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   throwWithAnyError();
 
-  const transformCsn = transformUtils.transformModel;
-
   forEachDefinition(csn, [
     // (001) Add a temporal where condition to views where applicable before assoc2join
     //       assoc2join eventually rewrites the table aliases
-    temporal.getViewDecorator(csn, {info}, csnUtils),
+    temporal.getViewDecorator(csn, messageFunctions, csnUtils),
     // check unique constraints - further processing is done in rewriteUniqueConstraints
     assertUnique.prepare(csn, options, error, info)
   ]);
 
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
-    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithAnyError}, csnUtils);
+    expansion.expandStructureReferences(csn, options, pathDelimiter, messageFunctions, csnUtils);
     bindCsnReference();
   }
 
@@ -217,7 +210,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     flattening.flattenElements(csn, options, pathDelimiter, error);
   } else {
     // For to.hdbcds with naming mode hdbcds we also need to resolve the types
-    flattening.resolveTypeReferences(csn, options, undefined, pathDelimiter);
+    flattening.resolveTypeReferences(csn, options, new WeakMap(), pathDelimiter);
   }
 
   // (010) If requested, translate associations to joins
@@ -227,7 +220,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   bindCsnReference();
 
   const redoProjections = [];
-  // Use the "raw" forEachDefinition here to ensure that the _ignore takes effect
+  // Use the "raw" forEachDefinition here to ensure that the $ignore takes effect
   _forEachDefinition(csn, (artifact) => {
     if(artifact.kind === 'entity' && artifact.projection) {
       artifact.query = { SELECT: artifact.projection };
@@ -242,8 +235,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         }
       })
     } else if(artifact.kind === 'annotation' || artifact.kind === 'action' || artifact.kind === 'function' || artifact.kind === 'event'){
-      // _ignore actions etc. - this loop seemed handy for this, as we can hook into an existing if
-      artifact._ignore = true;
+      // $ignore actions etc. - this loop seemed handy for this, as we can hook into an existing if
+      artifact.$ignore = true;
     }
   });
 
@@ -251,20 +244,30 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   timetrace.start('Transform CSN')
 
-  // (000) Rename primitive types, make UUID a String
-  transformCsn(csn, {
-    type: (val, node, key) => {
-      renamePrimitiveTypesAndUuid(val, node, key);
-      addDefaultTypeFacets(node, implicitDefaultLengths);
-    },
+  // Rename primitive types, make UUID a String; replace `items` by cds.LargeString
+  //
+  // First, gather all nodes that are arrayed: Don't replace inline, or getFinalTypeInfo()
+  // may not return `.items` for types that were already processed.
+  {
+    const removeItems = new Set();
+    applyTransformations(csn, {
+      type: (node) => {
+        if (node.items || node.type && csnUtils.getFinalTypeInfo(node.type)?.items)
+          removeItems.add(node);
+        renamePrimitiveTypesAndUuid(node.type, node, 'type');
+        addDefaultTypeFacets(node, implicitDefaultLengths);
+      },
+      items: (node) => removeItems.add(node),
+    });
     // no support for array-of - turn into CLOB/Text
     // must be done after A2J or compiler checks could change
     // (e.g. annotation def checks for arrayed types)
-    items: (val, node) => {
+    for (const node of removeItems) {
       node.type = 'cds.LargeString';
       delete node.items;
-    },
-  }, true);
+    }
+    removeItems.clear();
+  }
 
   forEachDefinition(csn, [
     // (040) Ignore entities and views that are abstract or implemented
@@ -273,7 +276,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     cdsPersistence.getAnnoProcessor(),
     // (050) Check @cds.valid.from/to only on entity
     //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
-    temporal.getAnnotationHandler(csn, options, pathDelimiter, {error})
+    temporal.getAnnotationHandler(csn, options, pathDelimiter, messageFunctions)
   ]);
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
@@ -285,7 +288,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
   // and make them entities
-  forEachDefinition(csn, cdsPersistence.getPersistenceTableProcessor(csn, options, {error}));
+  forEachDefinition(csn, cdsPersistence.getPersistenceTableProcessor(csn, options, messageFunctions));
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleAssociations, since then the foreign keys of the managed assocs
@@ -341,19 +344,19 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     createReferentialConstraints(csn, options);
 
   // no constraints for drafts
-  generateDrafts(csn, options, pathDelimiter, { info, warning, error });
+  generateDrafts(csn, options, pathDelimiter, messageFunctions);
 
   // Set the final constraint paths and produce hana tc indexes if required
   // See function comment for extensive information.
   assertUnique.rewrite(csn, options, pathDelimiter);
 
   // Associations that point to things marked with @cds.persistence.skip are removed
-  forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, {info}, csnUtils));
+  forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, messageFunctions, csnUtils));
 
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
-  const transformEntityOrViewPass2 = getViewTransformer(csn, options, {error, info}, transformCommon);
+  const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions, transformCommon);
   forEachDefinition(csn, transformViews);
 
   // Recursively apply transformCommon and attach @cds.persistence.name
@@ -384,14 +387,14 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   const killers = {
     // Used to ignore actions etc from processing and remove associations/elements
-    '_ignore': function (parent, a, b, path){
+    '$ignore': function (parent, a, b, path){
       if(path.length > 2) {
         const tail = path[path.length-1];
         const parentPath = path.slice(0, -1)
         const parentParent = walkCsnPath(csn, parentPath);
         delete parentParent[tail];
       } else {
-        delete parent._ignore;
+        delete parent.$ignore;
       }
     },
     // Still used in flattenStructuredElements - in db/flattening.js
@@ -441,7 +444,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
+    messageFunctions = makeMessageFunction(csn, options, moduleName);
+    ({ error, warning, info, message, throwWithAnyError } = messageFunctions);
 
     ({ flattenStructuredElement,
       flattenStructStepsInRef,
@@ -451,22 +455,12 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       expandStructsInExpression,
       csnUtils
     } = transformUtils.getTransformers(csn, options, pathDelimiter));
-
-    ({ artifactRef,
-      inspectRef,
-      effectiveType,
-      initDefinition,
-      dropDefinitionCache,
-      get$combined,
-      getCsnDef,
-      isAssocOrComposition,
-      addStringAnnotationTo,
-    } = csnUtils);
   }
 
   function bindCsnReferenceOnly(){
     // invalidate caches for CSN ref API
-    ({ artifactRef, inspectRef, effectiveType, initDefinition, dropDefinitionCache } = csnRefs(csn));
+    const csnRefApi = csnRefs(csn);
+    Object.assign(csnUtils, csnRefApi);
   }
 
   function handleMixinOnConditions(artifact, artifactName) {
@@ -513,7 +507,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
                 // not explicitly in column list, check query sources
                 // get$combined also includes elements which are part of "excluding {}"
                 // this shouldn't be an issue here, as such references get rejected
-                const elementsOfQuerySources = get$combined(query);
+                const elementsOfQuerySources = csnUtils.get$combined(query);
                 forEach(elementsOfQuerySources, (id, element) => {
                   // if the ref points to an element which is not explicitly exposed in the column list,
                   // but through the '*' operator -> replace the $projection / $self with the correct source entity
@@ -538,7 +532,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function transformViews(artifact, artifactName) {
-    if (!artifact._ignore) {
+    if (!artifact.$ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
 
@@ -557,7 +551,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
         const process = (parent, prop, query, path) => {
           transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))
-          replaceAssociationsInGroupByOrderBy(parent, options, inspectRef, error, path.concat(prop));
+          replaceAssociationsInGroupByOrderBy(parent, options, csnUtils.inspectRef, error, path.concat(prop));
           return query;
         }
         applyTransformationsOnNonDictionary(csn.definitions, artifactName, {
@@ -572,9 +566,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function recursivelyApplyCommon(artifact, artifactName) {
-    if (!artifact._ignore) {
+    if (!artifact.$ignore) {
       if (artifact.kind !== 'service' && artifact.kind !== 'context')
-        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+        csnUtils.addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
         if (property === 'returns')
@@ -584,7 +578,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         // Virtual elements in entities and types are not annotated, as they have no DB representation.
         // In views they are, as we generate a null expression for them (null as <colname>)
         if ((!member.virtual || artifact.query))
-          addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
+          csnUtils.addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
       }, [ 'definitions', artifactName ]);
     }
   }
@@ -594,7 +588,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function removeKeyPropInType(artifact, artifactName) {
-    if (!artifact._ignore && artifact.kind === 'type') {
+    if (!artifact.$ignore && artifact.kind === 'type') {
       forEachMemberRecursively(artifact, (member) => {
         if (member.key)
           delete member.key;
@@ -618,7 +612,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     function doit(dict, subPath) {
       for (const elemName in dict) {
         const elem = dict[elemName];
-        if (elem.on && isAssocOrComposition(elem))
+        if (elem.on && csnUtils.isAssocOrComposition(elem))
           processBacklinkAssoc(elem, elemName, artifact, artifactName, subPath.concat([ elemName, 'on' ]));
       }
     }
@@ -641,7 +635,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // For HANA: Report an error on
       // - view with parameters that has an element of type association/composition
       // - association that points to entity with parameters
-      if (options.sqlDialect === 'hana' && member.target && isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
+      if (options.sqlDialect === 'hana' && member.target && csnUtils.isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
         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)
@@ -676,7 +670,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function handleChecksForWithParameters(artifact, artifactName) {
-    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity')) {
+    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' }, {
@@ -714,7 +708,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     // restore all (non-enumerable) properties that wouldn't survive reaugmentation/compactification into the new compact model
     forEachDefinition(csn, (art, artName) => {
       if(art['$tableConstraints']) {
-        setProp(newCsn.definitions[artName], '$tableConstraints', art['$tableConstraints']);
+        newCsn.definitions[artName].$tableConstraints = art['$tableConstraints'];
       }
       if (art.technicalConfig)
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
@@ -790,7 +784,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     if (elem.default && elem.default['#']) {
       let Enum = elem.enum;
       if (!Enum && !isBuiltinType(elem.type)) {
-        const typeDef = getCsnDef(elem.type);
+        const typeDef = csnUtils.getCsnDef(elem.type);
         Enum = typeDef && typeDef.enum;
       }
       if (!Enum) {
@@ -852,7 +846,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
           // Check if one side is $self and the other an association
           // (if so, replace all three tokens with the condition generated from the other side, in parentheses)
           if (isDollarSelfOrProjectionOperand(xprArgs[i]) && isAssociationOperand(xprArgs[i + 2], path.concat([ i + 2 ]))) {
-            const assoc = inspectRef(path.concat([ i + 2 ])).art;
+            const assoc = csnUtils.inspectRef(path.concat([ i + 2 ])).art;
             if (multipleExprs)
               result.push('(');
             const backlinkName = xprArgs[i + 2].ref[xprArgs[i + 2].ref.length - 1];
@@ -867,7 +861,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
             attachBacklinkInformation(backlinkName);
           }
           else if (isDollarSelfOrProjectionOperand(xprArgs[i + 2]) && isAssociationOperand(xprArgs[i], path.concat([ i ]))) {
-            const assoc = inspectRef(path.concat([ i ])).art;
+            const assoc = csnUtils.inspectRef(path.concat([ i ])).art;
             if (multipleExprs)
               result.push('(');
             const backlinkName = xprArgs[i].ref[xprArgs[i].ref.length - 1];
@@ -943,7 +937,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         if(assoc.keys.length)
           return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName);
         else {
-          elem._ignore = true;
+          elem.$ignore = true;
           return [];
         }
       }
@@ -1034,10 +1028,10 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   function checkTypeParameters(artifact, artifactName) {
     forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
       // Check type parameters (length, precision, scale ...)
-      if (!member._ignore && member.type)
+      if (!member.$ignore && member.type)
         _check(member, memberName, csn, path);
 
-      if (!member._ignore && member.items && member.items.type)
+      if (!member.$ignore && member.items && member.items.type)
         _check(member.items, memberName, csn, path.concat([ 'items' ]));
     }, [ 'definitions', artifactName ]);
 
@@ -1079,7 +1073,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // (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 === undefined || paramValue === null) {
+        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 {
@@ -1134,7 +1128,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
               if (typeof val === 'object' && val.ref) {
                 // Replace a reference by references to it's elements, if it is structured
                 const path = [ 'definitions', artName, 'technicalConfig', dialect, 'indexes', name, idx ];
-                const { art } = inspectRef(path);
+                const { art } = csnUtils.inspectRef(path);
                 if (!art) {
                   // A reference that has no artifact (e.g. the reference to the index name itself). Just copy it over
                   flattenedIndex.push(val);
@@ -1176,8 +1170,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       }
     }
   }
-}
 
+}
 
 module.exports = {
   transformForRelationalDBWithCsn,

package/lib/transform/localized.js

@@ -330,8 +330,8 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     let keyCount = 0;
     let textElements = [];
 
-    forEachGeneric(art, 'elements', (elem, elemName /*, prop, path*/) => {
-      if (elem._ignore) // from HANA backend
+    forEachGeneric(art, 'elements', (elem, elemName , _prop, path) => {
+      if (elem.$ignore) // from SAP HANA backend
         return;
 
       if (elem.key || elem.$key)
@@ -340,9 +340,10 @@ function _addLocalizationViews(csn, options, useJoins, config) {
       if (elem.key || elem.$key || elem.localized)
         textElements.push( elemName );
 
-      // TODO: Already warned about in extend.js
-      // if (elem.key && isLocalized)
-      //   warning( 'localized-key', path, {}, 'Keyword "localized" is ignored for primary keys' );
+      if ((elem.key|| elem.$key) && elem.localized) {
+        messageFunctions.warning('def-ignoring-localized', path, { keyword: 'localized' },
+          'Keyword $(KEYWORD) is ignored for primary keys');
+      }
     }, artPath);
 
     if (textElements.length <= keyCount || keyCount <= 0)

package/lib/transform/odata/toFinalBaseType.js

@@ -94,7 +94,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
   function expandToFinalBaseType(node, defName) {
     if (!node) return;
     // TODO: Clarify how should events be handled?
-    // They are not treated by the transformUtilsNew::toFinalBaseType function
+    // They are not treated by the transformUtils::toFinalBaseType function
     // in the same manner as named types, because the elements of structured events are not
     // propagated as it is with types.
     // It is ok to skip the expansion to the final base type for now as events are not rendered in
@@ -130,7 +130,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
               */
               if (isBuiltinType(finalBaseType.type)) {
                 /*
-                  use transformUtilsNew::toFinalBaseType for the moment,
+                  use transformUtils::toFinalBaseType for the moment,
                   as it is collects along the chain of types
                   attributes that need to be propagated
                   enum, length, scale, etc.
@@ -161,7 +161,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
               */
               if (isBuiltinType(finalBaseType.type)) {
                 /*
-                  use transformUtilsNew::toFinalBaseType for the moment,
+                  use transformUtils::toFinalBaseType for the moment,
                   as it is collects along the chain of types
                   attributes that need to be propagated
                   enum, length, scale, etc.