If you are still down here without an answer, I used a combination from @Antoine's answer and another SO answer:

model Likes {
  id         String     @id @unique @default(uuid())
  user_id    String
  tag        String
  auth_user  AuthUser   @relation(references: [id], fields: [user_id], onDelete: Cascade)

  @@unique([user_id, tag], name: "user_id_tag")  // <-- this is the unique constraint
  @@index([user_id])
  @@map("likes")
}

Then I was able to upsert via the following:

prisma.likes.upsert({
    where: {
        user_id_tag: { // <-- And this bit is important
            user_id: user.userId,
            tag: tag.tag
        }
    },
    update: {},
    create: tag
})

This seems to work:

where: {
  id: args.id || 0,
},

If an id is provided it will set it, otherwise it will use id 0 which does not exist so it will create a new record.

If I understand your question correctly, the request body may optionally contain an id or be undefined. If the id is present in the request, you want to update the corresponding record. If it isn't, you want to create a new record.

upsert functionality requires a unique identifier that can be used by the database to check whether there is a matching record. The database will then decide what to do. However with an undefined value, prisma cannot work.

You could use a key that will not exist in the database in case the value of id is undefined to make upsert insert the record in this case.

await prisma.profile.upsert({
  where: { id: id || '' },
  // ...
});

Or you could differentiate the cases and treat them appropriately:

if (id) {
  await prisma.profile.update({
    where: { id },
    data: {
      username,
      about,
      // ...
    },
  });
} else {
  await prisma.profile.create({
    data: {
      username,
      about,
      // ...
    },
  });
}

You might want to think about the case that there is an id given in the body, but it does exist in the database. Do you want the update to fail and reply with an error? Or do you want the database to silently insert? Then use upsert instead of update above.

looked further into the documentation, the upsert command has a limitation where if you do not have the id in a where clause it will not do the find/create. So this was not able to work, as shown below.

https://www.prisma.io/docs/concepts/components/prisma-client/crud#update-or-create-records

This was resolved by doing the following command where I seperated out the two arrays and then updated/created individually based on those two different arrays.

As shown below.

app.put('/api/recipes/:id', async (req, res) => {
    try {
      const recipeId = Number(req.params.id);
      const {
        name,
        description,
        steps,
        notes,
        Recipe_Ingredient,
      } = req.body;
  
      const recipe_ingredientNoID = [];
      const recipe_ingredientsID = [];
  
      Recipe_Ingredient.forEach((ingredient) => {
        if (ingredient.id) {
          recipe_ingredientsID.push(ingredient);
        } else {
          recipe_ingredientNoID.push(ingredient);
        }
      });
  
      const updatedRecipe = await prisma.recipe.update({
        where: {
          id: recipeId,
        },
        data: {
          name: name,
          description: description,
          steps: steps,
          notes: notes,
          Recipe_Ingredient: {
            updateMany: recipe_ingredientsID.map((ingredient) => ({
              where: { id: ingredient.id },
              data: {
                ingredientId: Number(ingredient.ingredientId),
                quantity: parseFloat(ingredient.quantity),
                measurement: ingredient.measurement,
              },
            })),
            create: recipe_ingredientNoID.map((ingredient) => ({
              ingredientId: Number(ingredient.ingredientId),
              quantity: parseFloat(ingredient.quantity),
              measurement: ingredient.measurement,
            })),
          },
        },
        include: {
          Recipe_Ingredient: true,
        },
      });
  
      res.status(200).json(updatedRecipe);
    } catch (error) {
      console.error(error);
      res.status(500).json({ error: 'Failed to update recipe' });
    }
  });