@sap/cds-compiler 4.6.2 → 4.7.4

package/lib/transform/db/backlinks.js

@@ -1,12 +1,13 @@
 'use strict';
 
 const {
-  cloneCsnNonDict, applyTransformationsOnNonDictionary, isAssociationOperand, isDollarSelfOrProjectionOperand,
+  applyTransformationsOnNonDictionary, isAssociationOperand, isDollarSelfOrProjectionOperand,
 } = require('../../model/csnUtils');
 
 const { setProp } = require('../../base/model');
 const { ModelError } = require('../../base/error');
 const { forEach } = require('../../utils/objectUtils');
+const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 /**
  * Get a function that transforms $self backlinks

package/lib/transform/db/constraints.js

@@ -2,7 +2,6 @@
 
 const { forEachDefinition } = require('../../base/model');
 const { applyTransformations, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
-const { csnRefs } = require('../../model/csnRefs');
 const { forEach, forEachKey } = require('../../utils/objectUtils');
 const { CompilerAssertion } = require('../../base/error');
 
@@ -16,6 +15,7 @@ const ASSOCIATION = 'cds.Association';
  * @param {CSN.Options} options are used to modify the validate / enforced flag on the constraints
  */
 function createReferentialConstraints( csn, options ) {
+  const isTenant = options.tenantDiscriminator === true;
   let validated = true;
   let enforced = true;
   if (options.integrityNotValidated)
@@ -24,14 +24,13 @@ function createReferentialConstraints( csn, options ) {
   if (options.integrityNotEnforced)
     enforced = false;
 
-  const { inspectRef } = csnRefs(csn);
   // prepare the functions with the compositions and associations across all entities first
   // and execute it afterwards.
   // compositions must be processed first, as the <up_> links for them must result in `ON DELETE CASCADE`
   const compositions = [];
   const associations = [];
   applyTransformations(csn, {
-    elements: (parent, prop, elements, path) => {
+    elements: (art, prop, elements, path) => {
       // Step I: iterate compositions, enrich dependent keys for <up_> association in target entity of composition
       for (const elementName in elements) {
         const element = elements[elementName];
@@ -39,7 +38,7 @@ function createReferentialConstraints( csn, options ) {
         if (element.type === COMPOSITION && element.$selfOnCondition) {
           compositions.push({
             fn: () => {
-              foreignKeyConstraintForUpLinkOfComposition(element, parent, ePath);
+              foreignKeyConstraintForUpLinkOfComposition(element, art, ePath);
             },
           });
         }
@@ -52,32 +51,39 @@ function createReferentialConstraints( csn, options ) {
         if (element.keys && isToOne(element) && element.type === ASSOCIATION || element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
           associations.push({
             fn: () => {
-              foreignKeyConstraintForAssociation(element, ePath );
+              // parent entity of assoc becomes dependent table
+              foreignKeyConstraintForAssociation( element, art, ePath );
             },
           });
         }
         // for `texts` compositions, we may generate foreign key constraints even w/o `up_`
         else if (elementName === 'texts' && element.target === `${path[path.length - 1]}.texts`) {
           const { on } = element;
-          const target = csn.definitions[element.target];
+          const textsEntity = csn.definitions[element.target];
           // `texts` entities have a key named "locale"
-          const targetSideHasLocaleKey = target.elements.locale?.key;
-          if (targetSideHasLocaleKey && !skipConstraintGeneration(parent, target, { /* there is no assoc */ })) {
-            const sourceElements = Array.from(elementsOfSourceSide(on, elements));
-            const targetElements = Array.from(elementsOfTargetSide(on, target.elements));
+          const targetSideHasLocaleKey = textsEntity.elements.locale?.key;
+          if (targetSideHasLocaleKey && !skipConstraintGeneration(art, textsEntity, { /* there is no assoc */ })) {
+            // Note: a `texts` composition in `Foo` will co-modify `Foo.texts` and create the constraints over there
+            const { dependentKeys, parentKeys } = extractKeys(on, textsEntity.elements, elements);
+
+            const keysInParent = Object.values(elements).filter(e => e.key);
+            if (keysInParent.length !== dependentKeys.length)
+              continue;
+
             // `texts` entities have all the keys the original entity has
-            const allElementsAreKeysAndHaveTheSameName = targetElements.length &&
-            targetElements.every(
-              ([ targetKey, e ]) => e.key &&
-              sourceElements.some(([ sourceKey, sourceElement ]) => sourceElement.key && targetKey === sourceKey )
-            );
+            const allElementsAreKeysAndHaveTheSameName = parentKeys.length &&
+            parentKeys
+              .every(
+                ([ targetKey, e ]) => e.key &&
+                dependentKeys.some(([ sourceKey, sourceElement ]) => sourceElement.key && targetKey === sourceKey )
+              );
             if (allElementsAreKeysAndHaveTheSameName)
-              attachConstraintsToDependentKeys(targetElements, sourceElements, path[path.length - 1], 'texts', { texts: true });
+              attachConstraintsToDependentKeys(dependentKeys, parentKeys, path[path.length - 1], 'texts', { texts: true });
           }
         }
       }
     },
-  }, [], { skipIgnore: false, skipArtifact: a => a.query || a.kind !== 'entity' });
+  }, [], { skipIgnore: false, skipArtifact: a => !!(a.query || a.kind !== 'entity' ) });
 
   // create constraints on foreign keys
   // always process unmanaged first, up_ links must be flagged
@@ -98,7 +104,7 @@ function createReferentialConstraints( csn, options ) {
    * @param {CSN.Path} path
    */
   function foreignKeyConstraintForUpLinkOfComposition( composition, parent, path ) {
-    const dependent = csn.definitions[path[1]];
+    const dependent = csn.definitions[composition.target];
     if (skipConstraintGeneration(parent, dependent, composition))
       return;
 
@@ -107,7 +113,7 @@ function createReferentialConstraints( csn, options ) {
       const upLinkName = composition.$selfOnCondition.up_[0];
       const up_ = csn.definitions[composition.target].elements[upLinkName];
       if (up_.keys && isToOne(up_)) // no constraint for unmanaged / to-many up_ links
-        foreignKeyConstraintForAssociation(up_, [ 'definitions', composition.target, 'elements', upLinkName ], path[path.length - 1]);
+        foreignKeyConstraintForAssociation(up_, dependent, [ 'definitions', composition.target, 'elements', upLinkName ], path[path.length - 1] );
     }
     else if (!onCondition && composition.keys.length > 0) {
       throw new CompilerAssertion('Please debug me, an on-condition was expected here, but only found keys');
@@ -120,28 +126,53 @@ function createReferentialConstraints( csn, options ) {
    * If the association is used as an <up_> link in a compositions on-condition, the ON DELETE rule will be `CASCADE`
    *
    * @param {CSN.Association} association for that a constraint should be generated
+   * @param {CSN.Entity} dependent the entity for which a constraint will be generated
    * @param {CSN.Path} path
    * @param {CSN.PathSegment} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
    */
-  function foreignKeyConstraintForAssociation( association, path, upLinkFor = null ) {
+  function foreignKeyConstraintForAssociation( association, dependent, path, upLinkFor = null ) {
     const parent = csn.definitions[association.target];
-    const dependent = csn.definitions[path[1]];
     if (skipConstraintGeneration(parent, dependent, association))
       return;
-    const { elements } = csn.definitions[path[1]];
-    const onCondition = association.on;
-    if (onCondition && hasConstraintCompliantOnCondition(association, elements, path)) {
+    const { elements } = dependent;
+    if (association.keys) {
       // 1. cds.Association has constraint compliant on-condition
       // mark each dependent key - in the entity containing the association - referenced in the on-condition
-      const dependentKeys = Array.from(elementsOfSourceSide(onCondition, elements));
-      const parentKeys = Array.from(elementsOfTargetSide(onCondition, parent.elements));
+      const parentKeys = [];
+      const dependentKeys = [];
+      association.keys.forEach( (k) => {
+        dependentKeys.push( [ k.$generatedFieldName, elements[k.$generatedFieldName] ] );
+        const parentKey = parent.elements[k.ref[0]];
+        if (parentKey.key) // only keys are valid references in foreign key constraints
+          parentKeys.push( [ k.ref[0], parent.elements[k.ref[0]] ] );
+      });
+      if (isTenant && elements.tenant && parent.elements.tenant) { // `tenant` is not part of on
+        dependentKeys.push([ 'tenant', elements.tenant ]);
+        parentKeys.push([ 'tenant', parent.elements.tenant ]);
+      }
+      const allKeysCovered = parentKeys.length === Object.values(parent.elements).filter(e => e.key).length;
       // sanity check; do not generate constraints for on-conditions like "dependent.idOne = id AND dependent.idTwo = id"
-      if (dependentKeys.length === parentKeys.length)
+      if (allKeysCovered && dependentKeys.length === parentKeys.length)
         attachConstraintsToDependentKeys(dependentKeys, parentKeys, association.target, path[path.length - 1], upLinkFor);
     }
-    else if (!onCondition && association.keys.length > 0) {
-      throw new CompilerAssertion('Please debug me, an on-condition was expected here, but only found keys');
+  }
+
+  /**
+   * Extracts dependent keys and their parent keys based on an 'on' condition.
+   *
+   * @param {CSN.OnCondition} on - on condition from which dependent keys and their parent keys are extracted.
+   * @param {CSN.Elements} elements - The elements of the dependent entity, containing the foreign keys.
+   * @param {CSN.Elements} parentElements - The elements of the parent entity, containing the referenced parent keys.
+   * @returns {object} An object containing dependent keys and the parent keys which they reference.
+   */
+  function extractKeys( on, elements, parentElements ) {
+    const dependentKeys = Array.from(elementsOfSourceSide(on, elements));
+    const parentKeys = Array.from(elementsOfTargetSide(on, parentElements));
+    if (isTenant && elements.tenant && parentElements.tenant) { // `tenant` is not part of on
+      dependentKeys.push([ 'tenant', elements.tenant ]);
+      parentKeys.push([ 'tenant', parentElements.tenant ]);
     }
+    return { dependentKeys, parentKeys };
   }
 
   /**
@@ -181,59 +212,6 @@ function createReferentialConstraints( csn, options ) {
     }
   }
 
-  /**
-   * Constraints can only be generated if the full primary key of the target is referenced by the foreign key in an on-condition.
-   * 1. on-condition only contains AND as logical operator
-   * 2. each part of the on-condition must either:
-   *    - reference a valid field in the dependent entity:
-   *      a) for cds.Composition this is in the target entity
-   *      b) for cds.Association this is the entity, where the association is defined
-   *    - reference a key element in the parent entity:
-   *      a) for cds.Composition this is the entity, where the composition itself is defined
-   *      b) for cds.Association this is the target entity
-   * 3. parent keys must be the full primary key tuple
-   *
-   * @param {CSN.Association} element
-   * @param {CSN.Elements} siblingElements
-   * @param {CSN.Path} path the path to the element
-   * @returns {boolean} indicating whether the association / composition is a constraint candidate
-   */
-  function hasConstraintCompliantOnCondition( element, siblingElements, path ) {
-    const onCondition = element.on;
-    const allowedTokens = [ '=', 'and', '(', ')' ];
-    // on condition must only contain logical operator 'AND'
-    if (onCondition.some(step => typeof step === 'string' && !allowedTokens.includes(step)))
-      return false;
-
-    // on-condition like ... TemplateAuthGroupAssignments.isTemplate = true; is not allowed
-    if (onCondition.some(step => typeof step === 'object' && Object.prototype.hasOwnProperty.call(step, 'val')))
-      return false;
-
-    // no magic vars in on-condition
-    // e.g. for localized: ... and localized.locale = $user.locale; -> not a valid on-condition
-    if (onCondition.some((step, index) => typeof step === 'object' && inspectRef(path.concat([ 'on', index ])).scope === '$magic'))
-      return false;
-
-    // for cds.Associations the parent keys are in the associations target entity
-    // for cds.Composition the parent keys are in the entity, where the composition is defined
-    const parentElements = csn.definitions[element.target].elements;
-    const parentKeys = elementsOfTargetSide(onCondition, parentElements);
-
-    const referencesNonPrimaryKeyField = Array.from(parentKeys.values()).some(parentKey => !parentKey.key);
-    if (referencesNonPrimaryKeyField)
-      return false;
-
-    // returns true if the parentKeys found in the on-condition are covering the full primary key tuple in the parent entity
-    return Array.from(parentKeys.entries())
-      // check if primary key found in on-condition is present in association target / composition source
-      .filter(([ keyName, pk ]) => pk.key && parentElements[keyName].key).length ===
-      Object.keys(parentElements)
-        // compare that with the length of the primary key tuple found in association target / composition source
-        .filter(key => parentElements[key].key &&
-          parentElements[key].type !== ASSOCIATION &&
-          parentElements[key].type !== COMPOSITION)
-        .length;
-  }
   /**
    *  Skip referential constraint if the parent table (association target, or artifact where composition is defined)
    *  of the relation is:

package/lib/transform/db/expansion.js

@@ -11,6 +11,7 @@ const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 const { killNonrequiredAnno } = require('./killAnnotations');
+const { featureFlags } = require('./featureFlags');
 
 /**
  * For keys, columns, groupBy and orderBy, expand structured things.
@@ -26,7 +27,10 @@ const { killNonrequiredAnno } = require('./killAnnotations');
 function expandStructureReferences( csn, options, pathDelimiter, messageFunctions, csnUtils, iterateOptions = {} ) {
   const { error, info, throwWithAnyError } = messageFunctions;
 
-  rewriteExpandInline();
+  if (options.transformation === 'odata' || options.transformation === 'effective' || csn.meta?.[featureFlags]?.$expandInline)
+    rewriteExpandInline();
+
+  throwWithAnyError();
 
   const transformers = {
     keys: (parent, name, keys, path) => {
@@ -189,10 +193,6 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         parent[name].splice(kill[i]);
     }
 
-    // We would be broken if we continue with assoc usage to now skipped
-    throwWithAnyError();
-
-
     for (const {
       parent, target, path,
     } of publishing) {
@@ -615,7 +615,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
       const obj = { ...root, ref: currentRef };
       if (withAlias) {
         // TODO: Remove this line in case foreign key annotations should
-        //       be adressed via full path into target instead of using alias
+        //       be addressed via full path into target instead of using alias
         //       names. See flattening.js::flattenAllStructStepsInRefs()
         //       apply transformations on `ref` counterpart comment.
         setProp(obj, '$structRef', currentAlias);

package/lib/transform/db/featureFlags.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const featureFlags = Symbol.for('Feature flags forRelationalDb');
+
+module.exports = { featureFlags };

package/lib/transform/db/flattening.js

@@ -2,15 +2,15 @@
 
 const {
   applyTransformations, applyTransformationsOnNonDictionary,
-  isBuiltinType, cloneCsnNonDict,
-  copyAnnotations, implicitAs, isDeepEqual,
+  isBuiltinType, cardinality2str,
+  copyAnnotations, implicitAs, isDeepEqual, findAnnotationExpression,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
-const { cardinality2str, isAnnotationExpression } = require('../../model/csnUtils');
 const { transformExpression } = require('./applyTransformations');
+const { cloneCsnNonDict } = require('../../model/cloneCsn');
 /**
  * Strip off leading $self from refs where applicable
  *
@@ -819,7 +819,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       if (options.transformation !== 'effective')
         fk[1]['@odata.foreignKey4'] = prefix;
       if (options.transformation === 'odata' || options.transformation === 'effective') {
-        const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !isAnnotationExpression(element[pn]));
+        const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !findAnnotationExpression(element, pn));
         copyAnnotations(element, fk[1], true, {}, validAnnoNames);
       }
       // propagate not null to final foreign key

package/lib/transform/db/killAnnotations.js

@@ -5,6 +5,7 @@ const requiredAnnos = {
   '@cds.persistence.exists': true,
   '@cds.persistence.table': true,
   '@cds.persistence.journal': true, // Build checks on it
+  '@cds.tenant.independent': true,
   '@sql.append': true,
   '@sql.prepend': true,
   '@sql.replace': true, // We do a check on this, no real function

package/lib/transform/db/rewriteCalculatedElements.js

@@ -7,10 +7,10 @@ const {
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
   implicitAs,
-  cloneCsnNonDict,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
 const { getColumnMap } = require('./views');
+const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
 
@@ -305,7 +305,7 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
    * @returns {object|Array}
    */
   function replaceInRef( oldValue, newValue, isInXpr, refBase, linksBase ) {
-    const clone = { value: cloneCsnNonDict({ value: newValue }, cloneCsnOptions).value };
+    const clone = { value: cloneCsnNonDict(newValue, cloneCsnOptions) };
     if (oldValue.stored)
       clone.value.stored = oldValue.stored;
 

package/lib/transform/db/transformExists.js

@@ -308,9 +308,21 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
 
         const target = subselect.SELECT.from.as; // use subquery alias as target - prevent shadowing
         const extension = root.keys ? translateManagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) : translateUnmanagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current);
+
+        if (options.tenantDiscriminator) {
+          const targetEntity = csn.definitions[root.target];
+          if (!targetEntity['@cds.tenant.independent']) {
+            subselect.SELECT.where.push(
+              { ref: [ target, 'tenant' ] }, '=', { ref: [ base, 'tenant' ] }, 'AND'
+            );
+          }
+        }
+
+        // TODO: parentheses around sub expressions are to be represented by inner `xpr`
         if (extension.length > 3)
           subselect.SELECT.where.push('('); // add braces around the on-condition part to ensure precedence is kept
 
+        // TODO: add tenant comparison here ?
         subselect.SELECT.where.push(...extension);
 
         if (extension.length > 3)

package/lib/transform/db/views.js

@@ -1,11 +1,12 @@
 'use strict';
 
 const {
-  getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary, forEachDefinition,
+  getUtils, applyTransformationsOnNonDictionary, forEachDefinition,
 } = require('../../model/csnUtils');
 const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { ModelError } = require('../../base/error');
 const { setProp } = require('../../base/model');
+const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 /**
  * If a mixin association is published, return the mixin association.
@@ -328,6 +329,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
    */
   // eslint-disable-next-line complexity
   function transformViewOrEntity( query, artifact, artName, path ) {
+    const ignoreAssociations = options.sqlDialect === 'hana' && options.withHanaAssociations === false;
     csnUtils.initDefinition(artifact);
     const { elements } = queryOrMain(query, artifact);
     // We use the elements from the leading query/main artifact - adapt the path
@@ -352,6 +354,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
 
     for (const elemName in elements) {
       const elem = elements[elemName];
+
       if (isSelect) {
         if (!columnMap[elemName])
           addProjectionOrStarElement(query, isProjection, isSelectStar, $combined, columnMap, elemName);
@@ -380,7 +383,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
 
     if (isSelect) {
       // Build new columns from the column map - bring elements and columns back in sync basically
-      query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem].$ignore).map(key => stripLeadingSelf(columnMap[key]));
+      query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem].$ignore && !(elements[elem].target && ignoreAssociations)).map(key => stripLeadingSelf(columnMap[key]));
       // If following an association, explicitly set the implicit alias
       // due to an issue with HANA - this seems to only have an effect on ref files with hdbcds-hdbcds, so only run then
       const columnProcessors = [];

package/lib/transform/draft/odata.js

@@ -21,13 +21,16 @@ const { makeMessageFunction } = require('../../base/messages');
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param {Array} [services] Will be calculated JIT if not provided
+ * @param {string[]|undefined} services Will be calculated JIT if not provided
+ * @param {object} [messageFunctions]
  * @returns {CSN.Model} Returns the transformed input model
  * @todo should be done by the compiler - Check associations for valid foreign keys
  * @todo check if needed at all: Remove '$projection' from paths in the element's ON-condition
  */
-function generateDrafts( csn, options, services ) {
-  const messageFunctions = makeMessageFunction(csn, options, 'for.odata');
+function generateDrafts( csn, options, services, messageFunctions ) {
+  // TEMP(2024-02-26): Temporary! Umbrella uses this file directly in cds/lib/compile/for/drafts.js#L1
+  messageFunctions ??= makeMessageFunction(csn, options, 'odata-drafts');
+
   const { error, info } = messageFunctions;
   const {
     createAndAddDraftAdminDataProjection, createScalarElement,
@@ -77,8 +80,7 @@ function generateDrafts( csn, options, services ) {
    */
   function generateDraftForOdata( artifact, artifactName, rootArtifact ) {
     // Nothing to do if already draft-enabled (composition traversal may have circles)
-    if ((artifact['@Common.DraftRoot.PreparationAction'] || artifact['@Common.DraftNode.PreparationAction']) &&
-        artifact.actions && artifact.actions.draftPrepare)
+    if (filterDict[artifactName])
       return;
 
 
@@ -194,7 +196,6 @@ function generateDrafts( csn, options, services ) {
       }
     }
 
-
     // Generate the actions into the draft-enabled artifact (only draft roots can be activated/edited)
 
     // action draftPrepare (SideEffectsQualifier: String) return <artifact>;

package/lib/transform/effective/associations.js

@@ -3,10 +3,11 @@
 const { setProp } = require('../../base/model');
 const flattening = require('../db/flattening');
 const {
-  applyTransformations, forEachDefinition, forEachMemberRecursively, implicitAs, cloneCsnNonDict, forEachMember, applyTransformationsOnNonDictionary,
+  applyTransformations, forEachDefinition, forEachMemberRecursively, implicitAs, forEachMember, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
 const associations = require('../db/associations');
 const backlinks = require('../db/backlinks');
+const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 
 /**

package/lib/transform/effective/main.js

@@ -2,7 +2,7 @@
 
 const { isBetaEnabled } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
-const { cloneCsnNonDict, getUtils, isAspect } = require('../../model/csnUtils');
+const { getUtils, isAspect } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const flattening = require('../db/flattening');
 const types = require('./types');
@@ -15,6 +15,7 @@ const generateDrafts = require('../draft/db');
 const handleExists = require('../db/transformExists');
 const misc = require('./misc');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('../db/rewriteCalculatedElements');
+const { cloneFullCsn } = require('../../model/cloneCsn');
 
 /**
  * This is just a PoC for now!
@@ -32,7 +33,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   if (!isBetaEnabled(options, 'effectiveCsn'))
     throw new CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
 
-  const csn = cloneCsnNonDict(model, options);
+  const csn = cloneFullCsn(model, options);
   delete csn.vocabularies; // must not be set for effective CSN
   messageFunctions.setModel(csn);
 

package/lib/transform/effective/types.js

@@ -1,9 +1,12 @@
 'use strict';
 
 const {
-  cloneCsnNonDict, applyTransformations, applyTransformationsOnNonDictionary, cloneCsnDictionary, applyTransformationsOnDictionary,
+  applyTransformations,
+  applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
 } = require('../../model/csnUtils');
 const { forEachKey } = require('../../utils/objectUtils');
+const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
 
 /**
  * Resolve all references to structured types in entities to the underlying elements.
@@ -56,7 +59,7 @@ function resolveTypes( csn, csnUtils ) {
     if (final?.elements) {
       // We do full clones so users don't get unexpected linkage later
       if (!parent.elements)
-        parent.elements = cloneCsnDictionary(final.elements);
+        parent.elements = cloneCsnDict(final.elements);
       delete parent.type;
     }
     else if (final && final.items) {
@@ -102,7 +105,7 @@ function resolveTypes( csn, csnUtils ) {
       if (finalSub?.elements) {
         // We do full clones so users don't get unexpected linkage later
         if (!_parent.elements)
-          _parent.elements = cloneCsnDictionary(finalSub.elements);
+          _parent.elements = cloneCsnDict(finalSub.elements);
         delete _parent.type;
         stack.push( _parent );
       }