typespeed 2.4.11 → 2.5.1

package/dist/route.decorator.js

@@ -4,6 +4,8 @@ exports.jwt = exports.upload = exports.setRouter = exports.requestMapping = expo
 const multiparty = require("multiparty");
 const express_jwt_1 = require("express-jwt");
 const core_decorator_1 = require("./core.decorator");
+const decorator_utils_1 = require("./decorator-utils");
+const bind_decorator_1 = require("./bind.decorator");
 const routerMapper = {
     "get": {},
     "post": {},
@@ -28,7 +30,53 @@ function setRouter(app) {
 }
 exports.setRouter = setRouter;
 function mapperFunction(method, value) {
-    return (target, propertyKey) => {
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [methodFn, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            ctx.addInitializer(function () {
+                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 = (0, core_decorator_1.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];
+        applyRouteBind(target.constructor.name, propertyKey, target[propertyKey]);
         routerMapper[method][value] = {
             "path": value,
             "name": [target.constructor.name, propertyKey].toString(),
@@ -65,7 +113,22 @@ function mapperFunction(method, value) {
         };
     };
 }
-function upload(target, propertyKey) {
+function upload(...args) {
+    if ((0, decorator_utils_1.isStd)(args)) {
+        const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+        ctx.addInitializer(function () {
+            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];
     const key = [target.constructor.name, propertyKey].toString();
     if (routerMiddleware[key]) {
         routerMiddleware[key].push(uploadMiddleware);
@@ -83,7 +146,22 @@ function uploadMiddleware(req, res, next) {
     });
 }
 function jwt(jwtConfig) {
-    return (target, propertyKey) => {
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            ctx.addInitializer(function () {
+                const key = [this.constructor.name, String(ctx.name)].toString();
+                if (routerMiddleware[key]) {
+                    routerMiddleware[key].push((0, express_jwt_1.expressjwt)(jwtConfig));
+                }
+                else {
+                    routerMiddleware[key] = [(0, express_jwt_1.expressjwt)(jwtConfig)];
+                }
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         const key = [target.constructor.name, propertyKey].toString();
         if (routerMiddleware[key]) {
             routerMiddleware[key].push((0, express_jwt_1.expressjwt)(jwtConfig));
@@ -96,15 +174,34 @@ function jwt(jwtConfig) {
 exports.jwt = jwt;
 function before(constructorFunction, methodName) {
     const targetBean = (0, core_decorator_1.getComponent)(constructorFunction);
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const hookKey = String(ctx.name);
+            ctx.addInitializer(function () {
+                const currentMethod = this[methodName];
+                if (currentMethod && currentMethod.length > 0) {
+                    routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
+                }
+                Object.assign(this, {
+                    [methodName]: function (...innerArgs) {
+                        this[hookKey](...innerArgs);
+                        return currentMethod.apply(this, innerArgs);
+                    }
+                });
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         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);
+            [methodName]: function (...innerArgs) {
+                target[propertyKey](...innerArgs);
+                return currentMethod.apply(targetBean, innerArgs);
             }
         });
     };
@@ -112,14 +209,34 @@ function before(constructorFunction, methodName) {
 exports.before = before;
 function after(constructorFunction, methodName) {
     const targetBean = (0, core_decorator_1.getComponent)(constructorFunction);
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const hookKey = String(ctx.name);
+            ctx.addInitializer(function () {
+                const currentMethod = this[methodName];
+                if (currentMethod && currentMethod.length > 0) {
+                    routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
+                }
+                Object.assign(this, {
+                    [methodName]: function (...innerArgs) {
+                        const result = currentMethod.apply(this, innerArgs);
+                        const afterResult = this[hookKey](result);
+                        return afterResult !== null && afterResult !== void 0 ? afterResult : result;
+                    }
+                });
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         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);
+            [methodName]: function (...innerArgs) {
+                const result = currentMethod.apply(targetBean, innerArgs);
                 const afterResult = target[propertyKey](result);
                 return afterResult !== null && afterResult !== void 0 ? afterResult : result;
             }
@@ -160,6 +277,54 @@ function getParamInFunction(fn, index) {
     const result = code.slice(code.indexOf('(') + 1, code.indexOf(')')).match(/([^\s,]+)/g);
     return result[index] || null;
 }
+/** 解析函数参数名列表（供 route @bind 做「参数名 → 索引」映射） */
+function getParamNames(fn) {
+    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, paramName) {
+    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, propertyKey, method) {
+    const bindMapping = (0, bind_decorator_1.getBindMapping)(className, propertyKey);
+    if (!bindMapping)
+        return;
+    const paramNames = getParamNames(method);
+    const nameToIndex = {};
+    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, propertyKey, parameterIndex) {
     const key = [target.constructor.name, propertyKey, parameterIndex].toString();
     const paramName = getParamInFunction(target[propertyKey], parameterIndex);

package/dist/typespeed.d.ts

@@ -5,68 +5,74 @@ import "reflect-metadata";
 
 /**设置路由中间件 */
 declare function setRouter(app: express.Application): void;
-/**上传文件装饰器，装饰页面具备解析上传文件的能力 */
-declare function upload(target: any, propertyKey: string): void;
+/**上传文件装饰器，装饰页面具备解析上传文件的能力（legacy 方法装饰器；2.5.x 起兼容标准 (value, context) 签名） */
+declare function upload(...args: any[]): any;
 /**
  * 页面支持 JWT 鉴权能力
  * @param jwtConfig jwt 配置
  */
-declare function jwt(jwtConfig: any): (target: any, propertyKey: string) => void;
+declare function jwt(jwtConfig: any): (...args: any[]) => any;
 /**
  * GET 请求装饰器
  * @param value 请求路径
  */
-declare const getMapping: (value: string) => (target: any, propertyKey: string) => void;
+declare const getMapping: (value: string) => (...args: any[]) => any;
 /**
  * POST 请求装饰器
  * @param value 请求路径
  */
-declare const postMapping: (value: string) => (target: any, propertyKey: string) => void;
+declare const postMapping: (value: string) => (...args: any[]) => any;
 /**
  * 请求装饰器，不区分请求类型
  * @param value 请求路径
  */
-declare const requestMapping: (value: string) => (target: any, propertyKey: string) => void;
+declare const requestMapping: (value: string) => (...args: any[]) => any;
 /**
  * INSERT 装饰器
  * 将方法作为 INSERT SQL 使用
  * @param sql INSERT SQL 语句
  */
-declare function insert(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function insert(sql: string): (...args: any[]) => any;
 /**
  * UPDATE 装饰器
  * 将方法作为 UPDATE SQL 使用
  * @param sql UPDATE SQL 语句
  */
-declare function update(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function update(sql: string): (...args: any[]) => any;
 /**
  * DELETE 装饰器
  * 将方法作为 DELETE SQL 使用
  * @param sql DELETE SQL 语句
  */
-declare function remove(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function remove(sql: string): (...args: any[]) => any;
 /**
  * SELECT 装饰器
  * 将方法作为 SELECT SQL 使用
  * @param sql SELECT SQL 语句
  */
-declare function select(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function select(sql: string): (...args: any[]) => any;
 /**
  * SELECT 结果类型装饰器，和 @select 配合使用
  * @param dataClass 结果类型
  */
-declare function resultType(dataClass: any): (target: any, propertyKey: string) => void;
+declare function resultType(dataClass: any): (...args: any[]) => any;
 /**
  * SQL 参数装饰器，标注 SQL 语句的绑定参数值，和 @select @insert @update @remove 配合使用
  * @param name 参数在 SQL 语句内的标记值
  */
 declare function param(name: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * 方法级参数绑定装饰器（标准装饰器删除了参数装饰器后的替代，legacy 模式也可用）。
+ * database 场景映射 SQL 占位符 → 参数索引（值为 number）；route 场景映射参数名 → 请求来源（值为 string）。
+ * @param mapping 绑定声明，如 { name: 0, id: 1 } 或 { id: "reqParam", body: "reqBody" }
+ */
+declare function bind(mapping: Record<string, string | number>): (...args: any[]) => any;
 /**
  * SELECT 缓存装饰器，自动缓存 SELECT 查询结果，和 @select 配合使用
  * 当执行 @insert @update @remove 时，会自动清除缓存。
  * @param ttl 缓存时间，单位秒
  */
-declare function cache(ttl: number): (target: any, propertyKey: string) => void;
+declare function cache(ttl: number): (...args: any[]) => any;
 /**模型数据操作类 */
 declare class Model {
     /**分页数据 */
@@ -139,23 +145,21 @@ declare class Model {
  * 
  * 被装饰的类将作为应用程序入口，框架将启动该类的 main 方法
  */
-declare function app<T extends {
-    new(...args: any[]): {};
-}>(constructor: T): void;
+declare function app(...args: any[]): any;
 /**获取配置文件中的配置项 */
 declare function config(node: string): any;
-/**组件装饰器，被装饰的类可以通过 @autoware 取得实例 */
-declare function component(constructorFunction: any): void;
+/**组件装饰器，被装饰的类可以通过 @autoware 取得实例（legacy 类装饰器；2.5.x 起兼容标准 (value, context) 签名） */
+declare function component(...args: any[]): any;
 /**获取组件实例函数，返回结果同 @autoware */
 declare function getComponent(constructorFunction: any): any;
-/**提供对象装饰器，框架将使用 @bean 装饰的方法来获取对象实例 */
-declare function bean(target: any, propertyKey: string): void;
+/**提供对象装饰器，框架将使用 @bean 装饰的方法来获取对象实例（legacy 方法装饰器；2.5.x 起兼容标准签名） */
+declare function bean(...args: any[]): any;
 /**获取对象实例函数，返回结果由 @bean 装饰的方法提供 */
 declare function getBean(mappingClass: Function): any;
 /**配置装饰器，装饰类成员变量值，获取配置文件中的配置项 */
 declare function value(configPath: string): any;
 /**自动装配装饰器，无参数版本，被装饰的类成员变量将自动注入实例 */
-declare function autoware(target: any, propertyKey: string): void;
+declare function autoware(...args: any[]): any;
 /**自动装配装饰器，带参数版本，可输入参数作为实例初始化参数，被装饰的类成员变量将自动注入实例 */
 declare function resource(...args: any[]): any;
 /**日志函数，输出打印日志 */
@@ -165,15 +169,15 @@ declare function logx(message: any): void;
 /**错误日志函数，输出打印错误日志 */
 declare function error(message?: any, ...optionalParams: any[]): void;
 /**路由页面前置执行装饰器，参数指向路由页面方法，被装饰的方法将在路由页面之前执行 */
-declare function before(constructorFunction: any, methodName: string): (target: any, propertyKey: string) => void;
+declare function before(constructorFunction: any, methodName: string): (...args: any[]) => any;
 /**路由页面后置执行装饰器，参数指向路由页面方法，被装饰的方法将在路由页面之后执行 */
-declare function after(constructorFunction: any, methodName: string): (target: any, propertyKey: string) => void;
+declare function after(constructorFunction: any, methodName: string): (...args: any[]) => any;
 /**定时程序装饰器，参数支持 crontab 格式字符串，可根据参数定时执行被装饰的方法 */
-declare function schedule(cronTime: string | Date): (target: any, propertyKey: string) => void;
+declare function schedule(cronTime: string | Date): (...args: any[]) => any;
 /**RabbitMQ 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
-declare function rabbitListener(queue: string): (target: any, propertyKey: string) => void;
-/**Redis 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
-declare function redisSubscriber(target: any, propertyKey: string): void;
+declare function rabbitListener(queue: string): (...args: any[]) => any;
+/**Redis 监听装饰器，参数是监听的频道名称，当接受到消息时将执行被装饰方法 */
+declare function redisSubscriber(channel: string): (...args: any[]) => any;
 /** request 对象装饰器，作为路由页面方法参数，获取 request 对象 */
 declare function req(target: any, propertyKey: string, parameterIndex: number): void;
 /** response 对象装饰器，作为路由页面方法参数，获取 response 对象 */
@@ -385,15 +389,15 @@ declare class SocketIo {
      * Socket IO 事件装饰器
      * @param event 事件名称
      */
-    public static onEvent(event: string): (target: any, propertyKey: string) => void;
+    public static onEvent(event: string): (...args: any[]) => any;
     /**Socket IO 错误捕获装饰器 */
-    public static onError(target: any, propertyKey: string): void;
+    public static onError(...args: any[]): any;
     /**Socket IO 客户端断开连接事件装饰器 */
-    public static onDisconnect(target: any, propertyKey: string): void;
+    public static onDisconnect(...args: any[]): any;
     /**Socket IO 客户端连接成功事件装饰器 */
-    public static onConnected(target: any, propertyKey: string): void;
+    public static onConnected(...args: any[]): any;
 }
 /**Socket IO 服务实现类 */
 declare const io: IoServer;
 
-export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, redisSubscriber, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, logx, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, resultType, cache, Model, SocketIo, io };
+export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, redisSubscriber, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, logx, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, bind, resultType, cache, Model, SocketIo, io };

package/dist/typespeed.js

@@ -19,6 +19,7 @@ require("reflect-metadata");
 const fs = require("fs");
 const path = require("path");
 const walkSync = require("walk-sync");
+const decorator_utils_1 = require("./decorator-utils");
 let globalConfig = {};
 const corePath = __dirname;
 const mainPath = path.dirname(getRootPath(new Error().stack.split("\n")) || process.argv[1]);
@@ -33,7 +34,18 @@ if (fs.existsSync(configFile)) {
 }
 globalConfig["MAIN_PATH"] = mainPath;
 globalConfig["CORE_PATH"] = corePath;
-function app(constructor) {
+function app(...args) {
+    if ((0, decorator_utils_1.isStd)(args)) {
+        const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+        ctx.addInitializer(function () {
+            startApp(this.constructor);
+        });
+        return;
+    }
+    startApp(args[0]);
+}
+exports.app = app;
+function startApp(constructor) {
     const coreFiles = walkSync(corePath, { globs: ['**/*.ts'], ignore: ['**/*.d.ts', 'scaffold/**'] });
     const mainFiles = walkSync(mainPath, { globs: ['**/*.ts'] });
     (async function () {
@@ -56,13 +68,28 @@ function app(constructor) {
         main["main"]();
     }());
 }
-exports.app = app;
 function config(node) {
     return globalConfig[node] || null;
 }
 exports.config = config;
 function value(configPath) {
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            // 标准 field 装饰器：返回 initializer 注入配置值（标准模式下无 design:type）。
+            return (initialValue) => {
+                if (globalConfig === undefined) {
+                    return initialValue;
+                }
+                let pathNodes = configPath.split(".");
+                let nodeValue = globalConfig;
+                for (let i = 0; i < pathNodes.length; i++) {
+                    nodeValue = nodeValue[pathNodes[i]];
+                }
+                return nodeValue === undefined ? initialValue : nodeValue;
+            };
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         if (globalConfig === undefined) {
             Object.defineProperty(target, propertyKey, {
                 get: () => {
@@ -108,6 +135,7 @@ function getRootPath(lines) {
 __exportStar(require("./core.decorator"), exports);
 __exportStar(require("./route.decorator"), exports);
 __exportStar(require("./database.decorator"), exports);
+__exportStar(require("./bind.decorator"), exports);
 var log_factory_class_1 = require("./factory/log-factory.class");
 Object.defineProperty(exports, "LogFactory", { enumerable: true, get: function () { return log_factory_class_1.default; } });
 var cache_factory_class_1 = require("./factory/cache-factory.class");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespeed",
-  "version": "2.4.11",
+  "version": "2.5.1",
   "description": "A new Framework for TypeScript.",
   "author": "speedphp",
   "license": "MIT License",
@@ -13,8 +13,12 @@
     "prebuild": "rm -rf dist"
   },
   "main": "dist/typespeed.js",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "bin": {
-    "typespeed": "./dist/scaffold/command.js"
+    "typespeed": "dist/scaffold/command.js"
   },
   "homepage": "https://github.com/speedphp/typespeed#readme",
   "repository": {

package/.github/workflows/test.yml

@@ -1,50 +0,0 @@
-name: Tests
-'on': 
-  push:
-    branches:
-      - main
-
-jobs:
-  test:
-    name: 'Test TypeSpeed'
-    runs-on: ubuntu-latest
-    services:
-      redis:
-        image: redis
-        ports:
-          - 6379:6379
-      rabbitmq:
-        image: rabbitmq:3.8
-        env:
-          RABBITMQ_DEFAULT_USER: guest
-          RABBITMQ_DEFAULT_PASS: guest
-        ports:
-          - 5672
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-      - name: Setup MySQL
-        run: |
-          sudo /etc/init.d/mysql start
-          mysql -e 'CREATE DATABASE test;USE test; \
-          CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(100) DEFAULT NULL,PRIMARY KEY (`id`)) \
-          ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;SHOW TABLES;' -uroot -proot
-      - name: 'Cache node_modules'
-        uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-v22-${{ hashFiles('**/package.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-v22-
-      - name: Install Dependencies
-        run: npm install
-      - name: Run Tests with Coverage
-        run: npm run test-with-coverage
-        env:
-          LOCAL_HOST: localhost
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

package/app/nodemon.json

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

package/app/package.json

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

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

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

package/app/src/config-development.json

@@ -1,26 +0,0 @@
-{
-    "view": {
-        "engine": "mustache",
-        "path": "/views/",
-        "suffix": "html"
-    },
-    "mysql": {
-        "host": "127.0.0.1",
-        "user": "root",
-        "password": "root",
-        "database": "test"
-    },
-    "redis": {
-        "host": "127.0.0.1",
-        "port": "6379",
-        "db": 0
-    },
-    "rabbitmq": {
-        "protocol": "amqp",
-        "hostname": "127.0.0.1",
-        "port": 5672,
-        "username": "guest",
-        "password": "guest"
-    },
-    "socket":{}
-}

package/app/src/config-production.json

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