Possible to change the operation inside Client Extension?

[haleksandre]

Question

Is it possible to modify the operation of a query?

The use case is to implement a Soft Delete but instead of adding a softDelete method, I'd prefer to change the behaviour of the delete operation on models & add a custom forceDelete that actually deletes.

// Custom 'softDelete' API
const prisma = new PrismaClient().$extends({
  model: {
    product: {
      async softDelete(this,  args) {
        return this.update(args);
      },
    },
  },
});

// 'delete' + custom 'forceDelete' API
const prisma = new PrismaClient().$extends({
  query: {
    product: {
      async delete({ args, query }) {
        // Modifying delete operation & change it to an update
        // return this.update(args) ??
        return query(args);
      },
    },
  },
  model: {
    product: {
      async forceDelete(this,  args) {
        return this.delete(args);
      },
    },
  },
});

Is it possible to implement some kind of behaviour like in the 'delete' + custom 'forceDelete' API example?

[GustavoGomez092]

I guess you can pass down the Prisma client instance and then return the operation you want to make:
(I ain't no expert, this is what worked for me, you can take this as pseudo-code or as a reference)

const originalPrisma = new PrismaClient();

prismaEnhancer(originalPrisma);

export const prismaEnhancer = (prisma: PrismaClient) => {
  return prisma.$extends({
    query: {
      $allModels: {
        async delete(data) {
          return deleteEnhancer(prisma, data);
        },
      },
    },
  });
};

export const deleteEnhancer = async (prisma:PrismaClient, { model, operation, args, query }) => {

  operation = 'update';
  args.data = {archived:{set: true}};
  return prisma[model][operation](args);
};

Hope this helps!

[ludralph]

Hi @haleksandre 👋

Yes, you can modify the operation of a query using Prisma Client extensions. Prisma Client extensions allow you to hook into the query life-cycle and modify an incoming query or its result. You can use the query extension component to create custom behavior for specific operations on models.
For example, to modify the delete operation on the user model to implement a soft delete, you could do something like this:

const prisma = new PrismaClient().$extends({
  query: {
    user: {
      async delete({ args, query }) {
        // Custom logic to implement soft delete
        // For instance, setting a 'deleted' flag instead of actual deletion
        args.data = { ...args.data, deleted: true };
        args.where = { ...args.where }; // Ensure the 'where' clause is preserved
        return query.update(args); // Use the update method with the modified args
      },
    },
  },
});

In this example, the delete operation is modified to perform an update instead, setting a deleted flag on the user record.

If this answers your question, it would be great if you could mark this Discussion as answered to indicate that it has been resolved.

Otherwise please let us know how else we can help you further or close the Discussion if it was resolved in some other way 🙏

[rsslldnphy]

hi @ludralph - i'm trying the same thing but getting type errors. should your example typecheck?

[rsslldnphy]

have also tried taking this as the first argument to the function and calling update on that, which still gives me type errors unfortunately :-(

[zac-cericola]

Hi @haleksandre 👋

Yes, you can modify the operation of a query using Prisma Client extensions. Prisma Client extensions allow you to hook into the query life-cycle and modify an incoming query or its result. You can use the query extension component to create custom behavior for specific operations on models. For example, to modify the delete operation on the user model to implement a soft delete, you could do something like this:

const prisma = new PrismaClient().$extends({
  query: {
    user: {
      async delete({ args, query }) {
        // Custom logic to implement soft delete
        // For instance, setting a 'deleted' flag instead of actual deletion
        args.data = { ...args.data, deleted: true };
        args.where = { ...args.where }; // Ensure the 'where' clause is preserved
        return query.update(args); // Use the update method with the modified args
      },
    },
  },
});

In this example, the delete operation is modified to perform an update instead, setting a deleted flag on the user record.

If this answers your question, it would be great if you could mark this Discussion as answered to indicate that it has been resolved.

Otherwise please let us know how else we can help you further or close the Discussion if it was resolved in some other way 🙏

@ludralph Hi, can I get some guidance on how this actually works? Like @rsslldnphy I'm getting the same type errors when calling query.update(args) and the call errors out saying the update method does not exist on query. Thanks!

[MaxBarbet]

Same error on my side in prisma 5.22

`import { Prisma } from '@prisma/client';

//extension for filtering soft deleted rows from queries
export const softDelete = Prisma.defineExtension({
name: 'softDelete',
query: {
$allModels: {
async $allOperations({ model, operation, args, query }) {
const dmmf = Prisma.dmmf.datamodel.models.find(
(m) => m.name === model
);
const hasDeletedAt = dmmf?.fields.some((field: any) => field.name === 'deletedAt');

			if (
				operation === 'findUnique' ||
				operation === 'findFirst' ||
				operation === 'findMany'
			) {
				if (hasDeletedAt && !(args.where as any)?.deletedAt) args.where = { ...args.where, deletedAt: null };
				return query(args);
			} else if (operation === 'delete' || operation === 'deleteMany') {
				if (hasDeletedAt) {
					return this.update({
						...args,
						data: {
							deletedAt: new Date(),
						},
					});
				}
			}
			return query(args);
		},
	},
},

});
`

I have the error : this.update is not a function
I tried to implement it using query.update, query({operation: 'update'}), same error.

[john-wallace-apps]

I also had to figure this out. Here's what I did:

const prisma = new PrismaClient().$extends(SoftDeleteExtension());
const handler = startServerAndCreateNextHandler(server, {
  context: async (request: NextRequest) => {
    return {
      prisma,
      request,
    }
  },
});

export const SoftDeleteExtension = () => {
  return Prisma.defineExtension((client) => {
    return client.$extends({
      query: {
        $allModels: {
          async $allOperations({ model, operation, args, query }: { model: any, operation: Operation, args: any, query: any }) {
            if (enableHardDeletes) {
              return query(args);
            }

            // Get the model object so that we can call the correct function.
            // NOTE: calling the other function will re-enter the stack and come back through this extension
            const modelObject = (client as any)[model];

            if (['findMany', 'findFirst', 'findUnique', 'count', 'groupBy', 'aggregate'].includes(operation)) {
              if (operation === 'findUnique') {
                // Prisma's findUnique doesn't support additional filters, so switch to findFirst
                return modelObject.findFirst(args);
              }

              args ||= {};
              args.where ||= {};
              args.where.deletedAt = null;
            }

            else if (['update', 'updateMany', 'upsert'].includes(operation)) {
              args ||= {};
              args.where ||= {};
              args.where.deletedAt = null;
            }

            else if (['delete', 'deleteMany'].includes(operation)) {
              if (operation === 'delete') {
                return modelObject.update({
                  where: args.where, 
                  data: { deletedAt: new Date() }, 
                });      
              }
              if (operation === 'deleteMany') {
                return modelObject.updateMany({
                  where: args.where, 
                  data: { deletedAt: new Date() }, 
                });      
              }
            }

            else {
              console.error(`SoftDeleteExtension: Operation ${operation} not supported`);
            }

            return query(args);
          }
        }
      }
    })
  });
}

[ludralph]

Hi there,

To keep our discussions organized and focused on the most relevant topics, we’re reviewing and tidying up our backlog. As part of this process, we’re closing discussions that haven’t had any recent activity and appear to be outdated.

If this discussion is still important to you or unresolved, we’d love to hear from you! Feel free to reopen it or start a new one with updated details.

For more details about our priorities and vision for the future of Prisma ORM, check out our latest blog post: https://www.prisma.io/blog/prisma-orm-manifesto.

Thank you for your understanding and being part of the community!