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.

Prisma doesn't natively support upsertMany.

There is a Feature Request to provide the upsertMany method.

As of now the best approach would be to loop over the data and invoke upsert in the loop along with using $transaction.

Example:

const collection = await prisma.$transaction(
    userData.map(cur =>
      prisma.cur.upsert({
        where: { id: cur.id },
        update: {},
        create: { id: cur.id },
      })
    )
  )

Here's a reference to $transaction API which should be helpful.

Sorry for this, I have changed and found another way to do this. If anyone was curious on how i changed it (for future use if anyone gets stuck and gets the same results like this)

    const prisma = new PrismaClient()
    const { username, email, hashPassword } = await request.json();
    let verified = crypto.randomBytes(32).toString('hex');

    const userExist = await prisma.users.findFirst({ where: { OR: [{ username }, { email }] } })
    if (userExist === null) {
        await prisma.users.create({ data: { username, email, hashPassword, verified } })
        return new NextResponse('Success!', { status: 201 })
    } else {
        return new NextResponse("Sorry, username and or email already exists!", { status: 500 })
    }

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
            }
        },
    },
});

This is a late answer, but it could help others.

The way I see it, on Postgres ON CONFLICT expect a unique field or a combination of fields with unique constraints. This goes the same for PRISMA.

On your Prisma model

model user_conference {
   user_id Int
   conference_id String
   points Int
   activities_completed String[]
   @@unique([user_id, conference_id])
 }

For your direct query translation, use this.

prisma.user_conference.upsert({
   where: {
     user_id_conference_id : { // here Prisma expects user_id and conference_id both in combination are unique
       user_id: 1,
       conference_id: '3a4QQI0KbO0eaDjzhIgeeZ',
     }
   },
   create: {
     user_id: 1,
     conference_id: '3a4QQI0KbO0eaDjzhIgeeZ',
     points: 40,
     activities_completed: ['4vwp3L1EJYQ9rI1Pv7er2']
   },
   update: {
     points: {
       increment: 40,
     },
     activities_completed: {
       push: '4vwp3L1EJYQ9rI1Pv7c4x0'
     }
   }
 });
}