lapeh 2.6.17 → 3.0.2

package/doc/en/TUTORIAL.md

@@ -1,74 +1,51 @@
-# Tutorial: Membangun API Perpustakaan
+# Tutorial: Building a Library API
 
-Dalam tutorial ini, kita akan membangun fitur "Manajemen Buku" sederhana menggunakan semua fitur unggulan Lapeh Framework:
-1.  **CLI** untuk generate kode.
-2.  **Validator** untuk validasi input.
-3.  **Fast Serialization** untuk respon cepat.
-4.  **RBAC** untuk proteksi delete (Admin only).
+In this tutorial, we will build a simple "Book Management" feature using Lapeh Framework's core features:
+1.  **CLI** for code generation.
+2.  **Validator** for input validation.
+3.  **Fast Serialization** for high-performance responses.
 
-## Langkah 1: Generate Model Database
+> **Note**: This tutorial uses an in-memory array for data storage to keep things simple. Lapeh v3.0.0 is database-agnostic, so you can easily swap this with Prisma, TypeORM, or any other DB library.
 
-Kita butuh tabel `books`. Gunakan CLI `make:model`.
+## Step 1: Generate Module (Controller & Route)
 
-```bash
-npm run make:model Book
-```
-
-File baru akan muncul di `src/models/book.prisma`. Edit file tersebut:
-
-```prisma
-// src/models/book.prisma
-
-model Book {
-  id          BigInt   @id @default(autoincrement())
-  title       String
-  author      String
-  isbn        String   @unique
-  publishedAt DateTime
-  stock       Int      @default(0)
-  created_at  DateTime @default(now())
-  updated_at  DateTime @updatedAt
-
-  @@map("books")
-}
-```
-
-Terapkan perubahan ke database:
-
-```bash
-npm run prisma:migrate
-```
-
-## Langkah 2: Generate Module (Controller & Route)
-
-Kita buat controller dan route sekaligus.
+We will create a controller and route for our Book feature.
 
 ```bash
 npm run make:module Book
 ```
 
-Framework akan membuat:
+The framework will generate:
 - `src/controllers/bookController.ts`
 - `src/routes/book.ts`
 
-## Langkah 3: Implementasi Controller
+## Step 2: Implement Controller
 
-Buka `src/controllers/bookController.ts` dan kita implementasikan fitur **Create** dan **List** dengan standar framework.
+Open `src/controllers/bookController.ts` and let's implement **Create** and **List** features.
 
-### Setup Import & Serializer
+### Setup Import & Data Store
 
 ```typescript
 import { Request, Response } from "express";
-import { prisma } from "@/core/database";
 import { sendFastSuccess, sendError } from "@/utils/response";
 import { Validator } from "@/utils/validator";
 import { getSerializer, createResponseSchema } from "@/core/serializer";
 
-// 1. Definisikan Schema Output (untuk Fastify Serialization)
+// Simple in-memory store
+interface Book {
+  id: string;
+  title: string;
+  author: string;
+  isbn: string;
+  stock: number;
+}
+const books: Book[] = [];
+
+// 1. Define Output Schema (for Fastify Serialization)
 const bookSchema = {
   type: "object",
   properties: {
-    id: { type: "string" }, // BigInt -> String
+    id: { type: "string" },
     title: { type: "string" },
     author: { type: "string" },
     isbn: { type: "string" },
@@ -76,7 +53,7 @@ const bookSchema = {
   }
 };
 
-// 2. Buat Serializer
+// 2. Create Serializer
 const bookDetailSerializer = getSerializer("book-detail", createResponseSchema(bookSchema));
 const bookListSerializer = getSerializer("book-list", createResponseSchema({
   type: "array",
@@ -84,109 +61,74 @@ const bookListSerializer = getSerializer("book-list", createResponseSchema({
 }));
 ```
 
-### Implementasi Create (dengan Validasi)
+### Implement Create (with Validation)
 
 ```typescript
 export async function createBook(req: Request, res: Response) {
-  // 1. Validasi Input
+  // 1. Validate Input
   const validator = await Validator.make(req.body, {
     title: "required|string|min:3",
     author: "required|string",
-    isbn: "required|string|unique:books,isbn", // Cek unik di tabel books
-    stock: "required|number|min:1",
-    publishedAt: "required|string" // Format tanggal ISO
+    isbn: "required|string",
+    stock: "required|number|min:1"
   });
 
   if (validator.fails()) {
     return sendError(res, 400, "Validation Error", validator.errors());
   }
 
-  const data = validator.validated();
-
-  // 2. Simpan ke Database
-  const book = await prisma.book.create({
-    data: {
-      title: data.title,
-      author: data.author,
-      isbn: data.isbn,
-      stock: data.stock,
-      publishedAt: new Date(data.publishedAt)
-    }
-  });
+  // 2. Save Data (In-Memory)
+  const newBook: Book = {
+    id: Date.now().toString(),
+    ...validator.validated()
+  };
+  books.push(newBook);
 
-  // 3. Return Response Cepat
-  return sendFastSuccess(res, 201, bookDetailSerializer, {
-    status: "success",
-    message: "Buku berhasil ditambahkan",
-    data: { ...book, id: book.id.toString() } // Konversi BigInt manual jika perlu
-  });
+  // 3. Send Response (Serialized)
+  return sendFastSuccess(res, bookDetailSerializer(newBook), 201);
 }
-```
-
-### Implementasi List (High Performance)
-
-```typescript
-export async function getBooks(req: Request, res: Response) {
-  const books = await prisma.book.findMany({
-    take: 50, // Limit 50
-    orderBy: { created_at: "desc" }
-  });
-
-  // Convert BigInt to string sebelum passing ke serializer (opsional, tapi aman)
-  const safeBooks = books.map(b => ({ ...b, id: b.id.toString() }));
 
-  return sendFastSuccess(res, 200, bookListSerializer, {
-    status: "success",
-    message: "Daftar buku",
-    data: safeBooks
-  });
+export async function listBooks(req: Request, res: Response) {
+  // Return all books
+  return sendFastSuccess(res, bookListSerializer(books));
 }
 ```
 
-## Langkah 4: Daftarkan Route & Proteksi
+## Step 3: Register Route
 
-Buka `src/routes/book.ts` (atau file yang digenerate). Pastikan route terhubung dan tambahkan middleware auth.
+Open `src/routes/book.ts`. The CLI has already generated the basic structure. We just need to connect it to our controller functions.
 
 ```typescript
 import { Router } from "express";
-import { createBook, getBooks } from "../controllers/bookController";
-import { requireAuth, requireAdmin } from "../middleware/auth";
+import { createBook, listBooks } from "../controllers/bookController";
 
-export const bookRouter = Router();
+const router = Router();
 
-// Public route (bisa diakses siapa saja)
-bookRouter.get("/", getBooks);
+router.post("/", createBook);
+router.get("/", listBooks);
 
-// Admin only (Butuh login + role admin)
-bookRouter.post("/", requireAuth, requireAdmin, createBook);
+export default router;
 ```
 
-Terakhir, daftarkan router ini di `src/routes/index.ts` (jika belum otomatis):
+## Step 4: Test Your API
 
-```typescript
-import { bookRouter } from "./book";
-// ...
-router.use("/books", bookRouter);
+Run the server:
+```bash
+npm run dev
 ```
 
-## Langkah 5: Testing
+Test with curl or Postman:
 
-Jalankan server:
+**Create Book:**
 ```bash
-npm run dev
+curl -X POST http://localhost:4000/api/book \
+  -H "Content-Type: application/json" \
+  -d '{"title":"Lapeh Guide", "author":"Team", "isbn":"12345", "stock":10}'
 ```
 
-Coba hit endpoint:
-1. **POST /api/books** (Tanpa token) -> 401 Unauthorized.
-2. **POST /api/books** (Token User Biasa) -> 403 Forbidden.
-3. **POST /api/books** (Token Admin + Data Invalid) -> 400 Validation Error.
-4. **POST /api/books** (Token Admin + Data Valid) -> 201 Created.
-5. **GET /api/books** -> 200 OK (Super Cepat).
-
-## Kesimpulan
+**List Books:**
+```bash
+curl http://localhost:4000/api/book
+```
 
-Dengan Lapeh Framework, Anda telah membuat API yang:
-- **Aman** (Validasi, Auth, RBAC).
-- **Cepat** (Fast Serialization).
-- **Rapi** (Struktur terstandarisasi).
-- **Mudah** (CLI Generator).
+Congratulations! You have built a fast, validated API without getting bogged down in database configuration.

package/doc/id/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 File ini mencatat semua perubahan, pembaruan, dan perbaikan yang dilakukan pada framework Lapeh, diurutkan berdasarkan tanggal.
 
+## [2025-12-30] - Selasa, 30 Desember 2025 - Major Release v3.0.0 (No-ORM)
+
+### ⚠️ Perubahan Besar (Breaking Changes)
+
+- **Penghapusan Prisma ORM**: Lapeh Framework kini **tidak lagi menyertakan ORM bawaan** (seperti Prisma). Kami memberikan kebebasan penuh kepada pengguna untuk memilih stack database mereka sendiri (Prisma, TypeORM, Drizzle, dll).
+- **Update CLI**:
+  - `init`: Tidak lagi menanyakan konfigurasi database.
+  - `make:module`: Tidak lagi membuat file `.prisma`.
+  - Penghapusan script `compile-schema.js` dan logika terkait split-schema Prisma.
+
+### 🚀 Fitur & Refactor
+
+- **In-Memory Mock Data**: Modul bawaan (Auth, RBAC, Pets) kini menggunakan data dummy in-memory untuk demonstrasi tanpa perlu setup database.
+- **Redis Caching**: Implementasi caching Redis pada Pets controller.
+- **Dokumentasi**: Pembaruan menyeluruh pada dokumentasi untuk mencerminkan filosofi agnostik database.
+
 ## [2025-12-29] - Senin, 29 Desember 2025 - Perbaikan Bug CLI Init (v2.6.7)
 
 ### 🛠️ Perbaikan Bug

package/doc/id/CHEATSHEET.md

@@ -12,11 +12,7 @@ Referensi cepat untuk perintah dan kode yang sering digunakan.
 | **`npm run lint:fix`**               | Perbaiki kode kotor otomatis.                |
 | **`npm run make:module <Name>`**     | Buat Controller, Route, & Model sekaligus.   |
 | **`npm run make:controller <Name>`** | Buat Controller saja.                        |
-| **`npm run make:model <Name>`**      | Buat Model Prisma saja.                      |
-| **`npm run prisma:migrate`**         | Apply perubahan schema ke DB lokal.          |
-| **`npm run db:studio`**              | Buka GUI Database.                           |
 | **`npm run db:seed`**                | Isi data dummy.                              |
-| **`npm run db:reset`**               | Hapus DB & mulai dari nol.                   |
 
 ## 🛡️ Validator Rules (Simple Syntax)
 

package/doc/id/CLI.md

@@ -11,6 +11,7 @@ Semua perintah dijalankan menggunakan `npm run <command>`.
 Perintah utama untuk menjalankan aplikasi:
 
 ### 1. Inisialisasi Project (`init`)
+
 Membuat project baru dari awal.
 
 ```bash
@@ -18,11 +19,13 @@ npx lapeh@latest init <nama-project> [flags]
 ```
 
 **Flag Tersedia:**
+
 - `--full`: Inisialisasi dengan setup lengkap (termasuk dummy user, role, permission).
 - `--default`: Inisialisasi dengan konfigurasi default (PostgreSQL) melewati prompt interaktif.
 - `--y`: Alias untuk `--default`.
 
 **Contoh:**
+
 ```bash
 # Mode Interaktif
 npx lapeh init my-app
@@ -35,17 +38,21 @@ npx lapeh init my-app --y
 ```
 
 ### 2. Upgrade Framework (`upgrade`)
+
 Memperbarui framework Lapeh ke versi terbaru di project yang sudah ada.
 
 ```bash
 npx lapeh upgrade
 ```
+
 **Fitur:**
+
 - Secara otomatis memperbarui dependensi `package.json`.
 - Menyinkronkan file inti framework sambil menjaga kode kustom Anda.
 - **Smart Dependency Handling**: Mempertahankan dependensi `file:` lokal jika Anda mengembangkan framework secara lokal, jika tidak akan mengupdate ke versi npm terbaru.
 
 ### 3. Development Server (`dev`)
+
 Menjalankan server dalam mode development dengan fitur hot-reload.
 
 ```bash
@@ -55,6 +62,7 @@ npx lapeh dev
 ```
 
 ### 2. Production Server (`start`)
+
 Menjalankan server dalam mode production (pastikan sudah dibuild).
 
 ```bash
@@ -64,6 +72,7 @@ npx lapeh start
 ```
 
 ### 3. Build Project (`build`)
+
 Mengompilasi kode TypeScript ke JavaScript di folder `dist`.
 
 ```bash
@@ -77,89 +86,44 @@ npx lapeh build
 Gunakan perintah ini untuk membuat file boilerplate secara otomatis.
 
 ### 1. Membuat Module Lengkap (`make:module`)
-Membuat Controller, Route, dan Model (Schema) sekaligus.
+
+Membuat Controller dan Route sekaligus.
 
 ```bash
 npm run make:module <nama-module>
 ```
+
 **Contoh:** `npm run make:module Product`
 
 Output:
+
 - `src/controllers/productController.ts`
 - `src/routes/product.ts`
-- `src/models/product.prisma`
 
 ### 2. Membuat Controller (`make:controller`)
+
 Hanya membuat file controller dengan method CRUD dasar.
 
 ```bash
 npm run make:controller <nama-controller>
 ```
-**Contoh:** `npm run make:controller Order` (Akan membuat `src/controllers/orderController.ts`)
-
-### 3. Membuat Model Database (`make:model`)
-Hanya membuat file schema Prisma baru.
-
-```bash
-npm run make:model <nama-model>
-```
-**Contoh:** `npm run make:model Transaction` (Akan membuat `src/models/transaction.prisma`)
-
-## Database Management (Prisma)
-
-Framework ini menggunakan sistem **Multi-File Schema**. Anda tidak mengedit `schema.prisma` secara langsung, melainkan mengedit file kecil di `src/models/*.prisma`.
-
-### 1. Migrasi Database (`prisma:migrate`)
-Jalankan setiap kali Anda mengubah definisi model di `src/models/*.prisma`.
-
-```bash
-npm run prisma:migrate
-```
-Perintah ini akan:
-1. Menggabungkan semua file `.prisma` di `src/models/` menjadi satu `prisma/schema.prisma`.
-2. Membuat file migrasi SQL.
-3. Menerapkan perubahan ke database lokal.
-4. Men-generate ulang Prisma Client (Type Definitions).
-
-### 2. Deploy ke Production (`prisma:deploy`)
-Gunakan di server production. Hanya menerapkan migrasi yang sudah ada tanpa reset data.
-
-```bash
-npm run prisma:deploy
-```
-
-### 3. Database Studio (`db:studio`)
-Membuka GUI di browser untuk melihat dan mengedit data database.
-
-```bash
-npm run db:studio
-```
-
-### 4. Seeding Data (`db:seed`)
-Mengisi database dengan data awal yang didefinisikan di `prisma/seed.ts`.
-
-```bash
-npm run db:seed
-```
 
-### 5. Reset Database (`db:reset`)
-**PERINGATAN:** Menghapus semua data dan tabel, lalu menjalankan migrasi dari awal.
-
-```bash
-npm run db:reset
-```
+**Contoh:** `npm run make:controller Order` (Akan membuat `src/controllers/orderController.ts`)
 
 ## Code Quality & Utilities
 
 ### 1. Linting (`lint`)
+
 Memeriksa kode dari error, variabel tidak terpakai, dan gaya penulisan.
 
 ```bash
 npm run lint
 ```
+
 Gunakan `npm run lint:fix` untuk memperbaiki error otomatis.
 
 ### 2. Type Check (`typecheck`)
+
 Memeriksa error tipe data TypeScript tanpa melakukan compile.
 
 ```bash
@@ -167,6 +131,7 @@ npm run typecheck
 ```
 
 ### 3. Generate JWT Secret (`generate:jwt`)
+
 Membuat random string aman untuk `JWT_SECRET` di file `.env`.
 
 ```bash