CLI command reference

version (-v)

The version command outputs information about your current @prisma/cli version, platform, and engine binaries.

$prisma version

Environment variables loaded from ./prisma/.env @prisma/cli : 2.13.0-beta.3 Current platform
: windows Query Engine : query-engine 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at
C:\Users\veroh\AppData\Roaming\npm\node_modules\@prisma\cli\query-engine-windows.exe) Migration
Engine : migration-engine-cli 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at
C:\Users\veroh\AppData\Roaming\npm\node_modules\@prisma\cli\migration-engine-windows.exe)
Introspection Engine : introspection-core 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at
C:\Users\veroh\AppData\Roaming\npm\node_modules\@prisma\cli\introspection-engine-windows.exe)

$prisma -v

Environment variables loaded from ./prisma/.env @prisma/cli : 2.0.0-beta.3 Current platform
: windows Query Engine : query-engine 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at
C:\Users\veroh\AppData\Roaming\npm\node_modules\@prisma\cli\query-engine-windows.exe) Migration
Engine : migration-engine-cli 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at
C:\Users\veroh\AppData\Roaming\npm\node_modules\@prisma\cli\migration-engine-windows.exe)
Introspection Engine : introspection-core 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at
C:\Users\veroh\AppData\Roaming\npm\node_modules\@prisma\cli\introspection-engine-windows.exe)

$prisma version --json

Environment variables loaded from ./prisma/.env
{
  "@prisma/cli": "2.0.0-beta.3",
  "current-platform": "windows",
  "query-engine": "query-engine 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at C:\\Users\\veroh\\AppData\\Roaming\\npm\\node_modules\\@prisma\\cli\\query-engine-windows.exe)",
  "migration-engine": "migration-engine-cli 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at C:\\Users\\veroh\\AppData\\Roaming\\npm\\node_modules\\@prisma\\cli\\migration-engine-windows.exe)",  "introspection-engine": "introspection-core 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6 (at C:\\Users\\veroh\\AppData\\Roaming\\npm\\node_modules\\@prisma\\cli\\introspection-engine-windows.exe)"
}

init

Bootstraps a fresh Prisma project within the current directory.

The init command does not interpret any existing files. Instead, it creates a prisma directory containing a bare-bones schema.prisma file within your current directory.

$prisma init

✔ Your Prisma schema was created at prisma/schema.prisma.
  You can now open it in your favorite editor.
Next steps:
1. Set the provider of the datasource block in schema.prisma to match your database: postgresql, mysql or sqlite.
2. Set the DATABASE_URL in the .env file to point to your existing database. If your database has no tables yet, read https://pris.ly/d/getting-started.
3. Run prisma introspect to turn your database schema into a Prisma data model.
4. Run prisma generate to install Prisma Client. You can then start querying your database.
More information in our documentation:
https://pris.ly/d/getting-started

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
generator client {
  provider = "prisma-client-js"
}

# Environment variables declared in this file are automatically made available to Prisma.
# See the documentation for more detail: https://pris.ly/d/prisma-schema#using-environment-variables
# Prisma supports the native connection string format for PostgreSQL, MySQL and SQLite.
# See the documentation for all the connection string options: https://pris.ly/d/connection-strings
DATABASE_URL="postgresql://johndoe:johndoe@localhost:5432/mydb?schema=public"

generate

The generate command generates assets like Prisma Client based on the generator and data model blocks defined in your prisma/schema.prisma file.

The generate command is most often used to generate Prisma Client with the prisma-client-js generator. This does three things:

1. Searches the current directory and parent directories to find the applicable npm project. It will create a package.json file in the current directory if it cannot find one.
2. Installs the @prisma/client into the npm project if it is not already present.
3. Inspects the current directory to find a Prisma schema file to process. It will then generate a customized Prisma Client for your project.

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

$prisma generate

✔ Generated Prisma Client to ./node_modules/@prisma/client in 61ms
You can now start using Prisma Client in your code:
import { PrismaClient } from '@prisma/client'
// or const { PrismaClient } = require('@prisma/client')
const prisma = new PrismaClient()
Explore the full API: http://pris.ly/d/client

$prisma generate --schema=./alternative/schema.prisma

$prisma generate --watch

Watching... /home/prismauser/prisma/prisma-play/prisma/schema.prisma
✔ Generated Prisma Client to ./node_modules/@prisma/client in 45ms

introspect

The introspect command connects to your database and adds Prisma models to your Prisma schema that reflect the current database schema.

To run the introspect command, a schema.prisma file with a valid datasource must be available.

Warning: The command will overwrite the current schema.prisma file with the new schema. Any manual changes or customization will be lost. Be sure to back up your current schema.prisma file before running introspect if it contains important modifications.

datasource db {
  provider = "sqlite"
  url      = "file:my-database.db"
}

$prisma introspect

Introspecting based on datasource defined in schema.prisma …
✔ Wrote Prisma data model into schema.prisma in 38ms
Run prisma generate to generate Prisma Client.

$prisma introspect --schema=./alternative/schema.prisma

Introspecting based on datasource defined in alternative/schema.prisma …
✔ Wrote Prisma data model into alternative/schema.prisma in 60ms
Run prisma generate to generate Prisma Client.

$prisma introspect --print

generator client {
  provider = "prisma-client-js"
}
datasource db {
  provider = "sqlite"
  url      = "file:./hello-prisma.db"
}
model User {
  email   String    @unique
  name    String?
  user_id Int       @default(autoincrement()) @id
  post    Post[]
  profile Profile[]
}
model Post {
  content   String?
  post_id   Int     @default(autoincrement()) @id
  title     String
  author_id User?
}
model Profile {
  bio        String?
  profile_id Int     @default(autoincrement()) @id
  user_id    User
}

db push

Note: This feature is currently in Preview. Features in Preview may still have some issues, and are not recommended for use in production environments. To access commands in Preview, you must opt-in via the --preview-feature flag.

The db push command pushes the state of your Prisma schema file to the database without using migrations. This command is a good choice when you do not need to version schema changes, such as during prototyping and local development. db push works as follows:

• db push introspects the database, and infers and executes the changes required to make your database schema reflect the state of your Prisma schema.

• By default, after changes have been applied to the database schema, generators are triggered (for example, Prisma Client). You do not need to manually invoke prisma generate.

• If db push anticipates that the changes could result in data loss, it will:

  • Throw an error
  • Require the --force option if you still want to make the changes

• db push does not interact with or rely on migrations. The migrations table will no be updated, and no migration files will be generated.

db push works well if:

• You want to quickly prototype and iterate on schema design locally without the need to deploy these changes to other environments such as other developers, or staging and production environments.
• You are prioritizing reaching a desired end-state and not the changes or steps executed to reach that end-state. There is no way to Preview the changes that will be made to the database.
• You do not need control over how schema changes impact data. There is no way to orchestrate schema and data migrations - if db push anticipates that changes will result in data loss, it will require specific confirmation via a --force option. You can either accept data loss by specifying the option or stop the process, but there is no way to customize the changes.

db push is not recommended if:

• You want to replicate your schema changes in other environments where there could be important data you cannot afford to lose. You can use db push for prototyping, but you should use migrations to commit the schema changes and apply these in your other environments.
• You want fine-grained control over how the schema changes are executed - for example, renaming a column instead of dropping it and creating a new one.
• You want to keep track of changes made to the database schema over time. db push does not create any artifacts that allow you to keep track of these changes.
• You want the schema changes to be reversible. You can use db push again to revert to the original state, but this might result in data loss and there will be no mechanism for you to orchestrate these changes.

datasource db {
  provider = "sqlite"
  url      = "file:my-database.db"
}

$npx prisma db push --preview-feature

$npx prisma db push --preview-feature --force

$npx prisma db push --preview-feature --schema=/tmp/schema.prisma

db seed (Preview)

$npx prisma db push --preview-feature --force

migrate dev

For use in development environments only, requires shadow database

The migrate dev command updates your database using migrations during development. In the simplest case, it does the following:

1. Applies pending migrations
2. Generate a new migration based on the changes in the Prisma schema
3. Applies the new migration to the database and updates the _prisma_migrations table
4. Trigger the generation of artifacts (for example, the Prisma Client)

The migrate dev command will prompt you to reset the database in the following scenarios:

• Migration history conflicts caused by modified or missing migration
• The database schema has drifted away from the end-state of the migration history

When the database is reset, if Prisma Migrate detects a seed script, the database will be automatically seeded.

Note: For a simple and integrated way to re-create data in your development database as often as needed, check out our seeding guide.

$prisma migrate dev --preview-feature

$prisma migrate dev --create-only --preview-feature

migrate reset

For use in development environments only.

The migrate reset command:

1. Drops the database
2. Creates a new database with the same name
3. Applies all migrations

Note: For a simple way to re-create data in your development database as often as needed, check out our seeding guide.

$prisma migrate reset --preview-feature

migrate deploy

The migrate deploy command applies all pending migrations. Primarily used in non-development environments. This command:

• Does not look for drift in the database or changes in the Prisma schema
• Does not reset the database or generate artifacts
• Does not rely on a shadow database

$prisma migrate deploy --preview-feature

migrate resolve

The migrate resolve command allows you to solve migration history issues in production by marking a migration as already applied (supports baselining) or rolled back.

$prisma migrate resolve --applied 20201231000000_add_users_table --preview-feature

$prisma migrate resolve --rolled-back 20201231000000_add_users_table --preview-feature

migrate status

The prisma migrate status command looks up the migrations in /prisma/migrations/* folder and the entries in the _prisma_migrations table and compiles informatoin about the state of the migrations in your databae. For example:

Status
3 migrations found in prisma/migrations
Your local migration history and the migrations table from your database are different:
The last common migration is: 20201127134938_new_migration
The migration have not yet been applied:
20201208100950_test_migration
The migrations from the database are not found locally in prisma/migrations:
20201208100950_new_migration

$prisma migrate status --preview-feature

studio

The studio command allows you to interact with and manage your data interactively. It does this by starting a local web server with a web app configured with your project's data schema and records.

datasource db {
  provider = "sqlite"
  url      = "file:my-database.db"
}

$prisma studio

$prisma studio --port 7777