@fastcar/core 0.2.38

package/src/annotation/stereotype/BeanName.ts

@@ -0,0 +1,9 @@
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+
+//应用别名声明
+export default function BeanName(name: string) {
+	return function(target: any) {
+		//生成别名 用于逻辑识别
+		Reflect.defineMetadata(FastCarMetaData.Alias, name, target.prototype); //放入至原型中
+	};
+}

package/src/annotation/stereotype/Component.ts

@@ -0,0 +1,6 @@
+import { ComponentKind } from "../../constant/ComponentKind";
+import Injection from "./Injection";
+
+export default function Component(target: any) {
+	Injection(target, ComponentKind.Component);
+}

package/src/annotation/stereotype/Configure.ts

@@ -0,0 +1,12 @@
+import Component from "./Component";
+import { LifeCycleModule } from "../../constant/LifeCycleModule";
+
+//配置文件层
+export default function Configure(name: string) {
+	return function (target: any) {
+		//配置对象也为组件
+		Component(target);
+		//当实例化时 加载默认配置并进行赋值
+		Reflect.defineMetadata(LifeCycleModule.LoadConfigure, name, target);
+	};
+}

package/src/annotation/stereotype/Controller.ts

@@ -0,0 +1,7 @@
+import { ComponentKind } from "../../constant/ComponentKind";
+import Injection from "./Injection";
+
+//业务逻辑层
+export default function Controller(target: any) {
+	Injection(target, ComponentKind.Controller);
+}

package/src/annotation/stereotype/Injection.ts

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+import CryptoUtil from "../../utils/CryptoUtil";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+
+export default function Injection(target: any, name: string) {
+	//生成别名 避免名称重复的情况
+	let key = `${name}:${CryptoUtil.getHashStr()}`;
+	Reflect.defineMetadata(name, true, target.prototype);
+	Reflect.defineMetadata(FastCarMetaData.InjectionUniqueKey, key, target); //放入至原型中
+}

package/src/annotation/stereotype/Log.ts

@@ -0,0 +1,17 @@
+import { CommonConstant } from "../../constant/CommonConstant";
+import FastCarApplication from "../../FastCarApplication";
+import Logger from "../../interface/Logger";
+
+//日志实例
+export default function Log(category?: string) {
+	return function (target: any, propertyKey: string) {
+		let m = category || propertyKey;
+
+		Reflect.defineProperty(target, propertyKey, {
+			get: (): Logger => {
+				let app: FastCarApplication = Reflect.get(global, CommonConstant.FastcarApp);
+				return app ? app.getLogger(m) : console;
+			},
+		});
+	};
+}

package/src/annotation/stereotype/Repository.ts

@@ -0,0 +1,7 @@
+import { ComponentKind } from "../../constant/ComponentKind";
+import Injection from "./Injection";
+
+//数据逻辑层(表明和数据库相关)
+export default function Repository(target: any) {
+	Injection(target, ComponentKind.Repository);
+}

package/src/annotation/stereotype/Service.ts

@@ -0,0 +1,7 @@
+import { ComponentKind } from "../../constant/ComponentKind";
+import Injection from "./Injection";
+
+//中间服务层
+export default function Service(target: any) {
+	Injection(target, ComponentKind.Service);
+}

package/src/annotation/valid/AddChildValid.ts

@@ -0,0 +1,61 @@
+import "reflect-metadata";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+import { FormRuleModel } from "../../model/FormRuleModel";
+import TypeUtil from "../../utils/TypeUtil";
+import ValidationUtil from "../../utils/ValidationUtil";
+
+//添加子元素的校验规则
+export default function AddChildValid(target: any, name: string, value: { [key: string]: any }, index?: number) {
+	let childMap: Map<string, FormRuleModel>;
+
+	let paramsFlag = ValidationUtil.isNumber(index);
+	let alias = paramsFlag ? `${name}-${index}` : name;
+	if (paramsFlag) {
+		childMap = Reflect.getMetadata(FastCarMetaData.ValidChildFormRules, target, alias);
+		if (!childMap) {
+			childMap = new Map();
+			Reflect.defineMetadata(FastCarMetaData.ValidChildFormRules, childMap, target, alias);
+		}
+	} else {
+		childMap = Reflect.getMetadata(FastCarMetaData.ValidChildFormRules, target);
+		if (!childMap) {
+			childMap = new Map();
+			Reflect.defineMetadata(FastCarMetaData.ValidChildFormRules, childMap, target);
+		}
+	}
+
+	let item = childMap.get(alias);
+	if (!item) {
+		let proto = Reflect.getMetadata(FastCarMetaData.designType, target, name);
+
+		if (paramsFlag) {
+			//修改为方法获取原型
+			let paramsTypes = Reflect.getMetadata(FastCarMetaData.paramTypes, target, name);
+			if (typeof index == "number") {
+				proto = paramsTypes[index];
+			}
+		}
+
+		let typeName = proto.name.toLowerCase();
+		if (!TypeUtil.isBasic(typeName)) {
+			typeName = typeName == "array" ? "array" : "object";
+		}
+
+		item = {
+			type: typeName,
+		};
+	}
+
+	//自定义方法合并
+	if (Reflect.has(value, "filters")) {
+		if (Array.isArray(item.filters)) {
+			item.filters.forEach((f) => {
+				value.filters.push(f);
+			});
+		}
+	}
+
+	//合并所有属性
+	Object.assign(item, value);
+	childMap.set(alias, item);
+}

package/src/annotation/valid/DefaultVal.ts

@@ -0,0 +1,8 @@
+import AddChildValid from "./AddChildValid";
+
+//默认值获取
+export default function DefaultVal(val: any) {
+	return function(target: any, propertyKey: string, index?: number) {
+		AddChildValid(target, propertyKey, { defaultVal: val }, index);
+	};
+}

package/src/annotation/valid/NotNull.ts

@@ -0,0 +1,7 @@
+import AddChildValid from "./AddChildValid";
+import ValidationUtil from "../../utils/ValidationUtil";
+
+//是否为非空字段
+export default function NotNull(target: any, propertyKey: string, index?: number) {
+	AddChildValid(target, propertyKey, { required: true }, index);
+}

package/src/annotation/valid/Rule.ts

@@ -0,0 +1,104 @@
+import "reflect-metadata";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+import { FormRuleModel, FormRuleType } from "../../model/FormRuleModel";
+import TypeUtil from "../../utils/TypeUtil";
+
+export function Rule(rules: { [prop: string]: FormRuleModel } = {}) {
+	return function(target: any, method: string, index: number) {
+		//获取设计类型
+		//获取增强类型的增加严格校验
+		let paramsTypes = Reflect.getMetadata(FastCarMetaData.paramTypes, target, method);
+
+		//对rules进行进一步的补充
+		let designObj = paramsTypes[index];
+		let basicFlag = false;
+		if (!designObj) {
+			console.warn(`Design type not found by ${method} in ${index}`);
+		} else {
+			basicFlag = TypeUtil.isBasic(designObj.name);
+			//获取表单类型
+			let childMap: Map<string, FormRuleModel> = Reflect.getMetadata(FastCarMetaData.ValidChildFormRules, target, `${method}-${index}`);
+
+			//进行合并添加
+			if (TypeUtil.isClass(designObj)) {
+				let appendMap: Map<string, FormRuleModel> = Reflect.getMetadata(FastCarMetaData.ValidChildFormRules, designObj.prototype);
+				if (appendMap) {
+					if (!childMap) {
+						childMap = new Map();
+					}
+					appendMap.forEach((v, key) => {
+						if (!childMap.has(key)) {
+							childMap.set(key, v);
+							return;
+						} else {
+							//进行覆盖更新
+							let item = childMap.get(key);
+							if (Reflect.has(v, "filters")) {
+								if (Array.isArray(item?.filters)) {
+									v.filters?.forEach(f => {
+										item?.filters?.push(f);
+									});
+								}
+							}
+
+							//合并所有属性
+							item = Object.assign(v, item);
+							childMap.set(key, item);
+						}
+					});
+				}
+			}
+			if (childMap && childMap.size > 0) {
+				//补充表单
+				childMap.forEach((citem, prop) => {
+					if (Reflect.has(rules, prop)) {
+						//优先取表单里的
+						rules[prop] = Object.assign(citem, rules[prop]);
+					} else {
+						Reflect.set(rules, prop, citem);
+					}
+				});
+			}
+		}
+
+		let rulesMap: Map<number, FormRuleType> = Reflect.getMetadata(FastCarMetaData.ValidFormRules, target, method);
+		if (!rulesMap) {
+			rulesMap = new Map<number, FormRuleType>();
+			Reflect.defineMetadata(FastCarMetaData.ValidFormRules, rulesMap, target, method);
+		}
+
+		//补全消息
+		Object.keys(rules).forEach(prop => {
+			let r = rules[prop];
+
+			//根据增强型补全type
+			if (basicFlag && !Reflect.has(r, "type")) {
+				if (designObj) {
+					r.type = designObj.name.toLowerCase();
+				} else {
+					r.type = "string";
+				}
+			}
+
+			if (r.message) {
+				if (r.required) {
+					r.nullMessage = r.nullMessage ? r.nullMessage : r.message;
+				}
+
+				if (r.maxSize || r.minSize) {
+					r.sizeMessgae = r.sizeMessgae ? r.sizeMessgae : r.message;
+				}
+
+				r.typeMessage = r.typeMessage ? r.typeMessage : r.message;
+			} else {
+				if (r.required) {
+					r.nullMessage = `${prop} is required`;
+				}
+
+				r.typeMessage = `${prop} type is ${r.type}`;
+			}
+		});
+
+		rulesMap.set(index, { rules, basicFlag, index });
+	};
+}

package/src/annotation/valid/Size.ts

@@ -0,0 +1,13 @@
+import AddChildValid from "./AddChildValid";
+
+type SizeModel = {
+	minSize?: number;
+	maxSize?: number;
+};
+
+//校验长度
+export default function Size(m: SizeModel = { minSize: 0, maxSize: 0 }) {
+	return function(target: any, propertyKey: string, index?: number) {
+		AddChildValid(target, propertyKey, m, index);
+	};
+}

package/src/annotation/valid/Type.ts

@@ -0,0 +1,8 @@
+import AddChildValid from "./AddChildValid";
+
+//表明类型
+export default function Type(type: string) {
+	return function(target: any, propertyKey: string, index?: number) {
+		AddChildValid(target, propertyKey, { type: type.toLowerCase() }, index);
+	};
+}

package/src/annotation/valid/ValidCustom.ts

@@ -0,0 +1,21 @@
+import AddChildValid from "./AddChildValid";
+type checkfun = (val: any) => boolean;
+
+//自定义表单校验
+export default function ValidCustom(fn: checkfun, message?: string) {
+	return function(target: any, propertyKey: string, index?: number) {
+		AddChildValid(
+			target,
+			propertyKey,
+			{
+				filters: [
+					{
+						fn,
+						message,
+					},
+				],
+			},
+			index
+		);
+	};
+}

package/src/annotation/valid/ValidForm.ts

@@ -0,0 +1,146 @@
+import { FormRuleModel, FormRuleType } from "../../model/FormRuleModel";
+import ValidError from "../../model/ValidError";
+import { TypeUtil } from "../../utils";
+import ValidationUtil from "../../utils/ValidationUtil";
+import DATAFORMAT from "../../utils/DataFormat";
+import { FastCarMetaData } from "../../constant/FastCarMetaData";
+
+function throwErrMsg(rule: FormRuleModel, prop: string, msg?: string) {
+	let showMsg = msg;
+	if (!showMsg) {
+		showMsg = rule.message ? rule.message : `The ${prop} parameter is invalid `;
+	}
+	throw new ValidError(showMsg);
+}
+
+function getFormValue(value: any, prop: string, defaultValue?: any) {
+	//查看是否校验子属性
+	if (ValidationUtil.isNotNull(value)) {
+		if (TypeUtil.isObject(value)) {
+			if (Reflect.has(value, prop)) {
+				let propValue = Reflect.get(value, prop);
+				if (ValidationUtil.isNotNull(propValue)) {
+					return propValue;
+				}
+			}
+		} else {
+			return value;
+		}
+	}
+
+	if (ValidationUtil.isNotNull(defaultValue)) {
+		return defaultValue;
+	}
+
+	return null;
+}
+
+function setFormValue(obj: any, prop: string, val: any) {
+	//查看是否校验子属性
+	if (ValidationUtil.isNotNull(obj) || TypeUtil.isObject(obj)) {
+		//修正为{}对象时无法赋值错误
+		if (TypeUtil.isObject(obj)) {
+			Reflect.set(obj, prop, val);
+		} else {
+			obj = val;
+		}
+	}
+
+	return obj;
+}
+
+function delFormValue(value: any, prop: string) {
+	if (ValidationUtil.isNotNull(value)) {
+		if (TypeUtil.isObject(value)) {
+			if (Reflect.has(value, prop)) {
+				Reflect.deleteProperty(value, prop);
+			}
+		}
+	}
+}
+
+/***
+ * @version 1.0 校验表单 支持校验大小 类型 和自定义方法
+ * @param rules key - value的形式 通常一个参数一个校验方式
+ * @param paramIndex 位于第几个参数的校验表单
+ *
+ */
+export default function ValidForm(target: any, methodName: string, descriptor: PropertyDescriptor) {
+	let next = descriptor.value;
+
+	descriptor.value = function (...args: any[]) {
+		let rulesMap: Map<number, FormRuleType> = Reflect.getMetadata(FastCarMetaData.ValidFormRules, target, methodName);
+
+		if (rulesMap && rulesMap.size > 0) {
+			rulesMap.forEach((item, paramIndex) => {
+				let { rules, basicFlag } = item;
+				let currObj = args[paramIndex];
+
+				if (ValidationUtil.isNull(currObj)) {
+					currObj = basicFlag ? "" : {};
+				}
+
+				for (let prop in rules) {
+					let rule = rules[prop];
+
+					//进行取值
+					let val = getFormValue(currObj, prop, rule.defaultVal);
+
+					//判断关键字是否相同
+					if (`${methodName}-${paramIndex}` == prop) {
+						val = currObj || rule.defaultVal;
+					}
+
+					//优先判断是否为必填项
+					if (ValidationUtil.isNull(val)) {
+						if (rule.required) {
+							throwErrMsg(rule, prop, rule.nullMessage);
+						} else {
+							delFormValue(currObj, prop);
+						}
+					} else {
+						//进行类型判断并赋值
+						let checkType = rule.type || "string";
+						val = DATAFORMAT.formatValue(val, checkType);
+						//调用check的方法
+						if (!ValidationUtil.checkType(val, checkType)) {
+							throwErrMsg(rule, prop, rule.typeMessage);
+						}
+
+						//判断长度
+						if (rule?.minSize) {
+							if (!ValidationUtil.isNotMinSize(val, rule.minSize)) {
+								throwErrMsg(rule, prop, rule.sizeMessgae ? rule.sizeMessgae : `${prop} should be greater than ${rule.minSize} `);
+							}
+						}
+
+						if (rule?.maxSize) {
+							if (!ValidationUtil.isNotMaxSize(val, rule.maxSize)) {
+								throwErrMsg(rule, prop, rule.sizeMessgae ? rule.sizeMessgae : `${prop} should be less than ${rule.maxSize} `);
+							}
+						}
+
+						//自定义方法校验
+						if (Array.isArray(rule.filters)) {
+							for (let fnItem of rule.filters) {
+								let fn = fnItem.fn;
+								let flag = Reflect.apply(fn, this, [val]);
+								if (!flag) {
+									//抛出错误提示
+									throwErrMsg(rule, prop, fnItem.message || rule.message);
+								}
+							}
+						}
+
+						//进行赋值
+						currObj = setFormValue(currObj, prop, val);
+					}
+				}
+
+				args[paramIndex] = currObj;
+			});
+		}
+
+		return Reflect.apply(next, this, args);
+	};
+}

package/src/annotation.ts

@@ -0,0 +1,103 @@
+import Application from "./annotation/Application";
+import Autowired from "./annotation/bind/Autowired";
+import ENV from "./annotation/env/ENV";
+import ExceptionMonitor from "./annotation/ExceptionMonitor";
+import ApplicationStart from "./annotation/lifeCycle/ApplicationStart";
+import ApplicationStop from "./annotation/lifeCycle/ApplicationStop";
+import Deprecate from "./annotation/property/Deprecate";
+import NotImplemented from "./annotation/property/NotImplemented";
+import Override from "./annotation/property/Override";
+import Readonly from "./annotation/property/Readonly";
+import ComponentScan from "./annotation/scan/ComponentScan";
+import ComponentScanExclusion from "./annotation/scan/ComponentScanExclusion";
+import Component from "./annotation/stereotype/Component";
+import Configure from "./annotation/stereotype/Configure";
+import Controller from "./annotation/stereotype/Controller";
+import Injection from "./annotation/stereotype/Injection";
+import Service from "./annotation/stereotype/Service";
+import Repository from "./annotation/stereotype/Repository";
+import AddRequireModule from "./annotation/bind/AddRequireModule";
+import DS from "./annotation/data/DS";
+import DSIndex from "./annotation/data/DSIndex";
+import AddChildValid from "./annotation/valid/AddChildValid";
+import DefaultVal from "./annotation/valid/DefaultVal";
+import NotNull from "./annotation/valid/NotNull";
+import Size from "./annotation/valid/Size";
+import Type from "./annotation/valid/Type";
+import ValidCustom from "./annotation/valid/ValidCustom";
+import ValidForm from "./annotation/valid/ValidForm";
+import { Rule } from "./annotation/valid/Rule";
+import BeanName from "./annotation/stereotype/BeanName";
+import ComponentInjection from "./annotation/scan/ComponentInjection";
+import DBType from "./annotation/data/DBType";
+import Field from "./annotation/data/Field";
+import PrimaryKey from "./annotation/data/PrimaryKey";
+import Table from "./annotation/data/Table";
+import Entity from "./annotation/data/Entity";
+import SqlSession from "./annotation/data/SqlSession";
+import Transactional from "./annotation/data/Transactional";
+import Log from "./annotation/stereotype/Log";
+import BaseFilePath from "./annotation/env/BaseFilePath";
+import BasePath from "./annotation/env/BasePath";
+import CallDependency from "./annotation/bind/CallDependency";
+import Hotter from "./annotation/scan/Hotter";
+import ApplicationRunner from "./annotation/lifeCycle/ApplicationRunner";
+import ApplicationInit from "./annotation/lifeCycle/ApplicationInit";
+import ApplicationDestory from "./annotation/lifeCycle/ApplicationDestory";
+import ApplicationSetting from "./annotation/env/ApplicationSetting";
+import AliasInjection from "./annotation/bind/AliasInjection";
+import ResourcePath from "./annotation/env/ResourcePath";
+
+//注解暴露出去
+export {
+	ApplicationStart,
+	ApplicationStop,
+	ApplicationRunner,
+	ApplicationInit,
+	ApplicationDestory,
+	ComponentScan,
+	ComponentScanExclusion,
+	Component,
+	ComponentInjection,
+	Hotter,
+	BeanName,
+	Configure,
+	Controller,
+	Service,
+	Repository,
+	Injection,
+	Application,
+	Autowired,
+	CallDependency,
+	AliasInjection,
+	ExceptionMonitor,
+	Deprecate,
+	NotImplemented,
+	Override,
+	Readonly,
+	Log,
+	AddRequireModule,
+	AddChildValid,
+	DefaultVal,
+	NotNull,
+	Size,
+	Type,
+	ValidCustom,
+	ValidForm,
+	Rule,
+	ResourcePath,
+};
+
+export {
+	DS,
+	DSIndex,
+	DBType, //数据库类型
+	Field, //数据库字段名
+	PrimaryKey, //是否为主键
+	Table, //表名
+	Entity, //表和对应编程内的类型映射
+	SqlSession, //连接会话 如果需要使用同一连接或者使用事务是传递
+	Transactional, //事务管理
+};
+
+export { ENV, BaseFilePath, BasePath, ApplicationSetting };

package/src/config/ApplicationConfig.ts

@@ -0,0 +1,5 @@
+export type ApplicationConfig = {
+	name: string;
+	env: string;
+	version: string;
+};

package/src/config/SysConfig.ts

@@ -0,0 +1,28 @@
+import { WinstonLoggerType } from "../type/WinstonLoggerType";
+import { ApplicationConfig } from "./ApplicationConfig";
+
+/***
+ * @version 1.0 系统基础配置
+ */
+export type SYSConfig = {
+	application: ApplicationConfig; //应用配置
+	settings: Map<string | symbol, any>; //自定义设置项
+};
+
+export const SYSDefaultConfig: SYSConfig = {
+	application: {
+		name: "app",
+		env: "development",
+		version: "1.0.0",
+	},
+	settings: new Map<string, Object>(), //自定义配置
+};
+
+export const LogDefaultConfig: WinstonLoggerType = {
+	consoleLevel: "info",
+	fileLevel: "info",
+	rootPath: __dirname, //日志路径
+	maxsize: 1024 * 1024 * 10, //默认10M
+	maxFiles: 30,
+	printConsole: true,
+};

package/src/constant/AppStatusEnum.ts

@@ -0,0 +1,5 @@
+export enum AppStatusEnum {
+	READY = "ready",
+	RUN = "run",
+	STOP = "stop",
+}

package/src/constant/BootPriority.ts

@@ -0,0 +1,7 @@
+export enum BootPriority {
+	Base = 0, //一般系统级的会优先启动这一个
+	Sys = 1, //系统优先的
+	Common = 2, //常用
+	Other = 3, //额外的
+	Lowest = 10000, //默认优先级1万最低
+}

package/src/constant/CommonConstant.ts

@@ -0,0 +1,14 @@
+export const CommonConstant = {
+	Application: "application",
+	Settings: "settings",
+	Resource: "resource",
+	ENV: Symbol("env"),
+	BasePath: Symbol("basePath"),
+	BaseFileName: Symbol("baseFileName"),
+	SYSLOGGER: "sys",
+	FastcarApp: Symbol("FastcarApp"), //应用app
+	FastcarSetting: Symbol("FastcarSetting"),
+	ResourcePath: "resourcePath",
+};
+
+export const FileResSuffix = ["json", "yml", "js"];

package/src/constant/ComponentKind.ts

@@ -0,0 +1,7 @@
+//实例类型
+export enum ComponentKind {
+	Controller = "Controller",
+	Service = "Service",
+	Component = "Component",
+	Repository = "Repository",
+}

package/src/constant/DataTypes.ts

@@ -0,0 +1,15 @@
+//数据类型枚举
+export enum DataTypes {
+	BOOLEAN = "boolean",
+	NUMBER = "number",
+	STRING = "string",
+	INT = "int",
+	FLOAT = "float",
+	DATE = "date",
+	Object = "object",
+	ARRAYNUMBER = "arraynumber",
+	ARRAYINT = "arrayint",
+	ARRAYFLOAT = "arrayfloat",
+	ARRAYSTRING = "arraystring",
+	ARRAYOBJECT = "arrayobject",
+}