sasat 0.22.8 → 0.22.9

package/dist/index.mjs

@@ -1,806 +1,3 @@
-import { a as SqlString, c as setConfig, i as SasatError, m as assignDeep, n as pick, r as unique, t as nonNullable } from "./util-BcMcffJ8.mjs";
-import { i as formatQuery, n as MySqlTransaction, r as DBClient, t as getDbClient } from "./getDbClient-CNcumqpO.mjs";
-import { createConnection } from "mysql2/promise";
-import * as SqlString$1 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.escape(literal.value),
-	fieldInCondition: (identifier) => SqlString.escapeId(identifier.table) + "." + SqlString.escapeId(identifier.name),
-	fieldInSelect: (identifier) => {
-		const alias = identifier.alias && identifier.name !== identifier.alias ? " AS " + SqlString.escapeId(identifier.alias) : "";
-		return SqlString.escapeId(identifier.table) + "." + SqlString.escapeId(identifier.name) + alias;
-	},
-	identifier: (ident) => {
-		return SqlString.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.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.escapeId(table.name);
-			return SqlString.escapeId(table.name) + " AS " + SqlString.escapeId(table.alias);
-		}
-		return `(${queryToSql(table.query)}) AS ${SqlString.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$1.escapeId(key);
-		if (!Array.isArray(value)) return `${column} = ${SqlString$1.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$1.escape(column)).join(", ")]})`;
-		}
-		if (value[0] === "BETWEEN") return `${column} BETWEEN ${SqlString$1.escape(value[1])} AND ${SqlString$1.escape(value[2])}`;
-		if (Object.keys(Comparison).includes(value[0])) return `${column} ${value[0]} ${SqlString$1.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.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.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.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) {
-		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
+import { a as getDbClient, c as formatQuery, f as setConfig, l as SqlString, n as pick, v as assignDeep } from "./util-Dkw5bD7a.mjs";
+import { _ as CompositeCondition, a as makeResolver, b as MysqlClient, c as dateOffset, d as getDayRange, f as getDayRangeQExpr, g as createTypeDef, h as QExpr, i as makeParamsMiddleware, l as dateToDateString, m as getTodayDateTimeString, n as getCurrentDateTimeString, o as makeNumberIdEncoder, p as getTodayDateString, r as SasatDBDatasource, s as gqlResolveInfoToField, t as pagingOption, u as dateToDatetimeString, v as queryToSql, y as Sql } from "./src-DebKrtYl.mjs";
 export { CompositeCondition, MysqlClient, QExpr, QExpr as qe, SasatDBDatasource, Sql, SqlString, assignDeep, createTypeDef, dateOffset, dateToDateString, dateToDatetimeString, formatQuery, getCurrentDateTimeString, getDayRange, getDayRangeQExpr, getDbClient, getTodayDateString, getTodayDateTimeString, gqlResolveInfoToField, makeNumberIdEncoder, makeParamsMiddleware, makeResolver, pagingOption, pick, queryToSql, setConfig };