@sap/cds-compiler 3.8.2 → 3.9.4

package/CHANGELOG.md

@@ -7,6 +7,69 @@
 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 3.9.4 - 2023-06-07
+
+### Fixed
+
+- compiler: `USING` empty files were incorrectly marked as "not found".
+- Localized convenience views for projections (not views) did not have references rewritten.
+  This only affects CSN, the SQL result was correct.
+- to.edm(x): Render correct EntitySetPath and annotation target path for actions/functions
+  with explicit binding parameter.
+
+## Version 3.9.2 - 2023-04-27
+
+### Fixed
+
+- Fix crash in core compiler which occurred when CAP was used in a node environments
+  where an enumerable property was added to `Array.prototype`.
+- to.edm(x):
+  + Publicly release `@open`.
+  + No `DefaultValue` for `Edm.NavigationProperty`.
+
+## Version 3.9.0 - 2023-04-20
+
+### Added
+
+- Variables `$valid.from` and `$valid.to` have been added to the compiler.
+  They behave the same as `$at.from` and `$at.to`.
+- to.edm(x):
+  + Add `--odata-vocabularies` to pass a dictionary `{ <prefix>: { Alias, Namespace, Uri } }`
+    into the EDM generation. `<prefix>` must match the value of `Alias`. Entries are ignored
+    if they are incomplete, malformed, redefine an official OASIS/SAP vocabulary or match the name
+    of the current service. Annotations of the form `@<prefix>.<annotation>` are added to the API
+    without evaluation including an `edm:Reference`. It is in the users responsibility to provide
+    a URI that a client can resolve against a valid vocabulary document.
+  + Support annotation `@open` on entity and structured type level to declare the corresponding
+    entity/complex type to be `OpenType=true`. If an open structured type is declared closed
+    (with a falsy annotation value), the corresponding EDM type is closed as well and suffixed
+    with `_closed` (or `_open` vice versa).
+    No further checks are performed on possibly open foreign or primary key types nor on eventually
+    bucket elements to store the additional data.
+
+### Changed
+
+- compiler: Parameter references in filters such as `assoc[field < :Param]` are now allowed.
+- In the compiled CSN, sort the non-enumerable `$sources` property
+  according to the reversed layered extension order.
+- Update OData vocabulary 'Common', 'ODM', 'UI'.
+- to.cdl: If an identifier contains illegal characters (e.g. newline), we no longer produces
+  invalid CDL, but emit an error instead.
+
+### Fixed
+
+- to.edm(x):
+  + Fix spec requirement: "Navigation properties of complex types MUST NOT specify a partner".
+  + Set default target cardinality for unspecified `composition of {}` to `[0..1]`.
+  + Correct referential constraint calculation for `[0..1]` backlink associations.
+- for.hana/for.odata: Reject final unmanaged assoc path step in ON Condition if preceded with `$self`.
+- to.cdl: Parentheses around expressions containing conditions were sometimes missing.
+- to.sql/hdi/hdbcds:
+  + Detect and process calculated elements in functions like `upper`.
+  + Better detection of calculated elements in `.expand`/`.inline`.
+  + Entities with calculated elements sometimes had incorrect types. This happened, for example,
+    if they were marked with `@odata.draft.enabled`
+
 ## Version 3.8.2 - 2023-03-30
 
 ### Fixed

package/bin/cdsc.js

@@ -353,8 +353,8 @@ function executeCommandLine( command, options, args ) {
       options.odataFormat = 'structured';
       options.odataContainment = true;
     }
-    if (options.odataVocRefs && typeof options.odataVocRefs === 'string')
-      options.odataVocRefs = JSON.parse(options.odataVocRefs);
+    if (options.odataVocabularies && typeof options.odataVocabularies === 'string')
+      options.odataVocabularies = JSON.parse(options.odataVocabularies);
 
     const csn = options.directBackend ? model : compactModel(model, options);
     if (options.csn) {

package/doc/CHANGELOG_BETA.md

@@ -8,6 +8,26 @@ 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 3.9.2 - 2023-04-27
+
+### Removed `odataOpenType`
+
+This feature is now set to production mode.
+
+## Version 3.9.0 - 2023-04-XX
+
+### Added `calculatedElementsOnWrite`
+
+Allows to define calculated elements "on-write" in entities and aspects.
+For example:
+
+```cds
+entity E { one: Integer; two = one + 1 stored; };
+```
+
+When a row is added to `E`, column `two` will be set automatically
+in databases supporting generated columns.
+
 ## Version 3.8.0 - 2023-03-27
 
 ### Added `v4preview`
@@ -100,11 +120,12 @@ allow lossless, easy to revert actions like adding a column or extending a strin
 
 ### Added `odataOpenType`
 
-- to.edm(x): Support annotation `@open` on entity and structured type level to declare the corresponding entity/complex type to
-  be `OpenType=true`. If an open structured type is declared closed (with a falsy annotation value), the corresponding EDM type
-  is closed as well and suffixed with `_closed` (or `_open` vice versa).
-  No further checks are performed on possibly open foreign or primary key types nor on eventually bucket elements to store the
-  additional data.
+- to.edm(x): Support annotation `@open` on entity and structured type level to declare the
+  corresponding entity/complex type to be `OpenType=true`. If an open structured type is declared
+  closed (with a falsy annotation value), the corresponding EDM type is closed as well and suffixed
+  with `_closed` (or `_open` vice versa).
+  No further checks are performed on possibly open foreign or primary key types nor on eventually
+  bucket elements to store the additional data.
 
 ## Version 3.0.0 - 2022-06-23
 

package/lib/api/.eslintrc.json

@@ -1,13 +1,13 @@
 {
   "root": true,
   "env": {
-    "es2020": true,
+    "es2022": true,
     "node": true
   },
   // we actually do not extend airbnb-base, as it weakens some eslint:recommended rules
   "extends": ["../../.eslintrc-ydkjsi.json", "plugin:jsdoc/recommended"],
   "parserOptions": {
-    "ecmaVersion": 2020,
+    "ecmaVersion": 2022,
     "sourceType": "script"
   },
   "plugins":  [
@@ -18,6 +18,7 @@
     "jsdoc/no-undefined-types": "off",
     // eslint-plugin-jsdoc warning
     "jsdoc/require-property": 0,
+    "jsdoc/tag-lines": "off",
     // =airbnb, >eslint:
     "max-len": [ "error", {
       "code": 100,

package/lib/api/options.js

@@ -29,7 +29,9 @@ const publicOptionsNewAPI = [
   'variableReplacements',
   'pre2134ReferentialConstraintNames',
   'generatedByComment',
+  'betterSqliteSessionVariables',
   // ODATA
+  'odataOpenapiHints',
   'odataVersion',
   'odataFormat',
   'odataContainment',
@@ -38,7 +40,7 @@ const publicOptionsNewAPI = [
   'odataProxies',
   'odataXServiceRefs',
   'odataV2PartialConstr',
-  'odataVocRefs',
+  'odataVocabularies',
   'service',
   'serviceNames',
   //

package/lib/api/validate.js

@@ -82,7 +82,7 @@ const validators = {
   sqlMapping: generateStringValidator([ 'plain', 'quoted', 'hdbcds' ]),
   odataVersion: generateStringValidator([ 'v2', 'v4' ]),
   odataFormat: generateStringValidator([ 'flat', 'structured' ]),
-  odataVocRefs: {
+  odataVocabularies: {
     validate: val => (typeof val === 'object' && !Array.isArray(val)),
     expected: () => 'type JSON object',
     found: val => `type ${ Array.isArray(val) ? 'JSON array' : typeof val }`,

package/lib/base/message-registry.js

@@ -164,17 +164,18 @@ const centralMessages = {
   'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
   'unmanaged-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
-  // Published! Used in @sap/cds-odata-v2-adapter-proxy; if renamed, add to oldMessageIds
+  'def-invalid-key-cardinality': { severity: 'Error' },
+  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-array': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @sap/cds-odata-v2-adapter-proxy; if renamed, add to oldMessageIds
+  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-assoc': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @sap/cds-odata-v2-adapter-proxy; if renamed, add to oldMessageIds
+  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
   'odata-spec-violation-id': { severity: 'Error', configurableFor: true },
   'odata-spec-violation-namespace': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @sap/cds-odata-v2-adapter-proxy; if renamed, add to oldMessageIds
+  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-param': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @sap/cds-odata-v2-adapter-proxy; if renamed, add to oldMessageIds
+  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-returns': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-type': { severity: 'Error', configurableFor: true },
   'odata-spec-violation-type-unknown': { severity: 'Warning' },
@@ -390,7 +391,7 @@ const centralMessageTexts = {
   'syntax-deprecated-value': {  // Warning
     std: 'Deprecated representation of the value in property $(PROP)',
     replace: 'Replace value in $(PROP) by $(VALUE)',
-    'zero-parens': 'Deprecated CSN v.0.1.0 representation of expressions in parentheses',
+    'zero-parens': 'Deprecated CSN v0.1.0 representation of expressions in parentheses',
     'zero-replace': 'Replace CSN v0.1.0 value in $(PROP) by $(VALUE)',
   },
   'syntax-deprecated-type-ref': {
@@ -458,8 +459,10 @@ const centralMessageTexts = {
     annotation: 'An annotation can\'t include an entity with calculated elements',
   },
   'def-unsupported-calc-elem': {
-    std: 'Calculated elements are not supported',
-    nested: 'Calculated elements in structures are not supported, yet'
+    std: 'Calculated elements are not supported, yet',
+    nested: 'Calculated elements in structures are not supported, yet',
+    'on-write': 'Calculated elements on-write are not supported, yet',
+    'hdbcds': 'Calculated elements on-write are not supported for HDBCDS',
   },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
@@ -512,7 +515,7 @@ const centralMessageTexts = {
   },
   'ref-expected-element': {
     std: 'Expected element reference',
-    magicVar: 'Only elements of magic variable $(ID) can be selected',
+    magicVar: 'Only elements of variable $(ID) can be selected',
   },
   'ref-expected-direct-structure': {
     std: '$(ART) can\'t be extended because it originates from an include',
@@ -595,14 +598,14 @@ const centralMessageTexts = {
   },
 
   'def-unexpected-paramview-assoc': {
-    std: 'SAP HANA doesn\'t support associations in/to parameterized entities',
-    view: 'SAP HANA doesn\'t support associations in parameterized entities',
-    target: 'SAP HANA doesn\'t support associations to parameterized entities',
+    std: 'unused',
+    source: 'Unexpected definition of an association in an entity with parameters',
+    target: 'Expected association target to have no parameters',
   },
   'def-unexpected-calcview-assoc': {
-    std: 'SAP HANA doesn\'t allow associations in/to entities annotated with $(ANNO)',
-    'entity-persistence': 'SAP HANA doesn\'t allow associations in entities annotated with $(ANNO)',
-    'target-persistence': 'SAP HANA doesn\'t allow associations pointing to entities annotated with $(ANNO)',
+    std: 'unused',
+    'source': 'Unexpected definition of an association in an entity annotated with $(ANNO)',
+    'target': 'Expected association target not to be annotated with $(ANNO)',
   },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
@@ -657,6 +660,12 @@ const centralMessageTexts = {
     elements: 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
     actions: 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
   },
+  'ref-invalid-override': {
+    std: 'Overridden element of include must not change element structure', // unused
+    'new-not-structured': 'Expected element $(NAME) to be structured, because it overrides the included element from $(ART)',
+    'old-not-structured': 'Expected element $(NAME) to be scalar, because it overrides the included element from $(ART)',
+    missing: 'Expected element $(ID) to have at least all the same sub-elements as included artifacts, but it is missing $(NAME)'
+  },
 
   // TODO: rename to ref-expected-XYZ
   'expected-actionparam-type': 'A type, an element, or a service entity is expected here',
@@ -753,12 +762,12 @@ const centralMessageTexts = {
   },
   // version independent messages
   'odata-spec-violation-key-array': {
-    std: 'Unexpected array type for element $(NAME)',
-    scalar: 'Unexpected array type',
+    std: 'Unexpected array type for primary key $(NAME)',
+    assoc: 'Unexpected target cardinality $(VALUE) for primary key $(NAME)',
   },
   'odata-spec-violation-key-null': {
-    std: 'Expected key element $(NAME) to be not nullable', // structured
-    scalar: 'Expected key element to be not nullable' // flat
+    std: 'Expected key element $(NAME) to be not nullable', // flat
+    scalar: 'Expected key element $(NAME) to be not nullable', // structured
   },
   'odata-spec-violation-key-type': {
     std: 'Unexpected $(TYPE) mapped to $(ID) as type for key element $(NAME)', // structured

package/lib/base/messages.js

@@ -670,7 +670,7 @@ const paramsTransform = {
   alias: quote.double,
   anno,
   annos: transformManyWith( anno ),
-  delimited: n => quote.single( `![${ n }]` ), // represent as delimited id (TODO: double-']')
+  delimited: n => quote.single( asDelimitedId(n) ),
   file: quote.single,
   option: quote.single,
   prop: quote.single,
@@ -708,6 +708,11 @@ const paramsTransform = {
   version: quote.single, // TODO delete: just use for OData $(VERSION), with version: 2.0
 };
 
+function asDelimitedId(id) {
+  // Same as in toCdl, but we don't want cyclic dependencies to toCdl.
+  return `![${id.replace(/]/g, ']]')}]`;
+}
+
 function anno( name ) {
   return (name.charAt(0) === '@') ? quote.double( name ) : quote.double( `@${ name }` );
 }

package/lib/base/model.js

@@ -29,10 +29,10 @@ const availableBetaFlags = {
   ignoreAssocPublishingInUnion: true,
   enableUniversalCsn: true,
   postgres: true,
-  aspectWithoutElements: true,
-  odataOpenType: true,
+  aspectWithoutElements: true, // TODO: do not just remove beta flag - remove elements, too!
   odataTerms: true,
   optionalActionFunctionParameters: true,
+  calculatedElementsOnWrite: true,
   // disabled by --beta-mode
   nestedServices: false,
   v4preview: false,

package/lib/checks/.eslintrc.json

@@ -16,6 +16,7 @@
     "jsdoc/require-param-description": 0,
     // there seem to be false positives
     "jsdoc/require-returns-check": 0,
+    "jsdoc/tag-lines": 0,
     // =airbnb, >eslint:
     "max-len": [ "error", {
       "code": 110,

package/lib/checks/actionsFunctions.js

@@ -67,7 +67,7 @@ function checkActionOrFunction( art, artName, prop, path ) {
    * @param {string} actKind 'action' or 'function'
    */
   function checkActionOrFunctionParameter( param, currPath, actKind ) {
-    const paramType = param.type ? this.csnUtils.getFinalBaseTypeWithProps(param.type) : param;
+    const paramType = param.type ? this.csnUtils.getFinalTypeInfo(param.type) : param;
     if (!paramType)
       return; // no type could be resolved
 
@@ -80,7 +80,7 @@ function checkActionOrFunction( art, artName, prop, path ) {
       });
     }
 
-    if (param.type && this.csnUtils.isAssocOrComposition(param.type)) {
+    if (param.type && this.csnUtils.isAssocOrComposition(param)) {
       this.error(null, currPath, { '#': actKind }, {
         std: 'An association is not allowed as this artifact\'s parameter type', // Not used
         action: 'An association is not allowed as action\'s parameter type',
@@ -103,11 +103,11 @@ function checkActionOrFunction( art, artName, prop, path ) {
    * @param {string} actKind 'action' or 'function'
    */
   function checkReturns( returns, currPath, actKind ) {
-    const finalReturnType = returns.type ? this.csnUtils.getFinalBaseTypeWithProps(returns.type) : returns;
+    const finalReturnType = returns.type ? this.csnUtils.getFinalTypeInfo(returns.type) : returns;
     if (!finalReturnType)
       return; // no type, e.g. `type of V:calculated`; already an error in `checkTypeOfHasProperType()`
 
-    if (this.csnUtils.isAssocOrComposition(finalReturnType.type)) {
+    if (this.csnUtils.isAssocOrComposition(returns)) {
       this.error(null, currPath, { '#': actKind },
                  {
                    std: 'An association is not allowed as this artifact\'s return type', // Not used
@@ -117,9 +117,9 @@ function checkActionOrFunction( art, artName, prop, path ) {
     }
 
     if (finalReturnType.items) // check array return type
-      checkReturns.bind(this)(finalReturnType.items, currPath.concat('items'), actKind);
+      checkReturns.call(this, finalReturnType.items, currPath.concat('items'), actKind);
     else // check if return type is user defined from the current service
-      checkUserDefinedType.bind(this)(finalReturnType, returns.type, currPath);
+      checkUserDefinedType.call(this, finalReturnType, returns.type, currPath);
   }
 
   /**

package/lib/checks/annotationsOData.js

@@ -23,7 +23,7 @@ function checkCoreMediaTypeAllowence( member ) {
     'cds.hana.CLOB': 1,
     'cds.hana.BINARY': 1,
   };
-  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type in allowedCoreMediaTypes)) {
+  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalTypeInfo(member.type)?.type in allowedCoreMediaTypes)) {
     this.warning(null, member.$path, { names: [ 'Edm.String', 'Edm.Binary' ] },
                  'Element annotated with “@Core.MediaType” should be of a type mapped to $(NAMES)');
   }

package/lib/checks/elements.js

@@ -1,6 +1,8 @@
 'use strict';
 
-const { forEachMember, forEachMemberRecursively, isBuiltinType } = require('../model/csnUtils');
+const {
+  forEachMember, forEachMemberRecursively, isBuiltinType, cardinality2str,
+} = require('../model/csnUtils');
 const { isGeoTypeName } = require('../compiler/builtins');
 const { setProp } = require('../base/model');
 // Only to be used with validator.js - a correct `this` value needs to be provided!
@@ -36,7 +38,7 @@ function checkPrimaryKey( art ) {
    */
   function checkIfPrimaryKeyIsOfGeoType( member, elemFqName, parentIsKey, parentPath ) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
+      const finalBaseType = this.csnUtils.getFinalTypeInfo(member.type);
       if (isGeoTypeName(finalBaseType?.type)) {
         this.error(null, parentPath || member.$path,
                    { type: finalBaseType.type, name: elemFqName },
@@ -65,10 +67,18 @@ function checkPrimaryKey( art ) {
    */
   function checkIfPrimaryKeyIsArray( member, elemFqName, parentIsKey, parentPath ) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
+      const finalBaseType = this.csnUtils.getFinalTypeInfo(member.type);
       if (member.items || (finalBaseType && finalBaseType.items)) {
-        this.error(null, parentPath || member.$path, { name: elemFqName },
-                   'Array-like type in element $(NAME) can\'t be used as primary key');
+        let msg = 'std';
+        if (member.target)
+          msg = this.csnUtils.isComposition(member) ? 'comp' : 'assoc';
+
+        this.error('def-invalid-key-cardinality', parentPath || member.$path,
+                   {
+                     name: elemFqName,
+                     value: cardinality2str(member, false),
+                     '#': msg,
+                   }, 'Array-like type in element $(NAME) can\'t be used as primary key');
       }
       else if (finalBaseType && this.csnUtils.isStructured(finalBaseType) && !finalBaseType.$visited) {
         setProp(finalBaseType, '$visited', true);
@@ -84,17 +94,17 @@ function checkPrimaryKey( art ) {
   }
 }
 
+
 /**
- * Checks virtual elelemts and throws an error if some is either structured or
+ * Checks virtual elements and throws an error if some is either structured or
  * an association
  *
  * @param {CSN.Element} member Element to be checked
  */
 function checkVirtualElement( member ) {
   if (member.virtual) {
-    if (this.csnUtils.isAssociation(member.type)) { // or Composition ???
-      this.error(null, member.$path, {}, 'Element can\'t be virtual and an association');
-    }
+    if (this.csnUtils.isAssocOrComposition(member))
+      this.error(null, member.$path, {}, 'Element can\'t be virtual and an association or composition');
   }
 }
 
@@ -107,18 +117,19 @@ function checkVirtualElement( member ) {
  */
 function checkManagedAssoc( art ) {
   forEachMemberRecursively(art, (member) => {
-    if (this.csnUtils.isAssocOrComposition(member.type) &&
+    if (this.csnUtils.isAssocOrComposition(member) &&
         !isManagedComposition.bind(this)(member)) {
-      if (member.on)
-        return;
-      const max = member.cardinality && member.cardinality.max;
-      if (max === '*' || Number(max) > 1) {
+      const max = member.cardinality?.max ? member.cardinality.max : 1;
+      if (max !== 1 && !member.on) {
         const isNoDb = art['@cds.persistence.skip'] || art['@cds.persistence.exists'];
         this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path,
-                     { '#': this.csnUtils.isComposition(member.type) ? 'cmp' : 'std' },
                      {
-                       std: 'An association can\'t have cardinality "to many" without an ON-condition',
-                       cmp: 'A composition can\'t have cardinality "to many" without an ON-condition',
+                       value: cardinality2str(member, false),
+                       '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
+                     },
+                     {
+                       std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
+                       comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
                      });
       }
     }

package/lib/checks/foreignKeys.js

@@ -65,7 +65,7 @@ function validateForeignKeys( member, memberName ) {
         delete type.$visited;
       }
     }
-    else if (mem && !mem.type) {
+    else if (mem && !mem.type && this.options.transformation !== 'odata') {
       const variant = member.type === 'cds.Composition' ? 'managedCompForeignKey' : 'managedAssocForeignKey';
       this.error('check-proper-type-of', member.$path, {
         '#': variant, name: memName, art: memberName,

package/lib/checks/invalidTarget.js

@@ -27,7 +27,7 @@ function invalidTarget( member ) {
       if (!target)
         throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
-        const isAssoc = this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type !== 'cds.Composition';
+        const isAssoc = this.csnUtils.getFinalTypeInfo(member.type)?.type !== 'cds.Composition';
         this.error(
           null,
           member.$path,

package/lib/checks/onConditions.js

@@ -79,23 +79,27 @@ function validateOnCondition( member, memberName, property, path ) {
           // For error messages
           const id = logReady(ref[j]);
           const elemref = { ref };
-
-          if (_links[j].art.target && !((_links[j].art === member) || ref[j] === '$self' || ref[j] === '$projection' || (validDollarSelf && j === _links.length - 1))) {
-            if (_links[j].art.on) {
+          const stepArt = _links[j].art;
+          if (stepArt.target &&
+              !(stepArt === member ||
+                ref[j] === '$self' ||
+                ref[j] === '$projection' ||
+                (validDollarSelf && j === _links.length - 1))) {
+            if (stepArt.on) {
               // It's an unmanaged association - traversal is always forbidden
               this.error('ref-unexpected-navigation', csnPath, { '#': 'unmanaged', id, elemref });
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
               const nextRef = ref[j + 1].id || ref[j + 1];
-              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef)) {
+              if (!stepArt.keys.some(r => r.ref[0] === nextRef)) {
                 this.error('ref-unexpected-navigation', csnPath, {
                   '#': 'std', id, elemref, name: nextRef,
                 });
               }
             }
           }
-          if (_links[j].art.virtual)
+          if (stepArt.virtual)
             this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-conditions, step $(ID) of path $(ELEMREF)');
 
           if (ref[j].where)
@@ -104,7 +108,8 @@ function validateOnCondition( member, memberName, property, path ) {
           if (ref[j].args)
             this.error(null, csnPath, { id, elemref }, 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)');
         }
-        if (_art && $scope !== '$self') {
+
+        if (_art && !($scope === '$self' && ref.length === 1)) {
           const type = resolveArtifactType.call(this, _art);
           if (type) {
           // For error messages

package/lib/checks/queryNoDbArtifacts.js

@@ -84,7 +84,7 @@ function checkQueryForNoDBArtifacts( query ) {
         const isJoinRelevant = (assoc, nextStep) => {
           if (!assoc.keys)
             return true;
-          const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art.type);
+          const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art);
           return !assoc.keys
             .some(fk => fk.ref[0] === nextStep && !isExposedColumnAssocOrComposition);
         };

package/lib/checks/types.js

@@ -130,7 +130,7 @@ function checkTypeOfHasProperType( artOrElement, name, model, error, path, deriv
   if (!artOrElement.type)
     return;
 
-  const typeOfType = this.csnUtils.getFinalBaseTypeWithProps(artOrElement.type);
+  const typeOfType = this.csnUtils.getFinalTypeInfo(artOrElement.type);
 
   if (typeOfType === null) {
     if (artOrElement.type.ref && this?.options?.transformation !== 'odata') {

package/lib/checks/utils.js

@@ -59,7 +59,7 @@ function otherSideIsExpandableStructure( on, startIndex ) {
  */
 function resolveArtifactType( art ) {
   if (art && art.type && !isBuiltinType(art.type))
-    return this.csnUtils.getFinalBaseTypeWithProps(art.type);
+    return this.csnUtils.getFinalTypeInfo(art.type);
 
   return art;
 }

package/lib/checks/validator.js

@@ -57,10 +57,12 @@ const forRelationalDBMemberValidators
   checkSqlAnnotationOnElement,
   // no temporal annotations on calc elements
   rejectAnnotationsOnCalcElement,
+  checkElementTypeDefinitionHasType,
 ];
 
 const forRelationalDBArtifactValidators
 = [
+  checkPrimaryKey,
   // @cds.persistence has no impact on odata
   validateCdsPersistenceAnnotation,
   // virtual items are not persisted on the db
@@ -108,12 +110,11 @@ const forOdataQueryValidators = [];
 const commonMemberValidators
 = [ validateOnCondition, validateForeignKeys,
   validateAssociationsInItems, checkForInvalidTarget,
-  checkVirtualElement, checkElementTypeDefinitionHasType ];
+  checkVirtualElement ];
 
 // TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [
   checkTypeDefinitionHasType,
-  checkPrimaryKey,
   checkManagedAssoc,
   checkRecursiveTypeUsage,
 ];

package/lib/compiler/assert-consistency.js

@@ -100,12 +100,13 @@ function assertConsistency( model, stage ) {
         '$builtins',
         '$internal',
         '$compositionTargets',
-        '$lateExtensions',
+        '$collectedExtensions',
         '_entities', '$entity',
         '$blocks',
         '$messageFunctions',
         '$functions',
         '$volatileFunctions',
+        '_sortedSources',
       ],
     },
     ':parser': {                // top-level from parser
@@ -139,6 +140,7 @@ function assertConsistency( model, stage ) {
       },
     },
     sources: { test: isDictionary( isObject ) },
+    _sortedSources: { test: isArray( isObject ) },
     file: { test: isString },
     dirname: { test: isString },  // TODO: really necessary?
     realname: { test: isString }, // TODO: really necessary?
@@ -401,6 +403,8 @@ function assertConsistency( model, stage ) {
         'elements', 'items', 'enum',
         // CSN parser may let these properties slip through to XSN, even if input is invalid.
         'args', 'op', 'func', 'suffix',
+        // calculated elements on-write
+        'stored',
       ],
 
       kind: true,
@@ -471,6 +475,7 @@ function assertConsistency( model, stage ) {
     op: { test: locationVal( isString ) },
     join: { test: locationVal( isString ) },
     quantifier: { test: locationVal( isString ) },
+    stored: { test: locationVal( isBoolean ) },
     // preliminary -----------------------------------------------------------
     doc: {
       kind: true,
@@ -608,7 +613,7 @@ function assertConsistency( model, stage ) {
     $entity: { kind: true, test: TODO },
     _entities: { test: TODO },
     $compositionTargets: { test: isDictionary( isBoolean ) },
-    $lateExtensions: { test: TODO },
+    $collectedExtensions: { test: TODO },
     _upperAspects: { kind: [ 'type', 'entity' ], test: isArray( TODO ) },
 
     // for implicit redirection - direct and indirect query sources of simple