lapeh 2.6.17 → 3.0.2

package/doc/id/STRUCTURE.md

@@ -9,7 +9,6 @@ Untuk memahami Lapeh Framework sepenuhnya, Anda perlu tahu apa fungsi setiap fil
 | `bin/`               | Berisi script eksekusi untuk CLI (`npx lapeh`). Anda jarang menyentuh ini.    |
 | `doc/`               | Dokumentasi proyek ini berada.                                                |
 | `lib/`               | **Framework Core**. Bagian internal framework yang jarang Anda sentuh.        |
-| `prisma/`            | Jantung konfigurasi Database.                                                 |
 | `scripts/`           | Kumpulan script Node.js untuk utility (generator, compiler schema, dll).      |
 | `src/`               | **Source Code Utama**. 99% kodingan Anda ada di sini.                         |
 | `.env`               | Variabel rahasia (Database URL, API Keys). **Jangan commit file ini ke Git!** |
@@ -29,7 +28,6 @@ Lapeh menggunakan pendekatan **Modular**. Setiap fitur dikelompokkan dalam satu
 Contoh struktur modul `Auth`:
 
 - `Auth/auth.controller.ts`: Logika aplikasi (Controller).
-- `Auth/auth.prisma`: Definisi tabel database (Model).
 
 ### `src/routes/`
 
@@ -54,7 +52,6 @@ Bagian ini mirip dengan `node_modules` atau folder `.next` di Next.js. Ini adala
 Bagian "Mesin" framework.
 
 - `server.ts`: Setup Express App.
-- `database.ts`: Instance Prisma Client.
 - `redis.ts`: Koneksi Redis.
 - `serializer.ts`: Logic caching JSON Schema.
 
@@ -74,18 +71,11 @@ Fungsi bantuan (Helper) bawaan.
 - `response.ts`: Standar format JSON response (`sendFastSuccess`, `sendError`).
 - `logger.ts`: Sistem logging (Winston).
 
-## Folder `prisma/`
-
-- `migrations/`: History perubahan database (SQL file). Jangan diedit manual.
-- `base.prisma.template`: Header dari schema database (berisi konfigurasi datasource db).
-- `seed.ts`: Script untuk mengisi data awal (Data Seeding).
-
 ## Folder `scripts/`
 
 Script-script "Magic" yang dijalankan `npm run`.
 
-- `make-module.js`: Generator modul baru (Controller + Prisma Model).
-- `compile-schema.js`: Penggabung file `.prisma` dari setiap modul menjadi satu `schema.prisma`.
+- `make-module.js`: Generator modul baru (Controller).
 - `init-project.js`: Wizard setup awal.
 - `generate-jwt-secret.js`: Generator kunci rahasia JWT otomatis.
 

package/doc/id/TUTORIAL.md

@@ -4,44 +4,12 @@ Dalam tutorial ini, kita akan membangun fitur "Manajemen Buku" sederhana menggun
 1.  **CLI** untuk generate kode.
 2.  **Validator** untuk validasi input.
 3.  **Fast Serialization** untuk respon cepat.
-4.  **RBAC** untuk proteksi delete (Admin only).
 
-## Langkah 1: Generate Model Database
+> **Catatan**: Tutorial ini menggunakan array in-memory untuk penyimpanan data agar tetap sederhana. Lapeh v3.0.0 bersifat database-agnostic, jadi Anda bebas menggantinya dengan Prisma, TypeORM, atau library database lainnya.
 
-Kita butuh tabel `books`. Gunakan CLI `make:model`.
+## Langkah 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.
+Kita akan membuat controller dan route untuk fitur Buku.
 
 ```bash
 npm run make:module Book
@@ -51,24 +19,33 @@ Framework akan membuat:
 - `src/controllers/bookController.ts`
 - `src/routes/book.ts`
 
-## Langkah 3: Implementasi Controller
+## Langkah 2: Implementasi Controller
 
-Buka `src/controllers/bookController.ts` dan kita implementasikan fitur **Create** dan **List** dengan standar framework.
+Buka `src/controllers/bookController.ts` dan kita implementasikan fitur **Create** dan **List**.
 
-### 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";
 
+// Simpan data di memory (Array sederhana)
+interface Book {
+  id: string;
+  title: string;
+  author: string;
+  isbn: string;
+  stock: number;
+}
+const books: Book[] = [];
+
 // 1. Definisikan Schema Output (untuk Fastify Serialization)
 const bookSchema = {
   type: "object",
   properties: {
-    id: { type: "string" }, // BigInt -> String
+    id: { type: "string" },
     title: { type: "string" },
     author: { type: "string" },
     isbn: { type: "string" },
@@ -92,101 +69,66 @@ export async function createBook(req: Request, res: Response) {
   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. Simpan 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. Kirim 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 semua buku
+  return sendFastSuccess(res, bookListSerializer(books));
 }
 ```
 
-## Langkah 4: Daftarkan Route & Proteksi
+## Langkah 3: Register Route
 
-Buka `src/routes/book.ts` (atau file yang digenerate). Pastikan route terhubung dan tambahkan middleware auth.
+Buka `src/routes/book.ts`. CLI sudah membuat struktur dasarnya. Kita hanya perlu menghubungkannya dengan fungsi controller kita.
 
 ```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):
-
-```typescript
-import { bookRouter } from "./book";
-// ...
-router.use("/books", bookRouter);
-```
-
-## Langkah 5: Testing
+## Langkah 4: Test API Anda
 
 Jalankan server:
 ```bash
 npm run dev
 ```
 
-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).
+Test dengan curl atau Postman:
+
+**Buat Buku Baru:**
+```bash
+curl -X POST http://localhost:4000/api/book \
+  -H "Content-Type: application/json" \
+  -d '{"title":"Panduan Lapeh", "author":"Tim Lapeh", "isbn":"12345", "stock":10}'
+```
 
-## Kesimpulan
+**List Buku:**
+```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).
+Selamat! Anda telah membangun API yang cepat dan tervalidasi tanpa terjebak dalam konfigurasi database yang rumit.

package/gitignore.template

@@ -23,16 +23,6 @@ coverage
 *.swo
 .DS_Store
 
-# Prisma
-generated/prisma
-*.sqlite
-*.db
-*.db-journal
-dev.db
-
-# OS
-Thumbs.db
-
 # Logs
 testing/*
 # Logs

package/lib/bootstrap.ts

@@ -10,7 +10,6 @@ import http from "http";
 import path from "path";
 import { initRealtime } from "./core/realtime";
 import { initRedis, redis } from "./core/redis";
-import { prisma } from "./core/database";
 import { visitorCounter } from "./middleware/visitor";
 import { errorHandler } from "./middleware/error";
 import { apiLimiter } from "./middleware/rateLimit";
@@ -23,31 +22,41 @@ export async function createApp() {
   // We map '@lapeh' to the directory containing this file (lib/ or dist/lib/)
   moduleAlias.addAlias("@lapeh", __dirname);
 
-  // LOAD USER CONFIG
+  // Register alias for src directory (@/) to support imports in controllers/routes
   const isProduction = process.env.NODE_ENV === "production";
+  moduleAlias.addAlias(
+    "@",
+    isProduction
+      ? path.join(process.cwd(), "dist", "src")
+      : path.join(process.cwd(), "src")
+  );
+
+  // LOAD USER CONFIG
   const configPath = isProduction
-      ? path.join(process.cwd(), "dist", "src", "config")
-      : path.join(process.cwd(), "src", "config");
+    ? path.join(process.cwd(), "dist", "src", "config")
+    : path.join(process.cwd(), "src", "config");
 
   let appConfig: any = { timeout: 30000, jsonLimit: "10mb" };
-  let corsConfig: any = { 
-      origin: process.env.CORS_ORIGIN || "*", 
-      credentials: true,
-      exposedHeaders: ["x-access-token", "x-access-expires-at"],
+  let corsConfig: any = {
+    origin: process.env.CORS_ORIGIN || "*",
+    credentials: true,
+    exposedHeaders: ["x-access-token", "x-access-expires-at"],
   };
 
   try {
-      const appConfModule = require(path.join(configPath, "app"));
-      if (appConfModule.appConfig) appConfig = { ...appConfig, ...appConfModule.appConfig };
+    const appConfModule = require(path.join(configPath, "app"));
+    if (appConfModule.appConfig)
+      appConfig = { ...appConfig, ...appConfModule.appConfig };
   } catch (e) {
-      // ignore
+    // ignore
   }
 
   try {
-      const corsConfModule = require(path.join(configPath, "cors"));
-      if (corsConfModule.corsConfig) corsConfig = { ...corsConfig, ...corsConfModule.corsConfig };
+    const corsConfModule = require(path.join(configPath, "cors"));
+    if (corsConfModule.corsConfig)
+      corsConfig = { ...corsConfig, ...corsConfModule.corsConfig };
   } catch (e) {
-      // ignore
+    // ignore
   }
 
   const app = express();
@@ -61,7 +70,7 @@ export async function createApp() {
     res.setTimeout(timeout, () => {
       res.status(408).send({
         status: "error",
-        message: `Request Timeout (${timeout/1000}s limit)`,
+        message: `Request Timeout (${timeout / 1000}s limit)`,
       });
     });
     next();
@@ -78,7 +87,9 @@ export async function createApp() {
 
   app.use(requestLogger);
   app.use(express.json({ limit: appConfig.jsonLimit || "10mb" }));
-  app.use(express.urlencoded({ extended: true, limit: appConfig.jsonLimit || "10mb" }));
+  app.use(
+    express.urlencoded({ extended: true, limit: appConfig.jsonLimit || "10mb" })
+  );
   app.use(apiLimiter);
   app.use(visitorCounter);
 
@@ -93,35 +104,24 @@ export async function createApp() {
 
   // DYNAMIC ROUTE LOADING
   try {
+    console.log("BOOTSTRAP: Loading routes. NODE_ENV=", process.env.NODE_ENV);
     const isProduction = process.env.NODE_ENV === "production";
-    const userRoutesPath = isProduction
+    let userRoutesPath = isProduction
       ? path.join(process.cwd(), "dist", "src", "routes")
       : path.join(process.cwd(), "src", "routes");
 
+    // In test environment, explicitly point to index to ensure resolution
+    if (process.env.NODE_ENV === "test") {
+      // In test environment (ts-jest), we need to point to the TS file
+      // And we might need to use the full path with extension
+      userRoutesPath = path.join(process.cwd(), "src", "routes", "index.ts");
+    }
+
     // Gunakan require agar sinkron dan mudah dicatch
     // Check if file exists before requiring to avoid crash in tests/clean env
     try {
-      // In test environment, we might need to point to src/routes explicitly if not compiled
-      // const routesPath = process.env.NODE_ENV === 'test'
-      //    ? path.join(process.cwd(), "src", "routes", "index.ts")
-      //    : userRoutesPath;
-
-      // Note: For TS files in jest, we rely on ts-jest handling 'require' if it points to .ts or we need to use 'import'
-      // But 'require' in jest with ts-jest should work if configured.
-
-      // However, require(path) with .ts extension might be tricky.
-      // Let's stick to userRoutesPath but maybe adjust for test env.
-
-      // Check if we are in test environment and using ts-jest
-      // If so, we might need to import the TS file directly via relative path if alias is not working for require
-
       const { apiRouter } = require(userRoutesPath);
       app.use("/api", apiRouter);
-      console.log(
-        `✅ User routes loaded successfully from ${
-          isProduction ? "dist/" : ""
-        }src/routes`
-      );
     } catch (e) {
       // If it's just missing module, maybe we are in test mode or fresh install
       if (process.env.NODE_ENV !== "test") {
@@ -134,10 +134,12 @@ export async function createApp() {
           `Error loading routes in test mode from ${userRoutesPath}:`,
           e
         );
+        throw e;
       }
     }
   } catch (error) {
     console.error(error);
+    if (process.env.NODE_ENV === "test") throw error;
   }
 
   app.use(errorHandler);
@@ -147,7 +149,7 @@ export async function createApp() {
 
 export async function bootstrap() {
   // Validasi Environment Variables
-  const requiredEnvs = ["DATABASE_URL", "JWT_SECRET"];
+  const requiredEnvs = ["JWT_SECRET"];
   const missingEnvs = requiredEnvs.filter((key) => !process.env[key]);
   if (missingEnvs.length > 0) {
     console.error(
@@ -186,7 +188,6 @@ export async function bootstrap() {
     console.log(`\n🛑 ${signal} received. Closing resources...`);
     server.close(() => console.log("Http server closed."));
     try {
-      await prisma.$disconnect();
       if (redis && redis.status === "ready") await redis.quit();
       process.exit(0);
     } catch (err) {

package/lib/core/store.ts

@@ -0,0 +1,116 @@
+import fs from "fs";
+import path from "path";
+
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  password?: string;
+  uuid: string;
+  avatar?: string | null;
+  avatar_url?: string | null;
+  email_verified_at?: string | Date | null;
+  created_at: string | Date;
+  updated_at: string | Date;
+}
+
+export interface Role {
+  id: string;
+  name: string;
+  slug: string;
+  description?: string | null;
+  created_at: string | Date;
+  updated_at: string | Date;
+}
+
+export interface Permission {
+  id: string;
+  name: string;
+  slug: string;
+  description?: string | null;
+  created_at: string | Date;
+  updated_at: string | Date;
+}
+
+export interface UserRole {
+  id: string;
+  user_id: string;
+  role_id: string;
+  created_at: string | Date;
+}
+
+export interface RolePermission {
+  id: string;
+  role_id: string;
+  permission_id: string;
+  created_at: string | Date;
+}
+
+export interface UserPermission {
+  id: string;
+  user_id: string;
+  permission_id: string;
+  created_at: string | Date;
+}
+
+// Database file path
+const dbPath = path.resolve(process.cwd(), "database.json");
+
+// Load data function
+function loadData() {
+  if (fs.existsSync(dbPath)) {
+    const raw = fs.readFileSync(dbPath, "utf-8");
+    return JSON.parse(raw);
+  }
+  return {
+    users: [],
+    roles: [
+      {
+        id: "1",
+        name: "Admin",
+        slug: "admin",
+        description: "Administrator",
+        created_at: new Date(),
+        updated_at: new Date(),
+      },
+      {
+        id: "2",
+        name: "User",
+        slug: "user",
+        description: "Standard User",
+        created_at: new Date(),
+        updated_at: new Date(),
+      },
+    ],
+    permissions: [],
+    user_roles: [],
+    role_permissions: [],
+    user_permissions: [],
+  };
+}
+
+const data = loadData();
+
+// Export mutable arrays
+export const users: User[] = data.users;
+export const roles: Role[] = data.roles;
+export const permissions: Permission[] = data.permissions;
+export const user_roles: UserRole[] = data.user_roles;
+export const role_permissions: RolePermission[] = data.role_permissions;
+export const user_permissions: UserPermission[] = data.user_permissions;
+
+// Helper to save data
+export function saveStore() {
+  const payload = {
+    users,
+    roles,
+    permissions,
+    user_roles,
+    role_permissions,
+    user_permissions,
+  };
+  fs.writeFileSync(dbPath, JSON.stringify(payload, null, 2), "utf-8");
+}
+
+// Helper to generate IDs
+export const generateId = () => Math.random().toString(36).substr(2, 9);

package/lib/middleware/error.ts

@@ -1,6 +1,5 @@
 import { Request, Response, NextFunction } from "express";
 import { ZodError } from "zod";
-import { Prisma } from "@prisma/client";
 import { sendError } from "../utils/response";
 import { Log } from "../utils/logger";
 
@@ -19,26 +18,7 @@ export function errorHandler(
     return sendError(res, 400, "Validation Error", formattedErrors);
   }
 
-  // 2. Prisma Errors
-  if (err instanceof Prisma.PrismaClientKnownRequestError) {
-    // P2002: Unique constraint failed
-    if (err.code === "P2002") {
-      const target = (err.meta?.target as string[]) || [];
-      const fields = target.length > 0 ? target.join(", ") : "field";
-      return sendError(res, 409, `Unique constraint failed on: ${fields}`);
-    }
-    // P2003: Foreign key constraint failed
-    if (err.code === "P2003") {
-      const field = err.meta?.field_name || "unknown field";
-      return sendError(res, 400, `Foreign key constraint failed on: ${field}`);
-    }
-    // P2025: Record not found
-    if (err.code === "P2025") {
-      return sendError(res, 404, "Record not found");
-    }
-  }
-
-  // 3. JWT Errors
+  // 2. JWT Errors
   if (err.name === "JsonWebTokenError") {
     return sendError(res, 401, "Invalid token");
   }

package/lib/utils/validator.ts

@@ -1,5 +1,4 @@
 import { z, ZodSchema, ZodError, ZodIssue } from "zod";
-import { prisma } from "../core/database";
 
 export class Validator {
   private data: any;
@@ -242,44 +241,9 @@ export class Validator {
           break;
         case "unique":
           // unique:table,column,ignore,idColumn
-          const [table, column = "id", ignoreValue, ignoreColumn = "id"] =
-            params;
-          schema = schema.refine(
-            async (val: any) => {
-              if (!val) return true;
-              const where: any = { [column]: val };
-              if (ignoreValue && ignoreValue !== "null") {
-                // Try to handle numeric IDs if ignoreValue looks numeric
-                const ignoreVal = !isNaN(Number(ignoreValue))
-                  ? Number(ignoreValue)
-                  : ignoreValue;
-                // But Prisma uses BigInt for IDs often in this project?
-                // Let's assume string or number is fine, user can cast if needed.
-                // In this project, IDs are BigInt.
-                if (
-                  typeof ignoreVal === "number" ||
-                  /^\d+$/.test(String(ignoreValue))
-                ) {
-                  where[ignoreColumn] = { not: BigInt(ignoreValue) };
-                } else {
-                  where[ignoreColumn] = { not: ignoreValue };
-                }
-              }
-
-              try {
-                // @ts-ignore
-                const count = await prisma[table].count({ where });
-                return count === 0;
-              } catch (e) {
-                console.error(
-                  `Validator unique check failed for table ${table}:`,
-                  e
-                );
-                return false;
-              }
-            },
-            { message: `The ${column} has already been taken.` }
-          );
+          // NOTE: Unique check requires Database implementation.
+          // Since v3.0.0 (No-ORM), this rule is disabled by default.
+          // You should implement your own uniqueness check manually in the controller.
           break;
       }
     }