@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/base/messages.js

@@ -5,8 +5,8 @@
 'use strict';
 
 const { term } = require('../utils/term');
-const { locationString } = require('./location');
-const { isDeprecatedEnabled } = require('./model');
+const { Location, locationString } = require('./location');
+const { isDeprecatedEnabled, isBetaEnabled } = require('./model');
 const { centralMessages, centralMessageTexts, oldMessageIds } = require('./message-registry');
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
 const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
@@ -17,7 +17,6 @@ const { cdlNewLineRegEx } = require('../language/textUtils');
 const fs = require('fs');
 const path = require('path');
 const { inspect } = require('util')
-const { CsnLocation } = require('../compiler/classes');
 
 // term instance for messages
 const colorTerm = term();
@@ -74,12 +73,32 @@ function isDowngradable( messageId, moduleName, options ) {
     return false;
   if (msg.severity !== 'Error')
     return true;
+  // v5 messages are downgradable (except if errorFor also contains the current module).
+  if (msg.errorFor && msg.errorFor.includes('v5'))
+    return true;
   const { configurableFor } = msg;
   return (Array.isArray( configurableFor ))
     ? configurableFor.includes( moduleName )
     : configurableFor && (configurableFor !== 'deprecated' || isDeprecatedEnabled( options, 'downgradableErrors' ));
 }
 
+/**
+ * Returns a marker for messages strings indicating whether the message can be downgraded
+ * or whether it will be an error in the next cds-compiler release.
+ *
+ * @returns {string}
+ */
+function severityChangeMarker(msg, config) {
+  const severity = msg.severity || 'Error';
+  if (config.moduleForMarker) {
+    if (severity === 'Error' && isDowngradable(msg.messageId, config.moduleForMarker, {}))
+      return '‹↓›';
+    if (msg.messageId && centralMessages[msg.messageId]?.errorFor?.includes('v5'))
+      return '‹↑›';
+  }
+  return '';
+}
+
 /**
  * Class for combined compiler errors.  Additional members:
  * - `messages`: array of compiler messages (CompileMessage)
@@ -88,17 +107,16 @@ function isDowngradable( messageId, moduleName, options ) {
 class CompilationError extends Error {
   /**
    * @param {CompileMessage[]} messages
+   * @param {boolean} [dontSerializeMessages] If true, compiler messages are NOT part of the errors message text.
    * @param {XSN.Model} [model] the XSN model, only to be set with options.attachValidNames
    */
-  constructor(messages, model) {
-    // TODO(v5): Don't store stringified messages.
-    super( `CDS compilation failed\n${messages?.map( m => m.toString() ).join('\n') || ''}` );
+  constructor(messages, model, dontSerializeMessages) {
+    const msg = !dontSerializeMessages && messages?.map( m => m.toString() ).join('\n') || '';
+    super( `CDS compilation failed\n${msg}` );
     /** @since v4.0.0 */
     this.code = 'ERR_CDS_COMPILATION_FAILURE';
     this.messages = [ ...messages ].sort(compareMessageSeverityAware);
 
-    // TODO: remove this bin/cdsc.js specifics
-    Object.defineProperty( this, 'hasBeenReported', { value: false, configurable: true, writable: true, enumerable: false } );
     // property `model` is only set with options.attachValidNames:
     Object.defineProperty( this, 'model', { value: model || undefined, configurable: true } );
   }
@@ -113,6 +131,27 @@ class CompilationError extends Error {
     return this.stack || this.message;
   }
 
+  /**
+   * Called when the exception is printed, e.g. when it is not caught.
+   * To give users a bit of information what went wrong, return stringified
+   * error messages.  But only errors to avoid spamming users.
+   *
+   * Compiler consumers should catch compilation errors and properly handle
+   * them by printing messages themselves.
+   *
+   * @returns {string}
+   */
+  toString() {
+    let messages = [ 'CDS compilation failed' ];
+    if (this.messages) {
+      messages = messages.concat(this.messages
+        .filter(msg => msg.severity === 'Error')
+        .map( m => m.toString())
+      );
+    }
+    return messages.join('\n');
+  }
+
   /**
    * @deprecated Use `.messages` instead.
    */
@@ -140,7 +179,7 @@ class CompileMessage {
    */
   constructor(location, msg, severity = 'Error', id = null, home = null, moduleName = null) {
     this.message = msg;
-    this.$location = { __proto__: CsnLocation.prototype, ...location, address: undefined };
+    this.$location = { __proto__: Location.prototype, ...location, address: undefined };
     this.validNames = null;
     this.home = home;  // semantic location, e.g. 'entity:"E"/element:"x"'
     this.severity = severity;
@@ -152,8 +191,14 @@ class CompileMessage {
     // this.error = null;
   }
 
-  toString() {                  // should have no argument...
-    return messageString( this, undefined, true ); // no message-id before finalization!
+  toString() {
+    // Used by cds-dk in their own `toString` wrapper.
+    return messageString( this, {
+      normalizeFilename: false,
+      noMessageId: true, // no message-id before finalization!
+      noHome: false,
+      module: null,
+    });
   }
 }
 
@@ -183,18 +228,28 @@ const severitySpecs = {
  */
 function reclassifiedSeverity( msg, options, moduleName ) {
   const spec = centralMessages[msg.messageId] || { severity: msg.severity, configurableFor: null, errorFor: null };
+  let severity = spec.severity;
+
   if (spec.severity === 'Error') {
     if (!isDowngradable(msg.messageId, moduleName, options))
       return 'Error';
   }
   else {
     const { errorFor } = spec;
-    if (Array.isArray( errorFor ) && errorFor.includes( moduleName ))
-      return 'Error';
+    if (Array.isArray( errorFor )) {
+      if (errorFor.includes(moduleName))
+        return 'Error';
+
+      if (errorFor.includes('v5') && isBetaEnabled(options, 'v5preview')) {
+        severity = 'Error';
+        if (!isDowngradable(msg.messageId, moduleName, options))
+          return severity;
+      }
+    }
   }
 
   if (!options.severities)
-    return spec.severity;
+    return severity;
 
   let newSeverity = options.severities[msg.messageId];
   // The user could have specified a severity through an old message ID.
@@ -202,7 +257,7 @@ function reclassifiedSeverity( msg, options, moduleName ) {
     const oldName = spec.oldNames.find((name => options.severities[name]));
     newSeverity = options.severities[oldName];
   }
-  return normalizedSeverity( newSeverity ) || spec.severity;
+  return normalizedSeverity( newSeverity ) || severity;
 }
 
 function normalizedSeverity( severity ) {
@@ -333,6 +388,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     callTransparently,
     moduleName,
     setModel,
+    setOptions,
   };
 
   function _message( id, location, textOrArguments, severity, texts = null ) {
@@ -352,7 +408,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     if (options.internalMsg)
       msg.error = new Error( 'stack' );
     if (definition)
-      msg.$location.address = { definition };
+      msg.$location.address = { definition }; // TODO: remove
 
     if (id) {
       if (options.testMode && !options.$recompile)
@@ -406,6 +462,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
   /**
    * Normalize the given location. Location may be a CSN path, XSN/CSN location or an
    * array of the form `[CSN.Location, XSN user, suffix]`.
+   * TODO: normalize to [ Location, SemanticLocation ]
    *
    * @param {any} location
    * @returns {[CSN.Location, string, string]} Location, semantic location and definition.
@@ -428,6 +485,9 @@ function makeMessageFunction( model, options, moduleName = null ) {
       ];
     }
 
+    if (location[1]?.mainKind)
+      return [ location[0], location[1].toString(), null ];
+
     let semanticLocation = location[1] ? homeName( location[1], false ) : null;
     if (location[2]) { // optional suffix, e.g. annotation
       semanticLocation += `/${ (typeof location[2] === 'string') ? location[2]: homeName(location[2]) }`;
@@ -494,8 +554,10 @@ function makeMessageFunction( model, options, moduleName = null ) {
   }
 
   function throwWithError() {
-    if (hasNewError)
-      throw new CompilationError( messages, options.attachValidNames && model );
+    if (hasNewError) {
+      const dontSerializeMessages = isBetaEnabled(options, 'v5preview');
+      throw new CompilationError(messages, options.attachValidNames && model, dontSerializeMessages);
+    }
   }
 
   /**
@@ -510,8 +572,10 @@ function makeMessageFunction( model, options, moduleName = null ) {
     if (!messages || !messages.length)
       return;
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
-    if (hasError( messages, moduleName, options ))
-      throw new CompilationError( messages, options.attachValidNames && model );
+    if (hasError( messages, moduleName, options )) {
+      const dontSerializeMessages = isBetaEnabled(options, 'v5preview');
+      throw new CompilationError(messages, options.attachValidNames && model, dontSerializeMessages);
+    }
   }
 
   /**
@@ -561,6 +625,18 @@ function makeMessageFunction( model, options, moduleName = null ) {
   function setModel( _model ) {
     model = _model;
   }
+
+  /**
+   * Change the options used to determine message severities.
+   * This is necessary if you change `options.severities`, as otherwise they may not be picked up.
+   *
+   * @param {CSN.Model} _model
+   */
+  function setOptions( _options ) {
+    options = _options;
+  }
+
+
 }
 
 /**
@@ -942,12 +1018,17 @@ function replaceInString( text, params ) {
  * @param {boolean} [config.noMessageId]
  *     If true, will _not_ show the message ID (+ explanation hint) in the output.
  *
+ * @param {boolean} [config.idInBrackets]
+ *     If true, the message ID (if there is one and noMessageId is falsey) will be put in brackets.
+ *     This will be the default in cds-compiler v5.
+ *
  * @param {boolean} [config.noHome]
  *     If true, will _not_ show message's semantic location.
  *
- * @param {string} [config.module]
+ * @param {string} [config.moduleForMarker]
  *     If set, downgradable error messages will get a '‹↓›' marker, depending on whether
- *     the message can be downgraded for the given module.
+ *     the message can be downgraded for the given module.  A `‹↑›` is used if the message
+ *     will be an error in the next major cds-compiler release.
  *
  * @returns {string}
  */
@@ -958,19 +1039,22 @@ function messageString( err,  config ) {
       normalizeFilename: arguments[1],
       noMessageId: arguments[2],
       noHome: arguments[3],
-      module: arguments[4],
+      moduleForMarker: arguments[4],
     };
   }
+  config.moduleForMarker ??= config.module; // v4.8.0 or earlier compatibility
 
   const location = (err.$location?.file ? `${ locationString( err.$location, config.normalizeFilename ) }: ` : '');
   const severity = err.severity || 'Error';
-  const downgradable = severity === 'Error' && config.module &&
-    isDowngradable(err.messageId, config.module, {}) ? '‹↓›' : '';
+  const downgradable = severityChangeMarker(err, config);
   // even with noHome, print err.home if the location is weak
   const home = !err.home || config.noHome && err.$location?.endLine ? '' : ` (in ${ err.home })`;
-  // TODO: the plan was with brackets = `Error[ref-undefined-def]`
-  const id = err.messageId && !config.noMessageId ? ` ${ err.messageId }` : '';
-  return `${ location }${ severity }${ downgradable }${ id }: ${ err.message }${ home }`;
+
+  let msgId = ''; // TODO(v5): Use brackets only
+  if (err.messageId && !config.noMessageId)
+    msgId = (config.idInBrackets) ? `[${err.messageId}]` : ` ${err.messageId}`;
+
+  return `${ location }${ severity }${ downgradable }${ msgId }: ${ err.message }${ home }`;
 }
 
 /**
@@ -1010,9 +1094,10 @@ function messageHash( msg ) {
  * @param {boolean} [config.hintExplanation]
  *     If true, messages with explanations will get a "…" marker.
  *
- * @param {string} [config.module]
+ * @param {string} [config.moduleForMarker]
  *     If set, downgradable error messages will get a '‹↓›' marker, depending on whether
- *     the message can be downgraded for the given module.
+ *     the message can be downgraded for the given module.  A `‹↑›` is used if the message
+ *     will be an error in the next major cds-compiler release.
  *
  * @param {Record<string, string>} [config.sourceMap]
  *     A dictionary of filename<->source-code entries.  You can pass the `fileCache` that is used
@@ -1040,12 +1125,13 @@ function messageHash( msg ) {
 function messageStringMultiline( err, config = {} ) {
   colorTerm.changeColorMode(config ? config.color : 'auto');
 
+  config.moduleForMarker ??= config.module; // v4.8.0 or earlier compatibility
+
   const explainHelp = (config.hintExplanation && hasMessageExplanation(err.messageId)) ? '…' : '';
   const home = !err.home ? '' : (`at ${ err.home }`);
   const severity = err.severity || 'Error';
-  const downgradable = config.module && severity === 'Error' &&
-    isDowngradable(err.messageId, config.module, {}) ? '‹↓›' : '';
-  const msgId = (err.messageId && !config.noMessageId) ? `[${ err.messageId }${downgradable}${ explainHelp }]` : '';
+  const downgradable = severityChangeMarker(err, config);
+  const msgId = (err.messageId && !config.noMessageId) ? `${downgradable}[${ err.messageId }${ explainHelp }]` : '';
 
   let location = '';
   let context = '';
@@ -1535,7 +1621,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (!currentThing)
     return result;
 
-  let selectDepth = (csnPath[0] !== 'extensions') ? queryDepthForMessage(csnPath, model, currentThing) : null;
+  const selectDepth = (csnPath[0] !== 'extensions') ? queryDepthForMessage(csnPath, model, currentThing) : null;
 
   // Artifact ref -------------------------------------
 
@@ -1704,7 +1790,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
         if (index >= csnPath.length)
           continue; // no column name
 
-        let elementHierarchy = [];
+        const elementHierarchy = [];
 
         // Concat column+expand/inline to get a name similar to elements.
         do {

package/lib/base/model.js

@@ -26,10 +26,6 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  annotationExpressions: true,
-  odataPathsInAnnotationExpressions: true,
-  odataAnnotationExpressions: true,
-  assocsWithParams: true, // beta, because runtimes don't support it, yet.
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
   enableUniversalCsn: true,
@@ -39,10 +35,11 @@ const availableBetaFlags = {
   effectiveCsn: true,
   tenantVariable: true,
   calcAssoc: true,
-  vectorType: true,
   v5preview: true,
+  temporalRawProjection: true,
   // disabled by --beta-mode
   nestedServices: false,
+  rewriteAnnotationExpressionsViaType: false,
 };
 
 // Used by isDeprecatedEnabled() to check if any flag ist set.
@@ -83,7 +80,7 @@ const oldDeprecatedFlags_v2 = [
  *
  * A feature always needs to be provided - otherwise false will be returned.
  *
- * Please do not move this function to the "option processor" code.
+ * Do not move this function to the "option processor" code.
  *
  * @param {object} options Options
  * @param {string} feature Feature to check for
@@ -103,7 +100,7 @@ function isBetaEnabled( options, feature ) {
  * Useful for newer functionality which might not work with some
  * deprecated feature turned on.
  *
- * Please do not move this function to the "option processor" code.
+ * Do not move this function to the "option processor" code.
  *
  * @param {object} options Options
  * @param {string|null} [feature] Feature to check for

package/lib/checks/actionsFunctions.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isBuiltinType } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
@@ -53,8 +53,8 @@ function checkActionOrFunction( art, artName, prop, path ) {
     Object.entries(params).forEach(([ pn, p ], i) => {
       const type = p.items?.type || p.type;
       if (type === '$self' && !this.csn.definitions.$self && i > 0) {
-        this.error(null, currPath.concat(pn),
-                   'Binding parameter is expected to appear on first position only');
+        this.error('def-invalid-param', currPath.concat(pn),
+                   'Binding parameter is expected to appear in first position only');
       }
     });
   }

package/lib/checks/annotationsOData.js

@@ -37,6 +37,7 @@ function checkCoreMediaTypeAllowance( member ) {
 function checkAnalytics( member ) {
   if (member['@Analytics.Measure'] && !member['@Aggregation.default']) {
     this.info(null, member.$path, {},
+              // eslint-disable-next-line cds-compiler/message-no-quotes
               'Annotation “@Analytics.Measure” expects “@Aggregation.default” to be assigned for the same element as well');
   }
 }
@@ -63,6 +64,7 @@ function checkReadOnlyAndInsertOnly( artifact, artifactName ) {
   if (!this.csnUtils.getServiceName(artifactName))
     return;
   if (artifact.kind === 'entity' && artifact['@readonly'] && artifact['@insertonly'])
+    // eslint-disable-next-line cds-compiler/message-no-quotes
     this.warning(null, artifact.$path, {}, 'Annotations “@readonly” and “@insertonly” can\'t be assigned in combination');
 }
 
@@ -93,6 +95,7 @@ function checkTemporalAnnotationsAssignment( artifact, artifactName ) {
 
   // if @cds.valid.key is defined, check whether @cds.valid.from and @cds.valid.to are also there
   if (valid.key.length && !(valid.from.length && valid.to.length))
+    // eslint-disable-next-line cds-compiler/message-no-quotes
     this.error(null, [ 'definitions', artifactName ], 'Annotation “@cds.valid.key” was used but “@cds.valid.from” and “@cds.valid.to” are missing');
 
   /**

package/lib/checks/defaultValues.js

@@ -23,6 +23,7 @@ function validateDefaultValues( member, memberName, prop, path ) {
       // TODO: This check only counts the number of leading signs, not inbetween (e.g. 1 - - 1).
       //       The message also needs to be improved.
       if (i > 1)
+        // eslint-disable-next-line cds-compiler/message-no-quotes
         this.error(null, path, {}, 'Illegal number of unary ‘+’/‘-’ operators');
     }
   }
@@ -37,8 +38,10 @@ function validateDefaultValues( member, memberName, prop, path ) {
  * @param {CSN.Path} path Path to the member
  */
 function rejectParamDefaultsInHanaCds( member, memberName, prop, path ) {
-  if (member.default && prop === 'params' && this.options.transformation === 'hdbcds')
-    this.error(null, path, {}, 'Parameter default values are not supported in SAP HANA CDS');
+  if (member.default && prop === 'params' && this.options.transformation === 'hdbcds') {
+    this.error('def-unsupported-param', path, {},
+               'Parameter default values are not supported in SAP HANA CDS');
+  }
 }
 
 /**

package/lib/checks/elements.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const {
-  forEachMember, forEachMemberRecursively, isBuiltinType, cardinality2str,
+  forEachMember, forEachMemberRecursively, cardinality2str,
 } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 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!

package/lib/checks/enricher.js

@@ -6,7 +6,7 @@
 
 const { csnRefs } = require('../model/csnRefs');
 const { setProp } = require('../base/model');
-const { xprInAnnoProperties } = require('../compiler/builtins');
+const { isAnnotationExpression } = require('../base/builtins');
 
 /**
  * The following properties are attached as non-enumerable where appropriate:
@@ -96,7 +96,7 @@ function enrichCsn( csn, options ) {
    */
   function annotation( _parent, _prop, node ) {
     if (options.enrichAnnotations) {
-      if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
+      if (isAnnotationExpression(node)) {
         standard(_parent, _prop, node);
       }
       else if (node && typeof node === 'object') {

package/lib/checks/queryNoDbArtifacts.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('../model/csnUtils');
+const { hasAnnotationValue, isPersistedOnDatabase } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { requireForeignKeyAccess } = require('./onConditions');
 const { pathId } = require('../model/csnRefs');
 
@@ -166,12 +167,13 @@ function _checkRef( ref, _links, $path, inColumns ) {
         const cdsPersistenceSkipped = hasAnnotationValue(targetArt, '@cds.persistence.skip');
         this.error( null, $path, {
           '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+          anno: '@cds.persistence.skip',
           id: nonPersistedTarget.pathStep,
           elemref: { ref },
           name: nonPersistedTarget.name,
         }, {
-          std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
-          abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
+          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/utils.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isBuiltinType } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { RelationalOperators } = require('../transform/transformUtils');
 /**
  * Prepare the ref steps so that they are loggable

package/lib/checks/validator.js

@@ -3,7 +3,7 @@
 const {
   forEachDefinition, forEachMemberRecursively, forAllQueries,
   forEachMember, getNormalizedQuery, hasAnnotationValue,
-  applyTransformations, functionList,
+  applyTransformations, functionList, mergeTransformers,
 } = require('../model/csnUtils');
 const enrichCsn = require('./enricher');
 
@@ -75,7 +75,7 @@ const forRelationalDBArtifactValidators = [
   // sql.prepend/append
   checkSqlAnnotationOnArtifact,
   // strip down CSN to reduce it's size by removing non-sql relevant parts
-  stripNonDbRelevant,
+  deleteBoundActions,
 ];
 
 const forRelationalDBCsnValidators = [
@@ -156,7 +156,7 @@ function _validate( csn, that,
   // TODO: Don't know if that's feasible? Do we really need to enrich annotations always?
   // const { cleanup } = enrich(csn, { processAnnotations: that.options.tranformation === 'odata' });
 
-  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
+  applyTransformations(csn, mergeTransformers(csnValidators, that), [], { drillRef: true });
 
   forEachDefinition(csn, (artifact, artifactName, prop, path) => {
     artifactValidators.forEach((artifactValidator) => {
@@ -180,38 +180,6 @@ function _validate( csn, that,
   return cleanup;
 }
 
-/**
- * Ensure the CSN validators adhere to the applyTransformation format - also, supply correct this value for each subfunction
- *
- * @param {object[]} csnValidators Validators
- * @param {object} that Value for this
- * @returns {object} Remapped validators.
- */
-function mergeCsnValidators( csnValidators, that ) {
-  const remapped = {};
-  for (const validator of csnValidators) {
-    for (const [ n, fns ] of Object.entries(validator)) {
-      if (!remapped[n])
-        remapped[n] = [];
-
-      if (Array.isArray(fns)) {
-        remapped[n].push((parent, name, prop, path) => fns.forEach(
-          fn => fn.bind(that)(parent, name, prop, path)
-        ));
-      }
-      else {
-        remapped[n].push((parent, name, prop, path) => fns.bind(that)(parent, name, prop, path));
-      }
-    }
-  }
-
-  for (const [ n, fns ] of Object.entries(remapped))
-    remapped[n] = (parent, name, prop, path) => fns.forEach(fn => fn.bind(that)(parent, name, prop, path));
-
-
-  return remapped;
-}
-
 /**
  * Depending on the dialect we need to run different validations.
  *
@@ -282,33 +250,17 @@ function forOdata( csn, that ) {
                    });
 }
 
-const dbRelevantKinds = {
-  entity: true,
-  type: true,
-  aspect: true,
-  service: true,
-  context: true,
-};
-
 /**
  * Shrink the CSN by
  * - deleting bound actions
- * - turning all non-entity/type/aspect/service/context entities into dummies
+ *
+ * Artifacts can only be shrunk later, when types are resolved
  *
  * @param {CSN.Artifact} artifact
- * @param {string} artifactName
  */
-function stripNonDbRelevant( artifact, artifactName ) {
-  if (this.options.transformation !== 'effective') {
-    if ( !dbRelevantKinds[artifact.kind] ) {
-      this.csn.definitions[artifactName] = {
-        kind: 'action',
-      };
-    }
-    else if (artifact.actions) {
-      delete artifact.actions;
-    }
-  }
+function deleteBoundActions( artifact ) {
+  if (this.options.transformation !== 'effective')
+    delete artifact.actions;
 }
 
 module.exports = { forRelationalDB, forOdata };