opencode-andev-rules 1.0.0 → 1.0.1

package/skills/infrastructure/prisma/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: prisma
+description: Prisma ORM rules — client setup, queries, errors, transactions, migrations. Use when building or reviewing Prisma data access.
+---
+
+# Prisma Skill
+
+## Setup
+
+- One PrismaClient singleton for the whole app — never `new PrismaClient()` per request or per service.
+- Provide it once (global module / DI) — services inject it, never instantiate it.
+- Datasource URL from env only — never hardcode connection strings, never log them.
+- Size the pool via `connection_limit`/`pool_timeout` — serverless or hot-reload dev must reuse the singleton or use an external pooler.
+
+## Relations: FK/PK decision
+
+- Always ask the user before modeling relations: database-enforced foreign keys vs Prisma-emulated relations (`relationMode = "prisma"`).
+- Without DB-level FKs, Prisma can still join via `include` — but nothing enforces referential integrity in the database.
+- With DB FKs: integrity enforced by the database; `onDelete` acts at the DB level; migrations carry the constraints.
+- Without DB FKs: integrity must be enforced in application code (existence checks + transactions); no `onDelete` in the database; fits providers without FK support.
+- Never assume one mode — the choice changes schema, migrations, and error handling; confirm it first.
+
+## Queries
+
+- Use `select` when only a subset of fields is required — don't over-fetch.
+- Avoid N+1 queries — use `include` or joins, not loops.
+- Avoid `include` for large relation collections — paginate or `select` instead.
+- Prisma fetches all scalar columns by default — with wide tables or heavy columns (text, JSON), always narrow it down.
+- Never blanket `include` — it pulls every column of the related table; nest `select` inside instead.
+
+```typescript
+// Good — narrow scalars, nested select for relations
+await prisma.user.findMany({
+  select: { id: true, name: true, posts: { select: { id: true, title: true } } },
+});
+
+// Or drop heavy fields (Prisma 6.2+)
+await prisma.post.findMany({ omit: { content: true } });
+```
+- Use `findUnique` when the field is unique — `findFirst` only otherwise.
+- Paginate `findMany` — never return unbounded results; cursor pagination for large datasets, offset for small.
+- Always `orderBy` deterministic fields for pagination.
+- Run independent queries in parallel — don't `await` sequentially.
+- Never raw SQL unless performance-critical (comment why) — never concatenate values into queries, use parameterized inputs.
+
+## Errors
+
+- Map Prisma errors to domain exceptions in one place (`P2002` → conflict, `P2025` → not found, ...) — never leak raw Prisma errors to API responses.
+
+## Transactions
+
+- Multi-step writes go in `$transaction` — no partial writes.
+- Keep transaction scope small — no external calls inside transactions.
+- Race conditions on read-modify-write — use transactions or locks.
+
+## Migrations
+
+- Keep migrations in `prisma/migrations` and commit them — never edit an applied migration, create a new one instead.
+- Deploy with `migrate deploy` — never `migrate dev` against prod.
+- Review destructive changes (drop column/table, type narrowing) before applying — backfill via a data migration when rows exist.
+
+## References
+
+- Schema layout, models, indexes, relations, enums: `references/prisma-schema.md`.
+- CLI, CRUD, optimization catalog: `references/prisma-queries.md`.

package/skills/infrastructure/prisma/references/prisma-queries.md

@@ -0,0 +1,197 @@
+# Prisma Queries & Operations
+
+Samples assume the global singleton `prisma` (see `SKILL.md` Setup) — never `new PrismaClient()` per call.
+
+## CLI
+
+| Command | Use |
+|---|---|
+| `prisma generate` | Regenerate Prisma Client |
+| `prisma migrate dev` | Create and apply migrations in dev |
+| `prisma migrate deploy` | Apply migrations in production/CI |
+| `prisma db push` | Push schema straight to DB, no migration (prototypes only) |
+| `prisma db pull` | Introspect an existing DB into the schema |
+| `prisma studio` | Open the GUI |
+
+## CRUD
+
+```typescript
+// Create
+await prisma.user.create({ data: { email: 'a@b.com', name: 'An' } });
+
+// Read
+await prisma.user.findUnique({ where: { email: 'a@b.com' } });
+await prisma.user.findMany({
+  where: { name: { contains: 'An' } },
+  orderBy: { id: 'desc' },
+  take: 10,
+});
+
+// Update / Delete
+await prisma.user.update({ where: { id: 'user_01' }, data: { name: 'Bình' } });
+await prisma.user.delete({ where: { id: 'user_01' } });
+
+// Relations — narrow, never blanket include
+await prisma.user.findMany({
+  select: { id: true, name: true, posts: { select: { id: true, title: true } } },
+});
+
+// Transaction (independent writes)
+await prisma.$transaction([
+  prisma.user.create({ data: { email: 'x@y.com', name: 'X' } }),
+  prisma.post.create({ data: { title: 'Hi', authorId: 'user_01' } }),
+]);
+```
+
+## Optimization
+
+### 1. Select only what you need (`select` / `omit`)
+
+- Same rule as `SKILL.md` Queries — full example there.
+- Never blanket `include` — it pulls every column of the related table.
+
+### 2. Avoid N+1 queries
+
+```typescript
+// Wrong (N+1)
+const users = await prisma.user.findMany();
+for (const u of users) {
+  u.posts = await prisma.post.findMany({ where: { authorId: u.id } });
+}
+
+// Right — one round trip, narrowed
+const users = await prisma.user.findMany({
+  select: { id: true, name: true, posts: { select: { id: true, title: true } } },
+});
+```
+
+- `relationLoadStrategy: 'join'` lets Prisma use one JOIN instead of separate queries — check preview/GA status for your Prisma version.
+- Simultaneous `findUnique` calls in the same tick are auto-batched (dataloader) — useful for GraphQL resolvers.
+
+### 3. Index the right columns
+
+```prisma
+model Post {
+  // ...
+  @@index([authorId])                 // FK
+  @@index([published, createdAt])     // composite for filter + sort
+  @@unique([authorId, slug])
+
+  @@map("posts")
+}
+```
+
+- Index columns used in `where`, `orderBy`, joins — column order matters in composite indexes.
+- Never over-index — indexes slow down writes.
+
+### 4. Paginate efficiently
+
+- Offset (`skip` + `take`) slows down as `skip` grows — the DB still scans skipped rows.
+- Cursor pagination is stable and fast for large datasets:
+
+```typescript
+await prisma.post.findMany({
+  take: 20,
+  skip: 1,
+  cursor: { id: lastId },
+  orderBy: { id: 'asc' },
+});
+```
+
+### 5. Batch writes
+
+- Never loop single-row writes — use batch operations:
+
+```typescript
+await prisma.user.createMany({ data: users, skipDuplicates: true });
+await prisma.post.updateMany({ where: { authorId: 'user_01' }, data: { published: true } });
+await prisma.post.deleteMany({ where: { published: false } });
+```
+
+### 6. Connection pooling
+
+- Reuse the singleton everywhere — hot-reload dev and serverless must guard it, never create clients per invocation:
+
+```typescript
+const globalForPrisma = globalThis as unknown as { prisma?: PrismaClient };
+export const prisma = globalForPrisma.prisma ?? new PrismaClient();
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+```
+
+- Size the pool via connection string: `?connection_limit=10&pool_timeout=20`.
+- Serverless (Vercel, Lambda): use an external pooler (PgBouncer, Supabase pooler, Prisma Accelerate) — never exhaust direct connections.
+
+### 7. Aggregate in the database
+
+```typescript
+await prisma.post.groupBy({ by: ['authorId'], _count: { _all: true } });
+await prisma.order.aggregate({ _sum: { total: true }, where: { status: 'PAID' } });
+await prisma.user.findMany({ include: { _count: { select: { posts: true } } } });
+```
+
+- Filter, sort, and count in the DB — never pull everything and `.filter()` in code.
+
+### 8. Keep transactions lean
+
+- `$transaction([...])` batch form for independent operations.
+- Interactive form only when logic runs between steps — keep it short:
+
+```typescript
+await prisma.$transaction(
+  async (tx) => {
+    const acc = await tx.account.update({
+      where: { id },
+      data: { balance: { decrement: 100 } },
+    });
+    if (acc.balance < 0) throw new Error('Insufficient balance');
+  },
+  { timeout: 5000, maxWait: 2000 },
+);
+```
+
+- No external API calls, no heavy work inside transactions — they hold connections and locks.
+
+### 9. Raw queries for complex cases
+
+- Window functions, CTEs, advanced full-text search: use raw queries.
+- Always the tagged template form — never string-concatenate user input:
+
+```typescript
+const rows = await prisma.$queryRaw`
+  SELECT author_id, COUNT(*) FROM "posts" WHERE published = true GROUP BY author_id
+`;
+```
+
+- Never `$queryRawUnsafe` with user input — use TypedSQL for typed raw queries.
+
+### 10. Measure before optimizing
+
+```typescript
+const prisma = new PrismaClient({ log: ['query', 'warn', 'error'] });
+```
+
+- Enable query logging in dev (on the singleton) to catch N+1 and redundant queries.
+- Run `EXPLAIN ANALYZE` on generated SQL to confirm index usage.
+- Trace per-query time with OpenTelemetry or Prisma `$extends`.
+
+### 11. Cache
+
+- Cache heavy-read, rarely-changed results with Redis or in-memory.
+- Prisma Accelerate supports `cacheStrategy: { ttl: 60, swr: 120 }`.
+
+### 12. Cold start / bundle
+
+- Edge/serverless: consider driver adapters (Neon, PlanetScale, D1, ...) to cut size and startup latency — check your Prisma version.
+- Generate only the needed binary targets on deploy (`binaryTargets`).
+
+## Checklist
+
+- One PrismaClient singleton
+- Always `select`/`omit` on wide tables
+- No queries in loops — use `include`, `in`, `createMany`
+- Indexes on FKs and filter/sort columns
+- Cursor pagination for large lists
+- Short transactions
+- Query logging in dev to catch N+1
+- Pooler for serverless
+- Raw SQL for complex queries (safe tagged-template form)

package/skills/infrastructure/prisma/references/prisma-schema.md

@@ -0,0 +1,126 @@
+# Prisma Schema Structure Rules
+
+## Layout
+
+- Follow this tree exactly — schema, migrations, and seed stay under `prisma/`.
+- Split the schema per domain under `prisma/schema/` — never one giant `schema.prisma`.
+
+```
+prisma/
+├── schema/
+│   ├── base.prisma
+│   ├── user.prisma
+│   └── order.prisma
+├── seed.ts
+└── migrations/
+    └── 20240101000000_init/
+        └── migration.sql
+```
+
+- `base.prisma` holds only `generator` + `datasource` — never models or enums in it.
+- One file per domain (`user.prisma`, `order.prisma`, ...) holding its models + enums — never split one model across files.
+- Cross-file relations reference the model by name — Prisma merges all files, no imports needed.
+- One model per table — never two models over the same table.
+
+## Models
+
+- Model names PascalCase singular with `@@map` to the snake_case table (e.g., `model User ... @@map("users")`).
+- Field names camelCase; map to snake_case columns with `@map` when the database uses snake_case.
+- Every model has a primary key, `createdAt`, and `updatedAt` — never a model without a PK.
+- Primary keys are `String @id @default(uuid())` — never auto-increment ints for IDs.
+- Soft-delete with `deletedAt DateTime?` — always filter it in queries, never return soft-deleted rows by default.
+- Put DB-level defaults in the schema (`@default`, `@updatedAt`) — never rely on application code for timestamps.
+
+```prisma
+model User {
+  id        String    @id @default(uuid())
+  email     String    @unique
+  name      String
+  role      Role      @default(USER)
+  createdAt DateTime  @default(now())
+  updatedAt DateTime  @updatedAt
+  deletedAt DateTime?
+
+  @@map("users")
+}
+```
+
+## Enums
+
+- Fixed sets (status, role) are Prisma enums — never free strings for status-like fields.
+- Map enum values explicitly when the database stores different labels.
+
+```prisma
+enum Role {
+  ADMIN
+  USER
+}
+```
+
+## Relations
+
+- Confirm FK/PK mode first (decision gate in `SKILL.md`) — the rules below assume DB-enforced foreign keys.
+- No-FK mode: skip DB constraints and `onDelete`, enforce integrity in code with existence checks + transactions.
+- Name relations explicitly when two models link more than once — never leave ambiguous relations unnamed.
+- Set `onDelete` deliberately per relation (`Cascade`, `Restrict`, `SetNull`) — never accept the default without thinking; dangerous cascades stay out.
+- Use an explicit relation table for many-to-many that carries extra fields — never overload a pure join with payload columns.
+- Index every foreign key — Prisma does not auto-index all relation columns on every provider.
+
+```prisma
+// WITH FK/PK — database enforces the relation
+// schema/user.prisma
+model User {
+  id    String @id @default(uuid())
+  email String @unique
+  posts Post[]
+
+  @@map("users")
+}
+
+// schema/post.prisma
+model Post {
+  id       String @id @default(uuid())
+  title    String
+  authorId String
+  author   User   @relation(fields: [authorId], references: [id], onDelete: Cascade)
+
+  @@index([authorId])
+  @@map("posts")
+}
+```
+
+```prisma
+// WITHOUT FK/PK — Prisma emulates the relation, DB has no constraints
+// schema/base.prisma
+datasource db {
+  provider     = "postgresql"
+  url          = env("DATABASE_URL")
+  relationMode = "prisma"
+}
+
+// schema/post.prisma
+model Post {
+  id       String @id @default(uuid())
+  title    String
+  authorId String // plain scalar — no FK constraint in the DB
+  author   User   @relation(fields: [authorId], references: [id])
+
+  @@index([authorId])
+  @@map("posts")
+}
+// integrity (author must exist) enforced in code + transactions — see SKILL.md
+```
+
+## Indexes & Constraints
+
+- Add `@@index` for frequently filtered/sorted fields and composite `@@index([a, b])` for common multi-field queries.
+- Add `@@unique` / `@unique` for data that must be unique (email, slug) — enforce in the database, not only in code.
+- Never duplicate or redundant indexes — one index per access pattern.
+- Keep nullable/required aligned across schema, DTO validation, and application types — inconsistent nullability is a bug source.
+
+## Migrations
+
+- Name migrations after what they do (`add_user_role`, not `update`) — one logical change per migration.
+- Schema changes that need existing rows rewritten ship with a data migration — never lose rows silently.
+- Changing a field type or dropping a column requires a backfill/dual-write plan when the table has data.
+- Never hand-edit `migration.sql` of an applied migration — revert with a new migration instead.

package/skills/registry.json

@@ -1,15 +1,56 @@
 {
   "name": "andev-skills",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "AI agent skills by thaiannguyen-05",
   "skills": [
     {
       "name": "improve-codenase-systems",
       "description": "Scan codebase for architecture issues and deepening opportunities",
       "version": "1.0.0",
-      "tags": ["architecture", "review", "nestjs", "react", "codebase"],
-      "path": "skills/improve-codenase-systems",
-      "files": ["SKILL.md", "HTML-REPORT.md", "agents/openai.yaml"]
+      "tags": [
+        "architecture",
+        "review",
+        "nestjs",
+        "react",
+        "codebase"
+      ],
+      "path": "skills/enhance/improve-codenase-systems",
+      "files": [
+        "SKILL.md",
+        "HTML-REPORT.md",
+        "agents/openai.yaml"
+      ]
+    },
+    {
+      "name": "nestjs",
+      "description": "NestJS backend rules — Fastify platform, module structure, zod validation",
+      "version": "1.0.0",
+      "tags": [
+        "nestjs",
+        "backend",
+        "typescript"
+      ],
+      "path": "skills/backend/nestJS",
+      "files": [
+        "SKILL.md",
+        "references/nestjs-module.md"
+      ]
+    },
+    {
+      "name": "prisma",
+      "description": "Prisma ORM rules — client setup, queries, errors, transactions, migrations",
+      "version": "1.0.0",
+      "tags": [
+        "prisma",
+        "database",
+        "orm"
+      ],
+      "path": "skills/infrastructure/prisma",
+      "files": [
+        "SKILL.md",
+        "references/prisma-queries.md",
+        "references/prisma-schema.md"
+      ]
     }
   ]
 }

package/RULES.md

@@ -1,253 +0,0 @@
-# Rules for TypeScript & NestJS
-
-## TypeScript
-
-- Use `strict: true` in `tsconfig.json`
-- No `any` type — use `unknown` and narrow with type guards
-- Use `interface` for object shapes, `type` for unions/intersections
-- Prefer `readonly` for immutable data
-- Avoid type assertions (`as`) — use type guards or `satisfies` instead
-- Use `!` non-null assertion only when value is guaranteed (add comment why)
-- Export types from barrel files (`index.ts`)
-
-## NestJS
-
-- Use CLI to generate: `nest g module`, `nest g controller`, `nest g service`
-- One module per feature (e.g., `users/`, `auth/`, `orders/`)
-- Controllers handle HTTP — no business logic in controllers
-- Services handle business logic — no HTTP concerns in services
-- Use `@nestjs/swagger` decorators on DTOs and controllers
-- Inject dependencies via constructor — never instantiate manually
-- Use `@InjectRepository()` for TypeORM/Prisma repositories
-- Use guards for auth (`@UseGuards`), interceptors for logging/transformation
-- Use `ConfigModule` for environment variables — no `process.env` in code
-- Use `@nestjs/schedule` for cron jobs — no `setInterval`
-
-## Types
-
-- Every module must have a `types.ts` file for module-specific types
-- Export all types from `types.ts` — import from there in other files
-- Use `type.ts` for: enums, interfaces, type aliases, return types
-- Do NOT put types in `dto/` — DTOs are for validation, types are for contracts
-- Import pattern: `import { UserRole } from './types'`
-- Put constants in `types.ts`: event names, URLs, status codes, config values
-- Use `enum` for constants — no hardcoded strings in business logic
-
-```typescript
-// types.ts
-export enum EventName {
-  CREATED = 'user.created',
-  UPDATED = 'user.updated',
-  DELETED = 'user.deleted',
-}
-
-export enum ApiUrl {
-  BASE = '/api/v1',
-  USERS = '/api/v1/users',
-}
-
-export interface User { id: string; name: string; }
-```
-
-## Validation
-
-- Handle ALL validation before controller and service
-- Use global `ValidationPipe` in `main.ts` — reject invalid requests early
-- Use `class-validator` decorators on DTOs
-- Use `class-transformer` with `ValidationPipe` globally
-- Validate nested objects with `@ValidateNested()`
-- Use `@IsString()`, `@IsNumber()`, `@IsEmail()`, `@IsOptional()` etc.
-- Controllers and services receive only valid data — no validation logic inside
-- Use `WhitelistStrategy` + `ForbidNonWhitelisted` to reject unknown fields
-- Use `TransformPipe` to auto-transform payloads to DTO instances
-
-```typescript
-// main.ts
-app.useGlobalPipes(
-  new ValidationPipe({
-    whitelist: true,
-    forbidNonWhitelisted: true,
-    transform: true,
-  }),
-);
-```
-
-## Error Handling
-
-- Handle errors with exceptions — use custom `AppException` classes
-- Create `src/error/` directory with exception classes and global filter
-- `errorCode` = uppercase snake_case (e.g., `RESOURCE_NOT_FOUND`)
-- Always return consistent JSON: `{ statusCode, timestamp, path, message, errorCode?, details? }`
-- Log unhandled (non-HttpException) errors with logger
-- Create helper files for domain-specific error scenarios
-
-```typescript
-// app.exception.ts
-export class AppException extends HttpException {
-  constructor(
-    message: string,
-    statusCode: HttpStatus,
-    public readonly errorCode?: string,
-    public readonly details?: unknown,
-  ) {
-    super({ message, errorCode, details, timestamp: new Date().toISOString() }, statusCode);
-  }
-}
-
-export class ResourceNotFoundException extends AppException {
-  constructor(resourceType: string, identifier: string | number) {
-    super(`${resourceType} with identifier ${identifier} not found`, HttpStatus.NOT_FOUND, 'RESOURCE_NOT_FOUND');
-  }
-}
-```
-
-```typescript
-// main.ts
-app.useGlobalFilters(new GlobalExceptionFilter(logger));
-```
-
-## Database
-
-- Use Prisma or TypeORM — pick one, don't mix
-- Keep migrations in `prisma/migrations` or `src/migrations`
-- Use repositories or Prisma client for data access
-- Never write raw SQL unless performance-critical (add comment why)
-- Use `select` when only a subset of fields is required — don't over-fetch
-- Avoid N+1 queries — use `include` or joins, not loops
-- Run independent queries in parallel — don't `await` sequentially
-- Use `findFirst` only when `findUnique` is possible
-- Paginate `findMany` — never return unbounded results
-- Use cursor pagination for large datasets, offset for small
-- Always `orderBy` deterministic fields for pagination
-- Handle Prisma errors — never leak raw Prisma errors to API responses
-- Use transactions for multi-step operations — no partial writes
-- Keep transaction scope small — no external calls inside transactions
-- Race conditions on read-modify-write — use transactions or locks
-- Add unique constraints for data that must be unique
-- Soft-delete: always filter `deletedAt` in queries
-- Avoid `include` for large relation collections — paginate or select
-
-## Testing
-
-- Use Jest (built into NestJS)
-- Unit tests: `*.spec.ts` next to source files
-- E2E tests: `test/*.e2e-spec.ts`
-- Mock dependencies with `@nestjs/testing` `Test.createTestingModule()`
-- Test controllers and services separately
-- Use `supertest` for HTTP assertions in e2e
-
-## Async & Concurrency
-
-- Run independent async operations in parallel — don't `await` sequentially
-- Always handle promise rejections — no fire-and-forget without error handling
-- Add timeout for external service calls
-- Use idempotency keys for retryable operations
-- Retry with limits and exponential backoff
-- Never retry non-idempotent operations unsafely
-- Race conditions: use transactions or locks for read-modify-write
-
-## Security
-
-- Never hardcode secrets or credentials — use `ConfigModule`
-- Never expose sensitive data in API responses
-- Validate and sanitize all user input
-- Prevent IDOR — check resource ownership
-- Use parameterized queries — no raw SQL concatenation
-- Validate file uploads: size, type, content
-- Never trust client-provided file metadata
-- Secure CORS configuration — no wildcard in production
-- Rate limit sensitive endpoints (login, register, password reset)
-- Never log sensitive data (passwords, tokens, PII)
-- Use guards for auth — no manual auth checks in controllers
-
-## API Design
-
-- Consistent REST naming: plural nouns, HTTP verbs for actions
-- Consistent error response format: `{ statusCode, message, errorCode }`
-- Paginate all list endpoints — no unbounded responses
-- Filter and limit query parameters
-- Version API when making breaking changes
-- Use appropriate HTTP status codes (201 for create, 204 for delete)
-- Never expose internal implementation details in responses
-
-## Observability
-
-- Use structured logging (nestjs-pino)
-- Never log sensitive data
-- Propagate request/correlation IDs
-- Add health check endpoints for critical dependencies
-- Handle graceful shutdown — clean up connections
-- Clean up timers, listeners, subscriptions
-- Handle background job failures
-
-## File Structure
-
-```
-andev-skill-agent/
-├── .git/
-├── package.json        # @thaiannguyen-05/opencode-rules
-├── plugin.js           # trigger detection + GitHub fetch
-├── README.md           # usage docs
-└── RULES.md            # this file — rules for agents
-```
-
-### NestJS Project Structure
-
-```
-src/
-├── app.module.ts
-├── main.ts
-├── config/
-│   └── configuration.ts
-├── common/
-│   ├── guards/
-│   ├── interceptors/
-│   ├── pipes/
-│   └── decorators/
-├── error/
-│   ├── app.exception.ts
-│   ├── global.exception.ts
-│   └── [domain]-error.helper.ts
-├── modules/
-│   ├── users/
-│   │   ├── users.module.ts
-│   │   ├── users.controller.ts
-│   │   ├── users.service.ts
-│   │   ├── types.ts
-│   │   ├── dto/
-│   │   └── entities/
-│   ├── auth/
-│   │   ├── auth.module.ts
-│   │   ├── auth.controller.ts
-│   │   ├── auth.service.ts
-│   │   ├── types.ts
-│   │   ├── dto/
-│   │   └── entities/
-│   └── orders/
-│       ├── orders.module.ts
-│       ├── orders.controller.ts
-│       ├── orders.service.ts
-│       ├── types.ts
-│       ├── dto/
-│       └── entities/
-```
-
-## Code Style
-
-- Use Prettier for formatting
-- Use ESLint with `@typescript-eslint` rules
-- Max 300 lines per file — split if超过
-- One export per file — no barrel exports in middle of file
-- Sort imports: node builtins → external → internal → relative
-- Use `path aliases` (`@/`) for clean imports
-- Prefer `async/await` over `.then()` chains
-- Use `enum` for constants — no hardcoded strings
-
-```json
-// .eslintrc
-{
-  "rules": {
-    "max-lines": ["error", { "max": 300, "skipBlankLines": true, "skipComments": true }]
-  }
-}
-```