@fastcar/core 0.2.38

package/src/annotation/Application.ts

@@ -0,0 +1,46 @@
+import FastCarApplication from "../FastCarApplication";
+import ClassUtils from "../utils/ClassUtils";
+import TypeUtil from "../utils/TypeUtil";
+
+//基础服务的应用
+export default function Application(target: any) {
+	return new Proxy(target, {
+		construct: (target: any, args: any) => {
+			let app = new FastCarApplication();
+			let appProxy = new target(...args);
+			Reflect.set(appProxy, "app", app);
+
+			let keys = ClassUtils.getProtoType(target);
+			for (let key of keys) {
+				if (key != "constructor") {
+					let desc = ClassUtils.getProtoDesc(target, key);
+					if (desc) {
+						let beforeFun = Object.getOwnPropertyDescriptor(FastCarApplication.prototype, key)?.value;
+						let afterFun = desc.value;
+
+						if (Reflect.has(app, key) && TypeUtil.isFunction(afterFun) && TypeUtil.isFunction(beforeFun)) {
+							let mixFn = async (...args: any[]) => {
+								let res: any;
+								if (TypeUtil.isPromise(beforeFun)) {
+									res = await Promise.resolve(Reflect.apply(beforeFun, app, args));
+								} else {
+									res = Reflect.apply(beforeFun, app, args);
+								}
+
+								TypeUtil.isPromise(afterFun) ? await Promise.resolve(Reflect.apply(afterFun, appProxy, args)) : Reflect.apply(afterFun, appProxy, args);
+								return res;
+							};
+
+							Reflect.defineProperty(app, key, Object.assign(desc, { value: mixFn }));
+						} else {
+							Reflect.defineProperty(app, key, desc);
+						}
+					}
+				}
+			}
+
+			app.init();
+			return appProxy;
+		},
+	});
+}

package/src/annotation/ExceptionMonitor.ts

@@ -0,0 +1,15 @@
+import * as process from "process";
+
+//异常监听器
+export default function ExceptionMonitor(target: any) {
+	process.on("uncaughtException", (err: any, origin: any) => {
+		console.error(`Caught exception: ${err.message}`);
+		console.error(`Exception origin: ${origin}`);
+		console.error(`stack: ${err.stack}`);
+	});
+
+	process.on("unhandledRejection", (reason, promise) => {
+		console.error("Unhandled Rejection at:", promise);
+		console.error("reason:", reason);
+	});
+}

package/src/annotation/bind/AddRequireModule.ts

@@ -0,0 +1,18 @@
+import "reflect-metadata";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+
+/***
+ * @version 1.0 依赖模块注入
+ *
+ */
+export default function AddRequireModule(target: any, m: string, alias: string) {
+	let relyname = FastCarMetaData.IocModule;
+	if (Reflect.hasMetadata(relyname, target)) {
+		let iocMap: Map<string, string> = Reflect.getMetadata(relyname, target);
+		iocMap.set(m, alias);
+	} else {
+		let modules: Map<string, string> = new Map();
+		modules.set(m, alias);
+		Reflect.defineMetadata(relyname, modules, target);
+	}
+}

package/src/annotation/bind/AliasInjection.ts

@@ -0,0 +1,24 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+import FastCarApplication from "../../FastCarApplication";
+
+/***
+ * @version 1.0 根据别名注入依赖
+ *
+ */
+export default function AliasInjection(alias: string) {
+	return function (target: any, propertyKey: string) {
+		Reflect.defineProperty(target, propertyKey, {
+			get: () => {
+				let app: FastCarApplication = Reflect.get(global, CommonConstant.FastcarApp);
+
+				if (!app.hasComponentByName(alias)) {
+					//找不到依赖组件异常
+					let injectionError = new Error(`Unsatisfied dependency expressed through [${propertyKey}] `);
+					throw injectionError;
+				}
+
+				return app.getComponentByName(alias);
+			},
+		});
+	};
+}

package/src/annotation/bind/Autowired.ts

@@ -0,0 +1,11 @@
+import CallDependency from "./CallDependency";
+
+/***
+ * @version 1.0 说明哪些模块需要被加载
+ * @version 1.1 更改为和call类型一致
+ *
+ */
+export default function Autowired(target: any, propertyKey: string) {
+	// //反向找设计类型
+	CallDependency(target, propertyKey);
+}

package/src/annotation/bind/CallDependency.ts

@@ -0,0 +1,24 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+import FastCarApplication from "../../FastCarApplication";
+import ReflectUtil from "../../utils/ReflectUtil";
+
+/***
+ * @version 1.0 在使用该函数时进行调用 声明的类可以不是组件
+ *
+ */
+export default function CallDependency(target: any, propertyKey: string) {
+	Reflect.defineProperty(target, propertyKey, {
+		get: () => {
+			let key = ReflectUtil.getNameByPropertyKey(target, propertyKey);
+			let app: FastCarApplication = Reflect.get(global, CommonConstant.FastcarApp);
+
+			if (!app.hasComponentByName(key)) {
+				//找不到依赖组件异常
+				let injectionError = new Error(`Unsatisfied dependency expressed through [${propertyKey}] `);
+				throw injectionError;
+			}
+
+			return app.getComponentByName(key);
+		},
+	});
+}

package/src/annotation/data/DBType.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+import { DesignMeta } from "../../type/DesignMeta";
+
+//字段名称 如果没有则为统一
+export default function DBType(name: string) {
+	return function(target: any, propertyKey: string) {
+		Reflect.defineMetadata(DesignMeta.dbType, name, target, propertyKey);
+	};
+}

package/src/annotation/data/DS.ts

@@ -0,0 +1,58 @@
+import "reflect-metadata";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+import ClassUtils from "../../utils/ClassUtils";
+import TypeUtil from "../../utils/TypeUtil";
+import ValidationUtil from "../../utils/ValidationUtil";
+
+//动态数据源获取 根据就近原则 传入参数-函数-类名
+export default function DS(name: string) {
+	return function(target: any, methodName?: string, descriptor?: PropertyDescriptor) {
+		if (methodName && descriptor) {
+			const orignFunction = descriptor.value;
+
+			//定义数据源
+			Reflect.defineMetadata(FastCarMetaData.DS, name, target, methodName);
+
+			//取出ds标记的位置 在编译前规避这个问题
+			const dsIndex = Reflect.getMetadata(FastCarMetaData.DSIndex, target, methodName);
+			if (!ValidationUtil.isNumber(dsIndex)) {
+				throw new Error(`${methodName} function dynamic data source not found`);
+			}
+
+			descriptor.value = function(...args: any[]) {
+				let dsName = args[dsIndex];
+				if (!dsName) {
+					args[dsIndex] = name;
+				}
+
+				return Promise.resolve(Reflect.apply(orignFunction, this, args));
+			};
+		} else {
+			Reflect.defineMetadata(FastCarMetaData.DS, name, target.prototype);
+
+			//找所有的方法 将符合要求的进行注入定义
+			let targetProto = target.prototype;
+			let keys = ClassUtils.getProtoType(target);
+
+			for (let key of keys) {
+				let dsIndex = Reflect.getMetadata(FastCarMetaData.DSIndex, targetProto, key);
+				if (ValidationUtil.isNumber(dsIndex)) {
+					let originValue = Reflect.get(targetProto, key);
+					if (TypeUtil.isFunction(originValue)) {
+						Reflect.defineProperty(targetProto, key, {
+							value: function(...args: any[]) {
+								let dsName = args[dsIndex];
+								if (!dsName) {
+									let fnDSName = Reflect.getMetadata(FastCarMetaData.DS, targetProto, key);
+									args[dsIndex] = fnDSName || name;
+								}
+
+								return Promise.resolve(Reflect.apply(originValue, this, args));
+							},
+						});
+					}
+				}
+			}
+		}
+	};
+}

package/src/annotation/data/DSIndex.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+
+//用于标记数据源位置
+export default function DSIndex(target: any, name: string, index: number) {
+	Reflect.defineMetadata(FastCarMetaData.DSIndex, index, target, name);
+}

package/src/annotation/data/Entity.ts

@@ -0,0 +1,8 @@
+import { DesignMeta } from "../../type/DesignMeta";
+
+//这是一个模板类 代表具体的映射关系
+export default function Entity(className: Function) {
+	return function(target: any) {
+		Reflect.defineMetadata(DesignMeta.entity, className, target.prototype);
+	};
+}

package/src/annotation/data/Field.ts

@@ -0,0 +1,15 @@
+import "reflect-metadata";
+import { DesignMeta } from "../../type/DesignMeta";
+
+//数据库列名称
+export default function Field(name: string) {
+	return function(target: any, propertyKey: string) {
+		let fieldMap: Set<string> = Reflect.getMetadata(DesignMeta.fieldMap, target);
+		if (!fieldMap) {
+			Reflect.defineMetadata(DesignMeta.fieldMap, new Set([propertyKey]), target);
+		} else {
+			fieldMap.add(propertyKey);
+		}
+		Reflect.defineMetadata(DesignMeta.field, name, target, propertyKey);
+	};
+}

package/src/annotation/data/PrimaryKey.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { DesignMeta } from "../../type/DesignMeta";
+
+//是否为主键
+export default function PrimaryKey(target: any, propertyKey: string) {
+	Reflect.defineMetadata(DesignMeta.primaryKey, true, target, propertyKey);
+}

package/src/annotation/data/SqlSession.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { DesignMeta } from "../../type/DesignMeta";
+
+//事务管理会话
+export default function SqlSession(target: any, name: string, index: number) {
+	Reflect.defineMetadata(DesignMeta.sqlSession, index, target, name);
+}

package/src/annotation/data/Table.ts

@@ -0,0 +1,37 @@
+import "reflect-metadata";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+import { DesignMeta } from "../../type/DesignMeta";
+import { MapperType } from "../../type/MapperType";
+
+//表名称 不缺省
+export default function Table(name: string) {
+	return function(target: any) {
+		const proto = target.prototype;
+		let fields: Set<string> = Reflect.getOwnMetadata(DesignMeta.fieldMap, proto);
+		let mappingMap = new Map<string, MapperType>();
+		let dbFields = new Map<string, string>();
+
+		fields.forEach(c => {
+			let tsType = Reflect.getOwnMetadata(FastCarMetaData.designType, proto, c);
+			let field = Reflect.getOwnMetadata(DesignMeta.field, proto, c) || c;
+			let dbType = Reflect.getOwnMetadata(DesignMeta.dbType, proto, c) || "varchar";
+			let primaryKey = !!Reflect.getOwnMetadata(DesignMeta.primaryKey, proto, c);
+
+			let tsName: string = tsType.name;
+
+			const m: MapperType = {
+				name: c, //变量名称
+				type: tsName.toLowerCase(), //ts类型
+				field, //数据库列名
+				dbType: dbType, //数据类型
+				primaryKey, //是否为主键 默认为false
+			};
+			dbFields.set(field, c);
+			mappingMap.set(c, m);
+		});
+
+		Reflect.defineMetadata(DesignMeta.dbFields, dbFields, target); //作用的列名
+		Reflect.defineMetadata(DesignMeta.mapping, mappingMap, target); //映射关系
+		Reflect.defineMetadata(DesignMeta.table, name, target); //注入表名
+	};
+}

package/src/annotation/data/Transactional.ts

@@ -0,0 +1,60 @@
+import "reflect-metadata";
+import { CommonConstant } from "../../constant/CommonConstant";
+import FastCarApplication from "../../FastCarApplication";
+import DataSourceManager from "../../interface/DataSourceManager";
+import Logger from "../../interface/Logger";
+import { DesignMeta } from "../../type/DesignMeta";
+import SqlError from "../../type/SqlError";
+
+/**
+ * @version 1.0 事务管理 不建议多个事务的嵌套(避免长事务) 尽量做到一个方法一个事务
+ * */
+export default function Transactional(driver: string = "MysqlDataSourceManager") {
+	return function (target: any, methodName: string, descriptor: PropertyDescriptor) {
+		const orignFunction = descriptor.value;
+
+		//在初始化时就应该检测是否注入了sessionID
+		const paramsIndex = Reflect.getOwnMetadata(DesignMeta.sqlSession, target, methodName);
+		if (typeof paramsIndex != "number") {
+			throw new SqlError(`${methodName} needs to inject the SqlSession`);
+		}
+
+		descriptor.value = async function (...args: any[]) {
+			//创建会话id
+
+			let app: FastCarApplication = Reflect.get(global, CommonConstant.FastcarApp);
+
+			let sysLogger: Logger = app.getSysLogger() || console;
+			let dsm: DataSourceManager = app.getComponentByName(driver);
+
+			if (!dsm) {
+				sysLogger.error(`DataSourceManager ${driver} not found`);
+				return Promise.reject(new SqlError(`DataSourceManager ${driver} not found`));
+			}
+
+			let sessionId = args[paramsIndex];
+			if (sessionId) {
+				return Promise.resolve(Reflect.apply(orignFunction, this, args));
+			}
+			let errFlag = false;
+			sessionId = dsm.createSession();
+			args[paramsIndex] = sessionId;
+			let res: any = null;
+
+			return new Promise((resolve, reject) => {
+				Reflect.apply(orignFunction, this, args)
+					.then((result: any) => {
+						res = result;
+					})
+					.catch((e: Error) => {
+						sysLogger.error(e);
+						errFlag = true;
+					})
+					.finally(async () => {
+						await dsm.destorySession(sessionId, errFlag);
+						return !errFlag ? resolve(res) : reject(new SqlError(`${methodName} exec fail `));
+					});
+			});
+		};
+	};
+}

package/src/annotation/env/ApplicationSetting.ts

@@ -0,0 +1,24 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+import FastCarApplication from "../../FastCarApplication";
+//应用程序设置 具有最高权限
+export default function ApplicationSetting(setting: { [key: string]: any }) {
+	return function (target: any) {
+		let fastcarSetting: Map<string, any> = Reflect.getMetadata(CommonConstant.FastcarSetting, FastCarApplication.prototype);
+		if (!fastcarSetting) {
+			fastcarSetting = new Map<string, any>();
+		}
+		Object.keys(setting).forEach((key) => {
+			let afterConfig = setting[key];
+			let beforeConfig = fastcarSetting.get(key);
+			if (beforeConfig) {
+				if (typeof beforeConfig == "object") {
+					afterConfig = Object.assign(beforeConfig, afterConfig);
+				}
+			}
+
+			fastcarSetting.set(key, afterConfig);
+		});
+
+		Reflect.defineMetadata(CommonConstant.FastcarSetting, fastcarSetting, FastCarApplication.prototype);
+	};
+}

package/src/annotation/env/BaseFilePath.ts

@@ -0,0 +1,12 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+import * as fs from "fs";
+
+//设置运行是的主路径
+export default function BaseFilePath(name: string) {
+	return function(target: any) {
+		let stats = fs.statSync(name);
+		if (stats.isFile()) {
+			Reflect.set(target.prototype, CommonConstant.BaseFileName, name);
+		}
+	};
+}

package/src/annotation/env/BasePath.ts

@@ -0,0 +1,12 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+import * as fs from "fs";
+
+//设置运行是的主路径
+export default function BasePath(name: string) {
+	return function(target: any) {
+		let stats = fs.statSync(name);
+		if (stats.isDirectory()) {
+			Reflect.set(target.prototype, CommonConstant.BasePath, name);
+		}
+	};
+}

package/src/annotation/env/ENV.ts

@@ -0,0 +1,8 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+
+//设置初始化的env 注入在原始的application上面
+export default function ENV(name: string) {
+	return function(target: any) {
+		Reflect.set(target.prototype, CommonConstant.ENV, name);
+	};
+}

package/src/annotation/env/ResourcePath.ts

@@ -0,0 +1,7 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+
+export default function ResourcePath(name: string) {
+	return function (target: any) {
+		Reflect.set(target.prototype, CommonConstant.ResourcePath, name);
+	};
+}

package/src/annotation/lifeCycle/AddLifeCycleItem.ts

@@ -0,0 +1,25 @@
+import { LifeCycleModule } from "../../constant/LifeCycleModule";
+import { BootPriority } from "../../constant/BootPriority";
+
+export type LifeCycleType = {
+	order: BootPriority;
+	exec: string;
+};
+
+export function AddLifeCycleItem(target: any, lifeCycle: LifeCycleModule, item: LifeCycleType) {
+	let list: LifeCycleType[] = Reflect.getMetadata(lifeCycle, target);
+	if (!list) {
+		list = [];
+	}
+
+	let exist = list.some((fitem) => {
+		return item.exec == fitem.exec;
+	});
+
+	if (exist) {
+		return;
+	}
+
+	list.push(item);
+	Reflect.defineMetadata(lifeCycle, list, target);
+}

package/src/annotation/lifeCycle/ApplicationDestory.ts

@@ -0,0 +1,13 @@
+import { BootPriority } from "../../constant/BootPriority";
+import { LifeCycleModule } from "../../constant/LifeCycleModule";
+import { AddLifeCycleItem } from "./AddLifeCycleItem";
+
+//启动时机
+export default function ApplicationDestory(order: number = BootPriority.Sys) {
+	return function (target: any, method: string, value: any) {
+		AddLifeCycleItem(target, LifeCycleModule.ApplicationStop, {
+			order,
+			exec: method,
+		});
+	};
+}

package/src/annotation/lifeCycle/ApplicationInit.ts

@@ -0,0 +1,13 @@
+import { BootPriority } from "../../constant/BootPriority";
+import { LifeCycleModule } from "../../constant/LifeCycleModule";
+import { AddLifeCycleItem } from "./AddLifeCycleItem";
+
+//启动时机
+export default function ApplicationInit(order: number = BootPriority.Sys) {
+	return function (target: any, method: string, value: any) {
+		AddLifeCycleItem(target, LifeCycleModule.ApplicationStart, {
+			order,
+			exec: method,
+		});
+	};
+}

package/src/annotation/lifeCycle/ApplicationRunner.ts

@@ -0,0 +1,5 @@
+import Component from "../stereotype/Component";
+
+export default function ApplicationRunner(target: any) {
+	Component(target);
+}

package/src/annotation/lifeCycle/ApplicationStart.ts

@@ -0,0 +1,23 @@
+import { BootPriority } from "../../constant/BootPriority";
+import { LifeCycleModule } from "../../constant/LifeCycleModule";
+import { AddLifeCycleItem } from "./AddLifeCycleItem";
+import ApplicationRunner from "./ApplicationRunner";
+
+/****
+ * @version 1.0 在应用启动后自动执行
+ * @params order 排序 序号越小排在越前面 系统级的组件 如数据库等一般为0
+ * @params exec 执行方法
+ */
+export default function ApplicationStart(order: number = BootPriority.Sys, exec: string = "run") {
+	return function (target: any) {
+		if (!Reflect.has(target.prototype, exec)) {
+			throw new Error(`${target.name} has no implementation ${exec} method`);
+		}
+
+		ApplicationRunner(target);
+		AddLifeCycleItem(target.prototype, LifeCycleModule.ApplicationStart, {
+			order,
+			exec,
+		});
+	};
+}

package/src/annotation/lifeCycle/ApplicationStop.ts

@@ -0,0 +1,18 @@
+import { BootPriority } from "../../constant/BootPriority";
+import { LifeCycleModule } from "../../constant/LifeCycleModule";
+import { AddLifeCycleItem } from "./AddLifeCycleItem";
+import ApplicationRunner from "./ApplicationRunner";
+
+//在应用停止前触发
+export default function ApplicationStop(order: number = BootPriority.Sys, exec: string = "run") {
+	return function (target: any) {
+		if (!Reflect.has(target.prototype, exec)) {
+			throw new Error(`${target.name} has no implementation ${exec} method`);
+		}
+		ApplicationRunner(target);
+		AddLifeCycleItem(target.prototype, LifeCycleModule.ApplicationStop, {
+			order,
+			exec,
+		});
+	};
+}

package/src/annotation/property/Deprecate.ts

@@ -0,0 +1,17 @@
+const DEFAULT_MSG = "This function will be removed in future versions.";
+
+/****
+ * @version 1.0 用于标记弃用
+ */
+export default function Deprecate(msg = DEFAULT_MSG) {
+	return function(target: any, prop?: string, descriptor?: PropertyDescriptor) {
+		console.warn(prop ? prop : Reflect.get(target, "name"), msg);
+		if (descriptor) {
+			const fn = descriptor.value;
+			descriptor.value = function(...args: any) {
+				console.warn(prop, msg);
+				return Reflect.apply(fn, this, args);
+			};
+		}
+	};
+}

package/src/annotation/property/NotImplemented.ts

@@ -0,0 +1,5 @@
+/***
+ * @version 1.0 不实现说明
+ *
+ */
+export default function NotImplemented(target: any, name?: string, descriptor?: PropertyDescriptor) {}

package/src/annotation/property/Override.ts

@@ -0,0 +1,4 @@
+/***
+ * @version 1.0 仅用于标记方法是否被重载
+ */
+export default function Override(target: any, methodName: string, descriptor: PropertyDescriptor) {}

package/src/annotation/property/Readonly.ts

@@ -0,0 +1,12 @@
+/**
+ * @version 1.0 用于标记只读 可作用于属性或者方法
+ */
+export default function Readonly(target: any, methodName: string, descriptor?: PropertyDescriptor) {
+	if (!descriptor) {
+		Reflect.defineProperty(target, methodName, {
+			writable: false,
+		});
+	} else {
+		descriptor.writable = false;
+	}
+}

package/src/annotation/scan/ComponentInjection.ts

@@ -0,0 +1,22 @@
+import * as path from "path";
+import * as fs from "fs";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+
+export default function ComponentInjection(target: any, ...names: string[]) {
+	let ScanPathList = FastCarMetaData.ComponentScan;
+	let list: string[] = Reflect.get(target.prototype, ScanPathList) || [];
+
+	for (let name of names) {
+		//可支持绝对路径
+		let p = path.join(require.main?.path || "", name);
+		if (fs.existsSync(name)) {
+			p = name;
+		}
+
+		if (!list.includes(p)) {
+			list.push(p);
+		}
+	}
+
+	Reflect.set(target.prototype, ScanPathList, list);
+}

package/src/annotation/scan/ComponentScan.ts

@@ -0,0 +1,7 @@
+import ComponentInjection from "./ComponentInjection";
+
+export default function ComponentScan(...names: string[]) {
+	return function(target: any) {
+		ComponentInjection(target, ...names);
+	};
+}

package/src/annotation/scan/ComponentScanExclusion.ts

@@ -0,0 +1,26 @@
+import "reflect-metadata";
+import * as path from "path";
+import * as fs from "fs";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+
+//和本包的相对路径
+export default function ComponentScanExclusion(...names: string[]) {
+	return function (target: any) {
+		let ScanPathList = FastCarMetaData.ComponentScanExclusion;
+		let list: string[] = Reflect.get(target.prototype, ScanPathList) || [];
+
+		for (let name of names) {
+			//可支持绝对路径
+			let p = path.join(require.main?.path || "", name);
+			if (fs.existsSync(name)) {
+				p = name;
+			}
+
+			if (!list.includes(p)) {
+				list.push(p);
+			}
+		}
+
+		Reflect.set(target.prototype, ScanPathList, list);
+	};
+}

package/src/annotation/scan/Hotter.ts

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+import { FastCarMetaData } from "../..";
+
+export default function Hotter(target: any) {
+	Reflect.defineMetadata(FastCarMetaData.Hotter, true, target.prototype);
+}