Usage & Integration

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

declare global {
  var prisma: PrismaClient | undefined;
}

let prisma: PrismaClient;

if (process.env.NODE_ENV === 'production') {
  prisma = new PrismaClient();
} else {
  if (!global.prisma) {
    global.prisma = new PrismaClient();
  }
  prisma = global.prisma;
}

export { prisma };

import { prisma } from '@/lib/prisma/prisma';
import { NextResponse } from 'next/server';

export async function POST(req: Request) {
  const { text, type, slug, timestamp } = await req.json();

  const event = await prisma.event.create({
    data: { text, type, slug, timestamp: BigInt(timestamp) }
  });

  return NextResponse.json({ event });
}

export async function GET() {
  // Find single record
  const event = await prisma.event.findFirst({
    orderBy: { timestamp: 'desc' }
  });

  // Find many records
  const events = await prisma.event.findMany({
    where: { type: 'post' },
    orderBy: { timestamp: 'desc' },
    take: 10
  });

  return NextResponse.json({ event, events });
}

export async function PATCH(req: Request) {
  const { id, text } = await req.json();

  const event = await prisma.event.update({
    where: { id },
    data: { text }
  });

  return NextResponse.json({ event });
}

export async function DELETE(req: Request) {
  const { searchParams } = new URL(req.url);
  const type = searchParams.get('type');

  await prisma.event.deleteMany({ where: { type } });

  return NextResponse.json({ message: 'Deleted' });
}

// Where clauses
const posts = await prisma.event.findMany({
  where: {
    type: 'post',
    timestamp: { gte: BigInt(Date.now() - 86400000) }
  }
});

// OR conditions
const events = await prisma.event.findMany({
  where: {
    OR: [{ type: 'post' }, { type: 'update' }]
  }
});

// Pagination
const page = 1;
const limit = 20;

const events = await prisma.event.findMany({
  skip: (page - 1) * limit,
  take: limit,
  orderBy: { timestamp: 'desc' }
});

// Assuming Post and Comment models
const posts = await prisma.post.findMany({
  include: {
    author: true,
    comments: {
      take: 5,
      orderBy: { createdAt: 'desc' }
    }
  }
});

// Create with relationships
const post = await prisma.post.create({
  data: {
    title: 'My Post',
    author: { connect: { id: userId } },
    comments: {
      create: [{ text: 'First comment', authorId: userId }]
    }
  },
  include: { comments: true }
});

import { prisma } from '@/lib/prisma/prisma';

export default async function DashboardPage() {
  const events = await prisma.event.findMany({
    orderBy: { timestamp: 'desc' },
    take: 10
  });

  return (
    <div>
      <h1>Recent Events</h1>
      {events.map(event => (
        <div key={event.id}>{event.text}</div>
      ))}
    </div>
  );
}

const result = await prisma.$transaction([
  prisma.event.deleteMany({ where: { type: 'old' } }),
  prisma.event.create({
    data: { type: 'new', text: 'New event', slug: 'new', timestamp: BigInt(Date.now()) }
  })
]);

export function serializeBigInt(obj: any): any {
  return JSON.parse(
    JSON.stringify(obj, (key, value) =>
      typeof value === 'bigint' ? value.toString() : value
    )
  );
}

import { serializeBigInt } from '@/lib/utils';

export async function GET() {
  const event = await prisma.event.findFirst();
  return NextResponse.json({ event: serializeBigInt(event) });
}

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

export async function POST(req: Request) {
  try {
    const data = await req.json();
    const event = await prisma.event.create({ data });
    return NextResponse.json({ event });
  } catch (error) {
    if (error instanceof Prisma.PrismaClientKnownRequestError) {
      if (error.code === 'P2002') {
        return NextResponse.json(
          { error: 'Record already exists' },
          { status: 409 }
        );
      }
    }
    
    return NextResponse.json(
      { error: 'Database operation failed' },
      { status: 500 }
    );
  }
}