jj.js 0.6.1 → 0.7.3

package/README.md

@@ -1,2 +1,317 @@
-# jj.js（原名iijs）
+# jj.js
+
+![jj.js](https://me.i-i.me/static/images/jjjs.png "jj.js")
+
 A simple and lightweight MVC framework built on nodejs+koa2（一个基于nodejs+koa2构建的简单轻量级MVC框架）
+
+## 项目介绍
+
+> 框架依赖koa2、koa-router、art-template、mysql，基于proxy实现了代码自动加载及懒加载技术，最低依赖仅仅为koa和koa-router，非常轻量。系统架构类似Thinkphp5，很容易上手。支持类库自动加载、手工引入两种开发模式。支持应用、路由、控制器三级中间件，方便插件及二次开发。支持单应用和多应用两种运行模式。
+
+
+项目地址：[https://github.com/yafoo/jj.js](https://github.com/yafoo/jj.js "https://github.com/yafoo/jj.js")
+
+码云镜像：[https://gitee.com/yafu/jj.js](https://gitee.com/yafu/jj.js "https://gitee.com/yafu/jj.js")
+
+官网地址：[https://me.i-i.me/jjjs/](https://me.i-i.me/jjjs/ "https://me.i-i.me/jjjs/")
+	
+
+## 安装
+
+```bash
+npm i jj.js
+```
+
+## Hello world !
+
+1、创建文件 `./app/controller/index.js`
+
+```javascript
+const {Controller} = require('jj.js');
+
+class Index extends Controller
+{
+    async index() {
+        this.$show('Hello jj.js, hello world !');
+    }
+}
+
+module.exports = Index;
+```
+
+2、创建文件 `./server.js`
+
+```javascript
+const {app, Logger} = require('jj.js');
+
+app.run(3000, '127.0.0.1', function(err){
+    !err && Logger.info('http server is ready on 3000');
+});
+```
+
+3、运行命令
+
+```bash
+node server.js
+```
+
+4、浏览器访问 `http://127.0.0.1:3000`，页面输出 `Hello jj.js, hello world !`
+
+5、或者执行命令 `npm test`，快速打开测试程序。
+
+## 应用结构
+
+```
+├── app             //应用目录 （非必需，可改名）
+│  ├── controller   //控制器目录 （非必需，可改名）
+│  │  └── index.js  //控制器
+│  ├── view         //模板目录 （非必需，可改名）
+│  │  └── index     //index控制器模板目录 （非必需，可改名）
+│  │     └── index.htm //模板
+│  ├── middleware //中间件目录 （非必需，不可改名）
+│  ├── model        //模型目录 （非必需，可改名）
+│  ├── pagination   //分页目录 （非必需，可改名）
+│  ├── logic        //逻辑目录 （非必需，可改名）
+│  └── ****         //其他目录 （非必需，可改名）
+├── app2            //应用2目录 （非必需，可改名）
+├── common          //公共应用目录 （非必需，可改名）
+├── config          //配置目录 （非必需，不可改名）
+│  ├── app.js       //APP配置 （非必需，不可改名）
+│  ├── db.js        //数据库配置 （非必需，不可改名）
+│  ├── routes.js     //路由配置 （非必需，不可改名）
+│  ├── view.js     //模版配置 （非必需，不可改名）
+│  ├── cache.js     //缓存配置 （非必需，不可改名）
+│  └── ****         //其他配置 （非必需，可改名）
+├── public          //静态访问目录 （非必需，可改名）
+│  └── static       //css image文件目录 （非必需，可改名）
+├── node_modules    //nodejs模块目录
+├── server.js       //应用入口文件 （必需，可改名）
+└── package.json    //npm package.json
+```
+
+## 系统类库
+
+```javascript
+const {app, Controller, Db, Model, Pagination, View, Logger, Cookie, Response, Upload, Url, Middleware, Context} = require('jj.js');
+```
+
+## 开发手册（待继续完善）
+
+> 系统类库除了app，其他都是Class类型，开发时建议继承系统类库，这样可以在类内使用$开头的属性，可以自动加载系统类，链式调用类方法时会自动实例化一个单例。例如，在控制器内使用 `this.$logger` 会返回系统Logger类，使用 `this.$logger.info()`，会自动生成一个logger单例，并调用info方法，其他系统类库及类库内可以以这种方法调用。
+
+### Controller控制器
+
+系统控制器类继承自系统中间件类Middleware，包含所有Middleware方法。
+
+> 属性：**middleware**
+
+数组，定义控制器中间件，一个元素为一个中间件，元素为字符串或对象。
+
+案例1： `this.middleware = ['index']`，则控制器内所有方法访问之前都会调用当前应用目录（app）下中间件目录（middleware ）下的控制器同名中间件的index方法。
+
+案例2： `this.middleware = ['index', {middleware: 'auth/test', accept: 'middleTest'}]`，则控制器内所有方法访问之前都会先调用当前应用目录（app）下中间件目录（middleware ）下的控制器同名中间件的index方法。仅当访问控制器middleTest方法之前，还会再调用当前应用下中间件目录下的auth中间件的test方法（需index中间件内调用`this.$next()`方法，否则后续程序不会执行）。
+
+> 方法：**$assign(name, value)**
+
+同步方法，赋值模版变量。
+
+案例1：`this.$assign('title', 'Hello jj.js !')`，在模版内使用变量 `{{title}}`
+
+如果name为一个对象，则清除之前赋值的模板变量，并将name设置为模板变量对象。
+
+案例2：`this.$assign({'title': 'jj.js', 'content': 'Hello jj.js !'})`，在模版内可使用变量 `{{title}}`、`{{content}}`
+
+> 方法：**$data(name)**
+
+同步方法，获取已赋模版变量。
+如果name为空，则获取全部变量。
+
+> 方法：**$show(content)**
+
+同步方法，继承自Middleware类，输出content，如果content为对象，则输出json字符串。
+
+> 方法：**$fetch(template)**
+
+异步方法，渲染模板文件，并输出。
+
+其中template会自动自动定位模板文件，如果name为空，则定位到当前应用下view目录下的控制器同名目录下的方法同名htm文件。
+
+案例1：`this.$fetch()`，在index控制器类的index方法调用，则模板定位到`/app/view/index/index.htm`
+
+案例2：`this.$fetch('list/show')`，则模板定位到`/app/view/list/show.htm`
+
+> 方法：**$load(template)**
+
+异步方法，直接加载模板，并输出。模板定位规则同$fetch方法。
+
+> 方法：**$render(data)**
+
+异步方法，渲染字符串模板，并输出。data为字符串模版内容。
+
+案例1：`this.$render('<div>{{title}}</div>')`，会输出`<div>jj.js</div>`
+
+> 方法：**$redirect(name, status = 302)**
+
+同步方法，继承自Middleware类，网页跳转，name解析同$fetch方法。
+
+案例1：`this.$fetch('test')`，在index控制器类的index方法调用，则跳转到到`/app/index/test`地址
+
+案例2：`this.$fetch('/show')`，name包含'/'前缀，则跳转到地址`/show`
+
+> 方法：**$success(msg, name)**
+
+同步方法，继承自Middleware类，返回成功提示，name解析同$redirect方法，如果是ajax请求，则返回json数据。
+
+案例1：`this.$success('操作成功！', 'test')`，返回成功提示，并跳转到`/app/index/test`地址
+
+案例2：`this.$success({ajax: 'data'})`，ajax返回json `{state: 1, msg: '操作成功！', data: {ajax: 'data'}}`
+
+> 方法：**$error(msg, name)**
+
+同步方法，继承自Middleware类，返回成功提示，name解析同$success方法，name为空，则跳转来源网址。
+
+### Middleware中间件类
+
+> 方法：**$show(content)** 参照控制器类
+
+> 方法：**$redirect(url, status)** 参照控制器类
+
+> 方法：**$success(msg, url)** 参照控制器类
+
+> 方法：**$error(msg, url)** 参照控制器类
+
+### Db数据库类
+
+> 方法：**async startTrans(fun)** 开启事务
+
+> 方法：**async commit()** 提交事务
+
+> 方法：**async rollback()** 事务回滚
+
+> 方法：**prefix(prefix)** 设置数据表前缀
+
+> 方法：**table(table)** 设置数据表
+
+> 方法：**field(field)** 设置查询字段
+
+> 方法：**where(where, logic)** 设置查询条件
+
+> 方法：**distinct()** 数据去重
+
+> 方法：**group(field)** 数据分组
+
+> 方法：**having(condition)** 数据筛选
+
+> 方法：**order(field, order='asc')** 查询排序
+
+> 方法：**limit(offset, rows)** 查询数据限制
+
+> 方法：**page(page, pageSize)** 分页查询
+
+> 方法：**cache(time)** 设置缓存时间
+
+> 方法：**getSql(fetch = true)** 设置返回sql语句
+
+> 方法：**join(table, on, type='left')** 设置表连接
+
+> 方法：**async select(condition)** 查询多条数据
+
+> 方法：**async find(condition)** 查询单条数据
+
+> 方法：**async value(field)** 查询单个值
+
+> 方法：**async count(field='*')** 查询记录数
+
+> 方法：**async max(field)** 查询最大值
+
+> 方法：**async min(field)** 查询最小值
+
+> 方法：**async avg(field)** 查询平均值
+
+> 方法：**async sum(field)** 对列求和
+
+> 方法：**async column(field, key)** 获取一列数据，如果设置key则获取一列键值对
+
+> 方法：**async pagination(page, page_size, pagination)** 分页查询并返回分页实例
+
+> 方法：**data(data)** 设置写入数据
+
+> 方法：**allowField(field = true)** 设置过滤非数据表字段
+
+> 方法：**async insert(data)** 插入一条数据
+
+> 方法：**async update(data, condition)** 更新数据
+
+> 方法：**async inc(field, step)** 数据表字段自增
+
+> 方法：**async dec(field, step)** 数据表字段自减
+
+> 方法：**async exp(field, step)** 数据表字段执行自定义方法
+
+> 方法：**async delete(condition)** 删除数据
+
+> 方法：**async execute(sql, params, reset=true)** 解析并执行sql语句
+
+> 方法：**async tableInfo(table)** 获取表信息
+
+> 方法：**async tableField(table)** 获取表字段信息
+
+> 方法：**format(sql, params)** 解析sql语句
+
+> 方法：**deleteCache()** 清空数据库查询缓存
+
+### Model模型类
+
+> 属性：**db** 模型的db实例
+
+> 方法：**async add(data)** 同Db类insert方法
+
+> 方法：**async save(data, condition = {})** 智能调用Db类insert或update方法
+
+> 方法：**async del(condition)** 同Db类delete方法
+
+> 方法：**async get(condition)** 同Db类find方法
+
+> 方法：**async all(condition)** 同Db类select方法
+
+### Pagination分页类
+
+### View模板引擎类
+
+### Logger日志类
+
+### Cookie类
+
+### Response跳转相应类
+
+### Upload上传类
+
+### Url网址解析类
+
+### Context自动加载基类
+
+### config配置
+
+
+## 应用案例
+
+- [基于jj.js的轻量博客系统：Melog](https://me.i-i.me/melog/)
+
+### Nginx代理
+
+```
+location / {
+    proxy_pass       http://127.0.0.1:3000;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection "upgrade";
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+}
+```
+
+### License
+
+[MIT](LICENSE)

package/lib/cache.js

@@ -7,7 +7,7 @@ class Cache
             class ChildCache extends this.constructor {}
             ChildCache.cache = {};
             ChildCache.timer = null;
-            ChildCache.clear(cfg_cache.clear_time);
+            ChildCache.setIntervalTime(cfg_cache.clear_time);
             return ChildCache;
         }
     }
@@ -20,12 +20,13 @@ class Cache
         if(this.cache[key] && this.cache[key].time > now_time) {
             return this.cache[key].data;
         } else {
+            this.delete(key);
             return undefined;
         }
     }
 
     static set(key, data, cache_time) {
-        typeof(cache_time) == 'undefined' && (cache_time = cfg_cache.cache_time);
+        cache_time || (cache_time = cfg_cache.cache_time || 60 * 60 * 24 * 365 * 10);
         const now_time = this.time();
         this.cache[key] = {data: data, time: cache_time + now_time};
     }
@@ -38,26 +39,18 @@ class Cache
         }
     }
 
-    static clear(time) {
-        switch(time) {
-            case undefined:
+    static setIntervalTime(time) {
+        if(time) {
+            this.timer && clearInterval(this.timer);
+            this.timer = setInterval(() => {
                 const now_time = this.time();
                 for(let key in this.cache) {
-                    this.cache[key].time < now_time && (delete this.cache[key]);
+                    this.cache[key].time < now_time && this.delete(key);
                 }
-                break;
-            case 0:
-                this.timer && clearInterval(this.timer);
-                this.timer = null;
-                break;
-            default:
-                this.timer && clearInterval(this.timer);
-                this.timer = setInterval(() => {
-                    const now_time = this.time();
-                    for(let key in this.cache) {
-                        this.cache[key].time < now_time && (delete this.cache[key]);
-                    }
-                }, time * 1000);
+            }, time * 1000);
+        } else {
+            this.timer && clearInterval(this.timer);
+            this.timer = null;
         }
     }
 
@@ -68,6 +61,6 @@ class Cache
 
 Cache.cache = {};
 Cache.timer = null;
-Cache.clear(cfg_cache.clear_time);
+Cache.setIntervalTime(cfg_cache.clear_time);
 
 module.exports = Cache;

package/lib/config.js

@@ -45,8 +45,8 @@ const log = {
 }
 
 const cache = {
-    cache_time: 60 * 60 * 24, // 默认缓存时间（1天）
-    clear_time: undefined // (undefined: 清理一次, 0: 关闭自动清理, >0: 为自动清理时间)
+    cache_time: 60 * 60 * 24, // 默认缓存时间（1天），为空或false则为10年
+    clear_time: undefined // (undefined: 清理一次, 0: 关闭自动清理, >0: 为自动清理周期)
 }
 
 const page = {

package/lib/cookie.js

@@ -8,11 +8,18 @@ class Cookie extends Context
     }
 
     get(key) {
+        if(key === undefined) {
+            return this.all();
+        }
         return this.ctx.cookies.get(key);
     }
 
     delete(key) {
-        this.ctx.cookies.set(key, '', {maxAge: 0});
+        if(key === undefined) {
+            return this.clear();
+        } else {
+            this.ctx.cookies.set(key, '', {maxAge: 0});
+        }
     }
 
     all() {

package/lib/db.js

@@ -14,31 +14,31 @@ class Db extends Context
     constructor(ctx) {
         ctx = ctx || {};
         super(ctx);
-        this._cfg = null;
+        this._config = null;
         this._table = '';
         this._prefix = '';
-        this._opts = {};
+        this._options = {};
         this._queryStr = '';
         this._tableField = {};
         this.connect();
     }
 
     connect(options='default') {
-        this._cfg = typeof options === 'string' ? cfg_db[options] : options;
-        this._prefix = this._cfg.prefix || '';
+        this._config = typeof options === 'string' ? cfg_db[options] : options;
+        this._prefix = this._config.prefix || '';
         this.reset();
 
-        let cur_pool = pool.get(this._cfg);
+        let cur_pool = pool.get(this._config);
         if(!cur_pool) {
-            switch(this._cfg.type) {
+            switch(this._config.type) {
                 case 'mysql':
-                    cur_pool = require('mysql').createPool(this._cfg);
+                    cur_pool = require('mysql').createPool(this._config);
                     break;
                 default:
                     //other database, please provide database driver and implement the connection method
-                    cur_pool = this._cfg.connect(this._cfg);
+                    cur_pool = this._config.connect(this._config);
             }
-            pool.set(this._cfg, cur_pool);
+            pool.set(this._config, cur_pool);
             this.$logger.sql(`连接池创建成功：{all: ${pool.size}}`);
         }
         
@@ -46,15 +46,15 @@ class Db extends Context
     }
 
     close() {
-        if(pool.has(this._cfg)) {
-            pool.get(this._cfg).end(err => {
+        if(pool.has(this._config)) {
+            pool.get(this._config).end(err => {
                 if(err) {
                     const message = '连接池销毁失败：' + err['message'];
                     this.$logger.sql(message);
                     this.$logger.error(message);
                     throw new Error(message);
                 } else {
-                    pool.delete(this._cfg);
+                    pool.delete(this._config);
                     this.$logger.sql(`连接池销毁成功：{poolTotal: ${pool.size}}`);
                 }
             });
@@ -91,7 +91,7 @@ class Db extends Context
     }
 
     async _getConnect() {
-        return trans.get(this.ctx) || await this._creatConnect(pool.get(this._cfg));
+        return trans.get(this.ctx) || await this._creatConnect(pool.get(this._config));
     }
 
     async startTrans(fun) {
@@ -220,7 +220,7 @@ class Db extends Context
     }
 
     reset() {
-        this._opts = {
+        this._options = {
             distinct: '',
             field: [],
             join: {},
@@ -252,7 +252,7 @@ class Db extends Context
     }
 
     distinct() {
-        this._opts.distinct = 'distinct';
+        this._options.distinct = 'distinct';
         return this;
     }
 
@@ -261,42 +261,42 @@ class Db extends Context
             if(typeof field === 'string') {
                 field = field.split(',').map(value=>value.trim().replace(/ +/g, ' ').replace(/ as /g, ' '));
             }
-            this._opts.field = [...this._opts.field, ...field];
+            this._options.field = [...this._options.field, ...field];
         }
         return this;
     }
 
     join(table, on, type='left') {
         if(table) {
-            this._opts.join[table.trim().replace(/ +/g, ' ')] = {on, type};
+            this._options.join[table.trim().replace(/ +/g, ' ')] = {on, type};
         }
         return this;
     }
 
     where(where, logic) {
         if(where) {
-            this._opts.where.push([where, logic]);
+            this._options.where.push([where, logic]);
         }
         return this;
     }
 
     group(field) {
         if(field) {
-            this._opts.group = 'group by `' + field.trim().replace(/\./g, '`.`') + '`';
+            this._options.group = 'group by `' + field.trim().replace(/\./g, '`.`') + '`';
         }
         return this;
     }
 
     having(condition) {
         if(condition) {
-            this._opts.having = 'having ' + condition;
+            this._options.having = 'having ' + condition;
         }
         return this;
     }
 
     order(field, order='asc') {
         if(field) {
-            this._opts.order[field.trim()] = order === 'asc' ? 'asc' : 'desc';
+            this._options.order[field.trim()] = order === 'asc' ? 'asc' : 'desc';
         }
         return this;
     }
@@ -305,7 +305,7 @@ class Db extends Context
         if(typeof offset === 'undefined') return this;
         offset = offset ? parseInt(offset) : 0;
         rows = rows ? parseInt(rows) : null;
-        this._opts.limit = 'limit ' + offset + (rows ? ',' + rows : '');
+        this._options.limit = 'limit ' + offset + (rows ? ',' + rows : '');
         return this;
     }
 
@@ -314,17 +314,17 @@ class Db extends Context
         page = page ? parseInt(page) : 1;
         pageSize = pageSize ? parseInt(pageSize) : 10;
         this.limit((page - 1) * pageSize, pageSize);
-        this._opts.page = {page, pageSize};
+        this._options.page = {page, pageSize};
         return this;
     }
 
     cache(time) {
-        this._opts.cache = time;
+        this._options.cache_time = time;
         return this;
     }
 
     getSql(fetch = true) {
-        this._opts.getSql = fetch;
+        this._options.getSql = fetch;
         return this;
     }
 
@@ -334,23 +334,23 @@ class Db extends Context
         } else if(typeof field == 'string') {
             field = field.split(',').map(value => value.trim());
         }
-        this._opts.allowField = field;
+        this._options.allowField = field;
         return this;
     }
 
     data(data) {
         if(data) {
-            this._opts.data = {...this._opts.data, ...data};
+            this._options.data = {...this._options.data, ...data};
         }
         return this;
     }
 
     async select(condition) {
-        condition && (this._opts.where = [], this._opts.where.push([condition]));
+        condition && (this._options.where = [], this._options.where.push([condition]));
 
         let params = [];
         const table = this._parseTable();
-        const distinct = this._opts.distinct;
+        const distinct = this._options.distinct;
         const field = this._parseField();
         const join = this._parseJoin();
 
@@ -359,19 +359,19 @@ class Db extends Context
 
         const order = this._parseOrder();
 
-        const group = this._opts.group;
-        const having = this._opts.having;
-        const limit = this._opts.limit;
+        const group = this._options.group;
+        const having = this._options.having;
+        const limit = this._options.limit;
 
         this._queryStr = `select ${distinct} ${field} from ${table} ${join} ${where[0]} ${group} ${having} ${order} ${limit}`;
 
-        if(this._opts.getSql) {
-            this._opts.getSql = false;
+        if(this._options.getSql) {
+            this._options.getSql = false;
             return this.format(this._queryStr, params);
         }
         
-        if(this._opts.cache) {
-            const cache_time = this._opts.cache;
+        if(this._options.cache_time) {
+            const cache_time = this._options.cache_time;
             const cache_key = md5(this.format(this._queryStr, params));
             if(this.getCache(cache_key)) {
                 this.reset();
@@ -386,10 +386,10 @@ class Db extends Context
     }
 
     async find(condition) {
-        condition && (this._opts.where = [], this._opts.where.push([condition])); 
+        condition && (this._options.where = [], this._options.where.push([condition])); 
         this.limit(1);
 
-        if(this._opts.getSql) {
+        if(this._options.getSql) {
             return await this.select();
         }
 
@@ -398,10 +398,10 @@ class Db extends Context
     }
 
     async value(field) {
-        this._opts.field = [];
+        this._options.field = [];
         this.field(field);
         
-        if(this._opts.getSql) {
+        if(this._options.getSql) {
             return await this.find();
         }
 
@@ -430,11 +430,11 @@ class Db extends Context
     }
 
     async column(field, key) {
-        this._opts.field = [];
+        this._options.field = [];
         this.field(field);
         key && this.field(key);
         
-        if(this._opts.getSql) {
+        if(this._options.getSql) {
             return await this.select();
         }
 
@@ -458,7 +458,7 @@ class Db extends Context
             pagination = this.$pagination.__node.isClass ? this.$pagination : this.$.pagination;
         }
 
-        const options = {...this._opts};
+        const options = {...this._options};
         const total = await this.count();
         pagination.total(total);
 
@@ -466,7 +466,7 @@ class Db extends Context
         page_size ? pagination.pageSize(page_size) : (page_size = pagination.pageSize());
         
         if(total) {
-            this._opts = options;
+            this._options = options;
             const result = await this.page(page, page_size).select();
             return [result, pagination];
         } else {
@@ -475,7 +475,7 @@ class Db extends Context
     }
 
     async insert(data) {
-        data && (this._opts.data = data);
+        data && (this._options.data = data);
 
         let params = [];
         const table = this._parseTable();
@@ -486,16 +486,16 @@ class Db extends Context
         params = params.concat(data[1]);
 
         this._queryStr = `insert into ${table} set ${data[0]}`;
-        if(this._opts.getSql) {
-            this._opts.getSql = false;
+        if(this._options.getSql) {
+            this._options.getSql = false;
             return this.format(this._queryStr, params);
         }
         return await this.query(this._queryStr, params);
     }
 
     async update(data, condition) {
-        data && (this._opts.data = data);
-        condition && (this._opts.where = [], this._opts.where.push([condition]));
+        data && (this._options.data = data);
+        condition && (this._options.where = [], this._options.where.push([condition]));
 
         let params = [];
         const table = this._parseTable();
@@ -514,8 +514,8 @@ class Db extends Context
         params = params.concat(where[1]);
 
         this._queryStr = `update ${table} set ${data[0]} ${where[0]}`;
-        if(this._opts.getSql) {
-            this._opts.getSql = false;
+        if(this._options.getSql) {
+            this._options.getSql = false;
             return this.format(this._queryStr, params);
         }
         return await this.query(this._queryStr, params);
@@ -534,7 +534,7 @@ class Db extends Context
     }
 
     async delete(condition) {
-        condition && (this._opts.where = [], this._opts.where.push([condition]));
+        condition && (this._options.where = [], this._options.where.push([condition]));
 
         let params = [];
         const table = this._parseTable();
@@ -547,8 +547,8 @@ class Db extends Context
         params = params.concat(where[1]);
 
         this._queryStr = `delete from ${table} ${where[0]}`;
-        if(this._opts.getSql) {
-            this._opts.getSql = false;
+        if(this._options.getSql) {
+            this._options.getSql = false;
             return this.format(this._queryStr, params);
         }
         return await this.query(this._queryStr, params);
@@ -556,18 +556,18 @@ class Db extends Context
 
     async execute(sql, params, reset=true) {
         this._queryStr = sql;
-        if(this._opts.getSql) {
-            this._opts.getSql = false;
+        if(this._options.getSql) {
+            this._options.getSql = false;
             return this.format(this._queryStr, params);
         }
         return await this.query(this._queryStr, params, reset);
     }
 
     async tableInfo(table) {
-        const get_sql = this._opts.getSql;
-        this._opts.getSql = false;
+        const get_sql = this._options.getSql;
+        this._options.getSql = false;
         const table_info = await this.table(table).execute(`show columns from ${this._parseTable()}`, false);
-        this._opts.getSql = get_sql;
+        this._options.getSql = get_sql;
         return table_info;
     }
 
@@ -588,9 +588,9 @@ class Db extends Context
 
     _parseJoin() {
         let join = '';
-        Object.keys(this._opts.join).forEach(key => {
+        Object.keys(this._options.join).forEach(key => {
             const table = '`' + this._prefix + key.replace(' ', '` `') + '`';
-            const value = this._opts.join[key];
+            const value = this._options.join[key];
             join += (join ? ' ' : '') + value.type + ' join ' + table + ' on ' + value.on;
         });
         return join;
@@ -598,7 +598,7 @@ class Db extends Context
 
     _parseField() {
         let fields = [];
-        this._opts.field.forEach(value => {
+        this._options.field.forEach(value => {
             let field = value.split(' ');
             let alias = '';
             const length = field.length;
@@ -620,7 +620,7 @@ class Db extends Context
         const logic = ['=', '<>', '!=', '>', '>=', '<', '<=', 'like', 'not like', 'in', 'not in', 'between', 'not between', 'is', 'is not', 'exp'];
         const where = [];
         const params = [];
-        this._opts.where.forEach(item => {
+        this._options.where.forEach(item => {
             const whereList = item[0];
             const whereLink = (item[1] && item[1].toLowerCase()) === 'or' ? 'or' : 'and';
             let whereChild = '';
@@ -673,9 +673,9 @@ class Db extends Context
 
     _parseOrder() {
         let order = '';
-        Object.keys(this._opts.order).forEach(key => {
+        Object.keys(this._options.order).forEach(key => {
             const field = '`' + key.replace('.', '`.`') + '`';
-            const value = this._opts.order[key];
+            const value = this._options.order[key];
             order += (order ? ',' : 'order by ') + field + (value ? ' ' + value : '');
         });
         return order;
@@ -684,9 +684,9 @@ class Db extends Context
     _parseData() {
         let data = '';
         const params = [];
-        Object.keys(this._opts.data).forEach(key => {
+        Object.keys(this._options.data).forEach(key => {
             const field = '`' + key.replace('.', '`.`') + '`';
-            const value = this._opts.data[key];
+            const value = this._options.data[key];
             data += (data ? ',' : '') + field + '=';
             if(value instanceof Array) {
                 value[0] = value[0].toLowerCase();
@@ -712,11 +712,11 @@ class Db extends Context
     }
 
     async _filterData() {
-        if(!this._opts.allowField) {
-            return this._opts.data;
+        if(!this._options.allowField) {
+            return this._options.data;
         }
 
-        let allowField = this._opts.allowField;
+        let allowField = this._options.allowField;
         if(allowField === true) {
             const table_name = this._prefix + this._table;
             if(!this._tableField[table_name]) {
@@ -725,32 +725,28 @@ class Db extends Context
             allowField = this._tableField[table_name];
         }
 
-        Object.keys(this._opts.data).forEach(key => {
+        Object.keys(this._options.data).forEach(key => {
             if(!~allowField.indexOf(key)) {
-                delete this._opts.data[key];
+                delete this._options.data[key];
             }
         });
-        return this._opts.data;
+        return this._options.data;
     }
 
     getCache(key) {
-        return this.constructor.cache.get(key);
+        return Db.cache.get(key);
     }
 
     setCache(key, data, cache_time) {
-        this.constructor.cache.set(key, data, cache_time);
+        Db.cache.set(key, data, cache_time);
     }
 
-    deleteCache(key) {
-        this.constructor.cache.delete(key);
-    }
-
-    clearCache(time) {
-        this.constructor.cache.clear(time);
+    deleteCache(key) {console.log('deleteCache', key);
+        Db.cache.delete(key);
     }
 }
 
 Db.cache = new (require('./cache'))();
-Db.cache.clear(20 * 60 * 60);
+Db.cache.setIntervalTime(20 * 60 * 60);
 
 module.exports = Db;

package/lib/upload.js

@@ -37,7 +37,7 @@ class Upload extends Context
 
         try {
             const filePath = pt.join(this.$config.app.base_dir, dir, savename);
-            await utils.fs.mkdirs(filePath);
+            await utils.fs.mkdirs(pt.dirname(filePath));
             const reader = fs.createReadStream(this._file.path);
             const writer = fs.createWriteStream(filePath);
             reader.pipe(writer);

package/lib/utils/fs.js

@@ -64,23 +64,13 @@ fsFun.isDirSync = (path) => {return fs.existsSync(path) && fs.statSync(path).isD
 });
 
 //(多级目录生成)
-fsFun.mkdirs = async function (path) {
-    const dir = pt.dirname(path);
-    if(!await fsFun.isDir(dir)) {
-        let pathtmp;
-        const dirnames = dir.split(/[/\\]/);
-        for(const dirname of dirnames) {
-            if(pathtmp) {
-                pathtmp = pt.join(pathtmp, dirname);
-            } else {
-                pathtmp = dirname;
-            }
-            if(!await fsFun.isDir(pathtmp)) {
-                const result = await fsFun.mkdir(pathtmp)
-                if (!result) {
-                    throw result;
-                }
-            }
+fsFun.mkdirs = async function (dirname) {
+    if(await fsFun.isDir(dirname)) {
+        return true;
+    } else {
+        if(await fsFun.mkdirs(pt.dirname(dirname))) {
+            await fsFun.mkdir(dirname);
+            return true;
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jj.js",
-  "version": "0.6.1",
+  "version": "0.7.3",
   "description": "A simple and lightweight MVC framework built on nodejs+koa2",
   "main": "jj.js",
   "scripts": {