typespeed 2.3.1 → 2.3.2

package/app/nodemon.json

@@ -1,5 +1,5 @@
 {
     "watch": ["src", "../dist", "../src", "../test"],
     "ext": "ts,json",
-    "exec": "npm start" 
+    "exec": "npm test" 
 }

package/app/package.json

@@ -4,7 +4,7 @@
     "description": "",
     "scripts": {
       "watch": "nodemon",
-      "start": "ts-node src/main.ts",
+      "test": "ts-node src/main.ts",
       "build": "tsc -p ."
     },
     "author": "",

package/app/src/config-development.json

@@ -11,5 +11,12 @@
         "engine": "mustache",
         "path": "/app/src/views",
         "suffix": "html"
+    },
+    "rabbitmq": {
+        "protocol": "amqp",
+        "hostname": "localhost",
+        "port": 5672,
+        "username": "guest",
+        "password": "guest"
     }
 }

package/app/src/jwt-authentication.class.ts

@@ -11,7 +11,7 @@ const jwtConfig: {
 
 export default class JwtAuthentication extends AuthenticationFactory {
 
-    //@bean
+    @bean
     public getJwtAuthentication(): AuthenticationFactory {
         return new JwtAuthentication();
     }
@@ -21,8 +21,9 @@ export default class JwtAuthentication extends AuthenticationFactory {
             const jwtMiddleware = expressjwt(jwtConfig);
             jwtMiddleware(req, res, (err) => {  
                 if (err) {
-                    next(err);
+                    //next(err);
                 }
+                next();
             });
         }
     }

package/app/src/main.ts

@@ -1,4 +1,4 @@
-import { app, log, autoware, ServerFactory } from "../../src/typespeed";
+import { app, log, autoware, ServerFactory } from "../../";
 //import * as basicAuth from "express-basic-auth"
 let appServer = null;
 

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

@@ -18,7 +18,7 @@ export default class TestDatabase {
     @getMapping("/db/insert2")
     async insertByObject(req, res) {
         const newId = await this.addRowByObject({
-            "id": 25, "name": "new name 25"
+            "id": Math.ceil(Math.random() * 1000), "name": "new name 25"
         });
         log("Insert newId: " + newId);
         res.send("Insert success");

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

@@ -1,9 +1,11 @@
-import { component } from "../../";
+import { component, getMapping, error } from "../../";
 
 @component
 export default class TestLog {
 
-    constructor() {
-        //log("TestLog constructor");
+    @getMapping("/test/error")
+    testError() {
+        //error("This is a error log");
+        return "This is a error log";
     }
 }

package/app/src/test-mq.class.ts

@@ -8,7 +8,7 @@ export default class TestMq {
     @autoware
     private rabbitMQ: RabbitMQ;
 
-    //@rabbitListener("myqueues")
+    @rabbitListener("myqueues")
     public async listen(message) {
         log(" Received by Decorator '%s'", message.content.toString());
     }
@@ -31,9 +31,8 @@ export default class TestMq {
             password: 'guest'
         });
         const channel = await connection.createChannel();
-        await channel.checkQueue(queue);
+        await channel.assertQueue(queue);
         channel.sendToQueue(queue, Buffer.from(text));
-        console.log(" [x] Sent by queue '%s'", text);
         await channel.close();
         return "sent by queue";
     }
@@ -46,7 +45,6 @@ export default class TestMq {
         const channel = await connection.createChannel();
         await channel.checkExchange(exchange);
         channel.publish(exchange, '', Buffer.from(text));
-        console.log(" [x] Publish by exchange '%s'", text);
         await channel.close();
         return "sent by exchange";
     }
@@ -60,10 +58,8 @@ export default class TestMq {
         await channel.checkQueue(queue);
         await channel.checkQueue(queue2);
         await channel.consume(queue, (message) => {
-            console.log(" [x] Received '%s'", message.content.toString());
         }, { noAck: true });
         await channel.consume(queue2, (message) => {
-            console.log(" [x] Received queue2 '%s'", message.content.toString());
         }, { noAck: true });
         return "ok";
     }

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

@@ -38,33 +38,33 @@ export default class TestOrm {
 
     @getMapping("/orm/count")
     async countTest(req, res) {
-        const results = await this.userModel.count();
-        res.send(results);
+        const total = await this.userModel.count();
+        res.send({"count": total});
     }
 
     @getMapping("/orm/new")
     async newUserTest(req, res) {
-        const results = await this.userModel.newUsers();
-        res.send("new user test, to " + results);
+        const newId = await this.userModel.newUsers();
+        res.send({"newId": newId});
     }
 
     @getMapping("/orm/page/calculate")
     async calculatePage(req, res) {
         const pages = this.userModel.pager(15, 376);
-        res.send("pages calculate result: " + JSON.stringify(pages));
+        res.json(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));
+        res.json(results);
     }
 
     @postMapping("/orm/edit")
     async updateTest(req, res) {
-        const results = await this.userModel.editUser(req.body.id, req.body.name);
-        res.send(results);
+        const effectRows = await this.userModel.editUser(req.body.id, req.body.name);
+        res.send({"effectRows": effectRows});
     }
 
     //@schedule("* * * * * *")

package/app/src/test-request.class.ts

@@ -18,20 +18,20 @@ export default class TestRequest {
     }
 
     @postMapping("/request/body")
-    testBody(@res res, @reqBody body: object):MutilUsers {
+    testBody(@res res, @reqBody body: UserDto):MutilUsers {
         log("body: " + JSON.stringify(body));
-        return new MutilUsers("group", [new UserDto(1, "name"), new UserDto(2, "name")]);
+        return new MutilUsers("group", [body]);
     }
 
     @postMapping("/request/form")
     testForm(@res res, @reqForm("name") name: string) {
         log("form: " + JSON.stringify(name));
-        res.send("test form");
+        res.send("Got name: " + name);
     }
 
     @getMapping("/request/param/:id")
     testParam(@res res, @reqParam id: number) {
         log("id: " + id);
-        res.send("test param");
+        res.send("test param: " + id);
     }
 }

package/app/src/user-model.class.ts

@@ -8,24 +8,25 @@ export default class UserModel extends Model {
         const users = await this.findAll({
             id: { $lt: 10, $lte: 20 }, "name": { $like: "%a%" },
             $or: [{ id: 1 }, { id: 2 }]
-        });
+        }, "id asc", "*", { page: 1, pageSize: 10 });
         log("users", users);
         return "getUsers";
     }
 
     async getUser(id: number) {
-        const user = await this.find({ id: id }, "");
+        const user = await this.find({ id: id }, "id asc", "*");
         log("user", user);
         return "getUser";
     }
 
     async newUsers() {
-        const users = await this.create([
-            new UserDto(30, "UserDto 30"),
-            new UserDto(31, "UserDto 31"),
-            { id: 33, name: "UserDto 33" }
+        const newId = Math.ceil(Math.random() * 1000);
+        await this.create([
+            new UserDto(newId, "UserDto " + newId),
+            new UserDto(newId+1, "UserDto " + (newId+1)),
+            { id: newId+2, name: "UserDto " + (newId+2) },
         ]);
-        return "newUsers";
+        return newId;
     }
 
     async remove(id: number) {
@@ -33,13 +34,13 @@ export default class UserModel extends Model {
         return "remove rows: " + result;
     }
 
-    async count() {
+    async count():Promise<number> {
         const result = await this.findCount("1");
-        return "we had users : " + result;
+        return result;
     }
 
     async editUser(id: number, name: string) {
-        const result = await this.update({ id: id }, { name: name });
-        return "edit user: " + result;
+        const effectRows = await this.update({ id: id }, { name: name });
+        return effectRows;
     }
 }

package/dist/database.decorator.js

@@ -74,7 +74,7 @@ function select(sql) {
 exports.select = select;
 function resultType(dataClass) {
     return function (target, propertyKey) {
-        resultTypeMap.set([target.constructor.name, propertyKey].toString(), new dataClass());
+        resultTypeMap.set([target.constructor.name, propertyKey].toString(), dataClass);
         //never return
     };
 }

package/dist/default/express-server.class.js

@@ -32,15 +32,13 @@ class ExpressServer extends server_factory_class_1.default {
     setMiddleware(middleware) {
         this.middlewareList.push(middleware);
     }
-    start(port) {
+    start(port, callback) {
         this.app.use(this.authentication.afterCompletion);
         this.middlewareList.forEach(middleware => {
             this.app.use(middleware);
         });
         this.setDefaultMiddleware();
-        return this.app.listen(port, () => {
-            (0, core_decorator_1.log)("server start at port: " + port);
-        });
+        return this.app.listen(port, callback);
     }
     setDefaultMiddleware() {
         this.app.use(express.urlencoded({ extended: true }));

package/dist/factory/log-factory.class.js

@@ -7,8 +7,5 @@ class LogFactory {
     error(message, ...optionalParams) {
         console.error(message, ...optionalParams);
     }
-    debug(message, ...optionalParams) {
-        console.debug(message, ...optionalParams);
-    }
 }
 exports.default = LogFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespeed",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "A new Framework for TypeScript.",
   "author": "speedphp",
   "license": "MIT License",

package/src/database.decorator.ts

@@ -72,7 +72,7 @@ function select(sql: string) {
 
 function resultType(dataClass) {
     return function (target, propertyKey: string) {
-        resultTypeMap.set([target.constructor.name, propertyKey].toString(), new dataClass());
+        resultTypeMap.set([target.constructor.name, propertyKey].toString(), dataClass);
         //never return
     };
 }

package/src/default/express-server.class.ts

@@ -53,7 +53,7 @@ export default class ExpressServer extends ServerFactory {
         this.middlewareList.push(middleware);
     }
 
-    public start(port: number): any {
+    public start(port: number, callback?: Function): any {
         this.app.use(this.authentication.afterCompletion);
         this.middlewareList.forEach(middleware => {
             this.app.use(middleware);
@@ -61,9 +61,7 @@ export default class ExpressServer extends ServerFactory {
 
         this.setDefaultMiddleware();
  
-        return this.app.listen(port, () => {
-            log("server start at port: " + port);
-        });
+        return this.app.listen(port, callback);
     }
 
     private setDefaultMiddleware() {

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

@@ -5,7 +5,4 @@ export default abstract class LogFactory {
     public error(message?: any, ...optionalParams: any[]) : void {
         console.error(message, ...optionalParams);
     }
-    public debug(message?: any, ...optionalParams: any[]) : void {
-        console.debug(message, ...optionalParams);
-    }
 }

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

@@ -2,5 +2,5 @@ export default abstract class ServerFactory {
     public app;
     protected middlewareList: Array<any> = [];
     public abstract setMiddleware(middleware: any);
-    public abstract start(port: number);
+    public abstract start(port: number, callback?: Function): any;
 }

package/test/database.test.ts

@@ -0,0 +1,61 @@
+const chaiObj = require('chai');
+chaiObj.use(require("chai-http"));
+const expect = chaiObj.expect;
+describe("Test Database", () => {
+    const testDatabase = [
+        {
+            "url": "/db/insert?id=" + Math.ceil(Math.random() * 1000),
+            "expect": "Insert success",
+        },
+        {
+            "url": "/db/insert2",
+            "expect": "Insert success",
+        },
+        {
+            "url": "/db/update",
+            "expect": "update success",
+        },
+        {
+            "url": "/db/set-cache?value=zzz",
+            "expect": "set cache success",
+        },
+        {
+            "url": "/db/get-cache",
+            "expect": "zzz",
+        }
+    ]
+    testDatabase.forEach((testRequest) => {
+        it(testRequest.url, (done) => {
+            chaiObj.request("http://localhost:8081").get(testRequest.url).end((err, res) => {
+                chaiObj.assert.equal(testRequest.expect, res.text);
+                return done();
+            });
+        });
+    });
+    it("/db/select1", (done) => {
+        chaiObj.request("http://localhost:8081").get("/db/select1").end((err, res) => {
+            const dataList = JSON.parse(res.text);
+            expect(dataList).to.be.an('array');
+            expect(dataList[0]).to.have.property("id").which.is.a("number").equal(1);
+            done();
+        });
+    });
+    it("/db/select", (done) => {
+        chaiObj.request("http://localhost:8081").get("/db/select").end((err, res) => {
+            const dataList = JSON.parse(res.text);
+            expect(dataList).to.be.an('array');
+            expect(dataList[0]).to.have.property('id');
+            done();
+        });
+    });
+    it("/db/select-user", (done) => {
+        chaiObj.request("http://localhost:8081").get("/db/select-user").end((err, res) => {
+            const dataList = JSON.parse(res.text);
+            expect(dataList).to.be.an('array');
+            expect(dataList[0]).to.have.property('id');
+            done();
+        });
+    });
+});
+
+export {};

package/test/first-page.test.ts

@@ -1,34 +1,32 @@
 const chaiObj = require('chai');
-
 chaiObj.use(require("chai-http"));
 
-const firstPageRequests = [
-    {
-        "url": "/first",
-        "expect": "FirstPage index running",
-    },
-    {
-        "url": "/first/sendJson",
-        "expect": JSON.stringify({
-            "from": "sendJson",
-            "to": "Browser"
-        }),
-    },
-    {
-        "url": "/first/sendResult",
-        "expect": "sendResult",
-    },
-    {
-        "url": "/first/renderTest",
-        "expect": "Hello zzz!",
-    }
-]
-
-describe("First page", () => {
-    let appClose;
-    before(() => {
-        appClose = require("../app/src/main");
-    });
+describe("Test First page", () => {
+    const firstPageRequests = [
+        {
+            "url": "/first",
+            "expect": "FirstPage index running",
+        },
+        {
+            "url": "/first/sendJson",
+            "expect": JSON.stringify({
+                "from": "sendJson",
+                "to": "Browser"
+            }),
+        },
+        {
+            "url": "/first/sendResult",
+            "expect": "sendResult",
+        },
+        {
+            "url": "/first/renderTest",
+            "expect": "Hello zzz!",
+        },
+        {
+            "url": "/test/error",
+            "expect": "This is a error log",
+        }
+    ]
     firstPageRequests.forEach((testRequest) => {
         it(testRequest.url, (done) => {
             chaiObj.request("http://localhost:8081").get(testRequest.url).end((err, res) => {
@@ -37,9 +35,7 @@ describe("First page", () => {
             });
         });
     });
-    after(() => {
-        if(appClose != null){
-            appClose.default();
-        }
-    });
-});
+
+});
+
+export {};

package/test/hooks.ts

@@ -0,0 +1,10 @@
+let appClose;
+before(() => {
+    appClose = require("../app/src/main");
+});
+
+after(() => {
+    if(appClose != null){
+        appClose.default();
+    }
+});

package/test/mq.test.ts

@@ -0,0 +1,34 @@
+const chaiObj = require('chai');
+
+chaiObj.use(require("chai-http"));
+
+const expect = chaiObj.expect;
+
+describe("Test RabbitMQ", () => {
+    it("/mq/listen", (done) => {
+        chaiObj.request("http://localhost:8081").get("/mq/listen").end((err, res) => {
+            expect(res.text).to.be.equal("ok");
+            done();
+        });
+    });
+    it("/mq/sendByMQClass", (done) => {
+        chaiObj.request("http://localhost:8081").get("/mq/sendByMQClass").end((err, res) => {
+            expect(res.text).to.be.equal("sent by MQClass");
+            done();
+        });
+    });
+    it("/mq/sendByQueue", (done) => {
+        chaiObj.request("http://localhost:8081").get("/mq/sendByQueue").end((err, res) => {
+            expect(res.text).to.be.equal("sent by queue");
+            done();
+        });
+    });
+    it("/mq/sendByExchange", (done) => {
+        chaiObj.request("http://localhost:8081").get("/mq/sendByExchange").end((err, res) => {
+            expect(res.text).to.be.equal("sent by exchange");
+            done();
+        });
+    });
+});
+
+export { };

package/test/orm.test.ts

@@ -0,0 +1,65 @@
+const chaiObj = require('chai');
+chaiObj.use(require("chai-http"));
+const expect = chaiObj.expect;
+
+describe("Test Request Paramters", () => {
+    it("/redis", (done) => {
+        chaiObj.request("http://localhost:8081").get("/redis").end((err, res) => {
+            expect(res.text).to.be.equal("get from redis: " + "Hello World");
+            done();
+        });
+    });
+    it("/orm/first", (done) => {
+        chaiObj.request("http://localhost:8081").get("/orm/first").end((err, res) => {
+            expect(res.text).to.be.equal("first test, to getUsers");
+            done();
+        });
+    });
+    it("/orm/one", (done) => {
+        chaiObj.request("http://localhost:8081").get("/orm/one?id=1").end((err, res) => {
+            expect(res.text).to.be.equal("find one test, to getUser");
+            done();
+        });
+    });
+    it("/orm/delete", (done) => {
+        chaiObj.request("http://localhost:8081").get("/orm/delete?id=0").end((err, res) => {
+            expect(res.text).to.be.equal("remove user, results: remove rows: 0");
+            done();
+        });
+    });
+    it("/orm/count", (done) => {
+        chaiObj.request("http://localhost:8081").get("/orm/count").end((err, res) => {
+            expect(JSON.parse(res.text)).to.have.property("count").which.is.a("number").above(0);
+            done();
+        });
+    });
+    it("/orm/new", (done) => {
+        chaiObj.request("http://localhost:8081").get("/orm/new").end((err, res) => {
+            expect(JSON.parse(res.text)).to.have.property("newId").which.is.a("number").above(0);
+            done();
+        });
+    });
+    it("/orm/page/calculate", (done) => {
+        chaiObj.request("http://localhost:8081").get("/orm/page/calculate").end((err, res) => {
+            expect(JSON.parse(res.text)).to.have.property("totalPage").which.is.a("number").equal(38);
+            done();
+        });
+    });
+    it("/orm/pages", (done) => {
+        chaiObj.request("http://localhost:8081").get("/orm/pages/1").end((err, res) => {
+            expect(JSON.parse(res.text)).is.a("array").lengthOf(3);
+            done();
+        });
+    });
+    it("/orm/edit", (done) => {
+        chaiObj.request("http://localhost:8081").post("/orm/edit")
+            .type("form")
+            .send({ id: 1, name: "new name" })
+            .end((err, res) => {
+                expect(JSON.parse(res.text)).to.have.property("effectRows").which.to.be.oneOf([0, 1]);
+                done();
+            });
+    });
+});
+
+export { };

package/test/request.test.ts

@@ -0,0 +1,50 @@
+import MutilUsers from "../app/src/entities/mutil-users.class";
+import UserDto from "../app/src/entities/user-dto.class";
+const chaiObj = require('chai');
+chaiObj.use(require("chai-http"));
+const expect = chaiObj.expect;
+
+describe("Test Request Paramters", () => {
+    it("/request/res", (done) => {
+        chaiObj.request("http://localhost:8081").get("/request/res").end((err, res) => {
+            expect(res.text).to.be.equal("test res");
+            done();
+        });
+    });
+    it("/request/query", (done) => {
+        chaiObj.request("http://localhost:8081").get("/request/query?id=100").end((err, res) => {
+            expect(res.text).to.be.equal(JSON.stringify(
+                new MutilUsers("group", [new UserDto(1, "name"), new UserDto(2, "name")]
+            )));
+            done();
+        });
+    });
+    it("/request/body", (done) => {
+        const sendUser = new UserDto(100, "name100");
+        chaiObj.request("http://localhost:8081").post("/request/body")
+            .send(sendUser)
+            .end((err, res) => {
+            expect(res.text).to.be.equal(JSON.stringify(new MutilUsers("group", [sendUser])));
+            done();
+        });
+    });
+    it("/request/form", (done) => {
+        const sendName = "name200";
+        chaiObj.request("http://localhost:8081").post("/request/form")
+            .type("form")
+            .send({ name: sendName })
+            .end((err, res) => {
+            expect(res.text).to.be.equal("Got name: " + sendName);
+            done();
+        });
+    });
+    it("/request/param", (done) => {
+        const sendId = 200;
+        chaiObj.request("http://localhost:8081").get("/request/param/" + sendId).end((err, res) => {
+            expect(res.text).to.be.equal("test param: " + sendId);
+            done();
+        });
+    });
+});
+
+export {};

package/test/second-page.test.ts

@@ -0,0 +1,51 @@
+import * as jwttoken from "jsonwebtoken";
+import * as fs from "fs";
+const chaiObj = require('chai');
+
+chaiObj.use(require("chai-http"));
+
+
+describe("Test Sencond Page", () => {
+    it("/second/setCookie", (done) => {
+        chaiObj.request("http://localhost:8081").get("/second/setCookie").end((err, res) => {
+            chaiObj.assert.equal(res.headers["set-cookie"].includes("name=zzz; Path=/"), true);
+            done();
+        });
+    });
+    it("/second/getCookie", (done) => {
+        const cookieSet = "mycookie"
+        chaiObj.request("http://localhost:8081").get("/second/getCookie")
+            .set("Cookie", "name=" + cookieSet).end((err, res) => {
+                chaiObj.assert.equal(res.text, "getCookie: " + cookieSet);
+                done();
+            });
+    });
+    it("/second/testSession", (done) => {
+        chaiObj.request("http://localhost:8081").get("/second/testSession").end((err, res) => {
+            chaiObj.assert.equal(res.text, "testForSession: 1");
+            done();
+        });
+    });
+    it("/upload", (done) => {
+        const uploadfile = "./app/static/k.jpg";
+        chaiObj.request("http://localhost:8081").post("/upload")
+            .set('Content-Type', 'multipart/form-data')
+            .attach("file", uploadfile)
+            .end((err, res) => {
+                chaiObj.assert.equal(res.text, "upload success");
+                done();
+            });
+    });
+    it("/form", (done) => {
+        const token = jwttoken.sign({ foo: 'bar' }, 'shhhhhhared-secret');
+        const fileContents = fs.readFileSync("./app/src/views/upload.html", "utf8");
+        chaiObj.request("http://localhost:8081").post("/form")
+            .set({ "Authorization": `Bearer ${token}` })
+            .end((err, res) => {
+                chaiObj.assert.equal(res.text, fileContents);
+                done();
+            });
+    });
+});
+
+export { };