@eggjs/dal-decorator 4.0.0-beta.4 → 4.0.0-beta.6

package/README.md

@@ -1,5 +1,17 @@
 # `@eggjs/dal-decorator`
 
+[![NPM version][npm-image]][npm-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![npm download][download-image]][download-url]
+[![Node.js Version](https://img.shields.io/node/v/@eggjs/dal-decorator.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/dal-decorator.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/dal-decorator
+[snyk-image]: https://snyk.io/test/npm/@eggjs/dal-decorator/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/@eggjs/dal-decorator
+[download-image]: https://img.shields.io/npm/dm/@eggjs/dal-decorator.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/dal-decorator
+
 ## Usage
 
-Please read [@eggjs/tegg-dal-plugin](../../plugin/dal-plugin)
+Please read [@eggjs/tegg-dal-plugin](../../plugin/dal/README.md)

package/dist/decorator/Column.d.ts

@@ -0,0 +1,6 @@
+import { ColumnParams, ColumnTypeParams } from "@eggjs/tegg-types";
+
+//#region src/decorator/Column.d.ts
+declare function Column(type: ColumnTypeParams, params?: ColumnParams): (target: any, propertyKey: PropertyKey) => void;
+//#endregion
+export { Column };

package/dist/decorator/Column.js

@@ -0,0 +1,17 @@
+import { ColumnInfoUtil } from "../util/ColumnInfoUtil.js";
+import "../util/index.js";
+import assert from "node:assert";
+
+//#region src/decorator/Column.ts
+function Column(type, params) {
+	return function(target, propertyKey) {
+		assert(typeof propertyKey === "string", `[Column/${target.name}] expect column name be typeof string, but now is ${String(propertyKey)}`);
+		const tableClazz = target.constructor;
+		const columnName = propertyKey;
+		ColumnInfoUtil.addColumnType(tableClazz, columnName, type);
+		if (params) ColumnInfoUtil.addColumnInfo(tableClazz, columnName, params);
+	};
+}
+
+//#endregion
+export { Column };

package/dist/decorator/Dao.d.ts

@@ -0,0 +1,6 @@
+import { EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/decorator/Dao.d.ts
+declare function Dao(): (constructor: EggProtoImplClass) => void;
+//#endregion
+export { Dao };

package/dist/decorator/Dao.js

@@ -0,0 +1,20 @@
+import { DaoInfoUtil } from "../util/DaoInfoUtil.js";
+import "../util/index.js";
+import { AccessLevel, ObjectInitType } from "@eggjs/tegg-types";
+import { Prototype, PrototypeUtil } from "@eggjs/core-decorator";
+import { StackUtil } from "@eggjs/tegg-common-util";
+
+//#region src/decorator/Dao.ts
+function Dao() {
+	return function(constructor) {
+		DaoInfoUtil.setIsDao(constructor);
+		Prototype({
+			accessLevel: AccessLevel.PUBLIC,
+			initType: ObjectInitType.SINGLETON
+		})(constructor);
+		PrototypeUtil.setFilePath(constructor, StackUtil.getCalleeFromStack(false, 5));
+	};
+}
+
+//#endregion
+export { Dao };

package/dist/decorator/DataSourceQualifier.d.ts

@@ -0,0 +1,4 @@
+//#region src/decorator/DataSourceQualifier.d.ts
+declare function DataSourceQualifier(dataSourceName: string): (target: any, propertyKey: PropertyKey, parameterIndex?: number) => void;
+//#endregion
+export { DataSourceQualifier };

package/dist/decorator/DataSourceQualifier.js

@@ -0,0 +1,12 @@
+import { DataSourceQualifierAttribute } from "@eggjs/tegg-types";
+import { QualifierUtil } from "@eggjs/core-decorator";
+
+//#region src/decorator/DataSourceQualifier.ts
+function DataSourceQualifier(dataSourceName) {
+	return function(target, propertyKey, parameterIndex) {
+		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, DataSourceQualifierAttribute, dataSourceName);
+	};
+}
+
+//#endregion
+export { DataSourceQualifier };

package/dist/decorator/Table.d.ts

@@ -0,0 +1,6 @@
+import { EggProtoImplClass, TableParams } from "@eggjs/tegg-types";
+
+//#region src/decorator/Table.d.ts
+declare function Table(params?: TableParams): (constructor: EggProtoImplClass) => void;
+//#endregion
+export { Table };

package/dist/decorator/Table.js

@@ -0,0 +1,21 @@
+import { TableInfoUtil } from "../util/TableInfoUtil.js";
+import "../util/index.js";
+import { AccessLevel, ObjectInitType } from "@eggjs/tegg-types";
+import { Prototype, PrototypeUtil } from "@eggjs/core-decorator";
+import { StackUtil } from "@eggjs/tegg-common-util";
+
+//#region src/decorator/Table.ts
+function Table(params) {
+	return function(constructor) {
+		TableInfoUtil.setIsTable(constructor);
+		if (params) TableInfoUtil.setTableParams(constructor, params);
+		Prototype({
+			accessLevel: AccessLevel.PUBLIC,
+			initType: ObjectInitType.ALWAYS_NEW
+		})(constructor);
+		PrototypeUtil.setFilePath(constructor, StackUtil.getCalleeFromStack(false, 5));
+	};
+}
+
+//#endregion
+export { Table };

package/dist/decorator/TableIndex.d.ts

@@ -0,0 +1,6 @@
+import { EggProtoImplClass, IndexParams } from "@eggjs/tegg-types";
+
+//#region src/decorator/TableIndex.d.ts
+declare function Index(params: IndexParams): (constructor: EggProtoImplClass) => void;
+//#endregion
+export { Index };

package/dist/decorator/TableIndex.js

@@ -0,0 +1,12 @@
+import { IndexInfoUtil } from "../util/IndexInfoUtil.js";
+import "../util/index.js";
+
+//#region src/decorator/TableIndex.ts
+function Index(params) {
+	return function(constructor) {
+		IndexInfoUtil.addIndex(constructor, params);
+	};
+}
+
+//#endregion
+export { Index };

package/dist/decorator/index.js

@@ -0,0 +1,7 @@
+import { Column } from "./Column.js";
+import { Dao } from "./Dao.js";
+import { DataSourceQualifier } from "./DataSourceQualifier.js";
+import { Table } from "./Table.js";
+import { Index } from "./TableIndex.js";
+
+export {  };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { Column } from "./decorator/Column.js";
+import { Dao } from "./decorator/Dao.js";
+import { DataSourceQualifier } from "./decorator/DataSourceQualifier.js";
+import { Table } from "./decorator/Table.js";
+import { Index } from "./decorator/TableIndex.js";
+import { ColumnModel } from "./model/ColumnModel.js";
+import { IndexKey, IndexModel } from "./model/IndexModel.js";
+import { TableModel } from "./model/TableModel.js";
+import { DeleteResult, InsertResult, UpdateResult } from "./type/MySql.js";
+import { SpatialHelper } from "./type/Spatial.js";
+import { ColumnInfoMap, ColumnInfoUtil, ColumnTypeMap } from "./util/ColumnInfoUtil.js";
+import { DaoInfoUtil } from "./util/DaoInfoUtil.js";
+import { IndexInfoUtil } from "./util/IndexInfoUtil.js";
+import { TABLE_CLAZZ_LIST, TableInfoUtil } from "./util/TableInfoUtil.js";
+export * from "@eggjs/tegg-types/dal";
+export { Column, ColumnInfoMap, ColumnInfoUtil, ColumnModel, ColumnTypeMap, Dao, DaoInfoUtil, DataSourceQualifier, DeleteResult, Index, IndexInfoUtil, IndexKey, IndexModel, InsertResult, SpatialHelper, TABLE_CLAZZ_LIST, Table, TableInfoUtil, TableModel, UpdateResult };

package/dist/index.js

@@ -0,0 +1,21 @@
+import { ColumnInfoUtil } from "./util/ColumnInfoUtil.js";
+import { DaoInfoUtil } from "./util/DaoInfoUtil.js";
+import { IndexInfoUtil } from "./util/IndexInfoUtil.js";
+import { TABLE_CLAZZ_LIST, TableInfoUtil } from "./util/TableInfoUtil.js";
+import "./util/index.js";
+import { Column } from "./decorator/Column.js";
+import { Dao } from "./decorator/Dao.js";
+import { DataSourceQualifier } from "./decorator/DataSourceQualifier.js";
+import { Table } from "./decorator/Table.js";
+import { Index } from "./decorator/TableIndex.js";
+import "./decorator/index.js";
+import { ColumnModel } from "./model/ColumnModel.js";
+import { IndexModel } from "./model/IndexModel.js";
+import { TableModel } from "./model/TableModel.js";
+import "./model/index.js";
+import { SpatialHelper } from "./type/Spatial.js";
+import "./type/index.js";
+
+export * from "@eggjs/tegg-types/dal"
+
+export { Column, ColumnInfoUtil, ColumnModel, Dao, DaoInfoUtil, DataSourceQualifier, Index, IndexInfoUtil, IndexModel, SpatialHelper, TABLE_CLAZZ_LIST, Table, TableInfoUtil, TableModel };

package/dist/model/ColumnModel.d.ts

@@ -0,0 +1,38 @@
+import { ColumnFormat, ColumnParams, ColumnTypeParams } from "@eggjs/tegg-types";
+
+//#region src/model/ColumnModel.d.ts
+declare class ColumnModel {
+  columnName: string;
+  propertyName: string;
+  type: ColumnTypeParams;
+  canNull: boolean;
+  default?: string;
+  comment?: string;
+  visible?: boolean;
+  autoIncrement?: boolean;
+  uniqueKey?: boolean;
+  primaryKey?: boolean;
+  collate?: string;
+  columnFormat?: ColumnFormat;
+  engineAttribute?: string;
+  secondaryEngineAttribute?: string;
+  constructor(params: {
+    columnName: string;
+    propertyName: string;
+    type: ColumnTypeParams;
+    canNull: boolean;
+    default?: string;
+    comment?: string;
+    visible?: boolean;
+    autoIncrement?: boolean;
+    uniqueKey?: boolean;
+    primaryKey?: boolean;
+    collate?: string;
+    columnFormat?: ColumnFormat;
+    engineAttribute?: string;
+    secondaryEngineAttribute?: string;
+  });
+  static build(property: string, type: ColumnTypeParams, params?: ColumnParams): ColumnModel;
+}
+//#endregion
+export { ColumnModel };

package/dist/model/ColumnModel.js

@@ -0,0 +1,59 @@
+import snakecase from "lodash.snakecase";
+
+//#region src/model/ColumnModel.ts
+var ColumnModel = class ColumnModel {
+	columnName;
+	propertyName;
+	type;
+	canNull;
+	default;
+	comment;
+	visible;
+	autoIncrement;
+	uniqueKey;
+	primaryKey;
+	collate;
+	columnFormat;
+	engineAttribute;
+	secondaryEngineAttribute;
+	constructor(params) {
+		this.columnName = params.columnName;
+		this.propertyName = params.propertyName;
+		this.type = params.type;
+		this.canNull = params.canNull;
+		this.default = params.default;
+		this.comment = params.comment;
+		this.visible = params.visible;
+		this.autoIncrement = params.autoIncrement;
+		this.uniqueKey = params.uniqueKey;
+		this.primaryKey = params.primaryKey;
+		this.collate = params.collate;
+		this.columnFormat = params.columnFormat;
+		this.engineAttribute = params.engineAttribute;
+		this.secondaryEngineAttribute = params.secondaryEngineAttribute;
+	}
+	static build(property, type, params) {
+		const columnName = params?.name ?? snakecase(property);
+		let canNull = params?.canNull ?? false;
+		if (params?.primaryKey) canNull = false;
+		return new ColumnModel({
+			columnName,
+			propertyName: property,
+			type,
+			canNull,
+			default: params?.default,
+			comment: params?.comment,
+			visible: params?.visible,
+			autoIncrement: params?.autoIncrement,
+			uniqueKey: params?.uniqueKey,
+			primaryKey: params?.primaryKey,
+			collate: params?.collate,
+			columnFormat: params?.columnFormat,
+			engineAttribute: params?.engineAttribute,
+			secondaryEngineAttribute: params?.secondaryEngineAttribute
+		});
+	}
+};
+
+//#endregion
+export { ColumnModel };

package/dist/model/IndexModel.d.ts

@@ -0,0 +1,32 @@
+import { ColumnModel } from "./ColumnModel.js";
+import { EggProtoImplClass, IndexParams, IndexStoreType, IndexType } from "@eggjs/tegg-types";
+
+//#region src/model/IndexModel.d.ts
+interface IndexKey {
+  columnName: string;
+  propertyName: string;
+}
+declare class IndexModel {
+  name: string;
+  keys: IndexKey[];
+  type: IndexType;
+  storeType?: IndexStoreType;
+  comment?: string;
+  engineAttribute?: string;
+  secondaryEngineAttribute?: string;
+  parser?: string;
+  constructor(params: {
+    name: string;
+    keys: IndexKey[];
+    type: IndexType;
+    storeType?: IndexStoreType;
+    comment?: string;
+    engineAttribute?: string;
+    secondaryEngineAttribute?: string;
+    parser?: string;
+  });
+  static buildIndexName(keys: string[], type: IndexType): string;
+  static build(params: IndexParams, columns: ColumnModel[], clazz: EggProtoImplClass<unknown>): IndexModel;
+}
+//#endregion
+export { IndexKey, IndexModel };

package/dist/model/IndexModel.js

@@ -0,0 +1,52 @@
+import "./ColumnModel.js";
+import { IndexType } from "@eggjs/tegg-types";
+
+//#region src/model/IndexModel.ts
+var IndexModel = class IndexModel {
+	name;
+	keys;
+	type;
+	storeType;
+	comment;
+	engineAttribute;
+	secondaryEngineAttribute;
+	parser;
+	constructor(params) {
+		this.name = params.name;
+		this.keys = params.keys;
+		this.type = params.type;
+		this.storeType = params.storeType;
+		this.comment = params.comment;
+		this.engineAttribute = params.engineAttribute;
+		this.secondaryEngineAttribute = params.secondaryEngineAttribute;
+		this.parser = params.parser;
+	}
+	static buildIndexName(keys, type) {
+		return (type === IndexType.UNIQUE ? "uk_" : "idx_") + keys.join("_");
+	}
+	static build(params, columns, clazz) {
+		const type = params.type ?? IndexType.INDEX;
+		const keys = params.keys.map((t) => {
+			const column = columns.find((c) => c.propertyName === t);
+			if (!column) throw new Error(`Table ${clazz.name} index configuration error: has no property named "${t}"`);
+			return {
+				propertyName: column.propertyName,
+				columnName: column.columnName
+			};
+		});
+		const name = params.name ?? IndexModel.buildIndexName(keys.map((t) => t.columnName), type);
+		return new IndexModel({
+			name,
+			keys,
+			type,
+			storeType: params.storeType,
+			comment: params.comment,
+			engineAttribute: params.engineAttribute,
+			secondaryEngineAttribute: params.secondaryEngineAttribute,
+			parser: params.parser
+		});
+	}
+};
+
+//#endregion
+export { IndexModel };

package/dist/model/TableModel.d.ts

@@ -0,0 +1,55 @@
+import { ColumnModel } from "./ColumnModel.js";
+import { IndexModel } from "./IndexModel.js";
+import { CompressionType, EggProtoImplClass, InsertMethod, RowFormat } from "@eggjs/tegg-types";
+
+//#region src/model/TableModel.d.ts
+declare class TableModel<T = object> {
+  clazz: EggProtoImplClass<T>;
+  name: string;
+  columns: Array<ColumnModel>;
+  indices: Array<IndexModel>;
+  dataSourceName: string;
+  comment?: string;
+  autoExtendSize?: number;
+  autoIncrement?: number;
+  avgRowLength?: number;
+  characterSet?: string;
+  collate?: string;
+  compression?: CompressionType;
+  encryption?: boolean;
+  engine?: string;
+  engineAttribute?: string;
+  insertMethod?: InsertMethod;
+  keyBlockSize?: number;
+  maxRows?: number;
+  minRows?: number;
+  rowFormat?: RowFormat;
+  secondaryEngineAttribute?: string;
+  constructor(params: {
+    clazz: EggProtoImplClass<T>;
+    name: string;
+    dataSourceName: string;
+    columns: Array<ColumnModel>;
+    indices: Array<IndexModel>;
+    comment?: string;
+    autoExtendSize?: number;
+    autoIncrement?: number;
+    avgRowLength?: number;
+    characterSet?: string;
+    collate?: string;
+    compression?: CompressionType;
+    encryption?: boolean;
+    engine?: string;
+    engineAttribute?: string;
+    insertMethod?: InsertMethod;
+    keyBlockSize?: number;
+    maxRows?: number;
+    minRows?: number;
+    rowFormat?: RowFormat;
+    secondaryEngineAttribute?: string;
+  });
+  getPrimary(): IndexModel | undefined;
+  static build<T>(clazz: EggProtoImplClass<T>): TableModel<T>;
+}
+//#endregion
+export { TableModel };

package/dist/model/TableModel.js

@@ -0,0 +1,116 @@
+import { ColumnInfoUtil } from "../util/ColumnInfoUtil.js";
+import { IndexInfoUtil } from "../util/IndexInfoUtil.js";
+import { TableInfoUtil } from "../util/TableInfoUtil.js";
+import "../util/index.js";
+import { ColumnModel } from "./ColumnModel.js";
+import { IndexModel } from "./IndexModel.js";
+import assert from "node:assert";
+import { IndexType } from "@eggjs/tegg-types";
+import snakecase from "lodash.snakecase";
+import pluralize from "pluralize";
+
+//#region src/model/TableModel.ts
+var TableModel = class TableModel {
+	clazz;
+	name;
+	columns;
+	indices;
+	dataSourceName;
+	comment;
+	autoExtendSize;
+	autoIncrement;
+	avgRowLength;
+	characterSet;
+	collate;
+	compression;
+	encryption;
+	engine;
+	engineAttribute;
+	insertMethod;
+	keyBlockSize;
+	maxRows;
+	minRows;
+	rowFormat;
+	secondaryEngineAttribute;
+	constructor(params) {
+		this.clazz = params.clazz;
+		this.name = params.name;
+		this.dataSourceName = params.dataSourceName;
+		this.columns = params.columns;
+		this.indices = params.indices;
+		this.comment = params.comment;
+		this.autoExtendSize = params.autoExtendSize;
+		this.autoIncrement = params.autoIncrement;
+		this.avgRowLength = params.avgRowLength;
+		this.characterSet = params.characterSet;
+		this.collate = params.collate;
+		this.compression = params.compression;
+		this.encryption = params.encryption;
+		this.engine = params.engine;
+		this.engineAttribute = params.engineAttribute;
+		this.insertMethod = params.insertMethod;
+		this.keyBlockSize = params.keyBlockSize;
+		this.maxRows = params.maxRows;
+		this.minRows = params.minRows;
+		this.rowFormat = params.rowFormat;
+		this.secondaryEngineAttribute = params.secondaryEngineAttribute;
+	}
+	getPrimary() {
+		const index = this.indices.find((t) => t.type === IndexType.PRIMARY);
+		if (index) return index;
+		const primaryColumn = this.columns.filter((t) => t.primaryKey === true);
+		return new IndexModel({
+			name: "PRIMARY",
+			type: IndexType.PRIMARY,
+			keys: primaryColumn.map((t) => {
+				return {
+					columnName: t.columnName,
+					propertyName: t.propertyName
+				};
+			})
+		});
+	}
+	static build(clazz) {
+		const params = TableInfoUtil.getTableParams(clazz);
+		const name = params?.name ?? snakecase(pluralize(clazz.name));
+		const columnInfoMap = ColumnInfoUtil.getColumnInfoMap(clazz);
+		const columnTypeMap = ColumnInfoUtil.getColumnTypeMap(clazz);
+		const dataSourceName = params?.dataSourceName ?? "default";
+		assert(TableInfoUtil.getIsTable(clazz), `${name} is not Table`);
+		assert(columnTypeMap, `${name} has no columns`);
+		const columns = [];
+		const indices = [];
+		for (const [property, columnType] of columnTypeMap?.entries() ?? []) {
+			const columnParam = columnInfoMap?.get(property);
+			columns.push(ColumnModel.build(property, columnType, columnParam));
+		}
+		const indexList = IndexInfoUtil.getIndexList(clazz);
+		for (const index of indexList) indices.push(IndexModel.build(index, columns, clazz));
+		return new TableModel({
+			clazz,
+			name,
+			columns,
+			indices,
+			dataSourceName,
+			comment: params?.comment,
+			autoExtendSize: params?.autoExtendSize,
+			autoIncrement: params?.autoIncrement,
+			avgRowLength: params?.avgRowLength,
+			characterSet: params?.characterSet,
+			collate: params?.collate,
+			compression: params?.compression,
+			encryption: params?.encryption,
+			engine: params?.engine,
+			engineAttribute: params?.engineAttribute,
+			insertMethod: params?.insertMethod,
+			keyBlockSize: params?.keyBlockSize,
+			maxRows: params?.maxRows,
+			minRows: params?.minRows,
+			rowFormat: params?.rowFormat,
+			secondaryEngineAttribute: params?.secondaryEngineAttribute
+		});
+	}
+};
+
+//#endregion
+export { TableModel };

package/dist/model/index.js

@@ -0,0 +1,5 @@
+import { ColumnModel } from "./ColumnModel.js";
+import { IndexModel } from "./IndexModel.js";
+import { TableModel } from "./TableModel.js";
+
+export {  };

package/dist/type/MySql.d.ts

@@ -0,0 +1,2 @@
+import { DeleteResult, InsertResult, UpdateResult } from "@eggjs/rds";
+export { type DeleteResult, type InsertResult, type UpdateResult };

package/dist/type/Spatial.d.ts

@@ -0,0 +1,14 @@
+import { ColumnType, Geometry, GeometryCollection } from "@eggjs/tegg-types";
+
+//#region src/type/Spatial.d.ts
+declare class SpatialHelper {
+  static isPoint(t: Geometry): boolean;
+  static isLine(t: Geometry): boolean;
+  static isPolygon(t: Geometry): boolean;
+  static getGeometryType(t: Geometry): ColumnType.POINT | ColumnType.LINESTRING | ColumnType.POLYGON;
+  static isMultiPoint(t: GeometryCollection): boolean;
+  static isMultiLine(t: GeometryCollection): boolean;
+  static isMultiPolygon(t: GeometryCollection): boolean;
+}
+//#endregion
+export { SpatialHelper };

package/dist/type/Spatial.js

@@ -0,0 +1,31 @@
+import { ColumnType } from "@eggjs/tegg-types";
+
+//#region src/type/Spatial.ts
+var SpatialHelper = class SpatialHelper {
+	static isPoint(t) {
+		return typeof Reflect.get(t, "x") === "number" && typeof Reflect.get(t, "y") === "number";
+	}
+	static isLine(t) {
+		return Array.isArray(t) && t[0] && SpatialHelper.isPoint(t[0]);
+	}
+	static isPolygon(t) {
+		return Array.isArray(t) && t[0] && SpatialHelper.isLine(t[0]);
+	}
+	static getGeometryType(t) {
+		if (SpatialHelper.isPoint(t)) return ColumnType.POINT;
+		else if (SpatialHelper.isLine(t)) return ColumnType.LINESTRING;
+		return ColumnType.POLYGON;
+	}
+	static isMultiPoint(t) {
+		return Array.isArray(t) && t[0] && SpatialHelper.isPoint(t[0]);
+	}
+	static isMultiLine(t) {
+		return Array.isArray(t) && t[0] && SpatialHelper.isLine(t[0]);
+	}
+	static isMultiPolygon(t) {
+		return Array.isArray(t) && t[0] && SpatialHelper.isPolygon(t[0]);
+	}
+};
+
+//#endregion
+export { SpatialHelper };

package/dist/type/index.js

@@ -0,0 +1,3 @@
+import { SpatialHelper } from "./Spatial.js";
+
+export {  };

package/dist/util/ColumnInfoUtil.d.ts

@@ -0,0 +1,13 @@
+import { ColumnParams, ColumnTypeParams, EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/util/ColumnInfoUtil.d.ts
+type ColumnInfoMap = Map<string, ColumnParams>;
+type ColumnTypeMap = Map<string, ColumnTypeParams>;
+declare class ColumnInfoUtil {
+  static addColumnInfo(clazz: EggProtoImplClass, property: string, column: ColumnInfoUtil): void;
+  static addColumnType(clazz: EggProtoImplClass, property: string, type: ColumnTypeParams): void;
+  static getColumnInfoMap(clazz: EggProtoImplClass): ColumnInfoMap | undefined;
+  static getColumnTypeMap(clazz: EggProtoImplClass): ColumnTypeMap | undefined;
+}
+//#endregion
+export { ColumnInfoMap, ColumnInfoUtil, ColumnTypeMap };

package/dist/util/ColumnInfoUtil.js

@@ -0,0 +1,21 @@
+import { DAL_COLUMN_INFO_MAP, DAL_COLUMN_TYPE_MAP } from "@eggjs/tegg-types";
+import { MetadataUtil } from "@eggjs/core-decorator";
+
+//#region src/util/ColumnInfoUtil.ts
+var ColumnInfoUtil = class {
+	static addColumnInfo(clazz, property, column) {
+		MetadataUtil.initOwnMapMetaData(DAL_COLUMN_INFO_MAP, clazz, /* @__PURE__ */ new Map()).set(property, column);
+	}
+	static addColumnType(clazz, property, type) {
+		MetadataUtil.initOwnMapMetaData(DAL_COLUMN_TYPE_MAP, clazz, /* @__PURE__ */ new Map()).set(property, type);
+	}
+	static getColumnInfoMap(clazz) {
+		return MetadataUtil.getMetaData(DAL_COLUMN_INFO_MAP, clazz);
+	}
+	static getColumnTypeMap(clazz) {
+		return MetadataUtil.getMetaData(DAL_COLUMN_TYPE_MAP, clazz);
+	}
+};
+
+//#endregion
+export { ColumnInfoUtil };

package/dist/util/DaoInfoUtil.d.ts

@@ -0,0 +1,9 @@
+import { BaseDaoType, EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/util/DaoInfoUtil.d.ts
+declare class DaoInfoUtil {
+  static setIsDao(clazz: EggProtoImplClass): void;
+  static getIsDao(clazz: EggProtoImplClass): clazz is BaseDaoType;
+}
+//#endregion
+export { DaoInfoUtil };