Prisma Client API — Agent Skill by Prisma

From the author

Prisma Client API reference covering model queries, filters, operators, and client methods. Use when writing database queries, using CRUD operations, filtering data, or configuring Prisma Client. Triggers on "prisma query", "findMany", "create", "update", "delete", "$transaction".

— the description by prisma

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Prisma Client API reference provides developers with essential guidance for interacting with databases using Prisma. It covers the full lifecycle of the Prisma Client, from instantiation and configuration to executing complex CRUD operations, managing transactions, and utilizing advanced features like query extensions and raw SQL execution. This skill serves as a central hub for understanding how to structure queries, apply filters, manage relations, and optimize database interactions within a TypeScript environment.

What it does

Provides syntax and usage patterns for CRUD operations like findMany, create, update, and delete.
Explains how to configure the PrismaClient instance, including adapters, logging, and transaction settings.
Details the use of query options such as select, include, omit, and pagination parameters.
Outlines filter operators and relation query patterns for complex data retrieval.
Documents client lifecycle methods like $connect, $disconnect, $transaction, and $extends.
Offers guidance on using raw SQL queries and type-safe query fragments.

When to use it

When writing or debugging database queries in a project using Prisma ORM.
When setting up or configuring a new PrismaClient instance.
When implementing complex data filtering, sorting, or relational queries.
When needing to perform bulk operations or manage database transactions.
When extending Prisma Client functionality with custom methods or computed fields.

Advantages

Centralized access to official Prisma Client API patterns and best practices.
Supports type-safe development through clear examples of TypeScript integration.
Simplifies complex tasks like transaction management and relation handling.
Provides clear guidance on performance-related configurations like query plan caching.

Usage examples

“How do I find multiple users with a specific role and sort them by creation date?”: The agent provides a findMany query example using the 'where' filter for the role and 'orderBy' for the createdAt field.
“Show me how to create a user and their associated posts in one transaction.”: The agent demonstrates a nested create operation within the data object of a prisma.user.create call.
“How can I log all SQL queries executed by Prisma?”: The agent explains how to configure the 'log' option in the PrismaClient constructor with the 'query' level.
“How do I add a computed field to my user model using $extends?”: The agent provides a code snippet showing the use of $extends with the 'result' property to define a computed fullName field.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/prisma/prisma-client-api/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip prisma-client-api.zip -d .agents/skills

Documentation by prisma

Prisma Client API Reference

Complete API reference for Prisma Client. This skill provides guidance on model queries, filtering, relations, and client methods for current Prisma projects.

When to Apply

Reference this skill when:

Writing database queries with Prisma Client
Performing CRUD operations (create, read, update, delete)
Filtering and sorting data
Working with relations
Using transactions
Configuring client options

Rule Categories by Priority

Priority	Category	Impact	Prefix
1	Client Construction	HIGH	`constructor`
2	Model Queries	CRITICAL	`model-queries`
3	Query Shape	HIGH	`query-options`
4	Filtering	HIGH	`filters`
5	Relations	HIGH	`relations`
6	Transactions	CRITICAL	`transactions`
7	Raw SQL	CRITICAL	`raw-queries`
8	Client Methods	MEDIUM	`client-methods`

Quick Reference

constructor - PrismaClient setup, adapter wiring, logging, and SQL commenter plugins
model-queries - CRUD operations and bulk operations
query-options - select, include, omit, sort, pagination
filters - scalar and logical filter operators
relations - relation reads and nested writes
transactions - array and interactive transaction patterns
raw-queries - $queryRaw and $executeRaw safety
client-methods - lifecycle methods, extensions, and satisfies patterns for prisma-client

Client Instantiation

import { PrismaClient } from '../generated/client'
import { PrismaPg } from '@prisma/adapter-pg'

const adapter = new PrismaPg({
  connectionString: process.env.DATABASE_URL
})

const prisma = new PrismaClient({ adapter })

Model Query Methods

Method	Description
`findUnique()`	Find one record by unique field
`findUniqueOrThrow()`	Find one or throw error
`findFirst()`	Find first matching record
`findFirstOrThrow()`	Find first or throw error
`findMany()`	Find multiple records
`create()`	Create a new record
`createMany()`	Create multiple records
`createManyAndReturn()`	Create multiple and return them
`update()`	Update one record
`updateMany()`	Update multiple records
`updateManyAndReturn()`	Update multiple and return them
`upsert()`	Update or create record
`delete()`	Delete one record
`deleteMany()`	Delete multiple records
`count()`	Count matching records
`aggregate()`	Aggregate values (sum, avg, etc.)
`groupBy()`	Group and aggregate

Query Options

Option	Description
`where`	Filter conditions
`select`	Fields to include
`include`	Relations to load
`omit`	Fields to exclude
`orderBy`	Sort order
`take`	Limit results
`skip`	Skip results (pagination)
`cursor`	Cursor-based pagination
`distinct`	Unique values only

Client Methods

Method	Description
`$connect()`	Explicitly connect to database
`$disconnect()`	Disconnect from database
`$transaction()`	Execute transaction
`$queryRaw()`	Execute raw SQL query
`$executeRaw()`	Execute raw SQL command
`$on()`	Subscribe to events
`$extends()`	Add extensions

Quick Examples

Find records

// Find by unique field
const user = await prisma.user.findUnique({
  where: { email: '[email protected]' }
})

// Find with filter
const users = await prisma.user.findMany({
  where: { role: 'ADMIN' },
  orderBy: { createdAt: 'desc' },
  take: 10
})

Create records

const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice',
    posts: {
      create: { title: 'Hello World' }
    }
  },
  include: { posts: true }
})

Update records

const user = await prisma.user.update({
  where: { id: 1 },
  data: { name: 'Alice Smith' }
})

Delete records

await prisma.user.delete({
  where: { id: 1 }
})

Transactions

const [user, post] = await prisma.$transaction([
  prisma.user.create({ data: { email: '[email protected]' } }),
  prisma.post.create({ data: { title: 'Hello', authorId: 1 } })
])

Rule Files

Detailed API documentation:

references/constructor.md        - PrismaClient constructor options
references/model-queries.md      - CRUD operations
references/query-options.md      - select, include, omit, where, orderBy
references/filters.md            - Filter conditions and operators
references/relations.md          - Relation queries and nested operations
references/transactions.md       - Transaction API
references/raw-queries.md        - $queryRaw, $executeRaw
references/client-methods.md     - $connect, $disconnect, $on, $extends

Filter Operators

Operator	Description
`equals`	Exact match
`not`	Not equal
`in`	In array
`notIn`	Not in array
`lt`, `lte`	Less than
`gt`, `gte`	Greater than
`contains`	String contains
`startsWith`	String starts with
`endsWith`	String ends with
`mode`	Case sensitivity

Relation Filters

Operator	Description
`some`	At least one related record matches
`every`	All related records match
`none`	No related records match
`is`	Related record matches (1-to-1)
`isNot`	Related record doesn't match

Resources

How to Use

Pick the category from the table above, then open the matching reference file for implementation details and examples.

Files

ATTRIBUTION.mdAdded by AutoGineer867 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md6.2 KiB
references/client-methods.md3.9 KiB
references/constructor.md4.8 KiB
references/filters.md3.4 KiB
references/model-queries.md4.7 KiB
references/query-options.md4.0 KiB
references/raw-queries.md4.3 KiB
references/relations.md4.3 KiB
references/transactions.md3.7 KiB

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Implement Spec
Matt Pocock· Community
A workflow for implementing technical specifications and tickets using concurrent subagents.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository317.5k
MCP Builder
AnthropicOfficial
A comprehensive guide for building high-quality Model Context Protocol (MCP) servers to integrate external services with LLMs.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
Apache-2.0Low riskHas scriptsGitHub stars of the source repository188.6k
Schema
Corey Haines· Community
Expert guidance for implementing and optimizing JSON-LD schema markup to improve search engine content understanding.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository59k
Postgresql Table Design
Seth Hobson· Community
A comprehensive guide for designing, reviewing, and optimizing PostgreSQL database schemas.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository42.3k
SQL Optimization Patterns
Seth Hobson· Community
A comprehensive guide to optimizing SQL database performance through indexing, query plan analysis, and efficient coding patterns.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository42.3k
API Scaffolding Fastapi Pro
Seth Hobson· Community
An expert FastAPI developer focused on high-performance, async-first API architecture and production-ready microservices.
Software developmentClaude Code
MITGitHub stars of the source repository42.3k

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download prisma-client-api.zip