Skip to main content
skill CX Codex

db-enforcer — Claude Code skill: features and installation

db-enforcer is a Claude Code skill that checks PostgreSQL integrity and alignment with Prisma. It activates for schema design, migration work, and RLS policy setup.

MIT 109 installs ★ 29 updated 2026-08-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill db-enforcer -a claude-code
Open on GitHub

What db-enforcer does

db-enforcer keeps TypeScript types aligned with PostgreSQL constraints and checks Prisma schema consistency. It sets an order for schema changes: generate SQL with prisma migrate dev --create-only, validate the schema with prisma validate, then add RLS policies to new tables.

The skill also covers naming with @map and @@map, relation index checks, and migration patterns that avoid long locks. UUIDv7 requires PostgreSQL 18; older versions can use gen_random_uuid() through pgcrypto. The description points to database-security for broader RLS auditing.

What it helps with

  • match TypeScript types with database CHECK constraints
  • generate a Prisma migration before applying schema changes
  • map Prisma field names to PostgreSQL column names
  • add RLS policies to new tables
  • plan schema changes around table locks

Example prompts for the agent

  • Check the Prisma schema and match its TypeScript types to PostgreSQL constraints.
  • Prepare a migration for a new table with an RLS policy, then verify the command sequence.
  • Review how to add a required field to a large table without a full lock.

How to install db-enforcer

1Skills CLI (Vercel)

npx skills add oakoss/agent-skills --skill db-enforcer -a claude-code

2Manually: put the files in place

~/.claude/skills/db-enforcer/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/db-enforcer/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about db-enforcer

How do I install db-enforcer in Claude Code?

Run npx skills add oakoss/agent-skills --skill db-enforcer -a claude-code. The skill file is located at ~/.claude/skills/db-enforcer/SKILL.md.

What does db-enforcer do?

It checks alignment between PostgreSQL and Prisma, including types, constraints, naming, migrations, and RLS policies. It also describes schema-change patterns that account for locks.

Which PostgreSQL versions support UUIDv7 and virtual columns?

Both uuidv7() and virtual columns require PostgreSQL 18. For earlier versions, the listed UUID alternative is gen_random_uuid() through pgcrypto; stored generated columns are available from PostgreSQL 12.

Source text

SKILL.md · MIT
---
name: db-enforcer
description: 'Enforces database integrity for PostgreSQL and Prisma systems. Use when designing schemas, writing migrations, or configuring Row-Level Security. Use for type-safe SQL, naming alignment, constraint validation, zero-trust RLS policies, UUIDv7 primary keys, and zero-downtime deployments.'
license: MIT
metadata:
  author: oakoss
  version: '1.1'
---

# DB Enforcer

## Overview

Enforces data integrity and architectural consistency between the TypeScript application layer and the PostgreSQL persistence layer. Prevents type drift by ensuring CHECK constraints mirror TypeScript types, migrations are generated before applying changes, and Row-Level Security protects every table.

**When to use:** Schema design, migration planning, RLS policy authoring, Prisma model mapping, constraint auditing, zero-downtime deployments.

**When NOT to use:** Application-level business logic, frontend state management, non-PostgreSQL databases. For full RLS auditing, performance tuning, and compliance validation, use the `database-security` skill instead.

## Quick Reference

| Pattern               | API/Tool                            | Key Points                                           |
| --------------------- | ----------------------------------- | ---------------------------------------------------- |
| Type-to-DB sync       | `prisma migrate dev --create-only`  | Generate SQL before applying changes                 |
| Naming alignment      | `@map` / `@@map`                    | snake_case in SQL, camelCase in TS                   |
| Primary keys          | `DEFAULT uuidv7()`                  | Sequential, globally unique, fast indexing (PG 18+)  |
| Virtual columns       | `GENERATED ALWAYS AS (...) VIRTUAL` | Zero disk cost, computed on read (PG 18+)            |
| Temporal uniqueness   | `EXCLUDE USING gist`                | Prevent overlapping ranges natively                  |
| NOT VALID constraints | `ADD CONSTRAINT ... NOT VALID`      | Add constraints without table locks                  |
| TypedSQL              | `prisma.$queryRawTyped()`           | Type-safe raw SQL via `.sql` files                   |
| Relation emulation    | `relationMode = "prisma"`           | Integrity in FK-less environments (GA since 4.8.0)   |
| Soft deletes          | Prisma `$extends`                   | Cross-cutting concern via client extensions          |
| RLS standard          | `(select auth.uid()) = user_id`     | Default own-data access policy with initPlan caching |
| Team RLS              | `EXISTS` subquery                   | Permission checks via join tables                    |
| Column-level security | PostgreSQL Views                    | Hide sensitive columns from public APIs              |

## Synchronization Protocol

Every schema modification MUST follow these steps:

1. **Type-to-DB Verification**: When adding an enum or union in TS, verify the equivalent CHECK constraint in SQL
2. **Migration-First Generation**: Generate SQL migrations using `prisma migrate dev --create-only` BEFORE applying
3. **Naming Alignment**: Enforce snake_case in SQL and camelCase in TS via explicit `@map`/`@@map` directives
4. **Integrity Audit**: Run `prisma validate` and check for missing indices on relation scalars
5. **RLS Verification**: Confirm every new table has RLS enabled with appropriate policies
6. **Lock Assessment**: Evaluate whether migration requires `CREATE INDEX CONCURRENTLY` or `NOT VALID` patterns

## PostgreSQL Version Requirements

Several patterns in this skill require specific PostgreSQL versions:

| Feature            | Minimum Version | Fallback                                      |
| ------------------ | --------------- | --------------------------------------------- |
| `uuidv7()`         | PostgreSQL 18   | `gen_random_uuid()` (UUIDv4) via `pgcrypto`   |
| Virtual columns    | PostgreSQL 18   | `STORED` generated columns (PG 12+)           |
| `EXCLUDE USING`    | PostgreSQL 9.0  | Application-level overlap checks              |
| `NOT VALID`        | PostgreSQL 9.1  | Schedule constraint addition during downtime  |
| `security_invoker` | PostgreSQL 15   | Use `security_definer` with restricted grants |

## Common Mistakes

| Mistake                                                  | Correct Pattern                                                                       |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| Running SQL changes manually without migrations          | Generate numbered migrations with `prisma migrate dev --create-only` before applying  |
| Using auto-increment or raw IDs exposed in URLs          | Use UUIDv7 for globally unique, non-enumerable identifiers                            |
| Skipping CHECK constraints on enums or unions            | Add database-level CHECK constraints that mirror TypeScript types                     |
| Mixing snake_case and camelCase without explicit mapping | Use `@map` and `@@map` to enforce snake_case in SQL and camelCase in TypeScript       |
| Tables without Row-Level Security policies               | Apply RLS policies to every table, defaulting to `(select auth.uid()) = user_id`      |
| DROP or RENAME column in a single deployment             | Use expand-and-contract: add new column, dual-write, backfill, switch reads, drop old |
| Adding NOT NULL to large tables with full lock           | Add column as NULL first, backfill, then add NOT NULL with NOT VALID                  |
| Creating indices without CONCURRENTLY                    | Use `CREATE INDEX CONCURRENTLY` in raw SQL migrations to avoid table locks            |
| Using `auth.uid()` directly in RLS without subselect     | Wrap in `(select auth.uid())` to trigger initPlan caching                             |
| Assuming `uuidv7()` works on all PG versions             | Verify PostgreSQL 18+; fall back to `gen_random_uuid()` on older versions             |

## Naming Conventions

Prisma models use camelCase in TypeScript and must map to snake_case in PostgreSQL:

| Layer      | Convention  | Enforced By              |
| ---------- | ----------- | ------------------------ |
| TypeScript | camelCase   | Prisma model field names |
| PostgreSQL | snake_case  | `@map` / `@@map`         |
| Enums      | UPPER_SNAKE | CHECK constraints        |
| Indices    | snake_case  | `idx_table_column`       |

## Deployment Pipeline

Migrations follow a strict pipeline order:

1. `prisma migrate dev --create-only` -- generate and review SQL locally
2. `prisma validate` -- verify schema consistency
3. Apply to staging/preview database and run integration tests
4. `prisma migrate deploy` -- apply in CI/CD pipeline to production
5. Monitor for lock contention and query plan regressions

## Relationship to Other Skills

- **`database-security`**: Covers full RLS auditing, PGAudit configuration, Supabase-specific patterns, Convex auth guards, and compliance validation. Use `database-security` for in-depth policy review and access simulation. Use `db-enforcer` for schema design and migration patterns that include RLS as part of the integrity workflow.

## Delegation

- **Audit existing schema for missing constraints or indices**: Use `Explore` agent
- **Plan a zero-downtime migration strategy for production databases**: Use `Plan` agent
- **Execute a full schema refactor with type alignment and RLS setup**: Use `Task` agent
- **Review RLS policies for bypasses and performance issues**: Use `database-security` skill

## References

- [PostgreSQL integrity patterns, UUIDv7, virtual columns, and temporal constraints](references/postgres-integrity.md)
- [Prisma architecture, TypedSQL, extensions, and edge-first patterns](references/prisma-architecture.md)
- [Migration safety protocols, destructive changes, and rollback strategies](references/migration-safety.md)
- [Row-Level Security, column-level security, and audit logging](references/rls-security.md)

© oakoss · MIT · oakoss/agent-skills

Similar skills

All skills for Data and databases →

From the same set106

The whole set →
figma-developer figma-developer pulls colours, type styles and icons out of Figma over the REST API and turns them into CSS variables and React components. Useful when the design file moves faster than your code. CX Codex +1 114installs tanstack-store A reference skill that teaches the agent how TanStack Store works: stores, derived values, batching, effects. Useful when state is shared across components. CX Codex +1 113installs hono Guides coding agents in building lightweight APIs, middleware pipelines, and RPC servers using the Hono framework. CX Codex +1 112installs astro Feeds the agent Astro patterns: content collections, island hydration, view transitions, rendering modes. Useful when most pages are static with a few interactive parts. CX Codex +1 111installs electricsql Briefs your coding agent on ElectricSQL: streaming slices of Postgres to the client through Shapes, plus the proxy and write patterns around it. CX Codex +1 109installs trpc trpc is a Claude Code skill for building type-safe TypeScript APIs with tRPC v11. It comes into play when working on routers, procedures, React clients, or tests. CX Codex +1 109installs tauri This Claude Code skill covers Tauri v2 apps with web frontends and Rust backends. It activates for project setup, IPC, permissions, or app releases. CX Codex +1 108installs turborepo This Claude Code skill helps configure Turborepo in JavaScript and TypeScript monorepos. Use it to set up task pipelines, caching, package filters, and CI workflows. CX Codex +1 108installs

Project sponsors

Companies that keep this analytics open