@sap/cds-compiler 5.0.6 → 5.1.0

package/lib/compiler/resolve.js

@@ -67,6 +67,7 @@ const {
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
+const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -90,7 +91,6 @@ function resolve( model ) {
     resolvePath,
     resolveDefinitionName,
     traverseExpr,
-    createRemainingAnnotateStatements,
     effectiveType,
     getOrigin,
     getInheritedProp,
@@ -131,8 +131,6 @@ function resolve( model ) {
         resolveDefinitionName( model.sources[name].namespace );
     }
 
-    // create “super” ANNOTATE statements for annotations on unknown artifacts:
-    createRemainingAnnotateStatements();
     // report cyclic dependencies:
     detectCycles( model.definitions, ( user, art, location, semanticLoc ) => {
       if (location) {
@@ -158,68 +156,102 @@ function resolve( model ) {
   // Phase 2+3: calculate propagated KEYs
   //--------------------------------------------------------------------------
 
+  /**
+   * Set `_projection` links in navigation elements and creates $navElement hierarchy.
+   *
+   * @param {XSN.Artifact} view
+   */
   function setNavigationProjections( view ) {
     if (!view.$queries)
       return;
     for (const query of view.$queries) {
-      forEachGeneric( query, 'elements', ( elem ) => {
-        if (!elem._origin || elem.expand || !elem.value)
+      // traversing sub-elements not necessary, since we're in a view
+      // TODO: Handle expand.
+      forEachGeneric( query, 'elements', function navProjectionsForElement( elem ) {
+        if (!elem._origin || elem.expand || !elem.value?.path)
           return;
         // TODO: what about elements where _origin is set without value?
         // TODO: or should we push elems with `expand` sibling to extra list for
         //       better messages?  (Whatever that means exactly.)
-        const nav = pathNavigation( elem.value );
-        const { path } = elem.value;
-
-        if (elem._pathHead?.kind === '$inline' && path.length === 1) {
-          const item = path[0];
-          const hpath = elem._pathHead.value?.path;
-          const head = hpath?.length === 1 && hpath[0]._navigation;
-          // Alias .{ elem } - but not with Alias.{ $magic }: consider for ON-rewrite
-          if (head?.kind === '$tableAlias' && item.id.charAt(0) !== '$')
-            pushLink( head.elements[item.id], '_projections', elem );
-        }
-        else if (nav.navigation) { // not set for $self.…
-          // Path could start with table alias; get start index
-          let index = path.indexOf(nav.item);
-          if (index === -1)
-            return; // should not happen
 
-          let navItem = nav.navigation;
-          if (!nav.item._navigation) // first non-table-alias
-            setLink( nav.item, '_navigation', navItem );
+        if (elem._pathHead) {
+          if (elem._pathHead?.kind !== '$inline')
+            // we're traversing top-level elements of the query; other _pathHead kinds can't happen
+            throw new CompilerAssertion('found unexpected "expand", but expected "inline"');
 
-          if (path[index].where || path[index].args)
-            return;
-          ++index;
-          while (navItem && index < path.length) {
-            const step = path[index];
-            if (!step?.id || step.where || step.args)
-              break;
-            if (!navItem.elements?.[step.id]) {
-              const elements = navItem._origin?.elements ||
-                navItem._origin?.target?._artifact?.elements;
-              if (!elements)
-                break;
-              // Only link available path steps (navigation tree).
-              const origin = elements[step.id];
-              const member = linkToOrigin( origin, step.id, navItem, 'elements',
-                                           navItem.path?.location, true );
-              member.$inferred = 'expanded';
-              member.kind = '$navElement';
-            }
-            navItem = navItem.elements[step.id];
-            setLink( step, '_navigation', navItem );
-            ++index;
+          if (!isPathBreakout( elem.value )) {
+            const fullPath = columnParentPath( elem );
+            if (fullPath)
+              setNavigationProjectionsForElementRef({ path: fullPath }, elem);
           }
-          // Last path step, if found, is a simple projection
-          if (index === path.length && navItem)
-            pushLink( navItem, '_projections', elem );
+        }
+        else {
+          setNavigationProjectionsForElementRef( elem.value, elem );
         }
       } );
     }
   }
 
+  function setNavigationProjectionsForElementRef( ref, elem ) {
+    const { path } = ref;
+    const nav = pathNavigation( ref );
+    if (nav.navigation) { // not set for $self.…
+      // Path could start with table alias; get start index
+      let index = path.indexOf(nav.item);
+      if (index === -1)
+        return; // should not happen
+
+      let navItem = nav.navigation;
+      if (!nav.item._navigation) // first non-table-alias
+        setLink( nav.item, '_navigation', navItem );
+
+      if (path[index].where || path[index].args)
+        return;
+      ++index;
+      while (navItem && index < path.length) {
+        const step = path[index];
+        if (!step?.id || step.where || step.args)
+          break;
+        if (!navItem.elements?.[step.id]) {
+          const elements = navItem._origin?.elements ||
+            navItem._origin?.target?._artifact?.elements;
+          if (!elements)
+            break;
+          // Only link available path steps (navigation tree).
+          const origin = elements[step.id];
+          const member = linkToOrigin( origin, step.id, navItem, 'elements',
+                                       navItem.path?.location, true );
+          member.$inferred = 'expanded';
+          member.kind = '$navElement';
+        }
+        navItem = navItem.elements[step.id];
+        setLink( step, '_navigation', navItem );
+        ++index;
+      }
+      // Last path step, if found, is a simple projection
+      if (index === path.length && navItem)
+        pushLink( navItem, '_projections', elem );
+    }
+  }
+
+  function columnParentPath( elem ) {
+    if (!elem._pathHead || !elem.value?.path || isPathBreakout( elem.value ))
+      return elem.value?.path;
+
+    const fullPath = [ ...elem.value.path ];
+    let pathHead = elem._pathHead;
+    while (pathHead) {
+      if (pathHead.kind !== '$inline' || !pathHead.value?.path ||
+          isPathBreakout( pathHead.value )) {
+        // path breakout for e.g. `$self.{ foo }`, `1 as a .{ foo }`
+        return null;
+      }
+      fullPath.unshift(...pathHead.value.path);
+      pathHead = pathHead._pathHead;
+    }
+    return fullPath;
+  }
+
   function propagateKeyProps( view ) {
     // Second argument true ensure that `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
@@ -256,9 +288,9 @@ function resolve( model ) {
   function inheritedSourceKeyProp( { value, _pathHead } ) {
     if (!value || !value.path)
       return null;
-    const nav = pathNavigation( value );
+    const nav = !_pathHead && pathNavigation( value );
     const item = value.path[value.path.length - 1];
-    if (nav.navigation && nav.item === item)
+    if (nav?.navigation && nav.item === item)
       return item._artifact?.key;
     if (value.path.length !== 1 || _pathHead?.kind !== '$inline')
       return null;
@@ -282,13 +314,11 @@ function resolve( model ) {
     const toMany = withAssociation( from, targetMaxNotOne, true );
     if (toMany) {
       propagateKeys = false;
-      info( 'query-from-many', [ toMany.location, query ], { art: toMany },
-            {
-              // eslint-disable-next-line max-len
-              std: 'Key properties are not propagated because a to-many association $(ART) is selected',
-              // eslint-disable-next-line max-len
-              element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
-            } );
+      info( 'query-from-many', [ toMany.location, query ], { art: toMany }, {
+        std: 'Key properties are not propagated because a to-many association $(ART) is selected',
+        // eslint-disable-next-line max-len
+        element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
+      } );
     }
     // Check that all keys from the source are projected:
     const notProjected = [];    // we actually push to the array
@@ -298,7 +328,7 @@ function resolve( model ) {
       if (nav.$duplicates)
         continue;
       const { key } = nav._origin;
-      if (key && key.val && !(nav._projections && nav._projections.length))
+      if (key?.val && !nav._projections?.length)
         notProjected.push( nav.name.id );
     }
     if (notProjected.length) {
@@ -312,9 +342,12 @@ function resolve( model ) {
     // Check that there is no to-many assoc used in select item:
     for (const name in query.elements) {
       const elem = query.elements[name];
-      if (!elem.$inferred && elem.value &&
-          testExpr( elem.value, selectTest, () => false, elem ))
-        propagateKeys = false;
+
+      if (!elem.$inferred && elem.value?.path) {
+        const path = elem._pathHead ? columnParentPath( elem ) : elem.value.path;
+        if (testExpr({ path }, selectTest, () => false, elem))
+          propagateKeys = false;
+      }
     }
     return propagateKeys;
 
@@ -322,15 +355,13 @@ function resolve( model ) {
       const art = withAssociation( expr, targetMaxNotOne );
       if (art) {
         // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
-        info( 'query-navigate-many', [ art.location, user || query ], { art },
-              {
-                // eslint-disable-next-line max-len
-                std: 'Navigating along to-many association $(ART) - key properties are not propagated',
-                // eslint-disable-next-line max-len
-                element: 'Navigating along to-many association $(MEMBER) of $(ART) - key properties are not propagated',
-                // eslint-disable-next-line max-len
-                alias: 'Navigating along to-many mixin association $(MEMBER) - key properties are not propagated',
-              } );
+        info( 'query-navigate-many', [ art.location, user || query ], { art }, {
+          std: 'Navigating along to-many association $(ART) - key properties are not propagated',
+          // eslint-disable-next-line max-len
+          element: 'Navigating along to-many association $(MEMBER) of $(ART) - key properties are not propagated',
+          // eslint-disable-next-line max-len
+          alias: 'Navigating along to-many mixin association $(MEMBER) - key properties are not propagated',
+        } );
       }
       return art;
     }
@@ -511,14 +542,12 @@ function resolve( model ) {
     else if (obj.targetAspect && obj.targetAspect.elements) { // silent dependencies
       forEachGeneric( obj.targetAspect, 'elements', elem => dependsOnSilent( art, elem ) );
     }
+
     if (obj.foreignKeys) {       // silent dependencies
       // Avoid strange ref-cyclic if managed composition is key (check comes later)
-      // TODO: the following is already done by addImplicitForeignKeys()!
-      if (obj.$inferred !== 'aspect-composition') {
-        forEachGeneric( obj, 'foreignKeys', (elem) => {
-          dependsOnSilent( art, elem );
-        } );
-      }
+      // Done by addImplicitForeignKeys() for implicit keys.
+      if (!art.foreignKeys?.[$inferred] && obj.$inferred !== 'aspect-composition')
+        forEachGeneric( obj, 'foreignKeys', elem => dependsOnSilent( art, elem ) );
       addForeignKeyNavigations( art );
     }
 
@@ -1552,8 +1581,6 @@ function resolve( model ) {
 function pathNavigation( ref ) {
   // currently, indirectly projectable elements are not included - we might
   // keep it this way!  If we want them to be included - be aware: cycles
-  if (!ref._artifact)
-    return {};
   let item = ref.path && ref.path[0];
   const root = item && item._navigation;
   if (!root)
@@ -1570,4 +1597,13 @@ function pathNavigation( ref ) {
   return { navigation: root.elements?.[item.id], item, tableAlias: root };
 }
 
+function isPathBreakout( ref ) {
+  if (!ref.path?.[0])
+    return false;
+  if (ref.scope === 'param')
+    return true;
+  const nav = (ref.path[0]._navigation || ref.path[0]._artifact);
+  return nav && (nav.kind === '$self' || ref.path[0].id.charAt(0) === '$');
+}
+
 module.exports = resolve;

package/lib/compiler/shared.js

@@ -1738,7 +1738,8 @@ function fns( model ) {
    * @param {string} msgId
    * @param {any} location
    * @param {object[]} valid
-   * @param  {object} [textParams]
+   * @param {object} [textParams]
+   * @param {object} [semantics]
    */
   function signalNotFound( msgId, location, valid, textParams, semantics ) {
     if (location.$notFound)     // TODO: still necessary?

package/lib/compiler/tweak-assocs.js

@@ -38,6 +38,9 @@ function tweakAssocs( model ) {
     checkOnCondition,
     effectiveType,
     getOrigin,
+    extendForeignKeys,
+    createRemainingAnnotateStatements,
+    mergeSpecifiedForeignKeys,
   } = model.$functions;
 
   Object.assign(model.$functions, {
@@ -45,7 +48,7 @@ function tweakAssocs( model ) {
   });
 
   // Phase 5: rewrite associations
-  model._entities.forEach( rewriteArtifact );
+  model._entities.forEach( rewriteArtifact ); // _entities contains all definitions, sorted.
   // Think hard whether an on condition rewrite can lead to a new cyclic
   // dependency.  If so, we need other messages anyway.  TODO: probably dox
   // another cyclic check with testMode.js
@@ -56,6 +59,11 @@ function tweakAssocs( model ) {
     if (art.kind === 'select')
       forEachQueryExpr( art, checkExpr );
   } );
+
+
+  // create “super” ANNOTATE statements for annotations on unknown artifacts:
+  createRemainingAnnotateStatements();
+
   return;
 
 
@@ -68,7 +76,6 @@ function tweakAssocs( model ) {
     // return;
     if (!art.query) {
       rewriteAssociation( art );
-      forEachGeneric( art, 'elements', rewriteAssociation );
     }
     else {
       traverseQueryExtra( art, ( query ) => {
@@ -78,9 +85,11 @@ function tweakAssocs( model ) {
     if (art._service)
       forEachGeneric( art, 'elements', complainAboutTargetOutsideService );
 
-    traverseQueryPost( art.query, false, ( query ) => {
-      forEachGeneric( query, 'elements', rewriteAssociationCheck );
-    } );
+    if (art.query) {
+      traverseQueryPost(art.query, false, (query) => {
+        forEachGeneric( query, 'elements', rewriteAssociationCheck );
+      });
+    }
   }
 
   // function rewriteView( view ) {
@@ -231,6 +240,16 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociation( element ) {
+    doRewriteAssociation( element );
+    if (element.target) {
+      extendForeignKeys( element );
+      if (element.foreignKeys$)
+        mergeSpecifiedForeignKeys( element );
+    }
+  }
+
+  // only to be used by rewriteAssociation()
+  function doRewriteAssociation( element ) {
     let elem = element.items || element; // TODO v6: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
@@ -238,6 +257,7 @@ function tweakAssocs( model ) {
       forEachGeneric( elem.targetAspect, 'elements', rewriteAssociation );
     if (!originTarget( elem ))
       return;
+
     // console.log(message( null, elem.location, elem,
     // {art:assoc,target,ftype:JSON.stringify(ftype)}, 'Info','RA').toString())
 
@@ -295,6 +315,7 @@ function tweakAssocs( model ) {
     }
   }
 
+  /** Returns the element's origin's target artifact. */
   function originTarget( elem ) {
     const assoc = !elem.expand && getOrigin( elem );
     const ftype = assoc && effectiveType( assoc );
@@ -373,6 +394,9 @@ function tweakAssocs( model ) {
       traverseExpr( elem.on, 'rewrite-on', elem,
                     expr => rewriteExpr( expr, elem, nav.tableAlias ) );
     }
+    else if (elem._pathHead) {
+      error( 'rewrite-not-supported', [ elem.target.location, elem ] );
+    }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ], {},

package/lib/edm/edm.js

@@ -883,12 +883,20 @@ function getEdm( options, messageFunctions ) {
   class ReturnType extends PropertyBase {
     constructor(version, csn) {
       super(version, {}, csn);
+      // CSDL 12.8: If the return type is a collection of entity types,
+      // the Nullable attribute has no meaning and MUST NOT be specified.
+      if (csn.$NoNullableProperty)
+        delete this._edmAttributes.Nullable;
     }
 
     // we need Name but NO $kind, can't use standard to JSON()
     toJSON() {
       const json = Object.create(null);
       this.toJSONattributes(json);
+      // CSDL 12.8: If the return type is a collection of entity types,
+      // the Nullable attribute has no meaning and MUST NOT be specified.
+      if (this._csn.$NoNullableProperty)
+        delete json.$Nullable;
       return json;
     }
   }

package/lib/edm/edmPreprocessor.js

@@ -1886,7 +1886,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     mapCdsToEdmProp(def);
     annotateAllowedValues(def, defLocation);
     if (def.returns) {
-      markCollection(def.returns);
+      markCollection(def.returns, true);
       mapCdsToEdmProp(def.returns);
       annotateAllowedValues(def.returns, [ ...defLocation, 'returns' ]);
     }
@@ -1899,16 +1899,20 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       rewriteAnnotationExpressions(member);
       if (member.returns) {
         edmUtils.assignAnnotation(member.returns, '@Core.Description', member.returns.doc);
-        markCollection(member.returns);
+        markCollection(member.returns, true);
         mapCdsToEdmProp(member.returns);
         annotateAllowedValues(member.returns, [ ...location, 'returns' ]);
         rewriteAnnotationExpressions(member.returns);
       }
     }, defLocation);
     // mark members that need to be rendered as collections
-    function markCollection( obj ) {
+    function markCollection( obj, isReturns ) {
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
       if (items) {
+        edmUtils.assignProp(obj, '$NoNullableProperty',
+                            isReturns && items.type &&
+                            !isBuiltinType(items.type) &&
+                            csn.definitions[items.type]?.kind === 'entity');
         edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : false);
         edmUtils.assignProp(obj, '$isCollection', true);
       }

package/lib/gen/Dictionary.json

@@ -1508,6 +1508,13 @@
       "Type": "HTML5.LinkTargetType",
       "$experimental": true
     },
+    "HTML5.RowSpanForDuplicateValues": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "Record"
+      ],
+      "$experimental": true
+    },
     "JSON.Schema": {
       "Type": "JSON.JSON",
       "AppliesTo": [
@@ -1934,6 +1941,16 @@
       ],
       "$experimental": true
     },
+    "UI.IsAIOperation": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "Action",
+        "Function",
+        "ActionImport",
+        "FunctionImport"
+      ],
+      "$experimental": true
+    },
     "UI.CreateHidden": {
       "Type": "Core.Tag",
       "AppliesTo": [
@@ -2019,6 +2036,13 @@
         "Parameter"
       ]
     },
+    "UI.Recommendations": {
+      "Type": "Edm.ComplexType",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
     "UI.ExcludeFromNavigationContext": {
       "Type": "Core.Tag",
       "AppliesTo": [
@@ -3235,6 +3259,7 @@
       "Properties": {
         "Property": "Edm.PropertyPath",
         "DynamicProperty": "Edm.AnnotationPath",
+        "Expression": "Edm.PrimitiveType",
         "Descending": "Edm.Boolean"
       }
     },
@@ -4230,6 +4255,7 @@
         "IncludeGrandTotal": "Edm.Boolean",
         "InitialExpansionLevel": "Edm.Int32",
         "Visualizations": "Collection(Edm.AnnotationPath)",
+        "RecursiveHierarchyQualifier": "Aggregation.HierarchyQualifier",
         "RequestAtLeast": "Collection(Edm.PropertyPath)",
         "SelectionFields": "Collection(Edm.PropertyPath)"
       }
@@ -4479,6 +4505,17 @@
         "ValueListProperty": "Edm.String"
       }
     },
+    "UI.PropertyRecommendationType": {
+      "$kind": "ComplexType",
+      "Abstract": "true",
+      "Properties": {
+        "RecommendedFieldValue": "Edm.PrimitiveType",
+        "RecommendedFieldDescription": "Edm.String",
+        "RecommendedFieldScoreValue": "Edm.Decimal",
+        "RecommendedFieldIsSuggestion": "Edm.Boolean"
+      },
+      "$experimental": true
+    },
     "UI.VisualizationType": {
       "$kind": "EnumType",
       "Members": [

package/lib/json/to-csn.js

@@ -384,6 +384,8 @@ function attachAnnotations( annotate, prop, dict, inferred, insideReturns = fals
         attachAnnotations( sub, 'elements', elems, inf, entry.returns );
       else if (many.enum)       // make 'enum' annotations appear in 'elements' annotate
         attachAnnotations( sub, 'elements', many.enum, inf, entry.returns );
+      else if (entry.foreignKeys) // make 'foreignKeys' annotations appear in 'elements' annotate
+        attachAnnotations( sub, 'elements', entry.foreignKeys, inf );
     }
     if (Object.keys( sub ).length)
       annoDict[name] = sub;

package/lib/main.js

@@ -30,11 +30,8 @@ const builtins = lazyload('./base/builtins');
 const base = lazyload('./compiler/base');
 const finalizeParseCdl = lazyload('./compiler/finalize-parse-cdl');
 const lsp = lazyload('./compiler/lsp-api');
+const meta = lazyload('./base/meta');
 
-// The compiler version (taken from package.json)
-function version() {
-  return require('../package.json').version;
-}
 
 const toCsn = lazyload('./json/to-csn')
 
@@ -76,7 +73,7 @@ function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
 // ATTENTION: Keep in sync with main.d.ts!
 module.exports = {
   // Compiler
-  version,
+  version: () => meta.version(),
   compile: (filenames, dir, options, fileCache) => { // main function
     traceApi( 'compile', options );
     return compiler.compileX(filenames, dir, options, fileCache).then(toCsn.compactModel);

package/lib/model/cloneCsn.js

@@ -30,6 +30,7 @@ const internalCsnProps = {
   $tableConstraints: shallowCopy,
   $default: shallowCopy, // used for HANA CSN migrations
   $notNull: shallowCopy, // used for HANA CSN migrations
+  $sqlService: shallowCopy,
 };
 const internalEnumerableCsnProps = {
   __proto__: null,

package/lib/model/csnRefs.js

@@ -448,7 +448,7 @@ function csnRefs( csn, universalReady ) {
     if (!step)
       return null;
     if (!effectiveType( art ))
-      throw new TypeError( 'Cyclic type definition' );
+      throw new ModelError( 'Cyclic type definition' );
     if (typeof step === 'string')
       return navigationEnv( art, true ).elements[step];
 
@@ -1324,6 +1324,7 @@ module.exports = {
   traverseQuery,
   artifactProperties,
   implicitAs,
+  getKeysDict,
   analyseCsnPath,
   pathId,
   columnAlias,

package/lib/model/csnUtils.js

@@ -12,7 +12,6 @@ const { isBuiltinType, isAnnotationExpression } = require('../base/builtins');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
-const { version } = require('../../package.json');
 const { cloneAnnotationValue } = require('./cloneCsn');
 
 // Low-level utility functions to work with compact CSN.
@@ -946,16 +945,6 @@ function isPersistedAsTable( artifact ) {
       !hasAnnotationValue(artifact, '@cds.persistence.exists');
 }
 
-/**
- * Central generated by cds-compiler string generator function without further decoration
- *  for unified tagging of generated content
- *
- * @returns {string} String containing compiler version that was used to generate content
- */
-function generatedByCompilerVersion() {
-  return `generated by cds-compiler version ${ version }`;
-}
-
 /**
  * Return the projection to look like a query.
  *
@@ -1438,7 +1427,6 @@ module.exports = {
   isPersistedOnDatabase,
   isPersistedAsView,
   isPersistedAsTable,
-  generatedByCompilerVersion,
   getNormalizedQuery,
   getRootArtifactName,
   getLastPartOfRef,

package/lib/model/revealInternalProperties.js

@@ -73,7 +73,6 @@ function revealInternalProperties( model, nameOrPath ) {
     artifacts: artifactDictionary,
     definitions: artifactDictionary,
     vocabularies: dictionary,
-    $lateExtensions: dictionary,
     elements,
     columns,
     expand: columns,

package/lib/modelCompare/compare.js

@@ -257,17 +257,19 @@ function getExtensionAndMigrations(beforeModel, options, {
 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) {
+    const isPersistedTable = isPersistedAsTable(artifact);
+    const isPersistedView = isPersistedAsView(artifact);
+    const isPersistedTableOther = otherArtifact && isPersistedAsTable(otherArtifact);
+    const isPersistedViewOther = otherArtifact && isPersistedAsView(otherArtifact);
+
+    // Looking for deleted entities or table -> view / view -> table
+    if (
+      (isPersistedTable && isPersistedViewOther) || // table -> view
+      (isPersistedView && isPersistedTableOther) || // view -> table
+      ((isPersistedTable || isPersistedView) && // deleted
+        !(isPersistedTableOther || isPersistedViewOther))
+    ) // view turned into table - need to render a drop for the view
       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;
-    }
   };
 }