@eggjs/dal-runtime 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/index.js

@@ -1,16 +1,1267 @@
-import { TemplateUtil } from "./TemplateUtil.js";
-import { BaseSqlMapGenerator } from "./BaseSqlMap.js";
-import { SqlGenerator } from "./SqlGenerator.js";
-import { CodeGenerator } from "./CodeGenerator.js";
-import { DaoLoader } from "./DaoLoader.js";
-import { MysqlDataSource } from "./MySqlDataSource.js";
-import { DatabaseForker } from "./DatabaseForker.js";
-import { NunjucksConverter } from "./NunjucksConverter.js";
-import { SqlUtil } from "./SqlUtil.js";
-import { NunjucksUtils } from "./NunjucksUtil.js";
-import { TableSqlMap } from "./TableSqlMap.js";
-import { TableModelInstanceBuilder } from "./TableModelInstanceBuilder.js";
-import { DataSource } from "./DataSource.js";
-import { SqlMapLoader } from "./SqlMapLoader.js";
+import _ from "lodash";
+import { ColumnModel, DaoInfoUtil, SpatialHelper, TableModel } from "@eggjs/dal-decorator";
+import { ColumnType, EggLoadUnitType, IndexType, SqlType, Templates } from "@eggjs/tegg-types";
+import path from "node:path";
+import fs from "node:fs/promises";
+import js_beautify from "js-beautify";
+import nunjucks, { Template } from "nunjucks";
+import { PrototypeUtil } from "@eggjs/core-decorator";
+import "@eggjs/tegg-types/dal";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+import assert from "node:assert";
+import { RDSClient } from "@eggjs/rds";
+import { Base } from "sdk-base";
+import sqlstring from "sqlstring";
 
+//#region src/TemplateUtil.ts
+var TemplateUtil = class TemplateUtil {
+	static isSpatialType(columnModel) {
+		switch (columnModel.type.type) {
+			case ColumnType.GEOMETRY:
+			case ColumnType.POINT:
+			case ColumnType.LINESTRING:
+			case ColumnType.POLYGON:
+			case ColumnType.MULTIPOINT:
+			case ColumnType.MULTILINESTRING:
+			case ColumnType.MULTIPOLYGON:
+			case ColumnType.GEOMETRYCOLLECTION: return true;
+			default: return false;
+		}
+	}
+	static importPath(tableModelPath, currentPath) {
+		return path.relative(currentPath, tableModelPath);
+	}
+	static dbTypeToTsType(columnType) {
+		return `ColumnTsType['${columnType}']`;
+	}
+	static toJson(value) {
+		return JSON.stringify(JSON.stringify(value));
+	}
+	static toPoint(point) {
+		if (typeof point.x !== "number" || typeof point.y !== "number") throw new Error(`invalidate point ${JSON.stringify(point)}`);
+		return `Point(${point.x}, ${point.y})`;
+	}
+	static toLine(val) {
+		return `LINESTRING(${val.map((t) => TemplateUtil.toPoint(t)).join(",")})`;
+	}
+	static toPolygon(val) {
+		return `POLYGON(${val.map((t) => TemplateUtil.toLine(t)).join(",")})`;
+	}
+	static toGeometry(val) {
+		const type = SpatialHelper.getGeometryType(val);
+		const filterName = TemplateUtil.getSpatialFilter(type);
+		return TemplateUtil[filterName](val);
+	}
+	static toMultiPoint(val) {
+		return `MULTIPOINT(${val.map((t) => TemplateUtil.toPoint(t)).join(",")})`;
+	}
+	static toMultiLine(val) {
+		return `MULTILINESTRING(${val.map((t) => TemplateUtil.toLine(t)).join(",")})`;
+	}
+	static toMultiPolygon(val) {
+		return `MULTIPOLYGON(${val.map((t) => TemplateUtil.toPolygon(t)).join(",")})`;
+	}
+	static toGeometryCollection(val) {
+		return `GEOMETRYCOLLECTION(${val.map((t) => {
+			return TemplateUtil.toGeometry(t);
+		}).join(",")})`;
+	}
+	static {
+		this.spatialFilter = {
+			[ColumnType.POINT]: "toPoint",
+			[ColumnType.LINESTRING]: "toLine",
+			[ColumnType.POLYGON]: "toPolygon",
+			[ColumnType.GEOMETRY]: "toGeometry",
+			[ColumnType.MULTIPOINT]: "toMultiPoint",
+			[ColumnType.MULTILINESTRING]: "toMultiLine",
+			[ColumnType.MULTIPOLYGON]: "toMultiPolygon",
+			[ColumnType.GEOMETRYCOLLECTION]: "toGeometryCollection"
+		};
+	}
+	static getSpatialFilter(columnType) {
+		const filter = TemplateUtil.spatialFilter[columnType];
+		if (!filter) throw new Error(`type ${columnType} is not spatial type`);
+		return filter;
+	}
+};
+
+//#endregion
+//#region src/BaseSqlMap.ts
+var BaseSqlMapGenerator = class {
+	constructor(tableModel, logger) {
+		this.tableModel = tableModel;
+		this.logger = logger;
+	}
+	generateAllColumns(countIf) {
+		const str = this.tableModel.columns.map((t) => `\`${t.columnName}\``).join(",");
+		return countIf ? `{% if $$count == true %}0{% else %}${str}{% endif %}` : str;
+	}
+	generateFindByPrimary() {
+		const result = [];
+		const primary = this.tableModel.getPrimary();
+		if (!primary) {
+			this.logger.warn(`表 \`${this.tableModel.name}\` 没有主键，无法生成主键查询语句。`);
+			return result;
+		}
+		let sql = `SELECT ${this.generateAllColumns(true)}
+               FROM \`${this.tableModel.name}\`
+               WHERE `;
+		sql += primary.keys.map((indexKey) => `\`${indexKey.columnName}\` = {{$${indexKey.propertyName}}}`).join(" AND ");
+		if (primary.keys.length === 1) result.push({
+			type: SqlType.SELECT,
+			name: `findBy${_.upperFirst(primary.keys[0].propertyName)}`,
+			sql
+		});
+		result.push({
+			name: "findByPrimary",
+			type: SqlType.SELECT,
+			sql
+		});
+		return result;
+	}
+	generateFindByIndexes() {
+		const sqlMaps = [];
+		for (const index of this.tableModel.indices) {
+			if (index.type === IndexType.PRIMARY) continue;
+			let sql = `SELECT ${this.generateAllColumns(true)}
+                 FROM \`${this.tableModel.name}\`
+                 WHERE `;
+			sql += index.keys.map((indexKey) => {
+				return `\`${indexKey.columnName}\` {{ "IS" if $${indexKey.propertyName} == null else "=" }} {{$${indexKey.propertyName}}}`;
+			}).join(" AND ");
+			const tempName = _.upperFirst(_.camelCase(index.keys.length === 1 ? index.keys[0].propertyName : index.name));
+			sqlMaps.push({
+				name: `findBy${tempName}`,
+				type: SqlType.SELECT,
+				sql
+			});
+			sqlMaps.push({
+				name: `findOneBy${tempName}`,
+				type: SqlType.SELECT,
+				sql: `${sql} LIMIT 0, 1`
+			});
+		}
+		return sqlMaps;
+	}
+	generateInsert() {
+		let sql = `INSERT INTO \`${this.tableModel.name}\` `;
+		sql += "{% set ___first = true %}";
+		const keys = [];
+		const values = [];
+		for (const column of this.tableModel.columns) {
+			const { propertyName, columnName, type } = column;
+			if (column.propertyName !== "gmtCreate" && column.propertyName !== "gmtModified") {
+				keys.push(`
+        {% if $${propertyName} !== undefined %}
+          {% if ___first %}
+            {% set ___first = false %}
+          {% else %}
+          ,
+          {% endif %}
+
+          \`${columnName}\`
+        {% endif %}
+        `.trim());
+				if (TemplateUtil.isSpatialType(column)) {
+					const filter = TemplateUtil.getSpatialFilter(column.type.type);
+					values.push(`
+        {% if $${propertyName} !== undefined %}
+          {% if ___first %}
+            {% set ___first = false %}
+          {% else %}
+          ,
+          {% endif %}
+
+          {{$${propertyName} | ${filter}}}
+        {% endif %}
+        `.trim());
+				} else if (column.type.type === ColumnType.JSON) values.push(`
+        {% if $${propertyName} !== undefined %}
+          {% if ___first %}
+            {% set ___first = false %}
+          {% else %}
+          ,
+          {% endif %}
+
+          {{$${propertyName} | toJson}}
+        {% endif %}
+        `.trim());
+				else values.push(`
+        {% if $${propertyName} !== undefined %}
+          {% if ___first %}
+            {% set ___first = false %}
+          {% else %}
+          ,
+          {% endif %}
+
+          {{$${propertyName}}}
+        {% endif %}
+        `.trim());
+			} else {
+				let now;
+				if (type.type === ColumnType.INT) now = "UNIX_TIMESTAMP()";
+				else if (type.type === ColumnType.BIGINT) now = "ROUND(UNIX_TIMESTAMP(CURTIME(4)) * 1000)";
+				else if (type.type === ColumnType.DATETIME || type.type === ColumnType.TIMESTAMP) now = type.precision ? `NOW(${type.precision})` : "NOW()";
+				else this.logger.warn(`unknown type ${type.type} for ${propertyName}`);
+				keys.push(`
+        {% if ___first %}
+          {% set ___first = false %}
+        {% else %}
+        ,
+        {% endif %}
+
+        \`${columnName}\`
+        `.trim());
+				values.push(`
+        {% if ___first %}
+          {% set ___first = false %}
+        {% else %}
+        ,
+        {% endif %}
+
+        {{ $${propertyName} if $${propertyName} !== undefined else '${now}' }}
+        `.trim());
+			}
+		}
+		sql += `(${keys.join("")})`;
+		sql += "{% set ___first = true %}";
+		sql += `VALUES(${values.join("")});`;
+		return sql;
+	}
+	generateUpdate() {
+		const primary = this.tableModel.getPrimary();
+		if (!primary) {
+			this.logger.warn(`表 \`${this.tableModel.name}\` 没有主键，无法生成主键更新语句。`);
+			return;
+		}
+		let sql = `UPDATE \`${this.tableModel.name}\` SET`;
+		sql += "{% set ___first = true %}";
+		const kv = [];
+		for (const column of this.tableModel.columns) {
+			const { type, propertyName, columnName } = column;
+			let now;
+			if (type.type === ColumnType.INT) now = "UNIX_TIMESTAMP()";
+			else if (type.type === ColumnType.BIGINT) now = "ROUND(UNIX_TIMESTAMP(CURTIME(4)) * 1000)";
+			else if (type.type === ColumnType.TIMESTAMP || type.type === ColumnType.DATETIME) now = type.precision ? `NOW(${type.precision})` : "NOW()";
+			const temp = propertyName !== "gmtModified" ? `
+      {% if $${propertyName} !== undefined %}
+        {% if ___first %}
+          {% set ___first = false %}
+        {% else %}
+        ,
+        {% endif %}
+
+        \`${columnName}\` = {{$${propertyName}}}
+      {% endif %}
+      ` : `
+      {% if ___first %}
+        {% set ___first = false %}
+      {% else %}
+      ,
+      {% endif %}
+
+      \`${columnName}\` =
+      {{ $${propertyName} if $${propertyName} !== undefined else '${now}' }}
+      `;
+			kv.push(temp);
+		}
+		sql += kv.join("");
+		sql += `WHERE ${primary.keys.map((indexKey) => `\`${indexKey.columnName}\` = {{primary.${indexKey.propertyName}}}`).join(" AND ")}`;
+		return sql;
+	}
+	generateDelete() {
+		const primary = this.tableModel.getPrimary();
+		if (!primary) {
+			this.logger.warn(`表 \`${this.tableModel.name}\` 没有主键，无法生成主键删除语句。`);
+			return;
+		}
+		let sql = `DELETE
+               FROM \`${this.tableModel.name}\`
+               WHERE `;
+		sql += primary.keys.map((indexKey) => `\`${indexKey.columnName}\` = {{${indexKey.propertyName}}}`).join(" AND ");
+		return sql;
+	}
+	load() {
+		const map = {};
+		map.allColumns = {
+			type: SqlType.BLOCK,
+			content: this.generateAllColumns(false)
+		};
+		const sqlMaps = [
+			...this.generateFindByPrimary(),
+			...this.generateFindByIndexes(),
+			(
+			/**
+			* 插入
+			*/
+			{
+				name: "insert",
+				type: SqlType.INSERT,
+				sql: this.generateInsert()
+			}),
+			(
+			/**
+			* 主键更新
+			*/
+			{
+				name: "update",
+				type: SqlType.UPDATE,
+				sql: this.generateUpdate()
+			}),
+			(
+			/**
+			* 主键删除
+			*/
+			{
+				name: "delete",
+				type: SqlType.DELETE,
+				sql: this.generateDelete()
+			})
+		];
+		for (const sqlMap of sqlMaps) map[sqlMap.name] = {
+			type: sqlMap.type,
+			sql: sqlMap.sql
+		};
+		return map;
+	}
+};
+
+//#endregion
+//#region src/SqlGenerator.ts
+var SqlGenerator = class {
+	formatComment(comment) {
+		return comment.replace(/\n/g, "\\n");
+	}
+	generateColumn(column) {
+		const sqls = [
+			" ",
+			column.columnName,
+			this.generateColumnType(column.type)
+		];
+		if (column.canNull) sqls.push("NULL");
+		else sqls.push("NOT NULL");
+		if ([
+			ColumnType.POINT,
+			ColumnType.GEOMETRY,
+			ColumnType.POINT,
+			ColumnType.LINESTRING,
+			ColumnType.POLYGON,
+			ColumnType.MULTIPOINT,
+			ColumnType.MULTILINESTRING,
+			ColumnType.MULTIPOLYGON,
+			ColumnType.GEOMETRYCOLLECTION
+		].includes(column.type.type)) {
+			const SRID = column.type.SRID;
+			if (SRID) sqls.push(`SRID ${SRID}`);
+		}
+		if (typeof column.default !== "undefined") sqls.push(`DEFAULT ${column.default}`);
+		if (column.autoIncrement) sqls.push("AUTO_INCREMENT");
+		if (column.uniqueKey) sqls.push("UNIQUE KEY");
+		if (column.primaryKey) sqls.push("PRIMARY KEY");
+		if (column.comment) sqls.push(`COMMENT '${this.formatComment(column.comment)}'`);
+		if (column.collate) sqls.push(`COLLATE ${column.collate}`);
+		if (column.columnFormat) sqls.push(`COLUMN_FORMAT ${column.columnFormat}`);
+		if (column.engineAttribute) sqls.push(`ENGINE_ATTRIBUTE='${column.engineAttribute}'`);
+		if (column.secondaryEngineAttribute) sqls.push(`SECONDARY_ENGINE_ATTRIBUTE='${column.secondaryEngineAttribute}'`);
+		return sqls.join(" ");
+	}
+	generateColumnType(columnType) {
+		const sqls = [];
+		switch (columnType.type) {
+			case ColumnType.BOOL:
+				sqls.push("BOOL");
+				break;
+			case ColumnType.BIT:
+				if (columnType.length) sqls.push(`BIT(${columnType.length})`);
+				else sqls.push("BIT");
+				break;
+			case ColumnType.TINYINT:
+			case ColumnType.SMALLINT:
+			case ColumnType.MEDIUMINT:
+			case ColumnType.INT:
+			case ColumnType.BIGINT:
+				if (typeof columnType.length === "number") sqls.push(`${columnType.type}(${columnType.length})`);
+				else sqls.push(columnType.type);
+				if (columnType.unsigned) sqls.push("UNSIGNED");
+				if (columnType.zeroFill) sqls.push("ZEROFILL");
+				break;
+			case ColumnType.DECIMAL:
+			case ColumnType.FLOAT:
+			case ColumnType.DOUBLE:
+				if (typeof columnType.length === "number" && typeof columnType.fractionalLength === "number") sqls.push(`${columnType.type}(${columnType.length},${columnType.fractionalLength})`);
+				else if (typeof columnType.length === "number") sqls.push(`${columnType.type}(${columnType.length})`);
+				else sqls.push("TINYINT");
+				if (columnType.unsigned) sqls.push("UNSIGNED");
+				if (columnType.zeroFill) sqls.push("ZEROFILL");
+				break;
+			case ColumnType.DATE:
+				sqls.push("DATE");
+				break;
+			case ColumnType.DATETIME:
+			case ColumnType.TIMESTAMP:
+				if (columnType.precision) sqls.push(`${columnType.type}(${columnType.precision})`);
+				else sqls.push(columnType.type);
+				if (columnType.autoUpdate) if (columnType.precision) sqls.push(`ON UPDATE CURRENT_TIMESTAMP(${columnType.precision})`);
+				else sqls.push("ON UPDATE CURRENT_TIMESTAMP");
+				break;
+			case ColumnType.TIME:
+				if (columnType.precision) sqls.push(`${columnType.type}(${columnType.precision})`);
+				else sqls.push(columnType.type);
+				break;
+			case ColumnType.YEAR:
+				sqls.push("YEAR");
+				break;
+			case ColumnType.CHAR:
+			case ColumnType.TEXT:
+				if (columnType.length) sqls.push(`${columnType.type}(${columnType.length})`);
+				else sqls.push(columnType.type);
+				if (columnType.characterSet) sqls.push(`CHARACTER SET ${columnType.characterSet}`);
+				if (columnType.collate) sqls.push(`COLLATE ${columnType.collate}`);
+				break;
+			case ColumnType.VARCHAR:
+				sqls.push(`${columnType.type}(${columnType.length})`);
+				if (columnType.characterSet) sqls.push(`CHARACTER SET ${columnType.characterSet}`);
+				if (columnType.collate) sqls.push(`COLLATE ${columnType.collate}`);
+				break;
+			case ColumnType.BINARY:
+				if (columnType.length) sqls.push(`${columnType.type}(${columnType.length})`);
+				else sqls.push(columnType.type);
+				break;
+			case ColumnType.VARBINARY:
+				sqls.push(`${columnType.type}(${columnType.length})`);
+				break;
+			case ColumnType.TINYBLOB:
+				sqls.push("TINYBLOB");
+				break;
+			case ColumnType.TINYTEXT:
+			case ColumnType.MEDIUMTEXT:
+			case ColumnType.LONGTEXT:
+				sqls.push(columnType.type);
+				if (columnType.characterSet) sqls.push(`CHARACTER SET ${columnType.characterSet}`);
+				if (columnType.collate) sqls.push(`COLLATE ${columnType.collate}`);
+				break;
+			case ColumnType.BLOB:
+				if (columnType.length) sqls.push(`${columnType.type}(${columnType.length})`);
+				else sqls.push(columnType.type);
+				break;
+			case ColumnType.MEDIUMBLOB:
+				sqls.push("MEDIUMBLOB");
+				break;
+			case ColumnType.LONGBLOB:
+				sqls.push("LONGBLOB");
+				break;
+			case ColumnType.ENUM: {
+				const enumValue = columnType.enums.map((t) => `'${t}'`).join(",");
+				sqls.push(`ENUM(${enumValue})`);
+				if (columnType.characterSet) sqls.push(`CHARACTER SET ${columnType.characterSet}`);
+				if (columnType.collate) sqls.push(`COLLATE ${columnType.collate}`);
+				break;
+			}
+			case ColumnType.SET: {
+				const enumValue = columnType.enums.map((t) => `'${t}'`).join(",");
+				sqls.push(`SET(${enumValue})`);
+				if (columnType.characterSet) sqls.push(`CHARACTER SET ${columnType.characterSet}`);
+				if (columnType.collate) sqls.push(`COLLATE ${columnType.collate}`);
+				break;
+			}
+			case ColumnType.JSON:
+				sqls.push("JSON");
+				break;
+			case ColumnType.GEOMETRY:
+			case ColumnType.POINT:
+			case ColumnType.LINESTRING:
+			case ColumnType.POLYGON:
+			case ColumnType.MULTIPOINT:
+			case ColumnType.MULTILINESTRING:
+			case ColumnType.MULTIPOLYGON:
+			case ColumnType.GEOMETRYCOLLECTION:
+				sqls.push(columnType.type);
+				break;
+			default: throw new Error(`unknown ColumnType ${columnType}`);
+		}
+		return sqls.join(" ");
+	}
+	generateIndex(indexModel) {
+		const indexSql = [" "];
+		switch (indexModel.type) {
+			case IndexType.INDEX:
+				indexSql.push("KEY");
+				break;
+			case IndexType.UNIQUE:
+				indexSql.push("UNIQUE KEY");
+				break;
+			case IndexType.PRIMARY:
+				indexSql.push("PRIMARY KEY");
+				break;
+			case IndexType.FULLTEXT:
+				indexSql.push("FULLTEXT KEY");
+				break;
+			case IndexType.SPATIAL:
+				indexSql.push("SPATIAL KEY");
+				break;
+			default: throw new Error(`unknown IndexType ${indexModel.type}`);
+		}
+		indexSql.push(indexModel.name);
+		indexSql.push(`(${indexModel.keys.map((t) => t.columnName).join(",")})`);
+		if (indexModel.storeType) indexSql.push(`USING ${indexModel.storeType}`);
+		if (indexModel.parser) indexSql.push(`WITH PARSER ${indexModel.parser}`);
+		if (indexModel.comment) indexSql.push(`COMMENT '${this.formatComment(indexModel.comment)}'`);
+		if (indexModel.engineAttribute) indexSql.push(`ENGINE_ATTRIBUTE='${indexModel.engineAttribute}'`);
+		if (indexModel.secondaryEngineAttribute) indexSql.push(`SECONDARY_ENGINE_ATTRIBUTE='${indexModel.secondaryEngineAttribute}'`);
+		return indexSql.join(" ");
+	}
+	generateTableOptions(tableModel) {
+		const sqls = [];
+		if (tableModel.autoExtendSize) sqls.push(`AUTOEXTEND_SIZE=${tableModel.autoExtendSize}`);
+		if (tableModel.autoIncrement) sqls.push(`AUTO_INCREMENT=${tableModel.autoIncrement}`);
+		if (tableModel.avgRowLength) sqls.push(`AVG_ROW_LENGTH=${tableModel.avgRowLength}`);
+		if (tableModel.characterSet) sqls.push(`DEFAULT CHARACTER SET ${tableModel.characterSet}`);
+		if (tableModel.collate) sqls.push(`DEFAULT COLLATE ${tableModel.collate}`);
+		if (tableModel.comment) sqls.push(`COMMENT='${this.formatComment(tableModel.comment)}'`);
+		if (tableModel.compression) sqls.push(`COMPRESSION='${tableModel.compression}'`);
+		if (typeof tableModel.encryption !== "undefined") sqls.push(`ENCRYPTION='${tableModel.encryption ? "Y" : "N"}'`);
+		if (typeof tableModel.engine !== "undefined") sqls.push(`ENGINE=${tableModel.engine}`);
+		if (tableModel.engineAttribute) sqls.push(`ENGINE_ATTRIBUTE='${tableModel.engineAttribute}'`);
+		if (tableModel.secondaryEngineAttribute) sqls.push(`SECONDARY_ENGINE_ATTRIBUTE = '${tableModel.secondaryEngineAttribute}'`);
+		if (tableModel.insertMethod) sqls.push(`INSERT_METHOD=${tableModel.insertMethod}`);
+		if (tableModel.keyBlockSize) sqls.push(`KEY_BLOCK_SIZE=${tableModel.keyBlockSize}`);
+		if (tableModel.maxRows) sqls.push(`MAX_ROWS=${tableModel.maxRows}`);
+		if (tableModel.minRows) sqls.push(`MIN_ROWS=${tableModel.minRows}`);
+		if (tableModel.rowFormat) sqls.push(`ROW_FORMAT=${tableModel.rowFormat}`);
+		return sqls.join(", ");
+	}
+	generate(tableModel) {
+		const createSql = [];
+		createSql.push(`CREATE TABLE IF NOT EXISTS ${tableModel.name} (`);
+		const columnSql = [];
+		for (const column of tableModel.columns) columnSql.push(this.generateColumn(column));
+		const indexSql = [];
+		for (const index of tableModel.indices) indexSql.push(this.generateIndex(index));
+		if (indexSql.length) {
+			createSql.push(columnSql.join(",\n") + ",");
+			createSql.push(indexSql.join(",\n"));
+		} else createSql.push(columnSql.join(",\n"));
+		createSql.push(`) ${this.generateTableOptions(tableModel)};`);
+		return createSql.join("\n");
+	}
+};
+
+//#endregion
+//#region src/CodeGenerator.ts
+var CodeGenerator = class {
+	constructor(options) {
+		this.moduleDir = options.moduleDir;
+		this.moduleName = options.moduleName;
+		this.teggPkg = options.teggPkg ?? "@eggjs/tegg";
+		this.dalPkg = options.dalPkg ?? "@eggjs/tegg/dal";
+		this.createNunjucksEnv();
+	}
+	createNunjucksEnv() {
+		this.njkEnv = nunjucks.configure(path.join(__dirname, "./templates"), { autoescape: false });
+		this.njkEnv.addFilter("pascalCase", (name) => _.upperFirst(_.camelCase(name)));
+		this.njkEnv.addFilter("camelCase", (name) => _.camelCase(name));
+		this.njkEnv.addFilter("dbTypeToTSType", TemplateUtil.dbTypeToTsType);
+	}
+	genCode(tplName, filePath, tableModel) {
+		let tableModelAbsolutePath = PrototypeUtil.getFilePath(tableModel.clazz);
+		tableModelAbsolutePath = tableModelAbsolutePath.substring(0, tableModelAbsolutePath.length - 3);
+		const data = {
+			table: tableModel,
+			file: filePath,
+			fileName: path.basename(filePath),
+			clazzName: tableModel.clazz.name,
+			moduleName: this.moduleName,
+			teggPkg: this.teggPkg,
+			dalPkg: this.dalPkg,
+			id: tableModel.columns.find((t) => t.propertyName === "id"),
+			primaryIndex: tableModel.getPrimary(),
+			tableModelPath: TemplateUtil.importPath(tableModelAbsolutePath, path.dirname(filePath)),
+			extensionPath: `../../extension/${tableModel.clazz.name}Extension`,
+			structurePath: `../../structure/${tableModel.clazz.name}.json`,
+			sqlPath: `../../structure/${tableModel.clazz.name}.sql`,
+			columnMap: tableModel.columns.reduce((p, c) => {
+				p[c.propertyName] = c;
+				return p;
+			}, {})
+		};
+		return this.njkEnv.render(`${tplName}.njk`, data);
+	}
+	async generate(tableModel) {
+		let dalDir;
+		try {
+			await fs.access(path.join(this.moduleDir, "src"));
+			dalDir = path.join(this.moduleDir, "src/dal");
+		} catch {
+			dalDir = path.join(this.moduleDir, "dal");
+		}
+		const clazzFileName = path.basename(PrototypeUtil.getFilePath(tableModel.clazz));
+		const baseFileName = path.basename(clazzFileName, ".ts");
+		const paths = {
+			baseBizDAO: path.join(dalDir, `dao/base/Base${baseFileName}DAO.ts`),
+			bizDAO: path.join(dalDir, `dao/${baseFileName}DAO.ts`),
+			extension: path.join(dalDir, `extension/${baseFileName}Extension.ts`),
+			structure: path.join(dalDir, `structure/${baseFileName}.json`),
+			structureSql: path.join(dalDir, `structure/${baseFileName}.sql`)
+		};
+		await fs.mkdir(path.dirname(paths.structure), { recursive: true });
+		await fs.writeFile(paths.structure, JSON.stringify(tableModel, null, 2), "utf8");
+		const structureSql = new SqlGenerator().generate(tableModel);
+		await fs.writeFile(paths.structureSql, structureSql, "utf8");
+		const codes = [
+			{
+				templates: Templates.BASE_DAO,
+				filePath: paths.baseBizDAO,
+				beautify: true,
+				overwrite: true
+			},
+			{
+				templates: Templates.DAO,
+				filePath: paths.bizDAO,
+				beautify: true,
+				overwrite: false
+			},
+			{
+				templates: Templates.EXTENSION,
+				filePath: paths.extension,
+				beautify: false,
+				overwrite: false
+			}
+		];
+		for (const { templates, filePath, beautify, overwrite } of codes) {
+			await fs.mkdir(path.dirname(filePath), { recursive: true });
+			const code = this.genCode(templates, filePath, tableModel);
+			let beautified;
+			if (beautify) beautified = js_beautify(code, {
+				brace_style: "preserve-inline",
+				indent_size: 2,
+				jslint_happy: true,
+				preserve_newlines: false
+			});
+			else beautified = code;
+			beautified = beautified.replace(/( )*\/\/ empty-line( )*/g, "").replace(/Promise( )*<( )*(.+?)( )*>/g, "Promise<$3>").replace(/Optional( )*<( )*(.+?)( )*>/g, "Optional<$3>").replace(/Record( )*<( )*(.+?)( )*>/g, "Record<$3>").replace(/Partial( )*<( )*(.+?)( )*>/g, "Partial<$3>").replace(/DataSource( )*<( )*(.+?)( )*>/g, "DataSource<$3>").replace(/ \? :/g, "?:");
+			if (overwrite !== true) try {
+				await fs.access(filePath);
+				continue;
+			} catch {}
+			await fs.writeFile(filePath, beautified, "utf8");
+		}
+	}
+};
+
+//#endregion
+//#region src/DaoLoader.ts
+var DaoLoader = class {
+	static async loadDaos(moduleDir) {
+		return (await LoaderFactory.createLoader(moduleDir, EggLoadUnitType.MODULE).load()).filter((t) => {
+			return DaoInfoUtil.getIsDao(t);
+		});
+	}
+};
+
+//#endregion
+//#region src/MySqlDataSource.ts
+const DEFAULT_OPTIONS = {
+	supportBigNumbers: true,
+	bigNumberStrings: true,
+	trace: true
+};
+var MysqlDataSource = class extends Base {
+	#initRetryTimes;
+	#logger;
+	constructor(options) {
+		super({ initMethod: "_init" });
+		const { name, initSql, forkDb, initRetryTimes, logger,...mysqlOptions } = options;
+		this.#logger = logger;
+		this.forkDb = forkDb;
+		this.initSql = initSql ?? "SELECT 1 + 1";
+		this.#initRetryTimes = initRetryTimes;
+		this.name = name;
+		this.timezone = options.timezone;
+		this.rdsOptions = Object.assign({}, DEFAULT_OPTIONS, mysqlOptions);
+		this.client = new RDSClient(this.rdsOptions);
+	}
+	async _init() {
+		if (this.initSql) await this.#doInit(1);
+	}
+	async #doInit(tryTimes) {
+		try {
+			this.#logger?.log(`${tryTimes} try to initialize dataSource ${this.name}`);
+			const st = Date.now();
+			await this.client.query(this.initSql);
+			this.#logger?.info(`dataSource initialization cost: ${Date.now() - st}, tryTimes: ${tryTimes}`);
+		} catch (e) {
+			this.#logger?.warn(`failed to initialize dataSource ${this.name}, tryTimes ${tryTimes}`, e);
+			if (!this.#initRetryTimes || tryTimes >= this.#initRetryTimes) throw e;
+			await this.#doInit(tryTimes + 1);
+		}
+	}
+	async query(sql) {
+		return this.client.query(sql);
+	}
+	async beginTransactionScope(scope) {
+		return await this.client.beginTransactionScope(scope);
+	}
+};
+
+//#endregion
+//#region src/DatabaseForker.ts
+var DatabaseForker = class {
+	constructor(env, options) {
+		this.env = env;
+		this.options = options;
+	}
+	shouldFork() {
+		return this.env === "unittest" && this.options.forkDb;
+	}
+	async forkDb(moduleDir) {
+		assert(this.shouldFork(), "fork db only run in unittest");
+		const { name, initSql, forkDb, database,...mysqlOptions } = this.options;
+		const client = new RDSClient(Object.assign(mysqlOptions));
+		const conn = await client.getConnection();
+		await this.doCreateUtDb(conn);
+		await this.forkTables(conn, moduleDir);
+		conn.release();
+		await client.end();
+	}
+	async forkTables(conn, moduleDir) {
+		const daoClazzList = await DaoLoader.loadDaos(moduleDir);
+		for (const clazz of daoClazzList) await this.doForkTable(conn, clazz.tableSql);
+	}
+	async doForkTable(conn, sqlFile) {
+		const sqls = sqlFile.split(";").filter((t) => !!t.trim());
+		for (const sql of sqls) await conn.query(sql);
+	}
+	async doCreateUtDb(conn) {
+		await conn.query(`CREATE DATABASE IF NOT EXISTS ${this.options.database};`);
+		await conn.query(`use ${this.options.database};`);
+	}
+	async destroy() {
+		assert(this.shouldFork(), "fork db only run in unittest");
+		const { name, initSql, forkDb, database,...mysqlOptions } = this.options;
+		const client = new RDSClient(Object.assign(mysqlOptions));
+		await client.query(`DROP DATABASE ${database}`);
+		await client.end();
+	}
+};
+
+//#endregion
+//#region src/NunjucksConverter.ts
+var NunjucksConverter = class {
+	/**
+	* 将变量 HTML 转义的逻辑改为 MySQL 防注入转义
+	*
+	* eg:
+	*
+	*   output += runtime.suppressValue(runtime.contextOrFrameLookup(context, frame, "allColumns")
+	*
+	*   转换为
+	*
+	*   output += runtime.escapeSQL.call(this, "allColumns", runtime.contextOrFrameLookup(context,  frame, "allColumns")
+	*
+	* @param {String} code 转换前的代码
+	* @return {String} 转换后的代码
+	*/
+	static convertNormalVariableCode(code) {
+		return code.replace(/\Woutput\W*?\+=\W*?runtime\.suppressValue\(runtime\.contextOrFrameLookup\((.+?),(.*?),\W*?"(.+?)"\)/g, "\noutput += runtime.escapeSQL.call(this, \"$3\", runtime.contextOrFrameLookup($1, $2, \"$3\")");
+	}
+	/**
+	* 三目运算的 MySQL 防注入转义
+	*
+	* eg:
+	*
+	*   output += runtime.suppressValue((runtime.contextOrFrameLookup(context, frame, "$gmtCreate") !== \
+	*     runtime.contextOrFrameLookup(context, frame, "undefined")?runtime.contextOrFrameLookup(context,\
+	*     frame, "$gmtCreate"):"NOW()"), env.opts.autoescape);
+	*
+	*   转换为
+	*
+	*   output += runtime.suppressValue((runtime.contextOrFrameLookup(...) != ...) ?
+	*     runtime.escapeSQL.call(this, "...", runtime.contextOrFrameLookup(...)) :
+	*     ...)
+	*
+	* @param {String} code 转换前的代码
+	* @return {String} 转换后的代码
+	*/
+	static convertTernaryCode(code) {
+		const ternaryBefore = code.match(/\Woutput\W*?\+=\W*?runtime\.suppressValue\(\(.*\W*?\?\W*?.*?:.*\),\W*?env\.opts\.autoescape/g) || [];
+		const ternaryAfter = ternaryBefore.map((str) => {
+			return str.replace(/([?:])runtime\.contextOrFrameLookup\((.+?),(.*?),\W*?"(.+?)"\)/g, "$1runtime.escapeSQL.call(this, \"$4\", runtime.contextOrFrameLookup($2, $3, \"$4\"))").replace(/env.opts.autoescape$/g, "false");
+		});
+		for (let i = 0; i < ternaryBefore.length; i++) code = code.replace(ternaryBefore[i], ternaryAfter[i]);
+		return code;
+	}
+	/**
+	* 对象的属性，如 `user.id` 防注入转义
+	*
+	* eg:
+	*   output += runtime.suppressValue(runtime.memberLookup(\
+	*     (runtime.contextOrFrameLookup(context, frame, "user")),"id"), env.opts.autoescape);
+	*
+	* 转换为
+	*
+	*   output += runtime.escapeSQL.call(this, "<...>", runtime.memberLookup(...), env.opts.autoescape);
+	*
+	* 由于 escapeSQL 中是根据 key 与预定义 block 匹配决定是否转义，而 memberLookup 的状态下总的 key 肯定不会匹配，
+	* 所以找一个绝对不会匹配的 "<...>" 传入。事实上它可以是任意一个不会被匹配的字符串，比如说 ">_<" 等。
+	*
+	* @param {String} code 转换前的代码
+	* @return {String} 转换后的代码
+	*/
+	static convertNestedObjectCode(code) {
+		return code.replace(/\Woutput\W*?\+=\W*?runtime\.suppressValue\(runtime\.memberLookup\((.+?)\), env\.opts\.autoescape\)/g, "\noutput += runtime.escapeSQL.call(this, \"<...>\", runtime.memberLookup($1), env.opts.autoescape)");
+	}
+	/**
+	* For 中的 `t_xxx` 要被转义：
+	*
+	* eg:
+	*   frame.set("...", t_...);
+	*   ...
+	*   output += runtime.suppressValue(t_.., env.opts.autoscape);
+	*
+	* 转换为
+	*
+	*   output += runtime.escapeSQL.call(this, "for.t_...", t_..., env.opts.autoescape);
+	*
+	* 由于 escapeSQL 中是根据 key 与预定义 block 匹配决定是否转义，而 memberLookup 的状态下总的 key 肯定不会匹配，
+	* 所以找一个绝对不会匹配的 "for.t_..." 传入。事实上它可以是任意一个不会被匹配的字符串，比如说 ">_<" 等。
+	*
+	* @param {String} code 转换前的代码
+	* @return {String} 转换后的代码
+	*/
+	static convertValueInsideFor(code) {
+		return code.replace(/\Woutput\W*?\+=\W*?runtime\.suppressValue\((t_\d+), env\.opts\.autoescape\)/g, "\noutput += runtime.escapeSQL.call(this, \"for.$1\", $1, env.opts.autoescape)");
+	}
+};
+
+//#endregion
+//#region src/SqlUtil.ts
+function isWhiteChar(ch) {
+	return ch === " " || ch === "\n" || ch === "\r" || ch === "	";
+}
+const COMMENT_CHARS = "-#/";
+const MUL_CHAR_LEADING_COMMENT_FIRST_CHAR = {
+	MAY_BE_FIRST_COMMENT: "-",
+	MAY_BE_FIRST_BLOCK_COMMENT: "/"
+};
+const MUL_CHAR_LEADING_COMMENT_VERIFIER = {
+	MAY_BE_FIRST_COMMENT: "-",
+	MAY_BE_FIRST_BLOCK_COMMENT: "*"
+};
+const MUL_CHAR_LEADING_COMMENT_NEXT_STATE = {
+	MAY_BE_FIRST_COMMENT: "IN_COMMENT_WAIT_HINT",
+	MAY_BE_FIRST_BLOCK_COMMENT: "IN_BLOCK_COMMENT_WAIT_HINT"
+};
+var SqlUtil = class {
+	static minify(sql) {
+		let ret = "";
+		let state = "START";
+		let tempNextState;
+		for (let i = 0; i < sql.length; i++) {
+			const ch = sql[i];
+			switch (state) {
+				case "MAY_BE_FIRST_COMMENT":
+				case "MAY_BE_FIRST_BLOCK_COMMENT":
+					switch (ch) {
+						case "\"":
+							tempNextState = "DOUBLE_QUOTE";
+							break;
+						case "'":
+							tempNextState = "SINGLE_QUOTE";
+							break;
+						case MUL_CHAR_LEADING_COMMENT_VERIFIER[state]:
+							tempNextState = MUL_CHAR_LEADING_COMMENT_NEXT_STATE[state];
+							break;
+						default:
+							tempNextState = "CONTENT";
+							break;
+					}
+					if (ch !== MUL_CHAR_LEADING_COMMENT_VERIFIER[state]) ret += `${MUL_CHAR_LEADING_COMMENT_FIRST_CHAR[state]}${ch}`;
+					state = tempNextState;
+					break;
+				case "IN_COMMENT_WAIT_HINT":
+					if (ch !== "+") state = "IN_COMMENT";
+					else {
+						state = "IN_COMMENT_HINT";
+						ret += "--+";
+					}
+					break;
+				case "IN_BLOCK_COMMENT_WAIT_HINT":
+					if (ch !== "+") state = "IN_BLOCK_COMMENT";
+					else {
+						state = "IN_BLOCK_COMMENT_HINT";
+						ret += "/*+";
+					}
+					break;
+				case "MAY_BE_LAST_BLOCK_COMMENT":
+					if (ch === "/") {
+						if (ret && !isWhiteChar(ret[ret.length - 1])) ret += " ";
+						state = "IN_SPACE";
+					} else state = "IN_BLOCK_COMMENT";
+					break;
+				case "MAY_BE_LAST_BLOCK_COMMENT_HINT":
+					ret += ch;
+					if (ch === "/") {
+						state = "IN_SPACE";
+						if (isWhiteChar(sql[i + 1])) ret += sql[i + 1];
+					} else state = "IN_BLOCK_COMMENT_HINT";
+					break;
+				case "IN_COMMENT":
+					if (ch === "\n" || ch === "\r") {
+						if (ret && !isWhiteChar(ret[ret.length - 1])) ret += " ";
+						state = "IN_SPACE";
+					}
+					break;
+				case "IN_COMMENT_HINT":
+					ret += ch;
+					if (ch === "\n" || ch === "\r") state = "IN_SPACE";
+					break;
+				case "IN_BLOCK_COMMENT":
+					if (ch === "*") state = "MAY_BE_LAST_BLOCK_COMMENT";
+					break;
+				case "IN_BLOCK_COMMENT_HINT":
+					ret += ch;
+					if (ch === "*") state = "MAY_BE_LAST_BLOCK_COMMENT_HINT";
+					break;
+				case "START":
+					if (isWhiteChar(ch)) continue;
+					switch (ch) {
+						case "\"":
+							state = "DOUBLE_QUOTE";
+							break;
+						case "'":
+							state = "SINGLE_QUOTE";
+							break;
+						case "-":
+							state = "MAY_BE_FIRST_COMMENT";
+							break;
+						case "#":
+							state = "IN_COMMENT";
+							break;
+						case "/":
+							state = "MAY_BE_FIRST_BLOCK_COMMENT";
+							break;
+						default:
+							state = "CONTENT";
+							break;
+					}
+					if (!COMMENT_CHARS.includes(ch)) ret += ch;
+					break;
+				case "DOUBLE_QUOTE":
+				case "SINGLE_QUOTE":
+					switch (ch) {
+						case "\\":
+							state = `BACKSLASH_AFTER_${state}`;
+							break;
+						case "'":
+							if (state === "SINGLE_QUOTE") state = "QUOTE_DONE";
+							break;
+						case "\"":
+							if (state === "DOUBLE_QUOTE") state = "QUOTE_DONE";
+							break;
+						default: break;
+					}
+					ret += ch;
+					break;
+				case "BACKSLASH_AFTER_SINGLE_QUOTE":
+				case "BACKSLASH_AFTER_DOUBLE_QUOTE":
+					ret += ch;
+					state = state.substr(16);
+					break;
+				case "QUOTE_DONE":
+				case "CONTENT":
+					switch (ch) {
+						case "'":
+							state = "SINGLE_QUOTE";
+							break;
+						case "\"":
+							state = "DOUBLE_QUOTE";
+							break;
+						case "-":
+							state = "MAY_BE_FIRST_COMMENT";
+							break;
+						case "#":
+							state = "IN_COMMENT";
+							break;
+						case "/":
+							state = "MAY_BE_FIRST_BLOCK_COMMENT";
+							break;
+						default:
+							if (isWhiteChar(ch)) {
+								state = "IN_SPACE";
+								ret += " ";
+								continue;
+							}
+							state = "CONTENT";
+					}
+					if (!COMMENT_CHARS.includes(ch)) ret += ch;
+					break;
+				case "IN_SPACE":
+					switch (ch) {
+						case "'":
+							state = "SINGLE_QUOTE";
+							break;
+						case "\"":
+							state = "DOUBLE_QUOTE";
+							break;
+						case "-":
+							state = "MAY_BE_FIRST_COMMENT";
+							break;
+						case "#":
+							state = "IN_COMMENT";
+							break;
+						case "/":
+							state = "MAY_BE_FIRST_BLOCK_COMMENT";
+							break;
+						default:
+							if (isWhiteChar(ch)) continue;
+							state = "CONTENT";
+					}
+					if (!COMMENT_CHARS.includes(ch)) ret += ch;
+					break;
+				default: throw new Error("Unexpected state machine while minifying SQL.");
+			}
+		}
+		return ret.trim();
+	}
+};
+
+//#endregion
+//#region src/NunjucksUtil.ts
+const compiler = nunjucks.compiler;
+const envs = {};
+const ROOT_RENDER_FUNC = Symbol("rootRenderFunc");
+const RUNTIME = Object.assign({}, nunjucks.runtime, { escapeSQL: function escapeSQL(key, value) {
+	if (this.env.globals[key]) return value;
+	return sqlstring.escape(value, true, this.env.timezone);
+} });
+function _replaceCodeWithSQLFeature(source) {
+	return [
+		"convertNormalVariableCode",
+		"convertTernaryCode",
+		"convertNestedObjectCode",
+		"convertValueInsideFor"
+	].reduce((source$1, func) => NunjucksConverter[func](source$1), source);
+}
+/**
+* compile the string into function
+* @see https://github.com/mozilla/nunjucks/blob/2fd547f/src/environment.js#L571-L592
+*/
+function _compile() {
+	let source = compiler.compile(this.tmplStr, this.env.asyncFilters, this.env.extensionsList, this.path, this.env.opts);
+	/**
+	* 将一些 Nunjucks 的 HTML 转义的代码转换成 SQL 防注入的代码
+	*/
+	source = _replaceCodeWithSQLFeature(source);
+	const props = new Function(source)();
+	this.blocks = this._getBlocks(props);
+	this[ROOT_RENDER_FUNC] = props.root;
+	this.rootRenderFunc = function(env, context, frame, _runtime, cb) {
+		/**
+		* 1. 将 runtime 遗弃，用新的
+		* 2. 移除 SQL 语句中多余空白符
+		*/
+		return this[ROOT_RENDER_FUNC](env, context, frame, RUNTIME, function(err, ret) {
+			// istanbul ignore if
+			if (err) return cb(err, ret);
+			return cb(err, SqlUtil.minify(ret || ""));
+		});
+	};
+	this.compiled = true;
+}
+var NunjucksUtils = class {
+	static createEnv(modelName) {
+		if (envs[modelName]) return envs[modelName];
+		return envs[modelName] = nunjucks.configure({ autoescape: false });
+	}
+	static compile(modelName, sqlName, sql) {
+		// istanbul ignore if
+		if (!envs[modelName]) throw new Error(`you should create an Environment for ${modelName} first.`);
+		const template = new Template(sql, envs[modelName], `egg-dal:MySQL:${modelName}:${sqlName}`, false);
+		template._compile = _compile;
+		template.compile();
+		return template;
+	}
+};
+
+//#endregion
+//#region src/TableSqlMap.ts
+var TableSqlMap = class {
+	constructor(name, map) {
+		this.name = name;
+		this.map = map;
+		const env = NunjucksUtils.createEnv(name);
+		const extracted = this.#extract(this.map);
+		this.blocks = extracted.blocks;
+		this.sqlGenerator = extracted.sqlGenerator;
+		for (const key in this.blocks) {
+			// istanbul ignore if
+			if (!this.blocks.hasOwnProperty(key)) continue;
+			env.addGlobal(key, this.blocks[key]);
+		}
+		env.addFilter("toJson", TemplateUtil.toJson);
+		env.addFilter("toPoint", TemplateUtil.toPoint);
+		env.addFilter("toLine", TemplateUtil.toLine);
+		env.addFilter("toPolygon", TemplateUtil.toPolygon);
+		env.addFilter("toGeometry", TemplateUtil.toGeometry);
+		env.addFilter("toMultiPoint", TemplateUtil.toMultiPoint);
+		env.addFilter("toMultiLine", TemplateUtil.toMultiLine);
+		env.addFilter("toMultiPolygon", TemplateUtil.toMultiPolygon);
+		env.addFilter("toGeometryCollection", TemplateUtil.toGeometryCollection);
+	}
+	#extract(map) {
+		const ret = {
+			blocks: {},
+			sqlGenerator: {}
+		};
+		for (const key in map) {
+			// istanbul ignore if
+			if (!map.hasOwnProperty(key)) continue;
+			const sqlMap = map[key];
+			switch (sqlMap.type) {
+				case SqlType.BLOCK:
+					ret.blocks[key] = sqlMap.content || "";
+					break;
+				case SqlType.INSERT:
+				case SqlType.SELECT:
+				case SqlType.UPDATE:
+				case SqlType.DELETE:
+				default:
+					ret.sqlGenerator[key] = {
+						type: sqlMap.type,
+						template: NunjucksUtils.compile(this.name, key, sqlMap.sql || ""),
+						raw: sqlMap.sql
+					};
+					break;
+			}
+		}
+		return ret;
+	}
+	generate(name, data, timezone) {
+		const generator = this.sqlGenerator[name];
+		// istanbul ignore if
+		if (!generator) throw new Error(`No sql map named '${name}' in '${name}'.`);
+		const template = generator.template;
+		template.env.timezone = timezone;
+		return template.render(data);
+	}
+	getType(name) {
+		const generator = this.sqlGenerator[name];
+		// istanbul ignore if
+		if (!generator) throw new Error(`No sql map named '${name}' in '${name}'.`);
+		return generator.type;
+	}
+	getTemplateString(name) {
+		const generator = this.sqlGenerator[name];
+		// istanbul ignore if
+		if (!generator) throw new Error(`No sql map named '${name}' in '${name}'.`);
+		return generator.raw;
+	}
+};
+
+//#endregion
+//#region src/TableModelInstanceBuilder.ts
+var TableModelInstanceBuilder = class TableModelInstanceBuilder {
+	constructor(tableModel, row) {
+		for (const [key, value] of Object.entries(row)) {
+			const column = tableModel.columns.find((t) => t.columnName === key);
+			Reflect.set(this, column?.propertyName ?? key, value);
+		}
+	}
+	static buildInstance(tableModel, row) {
+		return Reflect.construct(TableModelInstanceBuilder, [tableModel, row], tableModel.clazz);
+	}
+	static buildRow(instance, tableModel) {
+		const result = {};
+		for (const column of tableModel.columns) {
+			const columnValue = Reflect.get(instance, column.propertyName);
+			if (typeof columnValue !== "undefined") result[`$${column.propertyName}`] = columnValue;
+		}
+		return result;
+	}
+};
+
+//#endregion
+//#region src/DataSource.ts
+const PAGINATE_COUNT_WRAPPER = ["SELECT COUNT(0) as count FROM (", ") AS T"];
+var DataSource = class {
+	constructor(tableModel, mysqlDataSource, sqlMap) {
+		this.tableModel = tableModel;
+		this.mysqlDataSource = mysqlDataSource;
+		this.sqlMap = sqlMap;
+	}
+	/**
+	* public for aop execute to implement sql hint append
+	* @param sqlName - sql name
+	* @param data - sql data
+	*/
+	async generateSql(sqlName, data) {
+		const sql = this.sqlMap.generate(sqlName, data, this.mysqlDataSource.timezone);
+		const sqlType = this.sqlMap.getType(sqlName);
+		const template = this.sqlMap.getTemplateString(sqlName);
+		return {
+			sql,
+			sqlType,
+			template
+		};
+	}
+	async count(sqlName, data) {
+		const newData = Object.assign({ $$count: true }, data);
+		const executeSql = await this.generateSql(sqlName, newData);
+		return await this.#paginateCount(executeSql.sql);
+	}
+	async execute(sqlName, data) {
+		const executeSql = await this.generateSql(sqlName, data);
+		return (await this.mysqlDataSource.query(executeSql.sql)).map((t) => {
+			return TableModelInstanceBuilder.buildInstance(this.tableModel, t);
+		});
+	}
+	async executeRaw(sqlName, data) {
+		const executeSql = await this.generateSql(sqlName, data);
+		return await this.mysqlDataSource.query(executeSql.sql);
+	}
+	async executeScalar(sqlName, data) {
+		const ret = await this.execute(sqlName, data);
+		if (!Array.isArray(ret)) return ret || null;
+		return ret[0] || null;
+	}
+	async executeRawScalar(sqlName, data) {
+		const ret = await this.executeRaw(sqlName, data);
+		if (!Array.isArray(ret)) return ret || null;
+		return ret[0] || null;
+	}
+	async paginate(sqlName, data, currentPage, perPageCount) {
+		const limit = `LIMIT ${(currentPage - 1) * perPageCount}, ${perPageCount}`;
+		const sql = (await this.generateSql(sqlName, data)).sql + " " + limit;
+		const countSql = (await this.generateSql(sqlName, Object.assign({ $$count: true }, data))).sql;
+		const ret = await Promise.all([this.mysqlDataSource.query(sql), this.#paginateCount(countSql)]);
+		return {
+			total: Number(ret[1]),
+			pageNum: currentPage,
+			rows: ret[0].map((t) => TableModelInstanceBuilder.buildInstance(this.tableModel, t))
+		};
+	}
+	async #paginateCount(baseSQL) {
+		const sql = `${PAGINATE_COUNT_WRAPPER[0]}${baseSQL}${PAGINATE_COUNT_WRAPPER[1]}`;
+		return (await this.mysqlDataSource.query(sql))[0].count;
+	}
+};
+
+//#endregion
+//#region src/SqlMapLoader.ts
+var SqlMapLoader = class {
+	constructor(tableModel, baseDaoClazz, logger) {
+		this.clazzExtension = baseDaoClazz.clazzExtension;
+		this.logger = logger;
+		this.tableModel = tableModel;
+	}
+	load() {
+		const sqlMap = {
+			...new BaseSqlMapGenerator(this.tableModel, this.logger).load(),
+			...this.clazzExtension
+		};
+		return new TableSqlMap(this.tableModel.clazz.name, sqlMap);
+	}
+};
+
+//#endregion
 export { BaseSqlMapGenerator, CodeGenerator, DaoLoader, DataSource, DatabaseForker, MysqlDataSource, NunjucksConverter, NunjucksUtils, SqlGenerator, SqlMapLoader, SqlUtil, TableModelInstanceBuilder, TableSqlMap, TemplateUtil };