Prisma Client Api

Prisma Client API is a community skill for querying databases using the Prisma Client, covering CRUD operations, relation queries, filtering, pagination, transactions, and raw SQL execution for type-safe database access.

What Is This?

Overview

Prisma Client API provides patterns for querying databases with the auto-generated Prisma Client. It covers CRUD operations with create, findMany, update, and delete methods for basic record management, relation queries using include and select for loading associated records efficiently, advanced filtering with where clauses, contains, startsWith, and compound conditions, cursor and offset pagination for large result sets, and transaction support with interactive transactions and batch operations for atomic multi-step workflows. The skill enables developers to write type-safe database queries that leverage TypeScript autocompletion and compile-time validation.

Who Should Use This

This skill serves TypeScript developers building backends with Prisma ORM, teams migrating from raw SQL or other ORMs to Prisma Client, and engineers optimizing database access patterns for performance in production applications.

Why Use It?

Problems It Solves

Writing raw SQL queries lacks type safety and autocompletion that catches errors during development. Loading related records efficiently requires understanding eager versus lazy loading patterns. Building dynamic filter queries from user input needs composable query construction. Performing multi-step database operations atomically requires transaction management.

Core Highlights

Type-safe queries provide autocompletion and compile-time validation for all database operations. Relation loading uses include and select to control which associated data is fetched. Filter builder composes where conditions dynamically from input parameters. Transaction manager groups multiple operations into atomic units.

How to Use It?

Basic Usage

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

const prisma = new PrismaClient();

// Create with relation
const user = await prisma.user.create({
  data: {
    email: 'jane@example.com',
    name: 'Jane Smith',
    posts: {
      create: {
        title: 'First Post',
        content: 'Hello world',
        published: true,
      },
    },
  },
  include: { posts: true },
});

// Find with filters and relations
const posts = await prisma.post
  .findMany({
    where: {
      published: true,
      title: {
        contains: 'prisma',
        mode: 'insensitive',
      },
    },
    include: {
      author: {
        select: {
          name: true,
          email: true,
        },
      },
    },
    orderBy: {
      createdAt: 'desc' },
    take: 20,
    skip: 0,
  });
console.log(`Found ${posts.length}`);

Real-World Examples

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

const prisma = new PrismaClient();

// Dynamic filter builder
function buildFilters(
  params: {
    search?: string;
    status?: string;
    authorId?: string;
  }
): Prisma.PostWhereInput {
  const where: Prisma.PostWhereInput = {};
  if (params.search) {
    where.OR = [
      { title: { contains:
        params.search,
        mode: 'insensitive' } },
      { content: { contains:
        params.search,
        mode: 'insensitive' } },
    ];
  }
  if (params.status) {
    where.published =
      params.status === 'published';
  }
  if (params.authorId) {
    where.authorId = params.authorId;
  }
  return where;
}

// Interactive transaction
async function transferCredits(
  fromId: string,
  toId: string,
  amount: number
) {
  return prisma.$transaction(
    async (tx) => {
      const sender = await tx.user
        .update({
          where: { id: fromId },
          data: { credits: {
            decrement: amount } },
        });
      if (sender.credits < 0) {
        throw new Error(
          'Insufficient credits');
      }
      await tx.user.update({
        where: { id: toId },
        data: { credits: {
          increment: amount } },
      });
      return { sender: fromId,
        recipient: toId, amount };
    });
}

Advanced Tips

Use Prisma fluent API for chaining relation access in queries where you only need a specific nested value. Configure query logging by passing log levels to PrismaClient constructor for debugging slow queries in development. Use createMany with skipDuplicates for efficient bulk inserts that ignore conflicts.

When to Use It?

Use Cases

Build a REST API with paginated, filterable list endpoints backed by Prisma queries. Implement a credit transfer system using interactive transactions for atomic balance updates. Create a search service with dynamic filters composed from user query parameters.

Related Topics

TypeScript ORM, database queries, type-safe APIs, transaction management, and query optimization.

Important Notes

Requirements

TypeScript project with Prisma Client generated from a valid schema. Database connection configured in the datasource block. Prisma Client regenerated after each schema change.

Usage Recommendations

Do: use select to limit returned fields when you do not need all columns, reducing data transfer. Use include only for relations that the calling code actually needs. Wrap multi-step operations in transactions to maintain data consistency.

Don't: use findFirst without a where clause as it returns an arbitrary record. Chain multiple sequential queries when a single include or nested create can achieve the same result. Skip error handling for unique constraint violations on create operations.

Limitations

Prisma Client does not support all SQL features natively, and complex queries may require prisma.$queryRaw. Generated client size can increase with large schemas affecting bundle size. Connection pooling defaults may need tuning for serverless environments with many short-lived function invocations.