luak-express 2.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, Eko Suprianto
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# Luak Express Framework v2.0.0 🚀
+
+**Luak Express** adalah framework Node.js premium berbasis Express yang dirancang untuk memberikan pengalaman pengembangan (Developer Experience) sekelas Laravel. Dengan fokus pada keindahan desain, kemudahan penggunaan, dan struktur yang solid.
+
+## ✨ Fitur Utama (v2.0.0)
+
+*   **Premium Debugging (`dd` & `d`)**: Fungsi "Dump and Die" dengan tampilan HTML mewah, tipografi IBM Plex, dan isolasi konteks menggunakan `AsyncLocalStorage`.
+*   **Encapsulated Core Handling**: Exception handler dan view error default (500, 404) kini terisolasi di dalam core framework untuk keamanan maksimal.
+*   **Laravel-Like Architecture**: Struktur folder yang familiar (Controllers, Providers, Middleware, Routes).
+*   **Dynamic Branding**: Sinkronisasi otomatis Nama Aplikasi dan Versi di seluruh halaman sistem.
+*   **Dark Mode Aesthetic**: Desain UI sistem yang modern dan nyaman di mata.
+
+## 📦 Sertifikasi Instalasi
+
+```bash
+npm install luak-express
+```
+
+## 🛠️ Penggunaan Dasar
+
+### Global Helpers
+Luak Express menyediakan helper global yang bisa dipanggil di mana saja tanpa `require`.
+
+#### Dump and Die (`dd`)
+Hentikan eksekusi dan lihat isi variabel dengan tampilan cantik:
+```javascript
+Route.get('/debug', (req, res) => {
+    const data = {
+        user: 'Luak Developer',
+        role: 'Admin',
+        permissions: ['read', 'write']
+    };
+    
+    dd(data, req.all()); // Berhenti di sini
+});
+```
+
+#### Dump (`d`)
+Lihat isi variabel tanpa menghentikan eksekusi:
+```javascript
+d('Ini hanyalah log premium');
+```
+
+## 🏗️ Struktur Proyek
+
+```text
+├── app/                  # Logika Aplikasi (Controllers, Providers, etc)
+├── bootstrap/            # Inisialisasi Framework
+├── config/               # File Konfigurasi
+├── resources/            # Views & Assets (User Land)
+├── routes/               # Definisi Routing
+├── src/                  # Core Framework (Protected)
+└── package.json
+```
+
+## ⬆️ Update v2.0.0
+*   Centralized Versioning di `Application.js`.
+*   Pemindahan Error Handler ke `src/Foundation/Exceptions/Handler.js`.
+*   Premium UI overhaul untuk halaman 404 dan 500.
+*   Sinkronisasi gradient logo di seluruh sistem.
+
+---
+Dikembangkan dengan ❤️ oleh **Luak Express Team**.

package/app/Exceptions/AppException.js

@@ -0,0 +1,45 @@
+class AppException extends Error {
+    /**
+     * Create a new App Exception.
+     * 
+     * @param {string} message - Error message
+     * @param {number} statusCode - HTTP Status code
+     * @param {Array} errors - Additional error details
+     */
+    constructor(message, statusCode = 500, errors = []) {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        this.status = statusCode;
+        this.isOperational = true;
+        this.errors = errors;
+
+        Error.captureStackTrace(this, this.constructor);
+    }
+
+    /**
+     * Returns the error message.
+     * @returns {string}
+     */
+    getMessage() {
+        return this.message;
+    }
+
+    /**
+     * Returns the status code.
+     * @returns {number}
+     */
+    getStatusCode() {
+        return this.statusCode;
+    }
+
+    /**
+     * Returns the errors array.
+     * @returns {Array}
+     */
+    getErrors() {
+        return this.errors;
+    }
+}
+
+module.exports = AppException;

package/app/Exceptions/Handler.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const CoreHandler = require('../../src/Foundation/Exceptions/Handler');
+
+/**
+ * User-land Exception Handler.
+ * 
+ * This class inherits from the framework's core handler.
+ * You can override the render method here to customize
+ * how exceptions are reported or rendered.
+ */
+class Handler extends CoreHandler {
+    /**
+     * Create a new exception handler instance.
+     * 
+     * @param {import('../../src/Foundation/Application')} app
+     */
+    constructor(app) {
+        super(app);
+    }
+}
+
+module.exports = Handler;

package/app/Http/Middleware/LoggerMiddleware.js

@@ -0,0 +1,16 @@
+class LoggerMiddleware {
+    /**
+     * Handle an incoming request.
+     * 
+     * @param {import('express').Request} req
+     * @param {import('express').Response} res
+     * @param {Function} next
+     */
+    handle({ req, res }, next) {
+        const { Log } = require('../../../src/index');
+        Log.info(`${req.method()} ${req.url()}`);
+        return next();
+    }
+}
+
+module.exports = LoggerMiddleware;

package/app/Models/Post.js

@@ -0,0 +1,14 @@
+const { Model } = require('../../src/index');
+
+class Post extends Model {
+    /**
+     * The table associated with the model.
+     * 
+     * @returns {string}
+     */
+    static get table() {
+        return 'posts';
+    }
+}
+
+module.exports = Post;

package/app/Models/User.js

@@ -0,0 +1,14 @@
+const { Model } = require('../../src/index');
+
+class User extends Model {
+    /**
+     * The table associated with the model.
+     * 
+     * @returns {string}
+     */
+    static get table() {
+        return 'users';
+    }
+}
+
+module.exports = User;

package/app/Providers/AppServiceProvider.js

@@ -0,0 +1,24 @@
+const { ServiceProvider } = require('../../src/index');
+
+class AppServiceProvider extends ServiceProvider {
+    /**
+     * Register any application services.
+     * 
+     * @returns {void}
+     */
+    register() {
+        // Register your own bindings here
+        // this.app.bind('Services/UserService', require('../Services/UserService'));
+    }
+
+    /**
+     * Bootstrap any application services.
+     * 
+     * @returns {void}
+     */
+    boot() {
+        //
+    }
+}
+
+module.exports = AppServiceProvider;

package/app/Providers/CacheServiceProvider.js

@@ -0,0 +1,12 @@
+const { ServiceProvider } = require('../../src/index');
+const CacheManager = require('../../src/Cache/CacheManager');
+
+class CacheServiceProvider extends ServiceProvider {
+    register() {
+        this.app.singleton('cache', () => {
+            return new CacheManager(this.app);
+        });
+    }
+}
+
+module.exports = CacheServiceProvider;

package/app/Providers/DatabaseServiceProvider.js

@@ -0,0 +1,59 @@
+const { ServiceProvider } = require('../../src/index');
+
+class DatabaseServiceProvider extends ServiceProvider {
+    /**
+     * Register any application services.
+     * 
+     * @returns {void}
+     */
+    register() {
+        this.app.singleton('db', () => {
+            const config = this.app.make('config');
+            const defaultConnection = config.get('database.default');
+            const dbConfig = config.get(`database.connections.${defaultConnection}`);
+
+            if (!dbConfig) {
+                throw new Error(`Database connection [${defaultConnection}] not configured.`);
+            }
+
+            // For now, let's use Sequelize as the primary engine for SQL drivers
+            if (['mysql', 'sqlite', 'postgres'].includes(dbConfig.driver)) {
+                const { Sequelize } = require('sequelize');
+
+                if (dbConfig.driver === 'sqlite') {
+                    return new Sequelize({
+                        dialect: 'sqlite',
+                        storage: dbConfig.database,
+                        logging: config.get('app.debug') ? console.log : false
+                    });
+                }
+
+                return new Sequelize(dbConfig.database, dbConfig.username, dbConfig.password, {
+                    host: dbConfig.host,
+                    port: dbConfig.port,
+                    dialect: dbConfig.driver,
+                    logging: config.get('app.debug') ? console.log : false
+                });
+            }
+
+            return {};
+        });
+    }
+
+    boot() {
+        const db = this.app.make('db');
+        if (db.authenticate) {
+            db.authenticate()
+                .then(() => {
+                    if (this.app.make('config').get('app.debug')) {
+                        console.log('Database connection has been established successfully.');
+                    }
+                })
+                .catch(err => {
+                    console.error('Unable to connect to the database:', err);
+                });
+        }
+    }
+}
+
+module.exports = DatabaseServiceProvider;

package/app/Providers/RouteServiceProvider.js

@@ -0,0 +1,55 @@
+const { ServiceProvider } = require('../../src/index');
+const path = require('path');
+const fs = require('fs');
+
+class RouteServiceProvider extends ServiceProvider {
+    /**
+     * Map the routes.
+     * 
+     * @returns {void}
+     */
+    boot() {
+        // Mount the router onto Express
+        const router = this.app.make('router');
+        const app = this.app.make('express');
+
+        this.mapApiRoutes();
+        this.mapWebRoutes();
+
+        app.use('/', router.getExpressRouter());
+    }
+
+    /**
+     * Define the "api" routes for the application.
+     * 
+     * @returns {void}
+     */
+    mapApiRoutes() {
+        const router = this.app.make('router');
+        const routePath = this.app.path('routes/api.js');
+
+        if (fs.existsSync(routePath)) {
+            router.group({ prefix: '/api/v1' }, () => {
+                require(routePath);
+            });
+        }
+    }
+
+    /**
+     * Define the "web" routes for the application.
+     * 
+     * @returns {void}
+     */
+    mapWebRoutes() {
+        const router = this.app.make('router');
+        const routePath = this.app.path('routes/web.js');
+
+        if (fs.existsSync(routePath)) {
+            router.group({ prefix: '/' }, () => {
+                require(routePath);
+            });
+        }
+    }
+}
+
+module.exports = RouteServiceProvider;

package/bin/luak

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const command = process.argv[2];
+
+if (command === 'init') {
+    console.log('Initializing Luak Express project...');
+    initProject();
+} else {
+    console.log('Usage: luak init');
+    process.exit(1);
+}
+
+function initProject() {
+    const targetDir = process.cwd();
+    const packageDir = path.resolve(__dirname, '../'); // Assuming bin is inside the package
+
+    // Directories to copy
+    const dirsToCopy = [
+        'app',
+        'bootstrap',
+        'config',
+        'routes',
+        // 'database' // Optional, maybe created empty
+    ];
+
+    // Files to copy
+    const filesToCopy = [
+        'index.js',
+        '.env.example',
+        'gitignore.example' // We might need to rename .gitignore check
+    ];
+
+    // 1. Copy Directories
+    dirsToCopy.forEach(dir => {
+        const src = path.join(packageDir, dir);
+        const dest = path.join(targetDir, dir);
+        
+        if (fs.existsSync(src)) {
+            copyRecursiveSync(src, dest);
+            console.log(`Created: ${dir}`);
+        }
+    });
+
+    // 2. Copy Files
+    filesToCopy.forEach(file => {
+        const src = path.join(packageDir, file);
+        const dest = path.join(targetDir, file);
+        
+        // Handle .gitignore specifically if needed to avoid npm publishing issues
+        // For now direct copy
+        if (fs.existsSync(src)) {
+            fs.copyFileSync(src, dest);
+            console.log(`Created: ${file}`);
+        } else if (file === '.env.example' && fs.existsSync(path.join(packageDir, '.env'))) {
+             // Fallback to .env if .env.example doesn't exist in source but we want to provide one
+             fs.copyFileSync(path.join(packageDir, '.env'), dest);
+             console.log(`Created: ${file}`);
+        }
+    });
+
+    console.log('\nProject initialized successfully!');
+    console.log('Run "npm install" to install dependencies.');
+}
+
+function copyRecursiveSync(src, dest) {
+    const exists = fs.existsSync(src);
+    const stats = exists && fs.statSync(src);
+    const isDirectory = exists && stats.isDirectory();
+
+    if (isDirectory) {
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest);
+        }
+
+        fs.readdirSync(src).forEach(childItemName => {
+            copyRecursiveSync(path.join(src, childItemName), path.join(dest, childItemName));
+        });
+    } else {
+        fs.copyFileSync(src, dest);
+    }
+}

package/bootstrap/app.js

@@ -0,0 +1,43 @@
+const { Application } = require('../src/index');
+const path = require('path');
+
+/*
+|--------------------------------------------------------------------------
+| Create The Application
+|--------------------------------------------------------------------------
+|
+| The first thing we will do is create a new framework application instance
+| which serves as the "glue" for all the components of logic, and
+| serves as the IoC container for the system binding all of the
+| various parts.
+|
+*/
+
+const app = new Application(
+    path.join(__dirname, '../')
+);
+
+/*
+|--------------------------------------------------------------------------
+| Load Configuration & Providers
+|--------------------------------------------------------------------------
+|
+| We check the configuration (either file or cache) and load the
+| providers.
+|
+*/
+
+app.registerConfiguredProviders();
+
+/*
+|--------------------------------------------------------------------------
+| Return The Application
+|--------------------------------------------------------------------------
+|
+| This script returns the application instance. The instance is given to
+| the calling script so we can separate the building of the instances
+| from the actual running of the application and sending responses.
+|
+*/
+
+module.exports = app;

package/config/app.js

@@ -0,0 +1,32 @@
+module.exports = {
+    /*
+    |--------------------------------------------------------------------------
+    | Autoloaded Service Providers
+    |--------------------------------------------------------------------------
+    |
+    | The service providers listed here will be automatically loaded on the
+    | request to your application. Feel free to add your own services to
+    | this array to grant expanded functionality to your applications.
+    |
+    */
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Name
+    |--------------------------------------------------------------------------
+    */
+    name: process.env.APP_NAME || 'Luak Express',
+
+    debug: process.env.APP_DEBUG === 'true',
+
+    providers: [
+        // Framework Providers...
+        // ...
+
+        // Application Service Providers...
+        'app/Providers/AppServiceProvider',
+        'app/Providers/RouteServiceProvider',
+        'app/Providers/DatabaseServiceProvider',
+        'app/Providers/CacheServiceProvider',
+    ],
+};

package/config/cache.js

@@ -0,0 +1,12 @@
+const path = require('path');
+
+module.exports = {
+    default: process.env.CACHE_DRIVER || 'file',
+
+    stores: {
+        file: {
+            driver: 'file',
+            path: path.join(__dirname, '../storage/framework/cache/data'),
+        },
+    },
+};

package/config/database.js

@@ -0,0 +1,42 @@
+module.exports = {
+    /**
+     * Default Database Connection Name
+     */
+    default: process.env.DB_CONNECTION || 'mysql',
+
+    /**
+     * Database Connections
+     */
+    connections: {
+        sqlite: {
+            driver: 'sqlite',
+            database: process.env.DB_DATABASE || 'database.sqlite',
+            prefix: '',
+        },
+
+        mysql: {
+            driver: 'mysql',
+            host: process.env.DB_HOST || '127.0.0.1',
+            port: process.env.DB_PORT || '3306',
+            database: process.env.DB_DATABASE || 'luak_express',
+            username: process.env.DB_USERNAME || 'root',
+            password: process.env.DB_PASSWORD || '',
+            charset: 'utf8mb4',
+            collation: 'utf8mb4_unicode_ci',
+            prefix: '',
+        },
+
+        mongodb: {
+            driver: 'mongodb',
+            host: process.env.DB_HOST || '127.0.0.1',
+            port: process.env.DB_PORT || '27017',
+            database: process.env.DB_DATABASE || 'luak_express',
+            username: process.env.DB_USERNAME || '',
+            password: process.env.DB_PASSWORD || '',
+            options: {
+                useNewUrlParser: true,
+                useUnifiedTopology: true,
+            }
+        }
+    }
+};

package/index.js

@@ -0,0 +1,82 @@
+require('dotenv').config();
+
+/**
+ * Register global helpers
+ */
+require('./src/Support/helpers');
+
+/**
+ * Bootstrap the application
+ */
+const app = require('./bootstrap/app');
+const { Kernel } = require('./src/index');
+
+/**
+ * Run the application
+ */
+const port = process.env.PORT || 3000;
+
+const express = require('express');
+const path = require('path');
+const server = express();
+
+// Bind express to container
+app.bind('express', () => server, true);
+
+// Body Parsers
+server.use(express.json());
+server.use(express.urlencoded({ extended: true }));
+
+// Configure View Engine
+server.set('view engine', 'ejs');
+server.set('views', path.join(__dirname, 'resources/views'));
+
+// Resolve Kernel & Handler
+const kernel = new Kernel(app);
+const Handler = require('./app/Exceptions/Handler');
+const handler = new Handler(app);
+
+// Register Global Middleware
+const LoggerMiddleware = require('./app/Http/Middleware/LoggerMiddleware');
+const MethodOverride = require('./src/Http/Middleware/MethodOverride');
+const { ddContextMiddleware } = require('./src/Foundation/helpers/dd');
+
+server.use(ddContextMiddleware);
+kernel.pushMiddleware(new MethodOverride());
+kernel.pushMiddleware(new LoggerMiddleware());
+
+// Wire up the Kernel to Express
+server.use((req, res, next) => {
+    try {
+        const result = kernel.handle(req, res, next);
+        if (result && typeof result.catch === 'function') {
+            result.catch(err => handler.render(req, res, err));
+        }
+    } catch (err) {
+        handler.render(req, res, err);
+    }
+});
+
+// Mount the Router
+const router = app.make('router');
+server.use(router.router);
+
+// 404 Handler
+server.use((req, res, next) => {
+    const AppException = require('./app/Exceptions/AppException');
+    handler.render(req, res, new AppException('Page Not Found', 404));
+});
+
+// Final Error Handler for Express
+server.use((err, req, res, next) => {
+    handler.render(req, res, err);
+});
+
+app.start().then(() => {
+    server.listen(port, () => {
+        console.log(`Server is running on port ${port}`);
+    });
+}).catch(err => {
+    console.error('Failed to start application:', err);
+    process.exit(1);
+});