Function validateUniqueness

packages/api/src/validations/validations.ts:692–740

(
  model: string,
  fields: Record<string, unknown>,
  optionsOrCallback:
    | UniquenessValidatorOptions
    | ((tx: PrismaClient) => Promise<any>),
  callback?: (tx: PrismaClient) => Promise<any>,
)

  callback?: (tx: PrismaClient) => Promise<any>,
): Promise<any>
export async function validateUniqueness(
  model: string,
  fields: Record<string, unknown>,
  optionsOrCallback:
    | UniquenessValidatorOptions
    | ((tx: PrismaClient) => Promise<any>),
  callback?: (tx: PrismaClient) => Promise<any>,
): Promise<any> {
  const { $self, $scope, ...rest } = fields
  let options: UniquenessValidatorOptions = {}
  let validCallback: (tx: PrismaClient) => Promise<any>
  let db = null

  if (typeof optionsOrCallback === 'function') {
    validCallback = optionsOrCallback
  } else {
    options = optionsOrCallback
    validCallback = callback as (tx: PrismaClient) => Promise<any>
  }

  if (options.db) {
    const { db: customDb, ...restOptions } = options
    options = restOptions
    db = customDb
  } else {
    db = new PrismaClient()
  }

  const where: UniquenessWhere = {
    AND: [rest],
    NOT: [],
  }
  if ($scope) {
    where.AND.push($scope as Record<string, unknown>)
  }
  if ($self) {
    where.NOT.push($self as Record<string, unknown>)
  }

  return await db.$transaction(async (tx: PrismaClient) => {
    const found = await tx[model].findFirst({ where })

    if (found) {
      validationError('uniqueness', fieldsToString(fields), options)
    }

    return validCallback(tx)
  })
}