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

package/dist/SqlUtil.js

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

package/dist/TableModelInstanceBuilder.d.ts

@@ -0,0 +1,10 @@
+import { TableModel } from "@eggjs/dal-decorator";
+
+//#region src/TableModelInstanceBuilder.d.ts
+declare class TableModelInstanceBuilder {
+  constructor(tableModel: TableModel, row: Record<string, any>);
+  static buildInstance<T>(tableModel: TableModel<T>, row: Record<string, any>): any;
+  static buildRow<T extends object>(instance: T, tableModel: TableModel<T>): any;
+}
+//#endregion
+export { TableModelInstanceBuilder };

package/dist/TableModelInstanceBuilder.js

@@ -0,0 +1,25 @@
+import { TableModel } from "@eggjs/dal-decorator";
+
+//#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
+export { TableModelInstanceBuilder };

package/dist/TableSqlMap.d.ts

@@ -0,0 +1,18 @@
+import { SqlMap, SqlType } from "@eggjs/tegg-types";
+import { Template } from "nunjucks";
+
+//#region src/TableSqlMap.d.ts
+
+declare class TableSqlMap {
+  #private;
+  readonly name: string;
+  private readonly map;
+  private readonly blocks;
+  private readonly sqlGenerator;
+  constructor(name: string, map: Record<string, SqlMap>);
+  generate(name: string, data: object, timezone: string): string;
+  getType(name: string): SqlType;
+  getTemplateString(name: string): string;
+}
+//#endregion
+export { TableSqlMap };

package/dist/TableSqlMap.js

@@ -0,0 +1,81 @@
+import { TemplateUtil } from "./TemplateUtil.js";
+import { NunjucksUtils } from "./NunjucksUtil.js";
+import { SqlType } from "@eggjs/tegg-types";
+import { Template } from "nunjucks";
+
+//#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
+export { TableSqlMap };

package/dist/TemplateUtil.d.ts

@@ -0,0 +1,22 @@
+import { ColumnModel } from "@eggjs/dal-decorator";
+import { ColumnType, Geometry, GeometryCollection, Line, MultiLine, MultiPoint, MultiPolygon, Point, Polygon } from "@eggjs/tegg-types";
+
+//#region src/TemplateUtil.d.ts
+declare class TemplateUtil {
+  static isSpatialType(columnModel: ColumnModel): boolean;
+  static importPath(tableModelPath: string, currentPath: string): string;
+  static dbTypeToTsType(columnType: ColumnType): string;
+  static toJson(value: any): string;
+  static toPoint(point: Point): string;
+  static toLine(val: Line): string;
+  static toPolygon(val: Polygon): string;
+  static toGeometry(val: Geometry): string;
+  static toMultiPoint(val: MultiPoint): string;
+  static toMultiLine(val: MultiLine): string;
+  static toMultiPolygon(val: MultiPolygon): string;
+  static toGeometryCollection(val: GeometryCollection): string;
+  static spatialFilter: Record<ColumnType, string>;
+  static getSpatialFilter(columnType: ColumnType): string;
+}
+//#endregion
+export { TemplateUtil };

package/dist/TemplateUtil.js

@@ -0,0 +1,78 @@
+import { ColumnModel, SpatialHelper } from "@eggjs/dal-decorator";
+import { ColumnType } from "@eggjs/tegg-types";
+import path from "node:path";
+
+//#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
+export { TemplateUtil };

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { BaseSqlMapGenerator } from "./BaseSqlMap.js";
+import { CodeGenerator } from "./CodeGenerator.js";
+import { DaoLoader } from "./DaoLoader.js";
+import { DataSourceOptions, MysqlDataSource } from "./MySqlDataSource.js";
+import { DatabaseForker } from "./DatabaseForker.js";
+import { TableSqlMap } from "./TableSqlMap.js";
+import { DataSource, ExecuteSql } from "./DataSource.js";
+import { NunjucksConverter } from "./NunjucksConverter.js";
+import { NunjucksUtils } from "./NunjucksUtil.js";
+import { SqlGenerator } from "./SqlGenerator.js";
+import { SqlMapLoader } from "./SqlMapLoader.js";
+import { SqlUtil } from "./SqlUtil.js";
+import { TableModelInstanceBuilder } from "./TableModelInstanceBuilder.js";
+import { TemplateUtil } from "./TemplateUtil.js";
+export { BaseSqlMapGenerator, CodeGenerator, DaoLoader, DataSource, DataSourceOptions, DatabaseForker, ExecuteSql, MysqlDataSource, NunjucksConverter, NunjucksUtils, SqlGenerator, SqlMapLoader, SqlUtil, TableModelInstanceBuilder, TableSqlMap, TemplateUtil };

package/dist/index.js

@@ -0,0 +1,16 @@
+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";
+
+export { BaseSqlMapGenerator, CodeGenerator, DaoLoader, DataSource, DatabaseForker, MysqlDataSource, NunjucksConverter, NunjucksUtils, SqlGenerator, SqlMapLoader, SqlUtil, TableModelInstanceBuilder, TableSqlMap, TemplateUtil };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/dal-runtime",
-  "version": "4.0.0-beta.4",
+  "version": "4.0.0-beta.5",
   "description": "tegg dal decorator",
   "keywords": [
     "egg",
@@ -11,24 +11,15 @@
   ],
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./src/index.d.ts",
-      "default": "./src/index.js"
-    }
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
   "files": [
-    "src/**/*.js",
-    "src/**/*.d.ts"
+    "dist"
   ],
-  "scripts": {
-    "clean": "tsc -b --clean",
-    "tsc": "npm run clean && tsc -p ./tsconfig.json",
-    "tsc:pub": "npm run tsc",
-    "prepublishOnly": "npm run tsc"
-  },
   "author": "killagu <killa123@126.com>",
   "license": "MIT",
-  "homepage": "https://github.com/eggjs/tegg",
+  "homepage": "https://github.com/eggjs/tegg/tree/next/core/dal-runtime",
   "bugs": {
     "url": "https://github.com/eggjs/tegg/issues"
   },
@@ -38,31 +29,39 @@
     "directory": "core/dal-decorator"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.18.0"
   },
   "dependencies": {
-    "@eggjs/core-decorator": "^4.0.0-beta.4",
-    "@eggjs/dal-decorator": "^4.0.0-beta.4",
-    "@eggjs/rds": "^1.0.0",
-    "@eggjs/tegg-loader": "^4.0.0-beta.4",
-    "@eggjs/tegg-types": "^4.0.0-beta.4",
+    "@eggjs/rds": "^1.3.0",
     "js-beautify": "^1.15.3",
     "lodash": "^4.17.21",
     "nunjucks": "^3.2.4",
     "sdk-base": "^5.0.1",
-    "sqlstring": "^2.3.3"
+    "sqlstring": "^2.3.3",
+    "@eggjs/tegg-loader": "4.0.0-beta.5",
+    "@eggjs/tegg-types": "4.0.0-beta.5",
+    "@eggjs/dal-decorator": "4.0.0-beta.5",
+    "@eggjs/core-decorator": "4.0.0-beta.5"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
     "@types/js-beautify": "^1.14.3",
-    "@types/lodash": "4",
-    "@types/node": "22",
-    "@types/nunjucks": "3",
+    "@types/lodash": "^4.17.20",
+    "@types/node": "^22.10.5",
+    "@types/nunjucks": "^3.2.6",
     "@types/sqlstring": "^2.3.2",
-    "ts-node": "10",
-    "typescript": "5"
+    "typescript": "^5.9.3",
+    "tsdown": "^0.15.6",
+    "unplugin-unused": "^0.5.3"
   },
-  "gitHead": "9ba90bed3ab9f641ceaa6a7db560095817b7e52c"
-}
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/BaseSqlMap.d.ts

@@ -1,15 +0,0 @@
-import { TableModel } from '@eggjs/dal-decorator';
-import { SqlMap } from '@eggjs/tegg-types';
-import type { Logger, GenerateSqlMap } from '@eggjs/tegg-types';
-export 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 | undefined;
-    generateDelete(): string | undefined;
-    load(): Record<string, SqlMap>;
-}