lapeh 1.0.8 → 1.0.10

package/.env.example

@@ -1,10 +1,17 @@
 PORT=4000
 DATABASE_PROVIDER="postgresql"
-DATABASE_URL="postgresql://roby:12341234@localhost:5432/db_example_test?schema=public"   
+DATABASE_URL="postgresql://sianu:12341234@localhost:5432/db_example_test?schema=public"   
 JWT_SECRET="replace_this_with_a_secure_random_string"
 
-# redis example:
-REDIS_URL="redis://localhost:6379"
+# Redis Configuration (Optional)
+# If REDIS_URL is not set or connection fails, the framework will automatically 
+# switch to an in-memory Redis mock (bundled). No installation required for development.
+
+
+# REDIS_URL="redis://localhost:6379"
+
+# To force disable Redis and use in-memory mock even if Redis is available:
+# NO_REDIS="true"
 
 # mysql example:
 # DATABASE_PROVIDER="mysql"

package/bin/index.js

@@ -146,7 +146,7 @@ const selectOption = async (query, options) => {
   console.log('⚙️  Configuring environment...');
   const envExamplePath = path.join(projectDir, '.env.example');
   const envPath = path.join(projectDir, '.env');
-  const prismaBaseFile = path.join(projectDir, "prisma", "base.prisma");
+  const prismaBaseFile = path.join(projectDir, "prisma", "base.prisma.template");
 
   if (fs.existsSync(envExamplePath)) {
     let envContent = fs.readFileSync(envExamplePath, 'utf8');
@@ -168,9 +168,9 @@ const selectOption = async (query, options) => {
 
     fs.writeFileSync(envPath, envContent);
   }
-
-  // Update prisma/base.prisma
-  console.log("📄 Updating prisma/base.prisma...");
+  
+  // Update prisma/base.prisma.template
+  console.log("📄 Updating prisma/base.prisma.template...");
   if (fs.existsSync(prismaBaseFile)) {
     let baseContent = fs.readFileSync(prismaBaseFile, "utf8");
     // Replace provider in datasource block

package/document.md

@@ -0,0 +1,205 @@
+# Lapeh Framework For Website Documentation
+
+Jika Anda ingin membangun website dokumentasi sekelas **NestJS** atau **Next.js** di `https://lapeh.web.id`, berikut adalah **Blueprint Lengkap** (Rancang Bangun) yang perlu Anda siapkan.
+
+Tujuannya adalah membuat pengguna baru merasa _terbimbing_ dari nol hingga mahir, serta memberikan referensi cepat bagi pengguna lama.
+
+---
+
+## 1. Rekomendasi Teknologi (Tech Stack)
+
+Untuk membuat dokumentasi yang modern, cepat, dan mudah dikelola, jangan membuatnya dari nol (HTML manual). Gunakan _Documentation Framework_:
+
+- **Pilihan Utama (React/Next.js ecosystem):** [Nextra](https://nextra.site/) atau [Docusaurus](https://docusaurus.io/).
+  - _Alasan:_ Mendukung Markdown/MDX, SEO friendly, pencarian cepat, dan tampilan yang sangat mirip dengan Next.js/Vercel docs.
+- **Alternatif (Vue ecosystem):** [VitePress](https://vitepress.dev/).
+
+---
+
+## 2. Struktur Menu Utama (Top Navigation)
+
+Menu di bagian atas (Header) harus sederhana namun mencakup akses ke area vital:
+
+1.  **Docs** (Dokumentasi utama)
+2.  **API Reference** (Kamus kode: daftar lengkap class, function, interface)
+3.  **Blog** (Berita rilis versi baru, tutorial kasus nyata)
+4.  **Community** (Link ke Discord, GitHub Discussions)
+5.  **GitHub Icon** (Link ke repository)
+6.  **Search Bar** (Pencarian global - _Wajib ada_)
+7.  **Version Dropdown** (Jika nanti ada v2.0, v3.0, user bisa ganti versi)
+
+---
+
+## 3. Struktur Konten (Sidebar Menu)
+
+Ini adalah "Jantung" dari dokumentasi Anda. Urutannya harus logis: dari pengenalan -> dasar -> teknik lanjut -> deploy.
+
+### A. Introduction (Pengenalan)
+
+- **Overview**: Apa itu Lapeh? Kenapa menggunakan ini? (Filosofi: Struktur Laravel di Node.js).
+- **Installation**: Cara install via `npx lapeh@latest`.
+- **First Steps**: "Hello World" pertama, menjalankan `npm run dev`, struktur folder awal.
+- **CLI Commands**: Penjelasan perintah `lapeh`, `npm run make:module`, dll.
+
+### B. Fundamentals (Dasar-Dasar)
+
+- **Directory Structure**: Penjelasan detail folder `src/`, `prisma/`, `bin/`.
+- **Routing**: Cara membuat route baru di `src/routes/`.
+- **Controllers**: Cara membuat controller, menangani Request/Response.
+- **Services**: Business logic layer (pemisahan logic dari controller).
+- **Middleware**: Cara kerja middleware, error handling global, validation.
+- **DTO & Validation**: Validasi request menggunakan **Zod**.
+
+### C. Database (Prisma ORM)
+
+- **Prisma Basics**: Konfigurasi `.env`, `prisma/base.prisma`.
+- **Models**: Cara membuat model baru di `src/models/*.prisma`.
+- **Migrations**: Workflow `npm run prisma:migrate` vs `prisma:deploy`.
+- **Seeding**: Cara mengisi data awal (`npm run db:seed`).
+- **Studio**: Mengelola data via GUI (`npm run db:studio`).
+
+### D. Security (Keamanan)
+
+- **Authentication**: Login, Register, JWT Strategy.
+- **Authorization (RBAC)**: Role-based access control (Admin vs User).
+- **Encryption**: Hashing password (Bcrypt).
+- **Protection**: Helmet, CORS, Rate Limiting (sudah built-in di Lapeh).
+
+### E. Techniques (Teknik Lanjut)
+
+- **File Upload**: Upload gambar/file (Multer).
+- **Realtime**: Integrasi Socket.io (karena sudah ada di `src/realtime.ts`).
+- **Caching**: Redis integration.
+- **Logging**: Cara logging error dan activity.
+- **Unit Testing**: (Jika ada fitur testing).
+
+### F. Deployment (Rilis)
+
+- **Environment Variables**: Persiapan `.env` untuk production.
+- **Process Manager**: Menggunakan PM2.
+- **Docker**: Cara containerize aplikasi Lapeh.
+- **Cloud Platforms**: Panduan deploy ke VPS (Ubuntu), Railway, atau Vercel.
+
+---
+
+## 4. Fitur Wajib di Website Dokumentasi
+
+Agar website dokumentasi Anda terasa "Profesional" dan "Developer Friendly":
+
+1.  **Code Highlighting & Copy Button**:
+    Setiap blok kode harus punya warna syntax (highlighting) dan tombol "Copy" di pojok kanan atas.
+
+    ```typescript
+    // Contoh tombol copy harus ada di sini
+    const app = lapeh();
+    ```
+
+2.  **Dark Mode**:
+    Developer suka mode gelap. Pastikan website mendukung toggle Light/Dark mode.
+
+3.  **Algolia Search (Pencarian Cepat)**:
+    User tidak suka klik menu satu per satu. Mereka ingin ketik "JWT" dan langsung ketemu halamannya.
+
+4.  **Prev/Next Pagination**:
+    Di bawah setiap artikel, ada tombol untuk lanjut ke bab berikutnya.
+
+    - _< Sebelumnya: Installation_ | _Selanjutnya: First Steps >_
+
+5.  **"Edit this page on GitHub"**:
+    Tombol di setiap halaman agar komunitas bisa bantu koreksi typo atau update dokumentasi (Open Source contribution).
+
+6.  **Interactive Tabs**:
+    Jika ada pilihan (misal: NPM vs Yarn vs PNPM), gunakan tab.
+    ```
+    [NPM] [Yarn] [PNPM]
+    npm install lapeh
+    ```
+
+---
+
+## 5. Contoh Konten Halaman Utama (Landing Page)
+
+Halaman depan `https://lapeh.web.id` jangan langsung masuk ke dokumentasi teknis. Buat _Selling Point_:
+
+- **Hero Section**:
+  - Judul Besar: "The Standardized Node.js Framework".
+  - Sub-judul: "Build scalable APIs with ease. Inspired by Laravel, powered by Express & Prisma."
+  - Tombol: [Get Started] [GitHub].
+- **Features Grid**:
+  - 📦 **Modular**: Terstruktur rapi per fitur.
+  - 🛡️ **Type-Safe**: Full TypeScript & Zod.
+  - ⚡ **Prisma Power**: Database ORM modern.
+  - 🚀 **CLI Tools**: Generate code dalam detik.
+
+---
+
+## 6. Langkah Kerja (Action Plan)
+
+1.  **Setup Repo**: Buat repo baru `lapeh-docs`.
+2.  **Init Project**: `npx create-nextra-app` (paling cepat) atau `npx create-docusaurus@latest`.
+3.  **Isi Konten**: Pindahkan isi `readme.md` dan `framework.md` ke dalam struktur bab di atas.
+4.  **Deploy**: Push ke GitHub, connect ke **Vercel** (gratis untuk open source).
+5.  **Domain**: Beli/set `lapeh.web.id` arahkan ke Vercel.
+
+---
+
+## 7. Struktur Folder Proyek Dokumentasi (Nextra/Docusaurus)
+
+Berikut adalah gambaran struktur folder jika Anda menggunakan **Nextra** (berbasis Next.js) untuk website dokumentasi `lapeh.web.id`:
+
+```
+lapeh-docs/
+├── pages/
+│   ├── index.mdx              # Halaman Landing Page (Home)
+│   ├── _meta.json             # Konfigurasi Menu Sidebar & Top Nav
+│   ├── docs/                  # Folder Utama Dokumentasi
+│   │   ├── _meta.json         # Urutan menu sidebar
+│   │   ├── introduction/
+│   │   │   ├── _meta.json
+│   │   │   ├── overview.mdx   # Apa itu Lapeh?
+│   │   │   ├── installation.mdx
+│   │   │   ├── first-steps.mdx
+│   │   │   └── cli.mdx
+│   │   ├── fundamentals/
+│   │   │   ├── _meta.json
+│   │   │   ├── directory-structure.mdx
+│   │   │   ├── routing.mdx
+│   │   │   ├── controllers.mdx
+│   │   │   └── ...
+│   │   ├── database/
+│   │   │   ├── _meta.json
+│   │   │   ├── prisma-basics.mdx
+│   │   │   ├── models.mdx
+│   │   │   └── ...
+│   │   ├── security/
+│   │   │   ├── _meta.json
+│   │   │   └── ...
+│   │   ├── techniques/
+│   │   │   ├── _meta.json
+│   │   │   └── ...
+│   │   └── deployment/
+│   │       ├── _meta.json
+│   │       └── ...
+│   ├── blog/                  # Folder Blog
+│   │   ├── _meta.json
+│   │   ├── release-v1-0-0.mdx
+│   │   └── tutorial-auth.mdx
+│   └── about.mdx              # Halaman About/Team
+├── public/                    # Aset statis (Logo, Gambar)
+│   ├── logo.png
+│   ├── favicon.ico
+│   └── images/
+│       └── architecture-diagram.png
+├── theme.config.jsx           # Konfigurasi Tema (Logo, Footer, Social Links)
+├── next.config.js             # Config Next.js
+├── package.json
+└── tsconfig.json
+```
+
+### Penjelasan File Penting:
+
+- **`pages/`**: Semua konten Markdown/MDX ada di sini.
+- **`_meta.json`**: File json kecil di setiap folder untuk mengatur urutan menu sidebar dan judul yang tampil.
+- **`theme.config.jsx`**: Di sini Anda mengatur logo `Lapeh`, link GitHub, dan konfigurasi SEO.
+
+Dengan struktur ini, framework Anda akan terlihat sangat matang dan profesional, meningkatkan kepercayaan developer untuk menggunakannya.

package/framework.md

@@ -43,7 +43,7 @@ Framework ini menggunakan **Prisma ORM** dengan struktur schema yang modular (di
 Saat mengembangkan aplikasi di local environment:
 
 **a. Mengupdate Schema Database**
-Jika Anda mengubah file schema di `src/models/*.prisma` atau `prisma/schema.prisma`:
+Jika Anda mengubah file schema di `src/models/*.prisma` atau konfigurasi di `prisma/base.prisma.template`:
 
 ```bash
 npm run prisma:migrate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lapeh",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Framework API Express yang siap pakai (Standardized)",
   "main": "index.js",
   "bin": {
@@ -50,6 +50,7 @@
     "express-rate-limit": "8.2.1",
     "helmet": "8.1.0",
     "ioredis": "5.8.2",
+    "ioredis-mock": "^8.13.1",
     "jsonwebtoken": "9.0.3",
     "multer": "2.0.2",
     "pg": "8.16.3",

package/prisma/schema.prisma

@@ -1,5 +1,5 @@
 generator client {
-  provider = "postgresql"
+  provider = "prisma-client-js"
   output   = "../generated/prisma"
 }
 

package/readme.md

@@ -9,21 +9,38 @@
 - **Prisma ORM**: Integrasi database yang modern dan type-safe.
 - **Schema Terpisah**: Mendukung pemisahan schema Prisma per model (mirip Eloquent).
 - **Generator Tools**: CLI commands untuk generate Module dan Model dengan cepat.
+- **Zero-Config Redis**: Otomatis menggunakan Redis jika tersedia, atau fallback ke in-memory mock tanpa konfigurasi.
 - **Security Best Practices**: Dilengkapi dengan Helmet, Rate Limiting, CORS, dan JWT Authentication.
 - **Validasi Data**: Menggunakan Zod untuk validasi request yang kuat.
 
 ## 📦 Instalasi & Penggunaan
 
-Buat project baru cukup dengan satu perintah:
+Anda dapat menginstall framework ini menggunakan versi terbaru atau versi spesifik agar lebih fleksibel:
+
+### 1. Menggunakan Versi Terbaru (Recommended)
 
 ```bash
-npx lapeh nama-project-anda
+npx lapeh@latest nama-project-anda
 ```
 
 Atau gunakan flag `--full` untuk setup lengkap (termasuk seeding data default user & roles):
 
 ```bash
-npx lapeh nama-project-anda --full
+npx lapeh@latest nama-project-anda --full
+```
+
+### 2. Menggunakan Versi Spesifik
+
+Jika Anda membutuhkan versi tertentu (misalnya untuk kompatibilitas):
+
+```bash
+npx lapeh@1.0.8 nama-project-anda
+```
+
+Atau dengan setup lengkap:
+
+```bash
+npx lapeh@1.0.8 nama-project-anda --full
 ```
 
 ### Apa yang terjadi otomatis?
@@ -138,7 +155,7 @@ src/
 └── index.ts         # App Entry Point
 prisma/
 ├── schema.prisma    # [GENERATED] Jangan edit file ini
-└── base.prisma      # Konfigurasi Datasource & Generator
+└── base.prisma.template # Konfigurasi Datasource & Generator
 ```
 
 ## 📝 Lisensi

package/scripts/check-update.js

@@ -82,6 +82,9 @@ function showUpdateMessage(latest, current) {
     console.log(`${fgYellow}│                                                             │${reset}`);
     console.log(`${fgYellow}│   Silakan cek repository untuk melihat perubahan terbaru.   │${reset}`);
     console.log(`${fgYellow}│                                                             │${reset}`);
+    console.log(`${fgYellow}│   Untuk upgrade jalankan:                                   │${reset}`);
+    console.log(`${fgYellow}│   ${fgCyan}npm install lapeh@latest${reset}${fgYellow}                                    │${reset}`);
+    console.log(`${fgYellow}│                                                             │${reset}`);
     console.log(`${fgYellow}└─────────────────────────────────────────────────────────────┘${reset}`);
     console.log('\n');
 }

package/scripts/compile-schema.js

@@ -4,7 +4,7 @@ const path = require('path');
 const prismaDir = path.join(__dirname, '..', 'prisma');
 const modelsDir = path.join(__dirname, '..', 'src', 'models');
 const schemaFile = path.join(prismaDir, 'schema.prisma');
-const baseFile = path.join(prismaDir, 'base.prisma');
+const baseFile = path.join(prismaDir, 'base.prisma.template');
 
 // Ensure models directory exists
 if (!fs.existsSync(modelsDir)) {

package/scripts/init-project.js

@@ -6,7 +6,7 @@ const readline = require("readline");
 const rootDir = path.join(__dirname, "..");
 const envExample = path.join(rootDir, ".env.example");
 const envFile = path.join(rootDir, ".env");
-const prismaBaseFile = path.join(rootDir, "prisma", "base.prisma");
+const prismaBaseFile = path.join(rootDir, "prisma", "base.prisma.template");
 
 const rl = readline.createInterface({
   input: process.stdin,
@@ -104,8 +104,8 @@ const selectOption = async (query, options) => {
     fs.writeFileSync(envFile, envContent);
     console.log("✅ .env updated with database configuration.");
 
-    // 2. Update prisma/base.prisma
-    console.log("📄 Updating prisma/base.prisma...");
+    // 2. Update prisma/base.prisma.template
+    console.log("📄 Updating prisma/base.prisma.template...");
     if (fs.existsSync(prismaBaseFile)) {
       let baseContent = fs.readFileSync(prismaBaseFile, "utf8");
       // Replace provider in datasource block
@@ -115,7 +115,7 @@ const selectOption = async (query, options) => {
       );
       fs.writeFileSync(prismaBaseFile, baseContent);
     } else {
-      console.warn("⚠️ prisma/base.prisma not found. Skipping.");
+      console.warn("⚠️ prisma/base.prisma.template not found. Skipping.");
     }
 
     // 3. Install dependencies

package/src/index.ts

@@ -3,7 +3,7 @@ dotenv.config();
 import { app } from "./server";
 import http from "http";
 import { initRealtime } from "./realtime";
-import { useRedis, pingRedis } from "./redis";
+import { initRedis } from "./redis";
 
 const port = process.env.PORT ? Number(process.env.PORT) : 4000;
 const server = http.createServer(app);
@@ -12,18 +12,8 @@ initRealtime(server);
 
 server.listen(port, () => {
   (async () => {
-    if (!useRedis) {
-      console.log("Redis not configured, using in-memory cache");
-    } else {
-      const ok = await pingRedis();
-      if (ok) {
-        console.log(`Redis connected at ${process.env.REDIS_URL}`);
-      } else {
-        console.log(
-          `Redis configured at ${process.env.REDIS_URL}, but not reachable. Using in-memory cache`
-        );
-      }
-    }
+    // Initialize Redis transparently (no logs if missing)
+    await initRedis();
     console.log(`API running at http://localhost:${port}`);
   })();
 });

package/src/middleware/error.ts

@@ -1,8 +1,58 @@
-import { Request, Response, NextFunction } from "express"
-import { sendError } from "../utils/response"
-export function errorHandler(err: any, _req: Request, res: Response, _next: NextFunction) {
-  const code = err.statusCode || 500
-  const msg = err.message || "Internal Server Error"
-  sendError(res, code, msg)
-}
+import { Request, Response, NextFunction } from "express";
+import { ZodError } from "zod";
+import { Prisma } from "../../generated/prisma/client";
+import { sendError } from "../utils/response";
+
+export function errorHandler(
+  err: any,
+  _req: Request,
+  res: Response,
+  _next: NextFunction
+) {
+  // 1. Zod Validation Error
+  if (err instanceof ZodError) {
+    const formattedErrors = err.errors.map((e) => ({
+      field: e.path.join("."),
+      message: e.message,
+    }));
+    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}`);
+    }
+    // P2025: Record not found
+    if (err.code === "P2025") {
+      return sendError(res, 404, "Record not found");
+    }
+  }
+
+  // 3. JWT Errors
+  if (err.name === "JsonWebTokenError") {
+    return sendError(res, 401, "Invalid token");
+  }
+  if (err.name === "TokenExpiredError") {
+    return sendError(res, 401, "Token expired");
+  }
 
+  // 4. Syntax Error (JSON body parsing)
+  if (err instanceof SyntaxError && "body" in err) {
+    return sendError(res, 400, "Invalid JSON format");
+  }
+
+  // 5. Default / Custom Error
+  const code = err.statusCode || 500;
+  const msg = err.message || "Internal Server Error";
+
+  // Log error in development for debugging
+  if (code === 500 && process.env.NODE_ENV !== "production") {
+    console.error("❌ [Global Error Handler]:", err);
+  }
+
+  return sendError(res, code, msg);
+}

package/src/middleware/visitor.ts

@@ -1,6 +1,6 @@
 import { Request, Response, NextFunction } from "express";
 import { v4 as uuidv4 } from "uuid";
-import { redis, useRedis } from "../redis";
+import { redis } from "../redis";
 
 type DayMemoryStats = {
   requests: number;
@@ -75,7 +75,7 @@ export async function visitorCounter(
     });
   }
 
-  if (useRedis && redis) {
+  if (redis && redis.status === "ready") {
     const base = dateKey;
     const kRequests = `requests-${base}`;
     const kNewVisitors = `new-visitors-${base}`;
@@ -127,8 +127,7 @@ export async function visitorCounter(
       if (addedSession === 1) {
         await redis.incr(kSessions);
       }
-    } catch {
-    }
+    } catch {}
   } else {
     let stats = memoryStats.get(dateKey);
     if (!stats) {
@@ -177,4 +176,3 @@ export async function visitorCounter(
 
   next();
 }
-

package/src/redis.ts

@@ -1,69 +1,121 @@
-import Redis from "ioredis";
-
-export const useRedis = !!process.env.REDIS_URL;
-
-let redis: Redis | null = null;
-if (useRedis) {
-  redis = new Redis(process.env.REDIS_URL as string, {
-    lazyConnect: true,
-    maxRetriesPerRequest: 0,
-    enableOfflineQueue: false,
-  });
-}
-
-const memory = new Map<string, { value: any; expireAt: number }>();
-
-export async function getCache(key: string) {
-  if (useRedis && redis) {
-    try {
-      const v = await redis.get(key);
-      return v ? JSON.parse(v) : null;
-    } catch {
-      // fall through
-    }
-  } else {
-    const entry = memory.get(key);
-    if (entry && entry.expireAt > Date.now()) return entry.value;
-    if (entry) memory.delete(key);
-  }
-  return null;
-}
-
-export async function setCache(key: string, value: any, ttlSeconds = 60) {
-  if (useRedis && redis) {
-    try {
-      await redis.set(key, JSON.stringify(value), "EX", ttlSeconds);
-      return;
-    } catch {
-      // fall through
-    }
-  } else {
-    memory.set(key, { value, expireAt: Date.now() + ttlSeconds * 1000 });
-  }
-}
-
-export async function delCache(key: string) {
-  if (useRedis && redis) {
-    try {
-      await redis.del(key);
-      return;
-    } catch {
-      // fall through
-    }
-  } else {
-    memory.delete(key);
-  }
-}
-
-export async function pingRedis(): Promise<boolean> {
-  if (!useRedis || !redis) return false;
-  try {
-    await redis.connect();
-    const res = await redis.ping();
-    return res === "PONG";
-  } catch {
-    return false;
-  }
-}
-
-export { redis };
+import Redis from "ioredis";
+// @ts-ignore
+import RedisMock from "ioredis-mock";
+
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+
+// Create a wrapper to handle connection attempts
+let redis: Redis;
+let isRedisConnected = false;
+
+// If explicitly disabled via env
+if (process.env.NO_REDIS === "true") {
+  console.log("Redis disabled via NO_REDIS, using in-memory mock.");
+  redis = new RedisMock();
+  isRedisConnected = true;
+} else {
+  // Try to connect to real Redis
+  redis = new Redis(redisUrl, {
+    lazyConnect: true,
+    maxRetriesPerRequest: 1,
+    retryStrategy: (times) => {
+      // Retry 3 times then give up
+      if (times > 3) return null;
+      return 200;
+    },
+  });
+}
+
+redis.on("ready", () => {
+  isRedisConnected = true;
+  // console.log("Redis connected!");
+});
+
+redis.on("error", (err) => {
+  // If connection fails and we haven't switched to mock yet
+  if (!isRedisConnected && !(redis instanceof RedisMock)) {
+    // console.log("Redis connection failed, switching to in-memory mock...");
+    // Replace the global redis instance with mock
+    // Note: This is a runtime switch. Existing listeners might be lost if we don't handle carefully.
+    // However, for a simple fallback, we can just use the mock for future calls.
+    
+    // Better approach: Since we exported 'redis' as a const (reference), we can't reassign it easily 
+    // if other modules already imported it.
+    // BUT, ioredis instance itself is an EventEmitter.
+    
+    // Strategy: We keep 'redis' as the main interface. 
+    // If real redis fails, we just don't set isRedisConnected to true for the *real* one.
+    // But wait, the user wants 'bundle redis'.
+    // The best way is to detect failure during init and SWAP the implementation.
+  }
+  isRedisConnected = false;
+});
+
+// We need a way to seamlessly switch or just default to Mock if connect fails.
+// Since 'redis' is exported immediately, we can't easily swap the object reference for importers.
+// PROXY APPROACH:
+// We export a Proxy that forwards to real redis OR mock redis.
+
+const mockRedis = new RedisMock();
+let activeRedis = redis; // Start with real redis attempt
+
+// Custom init function to determine which one to use
+export async function initRedis() {
+  if (process.env.NO_REDIS === "true") {
+    activeRedis = mockRedis;
+    if (process.env.NODE_ENV === "production") {
+      console.warn(
+        "⚠️  WARNING: Running in PRODUCTION with in-memory Redis mock. Data will be lost on restart and not shared between instances."
+      );
+    }
+    return;
+  }
+
+  try {
+    await redis.connect();
+    activeRedis = redis; // Keep using real redis
+    isRedisConnected = true;
+  } catch (err) {
+    // Connection failed, switch to mock
+    // console.log("Redis failed, using in-memory mock");
+    activeRedis = mockRedis;
+    isRedisConnected = true; // Mock is always "connected"
+    if (process.env.NODE_ENV === "production") {
+      console.warn(
+        "⚠️  WARNING: Redis connection failed in PRODUCTION. Switched to in-memory mock. Data will be lost on restart."
+      );
+    }
+  }
+}
+
+// Proxy handler to forward all calls to activeRedis
+const redisProxy = new Proxy({} as Redis, {
+  get: (target, prop) => {
+    // @ts-ignore
+    return activeRedis[prop];
+  },
+});
+
+export async function getCache(key: string) {
+  try {
+    const v = await activeRedis.get(key);
+    return v ? JSON.parse(v) : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function setCache(key: string, value: any, ttlSeconds = 60) {
+  try {
+    await activeRedis.set(key, JSON.stringify(value), "EX", ttlSeconds);
+  } catch {}
+}
+
+export async function delCache(key: string) {
+  try {
+    await activeRedis.del(key);
+  } catch {}
+}
+
+// Export the proxy as 'redis' so consumers use it transparently
+export { redisProxy as redis };