@sap/cds-compiler 2.15.2 → 3.0.2

package/lib/transform/forOdataNew.js

@@ -3,8 +3,7 @@
 const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtilsNew');
-const { getUtils,
-        cloneCsnNonDict,
+const { cloneCsnNonDict,
         forEachDefinition,
         forEachMemberRecursively,
         applyTransformationsOnNonDictionary,
@@ -86,10 +85,10 @@ function transform4odataWithCsn(inputModel, options) {
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
     recurseElements, setAnnotation, renameAnnotation,
-    expandStructsInExpression
+    expandStructsInExpression,
+    csnUtils,
   } = transformers;
 
-  const csnUtils = getUtils(csn);
   const {
     getCsnDef,
     getServiceName,
@@ -98,11 +97,10 @@ function transform4odataWithCsn(inputModel, options) {
     inspectRef,
     artifactRef,
     effectiveType,
-    getFinalBaseType,
   } = csnUtils;
 
   // are we working with structured OData or not
-  const structuredOData = options.toOdata.odataFormat === 'structured' && options.toOdata.version === 'v4';
+  const structuredOData = options.odataFormat === 'structured' && options.odataVersion === 'v4';
 
   // collect all declared non-abstract services from the model
   // use the array when there is a need to identify if an artifact is in a service or not
@@ -115,17 +113,17 @@ function transform4odataWithCsn(inputModel, options) {
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
 
-  const keepLocalizedViews = isDeprecatedEnabled(options, 'createLocalizedViews');
+  const keepLocalizedViews = isDeprecatedEnabled(options, '_createLocalizedViews');
 
   function acceptLocalizedView(_name, parent) {
     csn.definitions[parent].$localized = true;
     return keepLocalizedViews && !isExternalServiceMember(undefined, parent);
   }
 
-  addLocalizationViews(csn, options, acceptLocalizedView);
+  addLocalizationViews(csn, options, { acceptLocalizedView, ignoreUnknownExtensions: true });
 
   const cleanup = validate.forOdata(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
   });
 
 
@@ -214,16 +212,16 @@ function transform4odataWithCsn(inputModel, options) {
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
-    if (options.toOdata.names && !(def.kind in skipPersNameKinds))
-      def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.toOdata.names, csn);
+    if (options.sqlMapping && !(def.kind in skipPersNameKinds))
+      def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
 
     forEachMemberRecursively(def, (member, memberName, propertyName) => {
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested
       // Only these are actually required and don't annotate virtual elements in entities or types
       // as they have no DB representation (although in views)
-      if (options.toOdata.names && typeof member === 'object' && !(member.kind === 'action' || member.kind === 'function') && propertyName !== 'enum' && (!member.virtual || def.query)) {
+      if (options.sqlMapping && typeof member === 'object' && !(member.kind === 'action' || member.kind === 'function') && propertyName !== 'enum' && (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
-        member['@cds.persistence.name'] = getElementDatabaseNameOf(member._flatElementNameWithDots || memberName, options.toOdata.names);
+        member['@cds.persistence.name'] = getElementDatabaseNameOf(member._flatElementNameWithDots || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -326,7 +324,7 @@ function transform4odataWithCsn(inputModel, options) {
       // but '@Core.Immutable' for everything else.
       if (!(node['@readonly'] && node['@insertonly'])) {
         if (name === '@readonly' && node[name] !== null) {
-          if (node.kind === 'entity') {
+          if (node.kind === 'entity' || node.kind === 'aspect') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -336,7 +334,7 @@ function transform4odataWithCsn(inputModel, options) {
         }
         // @insertonly is effective on entities/queries only
         else if (name === '@insertonly' && node[name] !== null) {
-          if (node.kind === 'entity') {
+          if (node.kind === 'entity' || node.kind === 'aspect') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);

package/lib/transform/localized.js

@@ -1,12 +1,14 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { setProp } = require('../base/model');
+const { setProp, isDeprecatedEnabled} = require('../base/model');
 const { hasErrors } = require('../base/messages');
-const { cloneCsnDictionary, applyDefinitionAnnotationsFromExtensions} = require('../model/csnUtils');
+const { forEachKey } = require('../utils/objectUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
+  cloneCsnDictionary,
   cloneCsnNonDict,
+  applyAnnotationsFromExtensions,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
@@ -67,9 +69,9 @@ const _targetFor = Symbol('_targetFor');
  * @param {CSN.Options} options
  * @param {boolean} useJoins If true, rewrite the "localized" association to a
  *                           join in direct convenience views.
- * @param {acceptLocalizedView} [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param {object} config
  */
-function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = null) {
+function _addLocalizationViews(csn, options, useJoins, config) {
   // Don't try to create convenience views with errors.
   if (hasErrors(options.messages))
     return csn;
@@ -78,6 +80,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   if (hasExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
 
+  const { acceptLocalizedView, ignoreUnknownExtensions } = config;
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
 
@@ -87,9 +90,13 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
 
   // In case that the user tried to annotate `localized.*` artifacts, apply them.
-  applyDefinitionAnnotationsFromExtensions(csn, {
-    overwrite: true,
-    filter: (name) => name.startsWith('localized.')
+  applyAnnotationsFromExtensions(csn, {
+    override: true,
+    filter: (name) => name.startsWith('localized.'),
+    notFound(name, index) {
+      if (!ignoreUnknownExtensions)
+        messageFunctions.message('anno-undefined-art', [ 'extensions', index ], { name })
+    },
   });
 
   sortCsnDefinitionsForTests(csn, options);
@@ -147,7 +154,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     else
       view = createLocalizedViewForEntity(art, artName, textElements);
 
-    copyPersistenceAnnotations(view, art);
+    copyPersistenceAnnotations(view, art, options);
     csn.definitions[viewName] = view;
   }
 
@@ -605,10 +612,10 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
  */
-function addLocalizationViews(csn, options, acceptLocalizedView = null) {
-  return _addLocalizationViews(csn, options, false, acceptLocalizedView);
+function addLocalizationViews(csn, options, config = {}) {
+  return _addLocalizationViews(csn, options, false, config);
 }
 
 /**
@@ -618,10 +625,10 @@ function addLocalizationViews(csn, options, acceptLocalizedView = null) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
  */
-function addLocalizationViewsWithJoins(csn, options, acceptLocalizedView = null) {
-  return _addLocalizationViews(csn, options, true, acceptLocalizedView);
+function addLocalizationViewsWithJoins(csn, options, config = {}) {
+  return _addLocalizationViews(csn, options, true, config);
 }
 
 /**
@@ -667,21 +674,24 @@ function copyLocation(target, source) {
 }
 
 /**
- * Copy some @cds.persistence.* annotations from the source to
- * the target.  Ignores existing annotations on the target.
+ * Copy @cds.persistence.exists/skip annotations from the source to
+ * the target.  Ignores existing annotations on the _target_.
  *
  * @param {CSN.Artifact} target
  * @param {CSN.Artifact} source
+ * @param {CSN.Options} options
  */
-function copyPersistenceAnnotations(target, source) {
-  Object.keys(source)
-    .forEach(anno => {
-      // Do NOT copy ".exists" at the moment.  ".exists" is not propagated
-      // and this would lead to some localization views referencing not-existing
-      // "localized.XYZ" views.
-      if (anno === '@cds.persistence.skip')
-        target[anno] = source[anno];
-    });
+function copyPersistenceAnnotations(target, source, options) {
+  const doNotCopyExists = isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+  forEachKey(source, anno => {
+    // Note:
+    //   Because `.exists` is copied to the convenience view, it could
+    //   lead to some localization views referencing non-existing ones.
+    //   But that is the contract: User says that it already exists!
+    //   In v2, `.exists` was never copied.
+    if (anno === '@cds.persistence.skip' || (!doNotCopyExists && anno === '@cds.persistence.exists'))
+      target[anno] = source[anno];
+  });
 }
 
 /**

package/lib/transform/odata/toFinalBaseType.js

@@ -7,7 +7,7 @@ const {
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
 function expandToFinalBaseType(csn, transformers, csnUtils, services, options, isExternalServiceMember) {
-  const isV4 = options.toOdata.version === 'v4';
+  const isV4 = options.odataVersion === 'v4';
   forEachDefinition(csn, (def, defName) => {
     // Unravel derived type chains to final one for elements, actions, action parameters (propagating annotations)
     forEachMemberRecursively(def, (member) => {
@@ -87,9 +87,9 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     if (node.kind === 'event') return;
 
     // elements have precedence over type
-    if (node.type && (!isBuiltinType(node.type) &&isExpandable(node, defName) || node.kind === 'type')) {
+    if (node.type && (!isBuiltinType(node.type) && isExpandable(node, defName) || node.kind === 'type')) {
       // 1. Get the final type of the node (resolve derived type chain)
-      const finalType = csnUtils.getFinalBaseType(node.type);
+      const finalType = csnUtils.getFinalBaseTypeWithProps(node.type);
       if (finalType) {
         // The type replacement depends on whether 'node' is a definition or a member[element].
         if (node.kind) {
@@ -101,7 +101,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
           // type A: B; -> {...}
           // type B: C; -> { ... }
           // type C { .... };
-          if (isBuiltinType(finalType)) {
+          if (isBuiltinType(finalType.type)) {
             // use transformUrilsNew::toFinalBaseType for the moment,
             // as it is collects along the chain of types
             // attributes that need to be propagated
@@ -129,8 +129,8 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
           //  type A: B; -> {...}
           //  type B: C; -> { ... }
           //  type C { .... };
-          if (isBuiltinType(finalType)) {
-            // use transformUrilsNew::toFinalBaseType for the moment,
+          if (isBuiltinType(finalType.type)) {
+            // use transformUtilsNew::toFinalBaseType for the moment,
             // as it is collects along the chain of types
             // attributes that need to be propagated
             // enum, length, scale, etc.
@@ -148,7 +148,9 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
         // example in actions: 'action act() return Primitive; type Primitive: array of String;'
       const currService = csnUtils.getServiceName(defName);
       const finalType = csnUtils.getFinalTypeDef(node.type);
-      if (finalType.items && isBuiltinType(finalType.items.type)) {
+      if (finalType.items &&
+        (isBuiltinType(finalType.items.type) || isBuiltinType(csnUtils.getFinalBaseTypeWithProps(finalType.items.type)?.type)))
+      {
         if (!isArtifactInService(node.type, currService) || !isV4) {
           node.items = finalType.items;
           delete node.type;
@@ -184,8 +186,8 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
   function isUserDefinedBuiltinFromTheCurrService(node, defName) {
     // in V4 we should use TypeDefinitions whenever possible, thus in case the final type of a field is
     // a builtin from the service - do not expand to the final base type
-    let finalBaseType = csnUtils.getFinalBaseType(node.type);
-    // if (finalBaseType && finalBaseType.items) finalBaseType = csnUtils.getFinalBaseType(finalBaseType.items);
+    let finalBaseType = csnUtils.getFinalBaseTypeWithProps(node.type).type;
+    // if (finalBaseType && finalBaseType.items) finalBaseType = csnUtils.getFinalBaseTypeWithProps(finalBaseType.items);
     const currService = csnUtils.getServiceName(defName);
     return node.type && !node.type.ref
       && isBuiltinType(finalBaseType) && !csnUtils.isAssocOrComposition(finalBaseType)

package/lib/transform/odata/typesExposure.js

@@ -14,7 +14,7 @@ const { copyAnnotations } = require('../../model/csnUtils');
 function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
   // are we working with OData proxies or cross-service refs
-  const isMultiSchema = options.toOdata.version === 'v4' && (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs);
+  const isMultiSchema = options.odataVersion === 'v4' && (options.odataProxies || options.odataXServiceRefs);
   // collect in this variable all the newly exposed types
   const schemas = Object.create(null);
   const exposedTypes = Object.create(null);
@@ -122,7 +122,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           if (node.elements && node.elements[elemName].$location)
             setProp(newElem, '$location', node.elements[elemName].$location);
           defName = typeDef.kind === 'type' ? typeName : defName;
-          exposeTypeOf(newElem, isKey, elemName, defName, serviceName, 
+          exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
                        getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName);
         });
         copyAnnotations(typeDef, newType);
@@ -151,7 +151,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
      * 1) If it's an anonymous structured type (items.elements || elements)
      * 2) If it's a named type resolve to the final type definition and
      *    check if this is a structured type
-     * Returns an object that indicates 
+     * Returns an object that indicates
      *  - wether or not the type needs exposure
      *  - the elements dictionary that needs to be cloned
      *  - the typeDef, either the resolved type def or the node itself

package/lib/transform/odata/utils.js

@@ -1,38 +1,4 @@
-const {
-  forEachDefinition,
-  forEachMemberRecursively,
-} = require('../../model/csnUtils');
-
-
-// Return true if 'artifact' has an association type
-function isAssociation(artifact) {
-  return (artifact.type === 'cds.Association' || artifact.type === 'Association');
-}
-
-// Return true if 'artifact' has a composition type
-function isComposition(artifact) {
-  return (artifact.type === 'cds.Composition' || artifact.type === 'Composition')
-}
-
-function isAssociationOrComposition(artifact) {
-  return isAssociation(artifact) || isComposition(artifact);
-}
-
-function isManagedAssociation(artifact) {
-  return artifact.target !== undefined && artifact.on === undefined;
-}
-
-function forEachManagedAssociation(csn, callback, isExternalServiceMember) {
-
-  forEachDefinition(csn, (def) => {
-    forEachMemberRecursively(def, (element) => {
-      if (isAssociationOrComposition(element) && !element.on) {
-        callback(element)
-      }
-    })
-  }, { skipArtifact: isExternalServiceMember });
-
-}
+'use strict';
 
 /**
  * Return the definition name, without the prefixed service name
@@ -87,12 +53,9 @@ function isLocalizedArtifactInService(artName, services) {
 }
 
 module.exports = {
-  forEachManagedAssociation,
   defNameWithoutServiceOrContextName,
   getServiceOfArtifact,
   isArtifactInService,
   isArtifactInSomeService,
-  isAssociationOrComposition,
   isLocalizedArtifactInService,
-  isManagedAssociation,
 }

package/lib/transform/transformUtilsNew.js

@@ -6,10 +6,10 @@
 
 const { hasErrors, makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
-const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
-const { cloneCsnNonDict, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnUtils');
+const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError } = require("../base/error");
 const { forEach } = require('../utils/objectUtils');
 
@@ -20,20 +20,18 @@ const { forEach } = require('../utils/objectUtils');
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
 function getTransformers(model, options, pathDelimiter = '_') {
   const { error, warning, info } = makeMessageFunction(model, options);
+  const csnUtils = getUtils(model);
   const {
     getCsnDef,
-    getFinalBaseType,
+    getFinalBaseTypeWithProps,
     hasAnnotationValue,
     inspectRef,
     isStructured,
-  } = getUtils(model);
-
-  const {
     effectiveType,
-  } = csnRefs(model);
-
+  } = csnUtils;
 
   return {
+    csnUtils,
     resolvePath,
     flattenPath,
     addDefaultTypeFacets,
@@ -45,7 +43,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
     copyTypeProperties,
     isAssociationOperand,
     isDollarSelfOrProjectionOperand,
-    getFinalBaseType,
     createExposingProjection,
     createAndAddDraftAdminDataProjection,
     createScalarElement,
@@ -243,21 +240,19 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // for type of 'x' -> elem.type is an object, not a string -> use directly
     let elemType;
     if (!elem.elements) // structures do not have final base type
-      elemType = getFinalBaseType(elem.type);
+      elemType = getFinalBaseTypeWithProps(elem.type);
 
     const struct = elemType ? elemType.elements : elem.elements;
 
     // Collect all child elements (recursively) into 'result'
     // TODO: Do not report collisions in the generated elements here, but instead
-    // leave that work to the receiver of this result
+    //       leave that work to the receiver of this result
     let result = Object.create(null);
     const addGeneratedFlattenedElement = (e, eName) => {
-      if(result[eName]){
-        error(null, pathInCsn, { name: eName },
-          'Generated element $(NAME) conflicts with other generated element')
-      } else {
+      if (result[eName])
+        error('name-duplicate-element', pathInCsn, { '#': 'flatten-element-gen', name: eName })
+      else
         result[eName] = e;
-      }
     }
     forEach(struct, (childName, childElem) => {
       if (isStructured(childElem)) {
@@ -287,7 +282,11 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
     // Fix all collected flat elements (names, annotations, properties, origin ..)
     forEach(result, (name, flatElem) => {
-      // Copy annotations from struct (not overwriting, because deep annotations should have precedence)
+      // Copy annotations from struct (not overwriting, because deep annotations should have precedence).
+      // Attention:
+      // This has historic reasons. We don't copy doc-comments because copying annotations
+      // is questionable to begin with.  Only selected annotations should have been copied,
+      // if at all.
       copyAnnotations(elem, flatElem, false);
       // Copy selected type properties
       const props = ['key', 'virtual', 'masked', 'viaAll'];
@@ -395,78 +394,65 @@ function getTransformers(model, options, pathDelimiter = '_') {
   }
 
   /**
-   * Replace the type of 'node' with its final base type (in contrast to the compiler,
-   * also unravel derived enum types, i.e. take the final base type of the enum's base type.
-   * Similar with associations and compositions (we probably need a _baseType link)
+   * Replace the type of 'nodeWithType' with its final base type, i.e. copy relevant type properties and
+   * set the `type` property to the builtin if scalar or delete it if structured/arrayed.
    *
-   * @param {CSN.Artifact} node
+   * @param {object} nodeWithType
    * @param {WeakMap} [resolved] WeakMap containing already resolved refs
    * @param {boolean} [keepLocalized=false] Whether to clone .localized from a type def
-   * @returns {void}
    */
-  function toFinalBaseType(node, resolved, keepLocalized=false) {
-    // Nothing to do if no type (or if array/struct type)
-    if (!node || !node.type) return;
-    // In case of a ref -> Follow the ref
-    if (node.type && node.type.ref) {
-      const finalBaseType = getFinalBaseType(node.type, undefined, resolved);
-      if(finalBaseType === null)
-        throw Error('Failed to obtain final base type for reference : ' + node.type.ref.join('/'));
-      if(finalBaseType.elements) {
-          // This changes the order - to be discussed!
-        node.elements = cloneCsnNonDict(finalBaseType, options).elements; // copy elements
-        delete node.type; // delete the type reference as edm processing does not expect it
-      } else if(finalBaseType.items) {
-          // This changes the order - to be discussed!
-        node.items = cloneCsnNonDict(finalBaseType.items, options); // copy items
-        delete node.type;
-      } else {
-        node.type=finalBaseType;
-      }
+  function toFinalBaseType(nodeWithType, resolved = new WeakMap(), keepLocalized = false) {
+    const type = nodeWithType?.type;
+    if (!type || nodeWithType.elements || nodeWithType.items || resolved.has(nodeWithType)) {
       return;
     }
-    // ..  or builtin already
-    if (node.type && isBuiltinType(node.type)) return;
+    // The caller may use `{ art }` syntax for `{ ref }` objects, but we only use
+    // it to indicate that an artifact has been processed.
+    resolved.set(nodeWithType, nodeWithType);
 
-    // The type might already be a full fledged type def (array of)
-    let typeDef = typeof node.type === 'string' ? getCsnDef(node.type) : node.type;
-    // Nothing to do if type is an array or a struct type
-    if (typeDef.items || typeDef.elements) {
-      // cloneCsn only works correctly if we start "from the top"
-      const cloneTypeDef = cloneCsnNonDict(typeDef, options);
-      // With hdbcds-hdbcds, don't resolve structured types - but propagate ".items", to turn into LargeString later on.
-      if(typeDef.items) {
-        delete node.type;
-        if(!node.items)
-          Object.assign(node, {items: cloneTypeDef.items});
-      }
-      if(typeDef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
-        if(!typeDef.items)
-          delete node.type;
-        if(!node.elements)
-          Object.assign(node, {elements: cloneTypeDef.elements});
-      }
+    // Nothing to copy from builtin.
+    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 = getFinalBaseTypeWithProps(typeRef.type);
+    } else {
+      typeRef = getFinalBaseTypeWithProps(type);
+    }
 
+    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,
+      // if not more (in client style CSN).
+      if (typeRef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
+        nodeWithType.elements = cloneCsnDictionary(typeRef.elements, options);
+        delete nodeWithType.type;
+      }
+      if (typeRef.items) {
+        nodeWithType.items = cloneCsnNonDict(typeRef.items, options);
+        delete nodeWithType.type;
+      }
       return;
     }
-    // if the declared element is an enum, these values are with priority
-    if (!node.enum && typeDef.enum) {
-      const clone = cloneCsnDictionary(typeDef.enum, options);
-      Object.assign(node, { enum: clone });
+
+    if (typeRef.enum && nodeWithType.enum === undefined)
+      nodeWithType.enum = cloneCsnDictionary(typeRef.enum, options);
+
+    // Copy type and type arguments (+ localized)
+
+    for (const param of typeParameters.list) {
+      if (nodeWithType[param] === undefined && typeRef[param] !== undefined &&!typeRef.$default) {
+        nodeWithType[param] = typeRef[param];
+      }
     }
-    if (node.length === undefined && typeDef.length !== undefined)
-      Object.assign(node, { length: typeDef.length });
-    if (node.precision === undefined && typeDef.precision !== undefined)
-      Object.assign(node, { precision: typeDef.precision });
-    if (node.scale === undefined && typeDef.scale !== undefined)
-      Object.assign(node, { scale: typeDef.scale });
-    if (node.srid === undefined && typeDef.srid !== undefined)
-      Object.assign(node, { srid: typeDef.srid });
-    if (keepLocalized && node.localized === undefined && typeDef.localized !== undefined)
-      Object.assign(node, { localized: typeDef.localized });
-    node.type = typeDef.type;
-    toFinalBaseType(node);
+    if (keepLocalized && nodeWithType.localized === undefined && typeRef.localized !== undefined)
+      nodeWithType.localized = typeRef.localized;
+    if (typeRef.type)
+      nodeWithType.type = typeRef.type;
   }
 
   // Return a full projection 'projectionId' of artifact 'art' for exposure in 'service'.

package/lib/transform/translateAssocsToJoins.js

@@ -57,10 +57,10 @@ function translateAssocsToJoins(model, inputOptions = {})
   const options = model.options || inputOptions;
 
   // create JOINs for foreign key paths
-  const noJoinForFK = options.forHana ? !options.forHana.joinfk : true;
+  const noJoinForFK = options.forHana ? !options.joinfk : true;
 
   // Note: This is called from the 'forHana' transformations, so it is controlled by its options)
-  const pathDelimiter = (options.forHana && options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = (options.forHana && options.sqlMapping === 'hdbcds') ? '.' : '_';
 
   forEachDefinition(model, prepareAssociations);
   forEachDefinition(model, transformQueries);
@@ -1818,6 +1818,10 @@ function walkPath(node, env)
   // or that are parameters ($parameters or escaped paths (':')
   //path.length && path[ path.length-1 ]._artifact
   const art = path && path.length && path[path.length-1]._artifact;
+
+  // regardless of the position in the query, ignore paths that have virtual path steps
+  if(art && path.some(ps => ps._artifact && ps._artifact.virtual && ps._artifact.virtual.val))
+    return path;
   if(art && !internalArtifactKinds.includes(art.kind))
   {
     if(env.callback)

package/lib/transform/universalCsn/.eslintrc.json

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

package/lib/transform/universalCsn/coreComputed.js

@@ -12,7 +12,7 @@ const { setAnnotationIfNotDefined } = require('./utils');
  */
 function setCoreComputedOnViews(csn) {
   const {
-    artifactRef, getColumn, getElement,
+    artifactRef, getColumn, getElement, getOrigin,
   } = getUtils(csn, 'init-all');
 
   forEachDefinition(csn, (artifact) => {
@@ -57,7 +57,15 @@ function setCoreComputedOnViews(csn) {
       const column = getColumn(element);
       if (column)
         return column;
-      return getElementFromFrom(name, base.from);
+      const from = getElementFromFrom(name, base.from);
+      if (from)
+        return from;
+      // For .expand/.inline, we can find it via origin
+      // Although I would have expected to find it via getColumn...
+      const origin = getOrigin(element);
+      if (origin)
+        return origin;
+      throw new Error(`Could not find ancestor for ${JSON.stringify(element)} named ${name}`);
     }
 
     /**
@@ -87,10 +95,7 @@ function setCoreComputedOnViews(csn) {
         return getElementFromFrom(name, base.SET.args[0]);
       }
       else if (base.args && base.join) {
-        const result = checkJoinSources(base.args, name);
-        if (!result)
-          throw new Error(`Could not find ${name} in ${JSON.stringify(base.args)}`);
-        return result;
+        return checkJoinSources(base.args, name);
       }
 
       throw new Error(JSON.stringify(base));