luak-express 2.0.0

package/src/Http/Middleware/MethodOverride.js

@@ -0,0 +1,26 @@
+class MethodOverride {
+    /**
+     * Handle the incoming request.
+     * 
+     * @param {object} data
+     * @param {Function} next
+     * @returns {any}
+     */
+    handle({ req, res }, next) {
+        if (req.method() === 'POST') {
+            const method = req.input('_method');
+
+            if (method) {
+                const upperMethod = method.toUpperCase();
+                if (['PUT', 'PATCH', 'DELETE'].includes(upperMethod)) {
+                    // Update the underlying express request method
+                    req.getOriginalRequest().method = upperMethod;
+                }
+            }
+        }
+
+        return next();
+    }
+}
+
+module.exports = MethodOverride;

package/src/Http/Request.js

@@ -0,0 +1,98 @@
+class Request {
+    /**
+     * Create a new Request instance.
+     * 
+     * @param {import('express').Request} req
+     */
+    constructor(req) {
+        this.req = req;
+        this.body = req.body || {};
+        this.query = req.query || {};
+        this.params = req.params || {};
+        this.headers = req.headers || {};
+    }
+
+    /**
+     * Get a value from the request input (body, query, or params).
+     * 
+     * @param {string} key
+     * @param {any} defaultValue
+     * @returns {any}
+     */
+    input(key, defaultValue = null) {
+        if (this.body[key] !== undefined) return this.body[key];
+        if (this.query[key] !== undefined) return this.query[key];
+        if (this.params[key] !== undefined) return this.params[key];
+
+        return defaultValue;
+    }
+
+    /**
+     * Get all input values.
+     * 
+     * @returns {object}
+     */
+    all() {
+        return { ...this.query, ...this.body, ...this.params };
+    }
+
+    /**
+     * Get a header value.
+     * 
+     * @param {string} key
+     * @param {any} defaultValue
+     * @returns {string|null}
+     */
+    header(key, defaultValue = null) {
+        return this.headers[key.toLowerCase()] || defaultValue;
+    }
+
+    /**
+     * Get the underlying Express request.
+     * 
+     * @returns {import('express').Request}
+     */
+    getOriginalRequest() {
+        return this.req;
+    }
+
+    /**
+     * Check if the request contains a given key.
+     * 
+     * @param {string} key
+     * @returns {boolean}
+     */
+    has(key) {
+        return this.input(key) !== null;
+    }
+
+    /**
+     * Get the request method.
+     * 
+     * @returns {string}
+     */
+    method() {
+        return this.req.method;
+    }
+
+    /**
+     * Get the request URL.
+     * 
+     * @returns {string}
+     */
+    url() {
+        return this.req.url;
+    }
+    /**
+     * Check if the request is an AJAX or API request.
+     * 
+     * @returns {boolean}
+     */
+    isApi() {
+        return this.header('X-Requested-With') === 'XMLHttpRequest' ||
+            this.header('Accept')?.includes('application/json') ||
+            this.url().startsWith('/api');
+    }
+}
+
+module.exports = Request;

package/src/Log/Logger.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class Logger {
+    /**
+     * Create a new Logger instance.
+     * 
+     * @param {import('../Foundation/Application')} app
+     */
+    constructor(app) {
+        this.app = app;
+    }
+
+    /**
+     * Log an info message.
+     */
+    info(message) {
+        this.write('INFO', message);
+    }
+
+    /**
+     * Log an error message.
+     */
+    error(message) {
+        this.write('ERROR', message);
+    }
+
+    /**
+     * Log a warning message.
+     */
+    warning(message) {
+        this.write('WARNING', message);
+    }
+
+    /**
+     * Write the message to the log file.
+     */
+    write(level, message) {
+        const timestamp = new Date().toISOString();
+        const formattedMessage = `[${timestamp}] ${level}: ${message}\n`;
+        const logPath = this.app.storagePath('logs/luak.log');
+
+        // Ensure directory exists (just in case)
+        const dir = path.dirname(logPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        fs.appendFileSync(logPath, formattedMessage);
+
+        // Also log to console for development visibility
+        console.log(formattedMessage.trim());
+    }
+}
+
+module.exports = Logger;

package/src/Routing/Controller.js

@@ -0,0 +1,50 @@
+class Controller {
+    /**
+     * Create a new Controller instance.
+     */
+    constructor() {
+        // Base controller logic
+    }
+
+    /**
+     * Send a JSON response.
+     * 
+     * @param {import('express').Response} res
+     * @param {object} data
+     * @param {number} status
+     */
+    json(res, data, status = 200) {
+        return res.status(status).json(data);
+    }
+
+    /**
+     * Send a success response.
+     * 
+     * @param {import('express').Response} res
+     * @param {object} data
+     * @param {string} message
+     */
+    success(res, data = {}, message = 'Success') {
+        return res.status(200).json({
+            success: true,
+            message,
+            data
+        });
+    }
+
+    /**
+     * Send an error response.
+     * 
+     * @param {import('express').Response} res
+     * @param {string} message
+     * @param {number} status
+     */
+    error(res, message = 'Error', status = 500) {
+        return res.status(status).json({
+            success: false,
+            message
+        });
+    }
+}
+
+module.exports = Controller;

package/src/Routing/Pipeline.js

@@ -0,0 +1,67 @@
+class Pipeline {
+    /**
+     * Create a new Pipeline instance.
+     * 
+     * @param {import('../Foundation/Application')} app
+     */
+    constructor(app) {
+        this.app = app;
+        this.pipes = [];
+    }
+
+    /**
+     * Set the object being sent through the pipeline.
+     * 
+     * @param {object} passable
+     * @returns {this}
+     */
+    send(passable) {
+        this.passable = passable;
+        return this;
+    }
+
+    /**
+     * Set the array of pipes.
+     * 
+     * @param {Array} pipes
+     * @returns {this}
+     */
+    through(pipes) {
+        this.pipes = pipes;
+        return this;
+    }
+
+    /**
+     * Run the pipeline with a final destination callback.
+     * 
+     * @param {Function} destination
+     * @returns {any}
+     */
+    then(destination) {
+        const pipeline = this.pipes.reduceRight((stack, pipe) => {
+            return () => {
+                // Resolve middleware from container if it's a string/class
+                let middleware = pipe;
+                if (typeof pipe === 'string' || (typeof pipe === 'function' && pipe.prototype)) {
+                    middleware = this.app.make(pipe);
+                }
+
+                if (typeof middleware.handle === 'function') {
+                    // It's a class middleware
+                    return middleware.handle(this.passable, stack);
+                }
+
+                if (typeof middleware === 'function') {
+                    // It's a functional middleware (passable, next)
+                    return middleware(this.passable, stack);
+                }
+
+                throw new Error('Invalid middleware type');
+            };
+        }, destination);
+
+        return pipeline();
+    }
+}
+
+module.exports = Pipeline;

package/src/Routing/Router.js

@@ -0,0 +1,163 @@
+const express = require('express');
+
+class Router {
+    /**
+     * Create a new Router instance.
+     * 
+     * @param {import('../Foundation/Application')} app
+     */
+    constructor(app) {
+        this.app = app;
+        this.router = express.Router();
+        this.groupStack = [];
+    }
+
+    /**
+     * Create a route group with shared attributes.
+     * 
+     * @param {object} attributes
+     * @param {Function} callback
+     */
+    group(attributes, callback) {
+        this.groupStack.push(attributes);
+        callback(this);
+        this.groupStack.pop();
+    }
+
+    /**
+     * Register a GET route.
+     * 
+     * @param {string} path
+     * @param {class|Function|Array} action
+     */
+    get(path, action) {
+        this.addRoute('get', path, action);
+        return this;
+    }
+
+    /**
+     * Register a POST route.
+     * 
+     * @param {string} path
+     * @param {class|Function|Array} action
+     */
+    post(path, action) {
+        this.addRoute('post', path, action);
+        return this;
+    }
+
+    /**
+     * Register a PUT route.
+     */
+    put(path, action) {
+        this.addRoute('put', path, action);
+        return this;
+    }
+
+    /**
+     * Register a PATCH route.
+     */
+    patch(path, action) {
+        this.addRoute('patch', path, action);
+        return this;
+    }
+
+    /**
+     * Register a DELETE route.
+     */
+    delete(path, action) {
+        this.addRoute('delete', path, action);
+        return this;
+    }
+
+    /**
+     * Register an OPTIONS route.
+     */
+    options(path, action) {
+        this.addRoute('options', path, action);
+        return this;
+    }
+
+    /**
+     * Register a route for all methods.
+     */
+    any(path, action) {
+        this.addRoute('all', path, action);
+        return this;
+    }
+
+    /**
+     * Register a route for specific methods.
+     * 
+     * @param {Array} methods 
+     * @param {string} path 
+     * @param {any} action 
+     */
+    match(methods, path, action) {
+        methods.forEach(method => {
+            this.addRoute(method.toLowerCase(), path, action);
+        });
+        return this;
+    }
+
+    /**
+     * Add route to the underlying Express router.
+     * 
+     * @param {string} method
+     * @param {string} path
+     * @param {any} action
+     */
+    addRoute(method, path, action) {
+        // Calculate Prefix
+        const prefix = this.groupStack.reduce((acc, group) => {
+            return acc + (group.prefix || '');
+        }, '');
+
+        const fullPath = (prefix + path).replace(/\/\//g, '/');
+
+        this.router[method](fullPath, (req, res, next) => {
+            const request = this.app.make('request');
+            this.dispatch(action, request, res, next);
+        });
+    }
+
+    /**
+     * Dispatch the request to the controller/action.
+     * 
+     * @param {any} action
+     * @param {import('../Http/Request')} req
+     * @param {object} res
+     * @param {Function} next
+     */
+    dispatch(action, req, res, next) {
+        // Handle [Controller, 'method'] syntax
+        if (Array.isArray(action)) {
+            const [ControllerClass, method] = action;
+
+            // Resolve Controller from Container (DI happens here!)
+            const controller = this.app.build(ControllerClass);
+
+            if (typeof controller[method] === 'function') {
+                return controller[method](req, res, next);
+            }
+        }
+
+        // Handle Closure
+        if (typeof action === 'function') {
+            return action(req, res, next);
+        }
+
+        throw new Error('Invalid route action.');
+    }
+
+    /**
+     * Get the Express router instance.
+     * 
+     * @returns {import('express').Router}
+     */
+    getExpressRouter() {
+        return this.router;
+    }
+}
+
+module.exports = Router;

package/src/Support/Facade.js

@@ -0,0 +1,69 @@
+class Facade {
+    /**
+     * Get the registered name of the component.
+     * 
+     * @throws {Error}
+     * @returns {string}
+     */
+    static getFacadeAccessor() {
+        throw new Error('Facade does not implement getFacadeAccessor method.');
+    }
+
+    /**
+     * Resolve the facade root instance from the container.
+     * 
+     * @returns {any}
+     */
+    static resolveFacadeInstance() {
+        const accessor = this.getFacadeAccessor();
+        if (!global.app) {
+            throw new Error('Application instance is not available globally.');
+        }
+        return global.app(accessor);
+    }
+
+    /**
+     * Handle dynamic static method calls.
+     * 
+     * @param {string} method
+     * @param {Array} args
+     * @returns {any}
+     */
+    static __callStatic(method, args) {
+        const instance = this.resolveFacadeInstance();
+
+        if (!instance) {
+            throw new Error(`Facade root [${this.getFacadeAccessor()}] has not been resolved.`);
+        }
+
+        if (typeof instance[method] !== 'function') {
+            throw new Error(`Method [${method}] does not exist on facade root [${this.getFacadeAccessor()}].`);
+        }
+
+        return instance[method](...args);
+    }
+}
+
+/**
+ * Create a Proxy to handle static method calls.
+ * 
+ * @param {typeof Facade} Target
+ * @returns {typeof Facade}
+ */
+const createFacade = (Target) => {
+    return new Proxy(Target, {
+        get: (target, prop, receiver) => {
+            // If the property exists on the class itself (like getFacadeAccessor), return it.
+            if (Reflect.has(target, prop)) {
+                return Reflect.get(target, prop, receiver);
+            }
+
+            // Otherwise, return a function that forwards the call to the instance.
+            return (...args) => {
+                return target.__callStatic(prop, args);
+            };
+        }
+    });
+};
+
+module.exports = { Facade, createFacade };

package/src/Support/Facades/Cache.js

@@ -0,0 +1,9 @@
+const { Facade, createFacade } = require('../Facade');
+
+class Cache extends Facade {
+    static getFacadeAccessor() {
+        return 'cache';
+    }
+}
+
+module.exports = createFacade(Cache);

package/src/Support/Facades/Config.js

@@ -0,0 +1,14 @@
+const { Facade, createFacade } = require('../Facade');
+
+class Config extends Facade {
+    /**
+     * Get the registered name of the component.
+     * 
+     * @returns {string}
+     */
+    static getFacadeAccessor() {
+        return 'config';
+    }
+}
+
+module.exports = createFacade(Config);

package/src/Support/Facades/Log.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { Facade, createFacade } = require('../Facade');
+
+class Log extends Facade {
+    /**
+     * Get the registered name of the component.
+     * 
+     * @returns {string}
+     */
+    static getFacadeAccessor() {
+        return 'log';
+    }
+}
+
+module.exports = createFacade(Log);

package/src/Support/Facades/Request.js

@@ -0,0 +1,14 @@
+const { Facade, createFacade } = require('../Facade');
+
+class Request extends Facade {
+    /**
+     * Get the registered name of the component.
+     * 
+     * @returns {string}
+     */
+    static getFacadeAccessor() {
+        return 'request';
+    }
+}
+
+module.exports = createFacade(Request);

package/src/Support/Facades/Route.js

@@ -0,0 +1,14 @@
+const { Facade, createFacade } = require('../Facade');
+
+class Route extends Facade {
+    /**
+     * Get the registered name of the component.
+     * 
+     * @returns {string}
+     */
+    static getFacadeAccessor() {
+        return 'router';
+    }
+}
+
+module.exports = createFacade(Route);

package/src/Support/ServiceProvider.js

@@ -0,0 +1,30 @@
+class ServiceProvider {
+    /**
+     * Create a new service provider instance.
+     * 
+     * @param {import('../Foundation/Application')} app
+     */
+    constructor(app) {
+        this.app = app;
+    }
+
+    /**
+     * Register any application services.
+     * 
+     * @returns {void}
+     */
+    register() {
+        //
+    }
+
+    /**
+     * Bootstrap any application services.
+     * 
+     * @returns {void}
+     */
+    boot() {
+        //
+    }
+}
+
+module.exports = ServiceProvider;