@eggjs/dal-runtime 4.0.0-beta.8 → 4.0.1-beta.0

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>): T;
+  static buildRow<T extends object>(instance: T, tableModel: TableModel<T>): Record<string, 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,21 @@
+import { SqlMap, SqlType } from "@eggjs/tegg-types";
+import { Template } from "nunjucks";
+
+//#region src/TableSqlMap.d.ts
+interface GeneratedSql {
+  sql: string;
+  params: any[];
+}
+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): GeneratedSql;
+  getType(name: string): SqlType;
+  getTemplateString(name: string): string;
+}
+//#endregion
+export { TableSqlMap };

package/dist/TableSqlMap.js

@@ -0,0 +1,98 @@
+import { TemplateUtil } from "./TemplateUtil.js";
+import { NunjucksUtils } from "./NunjucksUtil.js";
+import { SqlType } from "@eggjs/tegg-types";
+import { Template } from "nunjucks";
+
+//#region src/TableSqlMap.ts
+const SQL_PARAMS = "$$__sql_params";
+var TableSqlMap = class {
+	name;
+	map;
+	blocks;
+	sqlGenerator;
+	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);
+		env.addFilter("param", function(value) {
+			if (this.ctx[SQL_PARAMS]) this.ctx[SQL_PARAMS].push(value);
+			return "?";
+		});
+	}
+	#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;
+		const params = [];
+		template.env.timezone = timezone;
+		const context = {
+			...data,
+			[SQL_PARAMS]: params
+		};
+		return {
+			sql: template.render(context),
+			params
+		};
+	}
+	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,75 @@
+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);
+		return TemplateUtil[TemplateUtil.getSpatialFilter(type)](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 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 };