@sap/cds-compiler 4.2.4 → 4.3.0

package/CHANGELOG.md

@@ -7,6 +7,32 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 4.3.0 - 2023-09-29
+
+### Added
+
+- compiler: it is possible to publish associations with filters in views.
+  Managed associations become unmanaged ones.  For example:  
+  ```cds
+  entity Proj as projection on Base {
+    assoc[id = 1],
+  };
+  ```
+
+### Changed
+
+- Update OData vocabularies: 'Aggregation', 'Capabilities', 'Common', 'PDF', 'PersonalData', 'UI'.
+
+### Fixed
+
+- parser: Chained methods without arguments such as `b` in `a().b.c()` were lost.
+- compiler:
+  + Type arguments in `cast()` functions, whose column also has an explicit type set, were not
+    properly checked.  Now the `cast()`s type and type arguments are checked.
+  + SQL function `STDDEV(*)` was not parsable.
+  + In views, published association's ON-conditions containing `$projection` are now rewritten
+    to `$self` in the CSN `elements` property.  This ensures recompilability of the CSN.
+
 ## Version 4.2.4 - 2023-09-14
 
 ### Fixed

package/bin/cdsc.js

@@ -278,6 +278,7 @@ function executeCommandLine( command, options, args ) {
     manageConstraints,
     toSql,
     inspect,
+    toEffectiveCsn,
   };
   const commandsWithoutCompilation = {
     explain,
@@ -317,6 +318,13 @@ function executeCommandLine( command, options, args ) {
     return model;
   }
 
+  function toEffectiveCsn( model ) {
+    const csn = options.directBackend ? model : compactModel(model, options);
+    displayNamedCsn(main.for.effective(csn, options), 'effective');
+
+    return model;
+  }
+
   // Execute the command line option 'toCsn' and display the results.
   // Return the original model (for chaining)
   function toCsn( model ) {

package/bin/cdshi.js

@@ -41,11 +41,11 @@ function highlight( err, buf ) {
       continue;
     if (tok.$isSkipped) {
       if (tok.stop > tok.start) {
-        chars[tok.start] = (tok.$isSkipped === true ? '\x0f' : '\x16');
-        chars[tok.stop] = '\x17';
+        chars[tok.start] = (tok.$isSkipped === true ? '\x0f' : '\x16'); // ^O / ^V
+        chars[tok.stop] = '\x17';                                       // ^W
       }
       else {
-        chars[tok.start] = (tok.$isSkipped === true ? '\x0e' : '\x15');
+        chars[tok.start] = (tok.$isSkipped === true ? '\x0e' : '\x15'); // ^N / ^U
       }
     }
     else {

package/doc/CHANGELOG_BETA.md

@@ -8,6 +8,13 @@ Note: `beta` fixes, changes and features are listed in this ChangeLog just for i
 The compiler behavior concerning `beta` features can change at any time without notice.
 **Don't use `beta` fixes, changes and features in productive mode.**
 
+## Version 4.3.0 - 2023-09-29
+
+### Removed `associationDefault`
+
+This flag is now the default. Managed associations with exactly one foreign key can now
+have a default value.
+
 ## Version 4.1.0 - 2023-07-28
 
 ### Added `associationDefault`

package/lib/api/main.js

@@ -18,6 +18,7 @@ const csnUtils = lazyload('../model/csnUtils');
 const timetrace = lazyload('../utils/timetrace');
 const forRelationalDB = lazyload('../transform/forRelationalDB');
 const sqlUtils = lazyload('../render/utils/sql');
+const effective = lazyload('../transform/effective/main');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -225,6 +226,23 @@ function forHdbcds( csn, options = {} ) {
   return internalOptions.testMode ? toCsn.sortCsn(hanaCsn, internalOptions) : hanaCsn;
 }
 
+/**
+ * Effective CSN transformation
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {EffectiveCsnOptions} [options={}] Options
+ * @returns {CSN.Model} CSN transformed
+ * @private
+ */
+function forEffective( csn, options = {} ) {
+  const internalOptions = prepareOptions.to.sql(options);
+  internalOptions.transformation = 'effective';
+
+  const eCsn = effective.effectiveCsn(csn, internalOptions);
+
+  return internalOptions.testMode ? toCsn.sortCsn(eCsn, internalOptions) : eCsn;
+}
+
 /**
  * Process the given CSN into SQL.
  *
@@ -851,6 +869,7 @@ module.exports = {
   for_sql: publishCsnProcessor(forSql, 'for.sql'),
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
+  for_effective: publishCsnProcessor(forEffective, 'for.effective'),
   /** Deprecated, will be removed in cds-compiler@v4 */
   preparedCsnToEdmx,
   preparedCsnToEdm,

package/lib/base/location.js

@@ -71,6 +71,21 @@ function emptyWeakLocation( filename ) {
   };
 }
 
+/**
+ * @param {CsnLocation} loc
+ * @returns {CsnLocation}
+ */
+function weakLocation( loc ) {
+  return {
+    __proto__: CsnLocation.prototype,
+    file: loc.file,
+    line: loc.line,
+    col: loc.col,
+    endLine: undefined,
+    endCol: undefined,
+  };
+}
+
 /**
  * Returns a dummy location for built-in definitions.
  *
@@ -156,6 +171,7 @@ module.exports = {
   combinedLocation,
   emptyLocation,
   emptyWeakLocation,
+  weakLocation,
   builtinLocation,
   dictLocation,
   locationString,

package/lib/base/message-registry.js

@@ -74,7 +74,7 @@ const centralMessages = {
   'def-unexpected-calcview-assoc': { severity: 'Error' },
   'chained-array-of': { severity: 'Error' },
   'def-missing-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
-  'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
+  'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename', 'for.effective' ] },
 
   'def-duplicate-autoexposed': { severity: 'Error' },
   'def-unexpected-default': { severity: 'Error', configurableFor: 'test' },
@@ -92,6 +92,7 @@ const centralMessages = {
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'type-expecting-service-target': { severity: 'Error', configurableFor: true },
   'ref-expecting-const': { severity: 'Error' },
+  'ref-expecting-foreign-key': { severity: 'Error' },
   'ref-invalid-source': { severity: 'Error' },
   'ref-invalid-target': { severity: 'Error' },
   'ref-sloppy-target': { severity: 'Error', configurableFor: 'v4' },
@@ -186,13 +187,13 @@ const centralMessages = {
   'odata-spec-violation-key-null': { severity: 'Error', configurableFor: true }, // more than 30 chars
   'odata-spec-violation-key-type': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
-  'odata-anno-preproc': { severity: 'Warning', configurableFor: true },
-  'odata-anno-dict': { severity: 'Warning', configurableFor: true },
-  'odata-anno-vocref': { severity: 'Warning', configurableFor: true },
+  'odata-anno-preproc': { severity: 'Warning' },
+  'odata-anno-dict': { severity: 'Warning' },
+  'odata-anno-vocref': { severity: 'Warning' },
   'odata-anno-dict-enum': { severity: 'Error' },
-  'odata-anno-value': { severity: 'Warning', configurableFor: true },
-  'odata-anno-type': { severity: 'Warning', configurableFor: true },
-  'odata-anno-def': { severity: 'Info', configurableFor: true },
+  'odata-anno-value': { severity: 'Warning' },
+  'odata-anno-type': { severity: 'Warning' },
+  'odata-anno-def': { severity: 'Info' },
   'query-ignoring-assoc-in-union': { severity: 'Info' }
 };
 
@@ -274,6 +275,12 @@ const centralMessageTexts = {
   'anno-unstable-array': 'Unstable order of array items due to repeated assignments for $(ANNO)',
   'anno-mismatched-ellipsis': 'An array with $(CODE) can only be used if there is an assignment below with an array value',
   'anno-unexpected-ellipsis': 'No base annotation available to apply $(CODE)',
+
+  'anno-unexpected-localized-skip': {
+    std: 'Compiler generated entity $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped',
+    view: 'Compiler generated view $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped',
+  },
+
   'chained-array-of': '"Array of"/"many" must not be chained with another "array of"/"many" inside a service',
 
   'check-proper-type-of': {
@@ -463,12 +470,15 @@ const centralMessageTexts = {
   'syntax-missing-property': {  // location at sibling or '}' otherwise
     std: 'Object in $(PARENTPROP) must have the property $(PROP)',
     sibling: 'Object with property $(SIBLINGPROP) must also have a property $(PROP)',
+    bothTargets: 'Object with properties $(SIBLINGPROP) and $(OTHERPROP) must also have a property $(PROP)',
     columns: 'Object in $(PARENTPROP) must have an expression property like $(PROP)',
     extensions: 'Object in $(PARENTPROP) must have the property $(PROP) or $(OTHERPROP)',
   },
   'syntax-unexpected-property': {
     std: 'Unexpected CSN property $(PROP)',
     sibling: 'CSN property $(PROP) is not expected in an object with property $(SIBLINGPROP)',
+    target: 'CSN property $(PROP) with sub property $(SUBPROP) is not expected in an object with property $(SIBLINGPROP)',
+    targetAspect: 'CSN property $(PROP) is not expected in an object with property $(SIBLINGPROP) having sub property $(SUBPROP)',
     prop: 'CSN property $(PROP) is not expected in $(PARENTPROP)',
     top: 'CSN property $(PROP) is not expected top-level',
     kind: 'CSN property $(PROP) is not expected by a definition of kind $(KIND)',
@@ -590,6 +600,9 @@ const centralMessageTexts = {
     expr: 'Associations can\'t be used as values in expressions',
     'expr-comp': 'Compositions can\'t be used as values in expressions',
     cast: 'Casting to an association is not supported',
+
+    'managed-filter': 'Unexpected managed association $(NAME) in filter expression of $(ID)',
+    'unmanaged-filter': 'Unexpected unmanaged association $(NAME) in filter expression of $(ID)'
   },
   'ref-unexpected-calculated': {
     std: 'Unexpected reference to calculated element',
@@ -619,6 +632,9 @@ const centralMessageTexts = {
     calc: 'Unexpected arguments in path $(ELEMREF) of stored calculated element; only simple paths can be used here'
   },
 
+  // TODO: Better text ?
+  'rewrite-not-supported': 'The ON-condition is not rewritten here - provide an explicit ON-condition',
+
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
     type: 'Unexpected $(KEYWORD) for the type of a type definition',
@@ -703,7 +719,7 @@ const centralMessageTexts = {
   },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
-    virtual: 'Unexpected $(PROP) for virtual element $(ART)',
+    virtual: 'Unexpected $(PROP) for virtual element',
     // TODO: Better message?
     include: '$(ART) can\'t have additional keys (through include)',
   },
@@ -754,7 +770,7 @@ const centralMessageTexts = {
     'include-elements': 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
     'include-actions': 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
   },
-  // TODO: Remove in v4, use duplicate-definition
+  // TODO: Remove in v5, use duplicate-definition (or another ID?)
   'ref-duplicate-include-member': {
     std: 'Duplicate member $(NAME) through multiple includes $(SORTED_ARTS)',
     elements: 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
@@ -773,7 +789,9 @@ const centralMessageTexts = {
     missing: 'Expected element $(ID) to have at least all the same sub-elements as included artifacts, but it is missing $(NAME)'
   },
 
+  'ref-expecting-assoc': 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition, found $(TYPE)',
   'ref-expecting-const': 'A constant expression or variable is expected here',
+  'ref-expecting-foreign-key': 'Expecting foreign key access after managed association $(NAME) in filter expression of $(ID), but found $(ALIAS)',
   'ref-invalid-target': {
     std: 'An entity, projection or view is expected here', // TODO: change text
     composition: 'Expecting an entity or aspect as composition target',
@@ -826,6 +844,11 @@ const centralMessageTexts = {
     std: 'Ignoring nullability constraint on parameter when generating SAP HANA CDS view',
     sql: 'Ignoring nullability constraint on parameter when generating SQL view'
   },
+  'query-ignoring-filter': {
+    std: 'Ignoring filter on published association due to explicit redirection', // unused
+    onCond: 'Ignoring filter on published association due to explicit redirection with ON-condition',
+    fKey: 'Ignoring filter on published association due to explicit redirection with explicit foreign keys',
+  },
   'query-expected-identifier': {
     std: 'Expected identifier for select item',
     assoc: 'Expected identifier as the association\'s name',
@@ -842,15 +865,19 @@ const centralMessageTexts = {
     extra: 'Specified element $(NAME) differs from inferred element: it has an additional property $(PROP)',
     target: 'Expected target $(TARGET) of specified element $(NAME) to be the same as the inferred element\'s target $(ART)',
     foreignKeys: 'Expected foreign keys of specified element $(NAME) to be the same as the inferred element\'s foreign keys',
+    unmanagedToManaged: 'Unexpected foreign keys in specified element $(NAME); inferred element is a managed association',
     prop: 'Value for $(PROP) of the specified element $(NAME) does not match the inferred element\'s value',
     enumExtra: 'Specified element $(NAME) differs from inferred element: it has an additional enum element $(ID)',
     enumVal: 'Specified element $(NAME) differs from inferred element: it has a different value for enum element $(ID)',
   },
-
   'query-unexpected-property': {
     std: 'Unexpected property $(PROP) in the specified element $(NAME)',
     calculatedElement: 'Unexpected property $(PROP) in the specified element $(NAME); calculated elements are not supported in queries',
   },
+  'query-ignoring-assoc-in-union': {
+    'managed': 'Ignoring managed association $(NAME) that is published in a UNION',
+    'std': 'Ignoring association $(NAME) that is published in a UNION'
+  },
 
   'ref-sloppy-target': 'An entity or an aspect (not type) is expected here',
 
@@ -900,8 +927,14 @@ const centralMessageTexts = {
 
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
 
-  'expr-missing-foreign-key': 'Path step $(ID) of $(ELEMREF) has no valid foreign keys',
+  'expr-missing-foreign-key': {
+    std: 'Path step $(ID) of $(ELEMREF) has no valid foreign keys',
+    publishingFilter: 'Can\'t publish managed association $(ID) with filter, as it must have at least one foreign key',
+  },
 
+  // -----------------------------------------------------------------------------------
+  // OData Message section starts here
+  // -----------------------------------------------------------------------------------
   // OData version dependent messages
   'odata-spec-violation-array': 'Unexpected array type for OData $(VERSION)',
   'odata-spec-violation-param' : 'Expected parameter to be typed with either scalar or structured type for OData $(VERSION)',
@@ -1017,11 +1050,9 @@ const centralMessageTexts = {
     'deprecated': '$(ANNO) is deprecated. $(DEPR)',
     'notapplied': '$(ANNO) is not applied (AppliesTo: $(RAWVALUES))',
   },
-  'query-ignoring-assoc-in-union': {
-    'managed': 'Ignoring managed association $(NAME) that is published in a UNION',
-    'std': 'Ignoring association $(NAME) that is published in a UNION'
-  }
-
+  // -----------------------------------------------------------------------------------
+  // OData Message section ends here, no messages below this line
+  // -----------------------------------------------------------------------------------
 }
 
 /**

package/lib/base/messages.js

@@ -670,6 +670,7 @@ const paramsTransform = {
   prop: quote.single,
   siblingprop: quote.single,
   parentprop: quote.single,
+  subprop: quote.single,
   otherprop: quote.single,
   code: quote.single,
   newcode: quote.single,
@@ -820,10 +821,11 @@ function transformArg( arg, r, args, texts ) {
       return quoted(`${ arg.ref[0] }:${ arg.ref.slice(1).join('.') }`);
     return quoted(arg.ref);
   }
-  const { name } = arg;
-  if (!name)
-    return quoted( name );
+  if (!arg.name)
+    return quoted( arg.name );
+  const name = getArtifactName( arg );
   const prop = [ 'element', 'param', 'action', 'alias' ].find( p => name[p] );
+  //if (!prop) throw Error()
   if (!prop || !texts[prop] )
     return shortArtName( arg );
   r['#'] = texts[name.$variant] && name.$variant || prop; // text variant (set by searchName)
@@ -831,12 +833,6 @@ function transformArg( arg, r, args, texts ) {
   return artName( arg, prop );
 }
 
-const nameProp = {
-  enum: 'element',
-  key: 'element',
-  function: 'action',
-};
-
 // TODO: very likely delete this function
 function searchName( art, id, variant ) {
   if (!variant) {
@@ -844,17 +840,30 @@ function searchName( art, id, variant ) {
     // originally provided one (TODO: mention that in the message text)
     const type = art._effectiveType && art._effectiveType.kind !== 'undefined' ? art._effectiveType : art;
     if (type.elements) {        // only mentioned elements
-      art = type.target && type.target._artifact || type;
+      art = type.target?._artifact || type;
       variant = 'element';
     }
     else {
       variant = 'absolute';
     }
   }
-  const prop = nameProp[variant] || variant;
-  const name = Object.assign( { $variant: variant }, (art._artifact || art).name );
-  name[prop] = name[prop] ? `${ name[prop] }.${ id }` : id || '?';
-  return { name, kind: art.kind };
+  if (variant === 'absolute') {
+    const absolute = `${ art.name.id }.${ id }`;
+    return {
+      kind: art.kind,
+      name: { id: absolute, $variant: variant },
+    };
+  }
+  const undef = {
+    kind: variant || art.kind,
+    name: { id, $variant: variant },
+  };
+  Object.defineProperty( undef, '_parent',
+                         { value: art, configurable: true, writable: true } );
+  Object.defineProperty( undef, '_main',
+                         { value: art._main || art, configurable: true, writable: true } );
+  // console.log('SN:',undef)
+  return undef;
 }
 
 function messageText( texts, params, transform ) {
@@ -892,17 +901,6 @@ function replaceInString( text, params ) {
   return parts.join('');
 }
 
-/**
- * @param {CsnLocation} loc
- * @returns {CsnLocation}
- */
-function weakLocation( loc ) {
-  if (!loc)
-    return new CsnLocation();
-  // no endLine/endCol
-  return new CsnLocation( loc.file, loc.line, loc.col, undefined, undefined );
-}
-
 /**
  * Return message string with location if present in compact form (i.e. one line).
  *
@@ -1249,7 +1247,7 @@ function compareMessageSeverityAware( a, b ) {
 /**
  * Return sort-relevant part of semantic location (after the ':').
  * Messages without semantic locations are considered smaller (for syntax errors)
- * and (currently - should not happen in v2) larger for other messages.
+ * and (currently - should not happen in v5) larger for other messages.
  *
  * @param {CompileMessage} msg
  */
@@ -1299,14 +1297,9 @@ function deduplicateMessages( messages ) {
 }
 
 function shortArtName( art ) {
+  if (!art.name)
+    return artName( art );
   const name = getArtifactName( art );
-  if (!name) {
-    const loc = art.location ? ` at ${ locationString( art.location ) }` : '';
-    throw new CompilerAssertion(
-      art.path
-        ? `No artifact for ${ art.path.map( i => i.id ).join( '.' )}${ loc }`
-        : `No name found in ${ Object.keys( art ).join( '+' )}${ loc }` );
-  }
   if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
     return quote.double( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
@@ -1314,7 +1307,21 @@ function shortArtName( art ) {
 }
 
 function artName( art, omit ) {
+  let suffix = 0;
+  while (!art.name && art._outer) {
+    ++suffix;
+    art = art._outer;
+  }
+
   const name = getArtifactName( art );
+  if (!name) {
+    const loc = art.location ? ` at ${ locationString( art.location ) }` : '';
+    throw new CompilerAssertion(
+      art.path
+        ? `No artifact for ${ art.path.map( i => i.id ).join( '.' )}${ loc }`
+        : `No name found in ${ Object.keys( art ).join( '+' )}${ loc }` );
+  }
+
   const r = (name.absolute) ? [ quoted( name.absolute ) ] : [];
   if (name.select && name.select > 1 || name.select != null && art.kind !== 'element') // Yes, omit select:1 for element - TODO: re-check
     r.push( (art.kind === 'extend' ? 'block:' : 'query:') + name.select ); // TODO: rename to 'select:1' and consider whether there are more selects
@@ -1328,6 +1335,8 @@ function artName( art, omit ) {
   if (name.element != null && omit !== 'element') {
     if (name.select != null && !art.$inferred)
       r.push( 'column:' + quoted( name.element ) );
+    else if (art.kind === 'builtin')
+      return `$var:${ quoted( name.element ) }`;
     else
       // r.push( `${ art.kind }: ${ quoted( name.element )}` ); or even better element:"assoc"/key:"i" same with enum
       r.push( (art.kind === 'enum' ? 'enum:' : 'element:') + quoted( name.element ) );
@@ -1335,6 +1344,9 @@ function artName( art, omit ) {
 
   if (art.kind === '$self')
     r.push( `alias:${ quoted( name.alias ) }` ); // should be late due to $self in anonymous aspect
+  if (suffix)
+    r.push( art.targetAspect ? 'target' : art.items?.items ? `items:${ suffix }` : 'items');
+
   return r.join('/');
 }
 
@@ -1361,21 +1373,21 @@ function homeName( art, absoluteOnly ) {
     return `using:${ quoted( art.name.id ) }`;
   else if (art.kind === 'extend' || art.kind === 'annotate')
     return !absoluteOnly && homeNameForExtend( art );
+  else if (!art.kind)           // annotation assignments are not really supported
+    return (absoluteOnly) ? art.name.id : quoted( `@${ art.name.id }` );
   else if (art.name._artifact)             // block, extend, annotate
     return homeName( art.name._artifact, absoluteOnly ); // use corresponding definition
-  else if (absoluteOnly)
-    return art.name.absolute;
   let main = art._main || art;
   while (main._outer)           // anonymous aspect
     main = main._outer._main;
-  return `${ main.kind }:${ artName( art ) }`;
+  return (absoluteOnly) ? main.name.id : `${ main.kind }:${ artName( art ) }`;
 }
 
 // The "home" for extensions is handled differently because `_artifact` is not
 // set for unknown extensions, and we could have nested extensions.
 // TODO: delete this function, just set correct name/_parent for extensions
 function homeNameForExtend( art ) {
-  if (!art.name.absolute && art._main)       // new-style member name
+  if (art._main)                // new-style member name
     return `${ art._main.kind }:${ artName( art ) }`;
   const kind = art.kind || 'extend';
   // TODO: fix the following - do like in collectArtifactExtensions() or
@@ -1776,7 +1788,6 @@ function messageIdsWithExplanation() {
 
 module.exports = {
   hasErrors,
-  weakLocation,
   locationString,
   messageString,
   messageStringMultiline,

package/lib/base/model.js

@@ -33,8 +33,8 @@ const availableBetaFlags = {
   enableUniversalCsn: true,
   odataTerms: true,
   optionalActionFunctionParameters: true, // not supported by runtime, yet.
-  associationDefault: true,
   annotateForeignKeys: true,
+  effectiveCsn: true,
   // disabled by --beta-mode
   nestedServices: false,
 };

package/lib/checks/checkPathsInStoredCalcElement.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { requireForeignKeyAccess } = require('../checks/onConditions');
+const { applyTransformationsOnNonDictionary } = require('../model/csnUtils');
+
+/**
+ * Check that all paths in calculated elements-on write either access normal fields
+ * (structures are already rejected by the compiler) or access the foreign keys of
+ * associations. Filters and parameters are not allowed.
+ *
+ * @param {CSN.Element} calculatedElement
+ * @param {string} propOnParent
+ * @param {object} valueOfCalculatedElement
+ * @param {CSN.Path} path
+ */
+function checkPathsInStoredCalcElement( calculatedElement, propOnParent, valueOfCalculatedElement, path ) {
+  if (calculatedElement.value.stored) {
+    applyTransformationsOnNonDictionary(calculatedElement, 'value', {
+      ref: (parent, prop, value, csnPath) => {
+        _checkPathsInStoredCalcElement.call(this, parent, value, csnPath);
+      },
+    }, {}, path);
+  }
+}
+
+
+/**
+ * See comment for calling function above.
+ *
+ * @param {object} parent
+ * @param {(string|object)[]} value
+ * @param {CSN.Path} csnPath
+ */
+function _checkPathsInStoredCalcElement( parent, value, csnPath ) {
+  const { _links } = parent;
+
+  for (let i = 0; i < value.length; ++i) {
+    let hasPathError = false;
+    const step = value[i];
+    const stepArt = _links[i].art;
+
+    if (stepArt.value) {
+      applyTransformationsOnNonDictionary(stepArt, 'value', {
+        ref: (nestedParent, prop, nestedValue, path) => {
+          _checkPathsInStoredCalcElement.call(this, nestedParent, nestedValue, path);
+        },
+      }, {}, csnPath);
+    }
+    else if (stepArt.target) {
+      const id = step.id || step;
+      if (stepArt.on) {
+        // It's an unmanaged association - traversal is always forbidden
+        this.error('ref-unexpected-navigation', csnPath, { '#': 'calc-unmanaged', id, elemref: parent });
+        hasPathError = true;
+      }
+      else {
+        // It's a managed association - access of the foreign keys is allowed
+        requireForeignKeyAccess(parent, i, (errorIndex) => {
+          this.error('ref-unexpected-navigation', csnPath, {
+            '#': 'calc-non-fk', id, elemref: parent, name: value[errorIndex].id || value[errorIndex],
+          });
+          hasPathError = true;
+        });
+      }
+    }
+    if (typeof step === 'object') {
+      if (step.where) {
+        this.error('ref-unexpected-filter', csnPath, { '#': 'calc', elemref: parent });
+        hasPathError = true;
+      }
+      if (step.args) {
+        this.error('ref-unexpected-args', csnPath, { '#': 'calc', elemref: parent });
+        hasPathError = true;
+      }
+    }
+    if (hasPathError)
+      break; // avoid too many consequent errors
+  }
+}
+
+module.exports = {
+  value: checkPathsInStoredCalcElement,
+};