Create custom Prisma Client queries

Modify a specific operation in a specific model

The query object can contain functions that map to the names of the Prisma Client operations, such as findUnique, findFirst, findMany, count, and create. The following example modifies user.findMany to a use a customized query that finds only users who are older than 18 years:

const xprisma = prisma.$extends({
  query: {
    user: {
      async findMany({ model, operation, args, query }) {
        // set `age` and fill with the rest of `where`
        args.where = { age: { gt: 18 }, ...args.where }

        return query(args)
      },
    },
  },
})

await xprisma.user.findMany() // returns users whose age is greater than 18

In the above example, a call to xprisma.user.findMany triggers query.user.findMany. Each callback receives a type-safe { model, operation, args, query } object that describes the query. This object has the following properties:

• model: the name of the containing model for the query that we want to extend.

  In the above example, the model is a string of type "User".

• operation: the name of the operation being extended and executed.

  In the above example, the operation is a string of type "findMany".

• args: the specific query input information to be extended.

  This is a type-safe object that you can mutate before the query happens. You can mutate any of the properties in args. Exception: you cannot mutate include or select because that would change the expected output type and break type safety.

• query: a promise for the result of the query.

  • You can use await and then mutate the result of this promise, because its value is type-safe. TypeScript catches any unsafe mutations on the object.

Modify a specific operation in all models of your schema

To extend the queries in all the models of your schema, use $allModels instead of a specific model name. For example:

const xprisma = prisma.$extends({
  query: {
    $allModels: {
      async findMany({ model, operation, args, query }) {
        // set `take` and fill with the rest of `args`
        args = { take: 100, ...args }

        return query(args)
      },
    },
  },
})

Modify all operations in a specific model

Use $allOperations to extend all operations in a specific model.

For example, the following code applies a custom query to all operations on the user model:

const xprisma = prisma.$extends({
  query: {
    user: {
      $allOperations({ model, operation, args, query }) {
        // handle all operations
        return query(args)
      },
    },
  },
})

Modify all operations in all models of your schema

Use $allModels and $allOperations to extend all operations in all models of your schema.

To apply a custom query to all operations on all models of your schema:

const xprisma = prisma.$extends({
  query: {
    $allModels: {
      $allOperations({ model, operation, args, query }) {
        // handle all operations
        return query(args)
      },
    },
  },
})

Modify a top-level raw query operation

To apply custom behavior to a specific top-level raw query operation, use the name of a top-level raw query function instead of a model name:

const xprisma = prisma.$extends({
  query: {
    $queryRaw({ args, query, operation }) {
      // handle $queryRaw operation
      return query(args)
    },
    $executeRaw({ args, query, operation }) {
      // handle $executeRaw operation
      return query(args)
    },
    $queryRawUnsafe({ args, query, operation }) {
      // handle $queryRawUnsafe operation
      return query(args)
    },
    $executeRawUnsafe({ args, query, operation }) {
      // handle $executeRawUnsafe operation
      return query(args)
    },
  },
})

Mutate the result of a query

You can use await and then mutate the result of the query promise.

const xprisma = prisma.$extends({
  query: {
    user: {
      async findFirst({ model, operation, args, query }) {
        const user = await query(args)

        if (user.password !== undefined) {
          user.password = '******'
        }

        return user
      },
    },
  },
})

If you use the query extension component and middlewares

If you use the query extension component and middlewares in your project, then the following rules and priorities apply:

• In your application code, you must declare all your middlewares on the main Prisma Client instance. You cannot declare them on an extended client.
• In situations where middlewares and extensions with a query component execute, Prisma Client executes the middlewares before it executes the extensions with the query component. Prisma Client executes the individual middlewares and extensions in the order in which you instantiated them with $use or $extends.