Examples

Copy---
title: "Fix Prisma N+1 query problem with includes and joins"
slug: fix-prisma-n-plus-one-queries
tags: [prisma, database, performance, n-plus-one]
problem: "Prisma makes hundreds of individual queries when loading related data in a loop"
solution_type: fix
created: "2026-02-08"
environment:
  language: typescript
  framework: prisma
---

Copy## Problem

Loading a list of records and then accessing their relations triggers one
additional query per record:

```typescript
const posts = await prisma.post.findMany();
for (const post of posts) {
  const author = await prisma.user.findUnique({
    where: { id: post.authorId },
  });
}

Copy

Copy## Solution

**Option 1: Use `include` to eager-load relations (recommended)**

```typescript
const posts = await prisma.post.findMany({
  include: { author: true },
});

Copyconst posts = await prisma.post.findMany({
  select: {
    id: true,
    title: true,
    author: { select: { name: true, email: true } },
  },
});

Copyconst posts = await prisma.post.findMany({
  relationLoadStrategy: "join",
  include: { author: true },
});

Copy
<Callout type="info">
**Good because:** Labeled options, recommended default, version noted in the label, complete code with language labels.
</Callout>

### Why It Works section

The share explains that Prisma does not load relations by default, that the N+1 arises from manual looping, and that `include` changes the behavior to a single query with joined relation loading.

<Callout type="info">
**Good because:** Explains root cause, not just "add include." Written as prose.
</Callout>

### Context section

```markdown
## Context

- Prisma 4.x+ for `include`, Prisma 5.9+ for `relationLoadStrategy: "join"`
- Use Prisma's query logging to detect N+1: `new PrismaClient({ log: ["query"] })`
- For GraphQL resolvers, consider DataLoader patterns
- `select` is more efficient than `include` when you don't need all columns

Copy---
title: "Use TypeScript satisfies operator for type-safe config objects"
slug: fix-typescript-satisfies-type-safety
tags: [typescript, satisfies, type-safety, config]
problem: "Type annotation on config object widens types and loses literal inference"
solution_type: pattern
created: "2026-02-08"
environment:
  language: typescript
  version: "4.9+"
---

Copy---
title: "fix stuff"
slug: Fix_Stuff
tags: [Fix, stuff, things, misc, general, code, programming, software, development, engineering, TypeScript]
problem: "broken"
solution_type: pattern
created: Feb 8
---

Copy## Problem

This is a common issue that many developers face when working with modern web frameworks. There are several approaches to solving it, and in this share I will walk you through the best one I found after trying many different things.

Copy## Solution

Just add `include` to your query. This should fix it.

```
prisma.post.findMany({ include: { author: true } })
```

Copy## Why It Works

It works because we added `include: { author: true }` to the query. This tells Prisma to include the author in the results.

Copy## Context

This solution uses Prisma's include feature to eager-load relations. When you use include, Prisma will automatically join the related table in the SQL query. This is much more efficient than loading each relation individually.