sasat 0.22.8 → 0.22.9

package/dist/src-DebKrtYl.mjs

@@ -0,0 +1,806 @@
+import { a as getDbClient, i as SasatError, l as SqlString$1, o as MySqlTransaction, r as unique, s as DBClient, t as nonNullable } from "./util-Dkw5bD7a.mjs";
+import { createConnection } from "mysql2/promise";
+import * as SqlString from "sqlstring";
+//#region src/db/connectors/mysql/client.ts
+var MysqlClient = class extends DBClient {
+	async release() {}
+	constructor(connectionOption, logger) {
+		super(logger);
+		this.connectionOption = connectionOption;
+	}
+	getConnection() {
+		return createConnection({
+			dateStrings: true,
+			...this.connectionOption
+		});
+	}
+	async transaction() {
+		const connection = await this.getConnection();
+		await connection.beginTransaction();
+		return new MySqlTransaction(connection);
+	}
+	async execSql(sql) {
+		const connection = await this.getConnection();
+		const r = await connection.query(sql);
+		await connection.end();
+		return r[0];
+	}
+};
+//#endregion
+//#region src/runtime/dsl/query/sql/nodeToSql.ts
+function partitionBy(ids) {
+	if (!ids || ids.length === 0) return "";
+	return `PARTITION BY ${ids.map(Sql.identifier).join(",")} `;
+}
+function orderBy(sorts) {
+	if (!sorts || sorts.length === 0) return "";
+	return `ORDER BY ${sorts.map(Sql.sort).join(",")} `;
+}
+function windowValue(value) {
+	if (value.type === "FOLLOWING" || value.type === "PRECEDING") return `${value.value} ${value.type}`;
+	return value.type;
+}
+function window$1(window) {
+	if (!window) return "";
+	if (window.between) return `${window.type} BETWEEN ${windowValue(window.start)} AND ${window.end}`;
+	return `${window.type} ${windowValue(window.value)}`;
+}
+function over(v) {
+	if (!v) return "";
+	return `OVER (${partitionBy(v.partitionBy)}${orderBy(v.orderBy)}${window$1(v.window)})`;
+}
+const Sql = {
+	select: (expr) => {
+		switch (expr.kind) {
+			case 15: return expr.expr;
+			case 0: return Sql.fieldInSelect(expr);
+			case 13: return Sql.identifier(expr);
+			case 1: return Sql.fn(expr);
+		}
+	},
+	literal: (literal) => SqlString$1.escape(literal.value),
+	fieldInCondition: (identifier) => SqlString$1.escapeId(identifier.table) + "." + SqlString$1.escapeId(identifier.name),
+	fieldInSelect: (identifier) => {
+		const alias = identifier.alias && identifier.name !== identifier.alias ? " AS " + SqlString$1.escapeId(identifier.alias) : "";
+		return SqlString$1.escapeId(identifier.table) + "." + SqlString$1.escapeId(identifier.name) + alias;
+	},
+	identifier: (ident) => {
+		return SqlString$1.escapeId(ident.identifier);
+	},
+	fn: (fn) => `${fn.fnName}(${fn.args.map(Sql.value).join(",")})${over(fn.over)}${fn.alias ? ` AS ${fn.alias}` : ""}`,
+	value: (v) => {
+		if (v.kind === 1) return Sql.fn(v);
+		if (v.kind === 0) return Sql.fieldInCondition(v);
+		if (v.kind === 13) return Sql.identifier(v);
+		return Sql.literal(v);
+	},
+	between: (expr) => `${Sql.value(expr.left)} BETWEEN ${Sql.value(expr.begin)} AND ${Sql.value(expr.end)}`,
+	contains: (expr) => {
+		const operator = expr.isNot ? "NOT LIKE" : "LIKE";
+		const val = (value, type) => {
+			if (type === "contains") return "%" + value + "%";
+			if (type === "start") return "%" + value;
+			return value + "%";
+		};
+		return `${Sql.value(expr.left)} ${operator} ${SqlString$1.escape(val(expr.right, expr.type))}`;
+	},
+	in: (expr) => {
+		if ("right" in expr) return `${Sql.value(expr.left)} ${expr.operator} (${expr.right.map(Sql.value).join(", ")})`;
+		return `${Sql.value(expr.left)} ${expr.operator} (${Sql.queryOrRaw(expr.query)})`;
+	},
+	comparison: (expr) => `${Sql.value(expr.left)}  ${expr.operator} ${Sql.value(expr.right)}`,
+	compound: (expr) => `${Sql.booleanValue(expr.left)} ${expr.operator} ${Sql.booleanValue(expr.right)}`,
+	isNull: (expr) => `${Sql.value(expr.expr)} ${expr.isNot ? "IS NOT NULL" : "IS NULL"}`,
+	paren: (expr) => "(" + Sql.booleanValue(expr.expression) + ")",
+	table: (table) => {
+		if (!table.subquery) {
+			if (table.alias === table.name) return SqlString$1.escapeId(table.name);
+			return SqlString$1.escapeId(table.name) + " AS " + SqlString$1.escapeId(table.alias);
+		}
+		return `(${queryToSql(table.query)}) AS ${SqlString$1.escapeId(table.alias)}`;
+	},
+	join: (join) => `${join.type ? join.type + " " : ""}JOIN ${Sql.table(join.table)} ON ` + Sql.booleanValue(join.conditions),
+	booleanValue: (expr) => {
+		switch (expr.kind) {
+			case 9: return Sql.between(expr);
+			case 4: return Sql.compound(expr);
+			case 5: return Sql.comparison(expr);
+			case 10: return Sql.contains(expr);
+			case 7: return Sql.paren(expr);
+			case 8: return Sql.in(expr);
+			case 6: return Sql.isNull(expr);
+			case 14: return Sql.exists(expr);
+			case 15: return expr.expr;
+		}
+	},
+	exists: (expr) => {
+		return `EXISTS (${Sql.queryOrRaw(expr.query)})`;
+	},
+	sort: (expr) => {
+		const field = () => {
+			switch (expr.field.kind) {
+				case 0: return Sql.fieldInCondition(expr.field);
+				case 13: return Sql.identifier(expr.field);
+				default: return Sql.fn(expr.field);
+			}
+		};
+		if (expr.direction) return `${field()} ${expr.direction === "DESC" ? "DESC" : "ASC"}`;
+		return field();
+	},
+	sorts: (sorts) => sorts.map(Sql.sort).join(", "),
+	queryOrRaw: (expr) => {
+		if ("kind" in expr) return expr.expr;
+		return queryToSql(expr);
+	}
+};
+//#endregion
+//#region src/runtime/dsl/query/sql/queryToSql.ts
+const getJoin = (from) => {
+	return from.joins.flatMap((join) => [join, ...getJoin(join.table)]);
+};
+const getLock = (lock) => {
+	if (!lock) return "";
+	if (lock === "FOR UPDATE") return " FOR UPDATE";
+	return " FOR SHARE";
+};
+const queryToSql = (query) => {
+	const select = query.select.map(Sql.select).join(", ");
+	const join = [...getJoin(query.from), ...query.join ?? []].map(Sql.join).join(" ");
+	const where = query.where ? " WHERE " + Sql.booleanValue(query.where) : "";
+	const groupBy = query.groupBy ? " GROUP BY" + query.groupBy.cols.map(Sql.value).join(",") : "";
+	const having = query.having ? "HAVING " + Sql.booleanValue(query.having) : "";
+	const sort = query.sort && query.sort.length !== 0 ? " ORDER BY " + Sql.sorts(query.sort) : "";
+	const limit = query.limit ? " LIMIT " + query.limit : "";
+	const offset = query.offset ? " OFFSET " + query.offset : "";
+	if (offset && !limit) throw new Error("LIMIT is required to use OFFSET.");
+	return `SELECT ${select} FROM ${Sql.table(query.from)}` + join + where + groupBy + having + sort + limit + offset + getLock(query.lock);
+};
+//#endregion
+//#region src/db/sql/expression/comparison.ts
+let Comparison = /* @__PURE__ */ function(Comparison) {
+	Comparison["eq"] = "=";
+	Comparison["gt"] = ">";
+	Comparison["lt"] = "<";
+	Comparison["gte"] = ">=";
+	Comparison["lte"] = "<=";
+	Comparison["neq"] = "<>";
+	Comparison["like"] = "LIKE";
+	Comparison["notLike"] = "NOT LIKE";
+	return Comparison;
+}({});
+const comparisonExpressionToSql = (exp) => {
+	const type = Object.hasOwn(exp, "__type") ? exp.__type || "AND" : "AND";
+	return Object.entries(exp).map(([key, value]) => {
+		const column = SqlString.escapeId(key);
+		if (!Array.isArray(value)) return `${column} = ${SqlString.escape(value)}`;
+		if (value[0] === "IS NULL") return `${column} IS NULL`;
+		if (value[0] === "IS NOT NULL") return `${column} IS NOT NULL`;
+		if (value[0] === "IN") {
+			const [, ...columns] = value;
+			return `${column} IN (${[columns.map((column) => SqlString.escape(column)).join(", ")]})`;
+		}
+		if (value[0] === "BETWEEN") return `${column} BETWEEN ${SqlString.escape(value[1])} AND ${SqlString.escape(value[2])}`;
+		if (Object.keys(Comparison).includes(value[0])) return `${column} ${value[0]} ${SqlString.escape(value[1])}`;
+		throw new SasatError("SQL PARSE ERROR");
+	}).join(` ${type} `);
+};
+//#endregion
+//#region src/db/sql/expression/conditionExpression.ts
+const conditionExpressionToSql = (exp) => {
+	if (Array.isArray(exp)) return CompositeCondition.and(exp).toSQL();
+	if (exp instanceof CompositeCondition) return exp.toSQL();
+	return comparisonExpressionToSql(exp);
+};
+//#endregion
+//#region src/db/sql/expression/compositeCondition.ts
+var CompositeCondition = class CompositeCondition {
+	constructor(type, conditions) {
+		this.type = type;
+		this.conditions = conditions;
+	}
+	static or(conditions) {
+		return new CompositeCondition("OR", conditions);
+	}
+	static and(conditions) {
+		return new CompositeCondition("AND", conditions);
+	}
+	toSQL() {
+		return "(" + this.conditions.map(conditionExpressionToSql).join(this.type) + ")";
+	}
+};
+//#endregion
+//#region src/runtime/createTypeDef.ts
+const makeArgs = (args) => {
+	if (!args || args.length === 0) return "";
+	return `(${args.map((arg) => `${arg.name}: ${arg.type}`).join(", ")})`;
+};
+const makeTypedefString = (typeName, typedef, type) => {
+	const entries = Object.entries(typedef);
+	if (entries.length === 0) return "";
+	return `\
+${type} ${typeName} {
+${entries.map(([field, value]) => {
+		if (!value.return) throw new Error(`Return type required: ${typeName}.${field}`);
+		return `  ${field}${makeArgs(value.args)}: ${value.return}`;
+	}).join("\n")}
+}
+`;
+};
+const createTypeDef = (typeDefs, inputs) => {
+	const types = Object.entries(typeDefs).map(([type, fields]) => makeTypedefString(type, fields, "type"));
+	const input = Object.entries(inputs).map(([type, fields]) => makeTypedefString(type, fields, "input"));
+	return types.join("\n") + input.join("\n");
+};
+//#endregion
+//#region src/runtime/dsl/factory.ts
+const compound = (expr, operator) => {
+	const active = expr.filter(nonNullable);
+	if (active.length === 0) return conditions.eq(literal(1), literal(1));
+	return active.reduce((acc, current) => ({
+		kind: 4,
+		left: acc,
+		operator,
+		right: current
+	}));
+};
+const containsExpr = (isNot, type) => (left, right) => ({
+	kind: 10,
+	type,
+	left,
+	isNot,
+	right
+});
+const comparison = (operator) => (left, right) => ({
+	kind: 5,
+	left,
+	operator,
+	right
+});
+const and = (...expr) => compound(expr, "AND");
+const or = (...expr) => compound(expr, "OR");
+const field = (table, name, alias) => ({
+	kind: 0,
+	table,
+	name,
+	alias
+});
+const fn = (fnName, args, alias) => ({
+	kind: 1,
+	fnName,
+	args,
+	alias
+});
+const window = (type, value) => ({
+	kind: 18,
+	type,
+	between: false,
+	value
+});
+const windowBetween = (type, start, end) => ({
+	kind: 18,
+	type,
+	between: true,
+	start,
+	end
+});
+const paren = (expression) => ({
+	kind: 7,
+	expression
+});
+const In = (left, right) => {
+	if (Array.isArray(right)) {
+		if (right.length === 0) return conditions.eq(literal(0), literal(1));
+		return {
+			kind: 8,
+			left,
+			operator: "IN",
+			right: right.map(literal)
+		};
+	}
+	return {
+		kind: 8,
+		left,
+		operator: "IN",
+		query: right
+	};
+};
+const notIn = (left, values) => ({
+	kind: 8,
+	left,
+	operator: "NOT IN",
+	right: values.map(literal)
+});
+const between = (left, begin, end) => ({
+	kind: 9,
+	left,
+	begin,
+	end
+});
+const isNull = (isNot) => (expr) => ({
+	kind: 6,
+	expr,
+	isNot
+});
+const simpleWhere = (tableNameOrAlias, where, isOr = false) => {
+	return (isOr ? or : and)(...Object.entries(where).map(([f, value]) => {
+		const fe = field(tableNameOrAlias, f);
+		if (Array.isArray(value)) return comparison(value[0])(fe, literal(value[1]));
+		return conditions.eq(fe, literal(value));
+	}));
+};
+const exists = (query) => ({
+	kind: 14,
+	query
+});
+const raw = (sql) => ({
+	kind: 15,
+	expr: sql
+});
+const conditions = {
+	simpleWhere,
+	and,
+	or,
+	eq: comparison("="),
+	neq: comparison("<>"),
+	gt: comparison(">"),
+	gte: comparison(">="),
+	lt: comparison("<"),
+	lte: comparison("<="),
+	comparison: (left, operator, right) => comparison(operator)(left, right),
+	contains: containsExpr(false, "contains"),
+	notContains: containsExpr(true, "contains"),
+	startsWith: containsExpr(false, "start"),
+	notStartsWith: containsExpr(true, "start"),
+	endsWith: containsExpr(false, "end"),
+	notEndsWith: containsExpr(true, "end"),
+	in: In,
+	notIn,
+	between,
+	isNull: isNull(false),
+	isNotNull: isNull(true),
+	exists
+};
+const table = (name, joins, alias) => ({
+	kind: 2,
+	subquery: false,
+	name,
+	alias,
+	joins
+});
+const subQueryTable = (query, joins, alias) => ({
+	kind: 2,
+	subquery: true,
+	query,
+	alias,
+	joins
+});
+const join = (table, conditions, type) => ({
+	kind: 3,
+	type,
+	table,
+	conditions
+});
+const literal = (value) => ({
+	kind: 11,
+	value
+});
+const sort = (field, direction) => ({
+	kind: 12,
+	field,
+	direction
+});
+const ident = (identifier) => ({
+	kind: 13,
+	identifier
+});
+const QExpr = {
+	conditions,
+	...conditions,
+	field,
+	fn,
+	window,
+	windowBetween,
+	paren,
+	table,
+	subQueryTable,
+	join,
+	value: literal,
+	sort,
+	order: sort,
+	ident,
+	id: ident,
+	raw
+};
+//#endregion
+//#region src/runtime/date.ts
+const dateOffset = (date, timeZoneHour) => {
+	const offset = timeZoneHour ? timeZoneHour * 60 * 60 * 1e3 : date.getTimezoneOffset() * 6e4;
+	return new Date(date.getTime() + offset);
+};
+const zeroPad = (v, len) => v.toString().padStart(len, "0");
+const dateToDatetimeString = (d) => {
+	const year = d.getUTCFullYear();
+	const month = d.getUTCMonth() + 1;
+	const day = d.getUTCDate();
+	const hour = d.getUTCHours();
+	const minute = d.getUTCMinutes();
+	const second = d.getUTCSeconds();
+	const millisecond = d.getUTCMilliseconds();
+	return zeroPad(year, 4) + "-" + zeroPad(month, 2) + "-" + zeroPad(day, 2) + " " + zeroPad(hour, 2) + ":" + zeroPad(minute, 2) + ":" + zeroPad(second, 2) + "." + zeroPad(millisecond, 3);
+};
+const dateToDateString = (d) => {
+	const year = d.getUTCFullYear();
+	const month = d.getUTCMonth() + 1;
+	const day = d.getUTCDate();
+	return zeroPad(year, 4) + "-" + zeroPad(month, 2) + "-" + zeroPad(day, 2);
+};
+const getTodayDateString = (timeZoneHour) => {
+	const date = /* @__PURE__ */ new Date();
+	date.setHours(0, 0, 0, 0);
+	return dateToDateString(dateOffset(date, timeZoneHour));
+};
+const getTodayDateTimeString = (timeZoneHour) => {
+	const date = /* @__PURE__ */ new Date();
+	date.setHours(0, 0, 0, 0);
+	return dateToDatetimeString(dateOffset(date, timeZoneHour));
+};
+const getDayRange = (date, timeZoneHour) => {
+	date.setHours(0, 0, 0, 0);
+	const d = dateOffset(date, timeZoneHour || 0);
+	const begin = dateToDatetimeString(d);
+	d.setDate(d.getDate() + 1);
+	return [begin, dateToDatetimeString(d)];
+};
+const getDayRangeQExpr = (date, timeZoneHour) => {
+	return getDayRange(date, timeZoneHour).map(QExpr.value);
+};
+//#endregion
+//#region src/runtime/gqlResolveInfoToField.ts
+const selectionSetToField = (selections, number) => {
+	const result = {
+		fields: [],
+		relations: {},
+		tableAlias: "t" + number
+	};
+	let num = number;
+	for (const it of selections) {
+		if (it.kind !== "Field") continue;
+		if (it.selectionSet) {
+			num += 1;
+			const field = selectionSetToField(it.selectionSet.selections, num);
+			result.relations[it.name.value] = field[0];
+			num = field[1];
+		} else if (it.name.value !== "__typename") result.fields.push(it.name.value);
+	}
+	return [result, num];
+};
+const gqlResolveInfoToField = (info) => {
+	return selectionSetToField(info.fieldNodes[0].selectionSet.selections, 0)[0];
+};
+//#endregion
+//#region src/runtime/id.ts
+const makeNumberIdEncoder = (hashId) => {
+	return {
+		encode: (id) => hashId.encode(id),
+		decode: (id) => hashId.decode(id)[0]
+	};
+};
+//#endregion
+//#region src/runtime/makeResolver.ts
+const makeResolver = (resolver, middlewares = []) => {
+	return (...args) => {
+		return resolver(...middlewares.reduce((args, middleware) => {
+			return middleware(args);
+		}, args));
+	};
+};
+//#endregion
+//#region src/runtime/resolverMiddleware.ts
+const makeParamsMiddleware = (update) => {
+	return (args) => {
+		args[1] = update(args[1]);
+		return args;
+	};
+};
+//#endregion
+//#region src/runtime/dsl/mutation/mutation.ts
+const escapeId = SqlString$1.escapeId;
+const onDuplicateKeyUpdate = (columns) => {
+	if (!columns || columns.length === 0) return "";
+	return " ON DUPLICATE KEY UPDATE " + columns.map(escapeId).map((it) => `${it} = VALUES(${it})`).join(",");
+};
+const createToSql = (dsl, tableInfo) => {
+	const map = tableInfo[dsl.table].columnMap;
+	const values = dsl.entities.map((it) => `(${it.map((it) => SqlString$1.escape(it)).join(",")})`).join(",");
+	return `INSERT ${dsl.ignore ? "IGNORE " : ""}INTO ${escapeId(dsl.table)}(${dsl.fields.map((it) => escapeId(map[it]))}) VALUES ${values} ${onDuplicateKeyUpdate(dsl.upsert)}`;
+};
+const updateToSql = (dsl, tableInfo) => {
+	const map = tableInfo[dsl.table].columnMap;
+	return `UPDATE ${escapeId(dsl.table)} SET ${dsl.values.map((it) => escapeId(map[it.field]) + " = " + SqlString$1.escape(it.value)).join(", ")} WHERE ${Sql.booleanValue(dsl.where)}`;
+};
+const deleteToSql = (dsl) => {
+	return `DELETE FROM ${escapeId(dsl.table)} WHERE ${Sql.booleanValue(dsl.where)}`;
+};
+//#endregion
+//#region src/runtime/dsl/query/createQueryResolveInfo.ts
+const joinToQueryResolveInfo = (parentTableAlias, property, fields, map, tableInfo) => {
+	const info = map[parentTableAlias][property];
+	if (!info) return void 0;
+	return {
+		tableAlias: fields.tableAlias || info.table,
+		isArray: info.array,
+		keyAliases: tableInfo[info.table].identifiableFields,
+		joins: Object.entries(fields.relations || {}).filter(([, value]) => value).map(([key, value]) => joinToQueryResolveInfo(info.table, key, value, map, tableInfo)).filter(nonNullable),
+		property
+	};
+};
+const createQueryResolveInfo = (tableName, fields, map, tableInfo) => {
+	return {
+		tableAlias: fields.tableAlias || tableName,
+		isArray: true,
+		keyAliases: tableInfo[tableName].identifiableFields,
+		joins: Object.entries(fields.relations || {}).filter(([, value]) => value).map(([key, value]) => joinToQueryResolveInfo(tableName, key, value, map, tableInfo)).filter(nonNullable),
+		property: ""
+	};
+};
+//#endregion
+//#region src/runtime/dsl/query/sql/hydrate.ts
+const rowToObjs = (row) => {
+	const objs = {};
+	for (const [key, value] of Object.entries(row)) {
+		const [table, column] = key.split("__");
+		if (!objs[table]) objs[table] = {};
+		objs[table][column] = value;
+	}
+	return objs;
+};
+const getUnique = (obj, info) => info.keyAliases.map((it) => obj[it]).join("_~_");
+const execTable = (info, objs, current) => {
+	let entity = objs[info.tableAlias];
+	if (entity[info.keyAliases[0]] == null) entity = null;
+	let result;
+	let currentTarget;
+	if (info.isArray) if (!current) {
+		result = entity == null ? [] : [entity];
+		currentTarget = entity;
+	} else {
+		currentTarget = entity == null ? null : current.find((item) => item && info.keyAliases.every((key) => item[key] === entity[key]));
+		if (currentTarget) result = current;
+		else {
+			currentTarget = entity;
+			result = current;
+			if (currentTarget) result.push(currentTarget);
+		}
+	}
+	else {
+		currentTarget = current || entity;
+		result = currentTarget;
+	}
+	if (currentTarget !== null) for (const it of info.joins) currentTarget[it.property] = execTable(it, objs, currentTarget[it.property]);
+	return result;
+};
+/**
+* to use this function require to select primary keys for every table
+*/
+const hydrate = (data, info) => {
+	const result = [];
+	const t0mapper = {};
+	info.isArray = false;
+	for (const row of data) {
+		const objs = rowToObjs(row);
+		const currentObj = objs[info.tableAlias];
+		const unique = getUnique(currentObj, info);
+		if (t0mapper[unique] === void 0) {
+			t0mapper[unique] = result.length;
+			result.push(execTable(info, objs, currentObj));
+			continue;
+		}
+		const base = result[t0mapper[unique]];
+		execTable(info, objs, base);
+	}
+	return result;
+};
+//#endregion
+//#region src/runtime/sql/runQuery.ts
+const notTypeName = (fieldName) => fieldName !== "__typename";
+const createQuery = (baseTableName, fields, options, tableInfo, relationMap, context) => {
+	let tableCount = 0;
+	const select = [];
+	const resolveFields = (tableName, table) => {
+		const tableAlias = table.tableAlias || "t" + tableCount;
+		table.tableAlias = tableAlias;
+		tableCount++;
+		const info = tableInfo[tableName];
+		select.push(...unique([...table.fields.filter((it) => {
+			return notTypeName(it) && info.columnMap[it];
+		}), ...info.identifiableFields]).map((it) => {
+			const realName = info.columnMap[it] || it;
+			return QExpr.field(tableAlias, realName, tableAlias + "__" + it);
+		}));
+		return QExpr.table(tableName, Object.entries(table.relations || {}).map(([relationName, table]) => {
+			const current = tableCount;
+			const rel = relationMap[tableName][relationName];
+			if (!rel) return void 0;
+			return QExpr.join(resolveFields(rel.table, table), QExpr.and(rel.condition({
+				parentTableAlias: tableAlias,
+				childTableAlias: table.tableAlias || "t" + current,
+				context
+			}), table.joinOn), table.joinType ?? "LEFT");
+		}).filter(nonNullable), tableAlias);
+	};
+	return {
+		select,
+		from: resolveFields(baseTableName, fields),
+		...options
+	};
+};
+const createPagingInnerQuery = (tableName, tableAlias, fields, option, tableInfo, relationMap) => {
+	const map = tableInfo[tableName].columnMap;
+	return {
+		select: unique([
+			...tableInfo[tableName].identifiableKeys,
+			...Object.keys(fields.relations || {}).flatMap((key) => {
+				return relationMap[tableName][key]?.requiredColumns || [];
+			}),
+			...fields.fields.filter((it) => notTypeName(it) && map[it]).map((it) => map[it] || it)
+		]).map((it) => QExpr.field(tableAlias, it)),
+		from: QExpr.table(tableName, option.join || [], tableAlias),
+		limit: option.numberOfItem,
+		offset: option.offset,
+		where: option.where,
+		sort: option.sort
+	};
+};
+const createPagingFieldQuery = ({ baseTableName, fields, queryOption, pagingOption, tableInfo, relationMap, context }) => {
+	const innerQuery = createPagingInnerQuery(baseTableName, fields.tableAlias || "t0", fields, pagingOption, tableInfo, relationMap);
+	const main = createQuery(baseTableName, fields, queryOption, tableInfo, relationMap, context);
+	return {
+		select: main.select,
+		from: {
+			...main.from,
+			subquery: true,
+			query: innerQuery
+		}
+	};
+};
+//#endregion
+//#region src/runtime/sasatDBDatasource.ts
+var SasatDBDatasource = class {
+	constructor(client = getDbClient()) {
+		this.client = client;
+	}
+	async create(entity, option) {
+		const obj = {
+			...this.getDefaultValueString(),
+			...entity
+		};
+		const fields = Object.keys(obj);
+		const sql = createToSql({
+			table: this.tableName,
+			fields,
+			entities: [fields.map((key) => obj[key])],
+			upsert: option?.upsert?.updateColumns,
+			ignore: option?.ignore
+		}, this.tableInfo);
+		const response = await this.client.rawCommand(sql);
+		if (!this.autoIncrementColumn) return obj;
+		return {
+			...obj,
+			[this.autoIncrementColumn]: response.insertId
+		};
+	}
+	async createBulk(entities, option) {
+		if (entities.length === 0) return null;
+		const objects = entities.map((it) => ({
+			...this.getDefaultValueString(),
+			...it
+		}));
+		const keys = Object.keys(objects[0]);
+		const values = objects.map((it) => keys.map((key) => it[key]));
+		const sql = createToSql({
+			table: this.tableName,
+			fields: keys,
+			entities: values,
+			upsert: option?.upsert?.updateColumns,
+			ignore: option?.ignore
+		}, this.tableInfo);
+		return await this.client.rawCommand(sql);
+	}
+	async upsert(entity, updateFields = this.primaryKeys) {
+		return this.create(entity, { upsert: { updateColumns: this.fieldToColumn(updateFields) } });
+	}
+	update(entity) {
+		const sql = updateToSql({
+			table: this.tableName,
+			values: Object.entries(entity).filter(([, value]) => value !== void 0).map(([column, value]) => ({
+				field: column,
+				value
+			})),
+			where: this.createIdentifiableExpression(entity)
+		}, this.tableInfo);
+		return this.client.rawCommand(sql);
+	}
+	updateWhere(update, condition) {
+		const sql = updateToSql({
+			table: this.tableName,
+			values: Object.entries(update).filter(([, value]) => value !== void 0).map(([column, value]) => ({
+				field: column,
+				value
+			})),
+			where: condition
+		}, this.tableInfo);
+		return this.client.rawCommand(sql);
+	}
+	async delete(entity) {
+		return this.deleteWhere(this.createIdentifiableExpression(entity));
+	}
+	async deleteWhere(condition) {
+		const sql = deleteToSql({
+			table: this.tableName,
+			where: condition
+		});
+		return this.client.rawCommand(sql);
+	}
+	async first(fields, option, context) {
+		const result = await this.find(fields, option, context);
+		if (result.length !== 0) return result[0];
+		return null;
+	}
+	async find(fields = { fields: this.fields }, options, context) {
+		const query = createQuery(this.tableName, fields, options, this.tableInfo, this.relationMap, context);
+		return this.executeQuery(query, fields);
+	}
+	async findPageable(paging, fields = { fields: this.fields }, options, context) {
+		const query = createPagingFieldQuery({
+			baseTableName: this.tableName,
+			fields,
+			tableInfo: this.tableInfo,
+			relationMap: this.relationMap,
+			pagingOption: paging,
+			queryOption: options,
+			context
+		});
+		return this.executeQuery(query, fields);
+	}
+	async executeQuery(query, fields) {
+		const info = createQueryResolveInfo(this.tableName, fields, this.relationMap, this.tableInfo);
+		const sql = queryToSql(query);
+		return hydrate(await this.client.rawQuery(sql), info);
+	}
+	createIdentifiableExpression(entity) {
+		const expr = this.identifyFields.map((it) => {
+			const value = entity[it];
+			if (!value) throw new Error(`field ${it} is required`);
+			return QExpr.eq(QExpr.field(this.tableName, this.tableInfo[this.tableName].columnMap[it]), QExpr.value(value));
+		});
+		return QExpr.and(...expr);
+	}
+	getRelationMap() {
+		return this.relationMap[this.tableName];
+	}
+	fieldToColumn(fields) {
+		return fields.map((it) => this.tableInfo[this.tableName].columnMap[it] || it);
+	}
+};
+//#endregion
+//#region src/util/dateUtil.ts
+const getCurrentDateTimeString = () => {
+	const pad = (number) => {
+		if (number < 10) return "0" + number;
+		return number;
+	};
+	const date = /* @__PURE__ */ new Date();
+	return date.getFullYear() + "-" + pad(date.getMonth() + 1) + "-" + pad(date.getDate()) + " " + pad(date.getHours()) + ":" + pad(date.getMinutes()) + ":" + pad(date.getSeconds());
+};
+//#endregion
+//#region src/runtime/pagingOption.ts
+const pagingOption = (option) => {
+	const sort = option.order ? [QExpr.sort(QExpr.field("t1", option.order), option?.asc === false ? "DESC" : "ASC")] : [];
+	return {
+		numberOfItem: option.numberOfItem,
+		offset: option.offset,
+		sort
+	};
+};
+//#endregion
+export { CompositeCondition as _, makeResolver as a, MysqlClient as b, dateOffset as c, getDayRange as d, getDayRangeQExpr as f, createTypeDef as g, QExpr as h, makeParamsMiddleware as i, dateToDateString as l, getTodayDateTimeString as m, getCurrentDateTimeString as n, makeNumberIdEncoder as o, getTodayDateString as p, SasatDBDatasource as r, gqlResolveInfoToField as s, pagingOption as t, dateToDatetimeString as u, queryToSql as v, Sql as y };