@sap/cds-compiler 6.7.3 → 6.9.0

package/lib/compiler/shared.js

@@ -121,7 +121,7 @@ function fns( model ) {
       lexical: userBlock,
       dynamic: modelBuiltinsOrDefinitions,
       navigation: environment,
-      notFound: undefinedDefinition,
+      notFound: undefinedFromReference,
       accept: acceptQuerySource,
       noDep: '',                // dependency special for from
       args: () => 'from-args',
@@ -131,7 +131,7 @@ function fns( model ) {
       lexical: userBlock,
       dynamic: modelBuiltinsOrDefinitions,
       navigation: staticTarget,
-      notFound: undefinedDefinition,
+      notFound: undefinedTypeReference,
       accept: acceptTypeOrElement,
       // special `scope`s for CDL parser - TYPE OF (TODO generated?), cds.Association:
       typeOf: typeOfSemantics,
@@ -629,9 +629,11 @@ function fns( model ) {
 
     if (Array.isArray( art ))
       art = art[0];
-    if (!art)
-      return (semantics.dynamic !== modelDefinitions) ? art : pathName( path );
-
+    if (!art) {
+      return (semantics.dynamic !== modelDefinitions && !options.$cdsReplSupport)
+        ? art
+        : pathName( path );
+    }
     const first = (art.kind === 'using' ? art.extern : art.name).id;
     return (path.length === 1) ? first : `${ first }.${ pathName( ref.path.slice(1) ) }`;
   }
@@ -788,6 +790,8 @@ function fns( model ) {
       return undefined;         // parse error
     if (head._artifact !== undefined)
       return head._artifact;
+    if (user.$extended && user._outer && !semantics.isMainRef)
+      user = user._outer;
     let ruser = user._user || user; // TODO: nicer name if we keep this
     // TODO: re-think _user link
     if (ruser._outer && !semantics.isMainRef) {
@@ -1033,13 +1037,23 @@ function fns( model ) {
         return null;
       }
       case 'mixin': {
-        // use a source element having that name if in `extend … with columns`:
-        const elem = (user._user || user).$extended &&
-          art._parent._combined[head.id];
+        // use a source element having that name if in `extend … with` (columns or groupBy):
+        const $extended = user._user?.$extended ?? user.$extended;
+        const elem = $extended && art._parent._combined[head.id];
         if (elem) {
           path.$prefix = elem._parent.name.id; // prepend alias name
-          info( 'ref-special-in-extend', [ head.location, user ],
-                { '#': 'mixin', id: head.id, art: elem._origin._main } );
+          if ($extended === 'columns') {
+            warning( 'ref-special-in-extend', [ head.location, user ],
+                     { '#': 'mixin', id: head.id, art: elem._origin._main } );
+          }
+          else {
+            error( 'ref-unexpected-in-extend', [ head.location, user ], {
+              '#': 'mixin',
+              keyword: $extended,
+              id: head.id,
+              art: elem._origin._main,
+            } );
+          }
           setLink( head, '_navigation', elem );
           return setArtifactLink( head, elem._origin );
         }
@@ -1050,21 +1064,30 @@ function fns( model ) {
         return setArtifactLink( head, art._origin );
       }
       case '$tableAlias': {
-        // use a source element having that name if in `extend … with columns`:
-        const { $extended } = user._user || user;
+        // use a source element having that name if in `extend … with` (columns or groupBy):
+        const $extended = user._user?.$extended ?? user.$extended;
         // if query source has duplicates, table alias has no elements
         const elem = $extended && art.elements?.[head.id];
         if (elem) {
           path.$prefix = art.name.id; // prepend alias name
-          info( 'ref-special-in-extend', [ head.location, user ],
-                { '#': 'alias', id: head.id, art: elem._origin._main } );
+          if ($extended === 'columns') {
+            warning( 'ref-special-in-extend', [ head.location, user ],
+                     { '#': 'alias', id: head.id, art: elem._origin._main } );
+          }
+          else {
+            error( 'ref-unexpected-in-extend', [ head.location, user ], {
+              '#': 'alias',
+              keyword: $extended,
+              id: head.id,
+              art: elem._origin._main,
+            } );
+          }
           setLink( head, '_navigation', elem );
           return setArtifactLink( head, elem._origin );
         }
         else if ($extended && art.elements) {
-          warning( 'ref-deprecated-in-extend', [ head.location, user ], { id: head.id },
-                   // eslint-disable-next-line @stylistic/max-len
-                   'In an added column, do not use the table alias $(ID) to refer to source elements' );
+          warning( 'ref-deprecated-in-extend', [ head.location, user ],
+                   { '#': $extended, id: head.id } );
         }
       }
       /* FALLTHROUGH */
@@ -1186,7 +1209,11 @@ function fns( model ) {
     return model.definitions;
   }
   function modelBuiltinsOrDefinitions( user ) {
-    return definedViaCdl( user ) ? model.$builtins : model.definitions;
+    if (!definedViaCdl( user ))
+      return model.definitions;
+    if (!options.$cdsReplSupport)
+      return model.$builtins;
+    return Object.assign( { __proto__: null }, model.definitions, model.$builtins );
   }
 
   function artifactParams( user ) {
@@ -1355,6 +1382,21 @@ function fns( model ) {
     // TODO: improve text, use text variant for: "or builtin" or "definitions" or none
   }
 
+  function undefinedFromReference( user, item, valid, dict, prev, path, semantics ) {
+    const base = Functions.effectiveType?.( prev );
+    if (Functions.effectiveType?.( base?.elements?.[item.id] )?.target)
+      signalElementHint( user, item, valid, prev, semantics, path );
+    else
+      undefinedDefinition( user, item, valid, dict, prev, path, semantics );
+  }
+
+  function undefinedTypeReference( user, item, valid, dict, prev, path, semantics ) {
+    if (prev?.elements?.[item.id])
+      signalElementHint( user, item, valid, prev, semantics, path );
+    else
+      undefinedDefinition( user, item, valid, dict, prev, path, semantics );
+  }
+
   function undefinedForAnnotate( user, item, valid, _dict, prev, path ) {
     // in a CSN source, only one env was tested (valid.length 1):
     const name = (prev) ? `${ prev.name.id }.${ item.id }` : item.id;
@@ -1382,6 +1424,14 @@ function fns( model ) {
     }
   }
 
+  function signalElementHint( user, item, valid, prev, semantics, path ) {
+    const art = searchName( prev, item.id, 'absolute' );
+    const addSeparators = p => ( p === item ? ':' : '.' ) + p.id;
+    const code = path[0].id + path.slice( 1 ).map( addSeparators ).join( '' );
+    signalNotFound( 'ref-undefined-def', [ item.location, user ], valid,
+                    { '#': 'hint', art, code }, semantics );
+  }
+
   function endsWithSuffix( name, suffix, cond ) {
     if (!name.endsWith( suffix ))
       return false;

package/lib/compiler/tweak-assocs.js

@@ -87,7 +87,7 @@ function tweakAssocs( model ) {
       forEachGeneric( art, 'elements', complainAboutTargetOutsideService );
 
     if (art.query) {
-      traverseQueryPost(art.query, false, (query) => {
+      traverseQueryPost(art.query, null, (query) => {
         forEachGeneric( query, 'elements', handleQueryElements );
       });
     }
@@ -103,7 +103,7 @@ function tweakAssocs( model ) {
   // Check explicit ON / keys with REDIRECTED TO
   // TODO: run on all queries, but this is potentially incompatible
   // function rewriteViewCheck( view ) {
-  //   traverseQueryPost( view.query, false, ( query ) => {
+  //   traverseQueryPost( view.query, null, ( query ) => {
   //     forEachGeneric( query, 'elements', rewriteAssociationCheck );
   //   } );
   // }

package/lib/compiler/utils.js

@@ -6,11 +6,9 @@
 // Please do not add functions “for completeness”, this is not an API file for
 // others but only by the core compiler.
 
-// TODO: split this file into utils/….js, add some functions from lib/base/model.js
-
 'use strict';
 
-const { dictAdd, dictFirst } = require('../base/dictionaries');
+const { dictAdd, dictFirst } = require('./dictionaries');
 const { Location, weakLocation } = require('../base/location');
 const { XsnName, XsnArtifact } = require('./xsn-model');
 
@@ -294,6 +292,8 @@ const testFunctionPlaceholder = () => true;
  * Return path step if the path navigates along an association whose final type
  * satisfies function `test`; "navigates along" = last path item not considered
  * without truthy optional argument `alsoTestLast`.
+ *
+ * This function assumes that the reference has already been resolved.
  */
 function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
   for (const item of ref.path || []) {
@@ -419,7 +419,7 @@ function targetMaxNotOne( assoc, item ) {
  * two entities named `E`, the callback function is called on both.
  * It is also called on columns with `inline`.
  *
- * See also function forEachDefinition(), currently in lib/base/model.js.
+ * See also function forEachDefinition() below.
  */
 function forEachUserArtifact( model, prop, callback ) { // not enums
   forEachUserDict( model, prop, function main( art ) {
@@ -530,6 +530,11 @@ function forEachExprArray( query, array, refContext, exprContext, callback ) {
 // i.e. is necessary to calculate the elements of the query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
 // NOTE: does not run on non-referred sub queries!  Consider using ‹main›.$queries instead!
+//
+// Argument `simpleOnly`:
+// - truthy: only simple queries + sub query in from = do not traverse join and union args
+// - false, '', 0: all, but not right of union/intersect/etc
+// - null, undefined: all, including right side of union/intersect/etc
 function traverseQueryPost( query, simpleOnly, callback ) {
   if (!query)                   // parser error
     return;
@@ -540,7 +545,7 @@ function traverseQueryPost( query, simpleOnly, callback ) {
   }
   if (simpleOnly) {
     const { from } = query;
-    if (!from || from.join)     // parse error or join
+    if (!from || from.join)     // parse error or join or union etc
       return;                   // ok are: path or simple sub query (!)
   }
   if (query.from) {             // SELECT
@@ -550,7 +555,7 @@ function traverseQueryPost( query, simpleOnly, callback ) {
     // console.log('FE:')
   }
   else if (query.args) {             // JOIN, UNION, INTERSECT
-    if (!query.join && simpleOnly == null) {
+    if (!query.join && simpleOnly != null) {
       // enough for elements: traverse only first args for UNION/INTERSECT
       // TODO: we might use this also when we do not rewrite associations
       // in non-referred sub queries
@@ -578,7 +583,7 @@ function traverseQueryExtra( main, callback ) {
   if (!main.$queries)
     return;
   // with a top-level UNION, $queries[0] is just the left
-  traverseQueryPost( main.query, false, (q) => { // also with right of UNION (to be compatible)
+  traverseQueryPost( main.query, null, (q) => { // also into right of UNION (to be compatible)
     setLink( q, '_status', 'extra' );
     callback( q );
   } );
@@ -586,7 +591,7 @@ function traverseQueryExtra( main, callback ) {
     if (query._status === 'extra' || query._parent.kind === '$tableAlias')
       continue; // if parent is alias, query is FROM source -> run by traverseQueryPost
     // we are now in the top-level (parent is entity) or a non-referred query (parent is query)
-    traverseQueryPost( query, null, callback );
+    traverseQueryPost( query, false, callback ); // not into right of UNION
   }
 }
 
@@ -604,15 +609,18 @@ function viewFromPrimary( view ) {
 /**
  * About Helper property $expand for faster the XSN-to-CSN transformation
  * - null/undefined: artifact, member, items does not contain expanded members
- * - 'origin': all expanded (sub) elements have no new target/on and no new annotations
+ * - 'origin': all expanded (sub) elements have no associations and no new annotations
  *             that value is only on elements, types, and params -> no other members
  *             when set, only on elem/art with expanded elements
- * - 'target': all expanded (sub) elements might only have new target/on, but
+ * - 'target': all expanded (sub) elements might only have associations, but
  *             no individual annotations on any (sub) member
  *             when set, traverse all parents where the value has been 'origin' before
+ *             TODO: only set if `target` or `on` has changed during redirection/rewrite
  * - 'annotate': at least one inferred (sub) member has an individual annotation,
  *               not counting propagated ones; set up to the definition (main artifact)
- *               (only set with anno on $inferred elem), annotate “beats” target
+ *               (only set with anno on $inferred elem), 'annotate' beats 'target'
+ * - 'extend': at least one member has been added, 'extend' beats 'annotate'
+ *
  * Usage according to CSN flavor:
  * - gensrc: do not render inferred elements (including expanded elements),
  *           collect annotate statements with value 'annotate'
@@ -621,22 +629,16 @@ function viewFromPrimary( view ) {
  *           (might sometimes render the elements unnecessarily, which is not wrong)
  * - universal: do not render expanded sub elements if $expand = 'origin'
  */
-function setExpandStatus( elem, status ) {
-  // set on element
-  while (elem._main) {
-    elem = elem._parent;
-    if (status === 'annotate' ? elem.$expand === 'annotate' : elem.$expand !== 'origin')
-      return;
-    elem.$expand = status;    // meaning: expanded, containing assocs
-    for (let line = elem.items; line; line = line.items)
-      line.$expand = status; // to-csn just uses the innermost $expand
-  }
-}
+const expandStatusLevel = {
+  origin: 1,
+  target: 2,
+  annotate: 3,
+  extend: 4,
+};
 
-function setExpandStatusAnnotate( elem, status ) {
-  for (;;) {
-    if (elem.$expand === status)
-      return;                 // already set
+function setExpandStatus( elem, status ) {
+  const statusLevel = expandStatusLevel[status];
+  while (!elem.$expand || expandStatusLevel[elem.$expand] < statusLevel) {
     elem.$expand = status;    // meaning: expanded, containing annos
     for (let line = elem.items; line; line = line.items)
       line.$expand = status; // to-csn just uses the innermost $expand
@@ -864,7 +866,6 @@ module.exports = {
   traverseQueryExtra,
   viewFromPrimary,
   setExpandStatus,
-  setExpandStatusAnnotate,
   isDirectComposition,
   targetCantBeAspect,
   userQuery,

package/lib/compiler/xpr-rewrite.js

@@ -148,10 +148,10 @@ const { weakLocation } = require('../base/location');
 const {
   setArtifactLink,
   setLink,
-  setExpandStatusAnnotate,
+  setExpandStatus,
 } = require('./utils');
 const { CompilerAssertion } = require('../base/error');
-const { isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/specialOptions');
 const { isSimpleCdlIdentifier } = require('../parsers/identifiers');
 
 // Config object passed around all "rewrite" functions.
@@ -550,7 +550,7 @@ function xprRewriteFns( model ) {
 
     stripAbsolutePathPrefix( expr, config.expandedRootType );
     prependRootPath( config.expandedRootType, config.expandedRoot, expr );
-    setExpandStatusAnnotate( config.destination, 'annotate' );
+    setExpandStatus( config.destination, 'annotate' );
 
     config.destination[config.anno].$inferred = 'anno-rewrite';
     // $self-paths via type expansion always need to be rewritten.

package/lib/edm/EdmPrimitiveTypeDefinitions.js

@@ -244,7 +244,10 @@ const EdmPrimitiveTypeMap = {
     exact: 0,
     desc: 'Abstract meta type',
   },
-  // 'Edm.Untyped': { v4: true, desc: 'Abstract void type' },
+  'Edm.Untyped': {
+    v4: true,
+    desc: 'Abstract void type',
+  },
 };
 const EdmPathTypeMap = {
   'Edm.AnnotationPath': 1,

package/lib/edm/annotations/edmJson.js

@@ -8,7 +8,7 @@ const {
 } = require('../EdmPrimitiveTypeDefinitions.js');
 const { isBuiltinType, isAnnotationExpression } = require('../../base/builtins');
 const { transformExpression } = require('../../transform/db/applyTransformations.js');
-const { conditionAsTree, expressionAsTree } = require('../../model/xprAsTree');
+const { conditionAsTree, expressionAsTree } = require('../../base/xprAsTree');
 
 /**
  * Translate a given token stream expression into an edmJson representation
@@ -390,9 +390,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions, generi
 
 
   transform.ref = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
-    // until empty filter syntax is introduced for the annotation expressions,
-    // we ignore the filters in order to generate EDMX
-    if (xpr.some(ps => ps.args/* || ps.where */)) {
+    if (xpr.some(ps => ps.args /* || (ps.where && ps.where.length)) until PR#13752 filters were also forbidden */)) {
       error('odata-anno-xpr-ref', location, {
         anno, elemref: parent, '#': 'args',
       });

package/lib/edm/annotations/genericTranslation.js

@@ -6,7 +6,8 @@ const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const { forEachDefinition } = require('../../model/csnUtils');
-const { isBetaEnabled, setProp } = require('../../base/model.js');
+const { isBetaEnabled } = require('../../base/specialOptions.js');
+const { setProp } = require('../../utils/objectUtils.js');
 const { xpr2edmJson, getEdmJsonHandler } = require('./edmJson.js');
 const { vocabularyDefinitions } = require('./vocabularyDefinitions.js');
 const { EdmPathTypeMap } = require('../EdmPrimitiveTypeDefinitions.js');
@@ -890,13 +891,18 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   //   oTarget: the result object (o: odata)
   //   oTermName: current term
   //   dTypeNameArg: expected type of cAnnoValue according to dictionary, may be null (d: dictionary)
-  function handleValue( cAnnoValue, oTarget, oTermName, dTypeNameArg, msg ) {
+  //   dTypeDef: the whole object definition of the typefrom the dictionary, needed for DerivedTypeConstraints for Edm.Untyped
+  // @ts-ignore
+  function handleValue( cAnnoValue, oTarget, oTermName, dTypeNameArg, msg/* , dTypeDef = undefined */ ) {
     // this function basically only figures out what kind of annotation value we have
     //   (can be: array, expression, enum, pseudo-record, record, simple value),
     //   then calls a more specific function to deal with it and puts
     //   the result into the oTarget object
 
-    const [ dTypeName, dTypeIsACollection ] = stripCollection(dTypeNameArg);
+    const [ dTypeName, dTypeIsACollection/* , dTypeIsUntyped */ ] = stripCollectionAndgetIsCollectionOrUntyped(dTypeNameArg);
+
+    // if (dTypeIsUntyped)
+    //   validateUntypedAnnotationValue(cAnnoValue, typeof dTypeNameArg === 'object' ? dTypeNameArg : dTypeDef, msg);
 
     if (Array.isArray(cAnnoValue)) {
       if (isEnumType(dTypeName)) {
@@ -914,7 +920,12 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if ('=' in cAnnoValue) {
         if (dTypeIsACollection) {
           message('odata-anno-value', msg.location,
-                  { anno: msg.anno(), str: 'path', '#': 'incompval' });
+                  {
+                    anno: msg.anno(),
+                    type: dTypeName,
+                    str: 'path',
+                    '#': 'incompval',
+                  });
         }
         // expression
         const res = handleExpression(cAnnoValue['='], dTypeName);
@@ -1080,6 +1091,30 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       // concatenate all the enums to a string, separated by spaces
       return cAnnoValue.filter( x => x['#']).map( x => (forXml ? `${ dTypeName }/` : '') + x['#'] ).join(forXml ? ' ' : ',');
     }
+
+    // --------------------- Edm.Untyped helper function ----------------------
+
+    // // eslint-disable-next-line no-shadow
+    // function validateUntypedAnnotationValue( cAnnoValue, dTypeDef, msg ) {
+    //   if (!dTypeDef?.DerivedTypeConstraint)
+    //     return;
+    //   // if the annotation value is a path, but no path is allowed for this annotation, issue a message,
+    //   // for example the UI.DataField.Value annotation
+    //   if (cAnnoValue.$edmJson?.$Path/* || cAnnoValue['=']) -> this is handled in handleValue */ &&
+    //     !(dTypeDef.DerivedTypeConstraint.some(type => EdmPathTypeMap[type]) ||
+    //     dTypeDef.DerivedTypeConstraint.includes('Edm.EntityType') ||
+    //     dTypeDef.DerivedTypeConstraint.includes('Edm.ComplexType'))
+    //   ) {
+    //     message('odata-anno-value', msg.location,
+    //             {
+    //               anno: msg.anno(),
+    //               str: 'path',
+    //               type: 'Edm.Untyped',
+    //               '#': 'incompval',
+    //             });
+    //   }
+    // }
+    // ----------------------------------------------------------------------
   }
 
   // found an expression value ("=") "expr"
@@ -1417,7 +1452,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   function generateCollection( annoValue, termName, dTypeName, dTypeIsACollection, msg ) {
     const newCollection = new Edm.Collection(v);
 
-    if (dTypeName && !dTypeIsACollection) {
+    if (dTypeName && !dTypeIsACollection && dTypeName !== 'Edm.Untyped') {
       message('odata-anno-value', msg.location,
               {
                 anno: msg.anno(), str: 'collection', type: dTypeName, '#': 'incompval',
@@ -1720,14 +1755,23 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     return dTypeName;
   }
 
-  function stripCollection( typeName ) {
-    if (typeName) {
+  function stripCollectionAndgetIsCollectionOrUntyped( typeName ) {
+    if (typeName && typeof typeName === 'string') {
       const match = typeName.match(/^Collection\((.+)\)/);
       if (match)
         return [ match[1], true ];
+        // return [ match[1], true, match[1] === 'Edm.Untyped' ];
     }
 
+    // in the Dictionary.json, if a certain element or type has type 'Edm.Untyped', we also store
+    // a 'DerivedTypeConstraint' property containing the possible types for this element or type.
+    // Therefore, the type is not just a string but an object: { Type: 'Edm.Untyped', DerivedTypeConstraint: [...] }
+    if (typeName && typeof typeName === 'object')
+      return [ typeName.Type, typeName.DerivedTypeConstraint.every(type => type.startsWith('Collection(')) ];
+      // return [ typeName.Type, typeName.DerivedTypeConstraint.some(type => type.startsWith('Collection(')), true ];
+
     return [ typeName, false ];
+    // return [ typeName, false, typeName === 'Edm.Untyped' ];
   }
 
   function isPrimitiveType( typeName ) {

package/lib/edm/csn2edm.js

@@ -9,7 +9,8 @@ const VALUELIST_NAVPROP_PREFIX = '';
 const edmUtils = require('./edmUtils.js');
 const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
-const { setProp, isBetaEnabled } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
+const { isBetaEnabled } = require('../base/specialOptions');
 const {
   isEdmPropertyRendered, getUtils, findAnnotationExpression,
 } = require('../model/csnUtils');
@@ -21,7 +22,7 @@ const {
   EdmPrimitiveTypeMap,
 } = require('./EdmPrimitiveTypeDefinitions.js');
 const { getEdm } = require('./edm.js');
-const { cloneFullCsn } = require('../model/cloneCsn');
+const { cloneFullCsn } = require('../base/cloneCsn');
 const { forEach, forEachValue } = require('../utils/objectUtils.js');
 /*
 OData V2 spec 06/01/2017 PDF version is available here:

package/lib/edm/edmAnnoPreprocessor.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const edmUtils = require('./edmUtils.js');
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 const { forEachGeneric } = require('../model/csnUtils');
 
 /*

package/lib/edm/edmInboundChecks.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { setProp, isBetaEnabled } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
+const { isBetaEnabled } = require('../base/specialOptions');
 const {
   forEachDefinition, forEachMemberRecursively, getUtils,
   transformAnnotationExpression,

package/lib/edm/edmPreprocessor.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /* eslint max-statements-per-line:off */
-const { setProp, isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/specialOptions');
 const {
   forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isEdmPropertyRendered, getUtils,
@@ -15,8 +15,8 @@ const edmAnnoPreproc = require('./edmAnnoPreprocessor.js');
 const { inboundQualificationChecks } = require('./edmInboundChecks.js');
 const typesExposure = require('../transform/odata/typesExposure');
 const expandCSNToFinalBaseType = require('../transform/odata/toFinalBaseType');
-const { cloneCsnNonDict, cloneAnnotationValue } = require('../model/cloneCsn');
-const { forEach, forEachKey } = require('../utils/objectUtils.js');
+const { cloneCsnNonDict, cloneAnnotationValue } = require('../base/cloneCsn');
+const { setProp, forEach, forEachKey } = require('../utils/objectUtils.js');
 
 const NavResAnno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
 

package/lib/edm/edmUtils.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 const {
   isEdmPropertyRendered, applyTransformations,
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { escapeString, hasControlCharacters, hasUnpairedUnicodeSurrogate } = require('../render/utils/stringEscapes');
 const { CompilerAssertion } = require('../base/error');
-const { cloneAnnotationValue } = require('../model/cloneCsn');
+const { cloneAnnotationValue } = require('../base/cloneCsn');
 
 /* eslint max-statements-per-line:off */
 function validateOptions( _options ) {