typespeed 0.0.1 → 2.0.2

package/src/default/read-write-db.class.ts

@@ -0,0 +1,53 @@
+import { createConnection, createPool } from "mysql2";
+import DataSourceFactory from "../factory/data-source-factory.class";
+import { bean, config } from "../core.decorator";
+
+export default class ReadWriteDb extends DataSourceFactory {
+    private readonly readSession;
+    private readonly writeSession;
+
+    @bean
+    public getDataSource(): DataSourceFactory {
+        if (!config("mysql")) {
+            return null;
+        }
+        return new ReadWriteDb();
+    }
+
+    constructor() {
+        super();
+        const dbConfig = config("mysql");
+        if (dbConfig["master"] && dbConfig["slave"]) {
+            this.writeSession = this.getConnectionByConfig(dbConfig["master"]);
+            if (Array.isArray(dbConfig["slave"])) {
+                this.readSession = dbConfig["slave"].map(config => this.getConnectionByConfig(config));
+            } else {
+                this.readSession = [this.getConnectionByConfig(dbConfig["slave"])];
+            }
+        } else {
+            this.writeSession = this.getConnectionByConfig(dbConfig);
+            this.readSession = [this.writeSession];
+        }
+    }
+
+    private getConnectionByConfig(config: object) {
+        if (config["PoolOptions"] !== undefined) {
+            // we need pool
+            if (Object.keys(config["PoolOptions"]).length !== 0) {
+                config = Object.assign(config, config["PoolOptions"]);
+            }
+            return createPool(config).promise();
+        } else {
+            // only connection
+            return createConnection(config).promise();
+        }
+    }
+
+    public readConnection() {
+        return this.readSession[Math.floor(Math.random() * this.readSession.length)];
+    }
+
+    public writeConnection() {
+        return this.writeSession;
+    }
+}

package/src/default/redis.class.ts

@@ -0,0 +1,18 @@
+import { bean, config, log } from "../core.decorator";
+import IoRedis from "ioredis";
+
+export default class Redis extends IoRedis {
+
+    @bean
+    public getRedis(): Redis {
+        if (!config("redis")) {
+            return null;
+        }
+        return new Redis(config("redis"));
+    }
+
+    constructor(config: any) {
+        super(config);
+    }
+
+}

package/src/factory/cache-factory.class.ts

@@ -0,0 +1,7 @@
+export default abstract class CacheFactory {
+    public abstract get(key: string): any;
+    public abstract set(key: string, value: any, expire?: number): void;
+    public abstract del(key: string): void;
+    public abstract has(key: string): boolean;
+    public abstract flush(): void;
+}

package/src/factory/data-source-factory.class.ts

@@ -0,0 +1,4 @@
+export default abstract class DataSourceFactory {
+    public abstract readConnection();
+    public abstract writeConnection();
+}

package/src/factory/log-factory.class.ts

@@ -0,0 +1,4 @@
+export default abstract class LogFactory {
+    abstract log(message?: any, ...optionalParams: any[]) : void;
+    abstract error(message?: any, ...optionalParams: any[]) : void;
+}

package/src/factory/server-factory.class.ts

@@ -0,0 +1,6 @@
+export default abstract class ServerFactory {
+    public app;
+    protected middlewareList: Array<any> = [];
+    public abstract setMiddleware(middleware: any);
+    public abstract start(port: number);
+}

package/src/route.decorator.ts

@@ -0,0 +1,82 @@
+import * as express from "express";
+import * as multiparty from "multiparty";
+import { expressjwt } from "express-jwt";
+import { getComponent } from "./core.decorator";
+
+const routerMapper = {
+  "get": {},
+  "post": {},
+  "all": {}
+};
+
+const routerMiddleware = {};
+function setRouter(app: express.Application) {
+  ["get", "post", "all"].forEach(method => {
+    for (let key in routerMapper[method]) {
+      let rounterFunction = routerMapper[method][key];
+      if (routerMiddleware[rounterFunction["name"]]) {
+        let args: Array<any> = [key, ...routerMiddleware[rounterFunction["name"]], rounterFunction["invoker"]];
+        app[method].apply(app, args);
+      } else {
+        app[method](key, rounterFunction["invoker"]);
+      }
+    }
+  });
+}
+
+function mapperFunction(method: string, value: string) {
+  return (target: any, propertyKey: string) => {
+    routerMapper[method][value] = {
+      "path": value,
+      "name": [target.constructor.name, propertyKey].toString(),
+      "invoker": async (req, res, next) => {
+        const routerBean = getComponent(target.constructor);
+        try {
+          const testResult = await routerBean[propertyKey](req, res);
+          if (typeof testResult === "object") {
+            res.json(testResult);
+          } else if (typeof testResult !== "undefined") {
+            res.send(testResult);
+          }
+          return testResult;
+        } catch (err) {
+          next(err)
+        }
+      }
+    }
+  }
+}
+
+function upload(target: any, propertyKey: string) {
+  const key = [target.constructor.name, propertyKey].toString();
+  if (routerMiddleware[key]) {
+    routerMiddleware[key].push(uploadMiddleware);
+  } else {
+    routerMiddleware[key] = [uploadMiddleware];
+  }
+}
+
+function uploadMiddleware(req, res, next) {
+  const form = new multiparty.Form();
+  form.parse(req, (err, fields, files) => {
+    req.files = files || undefined;
+    next();
+  });
+}
+
+function jwt(jwtConfig) {
+  return (target: any, propertyKey: string) => {
+    const key = [target.constructor.name, propertyKey].toString();
+    if (routerMiddleware[key]) {
+      routerMiddleware[key].push(expressjwt(jwtConfig));
+    } else {
+      routerMiddleware[key] = [expressjwt(jwtConfig)];
+    }
+  }
+}
+
+const getMapping = (value: string) => mapperFunction("get", value);
+const postMapping = (value: string) => mapperFunction("post", value);
+const requestMapping = (value: string) => mapperFunction("all", value);
+
+export { getMapping, postMapping, requestMapping, setRouter, upload, jwt };

package/src/typespeed.ts

@@ -0,0 +1,15 @@
+export * from "./core.decorator";
+export * from "./route.decorator";
+export * from "./database.decorator";
+
+
+export { default as LogFactory} from "./factory/log-factory.class";
+export { default as CacheFactory} from "./factory/cache-factory.class";
+export { default as DataSourceFactory} from "./factory/data-source-factory.class";
+export { default as ServerFactory} from "./factory/server-factory.class";
+
+export { default as ExpressServer} from "./default/express-server.class";
+export { default as LogDefault} from "./default/log-default.class";
+export { default as NodeCache} from "./default/node-cache.class";
+export { default as Redis} from "./default/redis.class";
+export { default as ReadWriteDb} from "./default/read-write-db.class";

package/test/nodemon.json

@@ -0,0 +1,6 @@
+{
+    "watch": ["src", "test"],
+    "ext": "ts,json",
+    "ignore": ["src/**/*.spec.ts"],
+    "exec": "npm run test" 
+}

package/test/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "test-typespeed",
+    "version": "1.0.0",
+    "description": "",
+    "scripts": {
+      "watch": "nodemon",
+      "test": "ts-node src/main.ts",
+      "start": "ts-node --transpile-only src/main.ts",
+      "build": "tsc -p ."
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+      "@types/node": "^18.0.6",
+      "tracer": "^1.1.6"
+    }
+  }
+  

package/test/src/aop-test.class.ts

@@ -0,0 +1,29 @@
+import { before, log, component, after } from "../../";
+import FirstPage from "./first-page.class";
+
+@component
+export default class AopTest {
+
+    @before(FirstPage, "index")
+    public FirstIndex() {
+        log("Before FirstPage index run, at AopTest FirstIndex.");
+        log("AopTest FirstIndex run over." + this.getWordsFromAopTest());
+        return "FirstIndex";
+    }
+
+    public getWordsFromAopTest() {
+        return "getWordsFromAopTest";
+    }
+
+    @before(FirstPage, "getTestFromFirstPage")
+    public testGetTestFromFirstPage() {
+        log("AopTest testGetTestFromFirstPage run over.");
+    }
+
+    @after(FirstPage, "index")
+    public testFirstIndexAfter(result) {
+        log("AopTest testFirstIndexAfter run over, result: " + result);
+        log(result);
+    }
+
+}

package/test/src/config-development.json

@@ -0,0 +1,15 @@
+{
+    "server": {
+        "port": "8081"
+    },
+    "database": {
+        "host": "localhost",
+        "port": "4455",
+        "name": "test"
+    },
+    "view": {
+        "engine": "mustache",
+        "path": "/test/views",
+        "suffix": "html"
+    }
+}

package/test/src/config-production.json

@@ -0,0 +1,15 @@
+{
+    "server": {
+        "port": "8081"
+    },
+    "database": {
+        "host": "localhost",
+        "port": "27017",
+        "name": "test"
+    },
+    "view": {
+        "engine": "mustache",
+        "path": "./views",
+        "suffix": "html"
+    }
+}

package/test/src/config.json

@@ -0,0 +1,46 @@
+{
+    "view": {
+        "engine": "pug",
+        "path": "./views",
+        "suffix": "html"
+    },
+    "static": "/static",
+    "favicon": "/static/favicon.ico",
+    "compression": {
+        "level": 9
+    },
+    "cookie": {
+        "secret": "catme",
+        "options": {}
+    },
+    "session": {
+        "trust proxy": false,
+        "secret": "keyboard cat",
+        "resave": false,
+        "saveUninitialized": true,
+        "cookie": {
+            "secure": false
+        }
+    },
+    "mysql": {
+        "master": {
+            "host": "localhost",
+            "user": "root",
+            "password": "123456",
+            "database": "test"
+        },
+        "slave": [
+            {
+                "host": "localhost",
+                "user": "root",
+                "password": "123456",
+                "database": "test"
+            }
+        ]
+    },
+    "redis": {
+        "host": "localhost",
+        "port": "6379",
+        "db": 0
+    }
+}

package/test/src/custom-log.class.ts

@@ -0,0 +1,26 @@
+import * as tracer from "tracer";
+import { bean, LogFactory } from "../../";
+
+export default class CustomLog extends LogFactory {
+    private logger = tracer.console({
+        format: "[{{title}}] {{timestamp}} {{file}}:{{line}} ({{method}}) {{message}}",
+        dateformat: "yyyy-mm-dd HH:MM:ss",
+        stackIndex: 2,
+        preprocess: function (data) {
+            data.title = data.title.toUpperCase();
+        }
+    });
+
+    @bean
+    public createLog(): LogFactory {
+        return new CustomLog();
+    }
+
+    public log(message?: any, ...optionalParams: any[]) : void{
+        this.logger.log(message, ...optionalParams);
+    }
+
+    public error(message?: any, ...optionalParams: any[]) : void {
+        this.logger.error(message, ...optionalParams);
+    }
+}

package/test/src/entities/user-dto.class.ts

@@ -0,0 +1,3 @@
+export default class UserDto {
+    constructor(public id: number, public name: string){}
+}

package/test/src/first-page.class.ts

@@ -0,0 +1,46 @@
+//import * as jwttoken from "jsonwebtoken";
+import { log, component, getMapping } from "../../";
+
+@component
+export default class FirstPage {
+
+    @getMapping("/first")
+    public index(req: any, res: any) {
+        log("FirstPage index running" + this.getTestFromFirstPage());
+        res.send("FirstPage index running");
+    }
+
+    @getMapping("/first/sendJson")
+    public sendJson() {
+        log("FirstPage sendJson running");
+        return {
+            "from": "sendJson",
+            "to": "Browser"
+        }
+    }
+
+    @getMapping("/first/sendResult")
+    public sendResult() {
+        log("FirstPage sendResult running");
+        return "sendResult";
+    }
+
+    @getMapping("/first/renderTest")
+    public renderTest(req: any, res: any) {
+        res.render("index", { name: "zzz" });
+    }
+
+    // @getMapping("/login")
+    // login() {
+    //     const token = jwttoken.sign({ foo: 'bar' }, 'shhhhhhared-secret');
+    //     /**
+    //      * 将这里获得的token，放到header的Authorization中。
+    //      * 值是：Bearer + token
+    //      */
+    //     return token;
+    // }
+
+    public getTestFromFirstPage() {
+        return "getTestFromFirstPage";
+    }
+}

package/test/src/main.ts

@@ -0,0 +1,17 @@
+import { app, log, autoware, ServerFactory } from "../../";
+//import * as basicAuth from "express-basic-auth"
+
+@app
+class Main {
+
+    @autoware
+    public server : ServerFactory;
+
+    public main(){
+        // this.server.setMiddleware(basicAuth({
+        //     users: { 'admin': 'supersecret' }
+        // }));
+        this.server.start(8081);
+        log('start application');
+    }
+}

package/test/src/second-page.class.ts

@@ -0,0 +1,43 @@
+import { getMapping, postMapping, upload, jwt, log, component } from "../../";
+
+@component
+export default class SecondPage {
+
+    @getMapping("/second/setCookie")
+    setCookiePage(req, res) {
+        res.cookie("name", "zzz");
+        return "setCookie";
+    }
+
+    @getMapping("/second/getCookie")
+    getCookiePage(req, res) {
+        const cookieName = req.cookies.name;
+        return "getCookie: " + cookieName;
+    }
+
+    @getMapping("/second/testSession")
+    testForSession(req, res) {
+        req.session.view = req.session.view ? req.session.view + 1 : 1;
+        return "testForSession: " + req.session.view;
+    }
+
+    @postMapping("/upload")
+    @upload
+    public upload(req, res) {
+        const files = req.files;
+        log(files);
+        log("uploaded");
+        res.send("upload success");
+    }
+
+    @jwt({ secret: "shhhhhhared-secret", algorithms: ["HS256"] })
+    @postMapping("/form")
+    form(req, res) {
+        res.render("upload");
+    }
+
+    @getMapping("/second/testError")
+    testError(req, res) {
+        throw new Error('Test Error');
+    }
+}

package/test/src/test-database.class.ts

@@ -0,0 +1,85 @@
+import { insert, update, select, param, resultType, cache, CacheFactory, getMapping, component, log, autoware } from "../../";
+import UserDto from "./entities/user-dto.class";
+
+@component
+export default class TestDatabase {
+
+    @autoware
+    private cacheBean: CacheFactory;
+
+    @getMapping("/db/insert")
+    async insert(req, res) {
+        const id = req.query.id || 1;
+        const newId = await this.addRow("new name " + id, id);
+        log("Insert newId: " + newId);
+        res.send("Insert success");
+    }
+
+    @getMapping("/db/insert2")
+    async insertByObject(req, res) {
+        const newId = await this.addRowByObject({
+            "id": 25, "name": "new name 25"
+        });
+        log("Insert newId: " + newId);
+        res.send("Insert success");
+    }
+
+    @getMapping("/db/update")
+    async update(req, res) {
+        const affectedRows = await this.editRow();
+        log("Update rows: " + affectedRows);
+        res.send("update success");
+    }
+
+    @getMapping("/db/select")
+    async select(req, res) {
+        const rows = await this.selectRow();
+        log("select rows: " + rows);
+        res.send(rows);
+    }
+
+    @getMapping("/db/select1")
+    async selectById(req, res) {
+        const row = await this.findRow(req.query.id || 1);
+        log("select rows: " + row);
+        res.send(row);
+    }
+
+    @getMapping("/db/select-user")
+    async selectUser(req, res) {
+        const users: UserDto[] = await this.findUsers();
+        log("select users: " + users);
+        res.send(users);
+    }
+
+    @getMapping("/db/set-cache")
+    testCache(req, res) {
+        this.cacheBean.set("test", req.query.value || "test");
+        res.send("set cache success");
+    }
+
+    @getMapping("/db/get-cache")
+    displayCache(req, res) {
+        res.send(this.cacheBean.get("test"));
+    }
+
+    @insert("Insert into `user` (id, name) values (#{id}, #{name})")
+    private async addRow(@param("name") newName: string, @param("id") id: number) { }
+
+    @insert("Insert into `user` (id, name) values (#{id}, #{name})")
+    private async addRowByObject(myParams: object) { }
+
+    @update("Update `user` set `name` = 'test5' where id = 5")
+    private async editRow() { }
+
+    @select("Select * from `user`")
+    private async selectRow() { }
+
+    @cache(1800)
+    @select("Select * from `user` where id = #{id}")
+    private async findRow(@param("id") id: number) { }
+
+    @resultType(UserDto)
+    @select("Select * from `user`")
+    private findUsers(): UserDto[] { return; }
+}

package/test/src/test-log.class.ts

@@ -0,0 +1,9 @@
+import { component } from "../../";
+
+@component
+export default class TestLog {
+
+    constructor() {
+        //log("TestLog constructor");
+    }
+}

package/test/src/test-orm.class.ts

@@ -0,0 +1,74 @@
+import { resource, component, log, autoware, schedule, getMapping, postMapping, Redis } from "../../";
+import UserModel from "./user-model.class";
+
+@component
+export default class TestOrm {
+
+    @resource("user")
+    private userModel: UserModel;
+
+    @autoware
+    private redisObj: Redis;
+
+    @getMapping("/redis")
+    async redisTest() {
+        await this.redisObj.set("redisKey", "Hello World");
+        const value = await this.redisObj.get("redisKey");
+        log(value)
+        return "get from redis: " + value;
+    }
+
+    @getMapping("/orm/first")
+    async firstTest(req, res) {
+        const results = await this.userModel.getUsers();
+        res.send("first test, to " + results);
+    }
+
+    @getMapping("/orm/one")
+    async findOneTest(req, res) {
+        const results = await this.userModel.getUser(req.query.id || 0);
+        res.send("find one test, to " + results);
+    }
+
+    @getMapping("/orm/delete")
+    async deleteTest(req, res) {
+        const results = await this.userModel.remove(req.query.id || 0);
+        res.send("remove user, results: " + results);
+    }
+
+    @getMapping("/orm/count")
+    async countTest(req, res) {
+        const results = await this.userModel.count();
+        res.send(results);
+    }
+
+    @getMapping("/orm/new")
+    async newUserTest(req, res) {
+        const results = await this.userModel.newUsers();
+        res.send("new user test, to " + results);
+    }
+
+    @getMapping("/orm/page/calculate")
+    async calculatePage(req, res) {
+        const pages = this.userModel.pager(15, 376);
+        res.send("pages calculate result: " + JSON.stringify(pages));
+    }
+
+    @getMapping("/orm/pages/:id")
+    async findPage(req, res) {
+        const results = await this.userModel.findAll("1", { id: -1 }, "*", { page: req.params.id, pageSize: 3 });
+        log(this.userModel.page);
+        res.send("pages find result: " + JSON.stringify(results));
+    }
+
+    @postMapping("/orm/edit")
+    async updateTest(req, res) {
+        const results = await this.userModel.editUser(req.body.id, req.body.name);
+        res.send(results);
+    }
+
+    //@schedule("* * * * * *")
+    myTimer() {
+        log("myTimer running");
+    }
+}