typespeed 2.4.11 → 2.5.1

package/src/default/rabbitmq.class.ts

@@ -1,61 +0,0 @@
-import { bean, getComponent  } from "../core.decorator";
-import { config } from "../typespeed";
-import { connect } from "amqplib";
-let rabbitConnection = null;
-
-class RabbitMQ {
-    
-    @bean
-    public getRabbitMQ(): RabbitMQ {
-        if (!config("rabbitmq")) {
-            return null;
-        }
-        return new RabbitMQ();
-    }
-
-    public async publishMessageToExchange(exchange: string, routingKey: string, message: string): Promise<void> {
-        const channel = await getChannel();
-        await channel.assertExchange(exchange);
-        channel.publish(exchange, routingKey, Buffer.from(message));
-        await channel.close();
-    }
-
-    public async sendMessageToQueue(queue: string, message: string): Promise<void> {
-        const channel = await getChannel();
-        await channel.accertQueue(queue);
-        channel.sendToQueue(queue, Buffer.from(message));
-        await channel.close();
-    }
-
-    public async publish(exchange: string, routingKey: string, message: string): Promise<void> {
-        await this.publishMessageToExchange(exchange, routingKey, message);
-    }
-
-    public async send(queue: string, message: string):  Promise<void> {
-        await this.sendMessageToQueue(queue, message);
-    }
-}
-
-async function getChannel() {
-    if (rabbitConnection === null) {
-        rabbitConnection = await connect(config("rabbitmq"));
-        process.once('SIGINT', async () => { 
-            await rabbitConnection.close();
-        });
-    }
-    const channel = await rabbitConnection.createChannel();
-    return channel;
-}
-
-function rabbitListener(queue: string) {
-    return (target: any, propertyKey: string) => {
-        (async function () {
-            const channel = await getChannel();
-            await channel.assertQueue(queue);
-            const targetBean = getComponent(target.constructor);
-            await channel.consume(queue, targetBean[propertyKey], { noAck: true });
-        }());
-    }
-}
-
-export { RabbitMQ, rabbitListener };

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

@@ -1,53 +0,0 @@
-import { createConnection, createPool } from "mysql2";
-import DataSourceFactory from "../factory/data-source-factory.class";
-import { bean } from "../core.decorator";
-import { config } from "../typespeed";
-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

@@ -1,79 +0,0 @@
-import { bean, getComponent } from "../core.decorator";
-import { default as IoRedis, RedisKey} from "ioredis";
-import { config } from "../typespeed";
-const redisSubscribers = {};
-
-class Redis extends IoRedis {
-    private static pubObj: Redis = null;
-    private static subObj: Redis = null;
-
-    @bean
-    public getRedis(): Redis {
-        return Redis.getInstanceOfRedis("pub");
-    }
-
-    public async zrevranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>> {
-        const list = await this.zrevrange(key, start, stop, "WITHSCORES");
-        const map = new Map<string, number>();
-        for (let i = 0; i < list.length; i = i + 2) {
-            map.set(list[i], Number(list[i + 1]));
-        }
-        return map;
-    }
-
-    public async zranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>> {
-        const list = await this.zrange(key, start, stop, "WITHSCORES");
-        const map = new Map<string, number>();
-        for (let i = 0; i < list.length; i = i + 2) {
-            map.set(list[i], Number(list[i + 1]));
-        }
-        return map;
-    }
-
-    static getInstanceOfRedis(mode: "sub" | "pub") {
-        if (!config("redis")) {
-            return null;
-        }
-        if (mode === "pub") {
-            this.pubObj = this.pubObj || new Redis(config("redis"));
-            return this.pubObj;
-        } else {
-            this.subObj = this.subObj || new Redis(config("redis"));
-            return this.subObj;
-        }
-    }
-
-    static async close() {
-        if(this.subObj != null) { await this.subObj.quit(); }
-        if(this.pubObj != null) { await this.pubObj.quit(); }
-    }
-}
-
-function redisSubscriber(channel: string) {
-    if (!config("redis")) return function(){
-        throw new Error("redis not configured");
-    };
-    Redis.getInstanceOfRedis("sub").subscribe(channel, function (err, count) {
-        if (err) {
-            console.error(err);
-        }
-    });
-    return function (target: any, propertyKey: string) {
-        redisSubscribers[channel] = {
-            target: target,
-            propertyKey: propertyKey
-        };
-    };
-}
-
-if (config("redis")) {
-    Redis.getInstanceOfRedis("sub").on("message", async function (channel, message) {
-        await getComponent(redisSubscribers[channel].target.constructor)[redisSubscribers[channel].propertyKey](message);
-    });
-}
-
-process.once('SIGINT', () => { 
-    Redis.close();
-});
-
-export { Redis, redisSubscriber };

package/src/default/socket-io.class.ts

@@ -1,81 +0,0 @@
-import { Server as IoServer } from "socket.io";
-import { createServer } from "http";
-import { getComponent } from "../core.decorator";
-
-let io: IoServer = null;
-const listeners = { "event": [], "disconnect": null, "error": null, "connected": null };
-
-class SocketIo {
-
-    public static setIoServer(app, ioSocketConfig) {
-        const httpServer = createServer(app);
-        io = new IoServer(httpServer, ioSocketConfig);
-        io.use(async (socket, next) => {
-            if (listeners["connected"] !== null) {
-                await getComponent(listeners["connected"].target.constructor)[listeners["connected"].propertyKey](socket, async (err) => {
-                    if (listeners["error"] !== null && err) {
-                        await getComponent(listeners["error"].target.constructor)[listeners["error"].propertyKey](socket, err);
-                    }
-                });
-            }
-            next();
-        });
-        io.on("connection", async (socket) => {
-            if (listeners["disconnect"] !== null) {
-                socket.on("disconnect", async (reason) => {
-                    await getComponent(listeners["disconnect"].target.constructor)[listeners["disconnect"].propertyKey](socket, reason);
-                });
-            }
-            socket.use(async ([event, ...args], next) => {
-                try {
-                    for (let listener of listeners["event"]) {
-                        if (listener[1] === event) {
-                            await getComponent(listener[0].target.constructor)[listener[0].propertyKey](socket, ...args);
-                        }
-                    }
-                } catch (err) {
-                    next(err);
-                }
-            });
-
-            if (listeners["error"] !== null) {
-                socket.on("error", async (err) => {
-                    await getComponent(listeners["error"].target.constructor)[listeners["error"].propertyKey](socket, err);
-                });
-            }
-        });
-        return httpServer;
-    }
-
-    public static onEvent(event: string) {
-        return (target: any, propertyKey: string) => {
-            listeners["event"].push([{
-                target: target,
-                propertyKey: propertyKey
-            }, event]);
-        }
-    }
-
-    public static onError(target: any, propertyKey: string) {
-        listeners["error"] = {
-            target: target,
-            propertyKey: propertyKey
-        };
-    }
-
-    public static onDisconnect(target: any, propertyKey: string) {
-        listeners["disconnect"] = {
-            target: target,
-            propertyKey: propertyKey
-        };
-    }
-
-    public static onConnected(target: any, propertyKey: string) {
-        listeners["connected"] = {
-            target: target,
-            propertyKey: propertyKey
-        };
-    }
-}
-
-export { SocketIo, io }

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

@@ -1,9 +0,0 @@
-import * as express from 'express';
-export default abstract class AuthenticationFactory {
-    public preHandle(req: express.Request, res: express.Response, next: express.NextFunction): void{
-        next();
-    }
-    public afterCompletion(req: express.Request, res: express.Response, next: express.NextFunction): void{
-        next();
-    }
-}

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

@@ -1,7 +0,0 @@
-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

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

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

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

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

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

package/src/route.decorator.ts

@@ -1,175 +0,0 @@
-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 routerParams = {};
-const routerParamsTotal = {};
-const routerMiddleware = {};
-function setRouter(app: express.Application) {
-  ["get", "post", "all"].forEach(method => {
-    for (let key in routerMapper[method]) {
-      const rounterFunction = routerMapper[method][key];
-      if (routerMiddleware[rounterFunction["name"]]) {
-        const 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(),
-      "target": target.constructor,
-      "propertyKey": propertyKey,
-      "invoker": async (req, res, next) => {
-        const routerBean = getComponent(target.constructor);
-        try {
-          let paramTotal = routerBean[propertyKey].length;
-          if(routerParamsTotal[[target.constructor.name, propertyKey].toString()]){
-            paramTotal = Math.max(paramTotal, routerParamsTotal[[target.constructor.name, propertyKey].toString()]);
-          }
-          const args = [req, res, next];
-          if(paramTotal > 0) {
-            for(let i = 0; i < paramTotal; i++) {
-              if(routerParams[[target.constructor.name, propertyKey, i].toString()]){
-                args[i] = routerParams[[target.constructor.name, propertyKey, i].toString()](req, res, next);
-              }
-            }
-          }
-          const testResult = await routerBean[propertyKey].apply(routerBean, args);
-          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)];
-    }
-  }
-}
-
-function before(constructorFunction, methodName: string) {
-  const targetBean = getComponent(constructorFunction);
-  return function (target, propertyKey: string) {
-      const currentMethod = targetBean[methodName];
-      if(currentMethod.length > 0){
-        routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
-      }
-      Object.assign(targetBean, {
-          [methodName]: function (...args) {
-              target[propertyKey](...args);
-              return currentMethod.apply(targetBean, args);
-          }
-      })
-  };
-}
-
-function after(constructorFunction, methodName: string) {
-  const targetBean = getComponent(constructorFunction);
-  return function (target, propertyKey: string) {
-      const currentMethod = targetBean[methodName];
-      if(currentMethod.length > 0){
-        routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
-      }
-      Object.assign(targetBean, {
-          [methodName]: function (...args) {
-              const result = currentMethod.apply(targetBean, args);
-              const afterResult = target[propertyKey](result);
-              return afterResult ?? result;
-          }
-      })
-  };
-}
-
-function req(target: any, propertyKey: string, parameterIndex: number) {
-  const key = [target.constructor.name, propertyKey, parameterIndex].toString();
-  routerParams[key] = (req, res, next) => req;
-}
-
-function res(target: any, propertyKey: string, parameterIndex: number) {
-  const key = [target.constructor.name, propertyKey, parameterIndex].toString();
-  routerParams[key] = (req, res, next) => res;
-}
-
-function next(target: any, propertyKey: string, parameterIndex: number) {
-  const key = [target.constructor.name, propertyKey, parameterIndex].toString();
-  routerParams[key] = (req, res, next) => next;
-}
-
-function reqBody(target: any, propertyKey: string, parameterIndex: number) {
-  const key = [target.constructor.name, propertyKey, parameterIndex].toString();
-  routerParams[key] = (req, res, next) => req.body;
-}
-
-function reqParam(target: any, propertyKey: string, parameterIndex: number) {
-  const key = [target.constructor.name, propertyKey, parameterIndex].toString();
-  const paramName = getParamInFunction(target[propertyKey], parameterIndex);
-  routerParams[key] = (req, res, next) => req.params[paramName];
-}
-
-function getParamInFunction(fn: Function, index: number) {
-  const code = fn.toString().replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg, '').replace(/=>.*$/mg, '').replace(/=[^,]+/mg, '');
-  const result = code.slice(code.indexOf('(') + 1, code.indexOf(')')).match(/([^\s,]+)/g);
-  return result[index] || null;
-}
-
-function reqQuery(target: any, propertyKey: string, parameterIndex: number) {
-  const key = [target.constructor.name, propertyKey, parameterIndex].toString();
-  const paramName = getParamInFunction(target[propertyKey], parameterIndex);
-  routerParams[key] = (req, res, next) => req.query[paramName];
-}
-
-function reqForm(paramName: string) {
-  return (target: any, propertyKey: string, parameterIndex: number) => {
-    const key = [target.constructor.name, propertyKey, parameterIndex].toString();
-    routerParams[key] = (req, res, next) => req.body[paramName];
-  }
-}
-
-const getMapping = (value: string) => mapperFunction("get", value);
-const postMapping = (value: string) => mapperFunction("post", value);
-const requestMapping = (value: string) => mapperFunction("all", value);
-
-export { next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, before, after, getMapping, postMapping, requestMapping, setRouter, upload, jwt };

package/src/scaffold/command.ts

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-const program = new Command();
-import * as fs from "fs";
-
-program.command('new [appName]')
-    .description('Create a new app.')
-    .action((appName) => {
-        const currentDir = process.cwd();
-
-        fs.mkdirSync(currentDir + "/" + appName);
-        mkFile("nodemon.json", currentDir + "/" + appName, appName);
-        mkFile("package.json", currentDir + "/" + appName, appName);
-        mkFile("tsconfig.json", currentDir + "/" + appName, appName);
-
-        fs.mkdirSync(currentDir + "/" + appName + "/src");
-        mkFile("main.ts", currentDir + "/" + appName + "/src", appName);
-        mkFile("front-page.class.ts", currentDir + "/" + appName + "/src", appName);
-
-        console.log('');
-        console.log('  Create app success!');
-        console.log('');
-        console.log('  Please run `npm install` in the app directory.');
-        console.log('');
-    });
-
-program.on('--help', () => {
-    console.log('');
-    console.log('  Examples:');
-    console.log('');
-    console.log('    $ typespeed new blog');
-});
-
-program.parse(process.argv);
-
-function mkFile(fileName, targetPath, appName) {
-    const tplPath = __dirname + "/templates";
-    const fileContents = fs.readFileSync(tplPath + "/" + fileName + ".tpl", "utf-8");
-    fs.writeFileSync(targetPath + "/" + fileName, fileContents.replace("###appName###", appName));
-}

package/src/scaffold/templates/front-page.class.ts.tpl

@@ -1,12 +0,0 @@
-import { log, component, getMapping } from "typespeed";
-
-@component
-export default class FrontPage {
-
-    @getMapping("/")
-    public index(req, res) {
-        log("Front page running.");
-        res.send("Front page running.");
-    }
-
-}

package/src/scaffold/templates/main.ts.tpl

@@ -1,13 +0,0 @@
-import { app, log, autoware, ServerFactory } from "typespeed";
-
-@app
-class Main {
-
-    @autoware
-    public server: ServerFactory;
-
-    public main() {
-        this.server.start(8081);
-        log('start application');
-    }
-}

package/src/scaffold/templates/nodemon.json.tpl

@@ -1,7 +0,0 @@
-{
-    "watch": [
-        "src"
-    ],
-    "ext": "ts,json",
-    "exec": "npm run test"
-}

package/src/scaffold/templates/package.json.tpl

@@ -1,16 +0,0 @@
-{
-    "name": "###appName###",
-    "version": "1.0.0",
-    "scripts": {
-        "watch": "nodemon",
-        "test": "ts-node src/main.ts",
-        "start": "ts-node --transpile-only src/main.ts",
-        "build": "tsc -p ."
-    },
-    "dependencies": {
-        "typespeed": "latest"
-    },
-    "devDependencies": {
-        "@types/node": "^18.0.6"
-    }
-}

package/src/scaffold/templates/tsconfig.json.tpl

@@ -1,17 +0,0 @@
-{
-    "compilerOptions": {
-        "module": "CommonJS",
-        "declaration": true,
-        "emitDecoratorMetadata": true,
-        "experimentalDecorators": true,
-        "target": "ES6",
-        "outDir": "./dist",
-        "baseUrl": "./",
-        "typeRoots": [
-            "node_modules/@types"
-        ]
-    },
-    "include": [
-        "./src/**.ts"
-    ]
-}