jj.js 0.20.0 → 1.0.0-rc.2

package/README.md

@@ -6,7 +6,9 @@
 
 ## 📖 项目介绍
 
-jj.js 是一个模仿 ThinkPHP5 设计的轻量级 Node.js MVC 框架。基于 Proxy 实现了**类库自动加载**、**懒加载**和 **Class 自动实例化及单例化**技术，所有类库想用直接调用，系统会自动导入，无需手动 require/import。
+jj.js 是一个模仿 ThinkPHP5 设计的轻量级 Node.js MVC 框架。基于 Proxy 实现了**类库自动加载**、**懒加载**和 **Class 自动实例化及单例化**技术，所有类库想用就能直接调用，系统会自动导入，无需手动 require/import。
+
+框架采用**单应用无限子级**架构，在 `app/` 目录下可自由创建任意层级的子模块（如 `app/admin/`、`app/api/`），每个子级拥有独立的 controller、model、middleware 等，子级自动向上继承父级类库。
 
 ### ✨ 核心特性
 
@@ -16,7 +18,7 @@ jj.js 是一个模仿 ThinkPHP5 设计的轻量级 Node.js MVC 框架。基于 P
 | 🔄 **自动加载** | 系统类库、用户类库都支持自动加载、懒加载 |
 | 🎯 **智能实例化** | Class 自动生成单实例，节省内存开销 |
 | 🧩 **三级中间件** | 应用级、路由级、控制器级，方便插件及二次开发 |
-| 🌐 **多应用模式** | 支持单应用和多应用两种运行模式 |
+| 🌳 **单应用多级模式** | 单应用架构，支持无限子级分层，模块化更清晰 |
 | 📝 **完整类型提示** | 基于 JSDoc，自动生成应用端 types 类型文件 |
 
 ### 📍 项目地址
@@ -84,18 +86,24 @@ node server.js
 
 ```
 project/
-├── app/                    # 应用目录（默认应用，可改名）
+├── app/                    # 应用目录（根级，不可改名）
 │   ├── controller/         # 控制器目录（可改名）
 │   │   └── index.js        # 首页控制器
 │   ├── view/               # 模板目录（可改名）
 │   │   └── index/          # index 控制器模板
 │   │       └── index.htm   # 模板文件
-│   ├── middleware/         # 中间件目录（不可改名）
+│   ├── middleware/         # 中间件目录（可改名）
 │   ├── model/              # 模型目录（可改名）
 │   ├── pagination/         # 分页目录（可改名）
 │   ├── logic/              # 逻辑目录（可改名）
-│   └── ...                 # 其他自定义目录
-├── common/                 # 公共应用目录（可选）
+│   ├── admin/              # 子级模块（示例）
+│   │   ├── controller/     # 子级控制器
+│   │   ├── model/          # 子级模型
+│   │   ├── middleware/     # 子级中间件
+│   │   └── view/           # 子级模板
+│   ├── api/
+│   │   └── controller/     # API 子级控制器
+│   └── ...                 # 其他自定义目录或子级
 ├── config/                 # 配置目录（不可改名）
 │   ├── app.js              # 应用配置
 │   ├── db.js               # 数据库配置
@@ -117,13 +125,10 @@ project/
 | 目录 | 必需 | 说明 |
 |------|------|------|
 | `config/` | ❌ | 应用配置目录，所有配置参数放在这里，可简化为 `config.js` |
-| `app/` | ✅ | 默认应用目录，支持多应用时可创建 `app2`、`app3` 等 |
-| `common/` | ❌ | 公共应用目录，存放公共 model、logic 等 |
+| `app/` | ✅ | 应用根目录，支持无限子级分层（如 `app/admin/`、`app/api/`） |
 | `public/` | ❌ | 静态资源目录，在 `config/app.js` 中通过 `static_dir` 配置 |
 | `server.js` | ✅ | 应用入口文件，名字可任意修改 |
 
-> **多应用模式**：在 `./config/app.js` 中设置 `app_multi: true` 即可启用。
-
 ---
 
 ### 🏛️ 系统类库
@@ -213,25 +218,42 @@ module.exports = Index;
 
 **访问**：`http://127.0.0.1:3000/index/user`
 
-**加载流程**：
+#### 加载流程
 
 ```
 this.$db
   ↓
-1. 检查当前类实例是否有 $db 属性
-  ↓ (没有)
-2. 检查应用目录 ./app/db.js 或 ./app/db/
+1. 检查当前层级目录 ./app/[deep]/db.js 或 ./app/[deep]/db/
+  ↓ (没有，向上遍历父级)
+2. 检查父级目录 ./app/db.js 或 ./app/db/
   ↓ (没有)
-3. 检查应用根目录 ./db.js 或 ./db/
-  ↓ (没有)
-4. 检查框架 lib/db.js ✅ 找到！
+3. 检查框架 lib/db.js ✅ 找到！
   ↓
 自动实例化（单例）并返回 Db 实例
 ```
 
+> **向上继承**：子级模块可以访问父级定义的同名类库，自动向上查找最近的定义。系统类库（如 `$db`、`$model` 等）在应用目录找不到时，自动回退到框架内置类库。
+
 > **智能实例化**：调用 `this.$db.table('user')` 时，框架先检测是否有 `table` 静态方法，没有则自动 new 实例，然后调用实例方法。
 
-#### 示例 2：使用自定义模型
+#### 示例 2：子级模块
+
+在 `app/` 下创建子级目录即可实现模块化分层，每个子级拥有独立的 controller、model、middleware 等：
+
+```
+app/
+├── controller/index.js      # 根级控制器 → /index/index
+├── model/user.js            # 根级模型
+├── admin/
+│   ├── controller/index.js  # 子级控制器 → /admin/index/index
+│   └── model/admin.js       # 子级模型（可覆盖根级同名模型）
+└── api/
+    └── controller/index.js  # API 控制器 → /api/index/index
+```
+
+> **URL 规则**：URL 路径自动映射到子级，如 `/admin/index/index` 对应 `app/admin/controller/index.js` 的 `index` 方法。
+
+#### 示例 3：使用自定义模型
 
 **模型** `./app/model/user.js`：
 
@@ -270,12 +292,11 @@ async user() {
 ```javascript
 module.exports = {
     app_debug: false,              // 调试模式
-    app_multi: false,              // 是否开启多应用
-    default_app: 'app',            // 默认应用
+    default_deep: '',              // 默认应用深度（子级路径），为空表示 app 根目录
     default_controller: 'index',   // 默认控制器
     default_action: 'index',       // 默认方法
-    common_app: 'common',          // 公共应用
     controller_folder: 'controller', // 控制器目录名
+    middleware_folder: 'middleware', // 中间件目录名
     static_dir: '',                // 静态文件目录（为空关闭静态访问）
     koa_body: null                 // koa-body 配置（null 关闭）
 };
@@ -286,6 +307,11 @@ module.exports = {
 ```javascript
 module.exports = {
     default: {
+        type: 'sqlite',
+        database: ':memory:',   // 数据库文件绝对路径，支持 :memory: 内存数据库
+        prefix: 'jj_'
+    },
+    mysql: {
         type: 'mysql',
         host: '127.0.0.1',
         database: 'jj',
@@ -295,11 +321,6 @@ module.exports = {
         charset: 'utf8mb4',
         prefix: 'jj_'
     },
-    sqlite: {
-        type: 'sqlite',
-        database: ':memory:',
-        prefix: 'jj_'
-    },
     mongodb: {
         type: 'mongodb',
         host: '127.0.0.1',

package/jj.js

@@ -1,6 +1,6 @@
 /**
  * jj.js核心库<br/>
- * {App, Cache, Context, Controller, Cookie, Ctx, Db, Logger, Middleware, Model, Pagination, Request, Response, Upload, Url, View, utils, config}
+ * {App, Cache, Context, Controller, Cookie, Ctx, Db, Logger, Middleware, Model, Pagination, Request, Response, Upload, Url, View, utils, config, loader}
  * @module core
  * @type {import('./types').Core}
  */

package/lib/app.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const Koa = require('koa');
-const {app: cfg_app, cookie: cfg_cookie} = require('./config');
+const config = require('./config');
+const {app: cfg_app, cookie: cfg_cookie} = config;
 const loader = require('./loader');
 const Logger = require('./logger');
 const Response = require('./response');
@@ -46,9 +47,16 @@ class App extends Koa
         this.use(async (ctx, next) => {
             ctx.APP_TIME = Date.now();
             ctx.APP_VERSION = pjson.version;
+            const _ = loader(cfg_app.base_dir, ctx);
+            _.config || (_.config = {});
+            Object.entries(config).forEach(([key, value]) => {
+                _.config[key] = value;
+            });
             await storage.run({
                 $: loader(__dirname, ctx),
-                _: loader(cfg_app.base_dir, ctx)
+                $$: _.app,
+                $config: _.config,
+                DEEP: '', // 初始化，防止后面报错
             }, async() => {
                 await next();
             });

package/lib/cache.js

@@ -75,7 +75,7 @@ class Cache
             this.cache.delete(key);
         } else {
             // @ts-ignore
-            this.cache = new Map();
+            this.cache.clear();
         }
     }
 

package/lib/config.js

@@ -4,17 +4,15 @@ const {format} = require('./utils/date');
 
 const app = {
     app_debug: false, // 调试模式
-    app_multi: false, // 是否开启多应用
 
-    default_app: 'app', // 默认应用
+    default_deep: '', // 默认应用深度，为空表示app根目录
     default_controller: 'index', //默认控制器
     default_action: 'index', // 默认方法
 
-    common_app: 'common', // 公共应用，存放公共模型及逻辑
     controller_folder: 'controller', //控制器目录名
+    middleware_folder: 'middleware', //中间件目录名
 
     static_dir: '', // 静态文件目录，相对于应用根目录，为空时，关闭静态访问
-
     koa_body: null // koa-body配置参数，为null或空时，关闭koa-body
 }
 
@@ -22,12 +20,22 @@ const view = {
     view_folder: 'view', // 模板目录名
     view_depr: '/', // 模版文件名分割符，'/'代表二级目录
     view_ext: '.htm', // 模版后缀
-    view_engine: 'art-template', // 默认模版引擎，字符串或引擎类
+    view_engine: '@yafoo/art-template', // 默认模版引擎，字符串或引擎类
     view_filter: {}, // 模版函数
 }
 
 const db = {
     default: {
+        type      : 'sqlite', // 数据库类型
+        database  : ':memory:', // 数据库文件绝对地址，支持:memory:内存数据库
+        prefix    : 'jj_' // 数据库表前缀
+    },
+    sqlite: {
+        type      : 'sqlite', // 数据库类型
+        database  : ':memory:', // 数据库文件绝对地址，支持:memory:内存数据库
+        prefix    : 'jj_' // 数据库表前缀
+    },
+    mysql: {
         type      : 'mysql', // 数据库类型
         host      : '127.0.0.1', // 服务器地址
         database  : 'jj', // 数据库名
@@ -37,11 +45,6 @@ const db = {
         charset   : 'utf8mb4', // 数据库编码默认采用utf8mb4
         prefix    : 'jj_' // 数据库表前缀
     },
-    sqlite: {
-        type      : 'sqlite', // 数据库类型
-        database  : ':memory:', // 数据库文件绝对地址，支持:memory:内存数据库
-        prefix    : 'jj_' // 数据库表前缀
-    },
     mongodb: {
         type      : 'mongodb', // 数据库类型
         host      : '127.0.0.1', // 服务器地址
@@ -56,7 +59,7 @@ const db = {
 const log = {
     log_level: ['system', 'error'], // [system, error, warning, info, debug, http, sql]
     // @ts-ignore
-    log_handle: function(level, ...args) {console.log(`[${format('YY-mm-dd HH:ii:ss')}] [${level}]`, ...args.map(msg => typeof msg == 'object' ? JSON.stringify(msg) : String(msg)));}
+    log_handle: function(level, ...args) {console[level in console ? level : 'log'](`[${format('YY-mm-dd HH:ii:ss')}] [${level}]`, ...args.map(msg => typeof msg == 'object' ? JSON.stringify(msg) : String(msg)));}
 }
 
 const cache = {
@@ -100,20 +103,30 @@ const tpl = {
 }
 // @ts-ignore
 const base_dir = require.main.path;
-const base_config = loader(path.join(base_dir, './config'));
+const {
+    app: config_app,
+    view: config_view,
+    db: config_db,
+    log: config_log,
+    cache: config_cache,
+    page: config_page,
+    routes: config_routes,
+    cookie: config_cookie,
+    tpl: config_tpl
+} = loader(path.join(base_dir, './config')) || {};
 
 /**
  * @module config
  * @type {import('../types').Config}
  */
 module.exports = {
-    app: {...app, ...base_config.app, base_dir},
-    view: {...view, ...base_config.view},
-    db: {...db, ...base_config.db},
-    log: {...log, ...base_config.log},
-    cache: {...cache, ...base_config.cache},
-    page: {...page, ...base_config.page},
-    routes: base_config.routes,
-    cookie: {...cookie, ...base_config.cookie},
-    tpl: {...tpl, ...base_config.tpl}
+    app: {...app, ...config_app, base_dir},
+    view: {...view, ...config_view},
+    db: {...db, ...config_db},
+    log: {...log, ...config_log},
+    cache: {...cache, ...config_cache},
+    page: {...page, ...config_page},
+    routes: config_routes,
+    cookie: {...cookie, ...config_cookie},
+    tpl: {...tpl, ...config_tpl}
 };

package/lib/controller.js

@@ -1,14 +1,29 @@
 const Middleware = require('./middleware');
 
 /**
- * @typedef {import('../types').ViewInstance} ViewInstance
+ * @typedef {import('../types').ControllerMiddleware} ControllerMiddleware - Controller中间件
+ * @typedef {import('../types').ViewInstance} ViewInstance - View实例
  */
 
 /**
  * @extends Middleware
+ * @property {ControllerMiddleware[]} [middleware] - 控制器中间件
  */
 class Controller extends Middleware
 {
+    /**
+     * 初始化方法，在控制器方法执行前自动执行
+     * @protected
+     * @returns {any} - 返回Bool值false，则不会执行控制器及后续方法
+     */
+    _init() {}
+
+    /**
+     * 结束方法，在控制器方法执行后自动执行。如果控制器方法返回Bool值false，则不会执行此方法
+     * @protected
+     */
+    _end() {}
+
     /**
      * 模版数据赋值
      * @public

package/lib/ctx.js

@@ -1,58 +1,81 @@
-// @ts-nocheck
-const storage = require('./storage');
-// 允许$访问的系统类库
-const libs = ['ctx', 'context', 'cache', 'cookie', 'db', 'logger', 'middleware', 'model', 'pagination', 'request', 'response', 'upload', 'url', 'view', 'utils', 'config'];
-
-/**
- * 开发jj.js库本身时，需改为import('../types')
- * type {typeof import('../types')}
- * @type {typeof import('../../../types')}
- */
-const Ctx = new Proxy(class Ctx {}, {
-        construct() {
-            return new Proxy({__proto__: arguments[2].prototype}, {
-                get: (target, $prop, receiver) => {
-                    if($prop in target || typeof $prop == 'symbol' || $prop == 'inspect' || $prop == 'ctx' || $prop == '$next') {
-                        return Reflect.get(target, $prop, receiver);
-                    }
-
-                    const store = storage.getStore();
-                    if($prop == '$' || $prop == '_') {
-                        return store[$prop];
-                    }
-                    if($prop.slice(0, 1) != '$') {
-                        return undefined;
-                    }
-
-                    const {$, _, APP, COMMON} = store;
-                    const prop = $prop.slice(1);
-
-                    if(!_[APP]) {
-                        return libs.includes(prop) ? $[prop] : undefined;
-                    }
-
-                    if(!_[APP][prop] && !(_[COMMON] && _[COMMON][prop]) && !libs.includes(prop)) {
-                        return undefined;
-                    }
-
-                    return _[APP][$prop] = new Proxy(function() {}, {
-                        construct(target, args, newTarget) {
-                            const node = _[APP][prop] && _[APP][prop].__ISCLASS__ && _[APP][prop]
-                            || _[COMMON] && _[COMMON][prop].__ISCLASS__ && _[COMMON][prop]
-                            || libs.includes(prop) && $[prop].__ISCLASS__ && $[prop]
-                            || undefined;
-                            return node ? Reflect.construct(node, args, newTarget) : undefined;
-                        },
-                        get: (...args) => {
-                            return res = _[APP][prop] && _[APP][prop][args[1]]
-                            || _[COMMON] && _[COMMON][prop][args[1]]
-                            || libs.includes(prop) && $[prop][args[1]]
-                            || undefined;
-                        }
-                    });
-                }
-            });
-        }
-});
-
+// @ts-nocheck
+const storage = require('./storage');
+const path = require('path');
+const {app: cfg_app} = require('./config');
+const libs = require('./utils/libs').filter(lib => lib != 'config'); //排除config
+const {pathToDeep} = require('./utils/internal');
+
+/**
+ * 开发jj.js库本身时，需改为import('../types')
+ * type {typeof import('../types')}
+ * @type {typeof import('../../../types')}
+ */
+const Ctx = new Proxy(class Ctx {
+    _setDeep(mod) {
+        this.DEEP = pathToDeep(path.dirname(mod.path), cfg_app.base_dir);
+    }
+}, {
+    construct() {
+        return new Proxy({__proto__: arguments[2].prototype}, {
+            get: (target, $prop, receiver) => {
+                if($prop in target || typeof $prop == 'symbol' || $prop == 'inspect' || $prop == 'ctx' || $prop == '$next' || $prop == 'DEEP') {
+                    return Reflect.get(target, $prop, receiver);
+                }
+
+                const store = storage.getStore();
+                if($prop == '$' || $prop == '$$') {
+                    return store[$prop];
+                }
+                if($prop.slice(0, 1) != '$') {
+                    return undefined;
+                }
+
+                const {$, $$, $config, DEEP} = store;
+                const prop = $prop.slice(1);
+
+                const DEEPS = (target.DEEP !== undefined ? target.DEEP : DEEP).split('/').filter(Boolean);
+                const $nodes = [];
+
+                DEEPS.reduce((node, deep) => {
+                    if(!node) return;
+                    if(node[deep] && node[deep][prop]) $nodes.unshift(node[deep][prop]);
+                    return node[deep];
+                }, $$);
+
+                if(prop == 'config' && $config) $nodes.push($config);
+                if($$ && $$[prop]) $nodes.push($$[prop]);
+
+                if(!libs.includes(prop) && !$nodes.length) return undefined;
+                if(libs.includes(prop) && !$nodes.length) return $[prop];
+                if(!libs.includes(prop) && $nodes.length == 1) return $nodes[0];
+
+                target[$prop] = new Proxy(function() {}, {
+                    construct(_, args, newTarget) {
+                        const node = $nodes.find(node => node.__ISCLASS__)
+                        || libs.includes(prop) && $[prop].__ISCLASS__ && $[prop]
+                        || undefined;
+                        return node ? Reflect.construct(node, args, newTarget) : undefined;
+                    },
+                    get: (...args) => {
+                        const node = $nodes.find(node => args[1] in node) || libs.includes(prop) && args[1] in $[prop] && $[prop] || {};
+                        return Reflect.get(node, args[1], args[2]);
+                    },
+                    set: (...args) => {
+                        const node = $nodes.find(node => args[1] in node);
+                        if(node) {
+                            node[args[1]] = args[2];
+                        } else if(libs.includes(prop)) {
+                            $[prop][args[1]] = args[2];
+                        } else {
+                            return false;
+                        }
+                        return true;
+                    },
+                });
+                return Reflect.get(target, $prop, receiver);
+            }
+        });
+    }
+});
+
 module.exports = Ctx;

package/lib/db/sqlite.js

@@ -34,8 +34,34 @@ class Sqlite extends Sql
 
         let connection = connections.get(this._config);
         if(!connection) {
-            const sqlite3 = cfg_app.app_debug ? require('sqlite3').verbose() : require('sqlite3');
+            const sqlite3 = require('sqlite3');
+            cfg_app.app_debug && sqlite3.verbose();
             connection = new sqlite3.Database(this._config.database);
+            
+            // 性能优化：启用WAL模式，提升读写并发性能
+            await new Promise((resolve, reject) => {
+                connection.run('PRAGMA journal_mode = WAL;', (err) => {
+                    if(err) reject(err);
+                    else resolve();
+                });
+            });
+            
+            // 性能优化：配合WAL模式，减少不必要的磁盘同步
+            await new Promise((resolve, reject) => {
+                connection.run('PRAGMA synchronous = NORMAL;', (err) => {
+                    if(err) reject(err);
+                    else resolve();
+                });
+            });
+            
+            // 性能优化：设置锁等待超时时间，避免并发写入时直接报错
+            await new Promise((resolve, reject) => {
+                connection.run('PRAGMA busy_timeout = 5000;', (err) => {
+                    if(err) reject(err);
+                    else resolve();
+                });
+            });
+            
             connections.set(this._config, connection);
             this.logger.sql(`SQLITE数据库连接创建成功：{all: ${connections.size}}`);
         }
@@ -289,4 +315,4 @@ class Sqlite extends Sql
     }
 }
 
-module.exports = Sqlite;
+module.exports = Sqlite;