arcanajs 2.1.1 → 2.1.2

package/framework/lib/server/ArcanaJSServer.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArcanaJSServer = void 0;
+const compression_1 = __importDefault(require("compression"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const express_1 = __importDefault(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const helmet_1 = __importDefault(require("helmet"));
+const path_1 = __importDefault(require("path"));
+const ArcanaJSMiddleware_1 = require("./ArcanaJSMiddleware");
+const CsrfMiddleware_1 = require("./CsrfMiddleware");
+const DynamicRouter_1 = require("./DynamicRouter");
+const ResponseHandlerMiddleware_1 = require("./ResponseHandlerMiddleware");
+class ArcanaJSServer {
+    constructor(config) {
+        this.config = config;
+        this.app = (0, express_1.default)();
+        this.initialize();
+    }
+    initialize() {
+        let { staticDir = "public", distDir = "dist/public", indexFile = "dist/public/index.html", views, viewsContext, routes, layout, } = this.config;
+        if (!views && viewsContext) {
+            views = {};
+            viewsContext.keys().forEach((key) => {
+                const viewName = key.replace(/^\.\/(.*)\.tsx$/, "$1");
+                views[viewName] = viewsContext(key).default;
+            });
+        }
+        if (!views) {
+            // Auto-discovery using fs (Server-side only)
+            views = this.discoverViews();
+        }
+        if (!views || Object.keys(views).length === 0) {
+            console.warn("No views found. Please check your views directory.");
+            views = {};
+        }
+        // Security and Performance
+        this.app.use((0, helmet_1.default)({
+            contentSecurityPolicy: false,
+        }));
+        this.app.use((0, compression_1.default)());
+        this.app.use((0, cookie_parser_1.default)());
+        this.app.use((0, CsrfMiddleware_1.createCsrfMiddleware)());
+        this.app.use(ResponseHandlerMiddleware_1.responseHandler);
+        // Static files
+        this.app.use(express_1.default.static(path_1.default.resolve(process.cwd(), distDir), {
+            index: false,
+            maxAge: "1y",
+        }));
+        this.app.use(express_1.default.static(path_1.default.resolve(process.cwd(), staticDir), {
+            index: false,
+            maxAge: "1d",
+        }));
+        // ArcanaJS Middleware
+        this.app.use((0, ArcanaJSMiddleware_1.createArcanaJSMiddleware)({
+            views,
+            indexFile: path_1.default.resolve(process.cwd(), indexFile),
+            layout,
+        }));
+        // Custom Routes
+        if (routes) {
+            if (Array.isArray(routes)) {
+                routes.forEach((route) => this.app.use(route));
+            }
+            else {
+                this.app.use(routes);
+            }
+        }
+        // Dynamic Router
+        this.app.use((0, DynamicRouter_1.createDynamicRouter)(views));
+        // 404 Fallback
+        this.app.use((req, res) => {
+            res.status(404).renderPage("NotFoundPage");
+        });
+        // Error Handler
+        this.app.use((err, req, res, next) => {
+            console.error(err);
+            const message = process.env.NODE_ENV === "production"
+                ? "Internal Server Error"
+                : err.message;
+            res.status(500).renderPage("ErrorPage", { message });
+        });
+    }
+    discoverViews() {
+        const views = {};
+        const viewsDir = this.config.viewsDir
+            ? path_1.default.resolve(process.cwd(), this.config.viewsDir)
+            : path_1.default.resolve(process.cwd(), "src/views");
+        const traverse = (dir) => {
+            if (!fs_1.default.existsSync(dir))
+                return;
+            const files = fs_1.default.readdirSync(dir);
+            files.forEach((file) => {
+                const fullPath = path_1.default.join(dir, file);
+                const stat = fs_1.default.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    traverse(fullPath);
+                }
+                else if (file.endsWith(".tsx") || file.endsWith(".jsx")) {
+                    const relativePath = path_1.default.relative(viewsDir, fullPath);
+                    const viewName = relativePath.replace(/\.(tsx|jsx)$/, "");
+                    try {
+                        // Use __non_webpack_require__ if available to avoid Webpack bundling issues
+                        // or standard require if running in Node directly
+                        const requireFunc = typeof __non_webpack_require__ !== "undefined"
+                            ? __non_webpack_require__
+                            : module.require;
+                        // We need to register ts-node if we are requiring .tsx files directly
+                        // This is a simplified approach. In a real framework, we'd handle compilation.
+                        if (file.endsWith(".tsx") || file.endsWith(".ts")) {
+                            try {
+                                requireFunc("ts-node/register");
+                            }
+                            catch (e) {
+                                // Ignore if already registered or not found (might be pre-compiled)
+                            }
+                        }
+                        const pageModule = requireFunc(fullPath);
+                        views[viewName] = pageModule.default || pageModule;
+                    }
+                    catch (error) {
+                        console.error(`Failed to load view ${viewName}:`, error);
+                    }
+                }
+            });
+        };
+        traverse(viewsDir);
+        return views;
+    }
+    start() {
+        const PORT = this.config.port || process.env.PORT || 3000;
+        this.app.listen(PORT, () => {
+            console.log(`Server is running on http://localhost:${PORT}`);
+        });
+    }
+}
+exports.ArcanaJSServer = ArcanaJSServer;

package/framework/lib/server/ControllerBinder.d.ts

@@ -0,0 +1,4 @@
+import { NextFunction, Request, Response } from "express";
+export default class ControllerBinder {
+    static handle(controller: any, method: string): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+}

package/framework/lib/server/ControllerBinder.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ControllerBinder {
+    static handle(controller, method) {
+        // Instantiate the controller once (Singleton pattern) for performance
+        // This assumes controllers are stateless, which is best practice.
+        let instance;
+        try {
+            instance = new controller();
+        }
+        catch (e) {
+            // Fallback if controller is not a class or fails to instantiate
+            console.warn(`Failed to instantiate controller ${controller.name}`, e);
+            instance = controller;
+        }
+        return async (req, res, next) => {
+            try {
+                // Call the method
+                if (typeof instance[method] === "function") {
+                    await instance[method](req, res, next);
+                }
+                else {
+                    throw new Error(`Method ${method} not found on controller ${controller.name}`);
+                }
+            }
+            catch (error) {
+                next(error);
+            }
+        };
+    }
+}
+exports.default = ControllerBinder;

package/framework/lib/server/CsrfMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const createCsrfMiddleware: () => (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/framework/lib/server/CsrfMiddleware.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCsrfMiddleware = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const CSRF_COOKIE_NAME = "_csrf";
+const createCsrfMiddleware = () => {
+    return (req, res, next) => {
+        // 1. Generate or retrieve token
+        let token = req.cookies[CSRF_COOKIE_NAME];
+        if (!token) {
+            token = crypto_1.default.randomBytes(32).toString("hex");
+            res.cookie(CSRF_COOKIE_NAME, token, {
+                httpOnly: true,
+                secure: process.env.NODE_ENV === "production",
+                sameSite: "strict",
+            });
+        }
+        // 2. Expose token to the response locals (for injection into the view)
+        res.locals.csrfToken = token;
+        // 3. Verify token on state-changing methods
+        const method = req.method.toUpperCase();
+        if (["POST", "PUT", "DELETE", "PATCH"].includes(method)) {
+            const headerToken = req.headers["x-csrf-token"];
+            if (!headerToken || headerToken !== token) {
+                return res.status(403).json({ error: "Invalid CSRF Token" });
+            }
+        }
+        next();
+    };
+};
+exports.createCsrfMiddleware = createCsrfMiddleware;

package/framework/lib/server/DynamicRouter.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const createDynamicRouter: (views: Record<string, any>) => (req: Request, res: Response, next: NextFunction) => void;

package/framework/lib/server/DynamicRouter.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDynamicRouter = void 0;
+const createDynamicRouter = (views) => {
+    return (req, res, next) => {
+        // Remove leading slash
+        let path = req.path.substring(1);
+        // Handle root path mapping to "index" if not handled elsewhere
+        if (path === "") {
+            path = "index";
+        }
+        // 1. Exact match
+        if (views[path]) {
+            return res.renderPage(path, {});
+        }
+        // 2. Dynamic match
+        for (const viewName of Object.keys(views)) {
+            if (!viewName.includes("["))
+                continue;
+            // Convert view path to regex
+            // e.g., "users/[id]" -> "^users/([^/]+)$"
+            // We need to escape special regex characters first, but keep [ and ] for our logic
+            // Actually, simpler: split by '/' and match segments
+            const pageParts = viewName.split("/");
+            const pathParts = path.split("/");
+            if (pageParts.length !== pathParts.length)
+                continue;
+            let match = true;
+            const params = {};
+            for (let i = 0; i < pageParts.length; i++) {
+                const pagePart = pageParts[i];
+                const pathPart = pathParts[i];
+                if (pagePart.startsWith("[") && pagePart.endsWith("]")) {
+                    const paramName = pagePart.slice(1, -1);
+                    params[paramName] = pathPart;
+                }
+                else if (pagePart !== pathPart) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                return res.renderPage(viewName, {}, params);
+            }
+        }
+        // If not found, pass to the next middleware (usually 404 handler)
+        next();
+    };
+};
+exports.createDynamicRouter = createDynamicRouter;

package/framework/lib/server/ResponseHandlerMiddleware.d.ts

@@ -0,0 +1,27 @@
+import type { NextFunction, Request, Response } from "express";
+declare global {
+    namespace Express {
+        interface Response {
+            /**
+             * Sends a success response with a standard format.
+             *
+             * @param data - The data payload to include in the response (default: {}).
+             * @param message - A descriptive message for the success (default: "Success").
+             * @param status - The HTTP status code to return (default: 200).
+             * @returns The Express Response object.
+             */
+            success: (data?: string | object | null, message?: string, status?: number) => Response;
+            /**
+             * Sends an error response with a standard format.
+             *
+             * @param message - A descriptive message for the error (default: "Error").
+             * @param status - The HTTP status code to return (default: 500).
+             * @param error - Additional error details or object (default: null).
+             * @param data - Optional data payload to include in the error response (default: null).
+             * @returns The Express Response object.
+             */
+            error: (message?: string, status?: number, error?: string | object | null, data?: string | object | null) => Response;
+        }
+    }
+}
+export declare const responseHandler: (req: Request, res: Response, next: NextFunction) => void;

package/framework/lib/server/ResponseHandlerMiddleware.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseHandler = void 0;
+const responseHandler = (req, res, next) => {
+    res.success = (data = {}, message = "Success", status = 200) => {
+        return res.status(status).json({
+            success: true,
+            message,
+            data,
+            error: null,
+        });
+    };
+    res.error = (message = "Error", status = 500, error = null, data = null) => {
+        const errorResponse = error
+            ? typeof error === "object" && error !== null
+                ? error instanceof Error
+                    ? error.toString()
+                    : error
+                : error.toString()
+            : null;
+        return res.status(status).json({
+            success: false,
+            message,
+            data,
+            error: errorResponse,
+        });
+    };
+    next();
+};
+exports.responseHandler = responseHandler;

package/framework/lib/server/Router.d.ts

@@ -0,0 +1,94 @@
+import express, { Router as ExpressRouter, RequestHandler } from "express";
+/**
+ * Provides Routing syntax for defining routes with prefixes, middlewares, and groups
+ */
+export declare class Router {
+    private router;
+    private middlewareStack;
+    private prefixStack;
+    constructor();
+    /**
+     * Create a new router instance
+     */
+    static create(): Router;
+    /**
+     * Add middleware to the current stack
+     */
+    middleware(...middleware: RequestHandler[]): Router;
+    /**
+     * Add prefix to the current stack
+     */
+    prefix(prefix: string): Router;
+    /**
+     * Create a route group
+     */
+    group(callback: (router: Router) => void): Router;
+    /**
+     * Define a GET route
+     */
+    get(path: string, ...args: any[]): Router;
+    /**
+     * Define a POST route
+     */
+    post(path: string, ...args: any[]): Router;
+    /**
+     * Define a PUT route
+     */
+    put(path: string, ...args: any[]): Router;
+    /**
+     * Define a DELETE route
+     */
+    delete(path: string, ...args: any[]): Router;
+    /**
+     * Define a PATCH route
+     */
+    patch(path: string, ...args: any[]): Router;
+    /**
+     * Define an OPTIONS route
+     */
+    options(path: string, ...args: any[]): Router;
+    /**
+     * Get the underlying Express router
+     */
+    getRouter(): ExpressRouter;
+    /**
+     * Mount this router to an Express app or router
+     */
+    mount(app: express.Application | ExpressRouter, basePath?: string): void;
+    /**
+     * Clone the current router instance
+     */
+    private _clone;
+    /**
+     * Add a route to the router
+     */
+    private _addRoute;
+    /**
+     * Build the full path with prefixes
+     */
+    private _buildPath;
+    /**
+     * Build the route handler
+     */
+    private _buildHandler;
+}
+/**
+ * Static Route class for Laravel-like syntax
+ */
+export declare class Route {
+    private static _router;
+    static create(): Router;
+    static middleware(...middleware: RequestHandler[]): Router;
+    static prefix(prefix: string): Router;
+    static group(callback: (router: Router) => void): Router;
+    static get(path: string, ...args: any[]): Router;
+    static post(path: string, ...args: any[]): Router;
+    static put(path: string, ...args: any[]): Router;
+    static delete(path: string, ...args: any[]): Router;
+    static patch(path: string, ...args: any[]): Router;
+    static options(path: string, ...args: any[]): Router;
+    static getRouter(): ExpressRouter;
+    static mount(app: express.Application, basePath?: string): void;
+    static reset(): void;
+}
+export default Route;

package/framework/lib/server/Router.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = exports.Router = void 0;
+const express_1 = __importDefault(require("express"));
+const ControllerBinder_1 = __importDefault(require("./ControllerBinder"));
+/**
+ * Provides Routing syntax for defining routes with prefixes, middlewares, and groups
+ */
+class Router {
+    constructor() {
+        this.router = express_1.default.Router();
+        this.middlewareStack = [];
+        this.prefixStack = [];
+    }
+    /**
+     * Create a new router instance
+     */
+    static create() {
+        return new Router();
+    }
+    /**
+     * Add middleware to the current stack
+     */
+    middleware(...middleware) {
+        const newRouter = this._clone();
+        newRouter.middlewareStack = [...this.middlewareStack, ...middleware];
+        return newRouter;
+    }
+    /**
+     * Add prefix to the current stack
+     */
+    prefix(prefix) {
+        const newRouter = this._clone();
+        newRouter.prefixStack = [
+            ...this.prefixStack,
+            prefix.replace(/^\/|\/$/g, ""),
+        ];
+        return newRouter;
+    }
+    /**
+     * Create a route group
+     */
+    group(callback) {
+        callback(this);
+        return this;
+    }
+    /**
+     * Define a GET route
+     */
+    get(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("get", path, action, middlewares);
+    }
+    /**
+     * Define a POST route
+     */
+    post(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("post", path, action, middlewares);
+    }
+    /**
+     * Define a PUT route
+     */
+    put(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("put", path, action, middlewares);
+    }
+    /**
+     * Define a DELETE route
+     */
+    delete(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("delete", path, action, middlewares);
+    }
+    /**
+     * Define a PATCH route
+     */
+    patch(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("patch", path, action, middlewares);
+    }
+    /**
+     * Define an OPTIONS route
+     */
+    options(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("options", path, action, middlewares);
+    }
+    /**
+     * Get the underlying Express router
+     */
+    getRouter() {
+        return this.router;
+    }
+    /**
+     * Mount this router to an Express app or router
+     */
+    mount(app, basePath = "/") {
+        app.use(basePath, this.router);
+    }
+    /**
+     * Clone the current router instance
+     */
+    _clone() {
+        const newRouter = new Router();
+        newRouter.router = this.router;
+        newRouter.middlewareStack = [...this.middlewareStack];
+        newRouter.prefixStack = [...this.prefixStack];
+        return newRouter;
+    }
+    /**
+     * Add a route to the router
+     */
+    _addRoute(method, path, action, routeMiddlewares = []) {
+        const fullPath = this._buildPath(path);
+        const handler = this._buildHandler(action);
+        const flatMiddlewares = routeMiddlewares.flat(Infinity);
+        const middlewares = [...this.middlewareStack, ...flatMiddlewares, handler];
+        this.router[method](fullPath, ...middlewares);
+        return this;
+    }
+    /**
+     * Build the full path with prefixes
+     */
+    _buildPath(path) {
+        const cleanPath = path.replace(/^\//, "");
+        const prefixes = this.prefixStack.filter((p) => p !== "");
+        if (prefixes.length === 0) {
+            return `/${cleanPath}`;
+        }
+        return `/${prefixes.join("/")}/${cleanPath}`.replace(/\/+/g, "/");
+    }
+    /**
+     * Build the route handler
+     */
+    _buildHandler(action) {
+        if (typeof action === "function") {
+            return action;
+        }
+        if (Array.isArray(action) && action.length === 2) {
+            const [controller, method] = action;
+            return ControllerBinder_1.default.handle(controller, method);
+        }
+        throw new Error('Action must be a function or array [Controller, "method"]');
+    }
+}
+exports.Router = Router;
+/**
+ * Static Route class for Laravel-like syntax
+ */
+class Route {
+    static create() {
+        return Router.create();
+    }
+    static middleware(...middleware) {
+        return this._router.middleware(...middleware);
+    }
+    static prefix(prefix) {
+        return this._router.prefix(prefix);
+    }
+    static group(callback) {
+        return this._router.group(callback);
+    }
+    static get(path, ...args) {
+        return this._router.get(path, ...args);
+    }
+    static post(path, ...args) {
+        return this._router.post(path, ...args);
+    }
+    static put(path, ...args) {
+        return this._router.put(path, ...args);
+    }
+    static delete(path, ...args) {
+        return this._router.delete(path, ...args);
+    }
+    static patch(path, ...args) {
+        return this._router.patch(path, ...args);
+    }
+    static options(path, ...args) {
+        return this._router.options(path, ...args);
+    }
+    static getRouter() {
+        return this._router.getRouter();
+    }
+    static mount(app, basePath = "/") {
+        return this._router.mount(app, basePath);
+    }
+    static reset() {
+        this._router = new Router();
+    }
+}
+exports.Route = Route;
+Route._router = new Router();
+exports.default = Route;

package/framework/lib/server/default-index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <!--HEAD_CONTENT-->
+  </head>
+  <body>
+    <div id="root"><!--APP_CONTENT--></div>
+    <!--ARCANAJS_DATA_SCRIPT-->
+  </body>
+</html>

package/framework/lib/server.d.ts

@@ -0,0 +1,6 @@
+export * from "./server/ArcanaJSMiddleware";
+export * from "./server/ArcanaJSServer";
+export { default as ControllerBinder } from "./server/ControllerBinder";
+export * from "./server/DynamicRouter";
+export * from "./server/Router";
+export { default as Route } from "./server/Router";

package/framework/lib/server.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = exports.ControllerBinder = void 0;
+__exportStar(require("./server/ArcanaJSMiddleware"), exports);
+__exportStar(require("./server/ArcanaJSServer"), exports);
+var ControllerBinder_1 = require("./server/ControllerBinder");
+Object.defineProperty(exports, "ControllerBinder", { enumerable: true, get: function () { return __importDefault(ControllerBinder_1).default; } });
+__exportStar(require("./server/DynamicRouter"), exports);
+__exportStar(require("./server/Router"), exports);
+var Router_1 = require("./server/Router");
+Object.defineProperty(exports, "Route", { enumerable: true, get: function () { return __importDefault(Router_1).default; } });