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.

You can use select or include as you would in a find operation to include referenced objects, e.g.

const client = await prisma.client.upsert({
  where: {
    email: email,
  },
  update: {
    tickets: {
      create: [ ticketOrder ]
    }
  },
  create: {
    first: first,
    last: last,
    email: email,
    tickets: {
      create: [ ticketOrder ]
    }
  },
  include: {
    tickets: true
  }
});

This would return all tickets.

To me, it seems strange to upsert the client, if you primarily want to create at ticket. You could instead create a ticket and create or connect the client:

const ticket = await prisma.ticket.create({
  data: {
    // ...
    client: {
      connectOrCreate: // ...
    }
  },
})

See: https://www.prisma.io/docs/concepts/components/prisma-client/relation-queries#connect-or-create-a-record

Hey @stardvst 👋 ,

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

Thanks!

I'm providing my solution based on the clarifications you provided in the comments. First I would make the following changes to your Schema.

Changing the schema

model A_User {
  id        Int          @id
  username  String
  age       Int
  bio       String       @db.VarChar(1000)
  createdOn DateTime     @default(now())
  features  A_Features[]
}

model A_Features {
  id          Int      @id @default(autoincrement())
  description String   @unique
  users       A_User[]
}

Notably, the relationship between A_User and A_Features is now many-to-many. So a single A_Features record can be connected to many A_User records (as well as the opposite).

Additionally, A_Features.description is now unique, so it's possible to uniquely search for a certain feature using just it's description.

You can read the Prisma Guide on Relations to learn more about many-to-many relations.

Writing the update query

Again, based on the clarification you provided in the comments, the update operation will do the following:

• Overwrite existing features in a A_User record. So any previous features will be disconnected and replaced with the newly provided ones. Note that the previous features will not be deleted from A_Features table, but they will simply be disconnected from the A_User.features relation.

• Create the newly provided features that do not yet exist in the A_Features table, and Connect the provided features that already exist in the A_Features table.

You can perform this operation using two separate update queries. The first update will Disconnect all previously connected features for the provided A_User. The second query will Connect or Create the newly provided features in the A_Features table. Finally, you can use the transactions API to ensure that both operations happen in order and together. The transactions API will ensure that if there is an error in any one of the two updates, then both will fail and be rolled back by the database.

//inside async function
const disconnectPreviouslyConnectedFeatures =  prisma.a_User.update({
    where: {id: 1},
    data: {
        features: {
            set: []  // disconnecting all previous features
        }
    }
})

const connectOrCreateNewFeatures =  prisma.a_User.update({
    where: {id: 1},
    data: {
        features: {
            // connect or create the new features
            connectOrCreate: [
                {
                    where: {
                        description: "'first feature'"
                    }, create: {
                        description: "'first feature'"
                    }
                },
                {
                    where: {
                        description: "second feature"
                    }, create: {
                        description: "second feature"
                    }
                }
            ]
        }
    }
})

// transaction to ensure either BOTH operations happen or NONE of them happen.
await prisma.$transaction([disconnectPreviouslyConnectedFeatures, connectOrCreateNewFeatures ])

If you want a better idea of how connect, disconnect and connectOrCreate works, read the Nested Writes section of the Prisma Relation queries article in the docs.

The error is pretty self-descriptive:

Unknown arg `userOneId` in create.userOneId for type ConnectionCreateInput

Since you are already passing userOne: {connect: {id: '.....' } } in your Prisma operation, you do not (and should not) also pass userOneId. You just need userOne: {connect..... and userTwo: {connect......

Your operation will end up looking like this:

const createOrUpdateRole = await prisma.connection.upsert({
    where: {
        id: id
    },
    update: {
        // You can have __either__ `userOneId: 'value'` or `userOne: {connect....` here
        // but not both
        userOneId: userOneId,
        userTwoId: userTwoId,
        isUserOneApproved,
        isUserTwoApproved,
        connectionRequestedOnDate,
        connectionAcceptedOnDate,
    },
    create: {
        isUserOneApproved,
        isUserTwoApproved,
        connectionRequestedOnDate,
        connectionAcceptedOnDate,
        userOne: {
            connect: {
                id: userOneId
            }
        },
        userTwo: {
            connect: {
                id: userTwoId
            }
        },
        profile: {
            connect: {
                id: profileId
            }
        },
    },
});

Hey @matteopolak 👋
Apologies for the late reply, this GitHub Discussion slipped through the cracks.

I think creating a unique constraint on the combination of userId and mode would be ideal.
For the upsert query, a record needs to be uniquely identified in order to decide whether a record needs to be inserted or updated.

In this case, as the uniqueness is dependent on both the userId and mode Prisma client prompts you to pass both the userId and mode.
Can you define the id of the parent document that needs to be inserted beforehand and pass that in the upsert statement?

Answered in this Discussion: #15959

You should cut out your steps in a transaction to delete the tags not in the query before inserting the new ones. Then you can create and update your data and return your post

With interactiveTransactions

In your schema.prisma you should enable interactiveTransactions, for this:

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["interactiveTransactions"]
}

Then cut out your steps in a transaction

// Remove <Post> if you aren't in typescript
await prisma.$transaction<Post>(async (trx) => {
  const existingTags = tags.filter(({ id }) => id);
  const newTags = tags.filter(({ id }) => !id);

  await trx.tag.deleteMany({
    where: {
      id: {
        notIn: existingTags.map(({ id }) => id),
      },
    },
  });
  // Update the existing tags
  await Promise.all(
    tags.map((tag) =>
      trx.tag.update({
        where: {
          id: tag.id,
        },
        data: {
          color: tag.color,
          name: tag.name,
        },
      })
    )
  );
  await trx.tag.createMany({
    data: newTags.map((tag) => ({
      ...tag,
      creator: {
        connect: {
          id: session.user.id,
        },
      },
    })),
  });
  return trx.post.update({
    where: {
      id: postId,
    },
    data: {
      title,
      content,
      updatedAt: new Date(),
    },
    include: {
      tags: true,
    },
  });
});