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

package/dist/NunjucksConverter.d.ts

@@ -0,0 +1,76 @@
+//#region src/NunjucksConverter.d.ts
+declare class NunjucksConverter {
+  /**
+   * 将变量 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: string): string;
+  /**
+   * 三目运算的 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: string): string;
+  /**
+   * 对象的属性，如 `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: string): string;
+  /**
+   * 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: string): string;
+}
+//#endregion
+export { NunjucksConverter };

package/dist/NunjucksConverter.js

@@ -0,0 +1,90 @@
+//#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
+export { NunjucksConverter };

package/dist/NunjucksUtil.d.ts

@@ -0,0 +1,9 @@
+import nunjucks from "nunjucks";
+
+//#region src/NunjucksUtil.d.ts
+declare class NunjucksUtils {
+  static createEnv(modelName: string): nunjucks.Environment;
+  static compile(modelName: string, sqlName: string, sql: string): nunjucks.Template;
+}
+//#endregion
+export { NunjucksUtils };

package/dist/NunjucksUtil.js

@@ -0,0 +1,64 @@
+import { NunjucksConverter } from "./NunjucksConverter.js";
+import { SqlUtil } from "./SqlUtil.js";
+import nunjucks, { Template } from "nunjucks";
+import sqlstring from "sqlstring";
+
+//#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
+export { NunjucksUtils };

package/dist/SqlGenerator.d.ts

@@ -0,0 +1,13 @@
+import { TableModel } from "@eggjs/dal-decorator";
+
+//#region src/SqlGenerator.d.ts
+declare class SqlGenerator {
+  private formatComment;
+  private generateColumn;
+  private generateColumnType;
+  private generateIndex;
+  private generateTableOptions;
+  generate(tableModel: TableModel): string;
+}
+//#endregion
+export { SqlGenerator };

package/dist/SqlGenerator.js

@@ -0,0 +1,224 @@
+import { ColumnModel, TableModel } from "@eggjs/dal-decorator";
+import { ColumnType, IndexType } from "@eggjs/tegg-types";
+
+//#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
+export { SqlGenerator };

package/dist/SqlMapLoader.d.ts

@@ -0,0 +1,14 @@
+import { TableSqlMap } from "./TableSqlMap.js";
+import { BaseDaoType, TableModel } from "@eggjs/dal-decorator";
+import { Logger } from "@eggjs/tegg-types";
+
+//#region src/SqlMapLoader.d.ts
+declare class SqlMapLoader {
+  private readonly logger;
+  private readonly tableModel;
+  private readonly clazzExtension;
+  constructor(tableModel: TableModel, baseDaoClazz: BaseDaoType, logger: Logger);
+  load(): TableSqlMap;
+}
+//#endregion
+export { SqlMapLoader };

package/dist/SqlMapLoader.js

@@ -0,0 +1,22 @@
+import { BaseSqlMapGenerator } from "./BaseSqlMap.js";
+import { TableSqlMap } from "./TableSqlMap.js";
+import { TableModel } from "@eggjs/dal-decorator";
+
+//#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 { SqlMapLoader };

package/dist/SqlUtil.d.ts

@@ -0,0 +1,6 @@
+//#region src/SqlUtil.d.ts
+declare class SqlUtil {
+  static minify(sql: string): string;
+}
+//#endregion
+export { SqlUtil };