@sap/cds-compiler 3.8.2 → 3.9.4

package/lib/render/toHdbcds.js

@@ -21,7 +21,7 @@ const { makeMessageFunction } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 
 const { smartId, delimitedId } = require('../sql-identifier');
-const { ModelError } = require('../base/error');
+const { ModelError, CompilerAssertion } = require('../base/error');
 
 const $PROJECTION = '$projection';
 const $SELF = '$self';
@@ -60,7 +60,7 @@ function toHdbcdsSource( csn, options ) {
   const hdbcdsNames = options.sqlMapping === 'hdbcds';
 
   const {
-    info, warning, error, throwWithAnyError,
+    info, warning, error, throwWithAnyError, message,
   } = makeMessageFunction(csn, options, 'to.hdbcds');
 
   const exprRenderer = createExpressionRenderer({
@@ -1051,7 +1051,7 @@ function toHdbcdsSource( csn, options ) {
     result += (elm.localized ? 'localized ' : '');
 
     // Anonymous structured type
-    if (!elm.type) {
+    if (!elm.type && !elm.value) {
       if (!elm.elements)
         throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
 
@@ -1070,14 +1070,14 @@ function toHdbcdsSource( csn, options ) {
     if ([ 'cds.Association', 'cds.Composition' ].includes(elm.type))
       return result + renderAssociationType(elm, env);
 
-    // Reference to another element
-    if (elm.type.ref) {
+
+    if (elm.type?.ref) {
+      // Reference to another element
       // For HANA CDS, we need a 'type of'
-      return `type of ${renderAbsolutePath(elm.type, env)}`;
+      result += `type of ${renderAbsolutePath(elm.type, env)}`;
     }
-
-    // If we get here, it must be a named type
-    if (isBuiltinType(elm.type)) {
+    else if (isBuiltinType(elm.type)) {
+      // If we get here, it must be a named type
       result += renderBuiltinType(elm);
     }
     else {
@@ -1086,6 +1086,14 @@ function toHdbcdsSource( csn, options ) {
       result += renderAbsoluteNameWithQuotes(elm.type, env);
     }
 
+    if (elm.value) {
+      if (!elm.value.stored)
+        throw new CompilerAssertion('Found calculated element on-read in rendering; should have been replaced!');
+      message('def-unsupported-calc-elem', env.path, { '#': 'hdbcds' });
+      result += ` GENERATED ALWAYS AS ${renderExpr(elm.value)}`;
+      return result;
+    }
+
     return result;
   }
 
@@ -1282,7 +1290,7 @@ function toHdbcdsSource( csn, options ) {
         else if (x.ref[1] === 'locale')
           return 'SESSION_CONTEXT(\'LOCALE\')';
       }
-      else if (x.ref[0] === '$at') {
+      else if (x.ref[0] === '$at' || x.ref[0] === '$valid') {
         if (x.ref[1] === 'from')
           return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
 

package/lib/render/toSql.js

@@ -1250,7 +1250,7 @@ function toSqlDdl( csn, options ) {
     let result = '';
 
     // Anonymous structured type: Not supported with SQL (but shouldn't happen anyway after forHana flattened them)
-    if (!elm.type) {
+    if (!elm.type && !elm.value) {
       if (!elm.elements)
         throw new ModelError(`Missing type of: ${elementName}`);
 
@@ -1278,6 +1278,20 @@ function toSqlDdl( csn, options ) {
       throw new ModelError(`Unexpected non-primitive type of: ${artifactName}.${elementName}`);
     }
     result += renderTypeParameters(elm);
+
+    if (elm.value) {
+      if (!elm.value.stored)
+        throw new CompilerAssertion('Found calculated element on-read in rendering; should have been replaced!');
+      // TODO: Properly implement calculated elements on-write:
+      // The SQL standard 2016 describes the syntax in section 11.3 - 11.4
+      // of the SQL Foundation spec (for 2003 in 5WD-02-Foundation-2003-09.pdf). Summarized:
+      //   <generation clause> ::= GENERATED ALWAYS AS '(' <value expression> ')'
+      result += ` GENERATED ALWAYS AS (${renderExpr(elm.value)})`;
+      // However, it appears many databases require a trailing "STORED".
+      if (options.sqlDialect === 'sqlite' || options.sqlDialect === 'postgres')
+        result += ' STORED';
+      return result;
+    }
     return result;
   }
 
@@ -1397,7 +1411,7 @@ function toSqlDdl( csn, options ) {
         if (result)
           return result;
       }
-      else if (x.ref[0] === '$at') {
+      else if (x.ref[0] === '$at' || x.ref[0] === '$valid') {
         const result = render$at();
         // Invalid second path step doesn't cause a return
         if (result)
@@ -1444,6 +1458,8 @@ function toSqlDdl( csn, options ) {
           return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
         else if (options.sqlDialect === 'postgres')
           return 'current_setting(\'CAP.APPLICATIONUSER\')';
+        else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
+          return 'session_context( \'$user.id\' )';
         warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
         return '\'$user.id\'';
       }
@@ -1452,6 +1468,8 @@ function toSqlDdl( csn, options ) {
           return 'SESSION_CONTEXT(\'LOCALE\')';
         else if (options.sqlDialect === 'postgres')
           return 'current_setting(\'CAP.LOCALE\')';
+        else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
+          return 'session_context( \'$user.locale\' )';
         return '\'en\''; // default language
       }
       // Basically: Second path step was invalid, do nothing - should not happen.
@@ -1473,6 +1491,8 @@ function toSqlDdl( csn, options ) {
       if (x.ref[1] === 'from') {
         switch (options.sqlDialect) {
           case 'sqlite': {
+            if (options.betterSqliteSessionVariables)
+              return 'session_context( \'$valid.from\' )';
             const dateFromFormat = '%Y-%m-%dT%H:%M:%S.000Z';
             return `strftime('${dateFromFormat}', 'now')`;
           }
@@ -1491,6 +1511,8 @@ function toSqlDdl( csn, options ) {
       if (x.ref[1] === 'to') {
         switch (options.sqlDialect) {
           case 'sqlite': {
+            if (options.betterSqliteSessionVariables)
+              return 'session_context( \'$valid.to\' )';
             // + 1ms compared to $at.from
             const dateToFormat = '%Y-%m-%dT%H:%M:%S.001Z';
             return `strftime('${dateToFormat}', 'now')`;

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

@@ -21,14 +21,15 @@
     "sonarjs/cognitive-complexity": "off",
     "sonarjs/no-duplicate-string": "off",
     // Does not recognize TS types
-    "jsdoc/no-undefined-types": "off"
+    "jsdoc/no-undefined-types": "off",
+    "jsdoc/tag-lines": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2020,
+    "ecmaVersion": 2022,
     "sourceType": "script"
   },
   "env": {
-    "es2020": true,
+    "es2022": true,
     "node": true
   },
   "settings": {

package/lib/transform/db/cdsPersistence.js

@@ -82,7 +82,7 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
   function ignore( member, memberName, prop, path ) {
     if (options.sqlDialect === 'hana' &&
        !member._ignore && member.target &&
-       isAssocOrComposition(member.type) &&
+       isAssocOrComposition(member) &&
        !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
            { target: member.target, anno: '@cds.persistence.skip' },

package/lib/transform/db/expansion.js

@@ -26,7 +26,7 @@ const { forEach } = require('../../utils/objectUtils');
  */
 function expandStructureReferences( csn, options, pathDelimiter, { error, info, throwWithAnyError }, csnUtils, iterateOptions = {} ) {
   const {
-    isStructured, get$combined, getFinalBaseTypeWithProps,
+    isStructured, get$combined, getFinalTypeInfo,
   } = csnUtils;
   let { effectiveType, inspectRef } = csnUtils;
 
@@ -76,6 +76,10 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         // We can directly use SELECT here, as only projections and SELECT can have .columns
         const root = get$combined({ SELECT: parent });
         if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
+          // Make root look like normal .elements - we never cared about conflict afaik anyway
+          Object.keys(root).forEach((key) => {
+            root[key] = root[key][0].element;
+          });
           const rewritten = rewrite(root, parent.columns, parent.excluding);
           /*
            * Do not remove unexpandable many columns in OData
@@ -240,7 +244,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
      */
     function nextBase( parent, base ) {
       if (parent.ref) {
-        const finalBaseType = getFinalBaseTypeWithProps(parent._art.type);
+        const finalBaseType = getFinalTypeInfo(parent._art.type);
         const art = parent._art;
 
         if (finalBaseType && (finalBaseType.type === 'cds.Association' || finalBaseType.type === 'cds.Composition'))
@@ -306,11 +310,11 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
 
     /**
      * Rewrite the expand/inline. For expand, keep along the alias - for inline, only leaf-alias has effect.
-     * Expand * into the corresponding leaves - correctly handling .exlcluding and shadowing.
+     * Expand * into the corresponding leaves - correctly handling .excluding and shadowing.
      *
      * Iterative, to not run into stack overflow.
      *
-     * @param {CSN.Artifact} root All elements visible fromt he query source ($combined)
+     * @param {CSN.Artifact} root All elements visible from the query source ($combined)
      * @param {CSN.Column} col Column to expand
      * @param {Array} ref Ref so far
      * @param {Array} alias Any start-alias
@@ -361,8 +365,9 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           expanded.push(Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } ));
         }
         else { // preserve stuff like .cast for redirection
-          if (base[currentAlias[currentAlias.length - 1]]?.value)
-            error('query-unsupported-calc', col.$path, { '#': 'inside' });
+          const thing = base[currentAlias[currentAlias.length - 1]];
+          if (current?._art?.value || thing?.value)
+            error('query-unsupported-calc', current.$path || col.$path, { '#': 'inside' });
           expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
         }
       }

package/lib/transform/db/flattening.js

@@ -9,6 +9,7 @@ const transformUtils = require('../transformUtilsNew');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
+const { cardinality2str } = require('../../model/csnUtils');
 
 /**
  * Strip off leading $self from refs where applicable
@@ -67,7 +68,7 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
     }
   }
   const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  const { getServiceName, getFinalBaseTypeWithProps } = csnUtils;
+  const { getServiceName, getFinalTypeInfo } = csnUtils;
 
   // We don't want to iterate over actions
   if (iterateOptions.skipDict && !iterateOptions.skipDict.actions)
@@ -155,7 +156,7 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
       return false;
 
     const typeServiceName = getServiceName(typeName);
-    const finalBaseType = getFinalBaseTypeWithProps(typeName)?.type;
+    const finalBaseType = getFinalTypeInfo(typeName)?.type;
     // we need the service of the current definition
     const currDefServiceName = getServiceName(path[1]);
 
@@ -313,7 +314,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
             flatElement.notNull = true;
 
 
-          if (flatElement.type && isAssocOrComposition(flatElement.type) && flatElement.on) {
+          if (flatElement.type && isAssocOrComposition(flatElement) && flatElement.on) {
             // Make refs resolvable by fixing the first ref step
             for (const onPart of flatElement.on) {
               if (onPart.ref) {
@@ -406,12 +407,13 @@ function getBranches( element, elementName, effectiveType, pathDelimiter ) {
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {Function} error
+ * @param {Function} warning
  * @param {string} pathDelimiter
  * @param {boolean} flattenKeyRefs
  * @param {object} csnUtils
  * @param {object} iterateOptions
  */
-function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
+function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, warning, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
   const { isManagedAssociation, inspectRef, isStructured } = csnUtils;
   const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, pathDelimiter);
   if (flattenKeyRefs) {
@@ -642,8 +644,13 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, pat
             if (element.cardinality === undefined)
               element.cardinality = {};
               // min=0 is falsy => check for undefined
-            if (element.cardinality.min === undefined)
+            if (element.cardinality.min === undefined) {
               element.cardinality.min = 1;
+            }
+            else if (element.cardinality.min === 0) {
+              warning(null, element.$path, { value: cardinality2str(element, false), code: 'not null' },
+                      'Expected target cardinality $(VALUE) and $(CODE) to match');
+            }
           }
         }
         orderedElements.push(...fks);
@@ -724,16 +731,6 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
   else if (lvl === 0) {
     return fks;
   }
-  // we have reached a leaf element, create a foreign key
-  else if (finalElement && isBuiltinType(finalElement.type)) {
-    const newFk = Object.create(null);
-    for (const prop of [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type' ]) {
-      // copy props from original element to preserve derived types!
-      if (element[prop] !== undefined)
-        newFk[prop] = element[prop];
-    }
-    return [ [ prefix, newFk ] ];
-  }
   else if (finalElement.elements) {
     Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
       // Skip already produced foreign keys
@@ -743,6 +740,16 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       }
     });
   }
+  // we have reached a leaf element, create a foreign key
+  else if (finalElement && (finalElement.type == null || isBuiltinType(finalElement.type))) {
+    const newFk = Object.create(null);
+    for (const prop of [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type' ]) {
+      // copy props from original element to preserve derived types!
+      if (element[prop] !== undefined)
+        newFk[prop] = element[prop];
+    }
+    return [ [ prefix, newFk ] ];
+  }
 
   /**
    * Get the path to continue resolving references

package/lib/transform/db/rewriteCalculatedElements.js

@@ -13,6 +13,8 @@ const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '
  * Rewrite usage of calculated Elements into the expression itself.
  * Delete calculated elements in entities after processing so they don't materialize on the db.
  *
+ * TODO: Calculated elements on-write (`stored: true`)
+ *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {string} pathDelimiter
@@ -37,24 +39,21 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     }
   });
 
-  // Replace calculated elements in filters (if the root-association element is in an entity).
+  // Replace calculated elements in filters, functions and other places (if the root-association element is in an entity).
   // Depends on the first pass!
   entities.forEach(({ artifactName }) => {
     applyTransformationsOnNonDictionary(csn.definitions, artifactName, {
-      where: (parent, prop) => {
-        applyTransformationsOnNonDictionary(parent, prop, {
-          ref: (_parent, _prop, ref, _path, root, index) => {
-            if (_parent._art && _parent._art.value) {
-              root[index] = _parent._art.value;
-              applyTransformationsOnNonDictionary(root, index, {
-                ref: (__parent, _, _ref) => {
-                  if (_ref[0] === '$self' || _ref[0] === '$projection')
-                    __parent.ref = _ref.slice(-1);
-                },
-              });
-            }
-          },
-        });
+      ref: (_parent, _prop, ref, _path, root, index) => {
+        if (_parent._art && _parent._art.value) {
+          root[index] = _parent._art.value;
+          // Note: Depends on A2J rejecting deeply nested filters
+          applyTransformationsOnNonDictionary(root, index, {
+            ref: (__parent, _, _ref) => {
+              if (_ref[0] === '$self' || _ref[0] === '$projection')
+                __parent.ref = _ref.slice(-1);
+            },
+          });
+        }
       },
     }, { drillRef: true }, [ 'definitions' ]);
   });
@@ -100,10 +99,11 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    */
   function rewriteInView( SELECT, elements, path ) {
     const containsExpandInline = hasExpandInline(SELECT);
+    let cleanupCallbacks;
     if (!SELECT.columns) // needs to happen for all subqueries!
-      calculateColumns(elements, SELECT);
+      cleanupCallbacks = calculateColumns(elements, SELECT);
     else
-      makeAllCalculatedElementsExplicitColumns(elements, SELECT, containsExpandInline);
+      cleanupCallbacks = makeAllCalculatedElementsExplicitColumns(elements, SELECT, containsExpandInline);
 
     const name = SELECT.from.args ? undefined : SELECT.from.as || (SELECT.from.ref && implicitAs(SELECT.from.ref));
 
@@ -114,7 +114,8 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
             art, env, links, scope,
           } = getRefInfo(parent, p);
 
-          if (art?.value) {
+          // TODO: Calculated elements on-write
+          if (art?.value && !art.value.stored) {
             const alias = parent.as || implicitAs(parent.ref);
             // TODO: What about other scopes? expand/inline?
             const value = (scope !== 'ref-target') ? absolutifyPaths(env, art, ref, links, name).value : keepAssocStepsInRef(ref, links, art).value;
@@ -129,10 +130,21 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
               root[p[p.length - 1]].as = alias;
             else
               delete root[p[p.length - 1]].as;
+
+            // If the calculated element has a type, use it. But only if the column did not have an explicit type.
+            // Note: We should not check `art.type`, because we only need the type for columns, not filters.
+            if (parent.cast)
+              root[p[p.length - 1]].cast = parent.cast;
+            else if (parent._element?.type)
+              root[p[p.length - 1]].cast = { type: parent._element.type };
+
+            // TODO: Copy annotations? May become relevant in the future
           }
         },
       }, {}, path);
     }
+
+    cleanupCallbacks.forEach(fn => fn());
   }
 
   /**
@@ -198,6 +210,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         });
       }
       else if (current.value.ref && current.value._art?.value) {
+        // TODO: Check for calculated elements on-write
         const linksBase = current.value._links;
         const refBase = current.value.ref;
         const parentIndex = Array.isArray(current.parent) ? current.parent.indexOf(current.value) : -1;
@@ -285,9 +298,10 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    */
   function calculateColumns( elements, carrier ) {
     carrier.columns = [ '*' ];
-    makeAllCalculatedElementsExplicitColumns(elements, carrier, false);
+    const cleanupCallbacks = makeAllCalculatedElementsExplicitColumns(elements, carrier, false);
     if (carrier.columns.length === 1 && carrier.columns[0] === '*')
       delete carrier.columns;
+    return cleanupCallbacks;
   }
 
   /**
@@ -304,7 +318,6 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
       return from.SELECT.elements;
     }
     else if (from.SET) {
-      // FIXME: Check if this is correct
       // args[0] could be SELECT or UNION
       return getDirectlyAdressableElements({ from: from.SET.args[0] });
     }
@@ -316,7 +329,6 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
             mergedElements[elementName] = arg._art.elements[elementName];
         }
         else if (arg.SET) {
-          // FIXME: Check if this is correct
           return getDirectlyAdressableElements({ from: arg.SET.args[0] });
         }
         else if (arg.SELECT) { // TODO: UNION
@@ -348,6 +360,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * @param {boolean} containsExpandInline
    */
   function makeAllCalculatedElementsExplicitColumns( elements, SELECT, containsExpandInline ) {
+    const cleanupCallbacks = [];
     const root = getDirectlyAdressableElements(SELECT);
     const columnMap = getColumnMap( { SELECT });
     const hasStar = SELECT.columns.includes('*');
@@ -368,10 +381,16 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
           containsCalculated = true;
           const columns = [];
           for (const branchName in branches) {
-            if (columnMap[branchName]) // Existing column - don't overwrite, we need $env!
+            if (columnMap[branchName]) { // Existing column - don't overwrite, we need $env!
               columns.push(columnMap[branchName]);
-            else // TODO: Hm, will we have a $env in the leaf of the thing then?
-              columns.push({ ref: [ ...originalRef, ...branches[branchName].ref.slice(1) ], as: branchName });
+            }
+            else {
+              // TODO: Hm, will we have a $env in the leaf of the thing then?
+              const column = { ref: [ ...originalRef, ...branches[branchName].ref.slice(1) ], as: branchName };
+              setProp(column, '_element', element);
+              cleanupCallbacks.push(() => delete column._element);
+              columns.push(column);
+            }
           }
           if (columnMap[name]) {
             unfoldingMap[name] = [ false, [ ...columns ] ];
@@ -406,6 +425,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
 
       SELECT.columns = newColumns;
     }
+    return cleanupCallbacks;
   }
 
   /**
@@ -553,9 +573,8 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
 
 /**
  * @param {CSN.Model} csn
- * @param {CSN.Options} _options
  */
-function processCalculatedElementsInEntities( csn, _options ) {
+function processCalculatedElementsInEntities( csn ) {
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.kind === 'entity' && !(artifact.query || artifact.projection))
       killInEntity(artifact, [ 'definitions', artifactName ]);
@@ -574,7 +593,8 @@ function processCalculatedElementsInEntities( csn, _options ) {
 function killInEntity( artifact, path ) {
   applyTransformationsOnDictionary(artifact.elements, {
     value: (parent, prop, value, p, root) => {
-      delete root[p[p.length - 1]];
+      if (!value.stored)
+        delete root[p[p.length - 1]];
     },
   }, {}, path);
 }
@@ -588,8 +608,9 @@ function killInEntity( artifact, path ) {
  */
 function dummifyInEntity( artifact, path ) {
   applyTransformationsOnDictionary(artifact.elements, {
-    value: (parent) => {
-      parent.value = { val: 1 };
+    value: (parent, _prop, value) => {
+      if (!value.stored)
+        parent.value = { val: 'DUMMY' };
     },
   }, {}, path);
 }

package/lib/transform/db/temporal.js

@@ -67,7 +67,7 @@ function getViewDecorator( csn, messageFunctions, csnUtils ) {
               ],
             };
 
-
+            // Clarify: What about $valid?
             const atFrom = { ref: [ '$at', 'from' ] };
             const atTo = { ref: [ '$at', 'to' ] };
 

package/lib/transform/db/views.js

@@ -294,7 +294,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
   function addImplicitAliasWithAssoc( col, path ) {
     if (!col.as && col.ref && col.ref.length > 1) {
       const { links } = inspectRef(path);
-      if (links && links.slice(0, -1).some(({ art }) => isAssocOrComposition(art && art.type || '')))
+      if (links && links.slice(0, -1).some(({ art }) => art && isAssocOrComposition(art)))
         col.as = getLastRefStepString(col.ref);
     }
   }

package/lib/transform/draft/db.js

@@ -75,7 +75,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     // Follow all composition targets in elements of 'artifact'
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
-      if (elem.target && isComposition(elem.type)) {
+      if (elem.target && isComposition(elem)) {
         const draftNode = getCsnDef(elem.target);
         const draftNodeName = elem.target;
         // Sanity check

package/lib/transform/draft/odata.js

@@ -33,10 +33,9 @@ function generateDrafts( csn, options, services ) {
     csnUtils,
   } = getTransformers(csn, options);
   const {
-    getFinalType,
     getServiceName,
     hasAnnotationValue,
-    getFinalBaseTypeWithProps,
+    getFinalTypeInfo,
   } = csnUtils;
 
   const { error, info } = makeMessageFunction(csn, options, 'for.odata');
@@ -173,7 +172,7 @@ function generateDrafts( csn, options, services ) {
 
           // Draft-enable the targets of composition elements (draft nodes), too
           // TODO rewrite
-          if (elem.target && elem.type && getFinalType(elem.type) === 'cds.Composition') {
+          if (elem.target && elem.type && getFinalTypeInfo(elem.type)?.type === 'cds.Composition') {
             const draftNode = csn.definitions[elem.target];
 
             // Ignore if that is our own draft root
@@ -196,7 +195,7 @@ function generateDrafts( csn, options, services ) {
             stack.push(elem);
           }
           else if (elem.type) { // types - possibly structured
-            const typeDef = getFinalBaseTypeWithProps(elem.type);
+            const typeDef = getFinalTypeInfo(elem.type);
             if (typeDef?.elements)
               stack.push(typeDef);
           }

package/lib/transform/forOdataNew.js

@@ -98,7 +98,7 @@ function transform4odataWithCsn(inputModel, options) {
     inspectRef,
     artifactRef,
     effectiveType,
-    getFinalBaseTypeWithProps
+    getFinalTypeInfo
   } = csnUtils;
 
   // are we working with structured OData or not
@@ -130,7 +130,7 @@ function transform4odataWithCsn(inputModel, options) {
   transformUtils.rewriteBuiltinTypeRef(csn);
 
   const cleanup = validate.forOdata(csn, {
-    message, error, warning, info, inspectRef, effectiveType, getFinalBaseTypeWithProps, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
+    message, error, warning, info, inspectRef, effectiveType, getFinalTypeInfo, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
   });
 
 
@@ -186,7 +186,7 @@ function transform4odataWithCsn(inputModel, options) {
 
   // TODO: add the generated foreign keys to the columns when we are in a view
   // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
@@ -398,8 +398,7 @@ function transform4odataWithCsn(inputModel, options) {
   // Handles on-conditions in unmanaged associations
   function processOnCond(def) {
     forEachMemberRecursively(def, (member) => {
-      // @ts-ignore
-      if (member.type && isAssocOrComposition(member.type) && member.on) {
+      if (member.on && isAssocOrComposition(member)) {
         removeLeadingDollarSelfInOnCondition(member);
       }
     });
@@ -432,7 +431,7 @@ function transform4odataWithCsn(inputModel, options) {
   // TODO: test???
   function addCommonValueListviaAssociation(member, memberName) {
     let vlAnno = '@Common.ValueList.viaAssociation';
-    if (isAssociation(member.type)) {
+    if (isAssociation(member)) {
       let navigable = member['@odata.navigable'] !== false; // navigable disabled only if explicitly set to false
       let targetDef = getCsnDef(member.target);
       if (navigable && targetDef['@cds.odata.valuelist'] && !member[vlAnno]) {