lapeh 2.2.1 → 2.2.3

package/doc/FEATURES.md

@@ -0,0 +1,165 @@
+# Fitur & Konsep Inti
+
+Dokumen ini menjelaskan fitur-fitur utama Lapeh Framework dan cara penggunaannya secara mendalam.
+
+## 1. Validasi Data (Laravel-Style)
+
+Framework ini menyediakan utility `Validator` yang terinspirasi dari Laravel, menggunakan `zod` di belakang layar namun dengan API yang lebih string-based dan mudah dibaca.
+
+**Lokasi:** `@/utils/validator`
+
+### Penggunaan Dasar
+
+```typescript
+import { Validator } from "@/utils/validator";
+
+export async function createProduct(req: Request, res: Response) {
+  const validator = await Validator.make(req.body, {
+    name: "required|string|min:3",
+    price: "required|number|min:1000",
+    email: "required|email|unique:user,email", // Cek unik di tabel user kolom email
+    category_id: "required|exists:category,id", // Cek exist di tabel category kolom id
+    photo: "required|image|max:2048", // Validasi file upload (Max 2MB)
+  });
+
+  if (validator.fails()) {
+    return sendError(res, 400, "Validation failed", validator.errors());
+  }
+
+  const data = validator.validated();
+  // Lanjut proses simpan...
+}
+```
+
+### Aturan Tersedia (Rules)
+
+- `required`: Wajib diisi.
+- `string`, `number`, `boolean`: Tipe data.
+- `email`: Format email valid.
+- `min:X`, `max:X`: Panjang string atau nilai number.
+- `unique:table,column`: Pastikan nilai belum ada di database (Async).
+- `exists:table,column`: Pastikan nilai ada di database (Async).
+- `image`: File harus berupa gambar (jpg, png, webp, dll).
+- `mimes:types`: File harus tipe tertentu (misal: `mimes:pdf,docx`).
+
+## 2. High Performance Response (Fastify-Style)
+
+Untuk endpoint yang membutuhkan performa tinggi (misalnya list data besar), gunakan serialisasi berbasis schema. Ini jauh lebih cepat daripada `res.json` standar Express.
+
+**Lokasi:** `@/utils/response`, `@/core/serializer`
+
+### Langkah Implementasi
+
+1. **Definisikan Schema Output**
+   Sesuaikan dengan field yang ingin ditampilkan ke user.
+
+   ```typescript
+   const productSchema = {
+     type: "object",
+     properties: {
+       id: { type: "string" }, // BigInt otomatis jadi string
+       name: { type: "string" },
+       price: { type: "number" },
+     },
+   };
+   ```
+
+2. **Buat Serializer (Cached)**
+   Simpan di luar handler function agar dicompile sekali saja.
+
+   ```typescript
+   import { getSerializer, createResponseSchema } from "@/core/serializer";
+
+   const productSerializer = getSerializer(
+     "product-single",
+     createResponseSchema(productSchema)
+   );
+   ```
+
+3. **Kirim Response**
+
+   ```typescript
+   import { sendFastSuccess } from "@/utils/response";
+
+   // Di dalam controller
+   sendFastSuccess(res, 200, productSerializer, {
+     status: "success",
+     message: "Data retrieved",
+     data: productData,
+   });
+   ```
+
+## 3. Authentication & Authorization (RBAC)
+
+Sistem autentikasi menggunakan JWT (JSON Web Token) dan mendukung Role-Based Access Control.
+
+### Middleware Auth
+
+- `requireAuth`: Memastikan user login (mengirim header `Authorization: Bearer <token>`).
+- `requireAdmin`: Memastikan user login DAN memiliki role `admin` atau `super_admin`.
+
+**Contoh di Route:**
+
+```typescript
+import { requireAuth, requireAdmin } from "@/middleware/auth";
+
+router.get("/profile", requireAuth, getProfile); // Login only
+router.delete("/users/:id", requireAuth, requireAdmin, deleteUser); // Admin only
+```
+
+### Helper RBAC (Role Based Access Control)
+
+Anda bisa mengecek permission secara granular di dalam controller:
+
+```typescript
+// (Contoh implementasi, logic ada di AuthController/RbacController)
+if (req.user.role !== "manager") {
+  return sendError(res, 403, "Forbidden");
+}
+```
+
+## 4. Caching & Redis
+
+Framework ini memiliki integrasi Redis "Zero-Config".
+
+- Jika `REDIS_URL` ada di `.env` dan server Redis berjalan, framework akan connect.
+- Jika tidak ada atau gagal connect, framework otomatis fallback ke **In-Memory Mock**. Ini membuat development di local tidak wajib install Redis.
+
+**Mengakses Redis:**
+
+```typescript
+import { redis } from "@/core/redis";
+
+// Set cache (1 jam)
+await redis.set("my-key", "value", "EX", 3600);
+
+// Get cache
+const val = await redis.get("my-key");
+```
+
+## 5. Keamanan (Security)
+
+Secara default, framework sudah menerapkan:
+
+- **Helmet**: Mengamankan HTTP headers.
+- **CORS**: Mengizinkan akses lintas domain (configurable).
+- **Rate Limiting**: Membatasi jumlah request per IP untuk mencegah DDoS/Brute Force.
+  - Konfigurasi ada di `src/middleware/rateLimit.ts`.
+  - Default: 100 request / 15 menit.
+
+## 6. Import Path Aliases
+
+Gunakan `@/` untuk import module agar kode lebih bersih.
+
+- `@/core` -> `src/core`
+- `@/controllers` -> `src/controllers`
+- `@/utils` -> `src/utils`
+- `@/middleware` -> `src/middleware`
+
+**Contoh:**
+
+```typescript
+import { prisma } from "@/core/database"; // ✅ Rapi
+// vs
+import { prisma } from "../../../core/database"; // ❌ Berantakan
+```

package/doc/GETTING_STARTED.md

@@ -0,0 +1,108 @@
+# Getting Started with Lapeh Framework
+
+Selamat datang di dokumentasi resmi **Lapeh Framework**. Panduan ini akan membantu Anda memulai instalasi, konfigurasi, dan pemahaman dasar tentang struktur proyek.
+
+## Persyaratan Sistem
+
+Sebelum memulai, pastikan sistem Anda memenuhi persyaratan berikut:
+
+- **Node.js**: Versi 18.x atau lebih baru.
+- **Database**: PostgreSQL (Recommended) atau MySQL/MariaDB.
+- **Package Manager**: NPM (bawaan Node.js).
+
+## Instalasi
+
+Cara termudah untuk memulai adalah menggunakan CLI generator `npx`.
+
+### 1. Buat Project Baru
+
+Jalankan perintah berikut di terminal Anda:
+
+```bash
+npx lapeh@latest nama-project-anda
+```
+
+Atau untuk setup lengkap (dengan data dummy user & role):
+
+```bash
+npx lapeh@latest nama-project-anda --full
+```
+
+### 2. Setup Awal
+
+Setelah project dibuat, masuk ke direktori project dan jalankan setup wizard:
+
+```bash
+cd nama-project-anda
+npm run first
+```
+
+Script ini akan melakukan hal-hal berikut secara otomatis:
+
+1.  Menyalin `.env.example` ke `.env`.
+2.  Menginstall semua dependency (`npm install`).
+3.  Membuat **JWT Secret** yang aman.
+4.  Menjalankan migrasi database (membuat tabel).
+5.  Menjalankan seeder (mengisi data awal).
+
+### 3. Jalankan Server Development
+
+```bash
+npm run dev
+```
+
+Server akan berjalan di `http://localhost:4000` (atau port yang Anda tentukan di `.env`).
+
+## Struktur Direktori
+
+Berikut adalah struktur folder standar Lapeh Framework:
+
+```
+my-app/
+├── bin/                  # Script CLI untuk npx
+├── doc/                  # Dokumentasi proyek
+├── prisma/               # Konfigurasi Database & Schema
+│   ├── migrations/       # File history migrasi database
+│   ├── base.prisma.template # Template konfigurasi database
+│   ├── schema.prisma     # File schema gabungan (Auto-generated)
+│   └── seed.ts           # Script untuk mengisi data awal
+├── scripts/              # Script utility (Generator, Compiler)
+├── src/                  # Source code utama aplikasi
+│   ├── controllers/      # Logika bisnis (Handler request)
+│   ├── core/             # Konfigurasi inti (DB, Redis, Server)
+│   ├── middleware/       # Middleware Express (Auth, RateLimit)
+│   ├── models/           # Definisi Schema Prisma per-fitur
+│   ├── routes/           # Definisi routing API
+│   ├── utils/            # Helper function (Response, Validator)
+│   └── index.ts          # Entry point aplikasi
+├── .env                  # Variabel lingkungan (Rahasia)
+├── package.json          # Dependensi & Script NPM
+└── tsconfig.json         # Konfigurasi TypeScript
+```
+
+## Konfigurasi Environment (.env)
+
+File `.env` menyimpan konfigurasi penting. Berikut adalah variabel kunci:
+
+```ini
+# Server
+PORT=4000
+NODE_ENV=development
+
+# Database (Ganti sesuai kredensial Anda)
+DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"
+
+# Security
+JWT_SECRET="rahasia-super-panjang-dan-acak"
+ACCESS_TOKEN_EXPIRES_IN=3600 # 1 jam
+
+# Redis (Opsional - otomatis mock jika tidak ada)
+REDIS_URL="redis://localhost:6379"
+NO_REDIS=false # Set true untuk memaksa mode mock
+```
+
+## Langkah Selanjutnya
+
+- Pelajari cara menggunakan **[CLI Tools](CLI.md)** untuk mempercepat development.
+- Pahami **[Fitur & Konsep Inti](FEATURES.md)** framework.
+- Ikuti **[Tutorial Studi Kasus](TUTORIAL.md)** untuk membangun fitur nyata.

package/doc/INTRODUCTION.md

@@ -0,0 +1,60 @@
+# Pengenalan Lapeh Framework
+
+## Apa itu Lapeh?
+
+**Lapeh** adalah framework Backend untuk Node.js yang dibangun di atas **Express** dan **TypeScript**.
+
+Jika Anda pernah menggunakan **Laravel** (PHP) atau **NestJS** (Node.js), Anda akan merasa sangat familiar. Lapeh mengambil filosofi kemudahan & struktur rapi dari Laravel, namun tetap mempertahankan fleksibilitas dan kecepatan Express.
+
+Nama "Lapeh" diambil dari bahasa Minang yang berarti "Lepas" atau "Bebas", melambangkan kebebasan developer untuk membangun aplikasi dengan cepat tanpa terbebani konfigurasi yang rumit.
+
+## Mengapa Lapeh Dibuat?
+
+Di ekosistem Node.js, developer sering mengalami "Decision Fatigue" (Kelelahan memilih):
+- "Pakai ORM apa? Prisma, TypeORM, atau Drizzle?"
+- "Validasi pakai Joi, Zod, atau express-validator?"
+- "Struktur foldernya gimana? MVC? Clean Architecture?"
+- "Auth-nya gimana?"
+
+Lapeh menjawab semua itu dengan **Opinionated Defaults**:
+1.  **ORM**: Prisma (Standar industri saat ini).
+2.  **Validasi**: Zod (dengan wrapper syntax ala Laravel).
+3.  **Struktur**: MVC Modular (Controller, Model, Route terpisah tapi kohesif).
+4.  **Auth**: JWT + RBAC (Role Based Access Control) siap pakai.
+
+## Perbandingan dengan Framework Lain
+
+| Fitur | Express (Raw) | NestJS | Lapeh Framework |
+| :--- | :--- | :--- | :--- |
+| **Learning Curve** | Rendah (tapi bingung struktur) | Tinggi (Angular-style, Decorators) | **Sedang** (Express + Struktur Jelas) |
+| **Boilerplate** | Kosong | Sangat Banyak | **Pas (Ready to use)** |
+| **Type Safety** | Manual | Strict | **Strict (TypeScript Native)** |
+| **Kecepatan Dev** | Lambat (setup manual) | Sedang | **Cepat (CLI Generator)** |
+| **Fleksibilitas** | Sangat Tinggi | Kaku | **Tinggi** |
+
+## Filosofi "The Lapeh Way"
+
+1.  **Developer Experience (DX) First**: CLI tools, error message yang jelas, dan hot-reload adalah prioritas.
+2.  **Performance by Default**: Serialisasi JSON cepat (Fastify-style) dan Redis caching terintegrasi.
+3.  **Explicit is Better than Implicit**: Tidak ada "sihir" yang terlalu gelap. Kode controller Anda adalah kode Express biasa yang Anda mengerti.
+4.  **Production Ready**: Security (Helmet, Rate Limit) dan Scalability (Docker, Cluster) bukan pikiran belakangan, tapi bawaan.
+
+## Siklus Hidup Request (Request Lifecycle)
+
+Bagaimana Lapeh menangani satu permintaan dari user?
+
+1.  **Request Masuk** (`GET /api/users`)
+2.  **Security Middleware**: Helmet (Headers), CORS, Rate Limiter.
+3.  **Global Middleware**: Request Logger, Body Parser (JSON).
+4.  **Routing**: Mencocokkan URL di `src/routes/`.
+5.  **Auth Middleware** (Opsional): Cek token JWT & Role.
+6.  **Validator** (Opsional): Validasi input body/query.
+7.  **Controller**: Logika bisnis utama dijalankan.
+    - Panggil Database (Prisma).
+    - Panggil Cache (Redis).
+8.  **Serializer**: Data diformat & disanitasi (misal: hide password).
+9.  **Response**: JSON dikirim kembali ke user.
+
+---
+
+**Selanjutnya:** Pelajari struktur folder di [Struktur Proyek](STRUCTURE.md).

package/doc/PACKAGES.md

@@ -0,0 +1,66 @@
+# Referensi Package & Dependencies
+
+Dokumen ini menjelaskan fungsi dari setiap library (package) yang terinstall di Lapeh Framework, sehingga Anda mengerti kegunaan "alat-alat" yang ada di dalam kotak peralatan Anda.
+
+## Core Framework (Fondasi)
+
+Package-package ini adalah nyawa dari framework ini.
+
+| Package | Deskripsi | Kenapa Kita Pakai? |
+| :--- | :--- | :--- |
+| **`express`** | Web Framework untuk Node.js. | Standar industri, ringan, dan komunitasnya terbesar. |
+| **`dotenv`** | Memuat variabel dari file `.env`. | Agar konfigurasi rahasia (DB password, API Key) tidak di-hardcode. |
+| **`cors`** | Cross-Origin Resource Sharing. | Mengizinkan frontend (React/Vue) dari domain berbeda untuk mengakses API kita. |
+| **`helmet`** | Middleware keamanan HTTP headers. | Melindungi aplikasi dari serangan umum (XSS, Clickjacking) dengan mengatur header HTTP secara otomatis. |
+
+## Database & ORM
+
+| Package | Deskripsi | Kenapa Kita Pakai? |
+| :--- | :--- | :--- |
+| **`@prisma/client`** | Query builder & ORM. | Type-safe query database. Autocomplete-nya sangat membantu developer. |
+| **`pg`** | Driver PostgreSQL. | Driver native untuk koneksi ke database Postgres. |
+| **`@prisma/adapter-*`** | Adapter serverless. | (Opsional) Persiapan untuk deployment ke environment serverless (seperti Vercel/Neon). |
+
+## Authentication & Security
+
+| Package | Deskripsi | Kenapa Kita Pakai? |
+| :--- | :--- | :--- |
+| **`jsonwebtoken`** | Implementasi JWT. | Standar token untuk autentikasi stateless (API). |
+| **`bcryptjs`** | Hashing password. | Mengamankan password user di database (satu arah). |
+| **`express-rate-limit`** | Pembatas request. | Mencegah serangan DDoS ringan atau Brute Force login. |
+
+## Utilities & Helper
+
+| Package | Deskripsi | Kenapa Kita Pakai? |
+| :--- | :--- | :--- |
+| **`zod`** | Schema validation library. | Memvalidasi input user (req.body) dengan syntax yang kuat dan mudah dibaca. |
+| **`fast-json-stringify`** | Serializer JSON cepat. | Mengubah object ke JSON string 2x-3x lebih cepat dari `JSON.stringify` bawaan. |
+| **`uuid`** | Generator ID unik. | Membuat string acak unik (UUID v4). |
+| **`slugify`** | String formatter. | Mengubah "Judul Artikel Keren" menjadi `judul-artikel-keren` (URL friendly). |
+| **`multer`** | Middleware upload file. | Menangani `multipart/form-data` untuk upload gambar/dokumen. |
+| **`winston`** | Logger library. | Mencatat log aplikasi (error/info) ke file atau console dengan format rapi. |
+
+## Realtime & Caching
+
+| Package | Deskripsi | Kenapa Kita Pakai? |
+| :--- | :--- | :--- |
+| **`socket.io`** | Library WebSocket. | Fitur komunikasi real-time dua arah (chat, notifikasi live). |
+| **`ioredis`** | Client Redis yang robust. | Driver terbaik untuk Redis di Node.js. |
+| **`ioredis-mock`** | Simulasi Redis di memori. | Memungkinkan development tanpa perlu install Redis server asli (sangat berguna untuk pemula). |
+
+## Development Tools (DevDependencies)
+
+Package ini hanya dipakai saat koding, tidak ikut terinstall di server production.
+
+| Package | Deskripsi | Fungsi |
+| :--- | :--- | :--- |
+| **`typescript`** | Compiler TS. | Mengubah kode `.ts` menjadi `.js`. |
+| **`nodemon`** | Auto-restarter. | Restart server otomatis setiap kita save file. |
+| **`eslint`** | Linter (Polisi Kode). | Mencari potensi error dan variabel yang tidak terpakai. |
+| **`@types/*`** | Definisi Tipe. | Memberikan intellisense (saran kode) untuk library JavaScript biasa. |
+| **`prisma`** | Prisma CLI. | Alat untuk migrasi database (`prisma migrate`) dan generate client. |
+| **`tsc-alias`** | Path resolver. | Mengubah alias `@/core` menjadi path relatif `../core` saat build production. |
+
+---
+
+Dengan memahami daftar ini, Anda tahu persis apa yang terjadi di balik layar aplikasi Anda. Tidak ada "Bloatware", setiap package punya tujuan spesifik.

package/doc/PERFORMANCE.md

@@ -0,0 +1,91 @@
+# Panduan Performa & Skalabilitas Lapeh Framework
+
+Dokumen ini menjelaskan cara memaksimalkan performa aplikasi Lapeh Anda menggunakan fitur-fitur canggih seperti Fast-Serialization dan Clustering.
+
+## 1. High Performance Serialization (Fastify-Style)
+
+Express secara default menggunakan `JSON.stringify()` yang lambat karena harus memeriksa tipe data setiap field secara runtime. Lapeh mengadopsi teknik **Schema Based Serialization** (seperti Fastify) yang bisa meningkatkan throughput JSON hingga **2x-3x lipat**.
+
+### Cara Penggunaan
+
+Gunakan `sendFastSuccess` di controller Anda untuk endpoint yang membutuhkan performa tinggi (misalnya: list data yang besar).
+
+```typescript
+import { Request, Response } from "express";
+import { getSerializer, createResponseSchema } from "../core/serializer";
+import { sendFastSuccess } from "../utils/response";
+
+// 1. Definisikan Schema Output (JSON Schema Standard)
+const userSchema = {
+  type: "object",
+  properties: {
+    id: { type: "integer" },
+    name: { type: "string" },
+    email: { type: "string" },
+    // Password tidak dimasukkan, jadi otomatis tidak akan terkirim (aman!)
+  }
+};
+
+// 2. Compile Serializer (Otomatis dicache oleh framework)
+const userListSerializer = getSerializer("user-list", createResponseSchema({
+  type: "array",
+  items: userSchema
+}));
+
+export async function getUsers(req: Request, res: Response) {
+  const users = await prisma.users.findMany();
+
+  // 3. Kirim response super cepat
+  return sendFastSuccess(res, 200, userListSerializer, {
+    status: "success",
+    message: "Data fetched",
+    data: users
+  });
+}
+```
+
+---
+
+## 2. Horizontal Scaling (Load Balancer & Cluster)
+
+Lapeh dirancang untuk siap di-scale secara horizontal (menambah jumlah server, bukan memperbesar spesifikasi server).
+
+### Arsitektur Cluster
+- **Nginx**: Bertindak sebagai Load Balancer yang membagi trafik ke server-server aplikasi.
+- **Redis**: Menyimpan Session, Rate Limit, dan Cache agar bisa diakses oleh semua server (Shared State).
+- **App Instances**: Beberapa instance aplikasi Lapeh yang berjalan paralel.
+
+### Cara Menjalankan Cluster (Docker)
+
+Kami telah menyediakan konfigurasi siap pakai di `docker-compose.cluster.yml`.
+
+1. **Build & Run Cluster**:
+   ```bash
+   docker-compose -f docker-compose.cluster.yml up --build
+   ```
+
+2. **Akses Aplikasi**:
+   Buka `http://localhost:8080`.
+   Nginx akan otomatis membagi request Anda ke `app-1` atau `app-2`.
+
+3. **Cek Status**:
+   ```bash
+   docker-compose -f docker-compose.cluster.yml ps
+   ```
+
+### Konfigurasi Rate Limiter Terdistribusi
+Middleware `src/middleware/rateLimit.ts` telah diupdate untuk menggunakan Redis Store.
+Ini artinya jika User A terkena limit di Server 1, dia juga akan terblokir di Server 2.
+
+```typescript
+// src/middleware/rateLimit.ts
+store: redis ? new RedisStore({ sendCommand: ... }) : undefined
+```
+
+---
+
+## 3. Tips Optimasi Lainnya
+
+- **Gunakan `.lean()` / Select**: Saat query database, selalu pilih field yang dibutuhkan saja.
+- **Compression**: Aktifkan gzip/brotli di Nginx (sudah ada di config default Nginx umumnya).
+- **Keep-Alive**: Gunakan koneksi database yang persistent (sudah dihandle oleh Prisma).

package/doc/ROADMAP.md

@@ -0,0 +1,93 @@
+# Roadmap & Future Requests (Rencana Pengembangan)
+
+Dokumen ini berisi daftar fitur yang direncanakan untuk membuat **Lapeh Framework** setara dengan framework backend enterprise lainnya (seperti NestJS, Laravel, atau Django).
+
+Ini adalah **Undangan Terbuka** bagi para kontributor! Jika Anda tertarik mengerjakan salah satu fitur di bawah ini, silakan buat Issue/PR.
+
+---
+
+## 🏗️ Core & Architecture
+
+### 1. Dependency Injection (DI) Container
+*   **Tujuan**: Membuat kode lebih testable dan modular.
+*   **Konsep**: Saat ini Lapeh menggunakan pendekatan import langsung. Implementasi DI sederhana (seperti `InversifyJS` atau custom container) akan memudahkan unit testing dan decoupling.
+*   **Inspirasi**: NestJS Providers, Angular DI.
+
+### 2. Event Emitter (Pub/Sub)
+*   **Tujuan**: Decoupling logic antar modul.
+*   **Contoh**: Saat user register -> Emit event `UserRegistered` -> Listener `SendWelcomeEmail` & `CreateWallet` berjalan terpisah.
+*   **Status**: Belum ada (bisa pakai `eventemitter3`).
+
+### 3. API Documentation Generator (Swagger/OpenAPI)
+*   **Tujuan**: Auto-generate dokumentasi API interaktif.
+*   **Rencana**: Membaca file route dan validator schema, lalu men-generate spesifikasi Swagger UI secara otomatis di `/api/docs`.
+
+---
+
+## 🛠️ Fitur Enterprise (The "Missing" Parts)
+
+### 4. Job Queues & Background Workers
+*   **Tujuan**: Memproses tugas berat di background agar tidak memblokir HTTP request.
+*   **Teknologi**: Integrasi dengan **BullMQ** (Redis).
+*   **Fitur**:
+    *   Decorators/Helpers untuk mendefinisikan Job.
+    *   Dashboard monitoring job (seperti Horizon di Laravel).
+    *   Retry mechanism & Failed job handling.
+
+### 5. Task Scheduling (Cron Jobs)
+*   **Tujuan**: Menjalankan tugas berkala (misal: "Kirim rekap email setiap jam 12 malam").
+*   **Rencana**: Wrapper di atas `node-cron` yang terintegrasi dengan struktur framework.
+*   **CLI**: `npm run schedule:run`.
+
+### 6. Storage Abstraction Layer
+*   **Tujuan**: Satu interface untuk upload file ke berbagai provider (Local, AWS S3, Google Cloud Storage, MinIO).
+*   **Konsep**:
+    ```typescript
+    // Tidak peduli drivernya apa, kodenya sama:
+    await Storage.disk('s3').put('avatars/1.jpg', fileBuffer);
+    ```
+
+### 7. Mailer Service
+*   **Tujuan**: Standarisasi pengiriman email.
+*   **Fitur**:
+    *   Support SMTP, Mailgun, SES.
+    *   Support Template Engine (Handlebars/EJS) untuk body email.
+    *   Queue integration (kirim email di background).
+
+---
+
+## 🧪 Testing & Quality Assurance
+
+### 8. Native Testing Suite
+*   **Tujuan**: Memudahkan user menulis test.
+*   **Rencana**:
+    *   Integrasi **Vitest** atau **Jest** pre-configured.
+    *   Helper untuk HTTP Testing (supertest wrapper).
+    *   Helper untuk Database Transaction (rollback setelah test selesai).
+    *   Command: `npm run test`, `npm run make:test`.
+
+---
+
+## 🌐 Globalization & Security
+
+### 9. Localization (i18n)
+*   **Tujuan**: Mendukung respon API dalam berbagai bahasa.
+*   **Fitur**: Mendeteksi header `Accept-Language` dan mengembalikan pesan error/success sesuai bahasa user.
+
+### 10. API Versioning
+*   **Tujuan**: Mendukung multiple versi API (v1, v2) tanpa merusak klien lama.
+*   **Rencana**: Routing strategy berbasis URL prefix (`/api/v1/...`) atau Header.
+
+---
+
+## 💻 CLI Enhancements
+
+### 11. Interactive CLI (TUI)
+*   **Tujuan**: Membuat CLI lebih user friendly.
+*   **Ide**: Saat menjalankan `npx lapeh`, muncul menu interaktif untuk memilih fitur yang mau diinstall (pilih DB, pilih mau pakai Redis atau tidak, dll).
+
+---
+
+## Tertarik Berkontribusi?
+
+Pilih salah satu topik di atas, buat Issue di GitHub dengan judul `[Proposal] Nama Fitur`, dan mari kita diskusikan cara implementasinya! 🚀

package/doc/SECURITY.md

@@ -0,0 +1,93 @@
+# Security Best Practices (Panduan Keamanan)
+
+Keamanan bukan fitur tambahan, melainkan prioritas utama. Lapeh Framework sudah dikonfigurasi dengan standar keamanan yang baik (Secure by Default), namun Anda tetap perlu memahami cara menjaga aplikasi tetap aman.
+
+## 1. Perlindungan Bawaan (Built-in Protection)
+
+Secara default, Lapeh sudah mengaktifkan:
+
+### Helmet (HTTP Headers)
+
+Mengamankan aplikasi dari serangan umum web vulnerabilities dengan mengatur HTTP headers yang tepat.
+
+- **XSS Filter**: Aktif.
+- **Frameguard**: Mencegah Clickjacking.
+- **HSTS**: Memaksa browser menggunakan HTTPS (di production).
+
+### Rate Limiting
+
+Mencegah serangan _Brute Force_ dan _DDoS_ sederhana.
+
+- **Default**: 100 request per 15 menit per IP.
+- **Lokasi Config**: `src/middleware/rateLimit.ts`.
+
+### CORS (Cross-Origin Resource Sharing)
+
+Mengontrol domain mana yang boleh mengakses API Anda.
+
+- **Lokasi Config**: `src/core/server.ts`.
+- **Saran**: Di production, ubah `origin: "*"` menjadi domain frontend spesifik Anda (misal `origin: "https://frontend-anda.com"`).
+
+## 2. Praktik Terbaik Developer
+
+Framework tidak bisa melindungi dari kode yang buruk. Berikut hal yang WAJIB Anda lakukan:
+
+### a. Validasi Input (Wajib!)
+
+Jangan pernah mempercayai input user. Selalu gunakan `Validator`.
+
+**❌ Tidak Aman (Raw Query):**
+
+```typescript
+// Bahaya SQL Injection jika pakai raw query manual (walau Prisma aman, tetap hati-hati)
+const user =
+  await prisma.$queryRaw`SELECT * FROM users WHERE email = ${req.body.email}`;
+```
+
+**✅ Aman (Validator + Prisma Client):**
+
+```typescript
+const valid = await Validator.make(req.body, { email: "required|email" });
+// Prisma Client otomatis sanitize input
+const user = await prisma.user.findUnique({
+  where: { email: valid.validated().email },
+});
+```
+
+### b. Manajemen Password
+
+- **Hashing**: Jangan pernah simpan password plain text. Gunakan `bcryptjs` (sudah terintegrasi di AuthController).
+- **Strength**: Validasi password minimal 8 karakter.
+  ```typescript
+  password: "required|string|min:8";
+  ```
+
+### c. JWT & Session
+
+- **Secret Key**: Pastikan `JWT_SECRET` di `.env` adalah string acak yang panjang (32+ karakter).
+- **Expiration**: Token akses (`ACCESS_TOKEN_EXPIRES_IN`) sebaiknya pendek (misal 15 menit - 1 jam). Gunakan Refresh Token (fitur roadmap) untuk sesi panjang.
+
+### d. Error Handling
+
+Jangan pernah mengekspos detail error sistem (stack trace) ke user di Production.
+
+**❌ Buruk:**
+
+```typescript
+res.status(500).json({ error: err.message, stack: err.stack }); // Hacker bisa lihat struktur folder server
+```
+
+**✅ Aman (Lapeh Default):**
+Lapeh sudah menangani ini. Di mode `production`, error internal hanya akan menampilkan "Internal Server Error" tanpa detail sensitif.
+
+## 3. Checklist Sebelum Deploy
+
+- [ ] Pastikan `NODE_ENV=production` di server.
+- [ ] Ganti `JWT_SECRET` default dengan yang baru (`npm run generate:jwt`).
+- [ ] Batasi CORS origin hanya ke domain frontend Anda.
+- [ ] Pastikan database tidak bisa diakses publik (gunakan firewall/private IP).
+- [ ] Gunakan HTTPS (SSL/TLS). API tanpa HTTPS sangat mudah disadap.
+
+## 4. Melaporkan Celah Keamanan
+
+Jika Anda menemukan celah keamanan di framework ini, mohon **JANGAN** buat Issue publik. Kirim email langsung ke maintainer (lihat `package.json`) agar bisa diperbaiki (patched) sebelum diexploitasi orang jahat.