sasat 0.21.21 → 0.22.1

package/dist/index.cjs

@@ -1,1065 +1,895 @@
-'use strict';
-
-const error = require('./shared/sasat.DHiyRw3a.cjs');
-require('path');
-require('fs-extra');
-require('js-yaml');
-const SqlString = require('sqlstring');
-require('mysql2');
-require('util');
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
-const SqlString__namespace = /*#__PURE__*/_interopNamespaceCompat(SqlString);
-
-var QueryNodeKind = /* @__PURE__ */ ((QueryNodeKind2) => {
-  QueryNodeKind2[QueryNodeKind2["Field"] = 0] = "Field";
-  QueryNodeKind2[QueryNodeKind2["Function"] = 1] = "Function";
-  QueryNodeKind2[QueryNodeKind2["Table"] = 2] = "Table";
-  QueryNodeKind2[QueryNodeKind2["Join"] = 3] = "Join";
-  QueryNodeKind2[QueryNodeKind2["CompoundExpr"] = 4] = "CompoundExpr";
-  QueryNodeKind2[QueryNodeKind2["ComparisonExpr"] = 5] = "ComparisonExpr";
-  QueryNodeKind2[QueryNodeKind2["IsNullExpr"] = 6] = "IsNullExpr";
-  QueryNodeKind2[QueryNodeKind2["Parenthesis"] = 7] = "Parenthesis";
-  QueryNodeKind2[QueryNodeKind2["InExpr"] = 8] = "InExpr";
-  QueryNodeKind2[QueryNodeKind2["BetweenExpr"] = 9] = "BetweenExpr";
-  QueryNodeKind2[QueryNodeKind2["ContainsExpr"] = 10] = "ContainsExpr";
-  QueryNodeKind2[QueryNodeKind2["Literal"] = 11] = "Literal";
-  QueryNodeKind2[QueryNodeKind2["Sort"] = 12] = "Sort";
-  QueryNodeKind2[QueryNodeKind2["Identifier"] = 13] = "Identifier";
-  QueryNodeKind2[QueryNodeKind2["Exists"] = 14] = "Exists";
-  QueryNodeKind2[QueryNodeKind2["Raw"] = 15] = "Raw";
-  QueryNodeKind2[QueryNodeKind2["GroupBy"] = 16] = "GroupBy";
-  QueryNodeKind2[QueryNodeKind2["Over"] = 17] = "Over";
-  QueryNodeKind2[QueryNodeKind2["Window"] = 18] = "Window";
-  return QueryNodeKind2;
-})(QueryNodeKind || {});
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_migrate = require("./migrate-Cc47Mufl.cjs");
+let sqlstring = require("sqlstring");
+sqlstring = require_migrate.__toESM(sqlstring, 1);
+let mysql2_promise = require("mysql2/promise");
+//#region src/db/connectors/mysql/client.ts
+var MysqlClient = class extends require_migrate.DBClient {
+	async release() {}
+	constructor(connectionOption, logger) {
+		super(logger);
+		this.connectionOption = connectionOption;
+	}
+	getConnection() {
+		return (0, mysql2_promise.createConnection)({
+			dateStrings: true,
+			...this.connectionOption
+		});
+	}
+	async transaction() {
+		const connection = await this.getConnection();
+		await connection.beginTransaction();
+		return new require_migrate.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(",")} `;
+	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(",")} `;
+	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;
+	if (value.type === "FOLLOWING" || value.type === "PRECEDING") return `${value.value} ${value.type}`;
+	return value.type;
 }
-function window$1(window2) {
-  if (!window2) return "";
-  if (window2.between) {
-    return `${window2.type} BETWEEN ${windowValue(window2.start)} AND ${window2.end}`;
-  }
-  return `${window2.type} ${windowValue(window2.value)}`;
+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)})`;
+	if (!v) return "";
+	return `OVER (${partitionBy(v.partitionBy)}${orderBy(v.orderBy)}${window$1(v.window)})`;
 }
-const SELECT_ALIAS_SEPARATOR = "__";
 const Sql = {
-  select: (expr) => {
-    switch (expr.kind) {
-      case QueryNodeKind.Raw:
-        return expr.expr;
-      case QueryNodeKind.Field:
-        return Sql.fieldInSelect(expr);
-      case QueryNodeKind.Identifier:
-        return Sql.identifier(expr);
-      case QueryNodeKind.Function:
-        return Sql.fn(expr);
-    }
-  },
-  literal: (literal) => error.SqlString.escape(literal.value),
-  fieldInCondition: (identifier) => error.SqlString.escapeId(identifier.table) + "." + error.SqlString.escapeId(identifier.name),
-  fieldInSelect: (identifier) => {
-    const alias = identifier.alias && identifier.name !== identifier.alias ? " AS " + error.SqlString.escapeId(identifier.alias) : "";
-    return error.SqlString.escapeId(identifier.table) + "." + error.SqlString.escapeId(identifier.name) + alias;
-  },
-  identifier: (ident) => {
-    return error.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 === QueryNodeKind.Function) return Sql.fn(v);
-    if (v.kind === QueryNodeKind.Field) return Sql.fieldInCondition(v);
-    if (v.kind === QueryNodeKind.Identifier) 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} ${error.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 error.SqlString.escapeId(table.name);
-      return error.SqlString.escapeId(table.name) + " AS " + error.SqlString.escapeId(table.alias);
-    }
-    return `(${queryToSql(table.query)}) AS ${error.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 QueryNodeKind.BetweenExpr:
-        return Sql.between(expr);
-      case QueryNodeKind.CompoundExpr:
-        return Sql.compound(expr);
-      case QueryNodeKind.ComparisonExpr:
-        return Sql.comparison(expr);
-      case QueryNodeKind.ContainsExpr:
-        return Sql.contains(expr);
-      case QueryNodeKind.Parenthesis:
-        return Sql.paren(expr);
-      case QueryNodeKind.InExpr:
-        return Sql.in(expr);
-      case QueryNodeKind.IsNullExpr:
-        return Sql.isNull(expr);
-      case QueryNodeKind.Exists:
-        return Sql.exists(expr);
-    }
-  },
-  exists: (expr) => {
-    return `EXISTS (${Sql.queryOrRaw(expr.query)})`;
-  },
-  sort: (expr) => {
-    const field = () => {
-      switch (expr.field.kind) {
-        case QueryNodeKind.Field:
-          return Sql.fieldInCondition(expr.field);
-        case QueryNodeKind.Identifier:
-          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);
-  }
-};
-
+	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) => require_migrate.SqlString.escape(literal.value),
+	fieldInCondition: (identifier) => require_migrate.SqlString.escapeId(identifier.table) + "." + require_migrate.SqlString.escapeId(identifier.name),
+	fieldInSelect: (identifier) => {
+		const alias = identifier.alias && identifier.name !== identifier.alias ? " AS " + require_migrate.SqlString.escapeId(identifier.alias) : "";
+		return require_migrate.SqlString.escapeId(identifier.table) + "." + require_migrate.SqlString.escapeId(identifier.name) + alias;
+	},
+	identifier: (ident) => {
+		return require_migrate.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} ${require_migrate.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 require_migrate.SqlString.escapeId(table.name);
+			return require_migrate.SqlString.escapeId(table.name) + " AS " + require_migrate.SqlString.escapeId(table.alias);
+		}
+		return `(${queryToSql(table.query)}) AS ${require_migrate.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);
+		}
+	},
+	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)]);
+	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";
+	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).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);
-};
-
-const makeParamsMiddleware = (update) => {
-  return (args) => {
-    args[1] = update(args[1]);
-    return args;
-  };
+	const select = query.select.map(Sql.select).join(", ");
+	const join = getJoin(query.from).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 require_migrate.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/migration/makeMutaion.ts
+const formatSubscription = (subscription) => {
+	if (subscription === void 0 || subscription === false) return {
+		enabled: false,
+		subscriptionFilter: []
+	};
+	if (subscription === true) return {
+		enabled: true,
+		subscriptionFilter: []
+	};
+	return {
+		enabled: subscription.enabled,
+		subscriptionFilter: subscription.subscriptionFilter || []
+	};
 };
-
-const makeNumberIdEncoder = (hashId) => {
-  return {
-    encode: (id) => hashId.encode(id),
-    decode: (id) => hashId.decode(id)[0]
-  };
+const formatOptions = (type, option) => ({
+	type,
+	noReFetch: option?.noRefetch || false,
+	middlewares: option?.middlewares || [],
+	contextFields: option?.contextFields || [],
+	subscription: formatSubscription(option?.subscription)
+});
+const Mutations = {
+	create: (options) => formatOptions("create", options),
+	update: (options) => formatOptions("update", options),
+	delete: (options) => formatOptions("delete", options)
 };
-
+//#endregion
+//#region src/migration/makeQuery.ts
 const single = (name, options) => ({
-  type: "single",
-  name,
-  conditions: options?.conditions || [],
-  middlewares: options?.middlewares || []
+	type: "single",
+	name,
+	conditions: options?.conditions || [],
+	middlewares: options?.middlewares || []
 });
 const listAll = (name, options) => ({
-  type: "list-all",
-  name,
-  conditions: options?.conditions || [],
-  middlewares: options?.middlewares || []
+	type: "list-all",
+	name,
+	conditions: options?.conditions || [],
+	middlewares: options?.middlewares || []
 });
 const paging = (name, options) => ({
-  type: "list-paging",
-  name,
-  conditions: options?.conditions || [],
-  middlewares: options?.middlewares || []
+	type: "list-paging",
+	name,
+	conditions: options?.conditions || [],
+	middlewares: options?.middlewares || []
 });
 const primary = (middlewares = []) => ({
-  type: "primary",
-  conditions: [],
-  middlewares
+	type: "primary",
+	conditions: [],
+	middlewares
 });
 const Queries = {
-  single,
-  listAll,
-  paging,
-  primary
+	single,
+	listAll,
+	paging,
+	primary
 };
-
-const formatSubscription = (subscription) => {
-  if (subscription === void 0 || subscription === false) {
-    return {
-      enabled: false,
-      subscriptionFilter: []
-    };
-  }
-  if (subscription === true)
-    return {
-      enabled: true,
-      subscriptionFilter: []
-    };
-  return {
-    enabled: subscription.enabled,
-    subscriptionFilter: subscription.subscriptionFilter || []
-  };
+//#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 formatOptions = (type, option) => ({
-  type,
-  noReFetch: option?.noRefetch || false,
-  middlewares: option?.middlewares || [],
-  contextFields: option?.contextFields || [],
-  subscription: formatSubscription(option?.subscription)
-});
-const Mutations = {
-  create: (options) => formatOptions("create", options),
-  update: (options) => formatOptions("update", options),
-  delete: (options) => formatOptions("delete", options)
+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(error.nonNullable);
-  if (active.length === 0) return conditions.eq(literal(1), literal(1));
-  return active.reduce((acc, current) => ({
-    kind: QueryNodeKind.CompoundExpr,
-    left: acc,
-    operator,
-    right: current
-  }));
+	const active = expr.filter(require_migrate.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: QueryNodeKind.ContainsExpr,
-  type,
-  left,
-  isNot,
-  right
+	kind: 10,
+	type,
+	left,
+	isNot,
+	right
 });
 const comparison = (operator) => (left, right) => ({
-  kind: QueryNodeKind.ComparisonExpr,
-  left,
-  operator,
-  right
+	kind: 5,
+	left,
+	operator,
+	right
 });
 const and = (...expr) => compound(expr, "AND");
 const or = (...expr) => compound(expr, "OR");
-const field = (table2, name, alias) => ({
-  kind: QueryNodeKind.Field,
-  table: table2,
-  name,
-  alias
+const field = (table, name, alias) => ({
+	kind: 0,
+	table,
+	name,
+	alias
 });
 const fn = (fnName, args, alias) => ({
-  kind: QueryNodeKind.Function,
-  fnName,
-  args,
-  alias
+	kind: 1,
+	fnName,
+	args,
+	alias
 });
 const window = (type, value) => ({
-  kind: QueryNodeKind.Window,
-  type,
-  between: false,
-  value
+	kind: 18,
+	type,
+	between: false,
+	value
 });
 const windowBetween = (type, start, end) => ({
-  kind: QueryNodeKind.Window,
-  type,
-  between: true,
-  start,
-  end
+	kind: 18,
+	type,
+	between: true,
+	start,
+	end
 });
 const paren = (expression) => ({
-  kind: QueryNodeKind.Parenthesis,
-  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: QueryNodeKind.InExpr,
-      left,
-      operator: "IN",
-      right: right.map(literal)
-    };
-  }
-  return {
-    kind: QueryNodeKind.InExpr,
-    left,
-    operator: "IN",
-    query: 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: QueryNodeKind.InExpr,
-  left,
-  operator: "NOT IN",
-  right: values.map(literal)
+	kind: 8,
+	left,
+	operator: "NOT IN",
+	right: values.map(literal)
 });
 const between = (left, begin, end) => ({
-  kind: QueryNodeKind.BetweenExpr,
-  left,
-  begin,
-  end
+	kind: 9,
+	left,
+	begin,
+	end
 });
 const isNull = (isNot) => (expr) => ({
-  kind: QueryNodeKind.IsNullExpr,
-  expr,
-  isNot
+	kind: 6,
+	expr,
+	isNot
 });
 const simpleWhere = (tableNameOrAlias, where, isOr = false) => {
-  const compound2 = isOr ? or : and;
-  return compound2(
-    ...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));
-    })
-  );
+	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: QueryNodeKind.Exists,
-  query
+	kind: 14,
+	query
 });
 const raw = (sql) => ({
-  kind: QueryNodeKind.Raw,
-  expr: 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
+	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: QueryNodeKind.Table,
-  subquery: false,
-  name,
-  alias,
-  joins
+	kind: 2,
+	subquery: false,
+	name,
+	alias,
+	joins
 });
 const subQueryTable = (query, joins, alias) => ({
-  kind: QueryNodeKind.Table,
-  subquery: true,
-  query,
-  alias,
-  joins
+	kind: 2,
+	subquery: true,
+	query,
+	alias,
+	joins
 });
-const join = (table2, conditions2, type) => ({
-  kind: QueryNodeKind.Join,
-  type,
-  table: table2,
-  conditions: conditions2
+const join = (table, conditions, type) => ({
+	kind: 3,
+	type,
+	table,
+	conditions
 });
 const literal = (value) => ({
-  kind: QueryNodeKind.Literal,
-  value
+	kind: 11,
+	value
 });
-const sort = (field2, direction) => ({
-  kind: QueryNodeKind.Sort,
-  field: field2,
-  direction
+const sort = (field, direction) => ({
+	kind: 12,
+	field,
+	direction
 });
 const ident = (identifier) => ({
-  kind: QueryNodeKind.Identifier,
-  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
+	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 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];
+	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]
+	};
 };
-
-const escape = error.SqlString.escape;
-const escapeId = error.SqlString.escapeId;
+//#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 = require_migrate.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(",");
+	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((it2) => escape(it2)).join(",")})`).join(",");
-  return `INSERT ${dsl.ignore ? "IGNORE " : ""}INTO ${escapeId(
-    dsl.table
-  )}(${dsl.fields.map((it) => escapeId(map[it]))}) VALUES ${values} ${onDuplicateKeyUpdate(dsl.upsert)}`;
+	const map = tableInfo[dsl.table].columnMap;
+	const values = dsl.entities.map((it) => `(${it.map((it) => require_migrate.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]) + " = " + escape(it.value)).join(", ")} WHERE ${Sql.booleanValue(dsl.where)}`;
+	const map = tableInfo[dsl.table].columnMap;
+	return `UPDATE ${escapeId(dsl.table)} SET ${dsl.values.map((it) => escapeId(map[it.field]) + " = " + require_migrate.SqlString.escape(it.value)).join(", ")} WHERE ${Sql.booleanValue(dsl.where)}`;
 };
 const deleteToSql = (dsl) => {
-  return `DELETE FROM ${escapeId(dsl.table)} WHERE ${Sql.booleanValue(
-    dsl.where
-  )}`;
+	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;
-  const tableAlias = fields.tableAlias || info.table;
-  return {
-    tableAlias,
-    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(error.nonNullable),
-    property
-  };
+	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(require_migrate.nonNullable),
+		property
+	};
 };
 const createQueryResolveInfo = (tableName, fields, map, tableInfo) => {
-  const tableAlias = fields.tableAlias || tableName;
-  return {
-    tableAlias,
-    isArray: true,
-    keyAliases: tableInfo[tableName].identifiableFields,
-    joins: Object.entries(fields.relations || {}).filter(([, value]) => value).map(
-      ([key, value]) => joinToQueryResolveInfo(
-        tableName,
-        key,
-        value,
-        map,
-        tableInfo
-      )
-    ).filter(error.nonNullable),
-    property: ""
-  };
-};
-
+	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(require_migrate.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(SELECT_ALIAS_SEPARATOR);
-    if (!objs[table]) {
-      objs[table] = {};
-    }
-    objs[table][column] = value;
-  }
-  return objs;
+	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;
-};
+	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;
-};
-
+	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(
-      ...error.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 + SELECT_ALIAS_SEPARATOR + it
-        );
-      })
-    );
-    return QExpr.table(
-      tableName,
-      Object.entries(table.relations || {}).map(([relationName, table2]) => {
-        const current = tableCount;
-        const rel = relationMap[tableName][relationName];
-        if (!rel) return void 0;
-        return QExpr.join(
-          resolveFields(rel.table, table2),
-          QExpr.and(
-            rel.condition({
-              parentTableAlias: tableAlias,
-              childTableAlias: table2.tableAlias || "t" + current,
-              context
-            }),
-            table2.joinOn
-          ),
-          "LEFT"
-        );
-      }).filter(error.nonNullable),
-      tableAlias
-    );
-  };
-  const from = resolveFields(baseTableName, fields);
-  return {
-    select,
-    from,
-    ...options
-  };
+	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(...require_migrate.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), "LEFT");
+		}).filter(require_migrate.nonNullable), tableAlias);
+	};
+	return {
+		select,
+		from: resolveFields(baseTableName, fields),
+		...options
+	};
 };
 const createPagingInnerQuery = (tableName, tableAlias, fields, option, tableInfo, relationMap) => {
-  const map = tableInfo[tableName].columnMap;
-  return {
-    select: error.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 tableAlias = fields.tableAlias || "t0";
-  const innerQuery = createPagingInnerQuery(
-    baseTableName,
-    tableAlias,
-    fields,
-    pagingOption,
-    tableInfo,
-    relationMap
-  );
-  const main = createQuery(
-    baseTableName,
-    fields,
-    queryOption,
-    tableInfo,
-    relationMap,
-    context
-  );
-  return {
-    select: main.select,
-    from: {
-      ...main.from,
-      subquery: true,
-      query: innerQuery
-    }
-  };
-};
-
-class SasatDBDatasource {
-  constructor(client = error.getDbClient()) {
-    this.client = client;
-  }
-  queryLogger = noop;
-  commandLogger = noop;
-  async create(entity, option) {
-    const obj = {
-      ...this.getDefaultValueString(),
-      ...entity
-    };
-    const fields = Object.keys(obj);
-    const dsl = {
-      table: this.tableName,
-      fields,
-      entities: [fields.map((key) => obj[key])],
-      upsert: option?.upsert?.updateColumns,
-      ignore: option?.ignore
-    };
-    const sql = createToSql(dsl, this.tableInfo);
-    this.commandLogger(sql);
-    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 dsl = {
-      table: this.tableName,
-      fields: keys,
-      entities: values,
-      upsert: option?.upsert?.updateColumns,
-      ignore: option?.ignore
-    };
-    const sql = createToSql(dsl, this.tableInfo);
-    this.commandLogger(sql);
-    return await this.client.rawCommand(sql);
-  }
-  async upsert(entity, updateFields = this.primaryKeys) {
-    return this.create(entity, {
-      upsert: {
-        updateColumns: this.fieldToColumn(updateFields)
-      }
-    });
-  }
-  update(entity) {
-    const dsl = {
-      table: this.tableName,
-      values: Object.entries(entity).filter(([, value]) => value !== void 0).map(([column, value]) => ({
-        field: column,
-        value
-      })),
-      where: this.createIdentifiableExpression(entity)
-    };
-    const sql = updateToSql(dsl, this.tableInfo);
-    this.commandLogger(sql);
-    return this.client.rawCommand(sql);
-  }
-  updateWhere(update, condition) {
-    const dsl = {
-      table: this.tableName,
-      values: Object.entries(update).filter(([, value]) => value !== void 0).map(([column, value]) => ({
-        field: column,
-        value
-      })),
-      where: condition
-    };
-    const sql = updateToSql(dsl, this.tableInfo);
-    this.commandLogger(sql);
-    return this.client.rawCommand(sql);
-  }
-  async delete(entity) {
-    return this.deleteWhere(this.createIdentifiableExpression(entity));
-  }
-  async deleteWhere(condition) {
-    const dsl = {
-      table: this.tableName,
-      where: condition
-    };
-    const sql = deleteToSql(dsl);
-    this.commandLogger(sql);
-    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);
-    this.queryLogger(sql);
-    const resultRows = await this.client.rawQuery(sql);
-    return hydrate(resultRows, 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);
-  }
-}
-const noop = () => {
-};
-
+	const map = tableInfo[tableName].columnMap;
+	return {
+		select: require_migrate.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 = require_migrate.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());
-};
-
-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");
-};
-
-var Comparison = /* @__PURE__ */ ((Comparison2) => {
-  Comparison2["eq"] = "=";
-  Comparison2["gt"] = ">";
-  Comparison2["lt"] = "<";
-  Comparison2["gte"] = ">=";
-  Comparison2["lte"] = "<=";
-  Comparison2["neq"] = "<>";
-  Comparison2["like"] = "LIKE";
-  Comparison2["notLike"] = "NOT LIKE";
-  return Comparison2;
-})(Comparison || {});
-const comparisonExpressionToSql = (exp) => {
-  const type = Object.prototype.hasOwnProperty.call(exp, "__type") ? exp.__type || "AND" : "AND";
-  return Object.entries(exp).map(([key, value]) => {
-    const column = SqlString__namespace.escapeId(key);
-    if (!Array.isArray(value))
-      return `${column} = ${SqlString__namespace.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((column2) => SqlString__namespace.escape(column2)).join(", ")
-      ]})`;
-    }
-    if (value[0] === "BETWEEN")
-      return `${column} BETWEEN ${SqlString__namespace.escape(
-        value[1]
-      )} AND ${SqlString__namespace.escape(value[2])}`;
-    if (Object.keys(Comparison).includes(value[0]))
-      return `${column} ${value[0]} ${SqlString__namespace.escape(value[1])}`;
-    throw new error.SasatError("SQL PARSE ERROR");
-  }).join(` ${type} `);
-};
-
-const conditionExpressionToSql = (exp) => {
-  if (Array.isArray(exp)) {
-    return CompositeCondition.and(exp).toSQL();
-  }
-  if (exp instanceof CompositeCondition) return exp.toSQL();
-  return comparisonExpressionToSql(exp);
-};
-
-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) + ")";
-  }
-}
-
-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);
-};
-
-const makeResolver = (resolver, middlewares = []) => {
-  return (...args) => {
-    const newArgs = middlewares.reduce(
-      (args2, middleware) => {
-        return middleware(args2);
-      },
-      args
-    );
-    return resolver(...newArgs);
-  };
-};
-
+	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 };
-};
-
-exports.Conditions = error.Conditions;
-exports.SqlString = error.SqlString;
-exports.assignDeep = error.assignDeep;
-exports.formatQuery = error.formatQuery;
-exports.getDbClient = error.getDbClient;
-exports.pick = error.pick;
-exports.setConfig = error.setConfig;
+	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
 exports.CompositeCondition = CompositeCondition;
+exports.Conditions = require_migrate.Conditions;
 exports.Mutations = Mutations;
+exports.MysqlClient = MysqlClient;
 exports.QExpr = QExpr;
 exports.Queries = Queries;
 exports.SasatDBDatasource = SasatDBDatasource;
 exports.Sql = Sql;
+exports.SqlString = require_migrate.SqlString;
+exports.assignDeep = require_migrate.assignDeep;
 exports.createTypeDef = createTypeDef;
 exports.dateOffset = dateOffset;
 exports.dateToDateString = dateToDateString;
 exports.dateToDatetimeString = dateToDatetimeString;
+exports.formatQuery = require_migrate.formatQuery;
 exports.getCurrentDateTimeString = getCurrentDateTimeString;
 exports.getDayRange = getDayRange;
 exports.getDayRangeQExpr = getDayRangeQExpr;
+exports.getDbClient = require_migrate.getDbClient;
 exports.getTodayDateString = getTodayDateString;
 exports.getTodayDateTimeString = getTodayDateTimeString;
 exports.gqlResolveInfoToField = gqlResolveInfoToField;
 exports.makeNumberIdEncoder = makeNumberIdEncoder;
 exports.makeParamsMiddleware = makeParamsMiddleware;
 exports.makeResolver = makeResolver;
+exports.migrate = require_migrate.migrate;
 exports.pagingOption = pagingOption;
+exports.pick = require_migrate.pick;
 exports.qe = QExpr;
 exports.queryToSql = queryToSql;
+exports.setConfig = require_migrate.setConfig;