@sap/cds-compiler 4.0.0 → 4.1.2

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.

package/lib/transform/{transformUtilsNew.js → transformUtils.js}

@@ -420,17 +420,10 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (typeof type === 'string' && isBuiltinType(type))
       return;
 
-    let typeRef = null;
-    if (resolved.has(type)) {
-      typeRef = resolved.get(type)?.art
-      // The cached entry may not be resolved, yet.
-      if (typeRef.type && !isBuiltinType(typeRef.type))
-        typeRef = getFinalTypeInfo(typeRef.type);
-    } else {
-      typeRef = getFinalTypeInfo(type);
-    }
+    const typeRef = getFinalTypeInfo(type, (t) => resolved.get(t)?.art || csnUtils.artifactRef(t));
     if(!typeRef)
       return;
+
     if (typeRef.elements || typeRef.items) {
       // Copy elements/items and we're finished. No need to look up actual base type,
       // since it must also be structured and must contain at least as many elements,
@@ -909,7 +902,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (annotation === undefined) {
       throw new CompilerAssertion('Annotation ' + fromName + ' not found in ' + JSON.stringify(node));
     }
-    if(node[toName] === undefined || node[toName] === null) {
+    if(node[toName] == null) {
       delete node[fromName];
       node[toName] = annotation;
     }
@@ -931,9 +924,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (value === undefined) {
       throw new CompilerAssertion('Annotation value must not be undefined');
     }
-
-    if(node[name] === undefined || node[name] === null)
-      node[name] = value;
+    node[name] ??= value;
   }
 
   /**
@@ -1352,93 +1343,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
 }
 
-/**
- * Modify the given CSN/artifact in-place, applying the given customTransformations.
- * Dictionaries are correctly handled - a "type" transformer will not be called on an entity called "type".
- *
- * A custom transformation function has the following signature:
- * (any, object, string, CSN.Path) => undefined
- *
- * Given that we have a custom transformation for "type" and stumble upon a thing like below:
- *
- * {
- *    type: "cds.String",
- *    anotherProp: 1
- * }
- *
- * The input for the function would be:
- *
- * ("cds.String", { type: <>, anotherProp: <>}, "type", [xy, "type"])
- *
- * @param {CSN.Model} csn
- * @param {object} customTransformations Dictionary of functions to apply - if the property matches a key in this dict, it will be called
- * @param {boolean} [transformNonEnumerableElements=false] Transform non-enumerable elements to work with cds linked...
- * @returns {CSN.Model|CSN.Artifact} Return the CSN/artifact
- */
-function transformModel(csn, customTransformations, transformNonEnumerableElements=false){
-  const transformers = {
-    elements: dictionary,
-    definitions: dictionary,
-    actions: dictionary,
-    params: dictionary,
-    enum: dictionary,
-    mixin: dictionary,
-    args: dictionary
-  };
-
-  const csnPath = [];
-  if (csn.definitions)
-    dictionary( csn, 'definitions', csn.definitions );
-  else {
-    // fake it till you make it
-    const obj = { definitions: Object.create(null)};
-    obj.definitions.thing = csn;
-    dictionary(obj, 'definitions', obj.definitions);
-  }
-
-  return csn;
-
-  function standard( parent, prop, node ) {
-    // checking for .kind and .type is safe because annotations with such properties, are already flattened out
-    const isAnnotation = () => (typeof prop === 'string' && prop.startsWith('@') && !node.kind && !node.type);
-    if (!node || node._ignore || typeof node !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ) || isAnnotation())
-      return;
-
-    csnPath.push( prop );
-
-    if (Array.isArray(node)) {
-      node.forEach( (n, i) => standard( node, i, n ) );
-    }
-    else {
-      const iterateOver = Object.getOwnPropertyNames( node );
-      // cds-linked resolves types and add's them to elements as non-enum - need to be processed
-      if(transformNonEnumerableElements && node.elements && !Object.prototype.propertyIsEnumerable.call(node, 'elements')){
-        iterateOver.push('elements');
-      }
-      for (const name of iterateOver) {
-        if(customTransformations[name])
-          customTransformations[name](node[name], node, name, csnPath.concat(name))
-
-        const trans = transformers[name] || standard;
-        trans( node, name, node[name] );
-      }
-    }
-    csnPath.pop();
-  }
-  function dictionary( node, prop, dict ) {
-    csnPath.push( prop );
-
-    if (Array.isArray(dict)) {
-      dict.forEach( (n, i) => standard(dict, i, n))
-    } else {
-      for (const name of Object.getOwnPropertyNames( dict ))
-        standard( dict, name, dict[name] );
-    }
-
-    csnPath.pop();
-  }
-}
-
 /**
  * Mandatory input transformation for all backends:
  * Replace
@@ -1465,7 +1369,6 @@ function rewriteBuiltinTypeRef(csn) {
 module.exports = {
   // This function retrieves the actual exports
   getTransformers,
-  transformModel,
   RelationalOperators,
   rewriteBuiltinTypeRef,
 };