fix: deep delete for views without navigation

db-service/lib/SQLService.js

@@ -1,7 +1,7 @@
 const cds = require('@sap/cds/lib'),
   DEBUG = cds.debug('sql|db')
 const { Readable } = require('stream')
-const { resolveView } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
+const { resolveView, getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const DatabaseService = require('./common/DatabaseService')
 const cqn4sql = require('./cqn4sql')
 
@@ -192,7 +192,26 @@ class SQLService extends DatabaseService {
     // REVISIT: It's not yet 100 % clear under which circumstances we can rely on db constraints
     return (super.onDELETE = /* cds.env.features.assert_integrity === 'db' ? this.onSIMPLE : */ deep_delete)
     async function deep_delete(/** @type {Request} */ req) {
-      let { compositions } = req.target
+      const transitions = getTransition(req.query.target, this)
+      if (transitions.target !== transitions.queryTarget) {
+        const targetKeys = transitions.queryTarget.keys
+        const matchedKeys = Object.keys(targetKeys).filter(key => transitions.mapping.has(key))
+        const query = DELETE.from({
+          ref: [
+            {
+              id: transitions.target.name,
+              where: [
+                { list: Object.keys(transitions.target.keys || {}).map(k => ({ ref: [k] })) },
+                'in',
+                SELECT.from(req.query.DELETE.from).columns(matchedKeys).where(req.query.DELETE.where),
+              ],
+            },
+          ],
+        })
+        return this.onDELETE({ query })
+      }
+      const table = getDBTable(req.query.target)
+      const {compositions} = table
       if (compositions) {
         // Transform CQL`DELETE from Foo[p1] WHERE p2` into CQL`DELETE from Foo[p1 and p2]`
         let { from, where } = req.query.DELETE
@@ -204,11 +223,11 @@ class SQLService extends DatabaseService {
         }
         // Process child compositions depth-first
         let { depth = 0, visited = [] } = req
-        visited.push(req.target.name)
+        visited.push(req.query.target.name)
         await Promise.all(
           Object.values(compositions).map(c => {
             if (c._target['@cds.persistence.skip'] === true) return
-            if (c._target === req.target) {
+            if (c._target === req.query.target) {
               // the Genre.children case
               if (++depth > (c['@depth'] || 3)) return
             } else if (visited.includes(c._target.name))
@@ -219,7 +238,7 @@ class SQLService extends DatabaseService {
               )
             // Prepare and run deep query, à la CQL`DELETE from Foo[pred]:comp1.comp2...`
             const query = DELETE.from({ ref: [...from.ref, c.name] })
-            return this.onDELETE({ query, depth, visited: [...visited], target: c._target })
+            return this.onDELETE({ query, depth, visited: [...visited] })
           }),
         )
       }

test/compliance/DELETE.test.js

@@ -1,5 +1,47 @@
+const cds = require('../../test/cds.js')
+const complex = cds.utils.path.resolve(__dirname, '../compliance/resources')
+const Root = 'complex.Root'
+const GrandChild = 'complex.GrandChild'
+
 describe('DELETE', () => {
+  const { expect, GET, DELETE } = cds.test(complex)
   describe('from', () => {
+    test('deep delete', async () => {
+      const inserts = [
+        INSERT.into(Root).entries([
+          {
+            ID: 5,
+            children: [
+              {
+                ID: 6,
+                children: [
+                  {
+                    ID: 7,
+                  },
+                ],
+              },
+            ],
+          },
+        ]),
+      ]
+      const insertsResp = await cds.run(inserts)
+      expect(insertsResp[0].affectedRows).to.be.eq(1)
+
+      const deepDelete = await DELETE('/comp/RootP(5)')
+      expect(deepDelete.status).to.be.eq(204)
+
+      const root2 = await GET('/comp/RootP')
+      expect(root2.status).to.be.eq(200)
+      expect(root2.data.value.length).to.be.eq(0)
+
+      const child2 = await GET('/comp/ChildP')
+      expect(child2.status).to.be.eq(200)
+      expect(child2.data.value.length).to.be.eq(0)
+
+      const grandchild2 = await cds.run(SELECT.from(GrandChild))
+      expect(grandchild2.length).to.be.eq(0)
+    })
+
     test.skip('missing', () => {
       throw new Error('not supported')
     })

test/compliance/resources/db/complex/index.cds

@@ -11,3 +11,23 @@ entity Authors {
   name   : String(111);
   books  : Association to many Books on books.author = $self;
 }
+
+
+entity Root {
+    key ID : Integer;
+    fooRoot: String;
+    children : Composition of many Child on children.parent = $self;
+}
+
+entity Child {
+    key ID: Integer;
+    fooChild: String;
+    parent: Association to one Root;
+    children: Composition of many GrandChild on children.parent = $self
+}
+
+entity GrandChild {
+    key ID: Integer;
+    fooGrandChild: String;
+    parent: Association to one Child;
+}

test/compliance/resources/srv/index.cds

@@ -0,0 +1,17 @@
+using {complex as my} from '../db/complex';
+
+service ComplexService @(path:'/comp') {
+    entity RootP  as
+        projection on my.Root {
+            key ID,
+            fooRoot,
+            children
+        };
+
+    entity ChildP as
+        projection on my.Child {
+            key ID,
+            fooChild,
+            parent
+        }
+}