Want to build a Prisma extension for @default(<fn>), could you hint where I should look?

[grimen]

I have a very clear goal in mind of trying to make an extension to Prisma to support custom @default(<customFunction>()) functions defined in environment, e.g. P/SQL.

In my case I have a custom ULID function written in P/SQL that generated PostgreSQL UUID-compatible sequential UUIDs, which I would want to define in a Prisma schema as @default(ulid()).

I searched the code base with GitHub Search for hints on how the existing functionality is implemented, but I didn't find any matching source.

Thus, my question is: Could you share some pointers on where the native implementation of the fn in @default(<fn>()) is located?

Thanks in advance

[janpio]

What exactly are you trying to achieve? The existing Prisma level functions like uuid() or cuid() are pretty deeply embedded - and actually run on the Query Engine side (and not the database). If you have something that you could store as a Postgres function, you can already use those in as the default by defining them as a string default. Is that what you are looking for?

[janpio]

Ok, I found one example in the schema documentation, which shows I got it slightly wrong above:
https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#dbgenerated

model User {
  id   String  @id @db.Uuid @default(dbgenerated("gen_random_uuid()"))
  test String?
}

So you will need to use dbgenerated around the function you want to call.

[akshayvadher]

What if my DB does not have a function to generate ULID (or KSUID or NanoId), in that case, I would want to rely on a javascript function (custom made in somecasese) to generate those ids.

Is there a way in prisma to call a custom javascript function instead of predefined?

Or please provide pointer to do it, since uuid, cuid, or now are prisma defined functions, there is potentially a way to inject custom functions as well.

[GermanJablo]

What if my DB does not have a function to generate ULID (or KSUID or NanoId), in that case, I would want to rely on a javascript function (custom made in somecasese) to generate those ids.

Is there a way in prisma to call a custom javascript function instead of predefined?

Or please provide pointer to do it, since uuid, cuid, or now are prisma defined functions, there is potentially a way to inject custom functions as well.

I have exactly the same question. Any ideas?

[ruheni]

Hey 👋

You could achieve this with a Prisma Client extension by intercepting queries and creating the id

Given the following schema:

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite"
  url      = "file:./dev.db"
}

model User {
  id    String  @id @default("")
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        String  @id @default("")
  title     String
  content   String?
  published Boolean @default(false)
  author    User?   @relation(fields: [authorId], references: [id])
  authorId  String?
}

You can use Prisma Client extensions to intercept queries and define your own id before executing a query. In this case, I'm using nanoid and applying it to all my models.

import { PrismaClient } from '@prisma/client'
import { nanoid } from 'nanoid'

const prisma = new PrismaClient()
  .$extends({
    query: {
      $allModels: {
        async create({ args, query }) {
          args.data = {
            ...args.data,
            id: nanoid(),
          }

          return query(args)
        }
      }
    }

  })

const post = await prisma.post.create({
  data: {
    title: 'random title',
  }
})

// Result
{
  id: 'hMEny4U_XNQuMLDYTjl97',
  title: 'random title',
  content: null,
  published: false,
  authorId: null
}

[AndreyMarchuk]

don't forget createMany(), createManyAndReturn(), upsert()

[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 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!

[HokaigoTwin]

Hey everyone,

I was actually just reading through the Prisma docs recently, noticed we couldn't pass custom JS functions into @default(), and thought it would be a cool feature to build.

Looking at the manual $extends examples discussed above, it definitely gets messy once you try to handle createMany, upsert, or deeply nested relational writes without hardcoding model names everywhere.

So, I put together a zero-dependency package that parses the DMMF and handles this automatically via schema comments. Just wanted to drop it here for anyone looking for a cleaner setup!

Instead of writing massive middlewares, you just do this:

1. Schema:

model User {
  /// @defaultJs(generateCustomId)
  id String @id @default("")
  email String @unique
}

2. Extension:

import { PrismaClient } from '@prisma/client';
import { withJsDefaults } from 'prisma-js-defaults';
// Import the config auto-generated by the package
import { jsDefaultsConfig } from './prisma/generated/js-defaults';

const prisma = new PrismaClient().$extends(
    withJsDefaults(jsDefaultsConfig, {
        generateCustomId: () => `user_${nanoid()}`
    })
);

It intercepts all operations (including nested creations) and applies your JS functions out of the box.

You can check it out here:
https://github.com/HokaigoTwin/prisma-js-defaults