@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/transform/forHanaNew.js

@@ -41,9 +41,7 @@ function forEachDefinition(csn, cb) {
  * in HANA CDS style, used by 'toHana', toSql' and 'toRename'.
  * The behavior is controlled by the following options:
  * options = {
- *    forHana.names                               // See the behavior of 'names' in toHana, toSql and toRename
- *    forHana.alwaysResolveDerivedTypes           // Always resolve derived type chains (by default, this is only
- *                                                // done for 'quoted' names). FIXME: Should always be done in general.
+ *    sqlMapping // See the behavior of 'sqlMapping' in toHana, toSql and toRename
  * }
  * The result model will always have 'options.forHana' set, to indicate that these transformations have happened.
  * The following transformations are made:
@@ -69,9 +67,9 @@ function forEachDefinition(csn, cb) {
  * - (110) Actions and functions (bound or unbound) are ignored.
  * - (120) (a) Services become contexts.
  * - (130) (not for to.hdbcds with hdbcds names): Elements having structured types are flattened into
- *         multiple elements (using '_' or '.' as name separator, depending on 'forHana.names').
+ *         multiple elements (using '_' or '.' as name separator, depending on 'sqlMapping').
  * - (140) (not for to.hdbcds with hdbcds names): Managed associations get explicit ON-conditions, with
- *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'forHana.names').
+ *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'sqlMapping').
  * - (150) (a) Elements from inherited (included) entities are copied into the receiving entity
  *         (b) The 'include' property is removed from entities.
  * - (160) Projections become views, with MIXINs for association elements (adding $projection where
@@ -94,7 +92,7 @@ function forEachDefinition(csn, cb) {
  *         (d) Managed association entries in ORDER BY
  * - (240) All artifacts (a), elements, foreign keys, parameters (b) that have a DB representation are annotated
  *         with their database name (as '@cds.persistence.name') according to the naming convention chosen
- *         in 'options.forHana.names'.
+ *         in 'options.sqlMapping'.
  * - (250) Remove name space definitions again (only in forHanaNew). Maybe we can omit inserting namespace definitions
  *         completely (TODO)
  *
@@ -108,17 +106,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /** @type {CSN.Model} */
   let csn = cloneCsnNonDict(inputModel, options);
 
-
-
   checkCSNVersion(csn, options);
 
-  const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = (options.sqlMapping === 'hdbcds') ? '.' : '_';
 
   let message, error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
   let artifactRef, inspectRef, effectiveType, get$combined,
-    getFinalBaseType, // csnUtils (csnRefs)
     addDefaultTypeFacets, expandStructsInExpression; // transformUtils
 
   bindCsnReference();
@@ -130,14 +125,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     bindCsnReference();
   }
 
-  const dialect = options.forHana && options.forHana.dialect || options.toSql && options.toSql.dialect;
+  const dialect = options.sqlDialect;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
     forEachDefinition(csn, handleMixinOnConditions);
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forHana(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, isAspect
   });
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
@@ -222,6 +217,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     flattenStructuredElement,
     flattenStructStepsInRef,
     isAssociationOperand, isDollarSelfOrProjectionOperand,
+    csnUtils,
   } = transformUtils.getTransformers(csn, options, pathDelimiter);
 
   const {
@@ -229,7 +225,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     isAssocOrComposition,
     addStringAnnotationTo,
     cloneWithTransformations,
-  } = getUtils(csn);
+  } = csnUtils;
 
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
@@ -269,10 +265,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // To be done after handleAssociations, since then the foreign keys of the managed assocs
   // are part of the elements
   if (doA2J)
-    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter));
+    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, pathDelimiter));
 
   // Create convenience views for localized entities/views.
-  // To be done after getManagedAssocStepsInOnConditionFinalizer because associations are
+  // To be done after getFKAccessFinalizer because associations are
   // handled and before handleDBChecks which removes the localized attribute.
   // Association elements of localized convenience views do not have hidden properties
   // like $managed set, so we cannot do this earlier on.
@@ -396,6 +392,15 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
             setProp(SET, 'elements', query.SELECT.elements);
         }
       }
+    },
+
+  }
+
+  if(options.sqlDialect === 'postgres') {
+    killers.length = (parent) => {
+      if (parent.type === 'cds.Binary' || parent.type === 'cds.hana.BINARY') {
+        delete parent.length;
+      }
     }
   }
 
@@ -409,8 +414,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   function bindCsnReference(){
     ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
-    ({ artifactRef, inspectRef, effectiveType, getFinalBaseType, get$combined } = getUtils(csn));
     ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    // TODO: Can we use csnUtils of the call above (transformUtils.getTransformers)?
+    ({ artifactRef, inspectRef, effectiveType, get$combined } = getUtils(csn));
   }
 
   function bindCsnReferenceOnly(){
@@ -509,7 +515,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function recursivelyApplyCommon(artifact, artifactName) {
     if (!artifact._ignore) {
       if (artifact.kind !== 'service' && artifact.kind !== 'context')
-        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.forHana.names, csn), artifact);
+        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
         transformCommon(member, memberName, path);
@@ -517,7 +523,7 @@ function transformForHanaWithCsn(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.forHana.names), member);
+          addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
       }, [ 'definitions', artifactName ]);
     }
   }
@@ -543,7 +549,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function transformSelfInBacklinks(artifact, artifactName, dummy, path) {
     // Fixme: For toHana mixins must be transformed, for toSql -d hana
     // mixin elements must be transformed, why can't toSql also use mixins?
-    if(artifact.kind === 'entity' || artifact.query || (options.toHana && options.toHana.names === 'hdbcds' && artifact.kind == 'type'))
+    if(artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
       doit(artifact.elements, path.concat([ 'elements' ]));
     if (artifact.query && artifact.query.SELECT && artifact.query.SELECT.mixin)
       doit(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
@@ -574,7 +580,7 @@ function transformForHanaWithCsn(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.forHana.dialect === 'hana' && member.target && isAssocOrComposition(member.type) && !isBetaEnabled(options, 'assocsWithParams')) {
+      if (options.sqlDialect === 'hana' && member.target && isAssocOrComposition(member.type) && !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)
@@ -617,7 +623,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           sql: 'Table-like entities with parameters are not supported for conversion to SQL',
         });
       }
-      else if (options.forHana.dialect === 'sqlite') { // view with params
+      else if (options.sqlDialect === 'sqlite') { // view with params
         // Allow with plain
         error(null, [ 'definitions', artifactName ], `SQLite does not support entities with parameters`);
       }
@@ -626,8 +632,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           if (pname.match(/\W/g) || pname.match(/^\d/) || pname.match(/^_/)) { // parameter name must be regular SQL identifier
             warning(null, [ 'definitions', artifactName, 'params', pname ], `Expecting regular SQL-Identifier`);
           }
-          else if (options.forHana.names !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
-            warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.forHana.names },
+          else if (options.sqlMapping !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
+            warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.sqlMapping },
                    'Expecting parameter to be uppercase in naming mode $(NAME)');
           }
         }
@@ -1048,7 +1054,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   * @returns {boolean}
   */
   function isMaxParameterLengthRestricted(type) {
-    return !(options.toSql && type === 'cds.String' && (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain'));
+    return !(options.toSql && type === 'cds.String' && (options.sqlDialect === 'sqlite' || options.sqlDialect === 'plain'));
   }
 
   /**

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
   });
 
 
@@ -180,7 +178,7 @@ function transform4odataWithCsn(inputModel, options) {
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
   // since then the foreign keys of the managed assocs are part of the elements
   if(!structuredOData)
-    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, '_'));
+    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, '_'));
 
   // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
   throwWithAnyError();
@@ -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,8 +148,8 @@ 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) || isBuiltinType(csnUtils.getFinalBaseType(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;
@@ -186,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

@@ -10,11 +10,12 @@ const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
 const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
+const { isBetaEnabled } = require('../../base/model.js');
 
 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);
@@ -92,11 +93,16 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
               : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
           : `${serviceName}.${newTypeName}`;
 
-      // as soon as we leave of the anonymous world,
-      // we're no longer in a key def => don't set notNull:true on named types
-      if (!isAnonymous && isKey)
-        isKey = false;
-
+      if (!isAnonymous) {
+        // as soon as we leave of the anonymous world,
+        // we're no longer in a key def => don't set notNull:true on named types
+        if(isKey)
+          isKey = false;
+        // in case this was a named type and if the openess does not match the type definition
+        // expose the type as a new one not changing the original definition.
+        if((!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
+          fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
+      }
       // check if that type is already defined
       let newType = csn.definitions[fullQualifiedNewTypeName];
       if (newType) {
@@ -111,6 +117,9 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
          * Treat items.elements as ordinary elements for now.
          */
         newType = createNewStructType(elements);
+        // if using node enforces open/closed, set it on type
+        if(node['@open'] !== undefined)
+          newType['@open'] = node['@open']
         if (node.$location)
           setProp(newType, '$location', node.$location);
 
@@ -122,7 +131,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 +160,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,
 }