@prismakit/cli 2.2.3 → 3.0.2

package/skills/prismakit/reference.md

@@ -0,0 +1,312 @@
+# PrismaKit core reference
+
+API surface for `@prismakit/core` 3.x. Read [SKILL.md](SKILL.md) first.
+
+## Packages
+
+| Package | Role |
+|---------|------|
+| `@prismakit/core` | `createRepository`, AutoComposer, locks, pagination, `CacheAdapter` |
+| `@prismakit/redis` | `RedisCacheAdapter` |
+| `@prismakit/memory` | `MemoryCacheAdapter` (tests / local) |
+| `@prismakit/cli` | `prismakit generate / validate / skills` |
+| `@prismakit/eslint-plugin` | Repository-only data-access rules |
+
+Node ≥ 20. Install:
+
+```bash
+pnpm add @prismakit/core
+pnpm add @prismakit/redis ioredis          # optional production cache
+pnpm add -D @prismakit/eslint-plugin @prismakit/cli
+# tests: pnpm add -D @prismakit/memory
+```
+
+## Factory
+
+```typescript
+createRepository(options) → new RepoClass(deps: RepositoryDeps)
+```
+
+Aliases: `defineRepository`, `createPrismaRepository`.
+
+`RepositoryDeps`: `{ prisma, cache?, registry?, autoCompose? }`.
+
+### `RepositoryOptions`
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `model` | `string` | Client key. Required for cache + compose. |
+| `scalarFields` | `Record<string, string>` | `Prisma.XScalarFieldEnum`; inferred from meta if omitted. |
+| `cache` | `CacheOptions \| true` | `true` → `{ ttl: 86400, sensitiveFields: ['password'] }`. |
+| `lock` | `true \| string \| RepositoryLockConfig` | `true` / client key / Pascal name / `@@map` table. |
+| `schemaPath` | `string` | Lock/schema helpers when global meta is missing. |
+| `primaryKey` | `string \| string[]` | `*ById` + row locks. Default: meta PK or `id`. |
+| `getDelegate` | `(client) => delegate` | Default `(c) => c[model]`. |
+| `toPayload` | `(data) => payload` | Default identity. Prefer typed factories over this. |
+
+`RepositoryLockConfig`: `{ tableName: string; columns?: Record<string, string> }`.
+
+## Repository methods
+
+All methods accept optional `tx`. Cached repos also accept cache fields (see below). `id` is `string | Record<string, string>`.
+
+### Reads
+
+| Method | Extra args | Returns |
+|--------|------------|---------|
+| `getById` | `id`, `select?`, `lock?`, `setCache?` | `T \| null` |
+| `getThrowById` | same | `T` (throws if missing) |
+| `getFirst` | `where?`, `select?`, `lock?`, `setCache?`, `cacheTags?` | `T \| null` |
+| `getMany` | `where?`, `select?`, `orderBy?`, `take?`, `skip?`, `lock?`, `setCache?`, `cacheTags?` | `T[]` |
+| `getManyPaginate` | `where?`, `select?`, `orderBy?`, `page?`, `pageSize?`, `setCache?`, `cacheTags?` | `PaginatedResult<T>` |
+
+`PaginatedResult<T>`:
+
+```typescript
+{ data: T[]; meta: { page: number; pageSize: number; totalItems: number; totalPages: number } }
+```
+
+`cacheTags` may be `string[]` or `(where?) => string[]`.
+
+### Writes
+
+| Method | Extra args | Default `invalidate` | Returns |
+|--------|------------|----------------------|---------|
+| `create` | `data`, `select?`, `invalidate?`, `tags?` | `queries` | `T` |
+| `createMany` | `data[]`, `skipDuplicates?`, `invalidate?`, `tags?` | `queries` | `{ count }` |
+| `updateById` | `id`, `data`, `select?`, `invalidate?`, `tags?` | `all` | `T` |
+| `updateMany` | `where`, `data`, `invalidate?`, `tags?` | `all` | `{ count }` |
+| `upsert` | `where`, `create`, `update`, `select?`, `invalidate?`, `tags?` | `all` | `T` |
+| `deleteById` | `id`, `select?`, `invalidate?`, `tags?` | `all` | `T` |
+| `deleteMany` | `where`, `invalidate?`, `tags?` | `all` | `{ count }` |
+
+Mutation `tags`: `string[] | null | undefined | ((result) => string[] | null | undefined)`.
+
+### Manual invalidation (cached repos only)
+
+```typescript
+await repo.invalidateCache({ id?: string; tags?: string[] });
+```
+
+## Cache
+
+### When a read hits cache
+
+1. `setCache: true` **or** `cache.defaultSetCache: true` without `setCache: false`
+2. `model` + `cache` config present
+3. No `tx`
+4. Method not `{ enabled: false }` in `cache.methods`
+5. `select` has no `sensitiveFields` (default `['password']`)
+
+### `CacheOptions`
+
+| Field | Default | Notes |
+|-------|---------|-------|
+| `ttl` | `86400` | Entity TTL (seconds). |
+| `nullTtl` | — | Negative cache for null results. |
+| `sensitiveFields` | `['password']` | Selects containing these never cache. |
+| `methods` | — | Per-method `{ enabled?, ttl? }` for `getById`, `getThrowById`, `getFirst`, `getMany`, `getManyPaginate`. |
+| `defaultSetCache` | `false` | Reads cache unless caller passes `setCache: false`. |
+| `stampede` | see below | Per-repo stampede overrides. |
+| `compression` | — | Hint for adapters (`'none' \| 'zstd' \| 'lz4'`). Redis adapter uses `'none' \| 'gzip'`. |
+
+### `InvalidateMode`
+
+| Mode | Effect |
+|------|--------|
+| `all` | Entity keys for `id` (or all entities) + query index |
+| `entity` | Entity keys only |
+| `queries` | Query index only |
+| `none` | Skip — **required inside transactions** |
+| `stale` | Core treats like entity+queries (adapter may layer SWR) |
+
+### Allowlist
+
+`setRegisteredCacheModels(['user', 'product'])`. Empty/unset = fail-open. When set, a repo with `cache` whose `model` is missing throws at init.
+
+### Key schema
+
+```
+{prefix}:repo:{model}:e:{id}:{method}:{selectHash}
+{prefix}:repo:{model}:q:{method}:{queryHash}
+{prefix}:repo:{model}:e:{id}:__idx
+{prefix}:repo:{model}:e:__idx
+{prefix}:repo:{model}:q:__idx
+{prefix}:repo:{model}:t:{tag}:__idx
+```
+
+### Debug
+
+```bash
+CACHE_DEBUG=true
+```
+
+Hits/misses/bypasses via `cacheDebugStorage` from `@prismakit/core`.
+
+### Stampede (`StampedeOptions`)
+
+| Field | Default |
+|-------|---------|
+| `lockTtl` | `5` (seconds) |
+| `retryMs` | `100` |
+| `maxRetries` | `10` |
+| `backoff` | `'exponential'` (`'fixed'` also valid) |
+| `totalTimeoutMs` | `3000` |
+
+In-process `singleflight` is also used. If Redis is down, fail open.
+
+### Adapters
+
+**Redis** (`@prismakit/redis`):
+
+```typescript
+new RedisCacheAdapter({
+  url: process.env.REDIS_URL, // or host + port
+  host: 'localhost',          // default when url omitted
+  port: 6379,
+  prefix: 'myapp',            // default 'prismakit'
+  compression: 'gzip',        // 'none' | 'gzip'
+  compressionThresholdBytes: 1024,
+});
+```
+
+**Memory** (`@prismakit/memory`) — tests/local:
+
+```typescript
+new MemoryCacheAdapter({ prefix: 'test', maxSize: 1000, defaultTtl: 300 });
+```
+
+Custom: implement `CacheAdapter` (`get`/`set`/`del`/`setNx`/`setWithIndex`/`invalidateByIndex`/`saddAndExpire`/`smembers`/`isReady`/`getPrefix` + `safe*` wrappers). `get`/`safeGet` **must** return a fresh copy (structuredClone / JSON). Prefer fail-open `safe*` semantics.
+
+## Auto-compose
+
+`splitSelect` keeps scalars (+ FK fields from DMMF) for the Prisma query. Relation keys load via the target repository. Target PK is always injected into the nested select.
+
+Load meta once at bootstrap:
+
+```typescript
+import { loadPrismaMetaFromDmmf, loadPrismaMetaFromSchema } from '@prismakit/core';
+
+loadPrismaMetaFromDmmf(Prisma.dmmf);                 // Prisma 5/6
+loadPrismaMetaFromSchema('prisma/schema.prisma');    // Prisma 7 (no Prisma.dmmf)
+```
+
+Without meta, AutoComposer cannot resolve renamed relations; pass `schemaPath` or `dmmf`. Relation field → registry key is source-scoped (`Category.products` vs `Tag.products` can target different models).
+
+Validate: `npx prismakit validate --auto-register` or `assertSelectComposeValid`.
+
+### `ComposeOptions` (global via `setComposeOptions`)
+
+| Field | Default | Notes |
+|-------|---------|-------|
+| `maxDepth` | `10` | Max relation nesting. |
+| `parallel` | `true` | Same-level relations via `Promise.all`. |
+| `setCache` | `true` | Nested fetches pass `setCache: true` unless parent has `tx` / `setCache: false`. |
+| `tx` | — | Per-call only; forwarded to nested `getMany`. |
+
+Related repos must be registered on `RepositoryRegistry`.
+
+## Row locks
+
+`SELECT … FOR UPDATE` (and related). Repo `lock` config required. `tx` required on the call.
+
+### Per-call `RowLockOptions`
+
+| Field | Notes |
+|-------|-------|
+| `mode` | `'update' \| 'noKeyUpdate' \| 'share' \| 'keyShare'`. Default `noKeyUpdate`. |
+| `nowait` | Fail immediately if locked. |
+| `skipLocked` | Skip locked rows. **Cannot** combine with `nowait`. |
+
+`lock: true` / `'wallet'` / `'Wallet'` / `'wallets'` resolve via Prisma meta when available, else `buildLockConfigFromSchema`.
+
+## Telemetry
+
+```typescript
+import { setTelemetry } from '@prismakit/core';
+
+setTelemetry({
+  enabled: true,
+  onEvent: (event) => { /* metrics */ },
+});
+```
+
+| Type | When |
+|------|------|
+| `cache.hit` / `cache.miss` / `cache.bypass` / `cache.invalidate` | Cache-aside path |
+| `compose.start` / `compose.complete` | Auto-compose (`queryCount`, `durationMs`) |
+| `lock.acquired` / `lock.waited` / `lock.timeout` | Row locks |
+| `stampede.locked` / `stampede.waited` / `stampede.fallthrough` | Stampede protection |
+| `query.complete` / `query.slow` | Repository method timing |
+
+## CLI
+
+```bash
+npx prismakit generate <name> [--cache] [--full] [--route <path>] [--prisma-import <path>] [--dry-run]
+npx prismakit validate [--schema <path>] [--auto-register] [--no-assert]
+npx prismakit help
+```
+
+Default generate output: `src/modules/<kebab>/repositories/<kebab>.repository.ts`.
+
+`--full` emits Nest module + controller + service + select/where types. Register `*Module` in `app.module.ts` afterwards.
+
+## ESLint
+
+```js
+import prismakit from '@prismakit/eslint-plugin';
+export default [prismakit.configs.recommended];
+```
+
+`recommended` turns all rules on at **error**.
+
+| Rule | Forbids |
+|------|---------|
+| `prismakit/no-prisma-service-outside-repos` | Inject/reference `PrismaService` / `PrismaClient` outside allowlist |
+| `prismakit/no-direct-prisma-delegate` | `prisma.<model>.*` outside allowlist |
+| `prismakit/require-transaction-service` | `.$transaction` in feature code |
+
+Allowed path patterns (forward slashes):
+
+- `**/repositories/**`
+- `**/infrastructure/prisma/**`
+- `**/node_modules/**`
+- `packages/(core|nestjs|redis)/**` (PrismaKit monorepo)
+
+Mirror this layout rather than weakening the plugin.
+
+## Bootstrap (plain Node)
+
+```typescript
+import { Prisma, PrismaClient } from '@prisma/client';
+import {
+  createRepository,
+  loadPrismaMetaFromSchema,
+  setRegisteredCacheModels,
+  setComposeOptions,
+  setTelemetry,
+  RepositoryRegistry,
+  AutoComposer,
+} from '@prismakit/core';
+import { RedisCacheAdapter } from '@prismakit/redis';
+
+const prisma = new PrismaClient();
+loadPrismaMetaFromSchema('prisma/schema.prisma');
+setRegisteredCacheModels(['user', 'post']);
+setComposeOptions({ maxDepth: 6, parallel: true, setCache: true });
+setTelemetry({ enabled: true, onEvent: (e) => console.debug('[pk]', e.type) });
+
+const cache = new RedisCacheAdapter({ prefix: 'myapp' });
+const registry = new RepositoryRegistry();
+const autoCompose = new AutoComposer(registry);
+
+const UserRepo = createRepository({
+  model: 'user',
+  scalarFields: Prisma.UserScalarFieldEnum,
+  cache: { ttl: 86_400 },
+});
+const users = new UserRepo({ prisma, cache, registry, autoCompose });
+registry.register('user', users);
+```
+
+Nest apps should use `PrismaKitModule` instead of wiring this by hand.

package/skills/prismakit/review-checklist.md

@@ -0,0 +1,72 @@
+# PrismaKit review checklist
+
+Copy this list and tick every item before marking a data-access change done. Failures are bugs.
+
+```
+Task Progress:
+- [ ] Layering
+- [ ] Repository factory
+- [ ] Selects
+- [ ] Cache
+- [ ] Transactions
+- [ ] Locks
+- [ ] Compose
+- [ ] ESLint / layout
+```
+
+## Layering
+
+- [ ] No `PrismaClient` / `PrismaService` injected in services, helpers, controllers, processors, or queue workers
+- [ ] No `prisma.<model>.*` outside `**/repositories/**`
+- [ ] Controllers/route handlers call services only — not repositories (unless the app already uses a documented exception)
+- [ ] Helpers inject repositories, never the Prisma client
+
+## Repository factory
+
+- [ ] New model access goes through `createRepository` (core) or the app's Nest `defineRepo` binder — not a one-off Prisma call
+- [ ] File lives under `**/repositories/**` as `*.repository.ts`
+- [ ] `model` is the Prisma client key (`'user'`, not `'User'`)
+- [ ] `scalarFields` is set **or** Prisma meta is loaded at bootstrap (`dmmf` / `schemaPath`)
+- [ ] `cacheModels` is omitted unless the app wants an extra allowlist
+
+## Selects
+
+- [ ] Every read/write that returns a row passes an explicit `select`
+- [ ] Select presets used: `minimal` (no cache), `general` (API, cacheable), `withPassword` (auth, never cached)
+- [ ] Controllers do not construct `select` objects
+- [ ] Sensitive fields (`password`, tokens) only appear in auth presets
+
+## Cache
+
+- [ ] User-facing `getById` / `getThrowById` / `getMany` / `getManyPaginate` pass `setCache: true` when the repo has `cache` (unless `defaultSetCache: true`)
+- [ ] Auth / uniqueness / JWT `getFirst` does **not** pass `setCache: true`
+- [ ] No `setCache` on selects that include `sensitiveFields`
+- [ ] `setCache` / `invalidateCache` not passed on repos that omit `cache` config (types omit those fields)
+- [ ] Query lists that must drop together use `cacheTags` on read and `tags` on write
+
+## Transactions
+
+- [ ] Multi-step writes share one transaction; `tx` is passed into **every** repo call in that unit of work
+- [ ] Nest feature code uses `TransactionService.execTx`, not `prisma.$transaction`
+- [ ] Writes inside tx use `invalidate: 'none'`
+- [ ] `invalidateCache` runs after commit (`afterCommit` in Nest, or immediately after `$transaction` in plain Node)
+- [ ] No cached reads mixed with half-committed writes
+
+## Locks
+
+- [ ] Repo declares `lock` (`true`, client key, table name, or config) before any call passes `lock`
+- [ ] Every `lock: { mode }` call also passes `tx`
+- [ ] `skipLocked` is not combined with `nowait`
+- [ ] Locked transactions stay short
+
+## Compose
+
+- [ ] Relations are nested objects in `select`, not Prisma `include`
+- [ ] Related model repositories are registered (or `autoRegisterModels` covers them)
+- [ ] `npx prismakit validate` (or `validateCompose: true`) is clean when selects nest relations
+
+## ESLint / layout
+
+- [ ] `@prismakit/eslint-plugin` `recommended` is in the app ESLint config
+- [ ] Lint passes on the changed files
+- [ ] Prisma client construction stays under `**/infrastructure/prisma/**` (or equivalent allowlisted folder)

package/skills/prismakit-nestjs/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: prismakit-nestjs
+description: >-
+  PrismaKit NestJS adapter: PrismaKitModule.forRoot/forRootAsync wiring, injectable repositories via
+  createDefineRepo/defineInjectableRepository, TransactionService.execTx with afterCommit invalidation,
+  and PRISMAKIT_* DI tokens. Use when working with @prismakit/nestjs, Nest feature modules that need
+  Prisma data access, or Nest transactions and cache invalidation.
+---
+
+# PrismaKit NestJS
+
+Adapter for NestJS. The data-access contract (layering, cache, compose, locks, ESLint) lives in skill `prismakit` — follow it. This skill covers module wiring, injectable repos, and `TransactionService`.
+
+## Bootstrap
+
+```bash
+pnpm add @prismakit/core @prismakit/nestjs
+pnpm add @prismakit/redis ioredis
+pnpm add -D @prismakit/eslint-plugin @prismakit/cli
+```
+
+```typescript
+import { Module } from '@nestjs/common';
+import { PrismaKitModule } from '@prismakit/nestjs';
+import { RedisCacheAdapter } from '@prismakit/redis';
+import { Prisma } from '@prisma/client';
+
+@Module({
+  imports: [
+    PrismaKitModule.forRoot({
+      prisma: prismaClient,
+      cache: new RedisCacheAdapter({ prefix: 'myapp' }),
+      schemaPath: 'prisma/schema.prisma', // default; Prisma 5/6: dmmf: Prisma.dmmf
+      validateCompose: true,
+      compose: { maxDepth: 6, parallel: true, setCache: true },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+`forRootAsync` when cache/URL come from `ConfigService` — see [examples.md](examples.md).
+
+`schemaPath` defaults to `prisma/schema.prisma`. Always load Prisma meta (`dmmf` or `schemaPath`) so auto-compose and `lock: true` resolve FKs/`@@map` from the schema — no relation-alias map.
+
+## Factory (one default)
+
+Bind `Prisma.TypeMap` once, then define repos with runtime options only.
+
+```typescript
+// src/infrastructure/prisma/define-repo.ts
+import { createDefineRepo } from '@prismakit/nestjs';
+import type { Prisma } from '@prisma/client';
+
+export const defineRepo = createDefineRepo<Prisma.TypeMap>();
+```
+
+```typescript
+// src/modules/users/repositories/user.repository.ts
+import { Prisma } from '@prisma/client';
+import { defineRepo } from '../../../infrastructure/prisma/define-repo';
+
+const DAY = 86_400;
+
+export const UserRepository = defineRepo({
+  model: 'user',
+  scalarFields: Prisma.UserScalarFieldEnum,
+  cache: { ttl: DAY, nullTtl: 60, sensitiveFields: ['password'] },
+  lock: true,
+});
+export interface UserRepository extends InstanceType<typeof UserRepository> {}
+```
+
+Escape hatches (do not use as the app default):
+
+- `defineInjectableRepository` from `@prismakit/nestjs` (package alias `defineRepository`) — phantoms + payload HKT when TypeMap is unavailable.
+- `createInjectableRepository` without a types bag — thin, results are `unknown`. Alias: `createPrismaRepository`.
+
+Do not import `defineRepo` from `@prismakit/nestjs` in apps that already bind `createDefineRepo` as `defineRepo`.
+
+## Register and inject
+
+```typescript
+@Module({
+  controllers: [UserController],
+  providers: [UserService, UserRepository],
+  exports: [UserService, UserRepository],
+})
+export class UserModule {}
+```
+
+```typescript
+@Injectable()
+export class UserService {
+  constructor(private readonly users: UserRepository) {}
+}
+```
+
+**Do not** inject `PRISMAKIT_PRISMA`, `PrismaClient`, or `PrismaService` in services, helpers, controllers, or processors. The prisma token exists so injectable repositories can wire `RepositoryDeps`.
+
+Rare custom repos (dashboard/health) may inject `PRISMAKIT_PRISMA` **only** if the class lives under `**/repositories/**`.
+
+## Transactions
+
+```typescript
+import { TransactionService } from '@prismakit/nestjs';
+
+constructor(
+  private readonly tx: TransactionService,
+  private readonly orders: OrderRepository,
+  private readonly stocks: StockRepository,
+) {}
+
+await this.tx.execTx(
+  async (tx) => {
+    const order = await this.orders.create({
+      tx,
+      data: { /* ... */ },
+      select: { id: true },
+      invalidate: 'none',
+    });
+    await this.stocks.updateById({
+      tx,
+      id: input.stockId,
+      data: { qty: { decrement: input.qty } },
+      invalidate: 'none',
+    });
+    return order;
+  },
+  async () => {
+    await this.orders.invalidateCache({});
+    await this.stocks.invalidateCache({ id: input.stockId });
+  },
+);
+```
+
+Rules:
+
+- `TransactionService.execTx(fn, afterCommit?, options?)` — never `prisma.$transaction` in feature code.
+- Pass `tx` into every repo call in the unit of work.
+- Writes inside tx: `invalidate: 'none'`.
+- `afterCommit` runs only after `$transaction` resolves.
+- Keep transactions short. Do not mix cached reads with half-committed writes.
+
+Optional third argument: `{ maxWait, timeout, isolationLevel }`.
+
+## Row locks
+
+Repo must have `lock` config. Call must pass `tx`.
+
+```typescript
+await this.tx.execTx(
+  async (tx) => {
+    const wallet = await this.wallets.getById({
+      tx,
+      id,
+      select: { id: true, balance: true },
+      lock: { mode: 'update' },
+    });
+    await this.wallets.updateById({
+      tx,
+      id,
+      data: { balance: wallet!.balance - amount },
+      invalidate: 'none',
+    });
+  },
+  async () => {
+    await this.wallets.invalidateCache({ id });
+  },
+);
+```
+
+## Cache typing DX
+
+When the repo options include `cache`, TypeScript exposes `setCache`, `cacheTags`, mutation `invalidate`/`tags`, and `invalidateCache`. Without `cache`, those fields are omitted — do not pass them.
+
+Repository `cache` is the source of truth. Omit `cacheModels` (fail-open). Pass an allowlist only if you want a second check.
+
+`cache.defaultSetCache: true` makes user-facing reads cache by default; still pass `setCache: false` on auth/uniqueness.
+
+## What the module provides
+
+| Token / provider | Who may inject |
+|------------------|----------------|
+| `TransactionService` | Services / helpers |
+| `RepositoryRegistry` | Kit internals / compose |
+| `AutoComposer` | Kit internals / compose |
+| `PRISMAKIT_PRISMA` | **Repositories only** |
+| `PRISMAKIT_CACHE` | Repositories / kit internals |
+| `PRISMAKIT_OPTIONS` | Kit internals |
+
+## Ops
+
+| Option | Use |
+|--------|-----|
+| `cacheModels` | Optional extra allowlist (omit — repo `cache` is enough) |
+| `validateCompose: true` | Assert compose-safe selects on boot |
+| `compose` | `{ maxDepth, parallel, setCache }` |
+| `telemetry` | `{ enabled: true, onEvent }` |
+| `queryLog` | `{ slowThreshold, onSlowQuery }` — enables telemetry |
+| `autoRegisterModels` | `true` or `string[]` — stub repos for compose-only models |
+
+## Scaffolding
+
+```bash
+npx prismakit generate product --cache
+npx prismakit generate product --cache --full --route products
+```
+
+Repo-only: add the class to feature `providers`. `--full`: import `*Module` in `AppModule`. Then `npx prismakit validate`.
+
+Enable ESLint `prismakit.configs.recommended` (see skill `prismakit`).
+
+## Clean code (Nest)
+
+- One `defineRepo` binder under `src/infrastructure/prisma/`. Do not call `createDefineRepo` per feature.
+- Feature modules own their repository providers; do not make every repo global.
+- Controllers stay HTTP-only: map DTO → service method. No repository calls in controllers.
+- Select presets live next to the repository (`minimal` / `general` / `withPassword`).
+- Name TTL constants once; reuse in repo `cache` config.
+
+## Anti-patterns (BAD → GOOD)
+
+```typescript
+// BAD
+constructor(private readonly prisma: PrismaClient) {}
+constructor(@Inject(PRISMAKIT_PRISMA) private readonly prisma: PrismaClient) {}
+await this.prisma.$transaction(async (tx) => { /* ... */ });
+await this.products.updateById({ tx, id, data }); // invalidates inside tx
+await this.users.getFirst({ where: { email }, select: { id: true }, setCache: true });
+
+// GOOD
+constructor(
+  private readonly tx: TransactionService,
+  private readonly products: ProductRepository,
+) {}
+await this.tx.execTx(
+  async (tx) => {
+    await this.products.updateById({ tx, id, data, invalidate: 'none' });
+  },
+  async () => {
+    await this.products.invalidateCache({ id });
+  },
+);
+await this.users.getFirst({ where: { email }, select: { id: true } });
+```
+
+## Before you finish
+
+Copy and complete [review-checklist.md](review-checklist.md).
+
+- Module options and tokens: [reference.md](reference.md)
+- Production wiring snippets: [examples.md](examples.md)
+- Core contract: skill `prismakit`