typespeed 2.4.11 → 2.5.0

package/src/typespeed.ts

@@ -2,6 +2,7 @@ import "reflect-metadata";
 import * as fs from "fs";
 import * as path from "path";
 import * as walkSync from "walk-sync";
+import { isStd, getStdArgs } from "./decorator-utils";
 
 let globalConfig = {};
 const corePath = __dirname;
@@ -18,7 +19,18 @@ if (fs.existsSync(configFile)) {
 globalConfig["MAIN_PATH"] = mainPath;
 globalConfig["CORE_PATH"] = corePath;
 
-function app<T extends { new(...args: any[]): {} }>(constructor: T) {
+function app(...args: any[]): any {
+    if (isStd(args)) {
+        const [, ctx] = getStdArgs(args);
+        ctx.addInitializer(function (this: any) {
+            startApp(this.constructor);
+        });
+        return;
+    }
+    startApp(args[0]);
+}
+
+function startApp(constructor: any) {
     const coreFiles = walkSync(corePath, { globs: ['**/*.ts'], ignore: ['**/*.d.ts', 'scaffold/**'] });
     const mainFiles = walkSync(mainPath, { globs: ['**/*.ts'] });
 
@@ -47,7 +59,23 @@ function config(node: string) {
 }
 
 function value(configPath: string): any {
-    return function (target: any, propertyKey: string) {
+    return function (...args: any[]): any {
+        if (isStd(args)) {
+            // 标准 field 装饰器：返回 initializer 注入配置值（标准模式下无 design:type）。
+            return (initialValue: any) => {
+                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] as string;
         if (globalConfig === undefined) {
             Object.defineProperty(target, propertyKey, {
                 get: () => {
@@ -94,6 +122,7 @@ export { app, value, config };
 export * from "./core.decorator";
 export * from "./route.decorator";
 export * from "./database.decorator";
+export * from "./bind.decorator";
 
 export { default as LogFactory} from "./factory/log-factory.class";
 export { default as CacheFactory} from "./factory/cache-factory.class";

package/test/bind.test.ts

@@ -0,0 +1,28 @@
+const chaiObj = require('chai');
+chaiObj.use(require("chai-http"));
+const expect = chaiObj.expect;
+
+describe("Test @bind and token", () => {
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
+    it("/bind/param (route @bind)", (done) => {
+        chaiObj.request(testAddr).get("/bind/param/100?name=testname").end((err, res) => {
+            expect(JSON.parse(res.text)).to.deep.equal({ id: "100", name: "testname" });
+            done();
+        });
+    });
+    it("/bind/token (@bean(Token) + @autoware(Token) + @resource(Token, args))", (done) => {
+        chaiObj.request(testAddr).get("/bind/token").end((err, res) => {
+            expect(res.text).to.equal("test-bean|model-ok");
+            done();
+        });
+    });
+    it("/bind/db (database @bind scalar)", (done) => {
+        const id = Math.floor(Math.random() * 900000) + 100000;
+        chaiObj.request(testAddr).get(`/bind/db?id=${id}`).end((err, res) => {
+            expect(res.text).to.match(/^bind insert: \d+/);
+            done();
+        });
+    });
+});
+
+export {};

package/test/decorator-utils.test.ts

@@ -0,0 +1,42 @@
+import { expect } from "chai";
+import { isStd, getStdArgs } from "../src/decorator-utils";
+
+describe("decorator-utils · isStd 双签名判据", () => {
+    it("legacy 类装饰器（1 参）→ false", () => {
+        expect(isStd([class Foo {}])).to.equal(false);
+    });
+
+    it("legacy 方法/属性装饰器（2 参，第 2 参是 string key）→ false", () => {
+        expect(isStd([{}, "methodName"])).to.equal(false);
+    });
+
+    it("legacy 带 descriptor 方法 / 参数装饰器（3 参）→ false", () => {
+        expect(isStd([{}, "methodName", {}])).to.equal(false);
+        expect(isStd([{}, "methodName", 0])).to.equal(false);
+    });
+
+    it("标准类/方法/field 装饰器（2 参，第 2 参带 string kind）→ true", () => {
+        expect(isStd([function () {}, { kind: "class" }])).to.equal(true);
+        expect(isStd([function () {}, { kind: "method" }])).to.equal(true);
+        expect(isStd([undefined, { kind: "field" }])).to.equal(true);
+        expect(isStd([{}, { kind: "accessor" }])).to.equal(true);
+    });
+
+    it("第 2 参是对象但无 kind → false", () => {
+        expect(isStd([{}, {}])).to.equal(false);
+    });
+
+    it("第 2 参是 null / 非对象 → false", () => {
+        expect(isStd([{}, null])).to.equal(false);
+        expect(isStd([{}, 42])).to.equal(false);
+    });
+
+    it("getStdArgs 解出 (value, context)", () => {
+        const ctx = { kind: "method", name: "foo" };
+        const [value, context] = getStdArgs([function bar() {}, ctx]);
+        expect(typeof value).to.equal("function");
+        expect(context).to.equal(ctx);
+    });
+});
+
+export {};