@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/transform/forOdataNew.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const { handleMessages, makeMessageFunction } = require('../base/messages');
-const { isDeprecatedEnabled } = require('../base/model');
+const { makeMessageFunction } = require('../base/messages');
+const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtilsNew');
 const { getUtils,
         cloneCsn,
@@ -24,8 +24,9 @@ const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssoci
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const timetrace = require('../utils/timetrace');
 const { attachPath } = require('./odata/attachPath');
+const enrichUniversalCsn = require('./universalCsnEnricher');
 
-const { addLocalizationViews, hasLocalizedConvenienceView, isInLocalizedNamespace } = require('./localized');
+const { addLocalizationViews } = require('./localized');
 
 // Transformation for ODATA. Expects a CSN 'inputModel', processes it for ODATA.
 // The result should be suitable for consumption by EDMX processors (annotations and metadata)
@@ -77,15 +78,6 @@ function transform4odataWithCsn(inputModel, options) {
   const { error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
   throwWithError();
 
-  addLocalizationViews(csn, options);
-  const keepLocalizedViews = isDeprecatedEnabled(options, 'createLocalizedViews');
-  forEachDefinition(csn, (artifact, artifactName) => {
-    if (hasLocalizedConvenienceView(csn, artifactName))
-      artifact.$localized = true;
-    else if (!keepLocalizedViews && isInLocalizedNamespace(artifactName))
-      delete csn.definitions[artifactName];
-  });
-
   // the new transformer works only with new CSN
   checkCSNVersion(csn, options);
 
@@ -98,8 +90,8 @@ function transform4odataWithCsn(inputModel, options) {
     addElement, createAction, assignAction,
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
-    recurseElements, setAnnotation, renameAnnotation,
-    expandStructsInOnConditions
+    recurseElements, setAnnotation, resetAnnotation, renameAnnotation,
+    expandStructsInExpression
   } = transformers;
 
   const csnUtils = getUtils(csn);
@@ -107,7 +99,7 @@ function transform4odataWithCsn(inputModel, options) {
     getCsnDef,
     getFinalType,
     getServiceName,
-    hasBoolAnnotation,
+    hasAnnotationValue,
     isAssocOrComposition,
     isAssociation,
     isStructured,
@@ -122,15 +114,31 @@ function transform4odataWithCsn(inputModel, options) {
 
   // 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
-  let services = getServiceNames(csn);
+  const services = getServiceNames(csn);
+  // @ts-ignore
+  const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external']);
+  // @ts-ignore
+  const isExternalServiceMember = (_art, name) => externalServices.includes(getServiceName(name));
+
+  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
+    enrichUniversalCsn(csn, options);
+
+  const keepLocalizedViews = isDeprecatedEnabled(options, 'createLocalizedViews');
+
+  function acceptLocalizedView(_name, parent) {
+    csn.definitions[parent].$localized = true;
+    return keepLocalizedViews && !isExternalServiceMember(undefined, parent);
+  }
+
+  addLocalizationViews(csn, options, acceptLocalizedView);
 
   validate.forOdata(csn, {
-    error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect
+    error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
   });
 
 
   // Throw exception in case of errors
-  handleMessages(csn, options);
+  throwWithError();
 
   // Semantic checks before flattening regarding temporal data
   // TODO: Move in the validator
@@ -143,16 +151,17 @@ function transform4odataWithCsn(inputModel, options) {
       if (def.kind === 'entity' && def.projection) {
         def.query = { SELECT: def.projection };
       }
-    }]
+    }],
+    { skipArtifact: isExternalServiceMember }
   );
 
-  expandToFinalBaseType(csn, transformers, csnUtils, services, options);
+  expandToFinalBaseType(csn, transformers, csnUtils, services, options, isExternalServiceMember);
 
-  // Check if structured elements and managed associations are compared in an ON condition
+  // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
-  // subsequent procession steps (especially a2j) to see plain paths in ON conditions.
-  // If errors are detected, handleMessages will return from further processing
-  forEachDefinition(csn, expandStructsInOnConditions);
+  // subsequent procession steps (especially a2j) to see plain paths in expressions.
+  // If errors are detected, throwWithError() will return from further processing
+  expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
   // handles reference flattening
   let referenceFlattener = new ReferenceFlattener();
@@ -163,28 +172,29 @@ function transform4odataWithCsn(inputModel, options) {
 
   if (!structuredOData) {
     // flatten structures
-    flattenCSN(csn, csnUtils, options, referenceFlattener, error);
+    // @ts-ignore
+    flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExternalServiceMember);
     // flatten references
     referenceFlattener.flattenAllReferences(csn);
   }
 
   // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
-  handleMessages(inputModel, options);
+  throwWithError();
 
   // Process associations
   // 1. In case we generate flat mode, expand the structured foreign keys.
   // This logic rewrites the 'ref' for such keys with the corresponding flattened
   // elements.
   if (!structuredOData)
-    expandStructKeysInAssociations(csn, referenceFlattener, csnUtils);
+    expandStructKeysInAssociations(csn, referenceFlattener, csnUtils, isExternalServiceMember);
   // 2. generate foreign keys for managed associations
-  generateForeignKeys(csn, options, referenceFlattener, csnUtils, error);
+  generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
 
   // Apply default type facets as set by options
   // Flatten on-conditions in unmanaged associations
   // This must be done before all the draft logic as all
   // composition targets are annotated with @odata.draft.enabled in this step
-  forEachDefinition(csn, [ setDefaultTypeFacets, processOnCond ]);
+  forEachDefinition(csn, [ setDefaultTypeFacets, processOnCond ], { skipArtifact: isExternalServiceMember });
 
   // Now all artificially generated things are in place
   // - Generate artificial draft fields if requested
@@ -201,17 +211,13 @@ function transform4odataWithCsn(inputModel, options) {
       // Generate artificial draft fields if requested
       if (def['@odata.draft.enabled']) {
         // Ignore if not part of a service
-        if (!isArtifactInSomeService(defName, services)) {
-          warning(null, ['definitions', defName], { art: defName },
-            'Ignoring annotation “@odata.draft.enabled” because artifact $(ART) is not part of a service');
-        }
-        else {
+        if (isArtifactInSomeService(defName, services)) {
           generateDraftForOdata(def, defName, def, visitedArtifacts);
         }
       }
     }
     visitedArtifacts[defName] = true;
-  });
+  }, { skipArtifact: isExternalServiceMember });
 
   // Deal with all kind of annotations manipulations here
   forEachDefinition(csn, (def, defName) => {
@@ -223,16 +229,13 @@ function transform4odataWithCsn(inputModel, options) {
     if (options.toOdata.names && !['service', 'context', 'namespace', 'annotation', 'action', 'function'].includes(def.kind))
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.toOdata.names, csn);
 
-    forEachMemberRecursively(def, (member, memberName, propertyName) => {
+    forEachMemberRecursively(def, (member, memberName, propertyName, path) => {
       // 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' && !['action', 'function'].includes(member.kind) && 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
-        if (member._flatElementNameWithDots) {
-          memberName = member._flatElementNameWithDots;
-        }
-        member['@cds.persistence.name'] = getElementDatabaseNameOf(memberName, options.toOdata.names);
+        member['@cds.persistence.name'] = getElementDatabaseNameOf(referenceFlattener.getElementNameWithDots(path) || memberName, options.toOdata.names);
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -244,6 +247,7 @@ function transform4odataWithCsn(inputModel, options) {
       // - If the association target is annotated with @cds.odata.valuelist, annotate the
       //      association with @Common.ValueList.viaAssociation
       // - Check for @Analytics.Measure and @Aggregation.default
+      // @ts-ignore
       if (isArtifactInSomeService(defName, services) || isLocalizedArtifactInService(defName, services)) {
         // If the member is an association and the target is annotated with @cds.odata.valuelist,
         // annotate the association with @Common.ValueList.viaAssociation (but only for service member artifacts
@@ -258,16 +262,17 @@ function transform4odataWithCsn(inputModel, options) {
     if (def.kind === 'entity' && def.query && def.query && def.projection) {
       delete def.query;
     }
-  })
+  }, { skipArtifact: isExternalServiceMember })
 
   // Throw exception in case of errors
-  handleMessages(csn, options);
+  throwWithError();
 
   if (options.testMode) csn = cloneCsn(csn, options);   // sort, keep hidden properties
   timetrace.stop();
   return csn;
 
   // TODO: Move this to checks?
+  // @ts-ignore
   function checkTemporalAnnotationsAssignment(artifact, artifactName, propertyName, path) {
     // Gather all element names with @cds.valid.from/to/key
     let validFrom = [], validTo = [], validKey = [];
@@ -325,7 +330,7 @@ function transform4odataWithCsn(inputModel, options) {
         renameAnnotation(node, name, '@UI.Importance');
         let annotation = node['@UI.Importance'];
         if (annotation !== null)
-          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' }
+          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' };
       }
 
       // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
@@ -404,6 +409,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) {
         removeLeadingDollarSelfInOnCondition(member);
       }
@@ -430,6 +436,7 @@ function transform4odataWithCsn(inputModel, options) {
   // Draft Node: Must not be reachable from multiple draft roots
   function generateDraftForOdata(artifact, artifactName, rootArtifact, visitedArtifacts) {
     // Sanity check
+    // @ts-ignore
     if (!isArtifactInSomeService(artifactName, services)) {
       throw new Error('Expecting artifact to be part of a service: ' + JSON.stringify(artifact));
     }
@@ -440,9 +447,11 @@ function transform4odataWithCsn(inputModel, options) {
     }
 
     // Generate the DraftAdministrativeData projection into the service, unless there is already one
+    // @ts-ignore
     let draftAdminDataProjectionName = `${getServiceOfArtifact(artifactName, services)}.DraftAdministrativeData`;
     let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
     if (!draftAdminDataProjection) {
+      // @ts-ignore
       draftAdminDataProjection = createAndAddDraftAdminDataProjection(getServiceOfArtifact(artifactName, services));
     }
     // Report an error if it is not an entity or not what we expect
@@ -452,11 +461,11 @@ function transform4odataWithCsn(inputModel, options) {
     }
     // Generate the annotations describing the draft actions (only draft roots can be activated/edited)
     if (artifact == rootArtifact) {
-      artifact['@Common.DraftRoot.ActivationAction'] = 'draftActivate';
-      artifact['@Common.DraftRoot.EditAction'] = 'draftEdit';
-      artifact['@Common.DraftRoot.PreparationAction'] = 'draftPrepare';
+      resetAnnotation(artifact, '@Common.DraftRoot.ActivationAction', 'draftActivate', info, ['definitions', draftAdminDataProjectionName]);
+      resetAnnotation(artifact, '@Common.DraftRoot.EditAction', 'draftEdit', info, ['definitions', draftAdminDataProjectionName]);
+      resetAnnotation(artifact, '@Common.DraftRoot.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
     } else {
-      artifact['@Common.DraftNode.PreparationAction'] = 'draftPrepare';
+      resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
     }
 
     artifact.elements && Object.values(artifact.elements).forEach( elem => {
@@ -524,17 +533,12 @@ function transform4odataWithCsn(inputModel, options) {
 
         // Ignore if that is our own draft root
         if (draftNode != rootArtifact) {
-          // Barf if the draft node has @odata.draft.enabled itself
-          if (hasBoolAnnotation(draftNode, '@odata.draft.enabled', true)) {
+          // Report error when the draft node has @odata.draft.enabled itself
+          if (hasAnnotationValue(draftNode, '@odata.draft.enabled', true)) {
             error(null, ['definitions', artifactName, 'elements', elemName], 'Composition in draft-enabled entity can\'t lead to another entity with “@odata.draft.enabled”');
           }
-          // Ignore composition if not part of a service
-          else if (!getServiceName(elem.target)) {
-            warning(null, ['definitions', artifactName, 'elements', elemName], { target: elem.target },
-            'Ignoring draft node for composition target $(TARGET) because it is not part of a service');
-            return;
-          }
-          else if (hasBoolAnnotation(draftNode, '@odata.draft.enabled', false)) {
+          // Ignore composition if not part of a service or explicitly draft disabled
+          else if (!getServiceName(elem.target) || hasAnnotationValue(draftNode, '@odata.draft.enabled', false)) {
             return;
           }
           else {

package/lib/transform/localized.js

@@ -3,14 +3,16 @@
 const { makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 const { hasErrors } = require('../base/messages');
-const { cloneCsnDictionary } = require('../json/to-csn');
+const { cloneCsnDictionary } = require('../model/csnUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
+const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
 const {
   cloneCsn,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
   sortCsnDefinitionsForTests,
+  getUtils,
 } = require('../model/csnUtils');
 
 /**
@@ -34,6 +36,13 @@ const _isViewForEntity = Symbol('_isViewForEntity'); // $inferred = 'LOCALIZED-H
  */
 const _targetFor = Symbol('_targetFor');
 
+/**
+ * Callback function returning `true` if the localization view should be created.
+ * @callback acceptLocalizedView
+ * @param {string} viewName localization view name
+ * @param {string} originalName Artifact name of the original view
+ */
+
 /**
  * Create transitive localized convenience views
  *
@@ -60,8 +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
  */
-function _addLocalizationViews(csn, options, useJoins) {
+function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = null) {
   // Don't try to create convenience views with errors.
   if (hasErrors(options.messages))
     return csn;
@@ -69,7 +79,7 @@ function _addLocalizationViews(csn, options, useJoins) {
   if (hasExistingLocalizationViews(csn, options))
     return csn;
 
-  const { info } = makeMessageFunction(csn, options);
+  const { info, error } = makeMessageFunction(csn, options);
 
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
@@ -77,7 +87,16 @@ function _addLocalizationViews(csn, options, useJoins) {
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
 
-  forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
+  forEachDefinition(csn, (definition, artName, prop, path) => {
+    cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor)
+    if(definition.query) {
+      // reject managed association and structure publishing for to-hdbcds.hdbcds
+      const that = { csnUtils: getUtils(csn), options, error };
+      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
+    }
+  });
+
+
 
   sortCsnDefinitionsForTests(csn, options);
   return csn;
@@ -125,10 +144,16 @@ function _addLocalizationViews(csn, options, useJoins) {
 
     art[_hasLocalizedView] = viewName;
 
+    if(acceptLocalizedView && !acceptLocalizedView(viewName, artName))
+      return;
+
+    let view;
     if (art.query || art.projection)
-      csn.definitions[viewName] = createLocalizedViewForView(art);
+      view = createLocalizedViewForView(art);
     else
-      csn.definitions[viewName] = createLocalizedViewForEntity(art, artName, textElements);
+      view = createLocalizedViewForEntity(art, artName, textElements);
+
+    csn.definitions[viewName] = view;
 
     copyPersistenceAnnotations(csn.definitions[viewName], art);
   }
@@ -157,7 +182,7 @@ function _addLocalizationViews(csn, options, useJoins) {
           columns,
         },
       },
-      elements: cloneCsnDictionary(entity.elements, false, options),
+      elements: cloneCsnDictionary(entity.elements, options),
       [_isViewForEntity]: true,
     };
     copyLocation(convenienceView, entity);
@@ -187,13 +212,13 @@ function _addLocalizationViews(csn, options, useJoins) {
 
     function createFromClauseForEntity() {
       if (!shouldUseJoin) {
-        return createColumnRef( [ entityName ], 'L', false );
+        return createColumnRef( [ entityName ], 'L');
       }
 
       const from = {
         join: 'left',
         args: [
-          createColumnRef( [ entityName ], 'L_0', false ),
+          createColumnRef( [ entityName ], 'L_0'),
           createColumnRef( [ textsEntityName(entityName) ], 'localized_1' ),
         ],
         on: []
@@ -236,7 +261,7 @@ function _addLocalizationViews(csn, options, useJoins) {
     else if (view.projection)
       convenienceView.projection = cloneCsn(view.projection, options);
 
-    convenienceView.elements = cloneCsnDictionary(view.elements, false, options);
+    convenienceView.elements = cloneCsnDictionary(view.elements, options);
     convenienceView[_isViewForView] = true;
     copyLocation(convenienceView, view);
 
@@ -245,7 +270,7 @@ function _addLocalizationViews(csn, options, useJoins) {
     });
 
     if (view.params)
-      convenienceView.params = cloneCsnDictionary(view.params, false, options);
+      convenienceView.params = cloneCsnDictionary(view.params, options);
 
     return convenienceView;
   }
@@ -336,7 +361,7 @@ function _addLocalizationViews(csn, options, useJoins) {
 
     if (!isEntityPreprocessed( art )) {
       info( null, artPath, { name: artName },
-             `Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements` );
+             'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements' );
       return null;
     }
 
@@ -345,13 +370,13 @@ function _addLocalizationViews(csn, options, useJoins) {
 
     if (!textsEntity) {
       info( null, artPath, { name: artName },
-             `Skipped creation of convenience view for $(NAME) because its texts entity could not be found` );
+             'Skipped creation of convenience view for $(NAME) because its texts entity could not be found' );
       return null;
     }
 
     if (!isValidTextsEntity( textsEntity )) {
       info( null, [ 'definitions', textsName ], { name: artName },
-             `Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid` );
+             'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid' );
       return null;
     }
 
@@ -587,9 +612,10 @@ function _addLocalizationViews(csn, options, useJoins) {
  *
  * @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
  */
-function addLocalizationViews(csn, options) {
-  return _addLocalizationViews(csn, options, false);
+function addLocalizationViews(csn, options, acceptLocalizedView = null) {
+  return _addLocalizationViews(csn, options, false, acceptLocalizedView);
 }
 
 /**
@@ -599,21 +625,19 @@ function addLocalizationViews(csn, options) {
  *
  * @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
  */
-function addLocalizationViewsWithJoins(csn, options) {
-  return _addLocalizationViews(csn, options, true);
+function addLocalizationViewsWithJoins(csn, options, acceptLocalizedView = null) {
+  return _addLocalizationViews(csn, options, true, acceptLocalizedView);
 }
 
 /**
  * @param {string[]} ref Reference path
  * @param {string} [as] Alias for path.
- * @param {boolean} [withEnv=true] If true, add `$env:1`
  * @return {CSN.Column}
  */
-function createColumnRef(ref, as = null, withEnv = true) {
+function createColumnRef(ref, as = null) {
   const column = { ref };
-  if (withEnv)
-    setProp(column, '$env', 1);
   if (as)
     column.as = as;
   // @ts-ignore
@@ -634,9 +658,7 @@ function columnsForEntityWithExcludeList(entity, entityName, excludeList) {
   return Object.keys(entity.elements)
     .filter(elementName => !excludeList.includes(elementName))
     .map(elementName => {
-      const column = { ref: [ entityName, elementName ] }
-      setProp(column, '$env', 1);
-      return column;
+      return { ref: [ entityName, elementName ] };
     });
 }
 
@@ -664,7 +686,7 @@ function copyPersistenceAnnotations(target, source) {
       // 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.startsWith('@cds.persistence.skip'))
+      if (anno === '@cds.persistence.skip')
         target[anno] = source[anno];
     });
 }

package/lib/transform/odata/attachPath.js

@@ -24,6 +24,8 @@ const structuralNodeHandlers = {
   groupBy: traverseArray,
   having: traverseArray,
   xpr: traverseArray,
+  expand: traverseArray,
+  inline: traverseArray,
 }
 
 function attachPath(csn) {
@@ -38,6 +40,7 @@ function attachPathOnPartialCSN(csnPart, pathPrefix) {
 }
 
 function traverseRef(obj, path) {
+  if(!obj) return;
   setPath(obj, path);
   traverseArray(obj, path);
 }
@@ -48,7 +51,7 @@ function traverseArray(obj, path) {
 }
 
 function traverseDict(obj, path) {
-  if(typeof obj !== 'object') return;
+  if(!obj || typeof obj !== 'object') return;
   forAllEnumerableProperties(obj, name => {
     const ipath = path.concat(name);
     setPath(obj[name], ipath);
@@ -56,17 +59,29 @@ function traverseDict(obj, path) {
   })
 }
 
+function traverseDictArray(obj, path) {
+  if(!obj || typeof obj !== 'object') return;
+  forAllEnumerableProperties(obj, name => {
+    const ipath = path.concat(name);
+    setPath(obj[name], ipath);
+    traverseArray(obj[name], ipath);
+  })
+}
+
 function traverseTyped(obj, path) {
-  if(!obj) return;
+  if(!obj || typeof obj !== 'object') return;
   forAllEnumerableProperties(obj, name => {
     if(name[0]==='@') return; // skip annotations
     const func = structuralNodeHandlers[name];
-    if(func) func(obj[name], path.concat(name));
+    if(func)
+      func(obj[name], path.concat(name));
+    else if(path[path.length-2] === 'columns')
+      traverseDictArray(obj[name], path.concat(name)); // for columns
   })
 }
 
 function setPath(obj, path) {
-  if(typeof obj !== 'object') return;
+  if(!obj || typeof obj !== 'object') return;
   if(path.length>0)
     Object.defineProperty( obj, '$path', { value: path, configurable: true, writable: true, enumerable: false } );
 }

package/lib/transform/odata/expandStructKeysInAssociations.js

@@ -17,13 +17,13 @@ const { attachPath, attachPathOnPartialCSN } = require('./attachPath');
  * }
  * after expand -> keys:[ { ref: ['stru_subid'] } ]
  */
-module.exports = function (csn, referenceFlattener, csnUtils) {
+module.exports = function (csn, referenceFlattener, csnUtils, isExternalServiceMember) {
 
   forEachManagedAssociation(csn, (element) => {
     if (element.keys) {
       expandStructuredKeysForAssociation(element, referenceFlattener);
     }
-  });
+  }, isExternalServiceMember);
 
   // update paths and resolve references
   attachPath(csn);

package/lib/transform/odata/generateForeignKeyElements.js

@@ -18,13 +18,13 @@ const { implicitAs } = require('../../model/csnRefs');
  * @param {*} csnUtils
  * @param {object} error;
  */
-module.exports = function (csn, options, referenceFlattener, csnUtils, error) {
+module.exports = function (csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember) {
 
   const structuredOData = options.toOdata.odataFormat === 'structured' && options.toOdata.version === 'v4';
   const flatKeys = !structuredOData || (structuredOData && options.toOdata.odataForeignKeys);
 
   // sort all associations by their dependencies
-  const sortedAssociations = sortByAssociationDependency(csn, referenceFlattener);
+  const sortedAssociations = sortByAssociationDependency(csn, referenceFlattener, isExternalServiceMember);
 
   // generate foreign keys
   processSortedAssociations(sortedAssociations, flatKeys);
@@ -35,7 +35,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error) {
     let generatedForeignKeyNamesForPath = Object.create(null); // map<path,[key-name]>
 
     sortedAssociations.forEach(item => {
-      const { definitionName, elementName, element, parent, path } = item;
+      const { definitionName, structuralNodeName, elementName, element, parent, path } = item;
 
       if (csnUtils.isManagedAssociationElement(element) && element.keys) {
         if (flatKeys) // tackling the ref value in assoc.keys
@@ -44,7 +44,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error) {
         fixCardinality(element);
       }
 
-      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, elementName, element, parent, path);
+      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, structuralNodeName, elementName, element, parent, path);
       generatedForeignKeyNamesForPath[item.path.join('/')] = arrayOfGeneratedForeignKeyNames;
     })
 
@@ -111,7 +111,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error) {
   /**
    * Generates foreign keys and returns their names as an array
    */
-  function generateForeignKeys(definitionName, assocName, assoc, parent, path) {
+  function generateForeignKeys(definitionName, structuralNodeName, assocName, assoc, parent, path) {
     let foreignKeyElements = Object.create(null);
 
     // First, loop over the keys array of the association and generate the FKs.
@@ -134,13 +134,14 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error) {
     if (parent.returns)
       parent = parent.returns.items || parent.returns;
 
-    let currElementsNames = Object.keys(parent.elements);
+    const dictionary = parent[structuralNodeName];
+    let currElementsNames = Object.keys(parent[structuralNodeName]);
     for (const [foreignKeyName, foreignKey] of Object.entries(foreignKeyElements)) {
       copyAnnotations(assoc, foreignKey, true);
       // Insert artificial element into artifact, with all cross-links
-      if (parent.elements[foreignKeyName]) {
-        if (!(parent.elements[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(parent.elements[foreignKeyName], foreignKey))) {
-          const path = parent.elements[foreignKeyName].$path;
+      if (dictionary[foreignKeyName]) {
+        if (!(dictionary[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(dictionary[foreignKeyName], foreignKey))) {
+          const path = dictionary[foreignKeyName].$path;
           error(null, path, { name: foreignKeyName, art: assocName }, 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
         }
       }
@@ -151,8 +152,8 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error) {
     // if (flatKeys)
     currElementsNames.splice(assocIndex + 1, 0, ...Object.keys(foreignKeyElements));
 
-    parent.elements = currElementsNames.reduce((previous, name) => {
-      previous[name] = parent.elements[name] || foreignKeyElements[name];
+    parent[structuralNodeName] = currElementsNames.reduce((previous, name) => {
+      previous[name] = dictionary[name] || foreignKeyElements[name];
       return previous;
     }, Object.create(null));
 
@@ -180,7 +181,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error) {
 
     function processStucturedKey(fkArtifact, assocName, foreignKeyRef) {
       const subStruct = fkArtifact.elements ? fkArtifact : csnUtils.getFinalBaseType(fkArtifact.type);
-      const flatElements = flattenStructure(subStruct, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
+      const flatElements = flattenStructure(subStruct.elements, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
       for (const [flatElemName, flatElem] of Object.entries(flatElements)) {
         const foreignKeyElementName =
           `${assocName.replace(/\./g, '_')}_${foreignKeyRef.as ? flatElemName.replace(implicitAs(foreignKeyRef.ref), foreignKeyRef.as) : flatElemName}`;