[V4] QueryEngine - deleteMany not working when filter by nested entity.

[c7ming]

Bug report

Describe the bug

When trying to deleteMany by the nested entity filtering, An error occurs.

Steps to reproduce the behavior

1. Have eneties A & B.
2. Add relation between A & B, and B has many A.
3. Execute codes

Expected behavior

All B filtered A will be deleted.

Screenshots

Code snippets

await strapi.query(A).deleteMany({ where: { B: { id: { $eq: params.id }, } } })

System

• Node.js version: V14
• NPM version: 7.22.0
• Strapi version: 4.0.1
• Database: MySql
• Operating system: MacOs Monterey

[iicdii]

I reproduced it with sqlite too

[Error: delete from `addresses` where (`t2`.`id` = 1) - SQLITE_ERROR: no such column: t2.id] {
  errno: 1,
  code: 'SQLITE_ERROR'
}

And I found some evidences that it's WIP

strapi/packages/core/content-manager/server/services/entity-manager.js

Lines 202 to 207 in 0f9b692

	// FIXME: handle relations
	deleteMany(opts, uid) {
	const params = { ...opts };
	return strapi.entityService.deleteMany(uid, params);
	},

strapi/packages/core/database/lib/entity-manager.js

Lines 324 to 340 in e5ee7f0

	// TODO: where do we handle relation processing for many queries ?
	async deleteMany(uid, params = {}) {
	await db.lifecycles.run('beforeDeleteMany', uid, { params });
	const { where } = params;
	const deletedRows = await this.createQueryBuilder(uid)
	.where(where)
	.delete()
	.execute();
	const result = { count: deletedRows };
	await db.lifecycles.run('afterDelete', uid, { params, result });
	return result;
	},

[iicdii]

Temporary workaround

assume that..

api::address.address - A
api::category.category - B (has many addresses)

Example

let addressItems;
try {
  addressItems = await strapi
    .query("api::address.address")
    .findMany({ where: { category: { id: 1 } } });
} catch (e) {
  console.error(e);
}

try {
  for (const address of addressItems) {
    await strapi
      .query("api::address.address")
      .delete({ where: { id: address.id } });
  }
} catch (e) {
  console.error(e);
}

[rcdk]

I would also love to get this fixed :-)

[strapi-bot]

This issue has been mentioned on Strapi Community Forum. There might be relevant details there:

https://forum.strapi.io/t/find-and-filtering-entries-with-deletemany/21679/2

[antokhio]

Just came across this, with oneToOne relation, strapi version 4.3.2
Works:

let tasks = await strapi.db.query("api::task.task").findMany({
  where: {
    parent: section.id,
  },
});

Doesn't work:

let tasks = await strapi.db.query("api::task.task").deleteMany({
  where: {
    parent: section.id,
  },
});

Error message:

error: delete from "tasks" using "tasks_parent_links" as "t1","sections" as "t2" where ("t2"."id" = $1) and "t0"."id" = "t1"."task_id" and "t1"."section_id" = "t2"."id" - missing FROM-clause entry for table "t0"

[borisNG]

i'm currently having this issue do you have any clue on how to solve that?

[MHase]

I had exactly the same issue and I've managed to solve this by adding additional query

I wanted to remove all all products (lamps) which are related to common family
in my case I had to query for all related items and after that remove them one by one

I know it's not perfect, but for this deleteMany error should be enough 😞

still I hope that they will fix it in near future

beforeDelete: async (event) => {
  const { params } = event;

  const familyId = params.where.id;
 
  const lampsToDelete = await strapi.db.query("api::lamp.lamp").findMany({
    where: {
      family: {
        id: {
          $eq: familyId,
        },
      },
    },
  });

  await Promise.all(
    lampsToDelete.map(({ id }) =>
      strapi.db.query("api::lamp.lamp").delete({
        where: { id },
      })
    )
  );
},

[XanderD99]

Just encountered this issue as well.

Got it working with the code below. Seems like strapi just expects us to pass something in the id value in the where filter. So passing a query to match all ids in an array of numbers works just fine.

module.exports = {
  async beforeDelete({ params }) {
    const toDelete = await strapi.db.query('api::discord.channel').findMany({ where: { guild: params.where.id } });
    return strapi.db.query('api::discord.channel').deleteMany({ where: { id: { $in: toDelete.map(({ id }) => id) } } });
  },
}

[antokhio]

Just encountered this agian:
message collection type

{
  "kind": "collectionType",
  "attributes": {
    "chat": {
      "type": "relation",
      "relation": "oneToOne",
      "target": "api::chat.chat"
    },
  },
}

message has one chat

query:

await strapi.db.query("api::message.message").deleteMany({ where: { chat: chatId }});

result

[2022-11-14 21:07:03.662] error: delete from "messages" using "messages_chat_links" as "t1","chats" as "t2" where ("t2"."id" = $1) and "t0"."id" = "t1"."message_id" and "t1"."chat_id" = "t2"."id" - missing FROM-clause entry for table "t0"
error: delete from "messages" using "messages_chat_links" as "t1","chats" as "t2" where ("t2"."id" = $1) and "t0"."id" = "t1"."message_id" and "t1"."chat_id" = "t2"."id" - missing FROM-clause entry for table "t0"

temporary fix, use find, Promise.all