npm - @seip/blue-bird - Versions diffs - 0.1.0 - Mend

@seip/blue-bird 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/core/template.js ADDED Viewed

@@ -0,0 +1,223 @@
+import ejs from "ejs";
+import path from "node:path";
+import fs from "node:fs";
+import Config from "./config.js";
+import Logger from "./logger.js";
+const __dirname = Config.dirname();
+const props = Config.props();
+/**
+ * Template engine wrapper using EJS, providing helper functions and React island support.
+ */
+class Template {
+    /**
+     * Renders an EJS template with the provided context and helper functions.
+     * @param {string} template - The template name (without .ejs extension).
+     * @param {Object} [context={}] - Data to pass to the template.
+     * @param {import('express').Response} res - The Express response object.
+     * @returns {Promise<void>}
+     */
+    static async render(template, context = {}, res) {
+        try {
+            const templatePath = path.join(__dirname, "templates", `${template}.ejs`);
+            const helpers = {
+                asset: (file) => this.asset(file),
+                url: (p = "") => this.url(p),
+                react: (component, props = {}) => this.react(component, props),
+                vite_assets: () => this.vite_assets()
+            };
+            const fullContext = {
+                ...props,
+                ...helpers,
+                ...context
+            };
+            const html = await ejs.renderFile(templatePath, fullContext);
+            const minifiedHtml = this.minifyHtml(html);
+            res.send(minifiedHtml);
+        } catch (error) {
+            const logger = new Logger();
+            logger.error(`Template render error: ${error.message}`);
+            if (props.debug) {
+                res.status(500).send(`<pre>${error.stack}</pre>`);
+            } else {
+                res.status(500).send("Internal Server Error");
+            }
+        }
+    }
+    /**
+     * Generates a URL for a static asset.
+     * @param {string} file - The asset path.
+     * @returns {string} The full asset URL.
+     */
+    static asset(file) {
+        return `${props.host}:${props.port}/public/${file.replace(/^\//, "")}`;
+    }
+    /**
+     * Generates a full URL for the given path.
+     * @param {string} [p=""] - The relative path.
+     * @returns {string} The full URL.
+     */
+    static url(p = "") {
+        const cleanPath = p.replace(/^\//, "");
+        return `${props.host}:${props.port}/${cleanPath}`;
+    }
+    /**
+     * Renders a React component as an HTML string.
+     * @param {string} component - The React component name.
+     * @param {Object} [componentProps={}] - Props to pass to the component.
+     * @param {string} [classBody=""] - Class name to add to the body tag.
+     * @param {Array<Object>} [optionsHead=[]] - Array of objects with tag and attributes for head tags.
+     * @returns {string} The HTML string of the React component.
+     */
+    static renderReact(res, component = "App", propsReact = {}, classBody = "", optionsHead = []) {
+        const html = `
+<!DOCTYPE html>
+<html lang="${props.langMeta}">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${props.titleMeta}</title>
+    <meta name="description" content="${props.descriptionMeta}">
+    <meta name="keywords" content="${props.keywordsMeta}">
+    <meta name="author" content="${props.authorMeta}">
+    ${optionsHead.map(item => `<${item.tag} ${Object.entries(item.attrs).map(([key, value]) => `${key}="${value}"`).join(" ")}></${item.tag}>`).join("")}
+</head>
+<body class="${classBody}">
+    ${this.react(component, propsReact)}
+    ${this.vite_assets()}
+</body>
+</html>
+        `
+        res.type("text/html");
+        res.status(200);
+        res.setHeader("Content-Type", "text/html");
+        return res.send(this.minifyHtml(html));
+    }
+    /**
+     * Generates a container for a React island component.
+     * @param {string} component - The React component name.
+     * @param {Object} [componentProps={}] - Props to pass to the component.
+     * @returns {string} The HTML container with data attributes for hydration.
+     */
+    static react(component, componentProps = {}) {
+        const id = `react-${Math.random().toString(36).substr(2, 9)}`;
+        const propsJson = JSON.stringify(componentProps).replace(/'/g, "&apos;");
+        return `<div id="${id}" data-react-component="${component}" data-props='${propsJson}'></div>`;
+    }
+    /**
+     * Generates script and link tags for Vite-managed assets.
+     * Handles both development (Vite dev server) and production (manifest.json) modes.
+     * @returns {string} The HTML tags for scripts and styles.
+     */
+    static vite_assets() {
+        if (props.debug) {
+            return `
+                <script type="module">
+                    import RefreshRuntime from "http://localhost:5173/build/@react-refresh";
+                    RefreshRuntime.injectIntoGlobalHook(window);
+                    window.$RefreshReg$ = () => {};
+                    window.$RefreshSig$ = () => (type) => type;
+                    window.__vite_plugin_react_preamble_installed__ = true;
+                </script>
+                <script type="module" src="http://localhost:5173/build/@vite/client"></script>
+                <script type="module" src="http://localhost:5173/build/Main.jsx"></script>`;
+        }
+        const buildPath = path.join(__dirname, props.static.path, "build");
+        let manifestPath = path.join(buildPath, "manifest.json");
+        if (!fs.existsSync(manifestPath)) {
+            manifestPath = path.join(buildPath, ".vite", "manifest.json");
+        }
+        if (fs.existsSync(manifestPath)) {
+            try {
+                const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+                const entry = manifest["Main.jsx"];
+                if (entry) {
+                    const file = entry.file;
+                    const css = entry.css || [];
+                    let html = `<script type="module" src="/build/${file}"></script>`;
+                    css.forEach(cssFile => {
+                        html += `<link rel="stylesheet" href="/build/${cssFile}">`;
+                    });
+                    return html;
+                }
+            } catch (e) {
+                return `<!-- Error parsing Vite manifest: ${e.message} -->`;
+            }
+        }
+        return `<!-- Vite Manifest not found at ${manifestPath} -->`;
+    }
+    /**
+     * Renders a full HTML page with a React component as the main entry point.
+     * Useful for SPAs or full-page React modules.
+     * @param {import('express').Response} res - The Express response object.
+     * @param {string} component - The React component name.
+     * @param {Object} [componentProps={}] - Props to pass to the React component.
+     * @param {Object} [metaOverrides={}] - Metadata overrides (title, description, keywords, etc.).
+     */
+    static reactRender(res, component, componentProps = {}, metaOverrides = {}) {
+        const meta = {
+            title: props.titleMeta,
+            description: props.descriptionMeta,
+            keywords: props.keywordsMeta,
+            author: props.authorMeta,
+            lang: props.langMeta,
+            ...metaOverrides
+        };
+        const scriptsReact = this.vite_assets();
+        const componentHtml = this.react(component, componentProps);
+        const html = `
+<!DOCTYPE html>
+<html lang="${meta.lang}">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${meta.title}</title>
+    <meta name="description" content="${meta.description}">
+    <meta name="keywords" content="${meta.keywords}">
+    <meta name="author" content="${meta.author}">
+    ${scriptsReact}
+</head>
+<body>
+    ${componentHtml}
+</body>
+</html>`;
+        res.send(this.minifyHtml(html));
+    }
+    /**
+     * Minifies the HTML output by removing comments and excessive whitespace.
+     * @param {string} html - The raw HTML string.
+     * @returns {string} The minified HTML string.
+     */
+    static minifyHtml(html) {
+        return html
+            .replace(/<!--(?!\[if).*?-->/gs, "")
+            .replace(/>\s+</g, "><")
+            .replace(/\s{2,}/g, " ")
+            .trim();
+    }
+}
+export default Template;

package/core/upload.js ADDED Viewed

@@ -0,0 +1,70 @@
+import multer from "multer";
+import path from "node:path";
+import fs from "node:fs";
+import Config from "./config.js";
+const __dirname = Config.dirname();
+const props = Config.props();
+/**
+ * Upload helper to manage file uploads using multer.
+ */
+class Upload {
+    /**
+     * Configures storage for uploaded files.
+     * @param {string} folder - The destination folder within the static path.
+     * @returns {import('multer').StorageEngine}
+     */
+    static storage(folder = "uploads") {
+        const dest = path.join(__dirname, props.static.path, folder);
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+        }
+        return multer.diskStorage({
+            destination: (req, file, cb) => {
+                cb(null, dest);
+            },
+            filename: (req, file, cb) => {
+                const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1e9);
+                cb(null, uniqueSuffix + path.extname(file.originalname));
+            }
+        });
+    }
+    /**
+     * Returns a multer instance for single or multiple file uploads.
+     * @param {Object} options - Multer options.
+     * @param {string} [options.folder='uploads'] - Destination folder.
+     * @param {number} [options.fileSize=5000000] - Max file size in bytes (default 5MB).
+     * @param {Array<string>} [options.allowedTypes=[]] - Allowed mime types (e.g. ['image/png', 'image/jpeg']).
+     * @returns {import('multer').Multer}
+     */
+    static disk(options = {}) {
+        const { folder = "uploads", fileSize = 5000000, allowedTypes = [] } = options;
+        return multer({
+            storage: this.storage(folder),
+            limits: { fileSize },
+            fileFilter: (req, file, cb) => {
+                if (allowedTypes.length > 0 && !allowedTypes.includes(file.mimetype)) {
+                    return cb(new Error("File type not allowed"), false);
+                }
+                cb(null, true);
+            }
+        });
+    }
+    /**
+     * Helper to get the public URL of an uploaded file.
+     * @param {string} filename - The name of the file.
+     * @param {string} [folder='uploads'] - The folder where the file is stored.
+     * @returns {string} The full public URL.
+     */
+    static url(filename, folder = "uploads") {
+        return `${props.host}:${props.port}/public/${folder}/${filename}`;
+    }
+}
+export default Upload;

package/core/validate.js ADDED Viewed

@@ -0,0 +1,275 @@
+const messages_default = {
+    es: {
+        required: (f) => `El campo ${f} es obligatorio`,
+        min: (f, n) => `El campo ${f} debe tener al menos ${n} caracteres`,
+        max: (f, n) => `El campo ${f} no puede tener más de ${n} caracteres`,
+        email: (f) => `El campo ${f} debe ser un email válido`,
+        number: (f) => `El campo ${f} debe ser numérico`,
+        alpha: (f) => `El campo ${f} solo puede contener letras`,
+        alphanumeric: (f) => `El campo ${f} solo puede contener letras y números`,
+        boolean: (f) => `El campo ${f} debe ser verdadero o falso`,
+        date: (f) => `El campo ${f} debe ser una fecha válida`,
+        url: (f) => `El campo ${f} debe ser una URL válida`,
+        in: (f, v) => `El campo ${f} debe ser uno de: ${v.join(', ')}`,
+        equals: (f, v) => `El campo ${f} debe ser igual a ${v}`,
+        password: () => `La contraseña debe tener mayúsculas, minúsculas y números`,
+        pattern: (f) => `El campo ${f} no cumple el patrón requerido`
+    },
+    en: {
+        required: (f) => `${f} is required`,
+        min: (f, n) => `${f} must be at least ${n} characters`,
+        max: (f, n) => `${f} must be at most ${n} characters`,
+        email: (f) => `${f} must be a valid email`,
+        number: (f) => `${f} must be numeric`,
+        alpha: (f) => `${f} must contain only letters`,
+        alphanumeric: (f) => `${f} must contain only letters and numbers`,
+        boolean: (f) => `${f} must be true or false`,
+        date: (f) => `${f} must be a valid date`,
+        url: (f) => `${f} must be a valid URL`,
+        in: (f, v) => `${f} must be one of: ${v.join(', ')}`,
+        equals: (f, v) => `${f} must equal ${v}`,
+        password: () => `Password must contain uppercase, lowercase and numbers`,
+        pattern: (f) => `${f} does not match the required pattern`
+    },
+    pt: {
+        required: (f) => `O campo ${f} é obrigatório`,
+        min: (f, n) => `O campo ${f} deve ter pelo menos ${n} caracteres`,
+        max: (f, n) => `O campo ${f} não pode ter mais de ${n} caracteres`,
+        email: (f) => `O campo ${f} deve ser um email válido`,
+        number: (f) => `O campo ${f} deve ser numérico`,
+        alpha: (f) => `O campo ${f} só pode conter letras`,
+        alphanumeric: (f) => `O campo ${f} só pode conter letras e números`,
+        boolean: (f) => `O campo ${f} deve ser verdadeiro ou falso`,
+        date: (f) => `O campo ${f} deve ser uma data válida`,
+        url: (f) => `O campo ${f} deve ser uma URL válida`,
+        in: (f, v) => `O campo ${f} deve ser um de: ${v.join(', ')}`,
+        equals: (f, v) => `O campo ${f} deve ser igual a ${v}`,
+        password: () => `A senha deve conter maiúsculas, minúsculas e números`,
+        pattern: (f) => `O campo ${f} não corresponde ao padrão exigido`
+    },
+    br: {
+        required: (f) => `O campo ${f} é obrigatório`,
+        min: (f, n) => `O campo ${f} deve ter pelo menos ${n} caracteres`,
+        max: (f, n) => `O campo ${f} não pode ter mais de ${n} caracteres`,
+        email: (f) => `O campo ${f} deve ser um email válido`,
+        number: (f) => `O campo ${f} deve ser numérico`,
+        alpha: (f) => `O campo ${f} só pode conter letras`,
+        alphanumeric: (f) => `O campo ${f} só pode conter letras e números`,
+        boolean: (f) => `O campo ${f} deve ser verdadeiro ou falso`,
+        date: (f) => `O campo ${f} deve ser uma data válida`,
+        url: (f) => `O campo ${f} deve ser uma URL válida`,
+        in: (f, v) => `O campo ${f} deve ser um de: ${v.join(', ')}`,
+        equals: (f, v) => `O campo ${f} deve ser igual a ${v}`,
+        password: () => `A senha deve conter maiúsculas, minúsculas e números`,
+        pattern: (f) => `O campo ${f} não corresponde ao padrão exigido`
+    },
+    fr: {
+        required: (f) => `Le champ ${f} est obligatoire`,
+        min: (f, n) => `Le champ ${f} doit contenir au moins ${n} caractères`,
+        max: (f, n) => `Le champ ${f} ne peut pas contenir plus de ${n} caractères`,
+        email: (f) => `Le champ ${f} doit être un email valide`,
+        number: (f) => `Le champ ${f} doit être numérique`,
+        alpha: (f) => `Le champ ${f} ne peut contenir que des lettres`,
+        alphanumeric: (f) => `Le champ ${f} ne peut contenir que des lettres et des chiffres`,
+        boolean: (f) => `Le champ ${f} doit être vrai ou faux`,
+        date: (f) => `Le champ ${f} doit être une date valide`,
+        url: (f) => `Le champ ${f} doit être une URL valide`,
+        in: (f, v) => `Le champ ${f} doit être l'un de: ${v.join(', ')}`,
+        equals: (f, v) => `Le champ ${f} doit être égal à ${v}`,
+        password: () => `Le mot de passe doit contenir des majuscules, des minuscules et des chiffres`,
+        pattern: (f) => `Le champ ${f} ne correspond pas au modèle requis`
+    }
+};
+const validators = {
+    isEmpty: (value) => value === undefined || value === null || value === '',
+    isEmail: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+    isNumeric: (value) => !isNaN(value) && !isNaN(parseFloat(value)),
+    isAlpha: (value) => /^[a-zA-Z]+$/.test(value),
+    isAlphanumeric: (value) => /^[a-zA-Z0-9]+$/.test(value),
+    isBoolean: (value) => value === true || value === false || value === 'true' || value === 'false',
+    isISO8601: (value) => !isNaN(Date.parse(value)),
+    isURL: (value) => {
+        try {
+            new URL(value);
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    isLength: (value, { min, max }) => {
+        const len = String(value).length;
+        if (min !== undefined && len < min) return false;
+        if (max !== undefined && len > max) return false;
+        return true;
+    },
+    isIn: (value, values) => values.includes(value),
+    equals: (value, comparison) => value === comparison,
+    matches: (value, pattern) => pattern.test(value)
+};
+/**
+ * Comprehensive Validator class for handling multi-language data validation.
+ */
+class Validator {
+    /**
+     * Initializes the Validator instance with a schema and optional language settings.
+     * @param {Object} schema - Validation rules for each field (e.g., { email: { required: true, email: true } }).
+     * @param {string} [lang_default=null] - Default language for error messages (e.g., "en", "es").
+     * @param {Object} [messages=null] - Custom message overrides for validation rules.
+     */
+    constructor(schema, lang_default = null, messages = null) {
+        this.schema = schema;
+        this.lang_default = lang_default;
+        this.messages = messages ? messages : messages_default;
+    }
+    /**
+     * Validates the request body against the defined schema.
+     * @param {import('express').Request} req - The Express request object containing the body to validate.
+     * @returns {Promise<{success: boolean, error: boolean, errors: Array<{field: string, message: string}>, message: Array<string>, html: Array<string>}>} Validation results.
+     */
+    async validate(req) {
+        const lang = this.lang_default ? this.lang_default : req?.session?.lang || "es";
+        const msg = this.messages[lang] || this.messages.es;
+        const errors = [];
+        const messages = [];
+        const body = req.body || {};
+        for (const [field, config] of Object.entries(this.schema)) {
+            const value = body[field];
+            if (config.required && validators.isEmpty(value)) {
+                messages.push(config.messages?.required || msg.required(field));
+                errors.push({
+                    field: field,
+                    message: config.messages?.required || msg.required(field)
+                })
+                continue;
+            }
+            if (!validators.isEmpty(value)) {
+                if (config.min && !validators.isLength(value, { min: config.min })) {
+                    messages.push(config.messages?.min || msg.min(field, config.min));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.min || msg.min(field, config.min)
+                    })
+                }
+                if (config.max && !validators.isLength(value, { max: config.max })) {
+                    messages.push(config.messages?.max || msg.max(field, config.max));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.max || msg.max(field, config.max)
+                    })
+                }
+                if (config.email && !validators.isEmail(value)) {
+                    messages.push(config.messages?.email || msg.email(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.email || msg.email(field)
+                    })
+                }
+                if (config.number && !validators.isNumeric(value)) {
+                    messages.push(config.messages?.number || msg.number(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.number || msg.number(field)
+                    })
+                }
+                if (config.alpha && !validators.isAlpha(value)) {
+                    messages.push(config.messages?.alpha || msg.alpha(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.alpha || msg.alpha(field)
+                    })
+                }
+                if (config.alphanumeric && !validators.isAlphanumeric(value)) {
+                    messages.push(config.messages?.alphanumeric || msg.alphanumeric(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.alphanumeric || msg.alphanumeric(field)
+                    })
+                }
+                if (config.boolean && !validators.isBoolean(value)) {
+                    messages.push(config.messages?.boolean || msg.boolean(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.boolean || msg.boolean(field)
+                    })
+                }
+                if (config.date && !validators.isISO8601(value)) {
+                    messages.push(config.messages?.date || msg.date(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.date || msg.date(field)
+                    })
+                }
+                if (config.url && !validators.isURL(value)) {
+                    messages.push(config.messages?.url || msg.url(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.url || msg.url(field)
+                    })
+                }
+                if (config.in && !validators.isIn(value, config.in)) {
+                    messages.push(config.messages?.in || msg.in(field, config.in));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.in || msg.in(field, config.in)
+                    })
+                }
+                if (config.equals !== undefined && !validators.equals(value, config.equals)) {
+                    messages.push(config.messages?.equals || msg.equals(field, config.equals));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.equals || msg.equals(field, config.equals)
+                    })
+                }
+                if (config.password && !validators.matches(value, /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{6,}$/)) {
+                    messages.push(config.messages?.password || msg.password(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.password || msg.password(field)
+                    })
+                }
+                if (config.pattern && !validators.matches(value, config.pattern)) {
+                    messages.push(config.messages?.pattern || msg.pattern(field));
+                    errors.push({
+                        field: field,
+                        message: config.messages?.pattern || msg.pattern(field)
+                    })
+                }
+            }
+        }
+        if (errors.length > 0 || messages.length > 0) {
+            return {
+                success: false,
+                error: true,
+                errors: errors,
+                message: messages,
+                html: messages.map(e => `<p class="text-red-500 text-danger">${e}</p>`)
+            };
+        }
+        return { success: true, error: false, errors: [], message: [], html: [] };
+    }
+    /**
+     * Express middleware for automated validation of the request body.
+     * Returns a 400 Bad Request response with validation results if errors occur.
+     * @returns {Function} Express middleware function (req, res, next).
+     */
+    middleware() {
+        return async (req, res, next) => {
+            const result = await this.validate(req);
+            if (!result.success) {
+                return res.status(400).json(result);
+            }
+            next();
+        };
+    }
+}
+export default Validator

package/package.json ADDED Viewed

@@ -0,0 +1,39 @@
+{
+  "name": "@seip/blue-bird",
+  "version": "0.1.0",
+  "description": "Framework js",
+  "type": "module",
+  "bin": {
+    "blue-bird": "core/cli/init.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seip25/Blue-bird.git"
+  },
+  "keywords": [
+    "framework",
+    "js"
+  ],
+  "author": "Seip25",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/seip25/Blue-bird/issues"
+  },
+  "homepage": "https://seip25.github.io/Blue-bird/",
+  "scripts": {
+    "dev": "node --watch --env-file=.env backend/index.js",
+    "start": "node --env-file=.env backend/index.js",
+    "create-react-app": "node core/cli/react.js",
+    "react": "node core/cli/react.js",
+    "init": "node core/cli/init.js"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.6",
+    "ejs": "^4.0.1",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.2",
+    "multer": "^2.0.2"
+  }
+}