@nitronjs/framework 0.2.2 → 0.2.4

package/lib/Route/Manager.js

@@ -1,286 +0,0 @@
-
-import Loader from "./Loader.js";
-import Paths from "../Core/Paths.js";
-import Config from "../Core/Config.js";
-
-class Route {
-    static #routes = [];
-    static #kernel = null;
-
-    static getSessionConfig() {
-        return Config.all("session");
-    }
-
-    static async getKernel() {
-        if (!this.#kernel) {
-            this.#kernel = (await import(Paths.kernelUrl())).default;
-        }
-        return this.#kernel;
-    }
-
-    static async setup(server) {
-        globalThis.route = (name, params, query) => this.route(name, params, query);
-
-        const Kernel = await this.getKernel();
-
-        for (const route of this.#routes) {
-            if (this.#shouldApplyCsrf(route)) {
-                route.middlewares.unshift("verify-csrf");
-            }
-
-            route.middlewares = route.middlewares.map(middleware => {
-                const [name, param] = middleware.split(":");
-
-                if (!Kernel.routeMiddlewares[name]) {
-                    throw new Error(`Middleware '${name}' is not defined in Kernel.js`);
-                }
-
-                // Wrap middleware handler for hot reload
-                const handler = Loader.wrapHandler(Kernel.routeMiddlewares[name].handler);
-
-                return (request, response) => {
-                    return handler(request, response, param);
-                }
-            });
-
-            // Wrap controller handler for hot reload
-            const handler = Loader.wrapHandler(route.handler);
-
-            server.route({
-                method: route.method,
-                url: route.url,
-                preHandler: route.middlewares,
-                handler
-            });
-        }
-    }
-
-    static getClientManifest() {
-        const manifest = {};
-        for (const route of this.#routes) {
-            if (route.name) {
-                manifest[route.name] = route.url;
-            }
-        }
-        return manifest;
-    }
-
-    static match(pathname, method = "GET") {
-        for (const route of this.#routes) {
-            if (route.method !== method) continue;
-
-            const pattern = route.url
-                .replace(/:[^/]+/g, "([^/]+)")
-                .replace(/\//g, "\\/");
-            const regex = new RegExp(`^${pattern}$`);
-            const match = pathname.match(regex);
-
-            if (match) {
-                const paramNames = (route.url.match(/:[^/]+/g) || [])
-                    .map(p => p.slice(1));
-                const params = {};
-                paramNames.forEach((name, i) => {
-                    params[name] = match[i + 1];
-                });
-                return { handler: route.handler, params, route };
-            }
-        }
-        return null;
-    }
-
-    static get (url, handler) {
-        return this.#add("GET", url, handler);
-    }
-
-    static post (url, handler) {
-        return this.#add("POST", url, handler);
-    }
-
-    static put (url, handler) {
-        return this.#add("PUT", url, handler);
-    }
-
-    static delete (url, handler) {
-        return this.#add("DELETE", url, handler);
-    }
-
-    static prefix (url) {
-        return this.#addGroup(url, [], [], null);
-    }
-
-    static middleware (handlers) {
-        if (typeof handlers === 'string') {
-            return this.#addGroup("", [handlers], [], null);
-        }
-        else if (Array.isArray(handlers)) {
-            return this.#addGroup("", handlers, [], null);
-        }
-    }
-
-    static name (name) {
-        return this.#addGroup("", [], [], name);
-    }
-
-    static #add (method, url, handler) {
-        const route = {
-            method,
-            url,
-            handler,
-            middlewares: []
-        };
-
-        this.#routes.push(route);
-
-        return new RouteItem(route);
-    }
-
-    static #addGroup (prefix, middlewares, routes, name) {
-        const options = {
-            prefix,
-            middlewares,
-            routes,
-            name
-        };
-
-        return new RouteGroup(options, this.#routes);
-    }
-
-    static #resolveRouteName (name, params = {}) {
-        const route = this.#routes.find(r => r.name === name);
-
-        if (!route) {
-            throw new Error(`Route '${name}' is not defined`);
-        }
-
-        let url = route.url;
-
-        for (const key in params) {
-            url = url.replace(`:${key}`, params[key]);
-        }
-
-        return url;
-    }
-
-    static #shouldApplyCsrf (route) {
-        const sessionConfig = this.getSessionConfig();
-        const csrf = sessionConfig.csrf;
-        
-        if (!csrf.enabled) {
-            return false;
-        }
-        
-        if (!csrf.methods.includes(route.method)) {
-            return false;
-        }
-        
-        for (const pattern of csrf.except) {
-            if (this.#matchPattern(route.url, pattern)) {
-                return false;
-            }
-        }
-        
-        return true;
-    }
-    
-    static #matchPattern (url, pattern) {
-        if (url === pattern) {
-            return true;
-        }
-        
-        if (pattern.includes('*')) {
-            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-
-            return regex.test(url);
-        }
-        
-        return false;
-    }
-
-    static route (name, params = {}, query = {}) {
-        let url = this.#resolveRouteName(name, params);
-        
-        if (query && Object.keys(query).length > 0) {
-            url += '?' + new URLSearchParams(query).toString();
-        }
-        
-        return url;
-    }
-}
-
-class RouteItem {
-    constructor (route) {
-        this.route = route;
-    }
-
-    middleware (handlers) {
-        if (typeof handlers === 'string') {
-            this.route.middlewares.push(handlers);
-        }
-        else if (Array.isArray(handlers)) {
-            this.route.middlewares.push(...handlers);
-        }
-
-        return this;
-    }
-
-    name (name) {
-        this.route.name = name;
-
-        return this;
-    }
-}
-
-class RouteGroup {
-    constructor (options, routes) {
-        this.groupOptions = options;
-        this.routes = routes;
-    }
-
-    prefix (url) {
-        this.groupOptions.prefix = url;
-
-        return this;
-    }
-
-    middleware (handlers) {
-        if (typeof handlers === 'string') {
-            this.groupOptions.middlewares.push(handlers);
-        }
-        else if (Array.isArray(handlers)) {
-            this.groupOptions.middlewares.push(...handlers);
-        }
-
-        return this;
-    }
-
-    name (name) {
-        this.groupOptions.name = name;
-
-        return this;
-    }
-
-    group (callback) {
-        const beforeRoutes = this.routes.length;
-        callback();
-        const newRoutes = this.routes.slice(beforeRoutes);
-
-        for (const route of newRoutes) {
-            if (this.groupOptions.prefix) {
-                if (route.url === "/") {
-                    route.url = this.groupOptions.prefix;
-                }
-                else {
-                    route.url = this.groupOptions.prefix + route.url;
-                }
-            }
-
-            if (route.name && this.groupOptions.name) {
-                route.name = this.groupOptions.name + route.name;
-            }
-
-            route.middlewares.unshift(...this.groupOptions.middlewares);
-        }
-    }
-}
-
-export default Route;

package/lib/Translation/Manager.js

@@ -1,49 +0,0 @@
-import fs from "fs";
-import path from "path";
-import Paths from "../Core/Paths.js";
-
-class TranslationManager {
-    static #cache = new Map();
-
-    static get(req, key, params = null) {
-        const currentLang = req.language;
-        const translation = this.#getTranslation(currentLang, key);
-
-        if (params) {
-            return this.#replaceParams(translation, params);
-        }
-
-        return translation;
-    }
-
-    static #getTranslation(lang, key) {
-        const langPath = path.join(Paths.langs, lang + ".json");
-
-        if (!fs.existsSync(langPath)) {
-            return key;
-        }
-
-        let translations = this.#cache.get(lang);
-
-        if (!translations) {
-            const langFile = fs.readFileSync(langPath, { encoding: "utf-8", flag: "r" });
-            translations = JSON.parse(langFile);
-            this.#cache.set(lang, translations);
-        }
-
-        return translations[key] || key;
-    }
-
-    static #replaceParams(text, params) {
-        Object.keys(params).forEach((key) => {
-            text = text.replaceAll(":" + key, params[key]);
-        });
-        return text;
-    }
-
-    static clearCache() {
-        this.#cache.clear();
-    }
-}
-
-export default TranslationManager;