@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/transform/forOdata.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtils');
 const { cloneCsnNonDict,
@@ -24,6 +23,7 @@ const associations = require('./db/associations')
 const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
 
+const { addTenantFields } = require('./addTenantFields');
 const { addLocalizationViews } = require('./localized');
 
 // Transformation for ODATA. Expects a CSN 'inputModel', processes it for ODATA.
@@ -68,23 +68,22 @@ const { addLocalizationViews } = require('./localized');
 //     (Linter check candidate)
 module.exports = { transform4odataWithCsn };
 
-function transform4odataWithCsn(inputModel, options) {
+function transform4odataWithCsn(inputModel, options, messageFunctions) {
   timetrace.start('OData transformation');
 
   // copy the model as we don't want to change the input model
   let csn = cloneCsnNonDict(inputModel, options);
+  messageFunctions.setModel(csn);
 
-  const { message, error, warning, info, throwWithAnyError } = makeMessageFunction(csn, options, 'for.odata');
+  const { message, error, warning, info, throwWithAnyError } = messageFunctions;
   throwWithAnyError();
 
   // the new transformer works only with new CSN
   checkCSNVersion(csn, options);
 
-  const transformers = transformUtils.getTransformers(csn, options, '_');
+  const transformers = transformUtils.getTransformers(csn, options, messageFunctions, '_');
   const {
-    addDefaultTypeFacets,
-    extractValidFromToKeyElement,
-    checkAssignment, checkMultipleAssignments,
+    addDefaultTypeFacets, checkMultipleAssignments,
     recurseElements, setAnnotation, renameAnnotation,
     expandStructsInExpression,
     csnUtils,
@@ -119,6 +118,9 @@ function transform4odataWithCsn(inputModel, options) {
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
 
+  if (options.tenantAsColumn)
+    addTenantFields(csn, options);
+
   const keepLocalizedViews = isDeprecatedEnabled(options, '_createLocalizedViews');
 
   function acceptLocalizedView(_name, parent) {
@@ -132,17 +134,17 @@ function transform4odataWithCsn(inputModel, options) {
   transformUtils.rewriteBuiltinTypeRef(csn);
 
   const cleanup = validate.forOdata(csn, {
-    message, error, warning, info, inspectRef, effectiveType, getFinalTypeInfo, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
+    message, error, warning, info, inspectRef, effectiveType, getFinalTypeInfo, artifactRef,
+    options, csnUtils, services, isAspect, isExternalServiceMember, recurseElements,
+    checkMultipleAssignments, csn,
   });
 
 
   // Throw exception in case of errors
   throwWithAnyError();
 
-  // Semantic checks before flattening regarding temporal data
-  // TODO: Move in the validator
+  // TODO: Refactor out the following logic
   forEachDefinition(csn, [
-    checkTemporalAnnotationsAssignment,
     (def) => {
       // Convert a projection into a query for internal processing will be re-converted
       // at the end of the OData processing
@@ -175,21 +177,20 @@ function transform4odataWithCsn(inputModel, options) {
   // If errors are detected, throwWithAnyError() will return from further processing
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
-  
   if (!structuredOData) {
     expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
 
-    flattening.flattenAllStructStepsInRefs(csn, options, resolved, '_', { skipArtifact: isExternalServiceMember });
+    flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, resolved, '_', { skipArtifact: isExternalServiceMember });
     // No type references exist anymore
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
     // OData doesn't resolve type chains after the first 'items'
-    flattening.resolveTypeReferences(csn, options, resolved, '_',
+    flattening.resolveTypeReferences(csn, options, messageFunctions, resolved, '_',
       { skip: [ 'action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
     // No structured elements exists anymore
-    flattening.flattenElements(csn, options, '_', error,
+    flattening.flattenElements(csn, options, messageFunctions, '_',
       { skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
         skipStandard: { items: true },  // don't drill further into .items
@@ -198,7 +199,7 @@ function transform4odataWithCsn(inputModel, options) {
 
   // TODO: add the generated foreign keys to the columns when we are in a view
   // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
@@ -272,7 +273,7 @@ function transform4odataWithCsn(inputModel, options) {
 
     // Convert a query back into a projection for CSN compliance as
     // the very last conversion step of the OData transformation
-    if (def.kind === 'entity' && def.query && def.query && def.projection) {
+    if (def.kind === 'entity' && def.query && def.projection) {
       delete def.query;
     }
   }, { skipArtifact: isExternalServiceMember })
@@ -288,29 +289,6 @@ function transform4odataWithCsn(inputModel, options) {
   timetrace.stop('OData transformation');
   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 = [];
-    recurseElements(artifact, ['definitions', artifactName], (member, path) => {
-      let [f, t, k] = extractValidFromToKeyElement(member, path);
-      validFrom.push(...f);
-      validTo.push(...t);
-      validKey.push(...k);
-    });
-    // Check that @cds.valid.from/to/key is only in valid places
-    validFrom.forEach(obj => checkAssignment('@cds.valid.from', obj.element, obj.path, artifact));
-    validTo.forEach(obj => checkAssignment('@cds.valid.to', obj.element, obj.path, artifact));
-    validKey.forEach(obj => checkAssignment('@cds.valid.key', obj.element, obj.path, artifact));
-    checkMultipleAssignments(validFrom, '@cds.valid.from', artifact, artifactName);
-    checkMultipleAssignments(validTo, '@cds.valid.to', artifact, artifactName);
-    checkMultipleAssignments(validKey, '@cds.valid.key', artifact, artifactName);
-    if (validKey.length && !(validFrom.length && validTo.length)) {
-      error(null, path, 'Annotation “@cds.valid.key” was used but “@cds.valid.from” and “@cds.valid.to” are missing');
-    }
-  }
-
   // Mark elements that are annotated with @odata.on.insert/update with the annotation @Core.Computed.
   function annotateCoreComputed(node) {
     // If @Core.Computed is explicitly set, don't overwrite it!
@@ -347,7 +325,7 @@ function transform4odataWithCsn(inputModel, options) {
         return;
       // Rename according to map above
       const renamePrefix = (name in renameMappings)
-        ? name 
+        ? name
         : renameShortCuts.find(p => name.startsWith(p + '.'));
       if(renamePrefix) {
         const mapping = renameMappings[renamePrefix];
@@ -442,25 +420,18 @@ function transform4odataWithCsn(inputModel, options) {
     }
   }
 
-  // CDXCORE-481
   // (4.5) If the member is an association whose target has @cds.odata.valuelist annotate it
   // with @Common.ValueList.viaAssociation.
-  /*
-    FIXME (HJB): Comment outdated: Anno propagation to FKs is done in EdmPreprocessor
-  */
-  // This must be done before foreign keys are calculated and the annotations are propagated
-  // to them. This will make sure that association and all its foreign keys are annotated with
-  // Common.ValueList in the final EDM.
-  // Do this only if the association is navigable and the enclosing artifact is
-  // a service member (don't pollute the CSN with unnecessary annotations).
-  // TODO: test???
+  // Do this only if the association is navigable(@odata.navigable) and the enclosing artifact is
+  // a service member (don't pollute the CSN with unnecessary annotations, that is ensured by the caller
+  // of this function).
   function addCommonValueListviaAssociation(member, memberName) {
-    let vlAnno = '@Common.ValueList.viaAssociation';
+    const vlAnno = '@Common.ValueList.viaAssociation';
     if (isAssociation(member)) {
-      let navigable = member['@odata.navigable'] !== false; // navigable disabled only if explicitly set to false
-      let targetDef = getCsnDef(member.target);
+      const navigable = member['@odata.navigable'] !== false; // navigable disabled only if explicitly set to false
+      const targetDef = getCsnDef(member.target);
       if (navigable && targetDef['@cds.odata.valuelist'] && !member[vlAnno]) {
-        member[vlAnno] = { '=': memberName };
+        setAnnotation(member, vlAnno, { '=': memberName });
       }
     }
   }

package/lib/transform/forRelationalDB.js

@@ -6,13 +6,13 @@ const { cloneCsnNonDict,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath, isPersistedOnDatabase
       } = require('../model/csnUtils');
-const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
 const { csnRefs, pathId, traverseQuery, columnAlias} = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
+const { addTenantFields } = require('../transform/addTenantFields');
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
@@ -100,9 +100,9 @@ function forEachDefinition(csn, cb) {
  *
  * @param {CSN.Model}   csn
  * @param {CSN.Options} options
- * @param {string}      moduleName The calling compiler module name, e.g. `to.hdi` or `to.hdbcds`.
+ * @param {object}      messageFunctions Message functions such as `error()`, `info()`, …
  */
-function transformForRelationalDBWithCsn(csn, options, moduleName) {
+function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
 
@@ -111,6 +111,9 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   csn = cloneCsnNonDict(csn, options);
   timetrace.stop('Clone CSN');
 
+  if (options.tenantAsColumn)
+    addTenantFields(csn, options);
+
   checkCSNVersion(csn, options);
 
   const pathDelimiter = (options.sqlMapping === 'hdbcds') ? '.' : '_';
@@ -120,12 +123,11 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   /** @type {object} */
   let csnUtils;
   /** @type {object} */
-  let messageFunctions;
-  let message, error, warning, info; // message functions
+  let message, error, warning; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
   // transformUtils
-  let addDefaultTypeFacets, 
+  let addDefaultTypeFacets,
     expandStructsInExpression,
     flattenStructuredElement,
     flattenStructStepsInRef;
@@ -180,12 +182,13 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
     //       assoc2join eventually rewrites the table aliases
     temporal.getViewDecorator(csn, messageFunctions, csnUtils),
     // check unique constraints - further processing is done in rewriteUniqueConstraints
-    assertUnique.prepare(csn, options, error, info)
+    assertUnique.prepare(csn, options, messageFunctions)
   ]);
 
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
-    expansion.expandStructureReferences(csn, options, pathDelimiter, messageFunctions, csnUtils);
+    // In addition, kill all non-sql-backend relevant annotations
+    expansion.expandStructureReferences(csn, options, pathDelimiter, messageFunctions, csnUtils, { processAnnotations: true });
     bindCsnReference();
   }
 
@@ -203,15 +206,15 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   if(doA2J) {
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
-    flattening.flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter);
+    flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, resolved, pathDelimiter);
     // No type references exist anymore
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
-    flattening.resolveTypeReferences(csn, options, resolved, pathDelimiter);
+    flattening.resolveTypeReferences(csn, options, messageFunctions, resolved, pathDelimiter);
     // No structured elements exists anymore
-    flattening.flattenElements(csn, options, pathDelimiter, error);
+    flattening.flattenElements(csn, options, messageFunctions, pathDelimiter);
   } else {
     // For to.hdbcds with naming mode hdbcds we also need to resolve the types
-    flattening.resolveTypeReferences(csn, options, new WeakMap(), pathDelimiter);
+    flattening.resolveTypeReferences(csn, options, messageFunctions, new WeakMap(), pathDelimiter);
   }
 
   // With flattening errors, it makes little sense to continue.
@@ -284,7 +287,7 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   ]);
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
-  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
+  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
 
   doA2J && forEachDefinition(csn, flattenIndexes);
   // Managed associations get an on-condition - in views and entities
@@ -357,6 +360,9 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   // Associations that point to things marked with @cds.persistence.skip are removed
   forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, messageFunctions, csnUtils));
 
+  // some errors can't be handled in the subsequent processing steps for e.g. HDBCDS
+  messageFunctions.throwWithError();
+
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
@@ -448,15 +454,15 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    messageFunctions = makeMessageFunction(csn, options, moduleName);
-    ({ error, warning, info, message, throwWithAnyError } = messageFunctions);
+    messageFunctions.setModel(csn);
+    ({ error, warning, message, throwWithAnyError } = messageFunctions);
 
     ({ flattenStructuredElement,
       flattenStructStepsInRef,
       addDefaultTypeFacets,
       expandStructsInExpression,
       csnUtils
-    } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter));
   }
 
   function bindCsnReferenceOnly(){
@@ -613,10 +619,10 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
       // (100 a) Ignore the property 'masked' itself (but not its effect on projections)
       if (member.masked)
         delete member.masked;
-      // For HANA: Report an error on
+      // Report an error on
       // - view with parameters that has an element of type association/composition
       // - association that points to entity with parameters
-      if (options.sqlDialect === 'hana' && member.target && csnUtils.isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
+      if (member.target && csnUtils.isAssocOrComposition(member) && !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)
@@ -861,6 +867,20 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
             checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
             break;
           }
+          case 'cds.Vector': {
+            if (options.sqlDialect !== 'hana') {
+              error('ref-unsupported-type', path, {
+                '#': 'hana', type: node.type, value: 'hana',
+                othervalue: options.sqlDialect
+              });
+            }
+            else if (options.transformation === 'hdbcds') {
+              error('ref-unsupported-type', path, {
+                '#': 'hdbcds', type: node.type, value: options.sqlDialect
+              });
+            }
+            break;
+          }
         }
       }
 

package/lib/transform/odata/toFinalBaseType.js

@@ -7,7 +7,7 @@ const {
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
-function expandToFinalBaseType(csn, transformers, csnUtils, services, options, isExternalServiceMember) {
+function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
   const isV4 = options.odataVersion === 'v4';
   const special$self = !csn?.definitions?.$self && '$self';
   forEachDefinition(csn, (def, defName) => {
@@ -63,7 +63,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     if (def.kind === 'type' && def.items && isArtifactInSomeService(defName, services)) {
       expandFirstLevelOfArrayed(def);
     }
-  }, { skipArtifact: isExternalServiceMember });
+  });
 
   if(isBetaEnabled(options, 'odataTerms')) {
     forEachGeneric(csn, 'vocabularies', (def, defName) => {
@@ -75,7 +75,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
 
       expandToFinalBaseType(def, defName);
       expandToFinalBaseType(def.items, defName);
-    }, [], { skipArtifact: isExternalServiceMember });
+    }, []);
   }
   // In case we have in the model something like:
   // type Foo: array of Bar; type Bar: { qux: Integer };

package/lib/transform/odata/typesExposure.js

@@ -6,11 +6,11 @@
  * @module typesExposure
  */
 
-const { setProp } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
-const { copyAnnotations, getNamespace } = require('../../model/csnUtils');
-const { isBetaEnabled } = require('../../base/model.js');
+const { getNamespace, copyAnnotations, cloneCsnNonDict,
+  isBuiltinType, isAnnotationExpression, 
+  forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
 const { CompilerAssertion } = require('../../base/error');
 
 /**
@@ -219,7 +219,16 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
               }
             }
           });
-          copyAnnotations(typeDef, newType);
+
+          // expression annos and their sub annotations are not propagated to type
+          let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
+            if (pn[0] === '@')
+              acc[isAnnotationExpression(typeDef[pn]) ? 0 : 1].push(pn);
+            return acc;
+          }, [ [], [] ]);
+          nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));
+          copyAnnotations(typeDef, newType, false, {}, nxprANames);
+
           // if the origin type had items, add items to exposed type
           if(typeDef.kind === 'type') {
             if(typeDef.items) {

package/lib/transform/transformUtils.js

@@ -4,7 +4,6 @@
 // different backends.
 // The sibling of model/transform/TransformUtil.js which works with compacted new CSN.
 
-const { makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 
 const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand } = require('../model/csnUtils');
@@ -20,8 +19,8 @@ const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOpe
 // 'model' is compacted new style CSN
 // TODO: Error and warnings handling with compacted CSN? - currently just throw new ModelError for everything
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
-function getTransformers(model, options, pathDelimiter = '_') {
-  const { message, error, warning, info } = makeMessageFunction(model, options);
+function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
+  const { message, error, warning, info } = msgFunctions;
   const csnUtils = getUtils(model);
   const {
     getCsnDef,
@@ -321,48 +320,62 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
    * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
+   * @param {bool} [refParentIsItems] relative ref has an items root (suspend flattening by caller)
    * @returns {string[]}
    */
-  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap()) {
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), refParentIsItems=false) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
       return ref;
     }
 
-    return flatten(ref, path);
+    const result = scope === '$self' ? [ref[0]] : [];
+    //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
+    if(!links && !scope) { // calculate JIT if not supplied
+      const res = inspectRef(path);
+      links = res.links;
+      scope = res.scope;
+    }
+    if (scope === '$magic')
+      return ref;
 
-    function flatten(ref, path) {
-      let result = scope === '$self' ? [ref[0]] : [];
-      //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
-      if(!links && !scope) { // calculate JIT if not supplied
-        const res = inspectRef(path);
-        links = res.links;
-        scope = res.scope;
-      }
-      if (scope === '$magic')
-        return ref;
-      // Don't process a leading $self - it will a .art with .elements!
-      const startIndex = scope === '$self' ? 1 : 0;
-      let flattenStep = false;
-      for(let i = startIndex; i < links.length; i++) {
-        const value = links[i];
-        if (flattenStep) {
-          result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
-          // if we had a filter or args, we had an assoc so this step is done
-          // we then keep along the filter/args by updating the id of the current ref
-          if(ref[i].id) {
-            ref[i].id = result[result.length-1];
-            result[result.length-1] = ref[i];
-          }
-        }
-        else {
-          result.push(ref[i]);
+    // Don't process a leading $self - it will a .art with .elements!
+    let i = scope === '$self' ? 1 : 0;
+  
+    // read property from resolved path link
+    const art = (propName) =>
+    (links[i].art?.[propName] ||
+     effectiveType(links[i].art)[propName] ||
+     (resolvedLinkTypes.get(links[i])||{})[propName]);
+  
+    let flattenStep = false;
+    let nextIsItems = !!art('items') || (refParentIsItems && i === 0);
+    for(; i < links.length; i++) {
+
+      if (flattenStep && !nextIsItems) {
+        result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
+        // if we had a filter or args, we had an assoc so this step is done
+        // we then keep along the filter/args by updating the id of the current ref
+        if(ref[i].id) {
+          ref[i].id = result[result.length-1];
+          result[result.length-1] = ref[i];
         }
-        flattenStep = value.art && !value.art.kind && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements || (resolvedLinkTypes.get(value)||{}).elements);
+        // suspend flattening if the next path step has some 'items'
+        nextIsItems = !!art('items');
       }
-
-      return result;
+      else {
+        result.push(ref[i]);
+      }
+      // revoke items suspension for next assoc step
+      if(nextIsItems && art('target'))
+        nextIsItems = false;
+
+      flattenStep = !links[i].art?.kind && 
+        !links[i].art?.SELECT &&
+        !links[i].art?.from &&
+        art('elements');
     }
+    return result;
   }
 
   /**