typespeed 2.5.0 → 2.5.2

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,334 +0,0 @@
-import * as express from "express";
-import * as multiparty from "multiparty";
-import { expressjwt } from "express-jwt";
-import { getComponent } from "./core.decorator";
-import { isStd, getStdArgs } from "./decorator-utils";
-import { getBindMapping } from "./bind.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 (...args: any[]): any => {
-    if (isStd(args)) {
-      const [methodFn, ctx] = getStdArgs(args);
-      ctx.addInitializer(function (this: any) {
-        const className = this.constructor.name;
-        const propertyKey = String(ctx.name);
-        applyRouteBind(className, propertyKey, methodFn);
-        routerMapper[method][value] = {
-          "path": value,
-          "name": [className, propertyKey].toString(),
-          "target": this.constructor,
-          "propertyKey": propertyKey,
-          "invoker": async (req, res, next) => {
-            const routerBean = getComponent(this.constructor);
-            try {
-              let paramTotal = routerBean[propertyKey].length;
-              if (routerParamsTotal[[className, propertyKey].toString()]) {
-                paramTotal = Math.max(paramTotal, routerParamsTotal[[className, propertyKey].toString()]);
-              }
-              const callArgs = [req, res, next];
-              if (paramTotal > 0) {
-                for (let i = 0; i < paramTotal; i++) {
-                  if (routerParams[[className, propertyKey, i].toString()]) {
-                    callArgs[i] = routerParams[[className, propertyKey, i].toString()](req, res, next);
-                  }
-                }
-              }
-              const testResult = await routerBean[propertyKey].apply(routerBean, callArgs);
-              if (typeof testResult === "object") {
-                res.json(testResult);
-              } else if (typeof testResult !== "undefined") {
-                res.send(testResult);
-              }
-              return testResult;
-            } catch (err) {
-              next(err);
-            }
-          }
-        };
-      });
-      return;
-    }
-    const target = args[0];
-    const propertyKey = args[1] as string;
-    applyRouteBind(target.constructor.name, propertyKey, target[propertyKey]);
-    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(...args: any[]): any {
-  if (isStd(args)) {
-    const [, ctx] = getStdArgs(args);
-    ctx.addInitializer(function (this: any) {
-      const key = [this.constructor.name, String(ctx.name)].toString();
-      if (routerMiddleware[key]) {
-        routerMiddleware[key].push(uploadMiddleware);
-      } else {
-        routerMiddleware[key] = [uploadMiddleware];
-      }
-    });
-    return;
-  }
-  const target = args[0];
-  const propertyKey = args[1] as 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 (...args: any[]): any => {
-    if (isStd(args)) {
-      const [, ctx] = getStdArgs(args);
-      ctx.addInitializer(function (this: any) {
-        const key = [this.constructor.name, String(ctx.name)].toString();
-        if (routerMiddleware[key]) {
-          routerMiddleware[key].push(expressjwt(jwtConfig));
-        } else {
-          routerMiddleware[key] = [expressjwt(jwtConfig)];
-        }
-      });
-      return;
-    }
-    const target = args[0];
-    const propertyKey = args[1] as 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 (...args: any[]) {
-      if (isStd(args)) {
-        const [, ctx] = getStdArgs(args);
-        const hookKey = String(ctx.name);
-        ctx.addInitializer(function (this: any) {
-          const currentMethod = this[methodName];
-          if (currentMethod && currentMethod.length > 0) {
-            routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
-          }
-          Object.assign(this, {
-              [methodName]: function (...innerArgs: any[]) {
-                  this[hookKey](...innerArgs);
-                  return currentMethod.apply(this, innerArgs);
-              }
-          })
-        });
-        return;
-      }
-      const target = args[0];
-      const propertyKey = args[1] as string;
-      const currentMethod = targetBean[methodName];
-      if(currentMethod.length > 0){
-        routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
-      }
-      Object.assign(targetBean, {
-          [methodName]: function (...innerArgs) {
-              target[propertyKey](...innerArgs);
-              return currentMethod.apply(targetBean, innerArgs);
-          }
-      })
-  };
-}
-
-function after(constructorFunction, methodName: string) {
-  const targetBean = getComponent(constructorFunction);
-  return function (...args: any[]) {
-      if (isStd(args)) {
-        const [, ctx] = getStdArgs(args);
-        const hookKey = String(ctx.name);
-        ctx.addInitializer(function (this: any) {
-          const currentMethod = this[methodName];
-          if (currentMethod && currentMethod.length > 0) {
-            routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
-          }
-          Object.assign(this, {
-              [methodName]: function (...innerArgs: any[]) {
-                  const result = currentMethod.apply(this, innerArgs);
-                  const afterResult = this[hookKey](result);
-                  return afterResult ?? result;
-              }
-          })
-        });
-        return;
-      }
-      const target = args[0];
-      const propertyKey = args[1] as string;
-      const currentMethod = targetBean[methodName];
-      if(currentMethod.length > 0){
-        routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
-      }
-      Object.assign(targetBean, {
-          [methodName]: function (...innerArgs) {
-              const result = currentMethod.apply(targetBean, innerArgs);
-              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;
-}
-
-/** 解析函数参数名列表（供 route @bind 做「参数名 → 索引」映射） */
-function getParamNames(fn: Function): string[] {
-  const code = fn.toString().replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg, '').replace(/=>.*$/mg, '').replace(/=[^,)]+/g, '');
-  const paramsStr = code.slice(code.indexOf('(') + 1, code.indexOf(')'));
-  if (!paramsStr.trim()) return [];
-  return paramsStr.split(',').map(p => {
-    const matched = p.trim().match(/([A-Za-z_$][\w$]*)/);
-    return matched ? matched[1] : p.trim();
-  }).filter(Boolean);
-}
-
-/** 把 route @bind 的「来源字符串」转成参数解析器 */
-function getRouteSourceResolver(source: string, paramName: string) {
-  switch (source) {
-    case "req": return (req, res, next) => req;
-    case "res": return (req, res, next) => res;
-    case "next": return (req, res, next) => next;
-    case "reqBody": return (req, res, next) => req.body;
-    case "reqParam": return (req, res, next) => req.params[paramName];
-    case "reqQuery": return (req, res, next) => req.query[paramName];
-    case "reqForm": return (req, res, next) => req.body[paramName];
-    default: return null;
-  }
-}
-
-/** 读取 @bind 声明，把「参数名 → 来源」转成 routerParams 的「索引 → 解析器」 */
-function applyRouteBind(className: string, propertyKey: string, method: Function) {
-  const bindMapping = getBindMapping(className, propertyKey);
-  if (!bindMapping) return;
-  const paramNames = getParamNames(method);
-  const nameToIndex: Record<string, number> = {};
-  paramNames.forEach((paramName, index) => {
-    if (paramName && nameToIndex[paramName] === undefined) nameToIndex[paramName] = index;
-  });
-  for (const bindName in bindMapping) {
-    const source = bindMapping[bindName];
-    if (typeof source !== "string") continue;   // 跳过 database 的数值映射
-    const index = nameToIndex[bindName];
-    if (index === undefined) continue;
-    const resolver = getRouteSourceResolver(source, bindName);
-    if (resolver) {
-      routerParams[[className, propertyKey, index].toString()] = resolver;
-    }
-  }
-}
-
-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 };