There's two errors in the code.

Tag.name field is not unique

From what I can infer from your domain, two tags should not have the same name. Furthermore, since the name field is not unique, you can't use it by itself to uniquely identify a specific Tag record and so Prisma will complain if you try to pass only the name field in the where condition of connectOrCreate.

The simplest and logical solution to this is to make the name field unique. Here's your updated Tag model

model Tag {
  id       Int       @id @default(autoincrement())
  name     String    @unique  // change
  articles Article[]
}

Incorrect syntax for connectOrCreate

You're passing separate arrays to the where and create fields. Instead, when you want to connect/create multiple records, pass an array of objects to connectOrCreate each with its own where and create field. Here's an example from the Prisma Docs that shows how to use connectOrCreate with multiple records.

This is what your create query should look like:

await prisma.article.create({
  data: {
    title,
    summary,
    link,
    archive,
    content,
    image,
    tags: {
        connectOrCreate: tags.map((tag) => {
            return {
                where: { name: tag },
                create: { name: tag },
            };
        }),
    },
  },
});

@jsun969 👋

There's an error with where you're using tags.map. You need to map over connectOrCreate like this:

await prisma.article.create({
  data: {
    title,
    summary,
    link,
    archive,
    content,
    image,
    tags: {
        connectOrCreate: tags.map(tag => ({
          where: { name: tag }, create:  { name: tag } 
        }))
    },
  },
});

Hey @johhansantana, thanks a lot for raising this!

So, connectOrCreate is used as a nested operation whereas upsert is a top-level operation. We also chose the wording for connectOrCreate in a way that it's intuitively clear what's happening: Fist we try to connect to the record specified by where. If the record does not exist, we create a new one. Functionality-wise, they're indeed similar but we chose a bit more precise wording for this one to make it easier to understand.

On a technical level, the two are also different and take different input arguments:

await prisma.user.update({
  data: {
    name: 'Alice',
    posts: {
      upsert: {
        create: { title: 'Hello World' },
        where: { id: 1 },
        update: { title: 'Hello World' },
      },
    },
  },
  where: { id: 42 },
})

await prisma.user.update({
  data: {
    name: 'Alice',
    posts: {
      connectOrCreate: {
        create: { title: 'Hello World' },
        where: { id: 1 },
      },
    },
  },
  where: { id: 42 },
})

Does that help? 🙂

@techboy-coder 👋

This is the only way you could do it for now as connectOrCreate only supports unique fields. I would suggest creating a feature request here with the above use case so that we can look into this 🙂

What you need here is connectOrCreate.

So something like this should work:

      await prisma.post.create({
        data: {
          title: 'Hello',
          categories: {
            create: [
              {
                category: {
                  create: {
                    name: 'category-1',
                  },
                },
              },
              { category: { connect: { id: 10 } } },
            ],
          },
        },
      });

You can also read more about this in the docs here

As the docs states:

Multiple connectOrCreate queries that run as concurrent transactions can result in a race condition. ...

So if you request 2 movies of the same genre at the same time and this genre is not yet exist then both queries would try to create this genre and only the first one will succeed.

Docs recommends catching for specific error:

To work around this scenario, we recommend catching the unique violation exception (PrismaClientKnownRequestError, error P2002) and retrying failed queries.

You can also create all the genres at first, for example:

// Some abstract function which extracts all the genres
const genres = gatherGenres(results);

await prisma.genres.createMany({
    data: genres,
    // Do nothing on duplicates
    skipDuplicates: true,
});

And then create all the movies and connect them to genres, because genres have already been created.

Also, small nitpick, you function retrieveList is not awaitable because it returns an array of promises, and to actually wait until all the promises are done you need to use Promise.all on it

const retrieveList = async () => {
   const results = await API.getMovies();
   return results.map((item) => getMovieItem(item.id));
}

// ...

// You can't just await it ❌
await retrieveList()

// Need to use Promise.all ✅
await Promise.all(retrieveList())