typespeed 2.2.1 → 2.3.2

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "typespeed",
-  "version": "2.2.1",
+  "version": "2.3.2",
   "description": "A new Framework for TypeScript.",
   "author": "speedphp",
   "license": "MIT License",
   "scripts": {
+    "test": "mocha --require ts-node/register test/**/*.ts --exit",
+    "test-with-coverage": "nyc --reporter=text npm test",
+    "start": "ts-node --transpile-only app/src/main.ts",
     "build": "tsc -p .",
     "postbuild": "cp src/typespeed.d.ts dist/typespeed.d.ts && cp -r src/default/pages dist/default/pages && cp -r src/scaffold/templates dist/scaffold/templates",
     "prebuild": "rm -rf dist",
@@ -30,7 +33,6 @@
     "middleware"
   ],
   "dependencies": {
-    "@types/node": "^18.0.6",
     "commander": "^9.4.0",
     "compression": "^1.7.4",
     "connect-redis": "^6.1.3",
@@ -50,8 +52,18 @@
     "reflect-metadata": "^0.1.13",
     "serve-favicon": "^2.5.0",
     "tracer": "^1.1.6",
-    "typescript": "^4.7.4",
     "walk-sync": "^3.0.0",
     "amqplib": "0.10.3"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.6",
+    "@types/express": "^4.17.13",
+    "@types/mocha": "^10.0.1",
+    "chai": "4.3.7",
+    "chai-http": "^4.4.0",
+    "mocha": "10.2.0",
+    "nyc": "^15.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
   }
 }

package/src/core.decorator.ts

@@ -1,55 +1,11 @@
 import "reflect-metadata";
-import * as fs from "fs";
-import * as path from "path";
-import * as walkSync from "walk-sync";
 import * as cron from "cron";
 import LogFactory from "./factory/log-factory.class";
 
-let globalConfig = {};
 const resourceObjects = new Map<string, object>();
 const beanMapper: Map<string, any> = new Map<string, any>();
 const objectMapper: Map<string, any> = new Map<string, any>();
 
-function app<T extends { new(...args: any[]): {} }>(constructor: T) {
-    const coreDir = __dirname;
-    const mainPath = path.dirname(getRootPath() || process.argv[1]);
-    const configFile = mainPath + "/config.json";
-    if (fs.existsSync(configFile)) {
-        globalConfig = JSON.parse(fs.readFileSync(configFile, "utf-8"));
-        const nodeEnv = process.env.NODE_ENV || "development";
-        const envConfigFile = mainPath + "/config-" + nodeEnv + ".json";
-        if (fs.existsSync(envConfigFile)) {
-            globalConfig = Object.assign(globalConfig, JSON.parse(fs.readFileSync(envConfigFile, "utf-8")));
-        }
-    }
-
-    const coreFiles = walkSync(coreDir, { globs: ['**/*.ts'], ignore: ['**/*.d.ts', 'scaffold/**'] });
-    const mainFiles = walkSync(mainPath, { globs: ['**/*.ts'] });
-
-    (async function () {
-        try {
-            for (let p of coreFiles) {
-                let moduleName = p.replace(".d.ts", "").replace(".ts", "");
-                await import(coreDir + "/" + moduleName);
-            }
-
-            for (let p of mainFiles) {
-                let moduleName = p.replace(".d.ts", "").replace(".ts", "");
-                await import(mainPath + "/" + moduleName);
-            }
-        } catch (err) {
-            console.error(err);
-        }
-        //log("main start")
-        const main = new constructor();
-        main["main"]();
-    }());
-}
-
-function config(node: string) {
-    return globalConfig[node] || null;
-}
-
 function component(constructorFunction) {
     objectMapper.set(constructorFunction.name, new constructorFunction());
 }
@@ -72,28 +28,6 @@ function getBean(mappingClass: Function): any {
     return bean["factory"];
 }
 
-function value(configPath: string): any {
-    return function (target: any, propertyKey: string) {
-        if (globalConfig === undefined) {
-            Object.defineProperty(target, propertyKey, {
-                get: () => {
-                    return undefined;
-                }
-            });
-        } else {
-            let pathNodes = configPath.split(".");
-            let nodeValue = globalConfig;
-            for (let i = 0; i < pathNodes.length; i++) {
-                nodeValue = nodeValue[pathNodes[i]];
-            }
-            Object.defineProperty(target, propertyKey, {
-                get: () => {
-                    return nodeValue;
-                }
-            });
-        }
-    };
-}
 
 function autoware(target: any, propertyKey: string): void {
     const type = Reflect.getMetadata("design:type", target, propertyKey);
@@ -145,28 +79,10 @@ function error(message?: any, ...optionalParams: any[]) {
     }
 }
 
-function getRootPath() {
-    const lines = new Error().stack.split("\n");
-    let rootPath = "";
-    let lastLine = "";
-    for (let line of lines) {
-        if (line.includes("at ") &&
-            line.includes("node:internal/modules/cjs/loader") &&
-            line.includes("Module._compile") &&
-            lastLine.includes("at ") &&
-            lastLine.includes("Object.<anonymous>")) {
-            rootPath = lastLine.split("(")[1].split(":")[0];
-            break;
-        }
-        lastLine = line;
-    }
-    return rootPath;
-}
-
 function schedule(cronTime: string | Date) {
     return (target: any, propertyKey: string) => {
         new cron.CronJob(cronTime, target[propertyKey]).start();
     }
 }
 
-export { component, bean, resource, log, app, value, error, config, autoware, getBean, getComponent, schedule };
+export { component, bean, resource, log, error, autoware, getBean, getComponent, schedule };

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

@@ -8,7 +8,8 @@ import * as expressSession from "express-session";
 import * as connectRedis from "connect-redis";
 import ServerFactory from "../factory/server-factory.class";
 import { setRouter } from "../route.decorator";
-import { bean, log, value, error, autoware } from "../core.decorator";
+import { value } from "../typespeed";
+import { bean, log, error, autoware } from "../core.decorator";
 import Redis from "./redis.class";
 import AuthenticationFactory from "../factory/authentication-factory.class";
 
@@ -52,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);
@@ -60,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/default/node-cache.class.ts

@@ -1,6 +1,7 @@
 import CacheFactory from "../factory/cache-factory.class";
 import * as cache from "node-cache";
-import { value, bean } from "../core.decorator";
+import { value } from "../typespeed";
+import { bean } from "../core.decorator";
 
 export default class NodeCache extends CacheFactory {
     private NodeCache: any;

package/src/default/rabbitmq.class.ts

@@ -1,4 +1,5 @@
-import { bean, config } from "../core.decorator";
+import { bean  } from "../core.decorator";
+import { config } from "../typespeed";
 import { connect } from "amqplib";
 let rabbitConnection = null;
 

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

@@ -1,7 +1,7 @@
 import { createConnection, createPool } from "mysql2";
 import DataSourceFactory from "../factory/data-source-factory.class";
-import { bean, config } from "../core.decorator";
-
+import { bean } from "../core.decorator";
+import { config } from "../typespeed";
 export default class ReadWriteDb extends DataSourceFactory {
     private readonly readSession;
     private readonly writeSession;

package/src/default/redis.class.ts

@@ -1,6 +1,6 @@
-import { bean, config } from "../core.decorator";
+import { bean } from "../core.decorator";
 import IoRedis from "ioredis";
-
+import { config } from "../typespeed";
 export default class Redis extends IoRedis {
 
     @bean

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/src/typespeed.ts

@@ -1,8 +1,93 @@
+import "reflect-metadata";
+import * as fs from "fs";
+import * as path from "path";
+import * as walkSync from "walk-sync";
+
+let globalConfig = {};
+const coreDir = __dirname;
+const mainPath = path.dirname(getRootPath(new Error().stack.split("\n")) || process.argv[1]);
+const configFile = mainPath + "/config.json";
+if (fs.existsSync(configFile)) {
+    globalConfig = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+    const nodeEnv = process.env.NODE_ENV || "development";
+    const envConfigFile = mainPath + "/config-" + nodeEnv + ".json";
+    if (fs.existsSync(envConfigFile)) {
+        globalConfig = Object.assign(globalConfig, JSON.parse(fs.readFileSync(envConfigFile, "utf-8")));
+    }
+}
+
+function app<T extends { new(...args: any[]): {} }>(constructor: T) {
+    const coreFiles = walkSync(coreDir, { globs: ['**/*.ts'], ignore: ['**/*.d.ts', 'scaffold/**'] });
+    const mainFiles = walkSync(mainPath, { globs: ['**/*.ts'] });
+
+    (async function () {
+        try {
+            for (let p of coreFiles) {
+                let moduleName = p.replace(".d.ts", "").replace(".ts", "");
+                await import(coreDir + "/" + moduleName);
+            }
+
+            for (let p of mainFiles) {
+                let moduleName = p.replace(".d.ts", "").replace(".ts", "");
+                await import(mainPath + "/" + moduleName);
+            }
+        } catch (err) {
+            console.error(err);
+        }
+        //log("main start")
+        const main = new constructor();
+        main["main"]();
+    }());
+}
+
+function config(node: string) {
+    return globalConfig[node] || null;
+}
+
+function value(configPath: string): any {
+    return function (target: any, propertyKey: string) {
+        if (globalConfig === undefined) {
+            Object.defineProperty(target, propertyKey, {
+                get: () => {
+                    return undefined;
+                }
+            });
+        } else {
+            let pathNodes = configPath.split(".");
+            let nodeValue = globalConfig;
+            for (let i = 0; i < pathNodes.length; i++) {
+                nodeValue = nodeValue[pathNodes[i]];
+            }
+            Object.defineProperty(target, propertyKey, {
+                get: () => {
+                    return nodeValue;
+                }
+            });
+        }
+    };
+}
+
+function getRootPath(lines: string[]) {
+    const macths = ["at Function.Module._load", "at Module.require", "at require", "at Object.<anonymous>"];
+    let matchIndex = 0;
+    for (let line of lines) {
+        if (line.includes(macths[matchIndex])) {
+            if(matchIndex === macths.length - 1) {
+                return line.split("(")[1].split(":")[0];
+            }
+            matchIndex++;
+        }else{
+            matchIndex = 0;
+        }
+    }
+    return undefined;
+}
+
+export { app, value, config };
 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";

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

@@ -0,0 +1,41 @@
+const chaiObj = require('chai');
+chaiObj.use(require("chai-http"));
+
+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) => {
+                chaiObj.assert.equal(testRequest.expect, res.text);
+                return done();
+            });
+        });
+    });
+
+});
+
+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 { };