@eggjs/dal-runtime 4.0.0-beta.3 → 4.0.0-beta.5

package/README.md

@@ -1,5 +1,17 @@
 # `@eggjs/dal-runtime`
 
+[![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-runtime.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/dal-runtime.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/dal-runtime
+[snyk-image]: https://snyk.io/test/npm/@eggjs/dal-runtime/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/@eggjs/dal-runtime
+[download-image]: https://img.shields.io/npm/dm/@eggjs/dal-runtime.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/dal-runtime
+
 ## Usage
 
-Please read [@eggjs/tegg-dal-plugin](../../plugin/dal-plugin)
+Please read [@eggjs/tegg-dal-plugin](../../plugin/dal/README.md)

package/dist/BaseSqlMap.d.ts

@@ -0,0 +1,18 @@
+import { TableModel } from "@eggjs/dal-decorator";
+import { GenerateSqlMap, Logger, SqlMap } from "@eggjs/tegg-types";
+
+//#region src/BaseSqlMap.d.ts
+declare class BaseSqlMapGenerator {
+  private readonly tableModel;
+  private readonly logger;
+  constructor(tableModel: TableModel, logger: Logger);
+  generateAllColumns(countIf: boolean): string;
+  generateFindByPrimary(): Array<GenerateSqlMap>;
+  generateFindByIndexes(): GenerateSqlMap[];
+  generateInsert(): string;
+  generateUpdate(): string;
+  generateDelete(): string;
+  load(): Record<string, SqlMap>;
+}
+//#endregion
+export { BaseSqlMapGenerator };

package/dist/BaseSqlMap.js

@@ -0,0 +1,247 @@
+import { TemplateUtil } from "./TemplateUtil.js";
+import _ from "lodash";
+import { TableModel } from "@eggjs/dal-decorator";
+import { ColumnType, IndexType, SqlType } from "@eggjs/tegg-types";
+
+//#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
+export { BaseSqlMapGenerator };

package/dist/CodeGenerator.d.ts

@@ -0,0 +1,17 @@
+import { TableModel } from "@eggjs/dal-decorator";
+import { CodeGeneratorOptions, Templates } from "@eggjs/tegg-types";
+
+//#region src/CodeGenerator.d.ts
+declare class CodeGenerator {
+  private readonly moduleDir;
+  private readonly moduleName;
+  private readonly teggPkg;
+  private readonly dalPkg;
+  constructor(options: CodeGeneratorOptions);
+  private njkEnv;
+  createNunjucksEnv(): void;
+  genCode(tplName: Templates, filePath: string, tableModel: TableModel): string;
+  generate(tableModel: TableModel): Promise<void>;
+}
+//#endregion
+export { CodeGenerator };

package/dist/CodeGenerator.js

@@ -0,0 +1,114 @@
+import { TemplateUtil } from "./TemplateUtil.js";
+import { SqlGenerator } from "./SqlGenerator.js";
+import _ from "lodash";
+import { ColumnModel, TableModel } from "@eggjs/dal-decorator";
+import { Templates } from "@eggjs/tegg-types";
+import path from "node:path";
+import fs from "node:fs/promises";
+import js_beautify from "js-beautify";
+import nunjucks from "nunjucks";
+import { PrototypeUtil } from "@eggjs/core-decorator";
+
+//#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
+export { CodeGenerator };

package/dist/DaoLoader.d.ts

@@ -0,0 +1,8 @@
+import { BaseDaoType } from "@eggjs/tegg-types/dal";
+
+//#region src/DaoLoader.d.ts
+declare class DaoLoader {
+  static loadDaos(moduleDir: string): Promise<Array<BaseDaoType>>;
+}
+//#endregion
+export { DaoLoader };

package/dist/DaoLoader.js

@@ -0,0 +1,16 @@
+import { DaoInfoUtil } from "@eggjs/dal-decorator";
+import { EggLoadUnitType } from "@eggjs/tegg-types";
+import "@eggjs/tegg-types/dal";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+
+//#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
+export { DaoLoader };

package/dist/DataSource.d.ts

@@ -0,0 +1,32 @@
+import { MysqlDataSource } from "./MySqlDataSource.js";
+import { TableSqlMap } from "./TableSqlMap.js";
+import { TableModel } from "@eggjs/dal-decorator";
+import { DataSource, PaginateData, SqlType } from "@eggjs/tegg-types";
+
+//#region src/DataSource.d.ts
+interface ExecuteSql {
+  sql: string;
+  template: string;
+  sqlType: SqlType;
+}
+declare class DataSource$1<T> implements DataSource<T> {
+  #private;
+  private readonly tableModel;
+  private readonly mysqlDataSource;
+  private readonly sqlMap;
+  constructor(tableModel: TableModel<T>, mysqlDataSource: MysqlDataSource, sqlMap: TableSqlMap);
+  /**
+   * public for aop execute to implement sql hint append
+   * @param sqlName - sql name
+   * @param data - sql data
+   */
+  generateSql(sqlName: string, data: object): Promise<ExecuteSql>;
+  count(sqlName: string, data?: any): Promise<number>;
+  execute(sqlName: string, data?: any): Promise<Array<T>>;
+  executeRaw(sqlName: string, data?: any): Promise<Array<any>>;
+  executeScalar(sqlName: string, data?: any): Promise<T | null>;
+  executeRawScalar(sqlName: string, data?: any): Promise<any | null>;
+  paginate(sqlName: string, data: any, currentPage: number, perPageCount: number): Promise<PaginateData<T>>;
+}
+//#endregion
+export { DataSource$1 as DataSource, ExecuteSql };

package/dist/DataSource.js

@@ -0,0 +1,72 @@
+import "./MySqlDataSource.js";
+import "./TableSqlMap.js";
+import { TableModelInstanceBuilder } from "./TableModelInstanceBuilder.js";
+import { TableModel } from "@eggjs/dal-decorator";
+
+//#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
+export { DataSource };

package/dist/DatabaseForker.d.ts

@@ -0,0 +1,16 @@
+import { DataSourceOptions } from "./MySqlDataSource.js";
+
+//#region src/DatabaseForker.d.ts
+declare class DatabaseForker {
+  private readonly env;
+  private readonly options;
+  constructor(env: string, options: DataSourceOptions);
+  shouldFork(): boolean;
+  forkDb(moduleDir: string): Promise<void>;
+  private forkTables;
+  private doForkTable;
+  private doCreateUtDb;
+  destroy(): Promise<void>;
+}
+//#endregion
+export { DatabaseForker };

package/dist/DatabaseForker.js

@@ -0,0 +1,47 @@
+import { DaoLoader } from "./DaoLoader.js";
+import "./MySqlDataSource.js";
+import assert from "node:assert";
+import { RDSClient } from "@eggjs/rds";
+
+//#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
+export { DatabaseForker };

package/dist/MySqlDataSource.d.ts

@@ -0,0 +1,27 @@
+import { Logger } from "@eggjs/tegg-types";
+import { RDSClientOptions } from "@eggjs/rds";
+import { Base } from "sdk-base";
+
+//#region src/MySqlDataSource.d.ts
+interface DataSourceOptions extends RDSClientOptions {
+  name: string;
+  initSql?: string;
+  forkDb?: boolean;
+  initRetryTimes?: number;
+  logger?: Logger;
+}
+declare class MysqlDataSource extends Base {
+  #private;
+  private client;
+  private readonly initSql;
+  readonly name: string;
+  readonly timezone?: string;
+  readonly rdsOptions: RDSClientOptions;
+  readonly forkDb?: boolean;
+  constructor(options: DataSourceOptions);
+  protected _init(): Promise<void>;
+  query<T = any>(sql: string): Promise<T>;
+  beginTransactionScope<T>(scope: () => Promise<T>): Promise<T>;
+}
+//#endregion
+export { DataSourceOptions, MysqlDataSource };

package/dist/MySqlDataSource.js

@@ -0,0 +1,49 @@
+import { RDSClient } from "@eggjs/rds";
+import { Base } from "sdk-base";
+
+//#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
+export { MysqlDataSource };