For the model, it can be simplified as follows as Prisma supports @updatedAt which will automatically update the column:

model Post {
  author      String     @id
  lastUpdated DateTime   @updatedAt
  categories  Category[]
}

model Category {
  id    Int    @id
  posts Post[]
}

As for the query, it would look like this:

const categories = [
  { create: { id: 1 }, where: { id: 1 } },
  { create: { id: 2 }, where: { id: 2 } },
]
await db.post.upsert({
  where: { author: 'author' },
  create: {
    author: 'author',
    categories: {
      connectOrCreate: categories,
    },
  },
  update: {
    categories: { connectOrCreate: categories },
  },
})

connectOrCreate will create if not present and add the categories to the posts as well.

Hey @stardvst 👋 ,

Can you provide a specific error message? Is the error coming from Prisma or somewhere else?

Thanks!

Hi @gurjotkaur20 👋

Thank you for raising this question.

In the context of explicit many-to-many relationships, Prisma does not directly support the set operation as it does with implicit relationships. This is because, with explicit relationships, you are directly managing the join table (users_groups in your case), and Prisma expects you to handle the creation and deletion of records in this table yourself.
However, a workaround to achieve the behavior you're looking for—replacing existing relations with new ones—can be done in two steps:

• Delete the existing relations from the join table.
• Create new relations in the join table.

After clearing the existing relations, you then create new ones by updating the groupp model with a create operation under the users field. This operation adds new entries to the users_groups table, linking the groupp to new user(s).

// Step 1: Delete existing relations for the group
await prisma.users_groups.deleteMany({
  where: {
    groupId: 'b81f8b10-9bf6-4589-b95b-fe55430a47f5',
  },
});

// Step 2: Update the group and create or connect new user relations
await prisma.groupp.update({
  where: {
    id: 'b81f8b10-9bf6-4589-b95b-fe55430a47f5',
  },
  data: {
    users: {
      create: [
        { user: { connect: { id: 'newUserId1' } } },
        // Add more users as needed
      ],
    },
  },
});

This approach requires two separate operations and might not be as efficient or atomic as a single set operation in implicit many-to-many relations.

If this answers your question, it would be great if you could mark this Discussion as answered to indicate that it has been resolved.

Otherwise please let us know how else we can help you further or close the Discussion if it was resolved in some other way 🙏

Hey @Bradleykingz 👋
Remove async from the create function and run it again and check.

Here you go an example how to do that:

const { PrismaClient } = require('@prisma/client')
const prisma = new PrismaClient()

const saveData = async () => {
  const boxer1 = await prisma.boxer.create({
    data: {
      name: 'Boxer1',
    },
  })

  const boxer2 = await prisma.boxer.create({
    data: {
      name: 'Boxer2',
    },
  })
  const fight = await prisma.fight.create({
    data: {
      name: 'Fight 1',
      boxers: {
        createMany: {
          data: [
            { boxerId: boxer1.id },
            { boxerId: boxer2.id },
          ]
        },
      }
    },
    select: {
      id: true,
      name: true,
      boxers: {
        select: {
          boxer: {
            select: {
              name: true,
            }
          }
        }
      }
    }
  })

  console.log(JSON.stringify(fight, null, 2))

  const boxer3 = await prisma.boxer.create({
    data: {
      name: 'Boxer3',
    },
  })
  
  const fightUpdated = await prisma.fight.update({
    where: {
      id: fight.id
    },
    data: {
      boxers: {
        createMany: {
          data: [
            { boxerId: boxer3.id },
          ]
        },
        deleteMany: {
          OR: [
            { boxerId: { equals: boxer1.id } },
          ]
        }
      }
    },
    select: {
      name: true,
      boxers: {
        select: {
          boxer: {
            select: {
              name: true,
            }
          }
        }
      }
    }
  })

  console.log(JSON.stringify(fightUpdated, null, 2))

}

saveData()

In the update you have to remove the previous boxer and the new one :)

connectOrCreate should specify where key with id (so Prisma could find this entity) and create key with all required model fields (so Prisma could create it if it not already present), but you just passing an array of models. Change your code to this one:

  await prisma.user.upsert({
    where: {
      email: 'user.email',
    },
    create: {
      name: 'user.name',
      email: 'user.email',
      followings: {
        connectOrCreate: [
          {
            create: {
              name: 'MARINA',
              spotifyId: '6CwfuxIqcltXDGjfZsMd9A',
            },
            where: { id: '...' },
          },
        ],
      },
    },
    update: {
      followings: {
        connectOrCreate: [
          {
            create: {
              name: 'MARINA',
              spotifyId: '6CwfuxIqcltXDGjfZsMd9A',
            },
            where: { id: '...' },
          },
        ],
      },
    },
  });

Answered in this Discussion: #15959

@moroshko 👋

Currently yes this is the only way you could do it via Prisma's provided API. It would be great if you could add a 👍 to this request so that we can look at the priority for this.
#4134

Hey @ilya-lopukhin 👋
Did you try writing it like this?

prisma.chat.update({
    where: { id: 1 },
    data: {
      seenBy: {
        connect: [{ id: 1 }, { id: 2 }, { id: 3 }],
      },
    },
})

This will update the seen for all users specified in connect