@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/transform/db/flattening.js

@@ -3,12 +3,13 @@
 const {
   getUtils, walkCsnPath,
   applyTransformations, applyTransformationsOnNonDictionary,
-  isBuiltinType, cloneCsn,
+  isBuiltinType, cloneCsnNonDict,
   copyAnnotations, implicitAs, isDeepEqual,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtilsNew');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
+const { forEach } = require('../../utils/objectUtils');
 
 /**
  * Strip off leading $self from refs where applicable
@@ -46,6 +47,7 @@ function removeLeadingSelf(csn) {
  * @param {object} iterateOptions
  */
 function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOptions = {}) {
+  const typeCache = Object.create(null); // TODO: Argument as well?
   /**
    * Remove .localized from the element and any sub-elements
    *
@@ -66,26 +68,29 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
         stack.push(...Object.values(current.elements));
     }
   }
-  const { toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  const { getServiceName, getFinalBaseType } = getUtils(csn);
+  const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { getServiceName, getFinalBaseTypeWithProps } = csnUtils;
 
   // We don't want to iterate over actions
   if (iterateOptions.skipDict && !iterateOptions.skipDict.actions)
     iterateOptions.skipDict.actions = true;
   else
     iterateOptions.skipDict = { actions: true };
+
+  const ignoreOdataKinds = { aspect: 1, event: 1, type: 1 };
+  const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
   applyTransformations(csn, {
-    cast: (parent) => {
+    cast: (parent, prop, cast, path) => {
       // Resolve cast already - we otherwise lose .localized
-      if (parent.cast.type && !isBuiltinType(parent.cast.type))
-        toFinalBaseType(parent.cast, resolved, true);
+      if (cast.type && !isBuiltinType(cast.type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(cast.type, path) && !isODataItems(cast.type)))
+        toFinalBaseType(parent.cast, resolved, true, typeCache);
     },
     // @ts-ignore
-    type: (parent, prop, type, csnPath) => {
-      if (options.toOdata && parent.kind && [ 'aspect', 'event', 'type' ].includes(parent.kind))
+    type: (parent, prop, type, path) => {
+      if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
         return;
-      if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type) && !isODataItems(type))) {
-        toFinalBaseType(parent, resolved);
+      if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
+        toFinalBaseType(parent, resolved, true, typeCache);
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
         if (parent.elements) {
@@ -94,7 +99,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
             const elements = stack.pop();
             for (const e of Object.values(elements)) {
               if (e.type && !isBuiltinType(e.type))
-                toFinalBaseType(e, resolved);
+                toFinalBaseType(e, resolved, true, typeCache);
 
               if (e.elements)
                 stack.push(e.elements);
@@ -110,40 +115,6 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
         parent.type = 'cds.LargeString';
         delete parent.items;
       }
-
-      /**
-       * OData V4 only:
-       * Do not replace a type ref if:
-       * The type definition is terminating on a scalar type (that can also be a derived type chain)
-       * AND the typeName (that is the start of that (derived) type chain is defined within the same
-       * service as the artifact from which the type reference has to be resolved.
-       *
-       * @param {string} typeName
-       * @returns {boolean}
-       */
-      function isODataV4BuiltinFromService(typeName) {
-        if (!options.toOdata || (options.toOdata && options.toOdata.version === 'v2'))
-          return false;
-
-        const typeServiceName = getServiceName(typeName);
-        const finalBaseType = getFinalBaseType(typeName);
-        // we need the service of the current definition
-        const currDefServiceName = getServiceName(csnPath[1]);
-
-        return typeServiceName === currDefServiceName && isBuiltinType(finalBaseType);
-      }
-
-      /**
-       * OData stops replacing types @ 'items', if the type ref is a user defined type
-       * AND that type has items, don't do toFinalBaseType
-       *
-       * @param {string} typeName
-       * @returns {boolean}
-       */
-      function isODataItems(typeName) {
-        const typeDef = csn.definitions[typeName];
-        return !!(options.toOdata && typeDef && typeDef.items);
-      }
     },
     // HANA/SQLite do not support array-of - turn into CLOB/Text
     items: (parent) => {
@@ -159,8 +130,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
 
     // Do not do for OData
     // TODO:factor out somewhere else
-    if (!options.toOdata &&
-      ([ 'action', 'function', 'event' ].includes(artifact.kind))) {
+    if (!options.toOdata && artifact.kind in replaceWithDummyKinds) {
       const dummy = { kind: artifact.kind };
       if (artifact.$location)
         setProp(dummy, '$location', artifact.$location);
@@ -169,6 +139,42 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
     }
     // TODO: skipDict options as default function arguments not via Object.assign
   } ], iterateOptions);
+
+
+  /**
+   * OData V4 only:
+   * Do not replace a type ref if:
+   * The type definition is terminating on a scalar type (that can also be a derived type chain)
+   * AND the typeName (that is the start of that (derived) type chain is defined within the same
+   * service as the artifact from which the type reference has to be resolved.
+   *
+   * @param {string} typeName
+   * @param {CSN.Path} path
+   * @returns {boolean}
+   */
+  function isODataV4BuiltinFromService(typeName, path) {
+    if (!options.toOdata || (options.odataVersion === 'v2') || typeof typeName !== 'string')
+      return false;
+
+    const typeServiceName = getServiceName(typeName);
+    const finalBaseType = getFinalBaseTypeWithProps(typeName)?.type;
+    // we need the service of the current definition
+    const currDefServiceName = getServiceName(path[1]);
+
+    return typeServiceName === currDefServiceName && isBuiltinType(finalBaseType);
+  }
+
+  /**
+   * OData stops replacing types @ 'items', if the type ref is a user defined type
+   * AND that type has items, don't do toFinalBaseType
+   *
+   * @param {string} typeName
+   * @returns {boolean}
+   */
+  function isODataItems(typeName) {
+    const typeDef = csn.definitions[typeName];
+    return !!(options.toOdata && typeDef && typeDef.items);
+  }
 }
 
 /**
@@ -258,12 +264,11 @@ function flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter, iter
  * @param {CSN.Options} options
  * @param {string} pathDelimiter
  * @param {Function} error
- * @param {Object} iterateOptions
+ * @param {object} iterateOptions
  */
 function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}) {
-  const { isAssocOrComposition } = getUtils(csn);
-  const { flattenStructuredElement } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  const { effectiveType } = csnRefs(csn);
+  const { flattenStructuredElement, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { isAssocOrComposition, effectiveType } = csnUtils;
   const transformers = {
     elements: flatten,
   };
@@ -284,7 +289,7 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
   function flatten(parent, prop, dict, path) {
     if (!parent[prop].$orderedElements)
       setProp(parent[prop], '$orderedElements', []);
-    Object.entries(dict).forEach(([ elementName, element ]) => {
+    forEach(dict, (elementName, element) => {
       if (element.elements) {
         // Ignore the structured element, replace it by its flattened form
         // TODO: use $ignore - _ is for links
@@ -294,11 +299,13 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
 
         for (const flatElemName in flatElems) {
-          if (parent[prop][flatElemName])
-          // TODO: combine message ID with generated FK duplicate
-          // do the duplicate check in the consruct callback, requires to mark generated flat elements,
-          // check: Error location should be the existing element like @odata.foreignKey4
-            error(null, path.concat([ 'elements', elementName ]), `"${path[1]}.${elementName}": Flattened struct element name conflicts with existing element: "${flatElemName}"`);
+          if (parent[prop][flatElemName]) {
+            // TODO: combine message ID with generated FK duplicate
+            // do the duplicate check in the construct callback, requires to mark generated flat elements,
+            // check: Error location should be the existing element like @odata.foreignKey4
+            error('name-duplicate-element', path.concat([ 'elements', elementName ]),
+                  { '#': 'flatten-element-exist', name: flatElemName });
+          }
 
           const flatElement = flatElems[flatElemName];
 
@@ -315,16 +322,16 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
                 const firstRef = onPart.ref[0];
 
                 /*
-                    when element is defined in the current name resolution scope, like
-                      entity E {
-                        key x: Integer;
-                            s : {
-                            y : Integer;
-                            a3 : association to E on a3.x = y;
-                            }
-                      }
-                    We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
-                  */
+                  when element is defined in the current name resolution scope, like
+                    entity E {
+                      key x: Integer;
+                          s : {
+                          y : Integer;
+                          a3 : association to E on a3.x = y;
+                          }
+                    }
+                  We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
+                */
                 const prefix = flatElement._flatElementNameWithDots.split('.').slice(0, -1).join(pathDelimiter);
                 const possibleFlatName = prefix + pathDelimiter + firstRef;
 
@@ -418,11 +425,11 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
           }
         });
       },
-    }, [], {
+    }, [], Object.assign({
       skipIgnore: false,
       allowArtifact: artifact => (artifact.kind === 'entity' || artifact.kind === 'type'),
       skipDict: { actions: true },
-    });
+    }, iterateOptions));
   }
   createForeignKeyElements();
 
@@ -469,7 +476,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
           const flat = flattenStructuredElement(art, ref[ref.length - 1], [], pathToKey);
           Object.keys(flat).forEach((flatElemName) => {
             const key = assoc.keys[i];
-            const clone = cloneCsn(assoc.keys[i], options);
+            const clone = cloneCsnNonDict(assoc.keys[i], options);
             if (clone.as) {
               const lastRef = clone.ref[clone.ref.length - 1];
               // Cut off the last ref part from the beginning of the flat name
@@ -533,7 +540,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
      * @returns {object} The clone of base
      */
     function cloneAndExtendRef(key, base, ref) {
-      const clone = cloneCsn(base, options);
+      const clone = cloneCsnNonDict(base, options);
       if (key.ref) {
         // We build a ref that contains the aliased fk - that element will be created later on, so this ref is not resolvable yet
         // Therefore we keep it as $ref - ref is the non-aliased, resolvable "clone"
@@ -604,8 +611,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
           ((options.toOdata && isDeepEqual(element, parent[prop][fk[0]], true)) ||
             !options.toOdata)) {
             // error location is the colliding element
-            error(null, eltPath, { name: fk[0], art: elementName },
-                  'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
+            error('name-duplicate-element', eltPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
           }
           // attach a proper $path
           setProp(element, '$path', eltPath);
@@ -614,10 +620,8 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
 
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
-          if (occ > 1) {
-            error(null, eltPath, { name },
-                  'Duplicate definition of foreign key element $(NAME)');
-          }
+          if (occ > 1)
+            error('name-duplicate-element', eltPath, { '#': 'flatten-fkey-gen', name, art: elementName });
         });
         if (element.keys) {
           element.keys.forEach((key, i) => {
@@ -682,17 +686,21 @@ function createForeignKeysInternal(path, element, prefix, csn, options, pathDeli
     return fks;
 
   let finalElement = element;
+  let finalTypeName; // TODO: Find a way to not rely on $path?
   // TODO: effectiveType's return value is 'path' for the next inspectRef
   if (element.type && !isBuiltinType(element.type)) {
     const tmpElt = effectiveType(element);
     // effective type resolves to structs and enums only but not scalars
     if (Object.keys(tmpElt).length) {
       finalElement = tmpElt;
+      finalTypeName = finalElement.$path[1];
     }
     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];
+      }
     }
   }
 
@@ -709,7 +717,7 @@ function createForeignKeysInternal(path, element, prefix, csn, options, pathDeli
     }
     // TODO: has managed assoc keys?
     finalElement.keys.forEach((key, keyIndex) => {
-      const continuePath = isInspectRefResult ? [ path, 'keys', keyIndex ] : [ ...path, 'keys', keyIndex ];
+      const continuePath = getContinuePath([ 'keys', keyIndex ]);
       const alias = key.as || implicitAs(key.ref);
       const result = inspectRef(continuePath);
       fks = fks.concat(createForeignKeysInternal(result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
@@ -735,12 +743,33 @@ function createForeignKeysInternal(path, element, prefix, csn, options, pathDeli
     Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
       // Skip already produced foreign keys
       if (!elem['@odata.foreignKey4']) {
-        const continuePath = isInspectRefResult ? [ path, 'elements', elemName ] : [ ...path, 'elements', elemName ];
+        const continuePath = getContinuePath([ 'elements', elemName ]);
         fks = fks.concat(createForeignKeysInternal(continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
       }
     });
   }
 
+  /**
+   * Get the path to continue resolving references
+   *
+   * If we are currently inside of a type, we need to start our path fresh from that given type.
+   * Otherwise, we would try to resolve .elements on a thing that does not exist.
+   *
+   * We also respect if we have a previous inspectRef result as our base.
+   *
+   * @param {Array} additions
+   * @returns {CSN.Path}
+   */
+  function getContinuePath(additions) {
+    if (csn.definitions[finalElement.type])
+      return [ 'definitions', finalElement.type, ...additions ];
+    else if (finalTypeName)
+      return [ 'definitions', finalTypeName, ...additions ];
+    else if (isInspectRefResult)
+      return [ path, ...additions ];
+    return [ ...path, ...additions ];
+  }
+
   fks.forEach((fk) => {
     // prepend current prefix
     fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;

package/lib/transform/db/transformExists.js

@@ -110,8 +110,8 @@ function handleExists(csn, options, error) {
         sources[join.as] = join.as;
       }
       else if (join.args) {
-        const subsources = getJoinSources(join.args);
-        sources = Object.assign(sources, subsources);
+        const subSources = getJoinSources(join.args);
+        sources = Object.assign(sources, subSources);
       }
       else if (join.ref) {
         sources[join.ref[join.ref.length - 1]] = join.ref[join.ref.length - 1];
@@ -196,7 +196,7 @@ function handleExists(csn, options, error) {
     const stack = [ [ null, startAssoc, startRest, startIndex ] ];
     const { links } = inspectRef(path);
     while (stack.length > 0) {
-      // previous: to nest "up" if the previous assoc did not originaly have a filter
+      // previous: to nest "up" if the previous assoc did not originally have a filter
       // assoc: the assoc path step
       // rest: path steps after assoc
       // index: index of after-assoc in the overall ref-array - so we know where to start looking for the next assoc
@@ -411,14 +411,14 @@ function handleExists(csn, options, error) {
    * Translate an `EXISTS <managed assoc>` into a part of a WHERE condition.
    *
    * For each of the foreign keys, do:
-   * + build the target side by prefixing `target` infront of the ref
+   * + build the target side by prefixing `target` in front of the ref
    * + build the source side by prefixing `base` (if not already part of `current`)
-   *  and the assoc name itself (current) infront of the ref
+   *  and the assoc name itself (current) in front of the ref
    * + Compare source and target with `=`
    *
    * If there is more than one foreign key, join with `and`.
    *
-   * The new tokens are immediatly added to the WHERE of the subselect
+   * The new tokens are immediately added to the WHERE of the subselect
    *
    * @param {CSN.Element} root
    * @param {string} target
@@ -752,7 +752,7 @@ function handleExists(csn, options, error) {
    *
    * @param {string} target
    * @param {TokenStream} where
-   * @returns {TokenStream} The input-where with the refs "absolutified"
+   * @returns {TokenStream} The input-where with the refs transformed to absolute ones
    */
   function remapExistingWhere(target, where) {
     return where.map((part) => {

package/lib/transform/db/views.js

@@ -1,9 +1,9 @@
 'use strict';
 
 const {
-  getUtils, cloneCsn, applyTransformationsOnNonDictionary,
+  getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
-const { implicitAs, csnRefs } = require('../../model/csnRefs');
+const { implicitAs } = require('../../model/csnRefs');
 const { isBetaEnabled } = require('../../base/model');
 const { ModelError } = require('../../base/error');
 
@@ -69,9 +69,9 @@ function usesMixinAssociation(query, association, associationName) {
 function getViewTransformer(csn, options, messageFunctions, transformCommon) {
   const {
     get$combined, isAssocOrComposition,
+    inspectRef, queryOrMain, // csnRefs
   } = getUtils(csn);
-  const { inspectRef, queryOrMain } = csnRefs(csn);
-  const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = options.forHana && (options.sqlMapping === 'hdbcds') ? '.' : '_';
   const { error, info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 
@@ -209,7 +209,7 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
     const assocCol = columnMap[elemName];
     if (assocCol && assocCol.ref) {
       elem.keys.forEach((foreignKey) => {
-        const ref = cloneCsn(assocCol.ref, options);
+        const ref = cloneCsnNonDict(assocCol.ref, options);
         ref[ref.length - 1] = [ getLastRefStepString(ref) ].concat(foreignKey.as).join(pathDelimiter);
         const result = {
           ref,
@@ -277,7 +277,7 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
 
         // Copy the association element to the MIXIN clause under its alias name
         // Needs to be a deep copy, as we transform the on-condition
-        const mixinElem = cloneCsn(elem, options);
+        const mixinElem = cloneCsnNonDict(elem, options);
         // Perform common transformations on the newly generated MIXIN element (won't be reached otherwise)
         transformCommon(mixinElem, mixinElemName);
 
@@ -457,6 +457,9 @@ function checkIsNotMixinByItself(query, columnMap, elementName) {
   if (query && query.SELECT && query.SELECT.mixin) {
     const col = columnMap[elementName];
 
+    if (!col.ref) // No ref -> new association, but not a mixin.
+      return true;
+
     // Use getLastRefStepString - with hdbcds.hdbcds and malicious CSN input we might have .id
     const realName = getLastRefStepString(col.ref);
     // If the element is not part of the mixin => True

package/lib/transform/draft/.eslintrc.json

@@ -23,11 +23,11 @@
     "sonarjs/no-duplicate-string": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   "settings": {

package/lib/transform/draft/db.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  hasAnnotationValue, getUtils, getServiceNames, forEachDefinition,
+  hasAnnotationValue, getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
@@ -19,15 +19,15 @@ const booleanBuiltin = 'cds.Boolean';
  * @param {object} messageFunctions
  */
 function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
-  const draftSuffix = isDeprecatedEnabled(options, 'generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
+  const draftSuffix = isDeprecatedEnabled(options, '_generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
   // All services of the model - needed for drafts
   const allServices = getServiceNames(csn);
   const draftRoots = new WeakMap();
   const {
     createForeignKeyElement, createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
-    addElement, copyAndAddElement, createAssociationPathComparison,
+    addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
   } = getTransformers(csn, options, pathDelimiter);
-  const { getCsnDef, isComposition } = getUtils(csn);
+  const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
 
   forEachDefinition(csn, generateDraft);
@@ -155,7 +155,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
             'Generated entity $(NAME) conflicts with existing artifact');
     }
 
-    const persistenceName = getResultingName(csn, options.forHana.names, draftsArtifactName);
+    const persistenceName = getResultingName(csn, options.sqlMapping, draftsArtifactName);
     // Duplicate the artifact as a draft shadow entity
     if (csn.definitions[persistenceName]) {
       const definingDraftRoot = draftRoots.get(csn.definitions[persistenceName]);
@@ -187,7 +187,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
     for (const elemName in artifact.elements) {
       const origElem = artifact.elements[elemName];
       let elem;
-      if ((isDeprecatedEnabled(options, 'renderVirtualElements') && origElem.virtual) || !origElem.virtual)
+      if ((isDeprecatedEnabled(options, '_renderVirtualElements') && origElem.virtual) || !origElem.virtual)
         elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
       if (elem) {
         // Remove "virtual" - cap/issues 4956

package/lib/transform/draft/odata.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { forEachDefinition, getUtils, getServiceNames } = require('../../model/csnUtils');
+const { forEachDefinition, getServiceNames } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtilsNew');
@@ -30,15 +30,14 @@ function generateDrafts(csn, options, services) {
     createAssociationElement, createAssociationPathComparison,
     addElement, createAction, assignAction,
     resetAnnotation,
+    csnUtils,
   } = getTransformers(csn, options);
-
   const {
     getFinalType,
     getServiceName,
     hasAnnotationValue,
-    getFinalBaseType,
-    getFinalTypeDef,
-  } = getUtils(csn);
+    getFinalBaseTypeWithProps,
+  } = csnUtils;
 
   const { error, info } = makeMessageFunction(csn, options, 'for.odata');
 
@@ -197,8 +196,8 @@ function generateDrafts(csn, options, services) {
             stack.push(elem);
           }
           else if (elem.type) { // types - possibly structured
-            const typeDef = elem.type.ref ? getFinalBaseType(elem.type) : getFinalTypeDef(elem.type);
-            if (typeDef.elements)
+            const typeDef = getFinalBaseTypeWithProps(elem.type);
+            if (typeDef?.elements)
               stack.push(typeDef);
           }
         });