@fastcar/core 0.2.38

package/src/constant/FastCarMetaData.ts

@@ -0,0 +1,25 @@
+//元数据加载模块
+export enum FastCarMetaData {
+	paramTypes = "design:paramtypes", //传参类型
+	returnType = "design:returntype", //返回类型
+	designType = "design:type", //设计类型
+	InjectionMap = "InjectionMap", //应用服务需要加载的模块
+	IocModule = "IocModule", //每个中间件需要加载的模块
+	ComponentScan = "ComponentScan", //扫描路径
+	ComponentScanExclusion = "ComponentScanExclusion", //排序的扫描路径
+	RouterMap = "RouterMap", //路由集合模块
+	SpecifyMap = "SpecifyMap", //特定的组件集合
+	APP = "APP", //用于指定名称
+	DS = "dynamicDataSource",
+	DSIndex = "dynamicDataSourceIndex", //数据源索引位置
+	ValidFormRules = "validFormRules", //表单校验原始数据
+	ValidChildFormRules = "validChildFormRules", //原始
+	ValidSize = "valid:size", //校验长度
+	NotNull = "valid:notNull", //不为空
+	ValidCustom = "valid:custom", //自定义校验方式
+	Hotter = "hotter", //是否支持热更
+	InjectionUniqueKey = "injection_uniqueKey",
+	Alias = "alias", //别名
+	LoggerModule = "LoggerModule", //日志模块集合
+	HotterSysConfig = "hotterSysConfig", //支持热更系统配置
+}

package/src/constant/LifeCycleModule.ts

@@ -0,0 +1,5 @@
+export enum LifeCycleModule {
+	ApplicationStart = "applicationStart", //应用初始化完全完成后运行
+	ApplicationStop = "applicationStop", //应用结束之前进行执行
+	LoadConfigure = "loadConfigure", //应用加载配置文件
+}

package/src/db.ts

@@ -0,0 +1,182 @@
+import BaseMapper from "./model/BaseMapper";
+import SqlError from "./type/SqlError";
+
+export enum OperatorEnum {
+	eq = "=",
+	neq = "!=",
+	gt = ">",
+	gte = ">=",
+	lt = "<",
+	lte = "<=",
+	like = "LIKE",
+	in = "IN",
+	isNUll = "ISNULL",
+	isNotNull = "IS NOT NULL",
+	inc = "+", //累加
+	dec = "-", //累减
+	multiply = "*", //累乘
+	division = "/", //累除
+}
+
+export enum JoinEnum {
+	and = "AND",
+	or = "OR",
+}
+
+export enum OrderEnum {
+	asc = "ASC",
+	desc = "DESC",
+}
+
+export type SqlValue = number | string | number[] | string[] | null | Date;
+
+//where表达式
+type SqlExpression =
+	| {
+			[key: string]: { [key: string]: SqlValue };
+	  }
+	| SqlValue;
+
+export type SqlWhere = { [key: string]: SqlExpression | SqlWhere };
+
+export type RowData = {
+	[key: string]: SqlValue | { operate: string; value: SqlValue };
+};
+
+export type OrderType = { [key: string]: OrderEnum };
+
+export type SqlDelete = {
+	where?: SqlWhere; //查询条件
+	limit?: number; //限制行数
+};
+
+export type SqlQuery = {
+	where?: SqlWhere; //查询条件
+	fields?: string[]; //查询出来的元素
+	groups?: string[]; //分组排序
+	orders?: OrderType; //排序
+	limit?: number; //限制行数
+	offest?: number; //偏移量
+};
+
+export type SqlUpdate = {
+	where?: SqlWhere; //查询条件
+	row: RowData;
+	limit?: number; //限制行数
+};
+
+export type RowType = {
+	sql: string;
+	args: any[];
+};
+
+export interface DBMapper<T> {
+	/***
+	 * @version 1.0 更新或者添加记录多条记录(一般用于整条记录的更新)
+	 */
+	saveORUpdate(rows: T | T[], ds?: string, sessionId?: string): Promise<number | string>;
+
+	/***
+	 * @version 1.0 插入单条记录返回主键
+	 */
+	saveOne(row: T, ds?: string, sessionId?: string): Promise<number | string>;
+
+	/***
+	 * @version 1.0 批量插入记录
+	 */
+	saveList(rows: T[], ds?: string, sessionId?: string): Promise<boolean>;
+
+	/***
+	 * @version 1.0 更新记录
+	 *
+	 */
+	update({ row, where, limit }: SqlUpdate, ds?: string, sessionId?: string): Promise<boolean>;
+
+	/****
+	 * @version 1.0 更新一条数据
+	 *
+	 */
+	updateOne(sqlUpdate: SqlUpdate, ds?: string, sessionId?: string): Promise<boolean>;
+
+	/***
+	 * @version 1.0 根据实体类的主键来更新数据
+	 *
+	 */
+	updateByPrimaryKey(row: T, ds?: string, sessionId?: string): Promise<boolean>;
+
+	/***
+	 * @version 1.0 根据条件进行查找
+	 */
+	select(conditions: SqlQuery, ds?: string, sessionId?: string): Promise<T[]>;
+
+	/***
+	 * @version 1.0 查询单个对象
+	 *
+	 */
+	selectOne(conditions?: SqlQuery, ds?: string, sessionId?: string): Promise<T | null>;
+
+	/***
+	 * @version 1.0 通过主键查找对象
+	 *
+	 */
+	selectByPrimaryKey(row: T, ds?: string, sessionId?: string): Promise<T | null>;
+
+	/***
+	 * @version 1.0 判定是否存在
+	 *
+	 */
+	exist(where: SqlWhere, ds?: string, sessionId?: string): Promise<boolean>;
+
+	/***
+	 * @version 1.0 统计符合条件的记录
+	 */
+	count(where: SqlWhere, ds?: string, sessionId?: string): Promise<number>;
+
+	/***
+	 * @version 1.0 按照条件删除记录
+	 */
+	delete(conditions: SqlDelete, ds?: string, sessionId?: string): Promise<boolean>;
+
+	/***
+	 * @version 1.0 删除某条记录
+	 */
+	deleteOne(where: SqlWhere, ds?: string, sessionId?: string): Promise<boolean>;
+
+	/***
+	 * @version 1.0 删除某条记录根据主键
+	 */
+	deleteByPrimaryKey(row: T, ds?: string, sessionId?: string): Promise<boolean>;
+}
+
+export { BaseMapper, SqlError };
+
+export type MapperType = {
+	name: string; //量变名称
+	type: string; //类型
+	field: string; //数据库列名
+	dbType: string; //数据类型
+	primaryKey?: boolean; //是否为主键 默认为false
+	serialize?: Function; //序列化对象方法
+};
+
+export enum DesignMeta {
+	table = "db:table", //表名
+	field = "db:field", //列名
+	fieldMap = "db:fieldMap", //注入列名集合
+	dbType = "db:dbType", //数据类型
+	primaryKey = "db:primaryKey", //主键类型
+	entity = "db:entity", //实例化的数据库类
+	mapping = "db:mapping", //映射描述
+	dbFields = "db:fields", //数据库名-ts名
+	sqlSession = "SqlSession", //sql会话
+}
+
+export interface DataSourceManager {
+	createSession(): string;
+
+	destorySession(sessionId: string, status: boolean): void;
+
+	start(): void;
+
+	stop(): void;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+import { BootPriority } from "./constant/BootPriority";
+import { CommonConstant } from "./constant/CommonConstant";
+import { ComponentKind } from "./constant/ComponentKind";
+import { FastCarMetaData } from "./constant/FastCarMetaData";
+import { LifeCycleModule } from "./constant/LifeCycleModule";
+import FastCarApplication from "./FastCarApplication";
+import Logger from "./interface/Logger";
+import DataMap from "./model/DataMap";
+import ValidError from "./model/ValidError";
+
+export { LifeCycleModule, ComponentKind, BootPriority, FastCarApplication, FastCarMetaData, ValidError, DataMap, Logger, CommonConstant };

package/src/interface/ApplicationHook.ts

@@ -0,0 +1,9 @@
+export default interface ApplicationHook {
+	beforeStartServer(): Promise<void> | void; //启动前调用
+
+	startServer(): Promise<void> | void; //启动时调用
+
+	beforeStopServer(): Promise<void> | void; //停止前调用
+
+	stopServer(): void; //停止后调用 方法为指定的同步方法
+}

package/src/interface/ApplicationRunnerService.ts

@@ -0,0 +1,3 @@
+export default interface ApplicationRunnerService {
+	run(): void;
+}

package/src/interface/DataSourceManager.ts

@@ -0,0 +1,14 @@
+/***
+ * @version 1.0 数据源管理器
+ */
+export default interface DataSourceManager {
+	createSession(): string;
+
+	destorySession(sessionId: string, status: boolean): Promise<void>;
+
+	destorySession(sessionId: string, status: boolean): void;
+
+	start(): void;
+
+	stop(): void;
+}

package/src/interface/Logger.ts

@@ -0,0 +1,9 @@
+export default abstract class Logger {
+	abstract info(...args: any[]): void;
+
+	abstract debug(...args: any[]): void;
+
+	abstract warn(...args: any[]): void;
+
+	abstract error(...args: any[]): void;
+}

package/src/model/BaseMapper.ts

@@ -0,0 +1,115 @@
+import { DBMapper, MapperType, SqlDelete, SqlQuery, SqlUpdate, SqlWhere } from "../db";
+import { DesignMeta } from "../type/DesignMeta";
+import DataFormat from "../utils/DataFormat";
+
+export default class BaseMapper<T> implements DBMapper<T> {
+	protected tableName: string;
+	protected classZ: any; //映射的原型类
+	protected mappingMap: Map<string, MapperType>; //代码别名-映射关系
+	protected mappingList: MapperType[];
+	protected dbFields: Map<string, string>; //数据库别名-代码别名
+
+	/***
+	 * @version 1.0 对于类型做一个转换
+	 */
+	constructor() {
+		let tClass = Reflect.getMetadata(DesignMeta.entity, this);
+		this.classZ = tClass;
+
+		let tableName = Reflect.getMetadata(DesignMeta.table, tClass);
+		if (!tableName) {
+			throw new Error(`This class ${tClass.name} has no annotation table name`);
+		}
+		this.tableName = tableName;
+		this.mappingMap = Reflect.getMetadata(DesignMeta.mapping, tClass); //映射关系
+		this.dbFields = Reflect.getMetadata(DesignMeta.dbFields, tClass); //作用的列名
+		this.mappingList = Array.of();
+
+		this.mappingMap.forEach(item => {
+			this.mappingList.push(item);
+		});
+	}
+
+	//获取数据库别名通过代码内的名称
+	protected getFieldName(name: string): string {
+		let info = this.mappingMap.get(name);
+		return info ? info.field : name;
+	}
+
+	protected setRow(rowData: Object): T {
+		let t = new this.classZ();
+
+		this.mappingMap.forEach((item, key) => {
+			let value = Reflect.get(rowData, item.field) || Reflect.get(rowData, key);
+			if (value != null) {
+				let fvalue = DataFormat.formatValue(value, item.type);
+				Reflect.set(t, key, fvalue);
+			}
+		});
+
+		return t;
+	}
+
+	protected setRows(rowDataList: Object[]): T[] {
+		let list: T[] = Array.of();
+		rowDataList.forEach(item => {
+			list.push(this.setRow(item));
+		});
+
+		return list;
+	}
+
+	saveORUpdate(rows: T | T[], ds?: string, sessionId?: string): Promise<string | number> {
+		throw new Error("Method not implemented.");
+	}
+	saveOne(row: T, ds?: string, sessionId?: string): Promise<string | number> {
+		throw new Error("Method not implemented.");
+	}
+	saveList(rows: T[], ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	update({ row, where, limit }: SqlUpdate, ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	updateOne(sqlUpdate: SqlUpdate, ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	updateByPrimaryKey(row: T, ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	select(conditions: SqlQuery, ds?: string, sessionId?: string): Promise<T[]> {
+		throw new Error("Method not implemented.");
+	}
+
+	/***
+	 * @version 1.0 查询单个对象
+	 *
+	 */
+	async selectOne(conditions?: SqlQuery, ds?: string, sessionId?: string): Promise<T | null> {
+		throw new Error("Method not implemented.");
+	}
+
+	/***
+	 * @version 1.0 通过主键查找对象
+	 *
+	 */
+	async selectByPrimaryKey(row: T, ds?: string, sessionId?: string): Promise<T | null> {
+		throw new Error("Method not implemented.");
+	}
+
+	exist(where: SqlWhere, ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	count(where: SqlWhere, ds?: string, sessionId?: string): Promise<number> {
+		throw new Error("Method not implemented.");
+	}
+	delete(conditions: SqlDelete, ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	deleteOne(where: SqlWhere, ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	deleteByPrimaryKey(row: T, ds?: string, sessionId?: string): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+}

package/src/model/DataMap.ts

@@ -0,0 +1,103 @@
+export type FIELDTYPE = {
+	field: string;
+	order?: boolean; //是否为倒序 order true为倒序
+	compare?: (a: any, b: any) => boolean;
+};
+
+export default class DataMap<K, V extends Object> extends Map<K, V> {
+	constructor() {
+		super();
+	}
+
+	toValues(): V[] {
+		return [...this.values()];
+	}
+
+	toKeys(): K[] {
+		return [...this.keys()];
+	}
+
+	toObject(): { [key: string]: V } {
+		let o = {};
+		this.forEach((v, k: any) => {
+			Reflect.set(o, k, v);
+		});
+
+		return o;
+	}
+
+	//自定义排序 支持多个排序
+	sort(sorts?: FIELDTYPE[], list?: V[]): V[] {
+		list = !list ? this.toValues() : list;
+		if (!sorts || sorts?.length == 0) {
+			return list;
+		}
+		let total = sorts.length;
+		list.sort((a, b) => {
+			let resultNum = 0;
+			sorts.some((f, index) => {
+				let field = f.field;
+				let aValue = Reflect.get(a, field);
+				let bValue = Reflect.get(b, field);
+				let flag = f.compare ? f.compare(aValue, bValue) : aValue > bValue;
+				resultNum = flag ? total - index : index - total;
+
+				//降序则倒着
+				if (f.order) {
+					resultNum = -resultNum;
+				}
+
+				return !!flag;
+			});
+			return resultNum;
+		});
+		return list;
+	}
+
+	/***
+	 * @version 1.0 查找属性名称
+	 * @params atts代表属性键值对匹配
+	 *
+	 */
+	findByAtts(atts: { [key: string]: any }): V[] {
+		let list: V[] = [];
+		let keys = Object.keys(atts);
+
+		this.forEach((item) => {
+			let flag = keys.every((key) => {
+				let v = Reflect.get(atts, key);
+
+				//这边判断 是不是一个复合属性
+				if (Reflect.has(item, key)) {
+					let itemV = Reflect.get(item, key);
+					return itemV == v;
+				} else {
+					let keyList = key.split(".");
+					if (keyList.length > 1) {
+						let tmpV: any = item;
+						let f = keyList.every((tk) => {
+							if (!Reflect.has(tmpV, tk)) {
+								return false;
+							}
+							tmpV = Reflect.get(tmpV, tk);
+							return true;
+						});
+
+						if (!f) {
+							return false;
+						}
+
+						return tmpV == v;
+					}
+				}
+
+				return false;
+			});
+			if (flag) {
+				list.push(item);
+			}
+		});
+
+		return list;
+	}
+}

package/src/model/FormRuleModel.ts

@@ -0,0 +1,23 @@
+export type CheckTool = {
+	fn: (val: any) => boolean;
+	message?: string;
+};
+
+export interface FormRuleModel {
+	message?: string; //错误信息
+	type?: string; // 类型
+	minSize?: number; //最小值
+	maxSize?: number; //最大值
+	required?: boolean; //是否为必填项
+	defaultVal?: any; //默认值
+	filters?: CheckTool[]; //校验方法
+	nullMessage?: string; //是否为空的错误提示
+	sizeMessgae?: string; //长度错误提示
+	typeMessage?: string; //类型错误提示
+}
+
+export type FormRuleType = {
+	rules: { [prop: string]: FormRuleModel };
+	index: number;
+	basicFlag: boolean;
+};

package/src/model/ValidError.ts

@@ -0,0 +1 @@
+export default class ValidError extends Error {}

package/src/model/WinstonLogger.ts

@@ -0,0 +1,119 @@
+import * as winston from "winston";
+import { ColorLevelType, WinstonLoggerType } from "../type/WinstonLoggerType";
+import * as path from "path";
+import { DateUtil, ValidationUtil } from "../utils";
+import * as util from "util";
+const SPLAT = Symbol.for("splat");
+
+export default class WinstonLogger {
+	protected config: WinstonLoggerType;
+	protected categoryMap: Map<string, winston.Logger>;
+
+	constructor(config: WinstonLoggerType) {
+		this.config = config;
+		this.categoryMap = new Map();
+	}
+
+	//控制台着色
+	private colorize(str: string, level: string) {
+		let colorStyle = Reflect.get(ColorLevelType, level);
+		if (!colorStyle) {
+			return str;
+		}
+
+		return `\x1B[${colorStyle[0]}m ${str} \x1B[${colorStyle[1]}m`;
+	}
+
+	//数据着色为白色
+	private colorizeData(data: any) {
+		let msg = ValidationUtil.isObject(data) ? JSON.stringify(data) : data;
+		return `\x1B[37m ${msg} \x1B[39m`;
+	}
+
+	setConfig(config: WinstonLoggerType) {
+		this.config = config;
+	}
+
+	hasLogger(category: string): boolean {
+		return winston.loggers.has(category);
+	}
+
+	getLogger(category: string): winston.Logger | undefined {
+		return this.categoryMap.get(category);
+	}
+
+	addLogger(category: string) {
+		if (this.categoryMap.has(category)) {
+			winston.loggers.close(category);
+		}
+
+		let newLogger = winston.loggers.add(category, {
+			format: winston.format.combine(
+				winston.format.label({ label: category }),
+				winston.format.printf(info => {
+					//debug模式等级时仅为控制台输出
+					let level = info.level.toUpperCase();
+					let timestamp = DateUtil.toDateTimeMS();
+
+					let content = {
+						timestamp,
+						level,
+						label: info.label,
+						message: info.message,
+					};
+
+					if (Reflect.has(info, SPLAT)) {
+						Reflect.set(content, "splat", JSON.stringify(Reflect.get(info, SPLAT)));
+					}
+
+					if (info.stack) {
+						Reflect.set(content, "stack", info.stack);
+					}
+
+					Reflect.set(info, "timestamp", content.timestamp);
+
+					//新增打印控制台
+					if (this.config.printConsole) {
+						let text = this.colorize(util.format("[%s] [%s] %s - ", timestamp, level, info.label), info.level);
+						text += this.colorizeData(content.message);
+
+						if (Reflect.has(info, SPLAT)) {
+							let splatMsg: any[] = Reflect.get(info, SPLAT);
+							splatMsg.forEach(item => {
+								text += " " + this.colorizeData(item);
+							});
+						}
+
+						if (info.stack) {
+							text += this.colorizeData(`\nstatck: ${info.stack}`);
+						}
+						let fn = console.info;
+						if (Reflect.has(console, info.level)) {
+							fn = Reflect.get(console, info.level);
+						}
+
+						Reflect.apply(fn, console, [text]);
+					}
+
+					return util.format("%j", content);
+				})
+			),
+
+			transports: [
+				new winston.transports.File({
+					level: this.config.fileLevel,
+					filename: path.join(this.config.rootPath, `${category}.log`),
+					maxsize: this.config.maxsize,
+					maxFiles: this.config.maxFiles,
+				}),
+			],
+		});
+
+		this.categoryMap.set(category, newLogger);
+		return newLogger;
+	}
+
+	getLoggerList(): winston.Logger[] {
+		return [...this.categoryMap.values()];
+	}
+}

package/src/type/ComponentDesc.ts

@@ -0,0 +1,5 @@
+export type ComponentDesc = {
+	id: string;
+	name: string;
+	path: string;
+};

package/src/type/DesignMeta.ts

@@ -0,0 +1,11 @@
+export enum DesignMeta {
+	table = "db:table", //表名
+	field = "db:field", //列名
+	fieldMap = "db:fieldMap", //注入列名集合
+	dbType = "db:dbType", //数据类型
+	primaryKey = "db:primaryKey", //主键类型
+	entity = "db:entity", //实例化的数据库类
+	mapping = "db:mapping", //映射描述
+	dbFields = "db:fields", //数据库名-ts名
+	sqlSession = "SqlSession", //sql会话
+}

package/src/type/FileHotterDesc.ts

@@ -0,0 +1,4 @@
+export type FileHotterDesc = {
+	name: string;
+	key: string | symbol;
+};

package/src/type/MapperType.ts

@@ -0,0 +1,8 @@
+export type MapperType = {
+	name: string; //量变名称
+	type: string; //类型
+	field: string; //数据库列名
+	dbType: string; //数据类型
+	primaryKey?: boolean; //是否为主键 默认为false
+	serialize?: Function; //序列化对象方法
+};

package/src/type/ProcessType.ts

@@ -0,0 +1,12 @@
+export type ProcessType = {
+	pid: number; //进程id
+	name: string; //进程名称
+	env: string; //环境
+	version: string; //版本
+	rss: string; //常驻集大小
+	heapTotal: string; //V8 的内存使用量
+	heapUsed: string;
+	arrayBuffers: string; //包含所有的Buffer
+	external: string; //绑定到 V8 管理的 JavaScript 对象的 C++ 对象的内存使用量
+	uptime: string; //运行时间
+};

package/src/type/SqlError.ts

@@ -0,0 +1,3 @@
+class SqlError extends Error {}
+
+export default SqlError;