another hacky way around this is a wrapper class that contains the prisma object as an internal data field.

but this means none of the prisma methods are exposed on the wrapper class, so a lot of tedious mapping/duplication is needed.

export class CPlayer {
    data?: Player | null

    constructor(data?: Player | null) {
        this.data = data
    }

    static async findOrCreate(query: Prisma.PlayerWhereInput): Promise<CPlayer> {
        let data = await prisma.player.findFirst({ where: query })
        if (!data) {
            const input = query as Prisma.PlayerCreateInput
            data = await prisma.player.create({ data: input })
        }
        // construct object and return instance
        return new CPlayer(data)
    }

    // move a player
    async moveTo(px: number, py: number) {
        this.data = await prisma.player.update({
            where: { id: this.data!.id },
            data: { px, py },
        })
        console.log('new data', this.data)
    }

}

// use it like
const player = CPlayer.findOrCreate({name: 'bob'})

Came to find the same kind of tricks!

but this means none of the prisma methods are exposed on the wrapper class

What about using Proxy?

class BaseModel {
    static makeModel(modelData) {
        return new Proxy(modelData, new this);
    }
    
    get(target, property) {
        if (property in this) {
            return this[property];
        }
        
        return target[property];
    }

    has(target, property) {
        return (property in this) || (property in target)
    }
}

export UserModel extends BaseModel {
    verifyPassword(providedPassword) {
        // Don't do this at home!
        return this.password === providedPassword;
    }
}

The BaseModel class provides a convenience method that initializes a Proxy wrapping the Prisma "model" object, with a new instance of itself as the proxy handler.

You'd use it this way:

const user = UserModel.makeModel(await prisma.user.findUnique({...}))
if (!user.verifyPassword(providedPassword)) {
    throw new Error("Invalid password");
}

Curious to get your feedback on this; will try to start using this in a project of mine!

First of all, i'm a really newbie in JS (i've just discovered proxies^^), TS and prisma ^^

But found this post (and others) trying to mix differents methods to make my own trick (seems working as i want, i have to try furthermore), using an intern data object (prisma result) and two layers of proxies : [prismaModel] > [data] > [class handler]

import { PrismaClient } from "@prisma/client";

const prismaClient = new PrismaClient();

const proxyCreate = (handler: any) => ({
  get: (target: any, key: string) => {
    if (key in target) {
      return target[key as keyof typeof target];
    } else if (key in handler) {
      return handler[key as keyof typeof handler];
    } else {
      return undefined;
    }
  },

  has: (target: any, key: string) => {
    return key in target || key in handler;
  },

  set: (target: any, key: any, value: any) => {
    if ("data" in handler) {
      handler["data"][key] = value;
    } else {
      target[key as keyof typeof target] = value;
    }
    return true;
  },
});

class Model {
  data: any;
  proxy: any;

  // - Have to add those because of TS :
  findFirst: Function = () => {};
  findMany: Function = () => {};
  findUnique: Function = () => {};
  create: Function = () => {};
  // ... to be continued

  constructor(prismaClient: any, obj: any = {}) {
    this.data = obj;
    this.proxy = new Proxy(prismaClient, proxyCreate(this.data));
  }

  async save() {
    return await this.create({ data: this.data });
  }
}

export default class User extends Model {
  // - Have to add those beacuse of TS for using them direct on User object:
  id: unknown = null;
  username: unknown = "";
  email: unknown = "";
  password: unknown = "";

  constructor(obj: any = {}) {
    super(prismaClient.userModel, obj);
    return new Proxy(this.proxy, proxyCreate(this));
  }

  static async myFindFirst() {
    let user = new User();
    user = new User(await user.findFirst());
    return user;
  }
}

Then, in use :

import { User } from "./models";

const main = async () => {
  // - Getting a User
  const user: User = await User.myFindFirst();
  console.log("Direct access to data values : ", user.id, user.username);

  // - Using directly User object to access prisma Model functions
  const doc = await user.findFirst({ where: { email: "[email protected]" } });
  console.log(doc);

  //- Create user :
  const newUser = new User();
  newUser.username = "bob";
  newUser.email = "[email protected]";
  newUser.password = "123";
  await newUser.save();
};

main();

What do you think ?
As i'm totally new in TS, I have to add fake properties and methods (and giving priority to target in my proxy function), to avoid adding @ts-ignore each time i access something on user that is on underlayer proxies : maybe there's a better way ?

Any update?

Update

Found this https://www.prisma.io/docs/concepts/components/prisma-client/client-extensions
Thanks.

UPDATE

Adding a validatePassword method to a user can be easily accomplished by adding custom methods to a query's result.

import { PrismaClient } from '@prisma/client';
import bcrypt from 'bcryptjs';

const prisma = new PrismaClient().$extends({
  result: {
    user: {
      validatePassword: {
        needs: { password: true },
        compute: user => async (rawPassword: string) => {
          return await bcrypt.compare(rawPassword, user.password);
        },
      },
    },
  },
});

async function main() {
  const user = await prisma.user.findFirst({ where: { email: '[email protected]' } });

  if (user) {
    const isValidPassword = user.validatePassword('mypassword');
  }
}

And you can also automatically hash the password when creating or updating a user using custom Prisma client queries

import { PrismaClient, Prisma } from '@prisma/client';

const prisma = new PrismaClient().$extends({
  query: {
    user: {
      async $allOperations({ args, model, operation, query }) {
        if ((operation === 'create' || operation === 'update') && 'data' in args) {
          const data = args.data as Prisma.UserCreateInput | Prisma.UserUpdateInput;

          if (data.password) {
            data.password = hashPassword(data.password);
          }
        }

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

Credit to @angelhdzmultimedia

This solution isn't perfect, but it gets you close to what you're aiming to do by utilizing Prisma's custom models.

In the script below, a new method called validatePassword is added to the user model through Prisma's $extend function. This method is designed to take an email and a password as its parameters:

import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient().$extend({
  model: {
    user: {
      async validatePassword(email: string, password: string) {
        // Your validation logic here
      },
    },
  },
})

async function main() {
  await prisma.user.validatePassword('[email protected]', 's3cret')
}

It's important to note that validatePassword is a static method, meaning it is called on the user model itself and not on an instance of a user. Prisma operates with plain objects rather than class instances, so adding methods to individual user instances (like you might with other ORMs) isn't an option here. However, by using a static method with Prisma's custom models, you can still organize and centralize logic such as password validation in a coherent manner, providing a structured way to validate user credentials by simply passing the email and password to the validatePassword method.

You can add the validatePassword method as a result extension. Prisma extensions can be made for:

I add my validatePassword as a result extension, and then use a query extension to override the create query to hash the password before saving it in the db, and excluding the password from both extensions, so any find or create query, will not have the user's password.

So I would define a login.prisma.ts extension and a register.prisma.ts extension with the certainity that using these clients won't include the user's password.

const user = await loginPrisma.user.findOne({email})

if (!user) {
  throw new NotFoundException('Email not found')
}

const isPasswordValid: boolean = await user.validatePassword( loginDto.password )

if (!isPasswordValid) {
throw new UnauthorizedException('Email or password not valid')
}

return user  // no password!

Hi @florianmartens,

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 have already been marked as answered but remain open.

If this discussion still requires further input or clarification, feel free to reopen it or start a new one with updated details. Your contributions are invaluable to the community, and we’re here to help!

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 ongoing support of the Prisma community!