@sap/cds-compiler 6.2.2 → 6.3.0

package/CHANGELOG.md

@@ -8,6 +8,41 @@ Note: `beta` fixes, changes and features are usually not listed in this ChangeLo
 but in [doc/CHANGELOG_BETA.md](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 6.3.0 - 2025-08-28
+
+### Added
+
+- compiler: Column casts can now use more modifiers such as `default` directly.
+- for.odata/to.edm(x):
+  + New option `draftUserDescription` is now available. It adds the fields `CreatedByUserDescription`,
+    `LastChangedByUserDescription`, `InProcessByUserDescription` to the `DraftAdministrativeData` entity.
+- to.sql:
+  + Structures with only one element can now be compared to scalar values.
+    This also applies to associations with only one foreign key.
+  + `cds.UInt8` can now be used in SQL dialects "h2" and "postgres".
+  + Managed associations can now be used in comparisons, e.g. `assoc = struct`.
+  + Structures and managed associations with only one element can be compared with scalars, e.g. `struct = 1`.
+  + In the draft use case, the `DRAFT.DraftAdministrativeData` entity now includes the following fields by default:
+  `CreatedByUserDescription`, `LastChangedByUserDescription`, `InProcessByUserDescription`, and `DraftMessages`.
+
+### Changed
+
+- Update OData vocabularies: Common
+- cdsc: EDMX output uses XML comments as service separators instead of `//`.
+        If there is only one service, no header is printed, allowing piping the output to a file.
+- to.sql: path expressions which end in a foreign key are now always optimized to use the element of the source side.
+
+### Fixed
+
+- compiler: Redirecting associations to non-query entities was fixed.
+- to.sql/to.edm(x): References to associations can now be compared to other associations and structures.
+- to.sql: Referencing a foreign key of an `@cds.persistence.skip` entity previously caused an
+  error in queries. Now the foreign key in the source entity is resolved and rendered.
+
+### Removed
+
+- for.odata/to.edm(x): The `addAnnotationAddressViaNavigationPath` option has been removed. Its functionality is included in the `draftMessages` option.
+
 ## Version 6.2.2 - 2025-07-28
 
 ### Fixed

package/bin/cdsc.js

@@ -462,13 +462,15 @@ async function executeCommandLine( command, options, args ) {
     }
     else if (options.json) {
       const result = main.to.edm.all(csn, options);
+      const omitHeadline = Object.keys(result).length === 1;
       for (const serviceName in result)
-        writeToFileOrDisplay(options.out, `${ serviceName }.json`, result[serviceName]);
+        writeToFileOrDisplay(options.out, `${ serviceName }.json`, result[serviceName], omitHeadline);
     }
     else {
       const result = main.to.edmx.all(csn, options);
+      const omitHeadline = Object.keys(result).length === 1;
       for (const serviceName in result)
-        writeToFileOrDisplay(options.out, `${ serviceName }.xml`, result[serviceName]);
+        writeToFileOrDisplay(options.out, `${ serviceName }.xml`, result[serviceName], omitHeadline);
     }
     return model;
   }
@@ -710,8 +712,13 @@ async function executeCommandLine( command, options, args ) {
           hdbview: true,
           hdbprojectionview: true,
         };
-        const commentStarter = fileName.split('.').pop() in sqlTypes ? '--$' : '//';
-        process.stdout.write(`${ commentStarter } ------------------- ${ fileName } -------------------\n`);
+        if (fileName.endsWith('.xml')) {
+          process.stdout.write(`<!-- ------------------- ${ fileName.replaceAll('-->', '-- >') } ------------------- -->\n`);
+        }
+        else {
+          const commentStarter = fileName.split('.').pop() in sqlTypes ? '--$' : '//';
+          process.stdout.write(`${ commentStarter } ------------------- ${ fileName } -------------------\n`);
+        }
       }
 
       process.stdout.write(`${ content }\n`);

package/lib/api/options.js

@@ -36,7 +36,6 @@ const publicOptionsNewAPI = [
   'booleanEquality',
   'dollarNowAsTimestamp',
   // ODATA
-  'addAnnotationAddressViaNavigationPath',
   'odataOpenapiHints',
   'edm4OpenAPI',
   'odataVersion',
@@ -50,6 +49,7 @@ const publicOptionsNewAPI = [
   'odataVocabularies',
   'odataNoCreator',
   'draftMessages',
+  'draftUserDescription',
   'service',
   'serviceNames',
   // to.cdl

package/lib/base/message-registry.js

@@ -178,7 +178,7 @@ const centralMessages = {
   'service-nested-context': { severity: 'Error', configurableFor: true }, // does not hurt compile, TODO
   'service-nested-service': { severity: 'Error' }, // not supported yet; TODO: configurableFor:'test'?
 
-  'expr-unexpected-operator': { severity: 'Error', configurableFor: true },
+  'expr-unexpected-operator': { severity: 'Error' },
 
   // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
   // Also used by other projects that rely on double-quotes for delimited identifiers.
@@ -196,7 +196,7 @@ const centralMessages = {
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
   'syntax-missing-proj-semicolon': { severity: 'Warning' },
   'syntax-unexpected-after': { severity: 'Error' },
-  'syntax-unexpected-filter': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-filter': { severity: 'Error', configurableFor: 'v7' },
   'syntax-unexpected-many-one': { severity: 'Error' },
   'syntax-deprecated-ref-virtual': { severity: 'Error' },
   'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
@@ -786,8 +786,11 @@ const centralMessageTexts = {
     calc: 'Calculated elements can\'t use parameter references',
   },
   'ref-unexpected-structured': {
-    std: 'Unexpected usage of structured type $(ELEMREF)',
-    expr: 'Structured elements can\'t be used in expressions',
+    std: 'Unexpected usage of structured element $(ELEMREF)',
+    assoc: 'Unexpected usage of managed association $(ELEMREF)',
+    'struct-expr': 'Structured element $(ELEMREF) can\'t be used in expressions with scalars; only possible for structures with one leaf-element',
+    'assoc-expr': 'Associations $(ELEMREF) can\'t be used in expressions with scalars; only possible for association with one foreign key',
+    complexExpr: 'Unexpected reference to a structured element $(ELEMREF) in expression $(VALUE)',
   },
   'ref-unexpected-virtual': {
     std: 'Unexpected reference to virtual element $(NAME)', // "std" currently unused
@@ -801,8 +804,14 @@ const centralMessageTexts = {
     'with-filter': 'Unexpected reference to an association with filter',
     'self-with-filter': 'Unexpected column reference starting with $(ALIAS) to an association with filter',
     self: 'A reference to an unmanaged association is only valid when compared via $(CODE)',
+
     expr: 'Associations can\'t be used as values in expressions',
     'expr-comp': 'Compositions can\'t be used as values in expressions',
+    'anno-expr': 'Associations can\'t be used in expressions for annotation values',
+    'anno-expr-comp': 'Compositions can\'t be used in expressions for annotation values',
+    'query-expr': 'Unmanaged associations can\'t be used in expressions in queries',
+    'query-expr-comp': 'Unmanaged compositions can\'t be used in expressions in queries',
+
     'assoc-stored': 'Associations and compositions can\'t be used as values in stored calculated elements',
 
     'managed-filter': 'Unexpected managed association $(NAME) in filter expression of $(ID)',
@@ -831,6 +840,7 @@ const centralMessageTexts = {
     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 association $(ID) in path $(ELEMREF) in a stored calculated element',
+    'calc-missing': 'Missing foreign key access for association $(ID) in path $(ELEMREF) in a stored calculated element',
   },
   'ref-unexpected-filter': {
     std: 'Unexpected filter in path $(ELEMREF)', // unused
@@ -983,10 +993,16 @@ const centralMessageTexts = {
   },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
-    virtual: 'Unexpected $(PROP) for virtual element',
+    virtual: 'Unexpected $(KEYWORD) for virtual element',
     // TODO: Better message?
     include: '$(ART) can\'t have additional keys (through include)',
-    invalidType: 'Unexpected $(PROP) for element of type $(TYPE)',
+    invalidType: 'Unexpected $(KEYWORD) for element of type $(TYPE)',
+  },
+  'def-unsupported-key': {
+    std: '$(KEYWORD) is not supported here', // unused variant
+    kind: '$(KEYWORD) is only supported for elements in an entity or an aspect',
+    sub: '$(KEYWORD) is only supported for top-level elements',
+    type: '$(KEYWORD) is not supported for elements of type $(TYPE)',
   },
   'def-unexpected-localized': {
     std: 'Unexpected $(KEYWORD)',
@@ -1046,6 +1062,9 @@ const centralMessageTexts = {
     'include-elements': 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
     'include-actions': 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
   },
+  'ref-invalid-assoc-navigation': {
+    std: 'Invalid navigation along association $(ID) in path $(ELEMREF) to target $(NAME) having annotation $(ANNO)',
+  },
   'ref-invalid-element': {
     std: 'Invalid element reference',
     $tableAlias: 'Can\'t refer to source elements of table alias $(ID)',
@@ -1254,7 +1273,17 @@ const centralMessageTexts = {
     publishingFilter: 'Can\'t publish managed association $(ID) with filter, as it must have at least one foreign key',
   },
 
-  // tenenat isolation via discriminator column:
+  'expr-invalid-expansion': {
+    std: 'Path $(NAME) in expression $(VALUE) can\'t be expanded',
+    'path-mismatch': 'Missing sub path $(NAME) in $(ALIAS) for tuple expansion of $(VALUE); both sides must expand to the same sub paths',
+    'non-scalar': 'Path $(NAME) in expression $(VALUE) can\'t be expanded as it does not contain any scalar element',
+  },
+  'expr-unsupported-expansion': {
+    std: 'Unsupported $(ELEMREF) in structural expression $(VALUE)',
+    scalarRef: 'Unsupported scalar reference $(ELEMREF) in structural expression $(VALUE)',
+  },
+
+  // tenant isolation via discriminator column:
   'tenant-invalid-alias-name': {
     std: 'Can\'t have a table alias named $(NAME) in a tenant-dependent entity',
     implicit: 'Provide an explicit table alias name; do not use $(NAME)',

package/lib/base/messages.js

@@ -911,14 +911,20 @@ function transformElementRef( arg ) {
   if (!ref)
     return quoted( arg );
   // Can be used by CSN backends or compiler to create a simple path such as E:elem
-  return quoted(
-    ((arg.scope === 'param' || arg.param) ? ':' : '') +
+  return quoted( pathToMessageString( arg ) );
+}
+
+function pathToMessageString( arg ) {
+  const ref = arg?.ref || arg?.path || arg; // support CSN and XSN
+  if (!ref)
+    return null;
+
+  return ((arg.scope === 'param' || arg.param) ? ':' : '') +
     ref.map(
       item => (typeof item !== 'string'
         ? `${ item.id }${ item.args ? '(…)' : '' }${ item.where ? '[…]' : '' }`
         : item)
-    ).join('.')
-  );
+    ).join('.');
 }
 
 function transformArg( arg, r, args, texts ) {
@@ -1958,4 +1964,5 @@ module.exports = {
   // for tests only
   constructSemanticLocationFromCsnPath,
   homeName,
+  pathToMessageString,
 };

package/lib/base/model.js

@@ -26,7 +26,6 @@ const availableBetaFlags = {
   calcAssoc: true,
   temporalRawProjection: true,
   v7preview: true,
-  draftMessages: true,
   rewriteAnnotationExpressionsViaType: true,
   sqlServiceDummies: true,
   projectionViews: true,

package/lib/checks/assocOutsideService.js

@@ -1,42 +1,29 @@
 'use strict';
 
+// Only to be used with validator.js - a correct this value needs to be provided!
+const { forEachMemberRecursively } = require('../model/csnUtils');
+
 /**
  * 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.
+ * @param {CSN.Artifact} artifact Artifact to validate
+ * @param {string} artifactName Name of the artifact
  */
-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;
-  // session variables can't have assoc steps, _links of 1 can't have assoc steps
-  // TODO: (typeof parentProp === 'number' && path[path.length - 2] === 'on') - ignore on-conditions, as they are cut off anyway
-  if (parent.$scope === '$magic' || _links?.length <= 1 )
+function assertNoAssocUsageOutsideOfService( artifact, artifactName ) {
+  if (artifact.kind !== 'entity' || this.csn.definitions[this.options.effectiveServiceName]?.kind !== 'service' ||
+    !artifactName.startsWith(`${ this.options.effectiveServiceName }.`))
     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;
-    }
+  if (artifact.kind === 'entity' && (artifact.query || artifact.projection)) {
+    forEachMemberRecursively(artifact, (element, elementName, prop, path) => {
+      if (element && element.target && !element.target.startsWith(`${ this.options.effectiveServiceName }.`)) {
+        this.error('assoc-invalid-outside-service', path,
+                   { name: this.options.effectiveServiceName, id: elementName },
+                   'Association $(ID) pointing outside of service $(NAME) must not be published');
+      }
+    }, [ 'definitions', artifactName ], true, { elementsOnly: true });
   }
 }
 
-module.exports = {
-  ref: assertNoAssocUsageOutsideOfService,
-};
+module.exports = assertNoAssocUsageOutsideOfService;

package/lib/checks/checkForTypes.js

@@ -18,22 +18,6 @@ function checkForHanaTypes( parent, name, type, path ) {
   }
 }
 
-/**
- * Check that `cds.UInt8` is not used - we don't have a clear idea how to represent it on postgres and h2
- *
- * @param {object} parent Object with a type
- * @param {string} name Name of the type property on parent
- * @param {Array} type type to check
- * @param {CSN.Path} path
- */
-function CheckForUInt8( parent, name, type, path ) {
-  const artifact = this.csn.definitions[path[1]];
-  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && parent.type === 'cds.UInt8') {
-    this.error('ref-unexpected-type', [ ...path, 'type' ], { type: 'cds.UInt8', value: this.options.sqlDialect },
-               'Type $(TYPE) can\'t be used with sqlDialect $(VALUE)');
-  }
-}
-
 /**
  * Check types - specifically for postgres and h2
  *
@@ -44,8 +28,6 @@ function CheckForUInt8( parent, name, type, path ) {
  */
 function checkTypes( parent, name, type, path ) {
   checkForHanaTypes.bind(this)(parent, name, type, path);
-  if (this.options.sqlDialect === 'postgres' || this.options.sqlDialect === 'h2')
-    CheckForUInt8.bind(this)(parent, name, type, path);
 }
 
 module.exports = {

package/lib/checks/checkPathsInStoredCalcElement.js

@@ -56,8 +56,9 @@ function _checkPathsInStoredCalcElement( parent, value, csnPath ) {
       else {
         // It's a managed association - access of the foreign keys is allowed
         requireForeignKeyAccess(parent, i, (errorIndex) => {
+          const variant = errorIndex >= value.length ? 'calc-missing' : 'calc-non-fk';
           this.error('ref-unexpected-navigation', csnPath, {
-            '#': 'calc-non-fk', id, elemref: parent, name: value[errorIndex].id || value[errorIndex],
+            '#': variant, id, elemref: parent, name: value[errorIndex]?.id || value[errorIndex],
           });
           hasPathError = true;
         });

package/lib/checks/onConditions.js

@@ -135,7 +135,7 @@ function validateOnCondition( member, memberName, property, path ) {
               ((type.target && type.keys || type.elements) && validStructuredElement ||
               (type.target && validDollarSelf)) && !type.virtual
             ) {
-              // Do nothing - handled by lib/checks/nonexpandableStructured.js
+              // Do nothing - handled by tuple expansion
             }
             else if (type.items && !type.virtual) {
               this.error(null, onPath, { elemref: { ref } },
@@ -183,7 +183,7 @@ function requireForeignKeyAccess( parent, refIndex, noForeignKeyCallback ) {
       ref.splice(refIndex + 1, 1, ...resolved);
   }
 
-  const next = pathId(ref[refIndex + 1]);
+  const next = ref[refIndex + 1] && pathId(ref[refIndex + 1]);
   let possibleKeys = next && assoc.keys.filter(r => r.ref[0] === next);
   if (!possibleKeys || possibleKeys.length === 0) {
     noForeignKeyCallback(refIndex + 1);

package/lib/checks/queryNoDbArtifacts.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isPersistedOnDatabase, hasPersistenceSkipAnnotation } = require('../model/csnUtils');
+const { isPersistedOnDatabase, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { requireForeignKeyAccess } = require('./onConditions');
 const { pathId } = require('../model/csnRefs');
@@ -26,8 +26,13 @@ function checkQueryForNoDBArtifacts( query ) {
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
-        for (const part of queryPart)
-          checkQueryRef.call(this, part, prop === 'columns');
+        const that = this;
+        applyTransformationsOnNonDictionary((query.SELECT || query.SET), prop, {
+          ref: (parent, _name, val, csnPath, tokenStream, refIndex) => {
+            const danglingAssocAllowed = tokenStream[refIndex - 1] !== 'exists';
+            checkQueryRef.call(that, parent, danglingAssocAllowed);
+          },
+        }, { skipStandard: { on: true } });
       }
       else if (typeof queryPart === 'object') {
         checkQueryRef.call(this, queryPart, prop === 'columns');
@@ -119,9 +124,10 @@ function _checkExpandInline( obj, previousRefs = [], previousLinks = [] ) {
  * @param {CSN.Path} ref
  * @param {object[]} _links
  * @param {CSN.Path} $path
- * @param {boolean} inColumns
+ * @param {boolean} danglingAssocAllowed usually optimised to foreign key hence allowed even if target is skipped,
+ *                                       except in from or after exists
  */
-function _checkRef( ref, _links, $path, inColumns ) {
+function _checkRef( ref, _links, $path, danglingAssocAllowed ) {
   if (!ref || !_links )
     return;
 
@@ -129,7 +135,7 @@ function _checkRef( ref, _links, $path, inColumns ) {
   const isPublishedAssoc = this.csnUtils.isAssocOrComposition(_links[_links.length - 1].art);
 
   // Don't check the last element - to allow association publishing in columns
-  for (let i = 0; i < (inColumns ? _links.length - 1 : _links.length); i++) {
+  for (let i = 0; i < (danglingAssocAllowed ? _links.length - 1 : _links.length); i++) {
     const link = _links[i];
     if (!link)
       continue;
@@ -153,8 +159,8 @@ function _checkRef( ref, _links, $path, inColumns ) {
     if (nonPersistedTarget) {
       let isJoinRelevant = isPublishedAssoc || // publishing associations is always join relevant
         isLast || // e.g. FROM targets are always join relevant.
-        isUnmanagedOrNoKeys; // unmanaged associations are always join relevant -> no FKs
-
+        isUnmanagedOrNoKeys || // unmanaged associations are always join relevant -> no FKs
+        ref.slice(i).some(s => s.where || s.args); // function calls or filters are always join relevant
       if (!isJoinRelevant) {
         // for managed, published associations with more than one $path-step, only FK
         // access is allowed.
@@ -164,17 +170,12 @@ function _checkRef( ref, _links, $path, inColumns ) {
       }
 
       if (isJoinRelevant) {
-        const cdsPersistenceSkipped = hasPersistenceSkipAnnotation(targetArt);
-        this.error( null, $path, {
-          '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+        this.error('ref-invalid-assoc-navigation', $path, {
           anno: '@cds.persistence.skip',
           id: nonPersistedTarget.pathStep,
           elemref: { ref },
           name: nonPersistedTarget.name,
-        }, {
-          std: 'Unexpected $(ANNO) annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
-          abstract: 'Unexpected abstract association target $(NAME) of $(ID) in path $(ELEMREF)',
-        } );
+        });
         break; // only one error per path
       }
     }

package/lib/checks/types.js

@@ -152,7 +152,7 @@ function checkTypeOfHasProperType( artOrElement, name, model, error, path, deriv
 
 
 /**
- * Can happen in CSN, e.g. `{ a: { kind: "type" } }` but should not happen in CDL.
+ * Can happen in CSN, e.g. `{ a: { kind: "type" } }` or via `elem;` in CDL.
  *
  * @param {Function} error the error function
  * @param {CSN.Path} path the path to the element or the artifact

package/lib/checks/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../base/builtins');
-const { RelationalOperators } = require('../transform/transformUtils');
+const { RelationalOperators } = require('../transform/tupleExpansion');
 /**
  * Prepare the ref steps so that they are loggable
  *
@@ -17,7 +17,9 @@ function logReady( refStep ) {
  * structured that can be used for tuple expansion. This can either be a
  * real 'elements' thing or a managed association/composition with foreign keys.
  *
- * The RHS may be 'null' or any value
+ * @TODO: This function also allows `is null` on the right-hand-side.
+ *        We should move these checks to the actual tuple expansion, because
+ *        if we're missing cases here, it currently results in incorrect expansion.
  *
  * @param {Array} on the on condition which to check
  * @param {number} startIndex the index of the relational term in the on condition array
@@ -26,8 +28,7 @@ function logReady( refStep ) {
 function otherSideIsExpandableStructure( on, startIndex ) {
   if (on[startIndex - 1] && RelationalOperators.includes(on[startIndex - 1])) {
     const lhs = on[startIndex - 2];
-    // if ever lhs is allowed to be a value uncomment this
-    return /* lhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, lhs?._art));
+    return isOk(resolveArtifactType.call(this, lhs?._art));
   }
   else if (on[startIndex + 1] && RelationalOperators.includes(on[startIndex + 1])) {
     const op = on[startIndex + 1];
@@ -35,8 +36,7 @@ function otherSideIsExpandableStructure( on, startIndex ) {
     if (op === 'is')
       // check for unary operator 'is [not] null' as token stream
       return rhs === 'null' || (rhs === 'not' && on[startIndex + 3] === 'null');
-    // if ever rhs is allowed to be a value uncomment this
-    return /* rhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, rhs?._art));
+    return isOk(resolveArtifactType.call(this, rhs?._art));
   }
   return false;
 
@@ -51,6 +51,29 @@ function otherSideIsExpandableStructure( on, startIndex ) {
   }
 }
 
+/**
+ * Check that the opposite operand to a relational term is s value or "is null".
+ *
+ * @param {Array} expr the expression which to check
+ * @param {number} startIndex the index of the relational term in the expression array
+ * @returns {boolean} indicates whether the other side of a relational term is scalar
+ */
+function otherSideIsValue( expr, startIndex ) {
+  if (expr[startIndex - 1] && RelationalOperators.includes(expr[startIndex - 1]))
+    return expr[startIndex - 2]?.val !== undefined;
+
+  if (expr[startIndex + 1] && RelationalOperators.includes(expr[startIndex + 1])) {
+    const op = expr[startIndex + 1];
+    const rhs = expr[startIndex + 2];
+    if (op === 'is')
+      // check for unary operator 'is [not] null' as token stream
+      return rhs === 'null' || (rhs === 'not' && expr[startIndex + 3] === 'null');
+    return rhs?.val !== undefined;
+  }
+
+  return false;
+}
+
 /**
  * Get the real type of an artifact
  *
@@ -68,5 +91,6 @@ function resolveArtifactType( art ) {
 module.exports = {
   logReady,
   otherSideIsExpandableStructure,
+  otherSideIsValue,
   resolveArtifactType,
 };

package/lib/checks/validator.js

@@ -42,7 +42,6 @@ const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
-const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
 const existsMustEndInAssoc = require('./existsMustEndInAssoc');
 const forbidAssocInExists = require('./existsExpressionsOnlyForeignKeys');
 const checkPathsInStoredCalcElement = require('./checkPathsInStoredCalcElement');
@@ -87,7 +86,6 @@ const forRelationalDBCsnValidators = [
   checkCdsMap,
   existsMustEndInAssoc,
   forbidAssocInExists,
-  nonexpandableStructuredInExpression,
   navigationIntoMany,
   checkPathsInStoredCalcElement,
   featureFlags,
@@ -124,7 +122,7 @@ const forOdataArtifactValidators
   checkReadOnlyAndInsertOnly,
 ];
 
-const forOdataCsnValidators = [ checkCdsMap, nonexpandableStructuredInExpression ];
+const forOdataCsnValidators = [ checkCdsMap ];
 
 const forOdataQueryValidators = [];
 
@@ -202,8 +200,6 @@ 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;
 }
@@ -232,6 +228,9 @@ function forRelationalDB( csn, that ) {
                      },
                      (artifact, artifactName) => {
                        if (that.options.transformation === 'effective') {
+                         if (that.options.effectiveServiceName)
+                           assertNoAssocUsageOutsideOfService.bind(that)(artifact, artifactName);
+
                          forEachMemberRecursively(artifact, checkAnnotationExpression.bind(that), [ 'definitions', artifactName ], false, {
                            skipArtifact: a => a.returns || (a.params && !a.query),
                          });