vboot 0.0.1

package/core/index.js

@@ -0,0 +1,739 @@
+const fs = require("fs");
+const path = require("path");
+const express = require("express");
+const core = require("./lib/core.js");
+// node接入证书
+var https = require('https');
+// 深度合并
+const deepmerge = require('deepmerge');
+// swagger
+const swaggerJSDoc = require('swagger-jsdoc');
+const swaggerUi = require('swagger-ui-express');
+const j2s = require('joi-to-swagger');
+const joi = require('joi');
+const payloadValidate = require('./middlewares/payloadValidate.js');
+const utils = require('./utils');
+const { pathToRegexp } = require('path-to-regexp');
+
+// 增加缓存机制
+const fileCache = new Map();
+
+// 插件系统
+class PluginManager {
+    register(hookName, fn) {
+        this.hooks[hookName] = this.hooks[hookName] || [];
+        this.hooks[hookName].push(fn);
+    }
+
+    async trigger(hookName, ...args) {
+        return Promise.all(this.hooks[hookName].map(fn => fn(...args)));
+    }
+}
+
+function isArrayOfStringsAndRegExp(arr) {
+    return Array.isArray(arr) && arr.every(item => typeof item === 'string' || item instanceof RegExp);
+}
+/**
+ * 拼接路径前缀和正则表达式路径，生成一个新的正则表达式
+ * @param {string} pathPrefix - 路径前缀字符串，例如 '/api/novel'
+ * @param {RegExp} pathRegex - 正则表达式路径，例如 /\/books\/\d+/
+ * @returns {RegExp} 拼接后的新正则表达式
+ */
+function combinePath(pathPrefix, path) {
+    if (!pathPrefix) {
+        return path;
+    }
+    if (typeof path === 'string') {
+        return pathPrefix + path;
+    }
+    // 转义路径前缀中的特殊字符，使其适配正则表达式
+    const escapedPrefix = pathPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    // 拼接前缀和正则表达式的源码部分
+    let pathNew = path.source.indexOf('^') === 0 ? path.source.substring(1) : path.source;
+    const combinedSource = escapedPrefix + pathNew;
+
+    // 创建新的正则表达式，继承原正则的标志（如 'i'、'g' 等）
+    return new RegExp(combinedSource, path.flags);
+}
+
+/**
+ * @description 基于express封装的mvc框架，遵循约定优于配置原则
+ */
+class VBoot {
+    // 添加静态实例属性
+    static _instance = null;
+    // 静态获取实例方法
+    static create(options = {}) {
+        if (VBoot._instance) {
+            throw new Error('实例已经存在，请使用 VBoot.getInstance() 获取实例');
+        }
+        VBoot._instance = new VBoot(options);
+        return VBoot._instance;
+    }
+    // 静态获取实例方法
+    static getInstance() {
+        if (!VBoot._instance) {
+            throw new Error('实例不存在，请使用 VBoot.create() 创建实例');
+        }
+        return VBoot._instance;
+    }
+    // 创建应用实例（工厂方法）
+    static createApp(options = {}) {
+        return new VBoot(options);
+    }
+    // 配置初始化
+    initConfig(customConfig) {
+        const baseConfig = require('./lib/config');
+        return deepmerge.all([
+            baseConfig,
+            customConfig || {}
+        ]);
+    }
+    constructor(options = {}) {
+        console.log('VBoot starting...');
+        //守卫（局部）中间件
+        this.guards = {};
+        // 扩展
+        this.extends = {};
+        // services
+        this.services = {};
+        this.utils = {};
+        this.plugins = new PluginManager();
+        // Express实例
+        this.app = express();
+        this.app.vithingInstance = this; // 反向引用
+        // 路由系统
+        this.router = express.Router();//路由实例
+        this.routers = [];//路由数据
+        // 配置系统
+        this.config = this.initConfig(options.config);
+        this.beforeStart = options.beforeStart || null;
+        this.beforeLoadRouter = options.beforeLoadRouter || null;
+
+        // 在Vithing类constructor中添加
+        this.swaggerSpec = swaggerJSDoc({
+            definition: {
+                openapi: '3.0.0',
+                info: {
+                    title: 'API Documentation',//TODO API系统名称
+                    version: '1.0.0',
+                }
+            },
+            apis: [] // 动态生成
+        });
+    }
+    // 加载本地配置
+    async loadLocalConfig() {
+        const configPath = path.join(this.config.SRC_PATH, "config/index.js");
+        if (fs.existsSync(configPath)) {
+            const localConfig = require(configPath);
+            // 合并本地配置 
+            this.config = deepmerge(this.config, localConfig);
+        }
+        console.log('============本地配置加载完成');
+    }
+    /**
+     * @description app核心模块：日志、favicon 图标、cookie、json、url、模板引擎、静态资源
+     */
+    loadCore() {
+        core(this.app, this.config);
+        console.log('============核心模块加载完成');
+    }
+    // 加载扩展工具
+    async loadExtends() {
+        // TODO 先加载默认扩展
+
+        // 再加载外部扩展
+        const extendPath = path.join(this.config.SRC_PATH, "extends/index.js");
+
+        if (fs.existsSync(extendPath)) {
+            let extendList = require(extendPath);
+            for (let index = 0; index < extendList.length; index++) {
+                const extend = extendList[index];
+                if (extend.name && extend.init) {
+                    // 挂载
+                    const service = await extend.init(this.app, this.config);
+                    this.extends[extend.name] = service;
+                }
+            }
+        }
+        console.log('============扩展工具加载完成');
+    }
+    /**
+     * 文件路径转模块名（去.js后缀）
+     *
+     * @param {any} rootDir 模块入口
+     * @param {any} postfix 需要的文件后缀
+     * @returns
+     */
+    scanDirModules(rootDir, postfix = '.js') {
+        if (fileCache.has(rootDir)) {
+            return fileCache.get(rootDir);
+        }
+        // 文件集合
+        const fileList = []
+        // 获取目录下的第一级子文件为路由文件队列
+        let filenames = fs.readdirSync(rootDir);
+        while (filenames.length) {
+            // 路由文件相对路径
+            const relativeFilePath = filenames.shift()
+            // 路由文件绝对路径
+            const absFilePath = path.join(rootDir, relativeFilePath);
+
+            if (fs.statSync(absFilePath).isDirectory()) {
+                // 是文件夹的情况下，读取子目录文件，添加到路由文件队列中
+                // const subFiles = fs.readdirSync(absFilePath).map(v => path.join(absFilePath.replace(rootDir, ''), v))
+                const relativePath = path.relative(rootDir, absFilePath);
+                const subFiles = fs.readdirSync(absFilePath).map(v => path.join(relativePath, v));
+
+                filenames = filenames.concat(subFiles)
+            } else {
+                // 是文件的情况下，先排除非文件
+                if (!absFilePath.endsWith(postfix)) {
+                    continue
+                }
+                fileList.push(absFilePath);
+            }
+        }
+        // 加入缓存
+        fileCache.set(rootDir, fileList);
+        return fileList
+    }
+    /**
+     * 文件路径转对象结构
+     *
+     * @param {any} rootDir 模块入口
+     * @param {any} needLast 需不需要最后一级
+     * @returns
+     */
+    pathToNestedObject(path, requireValue, needLast = true) {
+        const parts = path.replace('.js', '').split('\\');
+        if (!needLast) {
+            parts.pop();
+        }
+        if (parts[0] === '') {
+            parts.shift();
+        }
+        // 递归构建对象
+        function buildObject(parts, value) {
+            if (parts.length === 0) {
+                return value;
+            }
+            const key = parts.shift();
+            return {
+                [key]: buildObject(parts, value)
+            };
+        }
+
+        // 调用递归函数
+        return buildObject(parts, requireValue);
+    }
+    /**
+     * @description: 加载中间件
+     * @param {*} node 属性节点
+     * @param {*} isGlobal 是否全局中间件
+     * @return {*}
+     */
+    async loadMiddlewares(node, isGlobal = true) {
+        const extendPath = path.join(this.config.SRC_PATH, 'middlewares', node, "index.js");
+        if (!fs.existsSync(extendPath)) {
+            console.warn(extendPath + '未配置中间件');
+            return;
+        }
+        let middlewares;
+        try {
+            middlewares = require(extendPath);
+        } catch (error) {
+            console.error('中间件加载失败:', error);
+            return;
+        }
+        const list = Array.isArray(middlewares) ? middlewares : [];
+
+        for (const ware of list) {
+            if (!ware) {
+                console.warn('无效的中间件配置:中间件不存在');
+                continue;
+            }
+            if (typeof ware.execute !== 'function') {
+                console.warn('无效的中间件配置:execute需要是一个方法');
+                continue;
+            }
+
+            if (isGlobal) {
+                const path = ware.path || '/';
+                this.app.use(path, ware.execute);
+            } else {
+                if (!ware.name) {
+                    console.warn('❌ 守卫（局部）中间件缺少名称');
+                    continue;
+                }
+                this.guards[ware.name] = ware.execute;
+            }
+        }
+    }
+    /**
+     * @description: 加载前置全局中间件
+     * @return {*}
+     */
+    async loadGlobalMiddlewares() {
+        this.loadMiddlewares('globalMiddlewares');
+        console.log('============全局中间件加载完成');
+    }
+    /**
+     * @description: 加载局部守卫中间件
+     * @return {*}
+     */
+    async loadGuardMiddlewares() {
+        this.loadMiddlewares('guardMiddlewares', false);
+        console.log('============局部守卫中间件加载完成');
+    }
+
+    /**
+     * @description: 加载模块路由
+     * @return {*}
+     */
+    async loadModules(dirList, isCommon) {
+        let fileList;
+        if (isCommon) {
+            fileList = dirList.filter((f) => {
+                return f === path.join(this.config.SRC_PATH, "modules", "controller.js");
+            })
+        } else {
+            fileList = dirList.filter((f) => {
+                return f !== path.join(this.config.SRC_PATH, "modules", "controller.js") && f.endsWith('\\controller.js');
+            })
+        }
+        await this.loadControllers(fileList);
+    }
+    /**
+     * @description 扫描模块下所有router.js
+     * @param {*} moduleDir 模块路径
+     * @param {*} moduleName 模块名称
+     */
+    async loadServices(modulesDir, fileList) {
+        let list = fileList.filter((f) => {
+            return f.endsWith('\\service.js');
+        })
+        for (let i = 0; i < list.length; i++) {
+            const dir = list[i];
+            // 模块名
+            let filePath = dir.replace(modulesDir, '');
+            const requireValue = require(dir);
+            let obj = this.pathToNestedObject(filePath, requireValue, false)
+            this.services = deepmerge(this.services, obj);
+        }
+    }
+    /**
+     * 将文件名修正为前缀
+     *
+     * @param {String} filename
+     * @returns {String}
+     */
+    transform(filename) {
+        return filename.slice(0, filename.lastIndexOf('.'))
+            // 分隔符转换
+            .replace(/\\/g, '/')
+            // index去除
+            .replace('/index', '/')
+            // 路径头部/修正
+            .replace(/^[/]*/, '/')
+            // 去除/controller
+            .replace('/controller', '')
+            // 路径尾部/去除
+            .replace(/[/]*$/, '')
+    }
+
+    /**
+     * @description 扫描controller.js
+     * @param {*} moduleDir 模块路径
+     * @param {*} moduleName 模块名称
+     */
+    async loadControllers(fileList) {
+        let apiRouteList = [];
+        const modulesDir = path.join(this.config.SRC_PATH, "modules");
+
+        for (let i = 0; i < fileList.length; i++) {
+            const dir = fileList[i];
+            // 模块名
+            let filePath = dir.replace(modulesDir, '');
+            let prefix = this.transform(filePath);
+
+            const dirRouterMap = require(dir);
+            for (let key in dirRouterMap) {
+                let options = dirRouterMap[key];
+                let valid = options && options.handler && Object.prototype.toString.call(options.handler) === '[object Function]' || Object.prototype.toString.call(options.handler) === '[object AsyncFunction]'
+                if (!valid) {
+                    throw new Error(`API模块:${filePath}路由未成功导出`);
+                }
+
+                if (options.handler.length === 4) {
+                    // 错误处理中间件
+                    this.app.use(options.handler);
+                    continue;
+                }
+
+                if (!options.path) {
+                    if (options.method === 'use') {
+                        options.pathPrefix = '';
+                        options.path = '';
+                    } else {
+                        // 没传path默认用对应的属性名
+                        options.pathPrefix = prefix;
+                        options.path = `/${key}`;
+                    }
+                } else {
+                    if (options.isFullPath) {
+                        options.pathPrefix = '';
+                    } else {
+                        options.pathPrefix = prefix;
+                    }
+                }
+                if (!(typeof options.path === 'string' || isArrayOfStringsAndRegExp(options.path) || options.path instanceof RegExp)) {
+                    console.log(options.path)
+                    throw new Error('options.path 必须是字符串、正则、数组(字符串元素、正则元素)');
+                }
+                // 针对三种情况拼接完整的path
+                if (isArrayOfStringsAndRegExp(options.path)) {
+                    options.path = options.path.map(item => {
+                        return combinePath(options.pathPrefix, item);
+                    });
+                } else if (options.path instanceof RegExp) {
+                    // TODO 正则处理
+                    options.path = combinePath(options.pathPrefix, options.path);
+                } else {
+                    // string
+                    options.path = options.pathPrefix + options.path;
+                }
+
+                // 注意这里默认是use
+                let method = typeof options.method === 'string' ? options.method.trim().toLowerCase() : 'use';
+
+                let guards = options.guards || [];
+                let isApi = options.isApi;
+                let name = options.name || `${options.path}`;
+                let description = options.description || `${options.path}`;
+                let handler = options.handler;
+                let needLogin = options.needLogin ? true : false;
+                let permissions = options.permissions || [];
+                let requestSchema = options.requestSchema || {};
+                let responseSchema = options.responseSchema || {};
+
+                // TODO生成接口文档说明
+                if (this.config.showApiDocs && isApi) {
+                    let moduleName = options.pathPrefix || '/'; // 模块名
+                    // 转换路径参数
+                    const pathParams = requestSchema.params ? j2s(joi.object(requestSchema.params)).swagger : {};
+                    // 转换查询参数 
+                    const queryParams = requestSchema.query ? j2s(joi.object(requestSchema.query)).swagger : {};
+                    // 转换body参数
+                    const bodyParams = requestSchema.body ? j2s(joi.object(requestSchema.body)).swagger : {};
+                    // 生成swagger配置
+                    const parameters = [
+                        ...Object.entries(pathParams.properties || {}).map(([name, schema]) => ({
+                            name,
+                            in: 'path',
+                            schema
+                        })),
+                        ...Object.entries(queryParams.properties || {}).map(([name, schema]) => ({
+                            name,
+                            in: 'query',
+                            schema
+                        }))
+                    ];
+
+                    const pathItem = {
+                        [method]: {
+                            tags: [moduleName],
+                            summary: name,
+                            description: description,
+                            parameters: parameters,
+                            requestBody: {
+                                content: {
+                                    'application/json': {
+                                        schema: bodyParams
+                                    }
+                                }
+                            },
+                            responses: {
+                                200: {
+                                    description: 'Success response'
+                                }
+                            }
+                        }
+                    };
+                    this.swaggerSpec.paths[options.path] = {
+                        ...this.swaggerSpec.paths[options.path],
+                        ...pathItem
+                    };
+                }
+                const opt = {
+                    path: options.path,
+                    pathPrefix: options.pathPrefix,
+                    method,
+                    isApi,
+                    name,
+                    description,
+                    needLogin,
+                    permissions
+                }
+
+                // 添加路由,按顺序调用中间件
+                let router = express.Router();
+                let parList = [];
+                if (options.path) {
+                    parList.push(options.path)
+                }
+                if (guards && guards.length) {
+                    parList.push(...guards)
+                }
+                if (requestSchema && (requestSchema.body || requestSchema.query || requestSchema.params)) {
+                    parList.push(payloadValidate(requestSchema));
+                }
+                parList.push(handler);
+                router[method](...parList);
+                console.log('===========>>>>>------', method)
+                console.log('===========>>>>>------', parList)
+                this.router.use(router);
+
+
+                apiRouteList.push(opt);
+                if (router.stack && router.stack[0] && router.stack[0].route) {
+                    const rut = router.stack[0].route;
+                    this.router.customOptions = this.router.customOptions || [];
+
+                    const mtd = Object.keys(rut.methods).map(m => m.toUpperCase()).join(',');
+                    this.router.customOptions.push({
+                        ...opt,
+                        path: rut.path,
+                        methods: mtd,
+                        matchers: router.stack[0].matchers
+                    })
+
+                }
+            }
+        }
+
+        let filePath = path.join(this.config.ROOT_PATH, 'dist', 'apiRouteList.json')
+        utils.ensureFileExistence(path.resolve(filePath))
+        fs.writeFileSync(path.resolve(filePath), JSON.stringify(apiRouteList, null, 4))
+    }
+
+    /**
+     * @author: 
+     * @description: 加载api路由
+     * @param: 
+     * @return: 
+     */
+    async loadRouter() {
+        // 在路由加载前插入保护中间件
+        this.router.use((req, res, next) => {
+            if (res.headersSent) return;
+            next();
+        });
+        // 加载模块路由
+        const modulesDir = path.join(this.config.SRC_PATH, "modules");
+        if (!fs.existsSync(modulesDir)) {
+            console.log('============加载模块路由完成,未发现模块路由:', modulesDir);
+            return
+        }
+        const dirList = this.scanDirModules(modulesDir);
+        // 加载普通模块(api、web等等)
+        await this.loadModules(dirList);
+
+        if (this.config.showApiDocs) {
+            // swagger生成
+            let apiDocsPath = this.config.apiDocsPath ? this.config.apiDocsPath : '/api-docs';
+            this.app.use(apiDocsPath, swaggerUi.serve, swaggerUi.setup(this.swaggerSpec));
+            console.log('============生成swagger接口文档');
+            console.log(`查看接口文档请访问网站根目录${apiDocsPath}`);
+        }
+
+        // 加载公共路由(404处理、错误处理)
+        await this.loadModules(dirList, true);
+        // 获取路由模块列表并输出
+        if (this.router.customOptions) {
+            let filePath = path.join(this.config.ROOT_PATH, 'dist', 'customOptions.json')
+            utils.ensureFileExistence(path.resolve(filePath))
+            fs.writeFileSync(path.resolve(filePath), JSON.stringify(this.router.customOptions, null, 4))
+        }
+
+        // 注册路由
+        this.app.use(this.router);
+    }
+    /**
+     * @description: 加载ssl证书
+     * @return {*}
+     */
+    loadSsl() {
+        const sslDir = path.join(this.config.SRC_PATH, "ssl");
+        if (!fs.existsSync(sslDir)) {
+            throw new Error('SSL 目录不存在');
+        }
+        const keyFiles = this.scanDirModules(sslDir, '.key');
+        const certFiles = this.scanDirModules(sslDir, '.crt');
+
+        // 增加证书匹配验证
+        const certPairs = keyFiles.reduce((acc, keyFile) => {
+            const certFile = certFiles.find(f =>
+                path.basename(f, '.crt') === path.basename(keyFile, '.key')
+            );
+            if (certFile) acc.push({ key: keyFile, cert: certFile });
+            return acc;
+        }, []);
+
+        if (!certPairs.length) {
+            throw new Error('未找到有效的 SSL 证书文件');
+        }
+
+        try {
+            // https配置项
+            return certPairs.map(pair => ({
+                key: fs.readFileSync(pair.key, 'UTF8'),
+                cert: fs.readFileSync(pair.cert, 'UTF8')
+            }));
+        } catch (error) {
+            throw new Error(`SSL 证书读取失败: ${error.message}`);
+        }
+    }
+
+    async modelsHook(models) {
+        // 独立同步控制
+        const syncModels = async () => {
+            for (const model of Object.values(models)) {
+                try {
+                    console.log(`✅ Model ${model.name} 开始同步...`)
+                    await model.sync(model.syncOptions || {
+                        alter: process.env.ALTER_SYNC === 'true',
+                        force: process.env.FORCE_SYNC === 'true'
+                    });
+                    console.log(`✅ Model ${model.name} synced successfully`);
+
+                    // 插入初始化数据
+                    if (model.initData) {
+                        // 在syncModels循环内增加：
+                        const t = await model.sequelize.transaction();
+                        try {
+                            const count = await model.count({ transaction: t });
+
+                            if (count === 0) {
+                                await model.bulkCreate(model.initData(), {
+                                    transaction: t,
+                                    validate: true
+                                });
+                            }
+                            await t.commit();
+                        } catch (error) {
+                            await t.rollback();
+                            throw error;
+                        }
+                        console.log(`✅ Initial data inserted for ${model.name}`);
+                    }
+                } catch (error) {
+                    console.error(`❌ Error syncing model ${model.name}:`, error);
+                }
+            }
+        };
+
+        // 根据配置同步表模型到数据库和初始化数据
+        await syncModels()
+
+        // 创建关联关系（不做物理外键关联，仅做逻辑关联）
+        Object.values(models).forEach(model => {
+            if (model.associate) model.associate(models);
+        });
+    }
+    async loadModels() {
+        const modelsDir = path.join(this.config.SRC_PATH, "models");
+        if (fs.existsSync(modelsDir)) {
+            // 获取所有模型文件
+            const modelFiles = this.scanDirModules(modelsDir, '.js');
+            // 按最后一个文件夹分类
+            const dbModels = {};
+            modelFiles.forEach(filePath => {
+                // 提取数据库
+                const relativePath = path.relative(modelsDir, path.dirname(filePath));
+                const dbDir = relativePath.split(path.sep).join('_');
+
+                if (!dbModels[dbDir]) {
+                    dbModels[dbDir] = {};
+                }
+                const model = require(filePath);
+                dbModels[dbDir][model.name] = model;
+            })
+
+            // 注册模型
+            for (const dbDir in dbModels) {
+                if (dbModels.hasOwnProperty(dbDir)) {
+                    const modelList = dbModels[dbDir];
+                    await this.modelsHook(modelList)
+                }
+            }
+        }
+    }
+
+    async run(success, error) {
+        try {
+
+            this.beforeStart && await this.beforeStart();
+
+            // 加载本地配置
+            await this.loadLocalConfig();
+
+            // 加载核心（日志、favicon 图标、cookie、json、url、模板引擎、静态资源）
+            this.loadCore();
+
+            // 加载扩展，sequelize、mysql、redis、mailer等实例化，直接挂载到Vt下面
+            await this.loadExtends();
+
+            // 加载模型
+            await this.loadModels();
+
+            // 加载前置全局中间件
+            await this.loadGlobalMiddlewares();
+            // 加载守卫（局部）中间件
+            await this.loadGuardMiddlewares();
+
+            this.beforeLoadRouter && await this.beforeLoadRouter(this);
+
+            // TODO 后续要增加：加载插件路由
+            // 加载路由
+            await this.loadRouter();
+
+            const config = this.config;
+            const port = config.port || '81';
+            const useHttps = config.useHttps;
+
+            try {
+                if (useHttps) {
+                    let httpsOptions = this.loadSsl();
+                    // 创建https服务器，注意：一般设置https监听端口号443， http端口号为80。这里使用配置的端口号
+                    let httpsServer = https.createServer(httpsOptions, this.app);
+
+                    httpsServer.listen(port, function () {
+                        console.log(`VBoot's HTTPS server is running on port ${port}`);
+                        console.log('服务运行地址：%o', `https://localhost:${port}`);
+                        success && success()
+                    });
+                } else {
+                    this.app.listen(port, function () {
+                        console.log(`VBoot's HTTP server is running on port ${port}`);
+                        console.log('服务运行地址：%o', `http://localhost:${port}`);
+                        success && success()
+                    });
+                }
+
+            } catch (e) {
+                error && error(e)
+            }
+        } catch (e) {
+            console.error('VBoot startup failed:', e);
+            error && error(e);
+            // 可以考虑进程退出
+            process.exit(1);
+        }
+    }
+}
+
+// 导出
+module.exports = VBoot;

package/core/lib/config.js

@@ -0,0 +1,36 @@
+const path = require('path');
+
+/**
+ * @description 根目录
+ */
+const ROOT_PATH = process.cwd();
+
+/**
+ * @description 程序目录
+ */
+const SRC_PATH = path.join(ROOT_PATH, 'src');
+
+let config = {
+    JSON_LIMIT: "100kb",
+    env: 'dev',
+    template: 'default',
+    maxAge: '1d',
+    corsOptions: {},
+    showApiDocs: true,
+    apiDocsPath: '/api-docs',
+    database: {
+        client: "mysql2",
+        host: "localhost",
+        port: "3306",
+        user: "root",
+        password: "123456",
+        database: "vtsystem",
+        charset: "utf8mb4",
+    }
+}
+
+module.exports = {
+    ROOT_PATH,
+    SRC_PATH,
+    ...config
+}

package/core/lib/core.js

@@ -0,0 +1,51 @@
+/*
+ * @Author: tymon 573562310@qq.com
+ * @Date: 2024-08-11 19:53:34
+ * @LastEditors: tymon 573562310@qq.com
+ * @LastEditTime: 2024-08-11 19:57:17
+ * @FilePath: \vboot\core\lib\core.js
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+const express = require("express");
+const favicon = require("serve-favicon");
+const path = require("path");
+const cors = require('cors'); //处理跨域
+const fs = require('fs');
+
+module.exports = async function (app, config) {
+
+  const { SRC_PATH, maxAge, JSON_LIMIT, corsOptions } = config;
+
+  // favicon 图标
+  let faviconPath = path.join(SRC_PATH, "public/favicon.ico");
+  if (fs.existsSync(faviconPath)) {
+    app.use(favicon(faviconPath));
+  } else {
+    console.log('未配置favicon,可在src/public目录下进行配置')
+  }
+
+  // 注册cors跨域处理的中间件
+  app.use(cors(corsOptions));
+  // 配置解析 application/json 格式的中间件
+  app.use(express.json({ limit: JSON_LIMIT }));
+  // 配置解析 application/x-www-form-urlencoded 格式的表单数据的中间件
+  app.use(express.urlencoded({ extended: false }));
+
+  // 开放静态资源文件
+  const publicDir = path.join(SRC_PATH, "public");
+  app.use(
+    "/public",
+    express.static(publicDir, {
+      maxAge: maxAge,
+    })
+  );
+
+  // 模板的路径
+  const viewsDir = path.join(SRC_PATH, 'views');
+  app.set('views', viewsDir);
+  // 模板后缀
+  app.set('view engine', 'html');
+  // 指定渲染后缀为 html 的模板引擎
+  app.engine('html', require('express-art-template'));
+
+};

package/core/middlewares/payloadValidate.js

@@ -0,0 +1,43 @@
+/*
+ * 描述: 封装的joi校验中间件
+ */
+
+const Joi = require('joi')
+
+module.exports = function (schemas, options = { strict: false }) {
+  // 自定义校验选项
+  // strict 自定义属性，是否开启严格模式，默认不开启
+  if (!options.strict) {
+    // allowUnknown 允许提交未定义的参数项
+    // stripUnknown 过滤掉那些未定义的参数项
+    options = { allowUnknown: true, stripUnknown: false, ...options }
+  }
+
+  // 从 options 配置对象中，删除自定义的 strict 属性
+  delete options.strict
+
+  // TODO: 用户指定了什么 schema，就应该校验什么样的数据
+  return function (req, res, next) {
+    ['body', 'query', 'params'].forEach(key => {
+      // 如果当前循环的这一项 schema 没有提供，则不执行对应的校验
+      if (!schemas[key]) return
+
+      // 执行校验
+      const schema = Joi.object(schemas[key])
+      const { error, value } = schema.validate(req[key], options)
+
+      if (error) {
+        console.error('joi-error:', error);
+        // 校验失败
+        throw error
+      } else {
+        // 校验成功，把校验的结果重新赋值到 req 对应的 key 上
+        req[key] = value
+      }
+    })
+
+    // 校验通过
+    next()
+  }
+}
+

package/core/utils/index.js

@@ -0,0 +1,24 @@
+const path = require('path');
+const fs = require('fs');
+
+// 判断文件、文件夹是否存在，不存在则创建
+exports.ensureFileExistence = function (filePath) {
+    // 获取文件目录路径
+    const dirPath = path.dirname(filePath);
+
+    // 确保目录存在
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+        console.log(`Directory ${dirPath} created.`);
+    } else {
+        console.log(`Directory ${dirPath} already exists.`);
+    }
+
+    // 确保文件存在
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '', 'utf8'); // 创建空文件
+        console.log(`File ${filePath} created.`);
+    } else {
+        console.log(`File ${filePath} already exists.`);
+    }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "vboot",
+  "version": "0.0.1",
+  "description": "vtcore一个基于express的轻量级框架",
+  "main": "core/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "keywords": [
+    "vboot",
+    "vithing",
+    "express"
+  ],
+  "author": "tymoony",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "art-template": "^4.13.2",
+    "cors": "^2.8.5",
+    "deepmerge": "^4.3.1",
+    "express": "^5.1.0",
+    "express-art-template": "^1.0.1",
+    "joi": "^17.13.3",
+    "joi-to-swagger": "^6.1.1",
+    "mysql2": "^3.11.0",
+    "path-to-regexp": "^8.0.0",
+    "sequelize": "^6.37.3",
+    "serve-favicon": "^2.5.0",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^4.6.2"
+  },
+  "volta": {
+    "node": "18.20.4"
+  }
+}

package/readme.md

@@ -0,0 +1,2 @@
+一个基于express的轻量级开发框架
+约定大于配置

package/test/index.js

@@ -0,0 +1,16 @@
+const VBoot = require('../core/index');
+const vt = VBoot.create({
+    config: {
+        port: 3000,
+        useHttps: false
+    },
+    beforeStart: () => { },
+    beforeLoadRouter: async () => {
+        console.log('=======app:');
+    },
+});
+
+// TODO请求数据库获取配置
+vt.run(() => {
+    console.log("系统启动成功");
+});