@visulima/prisma-dmmf-transformer NPM

Features

Installation

npm install @visulima/prisma-dmmf-transformer

yarn add @visulima/prisma-dmmf-transformer

pnpm add @visulima/prisma-dmmf-transformer

Usage

import { transformDMMF, getJSONSchemaProperty } from "@visulima/prisma-dmmf-transformer";

const generator = async (prismaClient) => {
    const dmmf = await prismaClient._getDmmf();
    const schema = transformDMMF(dmmf);

    console.log(schema);
};

The generator currently supports a few options as a second argument:

Key	Default Value	Description
keepRelationScalarFields	"false"	By default, the JSON Schema that’s generated will output only objects for related model records. If set to "true", this will cause the generator to also output foreign key fields for related records
schemaId	undefined	Add an id to the generated schema. All references will include the schema id
includeRequiredFields	"false"	If this flag is `"true"` all required scalar prisma fields that do not have a default value, will be added to the `required` properties field for that schema definition.
persistOriginalType	"false"	If this flag is `"true"` the original type will be outputed under the property key "originalType"

Examples

PostgreSQL

This generator converts a prisma schema like this:

datasource db {
    provider = "postgresql"
    url      = env("DATABASE_URL")
}

model User {
    id                  Int      @id @default(autoincrement())
    // Double Slash Comment: It will NOT show up in JSON schema
    createdAt           DateTime @default(now())
    /// Triple Slash Comment: It will show up in JSON schema [EMAIL]
    email               String   @unique
    weight              Float?
    is18                Boolean?
    name                String?
    number              BigInt   @default(34534535435353)
    favouriteDecimal    Decimal
    bytes               Bytes /// Triple Slash Inline Comment: It will show up in JSON schema [BYTES]
    successorId         Int?     @unique
    successor           User?    @relation("BlogOwnerHistory", fields: [successorId], references: [id])
    predecessor         User?    @relation("BlogOwnerHistory")
    role                Role     @default(USER)
    posts               Post[]
    keywords            String[]
    biography           Json
}

model Post {
    id     Int   @id @default(autoincrement())
    user   User? @relation(fields: [userId], references: [id])
    userId Int?
}

enum Role {
    USER
    ADMIN
}

Into:

{
    $schema: "http://json-schema.org/draft-07/schema#",
    definitions: {
        Post: {
            properties: {
                id: { type: "integer" },
                user: {
                    anyOf: [{ $ref: "#/definitions/User" }, { type: "null" }],
                },
            },
            type: "object",
        },
        User: {
            properties: {
                biography: {
                    type: ["number", "string", "boolean", "object", "array", "null"],
                },
                createdAt: { format: "date-time", type: "string" },
                email: {
                    description: "Triple Slash Comment: Will show up in JSON schema [EMAIL]",
                    type: "string",
                },
                id: { type: "integer" },
                is18: { type: ["boolean", "null"] },
                keywords: { items: { type: "string" }, type: "array" },
                name: { type: ["string", "null"] },
                number: { type: "integer", default: "34534535435353" },
                bytes: {
                    description: "Triple Slash Inline Comment: Will show up in JSON schema [BYTES]",
                    type: "string",
                },
                favouriteDecimal: { type: "number" },
                posts: {
                    items: { $ref: "#/definitions/Post" },
                    type: "array",
                },
                predecessor: {
                    anyOf: [{ $ref: "#/definitions/User" }, { type: "null" }],
                },
                role: { enum: ["USER", "ADMIN"], type: "string", default: "USER" },
                successor: {
                    anyOf: [{ $ref: "#/definitions/User" }, { type: "null" }],
                },
                weight: { type: ["integer", "null"] },
            },
            type: "object",
        },
    },
    properties: {
        post: { $ref: "#/definitions/Post" },
        user: { $ref: "#/definitions/User" },
    },
    type: "object",
}

MongoDB

The generator also takes care of composite types in MongoDB:

datasource db {
    provider = "mongodb"
    url      = env("DATABASE_URL")
}

model User {
    id      String @id @default(auto()) @map("_id") @db.ObjectId
    photos  Photo[]
}

type Photo {
    height Int      @default(200)
    width  Int      @default(100)
    url    String
}

Output:

{
    $schema: "http://json-schema.org/draft-07/schema#",
    definitions: {
        User: {
            properties: {
                id: { type: "string" },
                photos: {
                    items: { $ref: "#/definitions/Photo" },
                    type: "array",
                },
            },
            type: "object",
        },
        Photo: {
            properties: {
                height: {
                    type: "integer",
                    default: 200,
                },
                width: {
                    type: "integer",
                    default: 100,
                },
                url: {
                    type: "string",
                },
            },
            type: "object",
        },
    },
    properties: {
        user: { $ref: "#/definitions/User" },
    },
    type: "object",
}

Supported Node.js Versions

Libraries in this ecosystem make the best effort to track Node.js’ release schedule. Here’s a post on why we think this is important.

Contributing

If you would like to help take a look at the list of issues and check our Contributing guild.

Note: please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.