@sap/cds-compiler 5.7.4 → 5.8.2

package/CHANGELOG.md

@@ -7,6 +7,63 @@
 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 5.8.2 - 2025-03-07
+
+### Fixed
+
+- for.odata: Generate foreign key elements for events again.
+
+## Version 5.8.0 - 2025-02-27
+
+### Added
+
+- Type definitions can now be projections on other types, i.e. `type Proj : projection on OtherType { elem }`.  
+  Use it to create types based on other types, e.g. by selecting only certain elements.  
+  Only available with the new parser (`newParser: true`)
+- Analyze enum symbols like `#ENUM_SYMB` in all (sub) expressions and conditions.
+  It can be validated if the compiler can deduce its `enum` type from its use context:
+  + when the enum symbol is used as `default` value, `select` column expression,
+    argument when navigating along an association to an entity with a parameter,
+    or argument of a `cast` function call, or
+  + when the enum symbol is compared to a reference or `cast` function call; we
+    consider the operators `=`, `<>`, `!=`, `in`, `not in` and also analyze enum
+    symbols as `when` operands if the `case` operand is a reference/`cast`.
+  + We not only consider simple enum symbols, but also lists of enum symbols (on
+    the right side of `in`/`not in`), and a `case … end` (sub) expression with
+    enum symbols after the `then`s and/or the `else`.
+  + An enum symbol can be validated if the deduced type is a direct or indirect
+    `enum` type, or an managed association with one foreign key having an `enum` type.
+  + For the effects in the compiler, IDE and backends, see the changelog entry for v5.7.0.
+    Hint: the deprecated hdbcds backend does not support enum symbols.
+  + Remark: the support for enum symbols used as annotation values is still limited.
+- to.sql.migration: Allow extending `precision` of `cds.Decimal` and allow extending
+  `scale` if `precision` is increased by at least the same amount.
+- to.edm(x): `@assert.range` now supports "exclusive" values by writing values
+  in parentheses such as `[ (1), (2) ]`, as well as "infinite" by using `[ _, _ ]`.
+- for.odata/to.edm(x)/for.seal: Propagate annotation expressions from managed associations
+  to the foreign keys
+
+
+### Changed
+
+- Top-level CSN property `csnInteropEffective` is ignored and no longer warned about.
+- Update OData vocabularies: 'Analytics', 'Common', 'Hierarchy', 'UI'
+
+### Fixed
+
+- New CDL parser: parse all entity definitions using `projection on` without a
+  terminating `;` if they had been accepted by the old parser, i.e. for compatibility,
+  we gave up the idea of removing the existing special handling in this case.
+- Old and new parser: issue a warning for an ignored filter on the result
+  of a function or method call.
+- CSN annotation expressions with value `true` for `=` were not checked.
+- Annotation `@Core.Computed` was not set for select items that are paths into structured parameters.
+- Annotation expression path rewriting has been improved.
+  + Paths on foreign keys are rewritten.
+- for.seal:
+  + References into structured parameters were incorrectly flattened.
+  + Set `@cds.persistence.name` only on persistence-relevant things.
+
 ## Version 5.7.4 - 2025-02-05
 
 ### Fixed
@@ -15,6 +72,7 @@ The compiler behavior concerning `beta` features can change at any time without
   + Improve code completion
   + Fix further edge cases in error recovery
 
+
 ## Version 5.7.2 - 2025-01-30
 
 ### Fixed
@@ -49,9 +107,9 @@ The compiler behavior concerning `beta` features can change at any time without
 - CDL parser: doc comment parser was susceptible to ReDos
 - to.sql/hdi: Paths inside calculated elements that are simple functions were not properly rewritten.
 - for.odata: Re-add foreign keys in property `targetAspect` in the OData CSN.
-- to.edm(x): In annotation translation, by default map `SemanticObjectMappingAbstract` to `SemanticObjectMappingType` to avoid regreessions.
+- to.edm(x): In annotation translation, by default map `SemanticObjectMappingAbstract` to `SemanticObjectMappingType` to avoid regressions.
 - to.cdl: Fix quoting of identifier `many` in `Composition of`/`Association to`
-- for.seal: Allow annotation paths to end in `many`-elements, not just scalar, liek we allow in for.odata
+- for.seal: Allow annotation paths to end in `many`-elements, not just scalar, like we allow in for.odata
 
 ## Version 5.6.0 - 2024-12-12
 

package/bin/cdsse.js

@@ -93,6 +93,12 @@ function complete( err, buf ) {
   }
 }
 
+const autoNavigateKinds = {
+  $navElement: art => art._origin,
+  $tableAlias: art => art._origin,
+  using: () => true,
+}
+
 // For finding the definition for reference under cursor, do the following
 //  * replace identifier under cursor by an undefined name
 //  * call compiler and retrieve valid names at cursor position
@@ -116,7 +122,13 @@ function find( err, buf ) {
 
   function show() {
     const vn = messageAt( messages, 'validNames', off.col ) || Object.create(null);
-    const art = vn[buf.substring( off.prefix, off.cursor )];
+    let art = vn[buf.substring( off.prefix, off.cursor )];
+    while (art?._origin && art.$inferred && art._effectiveType ||
+           autoNavigateKinds[art.kind]?.( art ))
+      art = art._origin || art.extern._artifact;
+    // TODO: set _origin in using proxies
+    // TODO: why no _effectiveType for $navElement ?
+    // TODO: display both the (first) inferred _and_ the "final" one
     if (art)
       console.log( `${locationString( art.name.location || art.location )}: Definition` );
     return true;

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 5.8.0 - 2025-02-27
+
+### Added `v6preview`
+
+Use this beta flag to enable features that will be available for cds-compiler v6.
+It also enables new warnings and errors that are intended for the next version.
+
 ## Version 5.3.0 - 2024-09-25
 
 ### Removed `optionalActionFunctionParameters`

package/lib/api/options.js

@@ -55,6 +55,7 @@ const publicOptionsNewAPI = [
   'resolveProjections',
   'remapOdataAnnotations',
   'keepLocalized',
+  'effectiveServiceName',
   // for.seal
   'deriveAnalyticalAnnotations',
   // to.sql.migration
@@ -217,7 +218,7 @@ module.exports = {
       const defaultOptions = {
         sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true, remapOdataAnnotations: false, keepLocalized: false,
       };
-      const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming' ], 'for.effective');
+      const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming', 'effectiveServiceName-and-type-resolution' ], 'for.effective');
 
       return Object.assign({}, processed);
     },

package/lib/api/validate.js

@@ -101,6 +101,11 @@ const validators = {
     expected: () => 'type array of string',
     found: val => `type ${ typeof val }`,
   },
+  effectiveServiceName: {
+    validate: val => typeof val === 'string',
+    expected: () => 'type string',
+    found: val => `type ${ typeof val }`,
+  },
   defaultBinaryLength: {
     validate: val => !Number.isNaN(Number(val)) && Number.isInteger(Number.parseFloat(val)),
 
@@ -154,6 +159,10 @@ const allCombinationValidators = {
     if (options.beta && !options.testMode)
       message.warning('api-unexpected-combination', null, { '#': 'beta-no-test', option: 'beta' });
   },
+  'effectiveServiceName-and-type-resolution': (options, message) => {
+    if (options.effectiveServiceName && !options.resolveSimpleTypes)
+      message.error('api-invalid-combination', null, { '#': 'effectiveServiceName-and-type-resolution', name: 'effectiveServiceName', prop: 'resolveSimpleTypes' });
+  },
 };
 
 const alwaysRunValidators = [ 'beta-no-test' ];

package/lib/base/message-registry.js

@@ -14,7 +14,8 @@
 // always configurable; useful for issues like deprecated syntax variants which
 // do not affect the compiler or CSN processors.  Temporarily, we also allow
 // value `deprecated` for errors which are only configurable if the option
-// `deprecated.downgradableErrors` is set.
+// `deprecated.downgradableErrors` is set.  If a string like `v6`, it works like
+// `true`, but is meant to be removed with the next major version.
 
 // Messages other than errors can always be reclassified by the user except if
 // the module is listed in the message's `errorFor` property.
@@ -43,6 +44,7 @@ const { createDict } = require('../utils/objectUtils');
  *
  * configurableFor: truthy = error can be downgraded in certain situations
  *  - true = can always be downgraded, we do not really care
+ *  - 'v4', 'v6' etc: like `true`, but is intended to be removed with next major
  *  - [‹module›, …] = can be downgraded in compiler function ‹module›
  *  - 'deprecated' = severity can only be changed with deprecated.downgradableErrors
  *
@@ -91,10 +93,12 @@ const centralMessages = {
 
   'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
   'ref-deprecated-self-element': { severity: 'Error', configurableFor: true },
+  'ref-deprecated-variable': { severity: 'Warning', errorFor: [ 'v6' ] },
   'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
   'ref-invalid-include': { severity: 'Error' },
   'type-unexpected-typeof': { severity: 'Error' },
+  'type-unexpected-null': { severity: 'Warning', errorFor: [ 'v6' ] },
   'type-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'type-expecting-service-target': { severity: 'Error', configurableFor: true },
@@ -159,15 +163,15 @@ const centralMessages = {
   // fallback, but then parse.cdl is not supposed to work correctly (it can
   // then either issue an error or produce a CSN missing some annotations):
   'syntax-duplicate-annotate': { severity: 'Error' },
-  'syntax-duplicate-clause': { severity: 'Error', configurableFor: true },
+  'syntax-duplicate-clause': { severity: 'Error', configurableFor: 'v6' },
   // remark: a hard syntax error in new parser for `null` together with `not null`
   'syntax-duplicate-equal-clause': { severity: 'Warning', errorFor: [ 'v6' ] },
   'syntax-invalid-name': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
   'syntax-missing-proj-semicolon': { severity: 'Warning', errorFor: [ 'v6' ] },
   'syntax-unexpected-after': { severity: 'Warning', errorFor: [ 'v6' ] },
+  'syntax-unexpected-filter': { severity: 'Warning', errorFor: [ 'v6' ] },
   'syntax-unexpected-many-one': { severity: 'Error', configurableFor: true }, // TODO: remove `configurableFor` soon, latest v6
-  'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
   'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
@@ -278,6 +282,7 @@ const centralMessageTexts = {
     'sql-dialect-and-naming': 'sqlDialect $(NAME) can\'t be combined with sqlMapping $(PROP)',
     'tenant-and-naming': 'Option $(OPTION) can\'t be combined with sqlMapping $(PROP) - expected sqlMapping $(VALUE)',
     'dry-and-script': 'script:true must be combined with dry:true, found $(VALUE)',
+    'effectiveServiceName-and-type-resolution': 'Option $(NAME) can\'t be used without $(PROP)',
   },
   'api-unexpected-combination': {
     std: 'Unexpected option combination: $(OPTION) and $(PROP)', // unused
@@ -378,6 +383,7 @@ const centralMessageTexts = {
     many: 'Unexpected $(KEYWORD) after array type',
     enum: 'Unexpected annotation assignment after enum type',
   },
+  'syntax-unexpected-filter': 'Unexpected filter on the result of a function call',
   'syntax-unexpected-many-one': 'Replace $(CODE) with $(DELIMITED) to avoid an ambiguity with managed compositions of anonymous aspects',
   'syntax-invalid-name': {
     std: 'Identifier must consist of at least one character', // only via delimited id
@@ -458,7 +464,6 @@ const centralMessageTexts = {
     std: 'Unexpected $(KEYWORD) inside $(CODE) block',
     'new-parser': 'Unexpected $(OFFENDING) inside $(CODE) block, expecting $(EXPECTING)',
   },
-  'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
   'syntax-unexpected-token': {
     std: 'Mismatched $(OFFENDING), expecting $(EXPECTING)',
     unwanted: 'Extraneous $(OFFENDING), expecting $(EXPECTING)',
@@ -512,6 +517,7 @@ const centralMessageTexts = {
   'syntax-expecting-string': {
     std: 'Expecting non-empty string for property $(PROP)',
     'or-object': 'Expecting non-empty string or object for property $(PROP)',
+    'or-bool': 'Expecting non-empty string or boolean for property $(PROP)',
     'or-null': 'Expecting non-empty string or null for property $(PROP)',
   },
   // 'syntax-expecting-boolean' (Warning), 'syntax-expecting-scalar',
@@ -581,6 +587,21 @@ const centralMessageTexts = {
   },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
+  'expr-unexpected-argument': {
+    // TODO: change to `Arguments…`
+    std: 'Parameters can only be provided when navigating along associations',
+    from: 'Parameters can only be provided for the source entity or associations',
+    tableAlias: 'Arguments can\'t be provided for table aliases, only when navigating along associations',
+    // no-params TODO: extra message id or a variant of expr-undefined-param
+    'no-params': 'Unexpected arguments for entity $(ART) without parameters',
+  },
+  'expr-unexpected-filter': {
+    std: 'A filter can only be provided when navigating along associations',
+    // to help users for `… from E:toF { toF[…].x }`
+    tableAlias: 'A filter can only be provided when navigating along associations, but found table alias',
+    from: 'A filter can only be provided for the source entity or associations',
+  },
+
   // multi-line strings: --------------------------------------------------------
   'syntax-unknown-escape': 'Unknown escape sequence $(CODE)',
   'syntax-invalid-escape': {
@@ -717,11 +738,11 @@ const centralMessageTexts = {
   },
 
   'ref-unexpected-navigation': {
-    std: 'Can\'t follow association $(ID) in path $(ELEMREF) in an ON-condition; only foreign keys can be referred to, but not $(NAME)',
-    unmanaged: 'Can\'t follow unmanaged association $(ID) in path $(ELEMREF) in an ON-condition',
+    std:       'Can\'t follow association $(ID) in path $(ELEMREF) in an ON-condition; only foreign keys can be referred to, but not $(NAME)',
+    unmanaged: 'Can\'t follow association $(ID) in path $(ELEMREF) in an ON-condition',
     unmanagedleaf: 'Unexpected unmanaged association as final path step of $(ELEMREF) in an ON-condition',
-    'calc-non-fk': 'Can\'t follow association $(ID) in path $(ELEMREF) in a stored calculated element; only foreign keys can be referred to, but not $(NAME)',
-    'calc-unmanaged': 'Can\'t follow unmanaged association $(ID) in path $(ELEMREF) in a stored calculated element',
+    'calc-non-fk':    'Can\'t follow association $(ID) in path $(ELEMREF) in a stored calculated element; only foreign keys can be referred to, but not $(NAME)',
+    'calc-unmanaged': 'Can\'t follow association $(ID) in path $(ELEMREF) in a stored calculated element',
   },
   'ref-unexpected-filter': {
     std: 'Unexpected filter in path $(ELEMREF)', // unused
@@ -759,7 +780,7 @@ const centralMessageTexts = {
     std:  'Rewriting the ON-condition not supported here', // unused: merge with 'rewrite-not-supported'
     'sub-element': 'Rewriting the ON-condition of unmanaged association in sub element is not supported',
   },
-  'rewrite-undefined-key': 'Expected element $(ID) to be available in $(TARGET), as it is required to match the foreign key of $(NAME)',
+  'rewrite-undefined-key': 'Can\'t redirect association $(NAME), as redirection target $(TARGET) does not project element $(ID), which is required to match foreign key of $(NAME)',
 
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
@@ -805,6 +826,16 @@ const centralMessageTexts = {
     targetAspect: 'Unexpected $(KEYWORD) on composition of aspect',
     map: 'Unexpected $(KEYWORD) for type $(TYPE)',
   },
+  'type-unexpected-null': {
+    std: 'Unexpected default value $(VALUE) for non-nullable artifact',
+
+    typeDefaultNull: 'Unexpected default value $(VALUE) for non-nullable type',
+    typeNotNull: 'Unexpected $(KEYWORD) for type with default value $(VALUE)',
+    elementDefaultNull: 'Unexpected default value $(VALUE) for non-nullable element',
+    elementNotNull: 'Unexpected $(KEYWORD) for element with default value $(VALUE)',
+    paramDefaultNull: 'Unexpected default value $(VALUE) for non-nullable parameter',
+    paramNotNull: 'Unexpected $(KEYWORD) for parameter with default value $(VALUE)',
+  },
   'type-expecting-service-target': {
     std: 'Expecting service entity $(TARGET)',
     ref: 'Expecting service entity $(TARGET); its element $(ID) referred to at line $(LINE), column $(COL) is not from an element with the same name in the provided model target',
@@ -868,7 +899,10 @@ const centralMessageTexts = {
     invalidType: 'Unexpected $(PROP) for element of type $(TYPE)',
   },
   'def-unexpected-localized': {
-    std: '$(ART) can\'t have localized elements',
+    std: 'Unexpected $(KEYWORD)',
+    struct: 'Unexpected $(KEYWORD) for structured type',
+    map: 'Unexpected $(KEYWORD) for map type',
+    elements: '$(ART) can\'t have localized elements',
     // TODO: Better message?
     include:  '$(ART) can\'t have localized elements (through include)',
   },
@@ -971,8 +1005,9 @@ const centralMessageTexts = {
     event: 'A type, an element, an event, or a service entity is expected here',
   },
   'ref-invalid-source': {
-    std: 'A query source must be an entity or an association',
-    event: 'An event\'s projection source must be an entity, structured type, event or an association',
+    std: 'A query source must be an entity or an association element',
+    event: 'An event\'s projection source must be an entity, structured type, aspect, event, or an association element',
+    type: 'A type\'s projection source must be an entity, structured type, aspect, event, or an association element',
   },
   'extend-columns': {
     std: 'Artifact $(ART) can\'t be extended with columns, only simple views/projections without JOINs and UNIONs can',
@@ -1144,10 +1179,10 @@ const centralMessageTexts = {
   'odata-spec-violation-assoc': 'Unexpected association in structured type for OData $(VERSION)',
   'odata-spec-violation-constraints': 'Partial referential constraints produced for OData $(VERSION)',
   'odata-spec-violation-id': {
-    std: 'Expected EDM name $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
-    v2firstchar: 'Unexpected first character $(PROP) of EDM Name $(ID) for OData $(VERSION)',
-    qualifier: 'Expected annotation qualifier $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
-    vocrefalias: 'Expected value $(VALUE) of vocabulary reference attribute $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
+    std: 'Expected OData name $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
+    v2firstChar: 'Unexpected first character $(PROP) of OData name $(ID) for OData $(VERSION)',
+    qualifier: 'Expected OData annotation qualifier $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
+    vocRefAlias: 'Expected value $(VALUE) of OData vocabulary reference attribute $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
   },
   // version independent messages
   'odata-spec-violation-key-array': {
@@ -1310,8 +1345,8 @@ const centralMessageTexts = {
     changed: 'Changed element $(ID) is a primary key change and will not work if the table contains data',
   },
   'migration-unsupported-precision-change': {
-    std: 'Changed element $(ID) is a precision change and is not supported',
-    script: 'Changed element $(ID) is a precision change and might lead to data loss',
+    std: 'Changed element $(ID) is a lossy precision change and is not supported',
+    script: 'Changed element $(ID) is a lossy precision change and might lead to data loss',
   },
   'migration-unsupported-element-drop': {
     std: 'Dropping elements is not supported',
@@ -1322,8 +1357,8 @@ const centralMessageTexts = {
     script: 'Changed element $(ID) is a length reduction and might lead to data loss',
   },
   'migration-unsupported-scale-change': {
-    std: 'Changed element $(ID) is a scale change and is not supported',
-    script: 'Changed element $(ID) is a scale change and might lead to data loss',
+    std: 'Changed element $(ID) is a lossy scale change and is not supported',
+    script: 'Changed element $(ID) is a lossy scale change and might lead to data loss',
   },
   'migration-unsupported-change': {
     std: 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported',

package/lib/base/messages.js

@@ -1465,8 +1465,11 @@ 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');
+
+  if (suffix && art.targetAspect)
+    r.push( 'target' );
+  else if (suffix)
+    r.push( art.items?.items ? `items:${ suffix }` : 'items' );
 
   return r.join('/');
 }

package/lib/base/model.js

@@ -25,9 +25,12 @@ const availableBetaFlags = {
   tenantVariable: true,
   calcAssoc: true,
   temporalRawProjection: true,
+  v6preview: true,
+  draftMessages: true,
+  rewriteAnnotationExpressionsViaType: true,
+  sqlServiceDummies: true,
   // disabled by --beta-mode
   nestedServices: false,
-  rewriteAnnotationExpressionsViaType: false,
 };
 
 // Used by isDeprecatedEnabled() to check if any flag ist set.

package/lib/checks/assocOutsideService.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * Asserts that there is no association usage outside of the specified service.
+ * We do not check in type-ofs - we resolve them, so they are not a problem.
+ *
+ * @param {object} parent - The parent object in the CSN (Core Schema Notation).
+ * @param {string} prop - The property name of the parent object.
+ * @param {object} ref - The reference object.
+ * @param {Array} path - The path array indicating the location in the CSN.
+ * @param {object} grandparent - The grandparent object in the CSN.
+ * @param {string} parentProp - The property name of the grandparent object.
+ */
+function assertNoAssocUsageOutsideOfService( parent, prop, ref, path, grandparent, parentProp ) {
+  const artifactName = path[1];
+  if (parentProp === 'type')
+    return;
+
+  if (this.csn.definitions[this.options.effectiveServiceName]?.kind !== 'service' ||
+      !artifactName.startsWith(`${ this.options.effectiveServiceName }.`))
+    return;
+
+  const { _links } = parent;
+  if (_links?.length <= 1)
+    return;
+
+  for (let i = 0; i < _links.length - 1; i++) {
+    const { art } = _links[i];
+    if (art.target && !art.target.startsWith(`${ this.options.effectiveServiceName }.`)) {
+      this.error('assoc-invalid-outside-service', path.concat('ref', i),
+                 { name: this.options.effectiveServiceName, id: ref[i].id || ref[i] },
+                 'Association $(ID) pointing outside of service $(NAME) must not be used');
+      return;
+    }
+  }
+}
+
+module.exports = {
+  ref: assertNoAssocUsageOutsideOfService,
+};

package/lib/checks/featureFlags.js

@@ -2,7 +2,7 @@
 
 const { setProp } = require('../base/model');
 const { featureFlags } = require('../transform/featureFlags');
-const { isSqlService } = require('../transform/db/processSqlServices');
+const { isSqlService, isDummyService } = require('../transform/db/processSqlServices');
 
 /**
  *
@@ -29,5 +29,8 @@ module.exports = {
   kind: function setFeatureFlagForSqlService( artifact ) {
     if (isSqlService(artifact))
       setFeatureFlag( '$sqlService' ).call(this);
+
+    if (isDummyService(artifact, this.options))
+      setFeatureFlag( '$dummyService' ).call(this);
   },
 };

package/lib/checks/types.js

@@ -52,10 +52,13 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
   // are skipped here.  References to such columns are checked further below.
   const parent = this.csn.definitions[path[1]];
 
-  // should only happen with csn input, not in cdl
-  // calculated elements on-read may not have a .type (requires beta flag)
+  // Type elements are not required to have a type.
+  // This can also happen via type projections.
+  // Elements of views are allowed to be typeless.
+  // Calculated elements on-read may not have a .type (requires beta flag)
   if ((!member.value || member.value.stored) &&
-      !parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
+      (parent.kind === 'type' || !parent.projection && !parent.query) &&
+      !hasArtifactTypeInformation(member)) {
     errorAboutMissingType(this.error, path, member, memberName, true);
     return;
   }
@@ -69,7 +72,7 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
       );
     }
     else if (member._type) {
-      if ( this.isAspect(member._type) || member._type.kind === 'type' && member._type.$syntax === 'aspect')
+      if ( member._type?.kind === 'aspect' || member._type.kind === 'type' && member._type.$syntax === 'aspect')
         this.error('ref-sloppy-type', path, {}, 'A type or an element is expected here');
     }
     return;

package/lib/checks/validator.js

@@ -50,6 +50,7 @@ const {
   checkSqlAnnotationOnArtifact,
   checkSqlAnnotationOnElement,
 } = require('./sql-snippets');
+const assertNoAssocUsageOutsideOfService = require('./assocOutsideService');
 const featureFlags = require('./featureFlags');
 
 const forRelationalDBMemberValidators
@@ -196,6 +197,8 @@ function getDBCsnValidators( options ) {
     validations.push(checkForParams.csnValidator);
   if (options.sqlDialect === 'h2' || options.sqlDialect === 'postgres')
     validations.push(checkForHanaTypes);
+  if (options.transformation === 'effective' && options.effectiveServiceName)
+    validations.push(assertNoAssocUsageOutsideOfService);
 
   return validations;
 }

package/lib/compiler/assert-consistency.js

@@ -427,17 +427,17 @@ function assertConsistency( model, stage ) {
     },
     $tokenTexts: {
       parser: true,
-      test: isString,
+      test: isStringOrBool,
     },
     value: {
       optional: [
         'location', '$inferred', 'sort', 'nulls',
         'param', 'scope', // for dynamic parameter '?'
-        // A2J wrongly propagates the following into a CAST of the CSN passed to compileX:
+        // before recompilation for A2J, named types are replaced by the base
+        // definition (TODO v6 remove, we can probably remove elements+items now)
         '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
+        // calculated elements on-write - TODO: outside `value`
         'stored',
       ],
 
@@ -472,6 +472,8 @@ function assertConsistency( model, stage ) {
           '$parens',
           '_artifact',          // _artifact with "localized data"s 'coalesce'
           'sort', 'nulls',      // if used in GROUP BY
+          'enum',               // for CAST in A2J recompilation (TODO v6: remove)
+          // `elements` of type is not put into cast, many will be cds.LargeString
           ...typeProperties,    // for CAST
         ],
       },
@@ -643,7 +645,6 @@ function assertConsistency( model, stage ) {
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
         '$limit', 'limit', '_status', '_origin',
-        '_effectiveType', '$effectiveSeqNo',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -1025,6 +1026,11 @@ function assertConsistency( model, stage ) {
       isString( node, parent, prop, spec );
   }
 
+  function isStringOrBool( node, parent, prop, spec ) {
+    if (typeof node !== 'boolean')
+      isString( node, parent, prop, spec );
+  }
+
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
       throw new InternalConsistencyError( `Expected string but found ${ typeof node }${ at( [ node, parent ], prop ) }` );