Initial koa-easy project

Changes to be committed:
	new file:   .gitignore
	new file:   ActionTrigger.js
	new file:   Controller.js
	new file:   LICENSE
	new file:   NotFoundError.js
	new file:   README.md
	new file:   Route.js
	new file:   Router.js
	new file:   Rule.js
	new file:   SessionStore.js
	new file:   View.js
	new file:   decorators/paramFrom.js
	new file:   decorators/params.js
	new file:   index.js
	new file:   install
	new file:   mvc.js
	new file:   package.json
	new file:   reflect/Decorator.js
	new file:   reflect/Metadata.js
	new file:   reflect/init.js
	new file:   session/index.js
	new file:   session/lib/context.js
	new file:   session/lib/session.js
	new file:   session/lib/util.js
	new file:   utils.js
	new file:   yarn.lock

Author: shjyh

.gitignore

@@ -0,0 +1,4 @@
+.idea
+.DS_Store
+.vscode
+node_modules

ActionTrigger.js

@@ -0,0 +1,89 @@
+const path = require('path');
+const Controller = require('./Controller');
+const reflectInit = require('./reflect/init');
+const NotFoundError = require('./NotFoundError');
+const Metadata = require('./reflect/Metadata');
+
+const cache = {};
+
+function findControllerByPath(p, decorator){
+    if(!cache[p]){
+        try{
+            cache[p] = require(p);
+            reflectInit(cache[p], decorator);
+        }catch(e){
+            if(e.message.startsWith('Cannot find module ')){
+                cache[p] = new NotFoundError('controller not found');
+            }
+            cache[p] = e;
+        }
+    }
+
+    const RouteController = cache[p];
+    if(RouteController instanceof Error) throw RouteController;
+    if(! RouteController.prototype instanceof Controller)
+        throw new Error('required controller class is not drive from koa-mvc/Controller');
+    return RouteController;
+}
+
+module.exports = class ActionTrigger{
+    constructor({ctx, route, router, decorator, view}){
+        this._ctx = ctx;
+        this._route = route;
+        this._router = router;
+        this._view = view;
+
+        this._decorator = decorator;
+
+        this._controllerName = route.controllerFileName;
+        this._actionName = route.actionMethodName;
+    }
+    build(){
+        const RouteController = findControllerByPath(path.resolve(
+            this._route.controllersRoot,
+            this._controllerName
+        ), this._decorator);
+
+        this._controller = new RouteController({
+            ctx: this._ctx,
+            route: this._route,
+            router: this._router,
+            view: this._view
+        });
+    }
+    async trigger(){
+        if(!this._controller) this.build();
+
+        const controller = this._controller;
+        if(controller[this._actionName]){
+            const meta = Metadata.getMetadata(controller.constructor, this._actionName);
+            let result = await controller.$beforeAction();
+
+            if(result!==false){
+                const args = (meta.$$params||[]).map(key=>{
+                    let searchParamFrom = ['query', 'post'];
+                    if(meta.$$paramFrom&&meta.$$paramFrom[key]){
+                        searchParamFrom = meta.$$paramFrom[key]; 
+                    }
+                    for(let from of searchParamFrom){
+                        switch(from){
+                            case 'query':
+                                if(key in controller.query)
+                                    return controller.query[key];
+                                break;
+                            case 'post':
+                                if(key in controller.request.body)
+                                    return controller.request.body[key];
+                                break;
+                        }
+                    }
+
+                    return undefined;
+                });
+                const actionResult = await controller[this._actionName](...args);
+            }
+            await controller.$afterAction(); 
+            
+        } else throw new NotFoundError('action not found');
+    }
+}

Controller.js

@@ -0,0 +1,88 @@
+
+const pug = require('pug');
+const path = require('path');
+const ActionTrigger = require('./ActionTrigger');
+const Route = require('./Route');
+
+const pugCompileOptions = {
+    cache: true,
+    doctype: 'html'
+}
+
+const viewKey = Symbol('#view');
+
+module.exports = class Controller {
+
+    $beforeAction(){}
+    $afterAction(){}
+
+    constructor({ctx, route, router, view}){
+        Object.defineProperties(this, {
+            ctx: { value: ctx },
+            route: { value: route },
+            router: { value: router }
+        });
+        this[viewKey] = view;
+    }
+    get request(){
+        return this.ctx.request;
+    }
+    get response(){
+        return this.ctx.response;
+    }
+    get session(){
+        return this.ctx.session;
+    }
+    set session(s){
+        this.ctx.session = s;
+    }
+    get sessionId(){
+        return this.ctx.sessionId;
+    }
+    get cookies(){
+        return this.ctx.cookies;
+    }
+    get query(){
+        return this.ctx.query;
+    }
+    throw(...arg){
+        this.ctx.throw(...arg);
+    }
+    isAjax(){
+        return this.ctx.headers['x-requested-with'] === 'XMLHttpRequest'
+    }
+    renderText(txt){
+        this.ctx.body = txt;
+    }
+    render(model = {}, view){
+        const controller = this.route.controller;
+        view = view || this.route.action;
+
+        const viewPath = path.resolve(this.route.viewsRoot, `${controller}/${view}.pug`);
+
+        this.ctx.body = pug.compileFile(viewPath, pugCompileOptions)({
+            model,
+            view: this[viewKey]
+        });
+    }
+    renderJSON(json = {}){
+        this.ctx.body = json;
+    }
+    renderSVG(svg){
+        this.ctx.body = svg;
+        this.ctx.type="image/svg+xml";
+    }
+    redirect(params, area){
+        const url = (typeof params === 'string') ? params : this.router.resolve(params, area);
+        this.ctx.redirect(url);
+    }
+    async rewrite(params, area){
+        const route = (typeof params === 'string') ? this.router.match(params) : new Route(params, area);
+        const actionTrigger = new ActionTrigger({
+            ctx: this.ctx,
+            route,
+            router: this.router
+        });
+        await actionTrigger.trigger();
+    }
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 kserver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

NotFoundError.js

@@ -0,0 +1,5 @@
+module.exports = class NotFoundError extends Error{
+    constructor(msg){
+        super(msg);
+    }
+}

README.md

@@ -0,0 +1,53 @@
+const path = require('path');
+const { appRoot, upperFirstLetter, camelCase } = require('./utils');
+
+const paramsKey = Symbol();
+const areaKey = Symbol();
+const controllersRootKey = Symbol();
+const viewRootKey = Symbol();
+const controllerFileNameKey = Symbol();
+const actionMethodNameKey = Symbol();
+
+module.exports = class Route {
+    constructor(params, area = ''){
+        this[paramsKey] = params;
+        this[areaKey] = area;
+
+        this[controllerFileNameKey] = upperFirstLetter(camelCase(params.controller)) + 'Controller';
+        this[actionMethodNameKey] = camelCase(params.action);
+
+        let moduleRoot = appRoot;
+        if(area){
+            moduleRoot = path.resolve(moduleRoot, `areas/${area}`); 
+        }
+        this[controllersRootKey] = path.resolve(moduleRoot, 'controllers');
+        this[viewRootKey] = path.resolve(moduleRoot, 'views');
+    }
+    get area(){
+        return this[areaKey];
+    }
+    get controller(){
+        return this[paramsKey].controller;
+    }
+    get action(){
+        return this[paramsKey].action;
+    }
+    get params(){
+        return this[paramsKey]
+    }
+
+    get controllerFileName(){
+        return this[controllerFileNameKey];
+    }
+    get actionMethodName(){
+        return this[actionMethodNameKey];
+    }
+
+    get controllersRoot(){
+        return this[controllersRootKey];
+    }
+
+    get viewsRoot(){
+        return this[viewRootKey];
+    }
+}

Route.js

@@ -0,0 +1,63 @@
+
+const Rule = require('./Rule');
+const Route = require('./Route');
+const p = require('path');
+
+const rulesKey = Symbol('#rules');
+const areasKey = Symbol('#areas');
+const getMatchedResultKey = Symbol('#getMatchedResultKey');
+
+module.exports = class Router{
+    get rules(){
+        return this[rulesKey];
+    }
+    get areas(){
+        return this[areasKey];
+    }
+    constructor({ 
+        rules = [],
+        areas = []
+    } = {}){
+        if(rules.length===0){
+            rules.push('{{controller:home}}/{{action:index}}')
+        }
+        this[areasKey] = areas;
+        this[rulesKey] = [];
+        for(let rule of rules){
+            this[rulesKey].push(new Rule(rule));
+        }
+    }
+
+    [getMatchedResultKey](path){
+        for(let rule of this.rules){
+            const result = rule.match(path);
+            if(result) return result;
+        }
+        return null;
+    }
+
+    match(path){
+        if(path.startsWith('/')) path = path.substr(1);
+        let area = '';
+        let areaPath = '';
+        for(let areaName of this.areas){
+            if(path.startsWith(areaName)){
+                area = areaName;
+                areaPath = p.relative(areaName, path);
+            }
+        }
+
+        if(area){
+            const params = this[getMatchedResultKey](areaPath);
+            if(params) return new Route(params, area);
+        }
+
+        const params = this[getMatchedResultKey](path);
+        if(params) return new Route(params);
+
+        return null;
+    }
+    resolve(params, area){
+        return p.join('/'+area, this.rules[0].resolve(params));
+    }
+}