@sap/cds-compiler 4.0.0 → 4.1.2

package/lib/model/csnUtils.js

@@ -69,7 +69,8 @@ function getUtils( model, universalReady ) {
   };
 
   /**
-   * Compute and return $combined for the given query.
+   * Compute and return $combined sources for the given query,
+   * that is, a map of elements that combine e.g. UNION sources.
    *
    * @param {CSN.Query} query
    * @returns {object}
@@ -291,11 +292,8 @@ function getUtils( model, universalReady ) {
     if (!absoluteName.startsWith('@'))
       throw new CompilerAssertion(`Annotation name should start with "@": ${ absoluteName }`);
 
-    // Only overwrite if undefined or null
-    if (node[absoluteName] === undefined || node[absoluteName] === null) {
-      // Assemble the annotation
-      node[absoluteName] = theValue;
-    }
+    // Assemble the annotation
+    node[absoluteName] ??= theValue;
   }
 
   /**
@@ -332,12 +330,18 @@ function getUtils( model, universalReady ) {
    *   - Does _not_ return the underlying type definition!  It is an object with all relevant
    *     type properties collected while traversing the type chain!
    *
-   * @todo Rename to e.g. getFinalTypeInfo()
+   * @param {string|object} type
+   *     Type as string or type ref, i.e. `{ ref: [...] }`
+   *
+   * @param {(string)=>CSN.Artifact} getArtifactRef
+   *     Function used to get an artifact for a reference. Useful in case that the caller
+   *     has a custom cache or a CSN that is in in-between state.
+   *     TODO: Can we make getUtils() more modular, so that this argument is already
+   *           passed to it?
    *
-   * @param {string|object} type Type as string or type ref, i.e. `{ ref: [...] }`
    * @returns {object|null}
    */
-  function getFinalTypeInfo( type ) {
+  function getFinalTypeInfo( type, getArtifactRef = artifactRef ) {
     type = normalizeTypeRef(type);
     if (!type)
       return null;
@@ -362,7 +366,7 @@ function getUtils( model, universalReady ) {
     if (typeof type === 'string' && (isBuiltinType( type ) || type === special$self))
       return _cacheResolved({ type });
 
-    const typeRef = artifactRef(type); // throws if not found
+    const typeRef = getArtifactRef(type); // default artifactRef() throws if not found
     const isNonScalar = _cacheNonScalar({ ...typeRef, type });
     if (isNonScalar)
       return finalBaseTypeCache[resolvedKey];
@@ -380,7 +384,7 @@ function getUtils( model, universalReady ) {
     finalBaseTypeCache[resolvedKey] = true;
 
     // Continue the search
-    const finalBase = getFinalTypeInfo(type);
+    const finalBase = getFinalTypeInfo(type, getArtifactRef);
     if (!finalBase) // Reference has no proper type, e.g. due to `type of View:calculated`.
       return _cacheResolved(null);
 
@@ -515,8 +519,8 @@ function forEachDefinition( csn, callback, iterateOptions = {} ) {
  */
 function forEachMember( construct, callback, path = [], ignoreIgnore = true, iterateOptions = {},
                         constructCallback = (_construct, _prop, _path) => {} ) {
-  // Allow processing _ignored elements if requested
-  if (ignoreIgnore && construct._ignore)
+  // Allow processing $ignored elements if requested
+  if (ignoreIgnore && construct.$ignore)
     return;
 
   // `items` itself is a structure that can contain "elements", and more.
@@ -775,7 +779,7 @@ function getArtifactDatabaseNameOf( artifactName, sqlMapping, csn, sqlDialect =
  * @returns {string} The resulting name
  */
 function getResultingName( csn, namingMode, artifactName ) {
-  if (namingMode === 'plain' || artifactName.indexOf('.') === -1)
+  if (namingMode === 'plain' || !artifactName.includes('.'))
     return artifactName;
 
   const namespace = getNamespace(csn, artifactName);
@@ -964,7 +968,7 @@ function isPersistedOnDatabase( art ) {
  */
 function isPersistedAsView( artifact ) {
   return artifact && artifact.kind === 'entity' &&
-      !artifact._ignore &&
+      !artifact.$ignore &&
       !artifact.abstract &&
       ((artifact.query || artifact.projection) && !hasAnnotationValue(artifact, '@cds.persistence.table')) &&
       !hasAnnotationValue(artifact, '@cds.persistence.skip') &&
@@ -978,7 +982,7 @@ function isPersistedAsView( artifact ) {
  */
 function isPersistedAsTable( artifact ) {
   return artifact.kind === 'entity' &&
-      !artifact._ignore &&
+      !artifact.$ignore &&
       !artifact.abstract &&
       (!artifact.query && !artifact.projection || hasAnnotationValue(artifact, '@cds.persistence.table')) &&
       !hasAnnotationValue(artifact, '@cds.persistence.skip') &&

package/lib/model/revealInternalProperties.js

@@ -102,8 +102,10 @@ function revealInternalProperties( model, nameOrPath ) {
     _status: primOrString,       // is a string anyway
     $annotations: as => as.map( $annotation ),
     $messageFunctions: () => '‹some functions›',
+    $functions: () => '‹some functions›',
+    $builtins: nameOrPath === '++' ? builtinsDictionary : () => '‹reveal with -R ++›',
   };
-  uniqueId = 1;
+  uniqueId = -1;
   return revealXsnPath(nameOrPath, model);
 
   // Returns the desired artifact/dictionary in the XSN.
@@ -129,7 +131,7 @@ function revealInternalProperties( model, nameOrPath ) {
   //   `name.space/S/E/elements/a/kind/`
   //   `name.space/S/E/elements/a/type/scope/`
   function revealXsnPath( path, xsn ) {
-    if (!path || path === '+')
+    if (!path || path === '+' || path === '++')
       return reveal( xsn );
 
     path = path.split('/');
@@ -173,7 +175,9 @@ function revealInternalProperties( model, nameOrPath ) {
     if (!Array.isArray(deps))
       return primOrString( deps );
     return deps
-      .map( d => `${ d.location ? '' : '-' }${ artifactIdentifier( d.art ) }`);
+      .map( d => (d.location
+        ? `${ artifactIdentifier( d.art ) } @${ locationString( d.location ) }`
+        : artifactIdentifier( d.art )) );
   }
 
   function layerExtends( dict ) {
@@ -213,7 +217,13 @@ function revealInternalProperties( model, nameOrPath ) {
   }
 
   function artifactDictionary( node, parent ) {
-    if (!node || typeof node !== 'object' || !model.definitions || parent === model )
+    if (parent === model )
+      return dictionary( node );    // no dictionary or no definitions section
+    return builtinsDictionary( node );
+  }
+
+  function builtinsDictionary( node, parent ) {
+    if (!node || typeof node !== 'object' || !model.definitions )
       return dictionary( node );    // no dictionary or no definitions section
     const dict = Object.create( Object.getPrototypeOf(node)
       ? NOT_A_DICTIONARY.prototype
@@ -237,7 +247,8 @@ function revealInternalProperties( model, nameOrPath ) {
       ? NOT_A_DICTIONARY.prototype
       : Object.prototype );
     for (const prop of Object.getOwnPropertyNames( node )) { // also non-enumerable
-      r[prop] = reveal( node[prop], node, prop );
+      if (node !== model.definitions || nameOrPath === '++' || !node[prop].builtin)
+        r[prop] = reveal( node[prop], node, prop );
     }
     if (node[$inferred] && !node['[$inferred]'])
       r['[$inferred]'] = node[$inferred];
@@ -275,8 +286,8 @@ function revealInternalProperties( model, nameOrPath ) {
 
     const r = Object.create( Object.getPrototypeOf( node ) );
     // property to recognize === objects
-    if (node.kind && node.__unique_id__ == null)
-      Object.defineProperty( node, '__unique_id__', { value: ++uniqueId } );
+    if (node.kind && node.__unique_id__ == null && node.$effectiveSeqNo == null && !node.builtin)
+      Object.defineProperty( node, '__unique_id__', { value: uniqueId-- } );
 
     for (const prop of Object.getOwnPropertyNames( node )) { // also non-enumerable
       const func = transformers[prop] ||
@@ -287,8 +298,8 @@ function revealInternalProperties( model, nameOrPath ) {
   }
 
   function targetAspect( node, parent ) {
-    if (node.elements && uniqueId && node.__unique_id__ == null)
-      Object.defineProperty( node, '__unique_id__', { value: ++uniqueId } );
+    if (node.elements && node.__unique_id__ == null && node.$effectiveSeqNo == null)
+      Object.defineProperty( node, '__unique_id__', { value: uniqueId-- } );
     return reveal( node, parent );
   }
 
@@ -305,19 +316,16 @@ function array( node, fn ) {
 }
 
 function artifactIdentifier( node, parent ) {
+  if (!node)
+    return `${ node }`;
   if (Array.isArray(node))
     return node.map( a => artifactIdentifier( a, node ) );
-  if (uniqueId && node.__unique_id__ == null)
-    Object.defineProperty( node, '__unique_id__', { value: ++uniqueId } );
-  let outer = uniqueId ? `##${ node.__unique_id__ }` : '';
-  if (node._outer) {
-    // eslint-disable-next-line no-nested-ternary
-    outer = (node._outer.items === node) ? `/items${ outer }`
-      // eslint-disable-next-line no-nested-ternary
-      : (node._outer.returns === node) ? `/returns${ outer }` // TODO returns now normal
-      // eslint-disable-next-line no-nested-ternary
-        : (node._outer.targetAspect === node) ? `/target${ outer }`
-          : `/returns/items${ outer }`;
+  if (uniqueId && node.__unique_id__ == null && node.$effectiveSeqNo == null && !node.builtin)
+    Object.defineProperty( node, '__unique_id__', { value: uniqueId-- } );
+  const outerNum = node.$effectiveSeqNo || node.__unique_id__;
+  let outer = outerNum != null ? `##${ outerNum }` : '';
+  if (node._outer) {            // anon aspect in targetAspect | items
+    outer = (node._outer.targetAspect === node) ? `/target${ outer }` : `/items${ outer }`;
     node = node._outer;
   }
   if (node === parent)
@@ -328,7 +336,7 @@ function artifactIdentifier( node, parent ) {
     return '$magicVariables';
   if (!node.name) {
     try {
-      return `${ locationString( node.location ) || '' }##${ node.__unique_id__ }`;
+      return `${ locationString( node.location ) || '' }##${ outerNum }`;
       // return JSON.stringify(node);
     }
     catch (e) {

package/lib/model/sortViews.js

@@ -93,13 +93,12 @@ function _findWithXPointers( definitionsArray, x, _dependents, _dependencies ) {
 module.exports = function sortViews({ sql, csn }) {
   const { cleanup, _dependents, _dependencies } = setDependencies(csn);
   const { layers, leftover } = sortTopologically(csn, _dependents, _dependencies);
-  cleanup.forEach(fn => fn());
   if (leftover.length > 0)
     throw new ModelError('Unable to build a correct dependency graph! Are there cycles?');
 
   const result = [];
   // keep the "artifact name" - needed for to.hdi sorting
-  layers.forEach(layer => layer.forEach(objName => result.push({ name: objName, sql: sql[objName] })));
+  layers.forEach(layer => layer.forEach(objName => result.push({ name: objName, sql: sql[objName], dependents: csn.definitions[objName][_dependents] })));
   // attach sql artifacts which are not considered during the view sorting algorithm
   // --> this is the case for "ALTER TABLE ADD CONSTRAINT" statements,
   //     because their identifiers are not part of the csn.definitions
@@ -107,5 +106,8 @@ module.exports = function sortViews({ sql, csn }) {
     if (!result.some( o => o.name === name )) // not in result but in incoming sql
       result.push({ name, sql: sqlString });
   });
+
+  cleanup.forEach(fn => fn());
+
   return result;
 };

package/lib/modelCompare/compare.js

@@ -8,6 +8,8 @@ const {
   isPersistedAsView
 } = require('../model/csnUtils');
 const { isBetaEnabled } = require('../base/model');
+const { forEachKey } = require('../utils/objectUtils');
+
 // used to mark a view as changed so we know to drop-create it
 const isChanged = Symbol('Marks a view as changed');
 
@@ -25,19 +27,18 @@ function compareModels(beforeModel, afterModel, options) {
   if(!(options && options.testMode)) // no $version with testMode
     validateCsnVersions(beforeModel, afterModel, options);
 
-  const deletedEntities = Object.create(null);
-  const elementAdditions = [];
-  const migrations = []; // element changes/removals or changes of entity properties
+  const returnObj = Object.create(null);
+  returnObj.definitions = afterModel.definitions;
+  returnObj.deletions = Object.create(null);
+  returnObj.extensions = [];
+  returnObj.migrations = []; // element changes/removals or changes of entity properties
+  returnObj.unchangedConstraints = new Set();
 
   // There is currently no use in knowing the added entities only. If this changes, hand in `addedEntities` to `getArtifactComparator` below.
-  forEachDefinition(afterModel, getArtifactComparator(beforeModel, options, null, null, elementAdditions, migrations));
-  forEachDefinition(beforeModel, getArtifactComparator(afterModel, options, null, deletedEntities, null, null));
+  forEachDefinition(afterModel, getExtensionAndMigrations(beforeModel, options, returnObj));
+  forEachDefinition(beforeModel, getDeletions(afterModel, options, returnObj));
+
 
-  const returnObj = Object.create(null);
-  returnObj.definitions = afterModel.definitions;
-  returnObj.deletions = deletedEntities;
-  returnObj.extensions = elementAdditions;
-  returnObj.migrations = migrations;
   return returnObj;
 }
 
@@ -65,13 +66,21 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   }
 }
 
-function getArtifactComparator(otherModel, options, addedEntities, deletedEntities, elementAdditions, migrations) {
+/**
+ * Calculate extensions, migrations and unchangedConstraints
+ * 
+ * @param {CSN.Model} beforeModel 
+ * @param {CSN.Options} options 
+ * @param {object} returnObj 
+ * @returns {function}
+ */
+function getExtensionAndMigrations(beforeModel, options, { extensions, migrations, unchangedConstraints }) {
   return function compareArtifacts(artifact, name) {
     function addElements() {
       const elements = {};
       forEachMember(artifact, getElementComparator(otherArtifact, elements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(elements).length > 0) {
-        elementAdditions.push(addedElements(name, elements));
+        extensions.push(addedElements(name, elements));
       }
     }
     function changePropsOrRemoveOrChangeElements() {
@@ -92,6 +101,54 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
           changedProperties[prop.name] = changedElement(artifact[prop.name], otherArtifact[prop.name] || null);
         }
       });
+
+      const removedConstraints = {};
+
+      // HDI (src === 'hdi) does handle table constraints via separate files and therefore no delta handling needed
+      if(options.src === 'sql' && (artifact.$tableConstraints  || otherArtifact.$tableConstraints)) {
+        const current = artifact.$tableConstraints || {};
+        const old = otherArtifact.$tableConstraints || {};
+        let changes = false;
+        const constraintTypes = ['unique', 'referential'];
+        constraintTypes.forEach(constraintType => {
+          // We only render/handle referential constraints for specific cases
+          if(hasReferentialConstraints(options) || constraintType !== 'referential')
+            if(current[constraintType] || old[constraintType]) {
+              removedConstraints[constraintType] = Object.create(null);
+
+              const cnew = current[constraintType] || Object.create(null);
+              const cold = old[constraintType] || Object.create(null);
+              forEachKey(cnew, (constraintName) => {
+                if(cold[constraintName]) {
+                  // constraint changed - add it to "removedConstraints" to drop-create it.
+                  // Quick-and-dirty compare with JSON.stringify - false-positive will just be a drop-create
+                  if(JSON.stringify(cold[constraintName]) !== JSON.stringify(cnew[constraintName])) {
+                    changes = true;
+                    removedConstraints[constraintType][constraintName] = cold[constraintName];
+                    if(options.constraintsInCreateTable || constraintType !== 'referential') // schedule an "ADD"
+                      extensions.push(addedConstraint(name, cnew[constraintName], constraintName,  constraintType));
+                  } else {
+                    unchangedConstraints.add(constraintName);
+                  }
+                } else if(options.constraintsInCreateTable || constraintType !== 'referential'){
+                  // Sometimes referential constraints are anyway added via ALTER - no need to add them as explicit extensions then
+                  extensions.push(addedConstraint(name, cnew[constraintName], constraintName,  constraintType));
+                }
+              });
+
+              forEachKey(cold, (constraintName) => {
+                if(!cnew[constraintName]) {
+                  changes = true;
+                  removedConstraints[constraintType][constraintName] = cold[constraintName];
+                }
+              })
+            }
+        });
+
+        if(changes)
+          migration.removeConstraints = removedConstraints;
+      }
+
       if (Object.keys(changedProperties).length > 0) {
         migration.properties = changedProperties;
       }
@@ -106,27 +163,15 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
         migration.change = changedElements;
       }
 
-      if (migration.properties || migration.remove || migration.change) {
+      if (migration.properties || migration.remove || migration.change || migration.removeConstraints) {
         migrations.push(migration);
       }
     }
 
-    const otherArtifact = otherModel.definitions[name];
+    const otherArtifact = beforeModel.definitions[name];
     const isPersisted = isPersistedAsTable(artifact);
     const isPersistedOther = otherArtifact && isPersistedAsTable(otherArtifact);
 
-    if (deletedEntities) {
-      // Looking for deleted entities only.
-      // Arguments are interchanged in this case: `artifact` from beforeModel and `otherArtifact` from afterModel.
-      if (isPersisted && !isPersistedOther) {
-        deletedEntities[name] = artifact;
-      // eslint-disable-next-line sonarjs/no-duplicated-branches
-      } else if(isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
-        deletedEntities[name] = artifact;
-      }
-      return;
-    }
-
     // to make it easier to know which views to drop-create
     if(isPersistedAsView(artifact) && isPersistedAsView(otherArtifact)) {
       // TODO: Check only on artifact.query/projection BUT: Need to manually check for sql-snippets then!
@@ -136,37 +181,52 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
     // Looking for added entities and added/deleted/changed elements.
     // Parameters: `artifact` from afterModel and `otherArtifact` from beforeModel.
 
-    if (!isPersisted) {
-      // Artifact not persisted in afterModel.
+    if (!isPersisted) // Artifact not persisted in afterModel.
       return;
-    }
 
     if (!isPersistedOther) {
-      if (addedEntities) {
-        addedEntities[name] = artifact;
-      }
+      extensions[name] = artifact;
       return;
     }
 
     // Artifact changed?
 
-    if (elementAdditions) {
-      addElements();
-    }
-    if (migrations) {
-      changePropsOrRemoveOrChangeElements();
+    addElements();
+    changePropsOrRemoveOrChangeElements();
+  };
+}
+/**
+ * Calculate all deleted entities.
+ * 
+ * @param {CSN.Model} afterModel 
+ * @param {CSN.Options} options 
+ * @param {object} returnObj 
+ * @returns {function}
+ */
+function getDeletions(afterModel, options, { deletions }) {
+  return function compareArtifacts(artifact, name) {
+    const otherArtifact = afterModel.definitions[name];
+    const isPersisted = isPersistedAsTable(artifact);
+    const isPersistedOther = otherArtifact && isPersistedAsTable(otherArtifact);
+
+    // Looking for deleted entities only.
+    if (isPersisted && !isPersistedOther) {
+      deletions[name] = artifact;
+      // eslint-disable-next-line sonarjs/no-duplicated-branches
+    } else if (isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
+      deletions[name] = artifact;
     }
   };
 }
 
 function getElementComparator(otherArtifact, addedElementsDict = null, changedElementsDict = null) {
   return function compareElements(element, name) {
-    if (element._ignore) {
+    if (element.$ignore) {
       return;
     }
 
     const otherElement = otherArtifact.elements[name];
-    if (otherElement && !otherElement._ignore) {
+    if (otherElement && !otherElement.$ignore) {
       // Element type changed?
       if (!changedElementsDict) {
         return;
@@ -239,6 +299,15 @@ function addedElements(entity, elements) {
   };
 }
 
+function addedConstraint(entity, constraint, constraintName, constraintType) {
+  return {
+    extend: entity,
+    constraint,
+    constraintName,
+    constraintType,
+  }
+}
+
 function changedElement(element, otherElement) {
   return {
     old: otherElement,
@@ -246,6 +315,10 @@ function changedElement(element, otherElement) {
   };
 }
 
+function hasReferentialConstraints(options) {
+  return options.src === 'sql' && (options.sqlDialect === 'postgres' || options.sqlDialect === 'hana' || options.sqlDialect === 'sqlite')
+}
+
 module.exports = {
   compareModels,
   deepEqual,

package/lib/modelCompare/utils/filter.js

@@ -13,20 +13,31 @@ function isKey( element ) {
 module.exports = {
   sqlite: getFilterObject(
     'sqlite',
-    function forEachExtension(extend, name, element, error) {
-      if (isKey(element)) { // Key must not be extended
-        error('type-unsupported-key-sqlite', [ 'definitions', extend, 'elements', name ], { id: name, name: 'sqlite' }, 'Added element $(ID) is a primary key change and will not work with dialect $(NAME)');
+    function forEachExtension(extend, name, elementOrConstraint, { error, warning }) {
+      if (isKey(elementOrConstraint)) { // Key must not be extended
+        error('type-unsupported-key-sqlite', [ 'definitions', extend, 'elements', name ], { id: name, name: 'sqlite', '#': 'std' } );
+        return false;
       }
+      else if (elementOrConstraint.parentTable) { // constraints have a .parentTable
+        warning('def-unsupported-constraint-add', [ 'definitions', elementOrConstraint.parentTable, 'elements', elementOrConstraint.paths ? name : name.slice(elementOrConstraint.parentTable.length + 1) ], { id: elementOrConstraint.identifier || name, name: 'sqlite' },
+                'Ignoring add of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
+        return false;
+      }
+
+      return true;
     },
     function forEachMigration(migrate, name, migration, change, error) {
       const newIsKey = isKey(migration.new);
       const oldIsKey = isKey(migration.old);
-      if ((newIsKey || oldIsKey) && oldIsKey !== newIsKey) { // Turned into key or key was removed
-        error('type-unsupported-key-sqlite', [ 'definitions', migrate, 'elements', name ], { id: name, name: 'sqlite' }, 'Changed element $(ID) is a primary key change and will not work with dialect $(NAME)');
-      }
-      else { // Ignore simple migrations
+      if ((newIsKey || oldIsKey) && oldIsKey !== newIsKey) // Turned into key or key was removed
+        error('type-unsupported-key-sqlite', [ 'definitions', migrate, 'elements', name ], { id: name, name: 'sqlite', '#': 'changed' } );
+      else
         delete change[name];
-      }
+    },
+    function forEachConstraintRemoval(constraintRemovals, name, constraint, warning) {
+      warning('def-unsupported-constraint-drop', [ 'definitions', constraint.parentTable, 'elements', constraint.paths ? name : name.slice(constraint.parentTable.length + 1) ], { id: constraint.identifier || name, name: 'sqlite' },
+              'Ignoring drop of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
+      delete constraintRemovals[name];
     }
   ),
   postgres: getFilterObject('postgres'),
@@ -35,22 +46,32 @@ module.exports = {
   csn: filterCsn,
 };
 
-function getFilterObject( dialect, extensionCallback, migrationCallback ) {
+function getFilterObject( dialect, extensionCallback, migrationCallback, removeConstraintsCallback ) {
   return {
-    // will be called with a simple Array.forEach
-    extension: ({ elements, extend }, error) => {
-      if (extensionCallback) {
-        forEach(elements, (name, element) => {
-          extensionCallback(extend, name, element, error);
-        });
-      }
+    // will be called with a simple Array.filter, as we need to filter constraint `ADD` for SQLite
+    extension: ({
+      elements, constraint, constraintName, extend,
+    }, { error, message, warning }) => {
+      let returnValue = true;
+      forEach(elements, (name, element) => {
+        if (dialect !== 'sqlite' && isKey(element))
+          message('type-unsupported-key-change', [ 'definitions', extend, 'elements', name ], { id: name, '#': 'std' } );
+        else if (extensionCallback && !extensionCallback(extend, name, element, { error, warning }))
+          returnValue = false;
+      });
+
+      if (constraint && extensionCallback && !extensionCallback(extend, constraintName, constraint, { error, warning }))
+        returnValue = false;
+
+      return returnValue;
     },
-    // will be called with a Array.map, as we need to filter "change" for SQLite
-    migration: ({ change, migrate, remove }, error) => {
+    // will be called with a Array.forEach
+    migration: ({
+      change, migrate, remove, removeConstraints,
+    }, { error, warning, message }) => {
       forEach(remove, (name) => {
         error('def-unsupported-element-drop', [ 'definitions', migrate, 'elements', name ], {}, 'Dropping elements is not supported');
       });
-
       forEach(change, (name, migration) => {
         const loc = [ 'definitions', migrate, 'elements', name ];
         if (migration.new.type === migration.old.type && migration.new.length < migration.old.length)
@@ -61,11 +82,22 @@ function getFilterObject( dialect, extensionCallback, migrationCallback ) {
           error('type-unsupported-precision-change', loc, { id: name }, 'Changed element $(ID) is a precision change and is not supported');
         else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type))
           error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported');
+        else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
+          message('type-unsupported-key-change', [ 'definitions', migrate, 'elements', name ], { id: name, '#': 'changed' } );
         else if (migrationCallback)
           migrationCallback(migrate, name, migration, change, error);
 
         // TODO: precision/scale growth
       });
+
+      if (removeConstraintsCallback) {
+        const constraintTypes = [ 'unique', 'referential' ];
+        constraintTypes.forEach((constraintType) => {
+          forEach(removeConstraints?.[constraintType], (name, constraint) => {
+            removeConstraintsCallback(removeConstraints[constraintType], name, constraint, warning);
+          });
+        });
+      }
     },
     deletion: ([ artifactName, artifact ], error) => {
       if (isPersistedAsTable(artifact))
@@ -110,10 +142,8 @@ function typeChangeIsNotCompatible( dialect, before, after ) {
  */
 function filterCsn( csn ) {
   const annosToKeep = {
-    '@cds.persistence.skip': true,
-    '@cds.persistence.exists': true,
-    '@cds.persistence.table': true,
-    '@cds.persistence.name': true,
+    // + @cds.persistence.*
+    '@assert.integrity': true,
     '@sql.append': true,
     '@sql.prepend': true,
   };
@@ -122,7 +152,7 @@ function filterCsn( csn ) {
     elements: (parent, prop, elements) => {
       forEachValue(elements, (element) => {
         forEachKey(element, (key) => {
-          if ((key.startsWith('@') && !annosToKeep[key]) || key === 'keys')
+          if ((key.startsWith('@') && !key.startsWith('@cds.persistence.') && !annosToKeep[key]) || key === 'keys')
             delete element[key];
         });
       });

package/lib/optionProcessor.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { createOptionProcessor } = require('./base/optionProcessorHelper');
+const { availableBetaFlags } = require('./base/model');
 
 // This option processor is used both by the command line parser (to translate cmd line options
 // into an options object) and by the API functions (to verify options)
@@ -102,12 +103,11 @@ optionProcessor
        --beta-mode          Enable all unsupported, incomplete (beta) features
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
                             Valid values are:
-                              hanaAssocRealCardinality
-                              mapAssocToJoinCardinality
-                              enableUniversalCsn
-                              aspectWithoutElements
-                              odataTerms
-                              optionalActionFunctionParameters
+                              ${
+  Object.keys(availableBetaFlags).sort()
+    .filter(flag => availableBetaFlags[flag])
+    .join('\n' + ' '.repeat(30))
+}
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
                               eagerPersistenceForGeneratedEntities