sasat 0.22.0 → 0.22.2

package/dist/index.mjs

@@ -1,3930 +1,6 @@
-import fs, { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import * as path$1 from "node:path";
-import path, { join } from "node:path";
-import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import yaml from "js-yaml";
-import "pluralize";
-import typescript from "typescript";
-import chalk from "chalk";
+import { D as setConfig, a as getDbClient, b as unique, c as formatQuery, d as SasatError, j as assignDeep, m as Conditions, o as MySqlTransaction, s as DBClient, t as migrate, u as SqlString, v as nonNullable, y as pick } from "./migrate-Cbj2OVbY.mjs";
 import * as SqlString$1 from "sqlstring";
-import pkg from "sqlstring";
-import { createConnection, createPool } from "mysql2/promise";
-import { build } from "esbuild";
-//#region src/util/assignDeep.ts
-const assignDeep = (base, ...objects) => {
-	const assign = (target, key, value) => {
-		if (key === "__proto__" || key === "constructor") return;
-		if (Array.isArray(target[key]) && Array.isArray(value)) target[key] = [...target[key], ...value];
-		else if (typeof target[key] === "object" && typeof value === "object") assignDeep(target[key], value);
-		else target[key] = value;
-	};
-	objects.forEach((obj) => {
-		if (typeof obj === "object") Object.entries(obj).forEach(([key, value]) => {
-			assign(base, key, value);
-		});
-	});
-	return base;
-};
-//#endregion
-//#region src/util/fsUtil.ts
-const readYmlFile = (filepath) => yaml.load(readFileSync(filepath, "utf8"));
-const mkDirIfNotExist = (path) => {
-	if (!existsSync(path)) mkdirSync(path);
-};
-const writeFileIfNotExist = (path, data) => {
-	if (existsSync(path)) return Promise.resolve();
-	return writeFile(path, data);
-};
-const writeYmlFile = (path, fileName, obj) => {
-	mkDirIfNotExist(path);
-	writeFileSync(join(path, fileName), yaml.dump(obj, {
-		skipInvalid: true,
-		noRefs: true,
-		sortKeys: (a, b) => {
-			if (b === "tableName") return 1;
-			if (a === "tableName") return -1;
-			if (a > b) return 1;
-			if (a < b) return -1;
-			return 0;
-		}
-	}));
-};
-const readInitialSchema = () => {
-	return readYmlFile(join(config().migration.dir, "initialSchema.yml"));
-};
-const writeCurrentSchema = (schema) => {
-	writeYmlFile(config().migration.dir, "currentSchema.yml", schema);
-};
-//#endregion
-//#region src/config/loader.ts
-var SasatConfigLoader = class SasatConfigLoader {
-	static loadConfig() {
-		const filepath = path.join(process.cwd(), "sasat.yml");
-		if (!existsSync(filepath)) return defaultConf;
-		return readYmlFile(filepath);
-	}
-	constructor() {
-		const conf = this.readValue({
-			...defaultConf,
-			...SasatConfigLoader.loadConfig()
-		});
-		this.conf = { ...conf };
-	}
-	getConfig() {
-		return this.conf;
-	}
-	readValue(value) {
-		if (!value) return value;
-		if (Array.isArray(value)) return value.map((it) => this.readValue(it));
-		if (typeof value === "string" && value.startsWith("$")) return process.env[value.slice(1)];
-		if (typeof value === "object") {
-			for (const key in value) if (Object.hasOwn(value, key)) value[key] = this.readValue(value[key]);
-			return value;
-		}
-		return value;
-	}
-};
-const defaultConf = {
-	db: {
-		host: "127.0.0.1",
-		port: 3306,
-		user: "root",
-		database: "sasat",
-		password: ""
-	},
-	migration: {
-		table: "__migrate__",
-		dir: "migrations",
-		out: "sasat"
-	},
-	generator: {
-		addJsExtToImportStatement: false,
-		gql: { subscription: true }
-	}
-};
-let conf;
-const config = () => {
-	if (conf === void 0) conf = new SasatConfigLoader().getConfig();
-	return conf;
-};
-function setConfig(update) {
-	conf = assignDeep(config(), update);
-	return conf;
-}
-//#endregion
-//#region src/generatorv2/fs/emptyDir.ts
-async function emptyDir(dir) {
-	let items;
-	try {
-		items = await readdir(dir);
-	} catch {
-		return mkdir(dir, { mode: 511 });
-	}
-	return Promise.all(items.map((item) => rm(path.join(dir, item), {
-		recursive: true,
-		force: true
-	})));
-}
-//#endregion
-//#region src/generatorv2/codegen/ts/tsFileNames.ts
-const tsFileNames = {
-	encoder: "idEncoder",
-	conditions: "conditions",
-	middleware: "middlewares"
-};
-//#endregion
-//#region src/migration/column/columnTypes.ts
-const columnTypeToTsType = (type) => {
-	switch (type) {
-		case "tinyint":
-		case "smallint":
-		case "mediumint":
-		case "int":
-		case "bigint":
-		case "float":
-		case "double":
-		case "decimal":
-		case "year": return "number";
-		case "char":
-		case "varchar":
-		case "text":
-		case "time":
-		case "date":
-		case "datetime":
-		case "timestamp": return "string";
-		case "boolean": return "boolean";
-	}
-};
-//#endregion
-//#region src/tsg/importDeclaration.ts
-var ImportDeclaration = class {
-	constructor(types, module) {
-		this.types = types;
-		this.module = module;
-	}
-	toString() {
-		const addJsExt = config().generator.addJsExtToImportStatement && this.module.startsWith(".");
-		return `import {${this.types.join(",")}} from "${addJsExt ? this.module + ".js" : this.module}";`;
-	}
-};
-//#endregion
-//#region src/tsg/abstruct/tsCode.ts
-var TsCode = class {
-	constructor() {
-		this.importDeclarations = [];
-	}
-	addImport(types, module) {
-		this.importDeclarations.push(new ImportDeclaration(types, module));
-		return this;
-	}
-	toString() {
-		return this.codePrefix() + this.toTsString();
-	}
-	codePrefix() {
-		return "";
-	}
-	mergeImport(...code) {
-		code.forEach((it) => {
-			if (it) this.importDeclarations.push(...it.importDeclarations);
-		});
-	}
-};
-//#endregion
-//#region src/tsg/abstruct/statement.ts
-var TsStatement = class extends TsCode {
-	constructor(..._args) {
-		super(..._args);
-		this.codeType = "statement";
-	}
-};
-//#endregion
-//#region src/tsg/node/block.ts
-const notNull = (v) => {
-	return v !== null;
-};
-var Block = class extends TsStatement {
-	constructor(...statements) {
-		super();
-		const sts = statements.filter(notNull);
-		this.mergeImport(...sts);
-		this.statements = sts;
-	}
-	toTsString() {
-		return `{${this.statements.map((it) => it.toString()).join("\n")}}`;
-	}
-};
-//#endregion
-//#region src/tsg/abstruct/exportableDeclaration.ts
-var ExportableDeclaration = class extends TsStatement {
-	constructor(..._args) {
-		super(..._args);
-		this.isExported = false;
-	}
-	codePrefix() {
-		return this.isExported ? "export " : "";
-	}
-	export() {
-		this.isExported = true;
-		return this;
-	}
-};
-//#endregion
-//#region src/tsg/node/class.ts
-var Class = class extends ExportableDeclaration {
-	constructor(name) {
-		super();
-		this.name = name;
-		this.properties = [];
-		this.methods = [];
-		this.isAbstract = false;
-	}
-	abstract() {
-		this.isAbstract = true;
-		return this;
-	}
-	extends(value) {
-		this._extends = value;
-		this.mergeImport(value);
-		return this;
-	}
-	implements(value) {
-		this._implements = value;
-		this.mergeImport(value);
-		return this;
-	}
-	addProperty(...properties) {
-		this.properties.push(...properties);
-		this.mergeImport(...properties);
-		return this;
-	}
-	addMethod(...methods) {
-		this.methods.push(...methods);
-		this.mergeImport(...methods);
-		return this;
-	}
-	toTsString() {
-		const properties = this.properties.map((it) => it.toString()).join("");
-		const methods = this.methods.map((it) => it.toString()).join("");
-		const implement = this._implements ? this._implements.toString() + " " : "";
-		const extend = this._extends ? this._extends.toString() + "" : "";
-		return (this.isAbstract ? "abstract " : "") + `class ${this.name} ${implement}${extend}{${properties}${methods}}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/enumDeclaration.ts
-var EnumDeclaration = class extends ExportableDeclaration {
-	constructor(identifier, members) {
-		super();
-		this.identifier = identifier;
-		this.members = members;
-		this.mergeImport(identifier, ...members);
-	}
-	addMembers(...members) {
-		this.members.push(...members);
-		this.mergeImport(...members);
-		return this;
-	}
-	toTsString() {
-		return `enum ${this.identifier}{${this.members.map((it) => it.toString() + ",").join("")}}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/enumMember.ts
-var EnumMember = class extends TsCode {
-	constructor(identifier, value) {
-		super();
-		this.identifier = identifier;
-		this.value = value;
-		this.mergeImport(identifier);
-		if (value) this.mergeImport(value);
-	}
-	toTsString() {
-		if (!this.value) return this.identifier.toString();
-		return this.identifier + "=" + this.value;
-	}
-};
-//#endregion
-//#region src/tsg/node/expressionStatement.ts
-var ExpressionStatement = class extends TsStatement {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return this.expression.toString() + ";";
-	}
-};
-//#endregion
-//#region src/tsg/tsValueString.ts
-const tsValueString = (value) => {
-	if (value === null) return "null";
-	if (value === void 0) return "undefined";
-	if (typeof value === "number") return "" + value;
-	if (typeof value === "boolean") return "" + value;
-	if (typeof value === "string") return `'${value.replaceAll("'", "\\'")}'`;
-	if (typeof value === "bigint") return "" + value;
-	if (typeof value === "function") return value.toString();
-	if (Array.isArray(value)) return `[${value.map(tsValueString).join(",")}]`;
-	if (typeof value === "object") return `{${Object.entries(value).map(([key, value]) => [key, tsValueString(value)]).map(([key, value]) => `${key}: ${value}`).join(",")}}`;
-	throw new TypeError(`tsValueString::unsupported data type ${typeof value}`);
-};
-//#endregion
-//#region src/tsg/node/parameter.ts
-var Parameter = class extends TsCode {
-	constructor(paramName, type) {
-		super();
-		this.paramName = paramName;
-		this.type = type;
-		this.mergeImport(type);
-	}
-	toTsString() {
-		if (!this.type) return this.paramName;
-		return `${this.paramName}: ${this.type.toString()}`;
-	}
-	static arrayToString(params) {
-		return params.map((it) => it.toString()).join(",");
-	}
-};
-//#endregion
-//#region src/tsg/node/expressions.ts
-var TsExpression = class extends TsCode {
-	constructor(..._args) {
-		super(..._args);
-		this._codeType = "expression";
-	}
-	toStatement() {
-		return new ExpressionStatement(this);
-	}
-	call(...args) {
-		return new CallExpression(this, ...args);
-	}
-	nonNull() {
-		return new NonNullExpression(this);
-	}
-	property(propertyName) {
-		return new PropertyAccessExpression(this, propertyName);
-	}
-	as(type) {
-		return new AsExpression(this, type);
-	}
-};
-var CallExpression = class extends TsExpression {
-	constructor(identifier, ...args) {
-		super();
-		this.identifier = identifier;
-		this._typeArgs = [];
-		this.mergeImport(identifier, ...args);
-		this.args = args;
-	}
-	typeArgs(...typeArgs) {
-		this._typeArgs = typeArgs;
-		this.mergeImport(...typeArgs);
-		return this;
-	}
-	toTsString() {
-		return this.identifier.toString() + (this._typeArgs.length !== 0 ? `<${this._typeArgs.map((it) => it.toString()).join(",")}>` : "") + `(${this.args.map((it) => it.toString()).join(",")})`;
-	}
-};
-var Literal = class extends TsExpression {};
-var StringLiteral = class extends Literal {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
-	toTsString() {
-		return tsValueString(this.value);
-	}
-};
-var NumericLiteral = class extends Literal {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
-	toTsString() {
-		return this.value.toString();
-	}
-};
-var Boolean = class extends Literal {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
-	toTsString() {
-		return this.value.toString();
-	}
-};
-var ArrayLiteral = class extends Literal {
-	constructor(literals) {
-		super();
-		this.literals = literals;
-		this.mergeImport(...literals);
-	}
-	toTsString() {
-		return `[${this.literals.map((it) => it.toString()).join(",")}]`;
-	}
-};
-var ObjectLiteral = class extends Literal {
-	constructor(...properties) {
-		super();
-		this.properties = [];
-		this.addProperties(...properties);
-	}
-	addProperties(...properties) {
-		this.properties.push(...properties);
-		this.mergeImport(...properties);
-		return this;
-	}
-	toTsString() {
-		return `{${this.properties.map((it) => it.toString()).join(",")}}`;
-	}
-};
-var ArrowFunction = class extends Literal {
-	constructor(params, returnType, body) {
-		super();
-		this.params = params;
-		this.returnType = returnType;
-		this.body = body;
-		this.mergeImport(...params, body, returnType);
-	}
-	toTsString() {
-		const returnType = this.returnType ? `: ${this.returnType}` : "";
-		return `(${Parameter.arrayToString(this.params)})${returnType} => ${this.body.toString()}`;
-	}
-	toAsync() {
-		return new AsyncExpression(this);
-	}
-};
-var AsyncExpression = class extends TsExpression {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return "async " + this.expression.toString();
-	}
-};
-var AwaitExpression = class extends TsExpression {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return "await " + this.expression.toString();
-	}
-};
-var BinaryExpression = class extends TsExpression {
-	constructor(left, operator, right) {
-		super();
-		this.left = left;
-		this.operator = operator;
-		this.right = right;
-		this.mergeImport(left, right);
-	}
-	toTsString() {
-		return this.left + this.operator + this.right;
-	}
-};
-var Identifier = class extends TsExpression {
-	constructor(name) {
-		super();
-		this.name = name;
-	}
-	toTsString() {
-		return this.name;
-	}
-	importFrom(path) {
-		this.addImport([this.name], path);
-		return this;
-	}
-};
-var NewExpression = class extends CallExpression {
-	toTsString() {
-		return "new " + super.toTsString();
-	}
-};
-var ParenthesizedExpression = class extends TsExpression {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return `(${this.expression})`;
-	}
-};
-var NonNullExpression = class extends TsExpression {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return `${this.expression}!`;
-	}
-};
-var PropertyAccessExpression = class extends TsExpression {
-	constructor(expression, propertyName) {
-		super();
-		this.expression = expression;
-		this.propertyName = propertyName;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return `${this.expression.toString()}.${this.propertyName}`;
-	}
-};
-var AsExpression = class extends TsExpression {
-	constructor(expression, asType) {
-		super();
-		this.expression = expression;
-		this.asType = asType;
-		this.mergeImport(expression, asType);
-	}
-	toTsString() {
-		return this.expression.toString() + " as " + this.asType.toString();
-	}
-};
-var TernaryExpression = class extends TsExpression {
-	constructor(condition, left, right) {
-		super();
-		this.condition = condition;
-		this.left = left;
-		this.right = right;
-		this.mergeImport(condition, left, right);
-	}
-	toTsString() {
-		return `(${this.condition})?${this.left}:${this.right}`;
-	}
-};
-var SpreadElement = class extends TsExpression {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return `...${this.expression}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/extendsClause.ts
-var ExtendsClause = class extends TsCode {
-	constructor(type) {
-		super();
-		this.type = type;
-		this.mergeImport(type);
-	}
-	toTsString() {
-		return `extends ${this.type}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/ifStatement.ts
-var IfStatement = class extends TsStatement {
-	constructor(condition, statement) {
-		super();
-		this.condition = condition;
-		this.statement = statement;
-		this.mergeImport(condition, statement);
-	}
-	toTsString() {
-		return `if(${this.condition})${this.statement}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/implementsClause.ts
-var ImplementsClause = class extends TsCode {
-	constructor(...types) {
-		super();
-		this.types = types;
-		this.mergeImport(...types);
-	}
-	toTsString() {
-		return `implements ${this.types.join(",")}`;
-	}
-};
-//#endregion
-//#region src/tsg/tsUtil.ts
-const TsUtil = {
-	readonly: (isReadonly) => isReadonly ? "readonly " : "",
-	questionToken: (isOptional) => isOptional ? "?" : ""
-};
-//#endregion
-//#region src/tsg/node/propertySignature.ts
-var PropertySignature = class extends TsCode {
-	constructor(propertyName, type, isOptional = false, isReadOnly = false) {
-		super();
-		this.propertyName = propertyName;
-		this.type = type;
-		this.isOptional = isOptional;
-		this.isReadOnly = isReadOnly;
-		this.mergeImport(type);
-	}
-	codePrefix() {
-		return TsUtil.readonly(this.isReadOnly);
-	}
-	toTsString() {
-		return `${this.propertyName}${TsUtil.questionToken(this.isOptional)}: ${this.type}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/interface.ts
-var TsInterface = class extends ExportableDeclaration {
-	constructor(name) {
-		super();
-		this.name = name;
-		this.properties = [];
-	}
-	addProperty(propertyName, type, isOptional = false, isReadOnly = false) {
-		this.properties.push(new PropertySignature(propertyName, type, isOptional, isReadOnly));
-		return this;
-	}
-	addProperties(properties) {
-		this.properties.push(...properties);
-		this.mergeImport(...properties);
-		return this;
-	}
-	extends(value) {
-		this._extends = value;
-		this.mergeImport(value);
-		return this;
-	}
-	toTsString() {
-		const extend = this._extends ? this._extends.toString() + " " : "";
-		return `interface ${this.name} ${extend}{${this.properties.map((it) => it.toString()).join(";")}}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/modifier/modifiers.ts
-var Modifiers = class extends TsCode {
-	constructor(..._args) {
-		super(..._args);
-		this._accessor = "";
-		this.isReadOnly = false;
-		this.isStatic = false;
-		this.isAbstract = false;
-		this.isAsync = false;
-	}
-	accessor(accessor) {
-		this._accessor = accessor;
-		return this;
-	}
-	private() {
-		return this.accessor("private");
-	}
-	protected() {
-		return this.accessor("protected ");
-	}
-	abstract() {
-		this.isAbstract = true;
-		return this;
-	}
-	readonly() {
-		this.isReadOnly = true;
-		return this;
-	}
-	static() {
-		this.isStatic = true;
-		return this;
-	}
-	async() {
-		this.isAsync = true;
-		return this;
-	}
-	toTsString() {
-		const optional = (bool, string) => bool ? string : "";
-		return this._accessor + " " + optional(this.isAbstract, "abstract ") + optional(this.isStatic, "static ") + optional(this.isReadOnly, "readonly ") + optional(this.isAsync, "async ");
-	}
-};
-//#endregion
-//#region src/tsg/node/modifier/methodModifiers.ts
-var MethodModifiers = class extends Modifiers {
-	private() {
-		return super.private();
-	}
-	protected() {
-		return super.protected();
-	}
-	abstract() {
-		return super.abstract();
-	}
-	static() {
-		return super.static();
-	}
-	async() {
-		return super.async();
-	}
-};
-//#endregion
-//#region src/tsg/node/type/type.ts
-const isCode = (t) => t instanceof TsCode;
-const pickCode = (types) => types.filter((it) => it instanceof TsCode);
-//#endregion
-//#region src/tsg/node/methodDeclaration.ts
-var MethodDeclaration = class extends TsCode {
-	constructor(methodName, params, returnType, body) {
-		super();
-		this.methodName = methodName;
-		this.params = params;
-		this.returnType = returnType;
-		this.body = body;
-		this._modifiers = new MethodModifiers();
-		this.mergeImport(...params, ...body);
-		if (isCode(returnType)) this.mergeImport(returnType);
-	}
-	modifiers(modifiers) {
-		this._modifiers = modifiers;
-		return this;
-	}
-	importFrom(from) {
-		this.addImport([this.methodName], from);
-		return this;
-	}
-	toTsString() {
-		const params = this.params.map((it) => it.toString()).join(",");
-		return this._modifiers.toString() + `${this.methodName}(${params}): ${this.returnType}{${this.body.map((it) => it.toString()).join("")}}\n`;
-	}
-};
-//#endregion
-//#region src/tsg/node/modifier/propertyModifiers.ts
-var PropertyModifiers = class extends Modifiers {
-	accessor(accessor) {
-		return super.accessor(accessor);
-	}
-	private() {
-		return super.private();
-	}
-	protected() {
-		return super.protected();
-	}
-	abstract() {
-		return super.abstract();
-	}
-	readonly() {
-		return super.readonly();
-	}
-	static() {
-		return super.static();
-	}
-};
-//#endregion
-//#region src/tsg/node/propertyAssignment.ts
-var PropertyAssignment = class extends TsCode {
-	constructor(key, value) {
-		super();
-		this.key = key;
-		this.value = value;
-		this.mergeImport(value);
-	}
-	toTsString() {
-		if (!this.value) return this.key;
-		return `${this.key}: ${this.value.toString()}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/propertyDeclaration.ts
-var PropertyDeclaration = class extends TsCode {
-	constructor(propertyName, type, optional = false) {
-		super();
-		this.propertyName = propertyName;
-		this.type = type;
-		this.optional = optional;
-		this._modifiers = new PropertyModifiers();
-		this._initializer = void 0;
-		if (isCode(type)) this.mergeImport(type);
-	}
-	modifiers(modifiers) {
-		this._modifiers = modifiers;
-		return this;
-	}
-	initializer(initializer) {
-		this._initializer = initializer;
-		this.mergeImport(initializer);
-		return this;
-	}
-	toTsString() {
-		const initializer = this._initializer ? ` = ${this._initializer.toString()}` : "";
-		return this._modifiers.toString() + `${this.propertyName}${TsUtil.questionToken(this.optional)}: ${this.type}` + initializer + ";";
-	}
-};
-//#endregion
-//#region src/tsg/node/returnStatement.ts
-var ReturnStatement = class extends TsStatement {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return `return ${this.expression.toString()};`;
-	}
-};
-//#endregion
-//#region src/tsg/node/spreadAssignment.ts
-var SpreadAssignment = class extends TsCode {
-	constructor(identifier) {
-		super();
-		this.identifier = identifier;
-		this.mergeImport(identifier);
-	}
-	toTsString() {
-		return `...${this.identifier.toString()}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/throwStatement.ts
-var ThrowStatement = class extends TsStatement {
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.mergeImport(expression);
-	}
-	toTsString() {
-		return "throw " + this.expression.toString() + ";";
-	}
-};
-//#endregion
-//#region src/tsg/node/type/arrayType.ts
-var ArrayType = class extends TsCode {
-	constructor(type) {
-		super();
-		this.type = type;
-		if (isCode(type)) this.mergeImport(type);
-	}
-	toTsString() {
-		return `Array<${this.type.toString()}>`;
-	}
-};
-//#endregion
-//#region src/tsg/node/type/intersectionType.ts
-var IntersectionType = class extends TsCode {
-	constructor(...types) {
-		super();
-		this.types = types;
-		this.mergeImport(...types);
-	}
-	toTsString() {
-		return this.types.map((it) => it.toString()).join(" & ");
-	}
-};
-//#endregion
-//#region src/tsg/node/type/typeAliasDeclaration.ts
-var TypeAliasDeclaration = class extends ExportableDeclaration {
-	constructor(alias, type) {
-		super();
-		this.alias = alias;
-		this.type = type;
-		if (isCode(type)) this.mergeImport(type);
-	}
-	toTsString() {
-		return `type ${this.alias} = ${this.type.toString()}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/type/typeLiteral.ts
-var TypeLiteral = class extends TsCode {
-	constructor(properties = []) {
-		super();
-		this.properties = properties;
-		this.mergeImport(...properties);
-	}
-	addProperty(propertyName, type, isOptional = false, isReadOnly = false) {
-		this.properties.push(new PropertySignature(propertyName, type, isOptional, isReadOnly));
-		return this;
-	}
-	toTsString() {
-		return `{${this.properties.map((it) => it.toString()).join(";")}}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/type/typeReference.ts
-var TypeReference = class TypeReference extends TsCode {
-	constructor(typeName, typeArguments = []) {
-		super();
-		this.typeName = typeName;
-		this.typeArguments = typeArguments;
-		this.mergeImport(...pickCode(typeArguments));
-	}
-	importFrom(path) {
-		this.addImport([this.typeName], path);
-		return this;
-	}
-	partial() {
-		return new TypeReference("Partial", [this]);
-	}
-	pick(...properties) {
-		return new TypeReference("Pick", [this, new Identifier(properties.map((it) => `'${it}'`).join("|"))]);
-	}
-	toTsString() {
-		const typeArgs = this.typeArguments.length === 0 ? "" : `<${this.typeArguments.join(",")}>`;
-		return `${this.typeName}${typeArgs}`;
-	}
-};
-//#endregion
-//#region src/tsg/node/type/unionType.ts
-var UnionType = class extends TsCode {
-	constructor(...types) {
-		super();
-		this.types = types;
-		const codeTypes = types.filter((it) => isCode(it));
-		this.mergeImport(...codeTypes);
-	}
-	toTsString() {
-		return this.types.map((it) => it.toString()).join(" | ");
-	}
-};
-//#endregion
-//#region src/tsg/node/variableDeclaration.ts
-var VariableDeclaration = class extends ExportableDeclaration {
-	constructor(flag, variableName, expression, type) {
-		super();
-		this.flag = flag;
-		this.expression = expression;
-		this.type = type;
-		this.variableName = typeof variableName === "string" ? new Identifier(variableName) : variableName;
-		this.mergeImport(expression, this.variableName, type);
-	}
-	toTsString() {
-		const type = this.type ? ": " + this.type.toString() : "";
-		return `${this.flag} ${this.variableName}${type} = ${this.expression.toString()};`;
-	}
-};
-//#endregion
-//#region src/tsg/factory.ts
-const createFactory = (Constructor) => {
-	return (...args) => new Constructor(...args);
-};
-const expressions = {
-	arrowFunc: createFactory(ArrowFunction),
-	async: createFactory(AsyncExpression),
-	await: createFactory(AwaitExpression),
-	binary: createFactory(BinaryExpression),
-	call: createFactory(CallExpression),
-	identifier: createFactory(Identifier),
-	new: createFactory(NewExpression),
-	nonNull: createFactory(NonNullExpression),
-	parenthesis: createFactory(ParenthesizedExpression),
-	propertyAccess: createFactory(PropertyAccessExpression),
-	string: createFactory(StringLiteral),
-	number: createFactory(NumericLiteral),
-	boolean: createFactory(Boolean),
-	array: createFactory(ArrayLiteral),
-	object: createFactory(ObjectLiteral),
-	as: createFactory(AsExpression),
-	ternary: createFactory(TernaryExpression)
-};
-const types = {
-	arrayType: createFactory(ArrayType),
-	intersectionType: createFactory(IntersectionType),
-	unionType: createFactory(UnionType),
-	typeAlias: createFactory(TypeAliasDeclaration),
-	typeLiteral: createFactory(TypeLiteral),
-	typeRef: createFactory(TypeReference)
-};
-const others = {
-	block: createFactory(Block),
-	class: createFactory(Class),
-	enum: createFactory(EnumDeclaration),
-	enumMember: createFactory(EnumMember),
-	ExpStatement: createFactory(ExpressionStatement),
-	extends: createFactory(ExtendsClause),
-	if: createFactory(IfStatement),
-	implements: createFactory(ImplementsClause),
-	interface: createFactory(TsInterface),
-	method: createFactory(MethodDeclaration),
-	parameter: createFactory(Parameter),
-	propertyAssign: createFactory(PropertyAssignment),
-	propertyDeclaration: createFactory(PropertyDeclaration),
-	propertySignature: createFactory(PropertySignature),
-	return: createFactory(ReturnStatement),
-	spreadAssign: createFactory(SpreadAssignment),
-	variable: createFactory(VariableDeclaration),
-	methodModifiers: createFactory(MethodModifiers),
-	propertyModifiers: createFactory(PropertyModifiers),
-	throw: createFactory(ThrowStatement),
-	spread: createFactory(SpreadElement)
-};
-const tsg = {
-	...expressions,
-	...types,
-	...others
-};
-//#endregion
-//#region src/tsg/file.ts
-var TsFile = class extends TsCode {
-	constructor(...statements) {
-		super();
-		this.esLintDisabled = false;
-		this.mergeImport(...statements);
-		this.statements = statements;
-	}
-	toTsString() {
-		const string = [...this.resolveImport(this.importDeclarations), ...this.statements].map((it) => it.toString()).join("\n");
-		return (this.esLintDisabled ? "/* eslint-disable */\n" : "") + string;
-	}
-	resolveImport(imports) {
-		const map = {};
-		imports.forEach((it) => {
-			if (!map[it.module]) map[it.module] = it.types;
-			else map[it.module] = [...map[it.module], ...it.types];
-		});
-		return Object.entries(map).map(([module, types]) => new ImportDeclaration([...new Set(types)], module));
-	}
-	disableEsLint() {
-		this.esLintDisabled = true;
-		return this;
-	}
-	enableEsLint() {
-		this.esLintDisabled = false;
-		return this;
-	}
-	async generate() {
-		return this.toString();
-	}
-};
-//#endregion
-//#region src/tsg/node/type/typeKeyword.ts
-const KeywordTypeNode = {
-	any: new TypeReference("any"),
-	unknown: new TypeReference("unknown"),
-	number: new TypeReference("number"),
-	bigInt: new TypeReference("BigInt"),
-	boolean: new TypeReference("boolean"),
-	string: new TypeReference("string"),
-	symbol: new TypeReference("Symbol"),
-	this: new TypeReference("this"),
-	void: new TypeReference("void"),
-	undefined: new TypeReference("undefined"),
-	null: new TypeReference("null"),
-	never: new TypeReference("never")
-};
-//#endregion
-//#region src/generatorv2/directory.ts
-const GeneratedDirName = "__generated__";
-const EntityDirName = "entities";
-const DataSourceDirName = "dataSources";
-const relative = (from, to) => {
-	const result = path$1.posix.relative(from, to);
-	if (result.startsWith("../")) return result;
-	return "./" + result;
-};
-const GENERATED_PATH = `/${GeneratedDirName}/`;
-const paths = {
-	BASE: "/",
-	GENERATED: GENERATED_PATH,
-	ENTITIES: `${GENERATED_PATH}${EntityDirName}/`,
-	DATA_SOURCES: `/${DataSourceDirName}/db/`,
-	GENERATED_DS: `${GENERATED_PATH}${DataSourceDirName}/db/`
-};
-const resolve = (from, source, fileName) => {
-	return relative(paths[from], paths[source] + fileName);
-};
-const Directory = {
-	paths,
-	resolve
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/getEntityTypeRefs.ts
-const typeRefs = {
-	entity: {
-		name: (entity) => entity.name,
-		dir: "ENTITIES",
-		file: (entity) => entity.name
-	},
-	creatable: {
-		name: (entity) => entity.creatableInterface(),
-		dir: "ENTITIES",
-		file: (entity) => entity.name
-	},
-	updatable: {
-		name: (entity) => entity.updatable(),
-		dir: "ENTITIES",
-		file: (entity) => entity.name
-	},
-	identifiable: {
-		name: (entity) => entity.identifiableInterfaceName(),
-		dir: "ENTITIES",
-		file: (entity) => entity.name
-	},
-	fields: {
-		name: (entity) => entity.fieldsTypeName(),
-		dir: "GENERATED",
-		file: () => "fields"
-	},
-	withRelation: {
-		name: (entity) => entity.entityWithRelationTypeName(),
-		dir: "GENERATED",
-		file: () => "relationMap"
-	},
-	result: {
-		name: (entity) => entity.resultType(),
-		dir: "GENERATED",
-		file: () => "relationMap"
-	}
-};
-const makeTypeRef = (entity, type, importFrom) => {
-	const info = typeRefs[type];
-	return tsg.typeRef(info.name(entity)).importFrom(Directory.resolve(importFrom, info.dir, info.file(entity)));
-};
-const makeContextTypeRef = (importFrom) => {
-	return tsg.typeRef("GQLContext").importFrom(Directory.resolve(importFrom, "BASE", "context"));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/sqlValueToTsExpression.ts
-const sqlValueToTsExpression = (value) => {
-	if (typeof value === "string") return tsg.string(value);
-	if (typeof value === "number") return tsg.number(value);
-	return tsg.identifier("null");
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateAutoGeneratedDatasource.ts
-const DIR$2 = "GENERATED_DS";
-const generateAutoGeneratedDatasource = (node) => {
-	return new TsFile(tsg.typeAlias("QueryResult", tsg.intersectionType(makeTypeRef(node.name, "withRelation", DIR$2).partial(), makeTypeRef(node.name, "identifiable", DIR$2))), tsg.class(node.name.generatedDataSourceName()).export().abstract().extends(tsg.extends(tsg.typeRef("BaseDBDataSource", [
-		makeTypeRef(node.name, "entity", DIR$2),
-		makeTypeRef(node.name, "identifiable", DIR$2),
-		makeTypeRef(node.name, "creatable", DIR$2),
-		makeTypeRef(node.name, "updatable", DIR$2),
-		makeTypeRef(node.name, "fields", DIR$2),
-		tsg.typeRef("QueryResult")
-	])).addImport(["BaseDBDataSource"], Directory.resolve(DIR$2, "BASE", "baseDBDataSource"))).addProperty(...makeClassProperties(node)).addMethod(makeDefaultValueMethod(node), ...makeFindMethods(node))).disableEsLint();
-};
-const makeClassProperties = (node) => {
-	const ai = node.fields.find((it) => it.isAutoIncrement);
-	return [
-		tsg.propertyDeclaration("tableName", KeywordTypeNode.string, false).modifiers(tsg.propertyModifiers().readonly()).initializer(tsg.string(node.tableName)),
-		tsg.propertyDeclaration("fields", tsg.arrayType(KeywordTypeNode.string), false).modifiers(tsg.propertyModifiers().readonly()).initializer(tsg.array(node.fields.map((it) => tsg.string(it.fieldName)))),
-		tsg.propertyDeclaration("primaryKeys", tsg.arrayType(KeywordTypeNode.string), false).modifiers(tsg.propertyModifiers().readonly().protected()).initializer(tsg.array(node.identifyKeys.map((it) => tsg.string(it)))),
-		tsg.propertyDeclaration("identifyFields", tsg.arrayType(KeywordTypeNode.string), false).modifiers(tsg.propertyModifiers().readonly().protected()).initializer(tsg.array(node.identifyKeys.map((it) => node.fields.find((f) => it === f.columnName).fieldName).map(tsg.string))),
-		tsg.propertyDeclaration("autoIncrementColumn", tsg.unionType(KeywordTypeNode.string, KeywordTypeNode.undefined), true).modifiers(tsg.propertyModifiers().readonly().protected()).initializer(ai ? tsg.string(ai.fieldName) : tsg.identifier("undefined"))
-	];
-};
-const fieldToExpression = (node) => {
-	if (node.column.defaultCurrentTimeStamp) return tsg.identifier("getCurrentDateTimeString").addImport(["getCurrentDateTimeString"], "sasat").call();
-	return sqlValueToTsExpression(node.column.default);
-};
-const makeDefaultValueMethod = (node) => {
-	const columns = node.fields.filter((it) => it.column.defaultCurrentTimeStamp || it.column.default !== void 0);
-	const properties = columns.map((it) => {
-		return tsg.propertyAssign(it.fieldName, fieldToExpression(it));
-	});
-	const body = tsg.return(tsg.object(...properties));
-	return tsg.method("getDefaultValueString", [], columns.length !== 0 ? tsg.typeRef(node.name.name).pick(...columns.map((it) => it.fieldName)) : tsg.typeRef(node.name.name).partial(), [body]).modifiers(tsg.methodModifiers().protected());
-};
-const makeFindMethods = (node) => {
-	const qExpr = tsg.identifier("qe").importFrom("sasat");
-	return node.findMethods.map((it) => {
-		const bve = it.params.flatMap((it) => {
-			if (!it.entity) return qExpr.property("eq").call(qExpr.property("field").call(tsg.identifier("tableName"), tsg.string(it.columnName.toString())), qExpr.property("value").call(tsg.identifier(it.fieldName.toString())));
-			return it.fields.map((field) => {
-				return qExpr.property("eq").call(qExpr.property("field").call(tsg.identifier("tableName"), tsg.string(field.columnName)), qExpr.property("value").call(tsg.identifier(it.name).property(field.fieldName)));
-			});
-		});
-		const body = [tsg.variable("const", "tableName", tsg.identifier("fields?.tableAlias || \"t0\"")), tsg.return(tsg.identifier(it.isArray ? "this.find" : "this.first").call(tsg.identifier("fields"), tsg.object().addProperties(tsg.spreadAssign(tsg.identifier("options")), tsg.propertyAssign("where", qExpr.property("and").call(...bve, tsg.identifier("options?").property("where")))), tsg.identifier("context")))];
-		const returnType = tsg.typeRef("QueryResult");
-		return tsg.method(it.name, [
-			...it.params.map((it) => tsg.parameter(it.entity ? it.name.toString() : it.fieldName, it.entity ? makeTypeRef(it.entityName, "identifiable", "GENERATED_DS") : tsg.typeRef(columnTypeToTsType(it.dbtype)))),
-			tsg.parameter(`fields?`, makeTypeRef(node.name, "fields", DIR$2)),
-			tsg.parameter("options?", it.isArray ? tsg.typeRef("QueryOptions").importFrom("sasat") : tsg.typeRef("Omit", [tsg.typeRef("QueryOptions").importFrom("sasat"), tsg.typeRef("\"offset\" | \"limit\" | \"sort\"")])),
-			tsg.parameter("context?", makeContextTypeRef(DIR$2))
-		], tsg.typeRef("Promise", [it.isArray ? tsg.arrayType(returnType) : tsg.unionType(returnType, tsg.typeRef("null"))]), body);
-	});
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateContext.ts
-const generateContext = (root) => {
-	return new TsFile(tsg.interface("BaseGQLContext").addProperties(root.contexts.map((it) => tsg.propertySignature(it.name, tsg.typeRef(columnTypeToTsType(it.dbtype))))).export()).disableEsLint();
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateDatasource.ts
-const generateDatasource = (node) => {
-	return new TsFile(tsg.class(node.name.dataSourceName()).extends(tsg.extends(tsg.typeRef(node.name.generatedDataSourceName()).importFrom(Directory.resolve("DATA_SOURCES", "GENERATED_DS", node.name.name)))).export());
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/fieldToProperty.ts
-const fieldToPropertySignature = (field) => {
-	const type = tsg.typeRef(columnTypeToTsType(field.dbType));
-	return tsg.propertySignature(field.fieldName, field.isNullable ? tsg.unionType(type, KeywordTypeNode.null) : type, field.isNullable, true);
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateEntity.ts
-const generateEntityFile = (node) => {
-	return new TsFile(generateEntity(node), generateCreatable(node), generateUpdatable(node), generateIdentifiable(node)).disableEsLint();
-};
-const generateEntity = (node) => {
-	return tsg.typeAlias(node.name.name, tsg.typeLiteral(node.fields.map(fieldToPropertySignature))).export();
-};
-const generateCreatable = (node) => {
-	return tsg.typeAlias(node.name.creatableInterface(), node.creatable.fields.length === 0 ? tsg.typeRef("Record<string, never>") : tsg.typeLiteral(node.creatable.fields.map(fieldToPropertySignature))).export();
-};
-const generateUpdatable = (node) => {
-	return tsg.typeAlias(node.name.updatable(), node.updateInput.fields.length === 0 ? tsg.typeRef("Record<string, never>") : tsg.typeLiteral(node.updateInput.fields.map(fieldToPropertySignature))).export();
-};
-const generateIdentifiable = (node) => {
-	return tsg.typeAlias(node.name.identifiableInterfaceName(), tsg.typeLiteral(node.fields.filter((it) => it.isPrimary).map(fieldToPropertySignature))).export();
-};
-//#endregion
-//#region src/util/stringUtil.ts
-const capitalizeFirstLetter = (str) => str.slice(0, 1).toUpperCase() + str.slice(1);
-const lowercaseFirstLetter = (str) => str.slice(0, 1).toLowerCase() + str.slice(1);
-const camelize = (str) => str.replace(/(?:^\w|[A-Z]|_\w|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase()).replace(/\s|_|-+/g, "");
-//#endregion
-//#region src/generatorv2/nodes/entityName.ts
-var EntityName = class EntityName {
-	static fromTableName(tableName) {
-		return new EntityName(capitalizeFirstLetter(camelize(tableName)));
-	}
-	constructor(name) {
-		this.name = name;
-	}
-	toString() {
-		return this.name;
-	}
-	creatableInterface() {
-		return `${this.name}Creatable`;
-	}
-	updatable() {
-		return `${this.name}Updatable`;
-	}
-	identifiableInterfaceName() {
-		return `${this.name}Identifiable`;
-	}
-	relationTypeName() {
-		return this.name + "Relations";
-	}
-	entityWithRelationTypeName() {
-		return this.name + "WithRelations";
-	}
-	resultType() {
-		return this.name + "Result";
-	}
-	fieldsTypeName() {
-		return this.name + "Fields";
-	}
-	dataSourceName() {
-		return `${this.name}DBDataSource`;
-	}
-	generatedDataSourceName() {
-		return `Generated${this.name}DBDataSource`;
-	}
-	lowerCase() {
-		return lowercaseFirstLetter(this.name);
-	}
-	createInputName() {
-		return this.name + "CreateInput";
-	}
-	updateInputName() {
-		return this.name + "UpdateInput";
-	}
-	identifyInputName() {
-		return `${this.name}IdentifyInput`;
-	}
-	IDEncoderName() {
-		return `${this.name}HashId`;
-	}
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateFields.ts
-const generateFields = (root) => {
-	return new TsFile(...root.entities.map((it) => tsg.typeAlias(it.name.fieldsTypeName(), tsg.typeRef("Fields", [makeTypeRef(it.name, "entity", "GENERATED"), makeTypeLiteral(it)]).importFrom("sasat")).export())).disableEsLint();
-};
-const makeTypeLiteral = (entity) => {
-	return tsg.typeLiteral([...entity.references.map((it) => tsg.propertySignature(`${it.fieldName}?`, tsg.typeRef(EntityName.fromTableName(it.parentTableName).fieldsTypeName()))), ...entity.referencedBy.map((it) => tsg.propertySignature(`${it.fieldName}?`, tsg.typeRef(EntityName.fromTableName(it.childTable).fieldsTypeName())))]);
-};
-//#endregion
-//#region src/runtime/util.ts
-const pick = (target, keys) => Object.fromEntries(keys.map((key) => [key, target[key]]));
-const unique = (array) => {
-	const result = [];
-	for (let i = 0, l = array.length; i < l; i += 1) if (!result.includes(array[i])) result.push(array[i]);
-	return result;
-};
-const nonNullable = (value) => value != null;
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/ast/getExportedVariables.ts
-const { SyntaxKind: SyntaxKind$1 } = typescript;
-const getExportedVariables = (sourceFile) => {
-	return sourceFile.statements.filter((it) => it.kind === SyntaxKind$1.VariableStatement && it.modifiers?.some((it) => it.kind === SyntaxKind$1.ExportKeyword));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/ast/isImported.ts
-const { SyntaxKind } = typescript;
-const isImported = (sourceFile, type, paths) => {
-	return sourceFile.statements.filter((it) => it.kind === SyntaxKind.ImportDeclaration).some((it) => {
-		if (!paths.some((path) => {
-			const text = it.moduleSpecifier.getText(sourceFile);
-			return `'${path}'` === text || `"${path}"` === text;
-		})) return false;
-		const binding = it.importClause?.namedBindings;
-		if (it.importClause?.name?.getText(sourceFile) === type) return true;
-		if (binding?.kind !== SyntaxKind.NamedImports) return false;
-		return binding.elements.some((it) => {
-			return it.name.text.trim() === type;
-		});
-	});
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateIDEncoder.ts
-const { createSourceFile: createSourceFile$2, ScriptTarget: ScriptTarget$2 } = typescript;
-const hashIds = "HashIds";
-const generateIDEncoder = (root, content) => {
-	const fields = root.entities.map((it) => it.fields.find((it) => it.column.option.autoIncrementHashId)).filter(nonNullable);
-	if (fields.length === 0) return null;
-	const sourceFile = createSourceFile$2(tsFileNames.encoder + ".ts", content, ScriptTarget$2.ESNext);
-	sourceFile.getChildren().map((it) => it);
-	const exportedVariables = getExportedVariables(sourceFile);
-	const hashIdImported = isImported(sourceFile, hashIds, ["hashids"]);
-	const statements = [];
-	fields.forEach((field) => {
-		const name = field.entity.name.IDEncoderName();
-		if (exportedVariables.some((it) => {
-			return it.declarationList.declarations[0].name.getText(sourceFile) === name;
-		})) return;
-		statements.push(tsg.variable("const", name, tsg.identifier("makeNumberIdEncoder").call(tsg.new(tsg.identifier(hashIds), tsg.string(field.column.option.hashSalt || field.entity.name.name)))).export());
-	});
-	const imports = hashIdImported ? "" : "import HashIds from \"hashids\";\n";
-	const makeEncoder = isImported(sourceFile, "makeNumberIdEncoder", ["sasat"]) ? "" : new ImportDeclaration(["makeNumberIdEncoder"], "sasat").toString();
-	const addition = statements.length === 0 ? "" : "\n" + new TsFile(...statements).toString();
-	return imports + makeEncoder + content + addition;
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateMiddlewares.ts
-const { createSourceFile: createSourceFile$1, ScriptTarget: ScriptTarget$1 } = typescript;
-const generateMiddlewares = (root, content) => {
-	const middlewares = unique(root.entities.flatMap((it) => [...it.queries.flatMap((it) => it.middlewares), ...it.mutations.flatMap((it) => it.middlewares)]));
-	if (middlewares.length === 0) return null;
-	const sourceFile = createSourceFile$1(tsFileNames.middleware + ".ts", content, ScriptTarget$1.ESNext);
-	const exportedVariables = getExportedVariables(sourceFile);
-	const statements = [];
-	middlewares.forEach((middleware) => {
-		if (exportedVariables.some((it) => {
-			return it.declarationList.declarations[0].name.getText(sourceFile) === middleware;
-		})) return;
-		statements.push(tsg.variable("const", middleware, tsg.arrowFunc([tsg.parameter("args")], void 0, tsg.block(tsg.throw(tsg.new(tsg.identifier("Error"), tsg.string("TODO: Not implemented"))), tsg.return(tsg.identifier("args")))), tsg.typeRef("ResolverMiddleware", [tsg.typeRef("GQLContext")])).export());
-	});
-	const contextImported = isImported(sourceFile, "GQLContext", ["./context", "./context.js"]);
-	const resolverMiddlewareImported = isImported(sourceFile, "ResolverMiddleware", ["sasat"]);
-	const imports = [contextImported ? "" : new ImportDeclaration(["GQLContext"], "./context").toString() + "\n", resolverMiddlewareImported ? "" : new ImportDeclaration(["ResolverMiddleware"], "sasat").toString() + "\n"].join("");
-	const addition = statements.length === 0 ? "" : "\n" + new TsFile(...statements).toString();
-	return imports + content + addition;
-};
-//#endregion
-//#region src/generatorv2/codegen/names.ts
-const map = {
-	create: "Created",
-	update: "Updated",
-	delete: "Deleted"
-};
-const publishFunctionName = (entityName, type) => {
-	return `publish${entityName}${map[type]}`;
-};
-const makeFindQueryName = (keys) => "findBy" + keys.map(capitalizeFirstLetter).join("And");
-//#endregion
-//#region src/generatorv2/codegen/ts/mutation/makeMutationInputDecoder.ts
-const DIR$1 = "GENERATED";
-const makeMutationMiddlewareAndTypes = (entity) => {
-	return entity.mutations.map((node) => makeMutationResolverMiddleware(entity, node));
-};
-const makeParamType = (node) => {
-	if (node.mutationType === "create") return makeTypeRef(node.entityName, "creatable", "GENERATED");
-	if (node.mutationType === "update") return tsg.intersectionType(makeTypeRef(node.entityName, "identifiable", "GENERATED"), makeTypeRef(node.entityName, "updatable", "GENERATED"));
-	return makeTypeRef(node.entityName, "identifiable", "GENERATED");
-};
-const makeEncoder = (name) => tsg.identifier(name).importFrom(Directory.resolve(DIR$1, "BASE", tsFileNames.encoder));
-const makeIdDecodeMiddleware = (fields, node) => {
-	const params = tsg.identifier("args[1]");
-	const entityName = node.entity.name.lowerCase();
-	return tsg.arrowFunc([tsg.parameter("args")], void 0, tsg.block(tsg.binary(params, "=", tsg.object(tsg.spreadAssign(params), tsg.propertyAssign(entityName, tsg.object(tsg.spreadAssign(params.property(entityName)), ...fields.filter((it) => it.hashId).map((it) => tsg.propertyAssign(it.fieldName, makeEncoder(it.hashId.encoder).property("decode").call(params.property(entityName).property(it.fieldName).as(tsg.typeRef("string"))))))))).toStatement(), tsg.return(tsg.identifier("args"))));
-};
-const makeResolverMiddleware = (typeName, entity, fields, node) => {
-	const sig = fields.map((it) => tsg.propertySignature(it.fieldName, tsg.typeRef(it.hashId ? "string" : columnTypeToTsType(it.dbType))));
-	const requiredType = tsg.typeAlias(typeName, tsg.typeLiteral([tsg.propertySignature(entity.name.lowerCase(), makeParamType(node))]));
-	const middlewareName = node.mutationName + "Middleware";
-	if (!node.requireIdDecodeMiddleware) return [requiredType, tsg.variable("const", middlewareName, tsg.array(node.middlewares.map((it) => tsg.identifier(it).importFrom("../" + tsFileNames.middleware))), tsg.arrayType(tsg.typeRef("ResolverMiddleware", [makeContextTypeRef(DIR$1), tsg.identifier(typeName)]).importFrom("sasat")))];
-	return [
-		tsg.typeAlias("GQL" + typeName, tsg.typeLiteral([tsg.propertySignature(entity.name.lowerCase(), tsg.typeLiteral(sig))])),
-		requiredType,
-		tsg.variable("const", node.mutationName + "Middleware", tsg.array([makeIdDecodeMiddleware(fields, node), ...node.middlewares.map((it) => tsg.identifier(it).importFrom("../" + tsFileNames.middleware))]), tsg.arrayType(tsg.typeRef("ResolverMiddleware", [
-			makeContextTypeRef(DIR$1),
-			tsg.identifier(typeName),
-			tsg.identifier("GQL" + typeName)
-		]).importFrom("sasat")))
-	];
-};
-const makeMutationResolverMiddleware = (entity, node) => {
-	switch (node.mutationType) {
-		case "create": return makeResolverMiddleware(entity.name.createInputName(), entity, entity.creatable.fields, node);
-		case "update": return makeResolverMiddleware(entity.name.updateInputName(), entity, entity.updateInput.fields, node);
-		case "delete": return makeResolverMiddleware(entity.name.identifyInputName(), entity, entity.identifyFields(), node);
-	}
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/makeDatasource.ts
-const makeDatasource = (entity, importFrom, args) => {
-	return tsg.new(tsg.identifier(entity.dataSourceName()).importFrom(Directory.resolve(importFrom, "DATA_SOURCES", entity.name)), ...args || []);
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateMutationResolver.ts
-const generateMutationResolver = (root) => {
-	return new TsFile(...root.entities.flatMap(makeMutationMiddlewareAndTypes).flat(), tsg.variable("const", "mutation", tsg.object(...root.entities.flatMap((it) => it.mutations).map(makeMutation$1))).export()).disableEsLint();
-};
-const result = tsg.identifier("result");
-const refetched = tsg.identifier("fetched");
-const ds = tsg.identifier("ds");
-const ident$1 = tsg.identifier("identifiable");
-const makeMutation$1 = (node) => {
-	return tsg.propertyAssign(node.mutationName, makeResolver$2.call(tsg.arrowFunc(makeResolverArgs(node), void 0, makeMutationBody(node)).toAsync(), tsg.identifier(node.mutationName + "Middleware")).typeArgs(...[
-		context,
-		tsg.typeRef(node.inputName),
-		node.requireIdDecodeMiddleware ? tsg.typeRef("GQL" + node.inputName) : null
-	].filter(nonNullable)));
-};
-const makeMutationBody = (node) => {
-	if (node.mutationType === "create") return makeCreateMutationBody(node);
-	if (node.mutationType === "update") return makeUpdateMutationBody(node);
-	return makeDeleteMutationBody(node);
-};
-const makeResolver$2 = tsg.identifier("makeResolver").importFrom("sasat");
-const context = tsg.typeRef("GQLContext").importFrom(Directory.resolve("GENERATED", "BASE", "context"));
-const makeResolverArgs = (node) => [
-	tsg.parameter("_"),
-	tsg.parameter(`{${node.entityName.lowerCase()}}`),
-	node.contextFields.length === 0 ? null : tsg.parameter("context")
-].filter(nonNullable);
-const makeCreateMutationBody = (node) => {
-	const entity = tsg.identifier(node.entityName.lowerCase());
-	const dsVariable = tsg.variable("const", ds, makeDatasource(node.entityName, "GENERATED"));
-	const createCall = ds.property("create").call(entity);
-	if (!node.subscription && !node.refetch) return tsg.block(dsVariable, tsg.return(createCall));
-	if (!node.refetch) return tsg.block(dsVariable, tsg.variable("const", result, tsg.await(createCall)), node.subscription ? makePublishCall(node, result) : null, tsg.return(result));
-	return tsg.block(dsVariable, tsg.variable("const", result, tsg.await(createCall)), ...makeRefetched(node), node.subscription ? makePublishCall(node, refetched) : null, tsg.return(refetched));
-};
-const makeRefetched = (node) => {
-	return [tsg.variable("const", ident$1, tsg.identifier("pick").importFrom("sasat").call(node.mutationType === "create" ? result : tsg.identifier(node.entityName.lowerCase()), tsg.array(node.identifyFields.map(tsg.string))).as(tsg.typeRef("unknown")).as(makeTypeRef(node.entityName, "identifiable", "GENERATED"))), tsg.variable("const", refetched, tsg.await(ds.property(makeFindQueryName(node.identifyFields)).call(...node.identifyFields.map((it) => ident$1.property(it)))))];
-};
-const makePublishCall = (node, identifier) => {
-	return tsg.await(tsg.identifier(publishFunctionName(node.entityName, node.mutationType)).importFrom("./subscription").call(identifier.as(makeTypeRef(node.entityName, "entity", "GENERATED")))).toStatement();
-};
-const makeDatasourceParam = (entity, contextParams) => {
-	if (contextParams.length === 0) return entity;
-	return tsg.object(tsg.spreadAssign(entity), ...contextParams.map((it) => tsg.propertyAssign(it.fieldName, tsg.identifier(`context.${it.contextName}`))));
-};
-const makeUpdateMutationBody = (node) => {
-	const entity = tsg.identifier(node.entityName.lowerCase());
-	const statements = [tsg.variable("const", ds, makeDatasource(node.entityName, "GENERATED")), tsg.variable("const", result, tsg.await(ds.property("update").call(makeDatasourceParam(entity, node.contextFields)).property("then").call(tsg.arrowFunc([tsg.parameter("it", tsg.typeRef("CommandResponse").importFrom("sasat"))], KeywordTypeNode.boolean, tsg.binary(tsg.identifier("it.changedRows"), "===", tsg.number(1))))))];
-	if (!node.refetch && !node.subscription) return tsg.block(...statements, tsg.return(result));
-	return tsg.block(...statements, ...makeRefetched(node), node.subscription ? makePublishCall(node, refetched) : null, tsg.return(node.refetch ? refetched : result));
-};
-const makeDeleteMutationBody = (node) => {
-	const entity = tsg.identifier(node.entityName.lowerCase());
-	const dsV = tsg.variable("const", ds, makeDatasource(node.entityName, "GENERATED"));
-	const deleteCall = ds.property("delete").call(entity).property("then").call(tsg.arrowFunc([tsg.parameter("it", tsg.typeRef("CommandResponse").importFrom("sasat"))], KeywordTypeNode.boolean, tsg.binary(tsg.identifier("it.affectedRows"), "===", new NumericLiteral(1))));
-	return tsg.block(dsV, tsg.variable("const", result, tsg.await(deleteCall)), node.subscription ? tsg.if(result, tsg.block(makePublishCall(node, entity))) : null, tsg.return(result));
-};
-//#endregion
-//#region src/cli/console.ts
-const Console = {
-	success: (msg) => {
-		console.log(chalk.green(msg));
-	},
-	error: (msg) => {
-		console.error(chalk.bold.red(msg));
-	},
-	log: (msg) => {
-		console.log(msg);
-	},
-	debug: (msg) => {
-		console.debug("debug:: " + msg);
-	}
-};
-//#endregion
-//#region src/migration/data/GQLOption.ts
-const defaultGQLOption = () => ({
-	enabled: false,
-	queries: [],
-	mutations: []
-});
-const getArgs = (query, entity) => {
-	if (query.type === "primary") return entity.fields.filter((it) => it.isPrimary).map((it) => ({
-		kind: "arg",
-		name: it.fieldName,
-		type: it.gqlType
-	}));
-	const r = [];
-	if (query.type === "list-paging") r.push({
-		kind: "arg",
-		name: "option",
-		type: "PagingOption"
-	});
-	query.conditions.forEach((it) => {
-		if (it.left.kind === "arg") r.push(it.left);
-		if (it.kind === "between") {
-			if (it.begin.kind === "arg") r.push(it.begin);
-			if (it.end.kind === "arg") r.push(it.end);
-		} else if (it.right.kind === "arg") r.push(it.right);
-	});
-	return r;
-};
-//#endregion
-//#region src/tsg/node/rawCodeStatement.ts
-var RawCodeStatement = class extends TsStatement {
-	constructor(code) {
-		super();
-		this.code = code;
-	}
-	toTsString() {
-		return this.code;
-	}
-};
-//#endregion
-//#region src/generatorv2/scripts/gqlTypes.ts
-const toTsType = (type) => {
-	switch (type) {
-		case "Int":
-		case "Float": return "number";
-		case "ID":
-		case "String": return "string";
-		case "Boolean": return "boolean";
-		default: return type;
-	}
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/makeConditonValueExpr.ts
-const qExpr$3 = tsg.identifier("qe").importFrom("sasat");
-const makeConditionValueRaw = (cv) => {
-	const context = tsg.identifier("arg").property("context?");
-	switch (cv.kind) {
-		case "context": {
-			const value = context.property(cv.field);
-			if (cv.onNotDefined.action !== "defaultValue") return value;
-			return tsg.binary(context.property(cv.field), "||", typeof cv.onNotDefined.value === "string" ? tsg.string(cv.onNotDefined.value) : tsg.number(cv.onNotDefined.value));
-		}
-		case "fixed": return typeof cv.value === "string" ? tsg.string(cv.value) : tsg.number(cv.value);
-		case "today": return tsg.identifier(cv.type === "datetime" ? "getTodayDateTimeString" : "getTodayDateString").importFrom("sasat").call();
-		case "now": return tsg.identifier("dateString").importFrom("sasat").call(tsg.new(tsg.identifier("Date")));
-		default: throw Error(`not implemented: makeConditionValue.${cv.kind}`);
-	}
-};
-const makeConditionValueQExpr = (cv) => {
-	const context = tsg.identifier("arg").property("context?");
-	switch (cv.kind) {
-		case "context": {
-			const value = context.property(cv.field);
-			if (cv.onNotDefined.action !== "defaultValue") return qExpr$3.property("value").call(value);
-			return qExpr$3.property("value").call(tsg.binary(context.property(cv.field), "||", typeof cv.onNotDefined.value === "string" ? tsg.string(cv.onNotDefined.value) : tsg.number(cv.onNotDefined.value)));
-		}
-		case "fixed": return qExpr$3.property("value").call(typeof cv.value === "string" ? tsg.string(cv.value) : tsg.number(cv.value));
-		case "today": return qExpr$3.property("value").call(tsg.identifier(cv.type === "datetime" ? "getTodayDateTimeString" : "getTodayDateString").importFrom("sasat").call());
-		case "now": return qExpr$3.property("value").call(tsg.identifier("dateString").importFrom("sasat").call(tsg.new(tsg.identifier("Date"))));
-		case "arg": return qExpr$3.property("value").call(tsg.identifier(cv.name));
-		case "field": return qExpr$3.property("field").call(tsg.string("t0"), tsg.string(cv.column));
-	}
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/makeQueryConditionExpr.ts
-const qExpr$2 = tsg.identifier("qe").importFrom("sasat");
-const makeQueryConditionExpr = (condition) => {
-	if (condition.kind === "between") return qExpr$2.property("between").call(makeConditionValueQExpr(condition.left), makeConditionValueQExpr(condition.begin), makeConditionValueQExpr(condition.end));
-	return qExpr$2.property("comparison").call(makeConditionValueQExpr(condition.left), tsg.string(condition.operator), makeConditionValueQExpr(condition.right));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateQueryResolver.ts
-const DIR = "GENERATED";
-const generateQueryResolver = (root) => {
-	return new TsFile(tsg.variable("const", "query", tsg.object(...root.entities.flatMap((entity) => entity.queries.map((query) => makeGQLQuery(entity, query))).filter(nonNullable))).export()).disableEsLint();
-};
-const makeResolver$1 = () => tsg.identifier("makeResolver").importFrom("sasat");
-const makeGQLQuery = (entity, query) => {
-	if (!entity.gqlEnabled) {
-		Console.log(`Query.${query.name || entity.name.lowerCase()} generation skipped. Reason: Entity:${entity.name.name} is not Open to GQL.`);
-		return null;
-	}
-	const args = getArgs(query, entity);
-	return tsg.propertyAssign(query.type === "primary" ? entity.name.lowerCase() : query.name, makeResolver$1().call(...[tsg.arrowFunc([
-		tsg.parameter("_"),
-		tsg.parameter(`{${args.map((it) => it.name).join(",")}}`),
-		tsg.parameter("context"),
-		tsg.parameter("info")
-	], void 0, makeGQLQueryBody(entity, query)).toAsync(), makeMiddlewares(entity, query)].filter(nonNullable)).typeArgs(...makeTypeArgs(args)));
-};
-const getHashIdArgs = (entity, query) => {
-	if (query.type === "primary") {
-		const hashIDs = entity.identifyFields().filter((it) => it.option.autoIncrementHashId);
-		if (hashIDs.length === 0) return null;
-		return hashIDs.map((it) => ({
-			encoder: it.hashId.encoder,
-			name: it.fieldName
-		}));
-	}
-	const getHashIdArg = (arg, field) => {
-		const columnName = field.column;
-		const hashIdOpt = entity.fields.find((e) => e.columnName === columnName)?.hashId;
-		if (!hashIdOpt) return null;
-		return {
-			name: arg.name,
-			encoder: hashIdOpt.encoder
-		};
-	};
-	return query.conditions.map((it) => {
-		if (it.kind === "comparison") {
-			if (it.left.kind === "arg") {
-				if (it.right.kind === "field") return getHashIdArg(it.left, it.right);
-			}
-			if (it.right.kind === "arg") {
-				if (it.left.kind === "field") return getHashIdArg(it.right, it.left);
-			}
-		}
-		return null;
-	}).filter(nonNullable);
-};
-const makeHashIdMiddleware = (entity, query) => {
-	const args = getHashIdArgs(entity, query);
-	if (!args || args?.length === 0) return null;
-	return tsg.arrowFunc([tsg.parameter("args")], void 0, tsg.block(new RawCodeStatement(`args[1] = {...args[1], ${args.map((it) => `${it.name}: ${it.encoder}.decode(args[1].${it.name} as string),`).join("")}};`).addImport(args.map((it) => it.encoder), Directory.resolve(DIR, "BASE", tsFileNames.encoder)), tsg.return(tsg.identifier("args"))));
-};
-const makeMiddlewares = (entity, query) => {
-	const hashId = makeHashIdMiddleware(entity, query);
-	if (!hashId && query.middlewares.length === 0) return null;
-	if (query.middlewares.length === 0) return tsg.array([hashId]);
-	const middlewares = query.middlewares.map((it) => tsg.identifier(it).importFrom("../" + tsFileNames.middleware));
-	if (!hashId) return tsg.array(middlewares);
-	return tsg.array([hashId, ...middlewares]);
-};
-const makeTypeArgs = (args) => {
-	let hashIds = false;
-	const getType = (arg, checkHashId) => {
-		if (arg.type === "PagingOption") return tsg.typeRef(arg.type).importFrom("sasat");
-		if (checkHashId && arg.type === "ID") {
-			hashIds = true;
-			return tsg.typeRef("number");
-		}
-		return tsg.typeRef(toTsType(arg.type));
-	};
-	const params = tsg.typeLiteral(args.map((it) => tsg.propertySignature(it.name, getType(it, true))));
-	if (!hashIds) return [makeContextTypeRef("GENERATED"), params];
-	return [
-		makeContextTypeRef("GENERATED"),
-		params,
-		tsg.typeLiteral(args.map((it) => tsg.propertySignature(it.name, getType(it, false))))
-	];
-};
-const qExpr$1 = tsg.identifier("qe").importFrom("sasat");
-const makeGQLQueryBody = (entity, query) => {
-	const fields = tsg.variable("const", "fields", tsg.identifier("gqlResolveInfoToField").importFrom("sasat").call(tsg.identifier("info")).as(makeTypeRef(entity.name, "fields", "GENERATED")));
-	const where = query.conditions && query.conditions.length !== 0 ? tsg.variable("const", "where", qExpr$1.property("and").call(...(query.conditions || []).map(makeQueryConditionExpr))) : null;
-	const method = {
-		single: "first",
-		primary: entity.primaryQueryName(),
-		"list-all": "find",
-		"list-paging": "findPageable"
-	};
-	const queryArgs = getArgs(query, entity);
-	const args = [
-		...query.type === "primary" ? queryArgs.map((it) => tsg.identifier(it.name)) : [],
-		query.type === "list-paging" ? tsg.identifier("pagingOption").importFrom("sasat").call(tsg.identifier("option")) : null,
-		tsg.identifier("fields"),
-		tsg.identifier(where ? "{ where }" : "undefined"),
-		tsg.identifier("context")
-	].filter(nonNullable);
-	const result = makeDatasource(entity.name, DIR).property(method[query.type]).call(...args);
-	return tsg.block(fields, where, tsg.return(result));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateResolver.ts
-const generateResolver = (root) => {
-	const hasSubscription = root.subscriptions.some((it) => it.gqlEnabled);
-	const properties = [tsg.propertyAssign("Query", tsg.identifier("query").importFrom("./query")), tsg.propertyAssign("Mutation", tsg.identifier("mutation").importFrom("./mutation"))];
-	if (hasSubscription) properties.push(tsg.propertyAssign("Subscription", tsg.identifier("subscription").importFrom("./subscription")));
-	return new TsFile(tsg.variable("const", tsg.identifier("resolvers"), tsg.object(...properties, tsg.spreadAssign(tsg.object(...root.entities.filter((it) => it.gqlEnabled).map(makeEntityResolver))))).export()).disableEsLint();
-};
-const makeEntityResolver = (node) => {
-	return tsg.propertyAssign(node.name.name, tsg.object(...node.fields.filter((it) => it.hashId).map(makeHashIdProperty).filter(nonNullable), ...node.references.filter((it) => it.isGQLOpen).map((ref) => makeRelationProperty(ref)), ...node.referencedBy.filter((it) => it.isGQLOpen).map((ref) => makeReferencedByProperty(ref))));
-};
-const makeHashIdProperty = (field) => {
-	if (!field.hashId) return null;
-	const paramName = field.entity.name.lowerCase();
-	return tsg.propertyAssign(field.fieldName, tsg.arrowFunc([tsg.parameter(paramName, makeTypeRef(field.entity.name, "result", "GENERATED"))], void 0, tsg.binary(tsg.identifier(paramName).property(field.fieldName), "&&", tsg.identifier(field.hashId.encoder).importFrom(Directory.resolve("GENERATED", "BASE", tsFileNames.encoder)).property("encode").call(tsg.identifier(paramName).property(field.fieldName)))));
-};
-const makeRelationProperty = (ref) => {
-	const paramName = ref.entity.name.lowerCase();
-	return tsg.propertyAssign(ref.fieldName, tsg.arrowFunc([tsg.parameter(paramName, makeTypeRef(ref.entity.name, "result", "GENERATED")), tsg.parameter("context", makeContextTypeRef("GENERATED"))], void 0, tsg.block(tsg.if(tsg.binary(tsg.identifier(paramName).property(ref.fieldName), "!==", tsg.identifier("undefined")), tsg.return(tsg.identifier(paramName).property(ref.fieldName))), tsg.variable("const", "ds", makeDatasource(EntityName.fromTableName(ref.parentTableName), "GENERATED")), tsg.variable("const", "where", tsg.identifier("ds").property("getRelationMap").call().property(ref.fieldName).property("condition").call(tsg.object(tsg.propertyAssign("parent", tsg.identifier(paramName)), tsg.propertyAssign("childTableAlias", tsg.string("t0")), tsg.propertyAssign("context")))), tsg.return(tsg.identifier("ds").property("first").call(tsg.identifier("undefined"), tsg.object(tsg.propertyAssign("where")))))));
-};
-const makeReferencedByProperty = (ref) => {
-	const paramName = ref.entity.name.lowerCase();
-	const propertyName = ref.fieldName;
-	return tsg.propertyAssign(propertyName, tsg.arrowFunc([tsg.parameter(paramName, makeTypeRef(ref.entity.name, "result", "GENERATED")), tsg.parameter("context", makeContextTypeRef("GENERATED"))], void 0, tsg.block(tsg.if(tsg.binary(tsg.identifier(paramName).property(propertyName), "!==", tsg.identifier("undefined")), tsg.return(tsg.identifier(paramName).property(propertyName))), tsg.variable("const", "ds", makeDatasource(EntityName.fromTableName(ref.childTable), "GENERATED")), tsg.variable("const", "where", tsg.identifier("ds").property("getRelationMap").call().property(propertyName).property("condition").call(tsg.object(tsg.propertyAssign("parent", tsg.identifier(paramName)), tsg.propertyAssign("childTableAlias", tsg.string("t0")), tsg.propertyAssign("context")))), tsg.return(tsg.identifier("ds").property(ref.isArray ? "find" : "first").call(tsg.identifier("undefined"), tsg.object(tsg.propertyAssign("where")))))));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateSubscription.ts
-const generateSubscription = (root) => {
-	const subscriptionEnum = tsg.enum(tsg.identifier("SubscriptionName"), []).export();
-	const subscriptions = tsg.object();
-	const publishFunctions = [];
-	root.subscriptions.forEach((it) => {
-		subscriptionEnum.addMembers(tsg.enumMember(tsg.identifier(it.subscriptionName), tsg.string(it.subscriptionName)));
-		if (it.gqlEnabled) {
-			const fn = it.filters.length === 0 ? makeAsyncIteratorCall(it.subscriptionName) : makeWithFilter(it.subscriptionName, it.filters);
-			subscriptions.addProperties(tsg.propertyAssign(it.subscriptionName, tsg.object(tsg.propertyAssign("subscribe", fn))));
-		}
-		publishFunctions.push(tsg.variable("const", tsg.identifier(it.publishFunctionName), tsg.arrowFunc([tsg.parameter("entity", makeTypeRef(it.entity, it.mutationType === "delete" ? "identifiable" : "entity", "GENERATED"))], tsg.typeRef("Promise", [KeywordTypeNode.void]), tsg.identifier("pubsub.publish").call(tsg.identifier(`SubscriptionName.${it.subscriptionName}`), tsg.object(tsg.propertyAssign(it.subscriptionName, tsg.identifier("entity")))))).export());
-	});
-	return new TsFile(subscriptionEnum, tsg.variable("const", tsg.identifier("subscription"), subscriptions).export(), ...publishFunctions).disableEsLint();
-};
-const makeAsyncIteratorCall = (event) => {
-	return tsg.arrowFunc([], void 0, tsg.identifier("pubsub").importFrom("../pubsub").property("asyncIterator").call(tsg.array([tsg.identifier(`SubscriptionName.${event}`)])));
-};
-const makeWithFilter = (event, filters) => {
-	const binaryExpressions = filters.map((it) => tsg.binary(tsg.identifier(`result.${it.field}`), "===", tsg.identifier(`variables.${it.field}`))).reduce((previousValue, currentValue) => tsg.binary(previousValue, "&&", currentValue));
-	return tsg.identifier("withFilter").importFrom("graphql-subscriptions").call(makeAsyncIteratorCall(event), tsg.arrowFunc([tsg.parameter("payload", KeywordTypeNode.any), tsg.parameter("variables", KeywordTypeNode.any)], tsg.typeRef("Promise", [KeywordTypeNode.boolean]), tsg.block(tsg.variable("const", tsg.identifier("result"), tsg.await(tsg.identifier(`payload.${event}`))), tsg.return(binaryExpressions))).toAsync());
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/gqlString.ts
-const GQLString = {
-	args: (args) => {
-		if (args.length === 0) return "";
-		return `(${args.map((arg) => `${arg.name}: ${GQLString.type(arg.type)}`).join(",")})`;
-	},
-	field: (field) => {
-		return `${field.fieldName}: ${fieldGqlType(field)}`;
-	},
-	referenceField: (ref) => {
-		return `${ref.fieldName}: ${makeGQLType(EntityName.fromTableName(ref.parentTableName).name, ref.isNullable, ref.isArray)}`;
-	},
-	referencedField: (ref) => {
-		return `${ref.fieldName}: ${makeGQLType(EntityName.fromTableName(ref.childTable).name, ref.isNullable, ref.isArray)}`;
-	},
-	query: (node) => {
-		return `${node.queryName}${GQLString.args(node.args)}: ${GQLString.type(node.returnType)}`;
-	},
-	mutation: (node) => {
-		return `${node.mutationName}${GQLString.args(node.args)}: ${GQLString.type(node.returnType)}`;
-	},
-	subscription: (node) => {
-		return `${node.subscriptionName}${GQLString.args(node.args)}: ${GQLString.type(node.returnType)}`;
-	},
-	type: (node) => {
-		const type = node.nullable ? node.typeName : node.typeName + "!";
-		if (node.array) return `[${type}]!`;
-		return type;
-	}
-};
-const fieldGqlType = (field) => {
-	return makeGQLType(field.gqlType, field.isNullable, field.isArray);
-};
-const makeGQLType = (typeName, isNullable, isArray) => {
-	const type = isNullable ? typeName : typeName + "!";
-	if (isArray) return `[${type}]!`;
-	return type;
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/scripts/typeDefinition.ts
-const typeFieldDefinitionToTsg = (def) => {
-	const properties = [tsg.propertyAssign("return", tsg.string(def.return)), def.args ? tsg.propertyAssign("args", tsg.array(def.args.map((it) => {
-		return tsg.object(tsg.propertyAssign("name", tsg.string(it.name)), tsg.propertyAssign("type", tsg.string(it.type)));
-	}))) : null];
-	return tsg.object(...properties.filter(nonNullable));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateTypeDefs.ts
-const generateTypeDefs = (root) => {
-	const types = [
-		...root.entities.map(makeEntityType),
-		makeQuery(root),
-		makeMutation(root.entities.flatMap((it) => it.mutations)),
-		makeSubscription(root.subscriptions.filter((it) => it.gqlEnabled))
-	].filter(nonNullable);
-	const inputs = [
-		tsg.propertyAssign("PagingOption", tsg.object(tsg.propertyAssign("numberOfItem", typeFieldDefinitionToTsg({ return: "Int!" })), tsg.propertyAssign("offset", typeFieldDefinitionToTsg({ return: "Int" })), tsg.propertyAssign("order", typeFieldDefinitionToTsg({ return: "String" })), tsg.propertyAssign("asc", typeFieldDefinitionToTsg({ return: "Boolean" })))),
-		...root.entities.map(makeCreateInput),
-		...root.entities.map(makeUpdateInput),
-		...root.entities.map(makeIdentifyInput)
-	].filter(nonNullable);
-	return new TsFile(tsg.variable("const", tsg.identifier("typeDefs"), tsg.object(...types)).export(), tsg.variable("const", tsg.identifier("inputs"), tsg.object(...inputs)).export()).disableEsLint();
-};
-const makeEntityType = (node) => {
-	if (!node.gqlEnabled) return null;
-	return tsg.propertyAssign(node.name.name, tsg.object(...node.fields.filter((it) => it.isGQLOpen).map((it) => {
-		return tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({ return: makeGQLType(it.gqlType, it.isNullable, it.isArray) }));
-	}), ...node.references.filter((it) => it.isGQLOpen).map((it) => {
-		return tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({ return: makeGQLType(EntityName.fromTableName(it.parentTableName).name, it.isNullable, it.isArray) }));
-	}), ...node.referencedBy.filter((it) => it.isGQLOpen).map((it) => {
-		return tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({ return: makeGQLType(EntityName.fromTableName(it.childTable).name, it.isNullable, it.isArray) }));
-	})));
-};
-const makeInput = (inputName, fields) => {
-	return tsg.propertyAssign(inputName, tsg.object(...fields.filter((it) => it.isGQLOpen).map((it) => tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({ return: makeGQLType(it.gqlType, it.isNullable, it.isArray) })))));
-};
-const makeCreateInput = (node) => {
-	if (!node.gqlEnabled || !node.creatable.gqlEnabled) return null;
-	return makeInput(node.name.createInputName(), node.creatable.fields);
-};
-const makeUpdateInput = (node) => {
-	if (!node.gqlEnabled || !node.updateInput.gqlEnabled) return null;
-	return makeInput(node.name.updateInputName(), node.updateInput.fields);
-};
-const makeIdentifyInput = (node) => {
-	if (!node.gqlEnabled || !node.mutations.find((it) => it.mutationType === "delete")) return null;
-	return makeInput(node.name.identifyInputName(), node.fields.filter((it) => it.isPrimary));
-};
-const makeQueryTypeDef = (entity, query) => {
-	const args = getArgs(query, entity);
-	return tsg.propertyAssign(query.type === "primary" ? entity.name.lowerCase() : query.name, typeFieldDefinitionToTsg({
-		return: GQLString.type({
-			typeName: entity.name.name,
-			entity: true,
-			array: query.type === "list-paging" || query.type === "list-all",
-			nullable: query.type !== "list-paging" && query.type !== "list-all"
-		}),
-		args: args.map((it) => ({
-			name: it.name,
-			type: it.type + "!"
-		}))
-	}));
-};
-const makeQueryProperties = (root) => {
-	return root.entities.filter((it) => it.gqlEnabled).flatMap((entity) => entity.queries.map((it) => makeQueryTypeDef(entity, it)));
-};
-const makeQuery = (root) => {
-	const properties = makeQueryProperties(root);
-	if (properties.length === 0) return null;
-	return tsg.propertyAssign("Query", tsg.object(...properties));
-};
-const makeMutation = (mutations) => {
-	if (mutations.length === 0) return null;
-	return tsg.propertyAssign("Mutation", tsg.object(...mutations.map((mutation) => {
-		return tsg.propertyAssign(mutation.mutationName, typeFieldDefinitionToTsg({
-			return: GQLString.type(mutation.returnType),
-			args: mutation.args.map((arg) => ({
-				name: arg.name,
-				type: GQLString.type(arg.type)
-			}))
-		}));
-	})));
-};
-const makeSubscription = (subscriptions) => {
-	if (subscriptions.length === 0) return null;
-	return tsg.propertyAssign("Subscription", tsg.object(...subscriptions.map((subscription) => {
-		return tsg.propertyAssign(subscription.subscriptionName, typeFieldDefinitionToTsg({
-			return: GQLString.type(subscription.returnType),
-			args: subscription.args.map((arg) => ({
-				name: arg.name,
-				type: GQLString.type(arg.type)
-			}))
-		}));
-	})));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/generateUserDefinedCondition.ts
-const { createSourceFile, ScriptTarget } = typescript;
-const generateUserDefinedCondition = (root, content) => {
-	const customConditionNames = unique(root.entities.flatMap((it) => [...it.references.flatMap((it) => it.joinCondition.filter((it) => it.kind === "custom").map((it) => it.conditionName)), ...it.referencedBy.flatMap((it) => it.joinCondition.filter((it) => it.kind === "custom").map((it) => it.conditionName))]));
-	if (customConditionNames.length === 0) return null;
-	const sourceFile = createSourceFile(tsFileNames.conditions + ".ts", content, ScriptTarget.ESNext);
-	const exportedVariables = getExportedVariables(sourceFile);
-	const contextImported = isImported(sourceFile, "GQLContext", ["./context", "./context.js"]);
-	const customConditionImported = isImported(sourceFile, "CustomCondition", ["sasat"]);
-	const statements = [];
-	customConditionNames.forEach((conditionName) => {
-		if (!exportedVariables.some((it) => {
-			return it.declarationList.declarations[0].name.getText(sourceFile) === conditionName;
-		})) statements.push(tsg.variable("const", conditionName, tsg.arrowFunc([], void 0, tsg.block(tsg.throw(tsg.new(tsg.identifier("Error"), tsg.string("TODO: Not Implemented"))))), tsg.typeRef("CustomCondition", [tsg.typeRef("GQLContext")])).export());
-	});
-	const context = contextImported ? "" : new ImportDeclaration(["GQLContext"], "./context").toString() + "\n";
-	const condition = customConditionImported ? "" : new ImportDeclaration(["CustomCondition"], "sasat").toString() + "\n";
-	const addition = statements.length === 0 ? "" : "\n" + new TsFile(...statements).toString();
-	return context + condition + content + addition;
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/relationMap/getRequiredColumnNames.ts
-const getChildConditionValue = (cv) => {
-	if (cv.kind === "child") return cv.field;
-	return null;
-};
-const getConditionChildColumnNames = (getConditionValue) => (c) => {
-	if (c.kind === "custom") return c.childRequiredFields || [];
-	if (c.kind === "isNull") return [];
-	const result = [getConditionValue(c.left)];
-	if (c.operator === "IN") {
-		result.push(getConditionValue(c.left));
-		c.right.forEach((it) => {
-			result.push(getConditionValue(it));
-		});
-	}
-	if (c.operator !== "BETWEEN") result.push(getConditionValue(c.right));
-	else if (c.right.kind === "range") result.push(getConditionValue(c.right.begin), getConditionValue(c.right.end));
-	return result;
-};
-const getChildRequiredNames = (ref) => {
-	const getNames = getConditionChildColumnNames(getChildConditionValue);
-	return ref.joinCondition.flatMap(getNames).filter(nonNullable);
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/relationMap/makeNoContexError.ts
-const makeJoinRangeConditionThrowExpressions = (cv) => {
-	if (cv.kind === "range") {
-		const result = [];
-		if (cv.begin.kind === "context") result.push(makeJoinConditionThrowExpressions(cv.begin));
-		if (cv.end.kind === "context") result.push(makeJoinConditionThrowExpressions(cv.end));
-		return result;
-	}
-	return [];
-};
-const makeJoinConditionThrowExpressions = (cv) => {
-	if (cv.kind !== "context") return null;
-	if (cv.onNotDefined.action !== "error") return null;
-	return tsg.if(tsg.binary(tsg.identifier("!arg.context"), "||", tsg.binary(tsg.identifier("arg.context").property(cv.field), "===", tsg.identifier("undefined"))), tsg.throw(tsg.new(tsg.identifier("Error"), tsg.string(cv.onNotDefined.message))));
-};
-const makeThrowExpressions = (condition) => {
-	if (condition.kind === "custom") return [];
-	if (condition.kind === "isNull") return [makeJoinConditionThrowExpressions(condition.value)];
-	if (condition.operator === "BETWEEN") return [makeJoinConditionThrowExpressions(condition.left), ...condition.right.kind === "range" ? makeJoinRangeConditionThrowExpressions(condition.right) : []];
-	if (condition.operator === "IN") return [makeJoinConditionThrowExpressions(condition.left), ...condition.right.map(makeJoinConditionThrowExpressions)];
-	return [makeJoinConditionThrowExpressions(condition.left), makeJoinConditionThrowExpressions(condition.right)];
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/relationMap/makeJoinConditionValue.ts
-const qExpr = tsg.identifier("qe").importFrom("sasat");
-const parentTableAlias = "parentTableAlias";
-const childTableAlias = "childTableAlias";
-const makeJoinConditionValueQExpr = (node, cv) => {
-	const arg = tsg.identifier("arg");
-	switch (cv.kind) {
-		case "parent": {
-			const columnName = node.fields.find((it) => it.fieldName === cv.field)?.columnName || cv.field;
-			return qExpr.property("field").call(arg.property(childTableAlias), tsg.string(columnName));
-		}
-		case "child": {
-			const columnName = node.fields.find((it) => it.fieldName === cv.field)?.columnName || cv.field;
-			return tsg.ternary(arg.property(parentTableAlias), qExpr.property("field").call(arg.property(parentTableAlias), tsg.string(columnName)), qExpr.property("value").call(arg.property("parent?").property(cv.field)));
-		}
-		default: return makeConditionValueQExpr(cv);
-	}
-};
-const makeRangeCondition = (entity, range) => {
-	if (range.kind === "range") return [makeJoinConditionValueQExpr(entity, range.begin), makeJoinConditionValueQExpr(entity, range.end)];
-	return [tsg.spread(tsg.identifier("getDayRangeQExpr").importFrom("sasat").call(tsg.new(tsg.identifier("Date")), range.thresholdHour ? tsg.number(range.thresholdHour) : tsg.identifier("undefined")))];
-};
-const makeConditionExpr = (entity, condition) => {
-	if (condition.kind === "custom") return tsg.identifier(condition.conditionName).importFrom("../conditions").call(tsg.identifier("arg"));
-	if (condition.kind === "isNull") return qExpr.property(condition.not ? "isNotNull" : "isNull").call(makeJoinConditionValueQExpr(entity, condition.value));
-	if (condition.operator === "BETWEEN") return qExpr.property("between").call(makeJoinConditionValueQExpr(entity, condition.left), ...makeRangeCondition(entity, condition.right));
-	if (condition.operator === "IN") return qExpr.property("in").call(makeJoinConditionValueQExpr(entity, condition.left), tsg.array(condition.right.map((it) => makeConditionValueRaw(it))));
-	return qExpr.property("comparison").call(makeJoinConditionValueQExpr(entity, condition.left), tsg.string(condition.operator), makeJoinConditionValueQExpr(entity, condition.right));
-};
-const makeJoinConditionValue = (node, ref) => {
-	const arg = tsg.identifier("arg");
-	return tsg.propertyAssign("condition", tsg.arrowFunc([tsg.parameter(arg.toString())], tsg.typeRef("BooleanValueExpression").importFrom("sasat"), tsg.block(...ref.joinCondition.flatMap((it) => makeThrowExpressions(it)).filter(nonNullable), tsg.return(qExpr.property("and").call(...ref.joinCondition.map((it) => makeConditionExpr(node, it)))))));
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/relationMap/index.ts
-const generateRelationMap = (root) => {
-	return new TsFile(makeRelationMap(root), makeTableInfo(root), ...root.entities.flatMap(entityRelationType)).disableEsLint();
-};
-const makeRelationMap = (root) => {
-	return tsg.variable("const", tsg.identifier("relationMap"), tsg.object(...root.entities.map((it) => makeEntityRelationMap(it))), tsg.typeRef("RelationMap", [makeContextTypeRef("GENERATED")]).importFrom("sasat")).export();
-};
-const fieldNameToColumnNameAndFilterPrimary = (node) => (field) => {
-	const column = node.fields.find((it) => it.fieldName === field || it.columnName === field);
-	if (!column) throw new Error(`${node.name.name}.${field} Not Found`);
-	if (column.isPrimary) return null;
-	return column.columnName;
-};
-const makeEntityRelationMap = (node) => {
-	return tsg.propertyAssign(node.tableName, tsg.object(...node.references.map((ref) => {
-		const toColumnName = fieldNameToColumnNameAndFilterPrimary(ref.entity);
-		return tsg.propertyAssign(ref.fieldName, tsg.object(tsg.propertyAssign("table", tsg.string(ref.parentTableName)), makeJoinConditionValue(node, ref), tsg.propertyAssign("array", tsg.boolean(ref.isArray)), tsg.propertyAssign("nullable", tsg.boolean(ref.isNullable)), tsg.propertyAssign("requiredColumns", tsg.array(getChildRequiredNames(ref).map(toColumnName).filter(nonNullable).map(tsg.string)))));
-	}), ...node.referencedBy.map((rel) => {
-		const toColumnName = fieldNameToColumnNameAndFilterPrimary(rel.entity);
-		return tsg.propertyAssign(rel.fieldName, tsg.object(tsg.propertyAssign("table", tsg.string(rel.childTable)), makeJoinConditionValue(node, rel), tsg.propertyAssign("array", tsg.boolean(rel.isArray)), tsg.propertyAssign("nullable", tsg.boolean(rel.isNullable)), tsg.propertyAssign("requiredColumns", tsg.array(getChildRequiredNames(rel).map(toColumnName).filter(nonNullable).map(tsg.string)))));
-	})));
-};
-const makeTableInfo = (root) => {
-	const columnMap = (entity) => tsg.propertyAssign("columnMap", tsg.object(...entity.fields.map((field) => tsg.propertyAssign(field.fieldName, tsg.string(field.columnName)))));
-	return tsg.variable("const", "tableInfo", tsg.object(...root.entities.map((entity) => tsg.propertyAssign(entity.tableName, tsg.object(tsg.propertyAssign("identifiableKeys", tsg.array(entity.identifyKeys.map(tsg.string))), tsg.propertyAssign("identifiableFields", tsg.array(entity.fields.filter((it) => it.isPrimary).map((it) => it.fieldName).map(tsg.string))), columnMap(entity))))), tsg.typeRef("TableInfo").importFrom("sasat")).export();
-};
-const referenceRelationType = (ref) => {
-	const parentEntityName = EntityName.fromTableName(ref.parentTableName);
-	const type = tsg.typeRef("EntityResult", [tsg.typeRef(parentEntityName.entityWithRelationTypeName()), tsg.typeRef(parentEntityName.relationTypeName())]).importFrom("sasat");
-	return tsg.propertySignature(ref.fieldName, ref.isArray ? tsg.arrayType(type) : type);
-};
-const referencedRelationType = (node) => {
-	const child = EntityName.fromTableName(node.childTable);
-	const type = tsg.typeRef("EntityResult", [tsg.typeRef(child.entityWithRelationTypeName()), makeTypeRef(child, "identifiable", "GENERATED")]).importFrom("sasat");
-	return tsg.propertySignature(node.fieldName, node.isArray ? tsg.arrayType(type) : type);
-};
-const entityRelationType = (node) => {
-	const typeProperties = [...node.references.map(referenceRelationType), ...node.referencedBy.map(referencedRelationType)];
-	return [
-		tsg.typeAlias(node.name.relationTypeName(), typeProperties.length !== 0 ? tsg.typeLiteral(typeProperties) : tsg.typeRef("Record<never, never>")).export(),
-		tsg.typeAlias(node.name.entityWithRelationTypeName(), tsg.intersectionType(makeTypeRef(node.name, "entity", "GENERATED"), tsg.typeRef(node.name.relationTypeName()))).export(),
-		tsg.typeAlias(node.name.resultType(), tsg.typeRef("EntityResult", [tsg.typeRef(node.name.entityWithRelationTypeName()), makeTypeRef(node.name, "identifiable", "GENERATED")]).importFrom("sasat")).export()
-	];
-};
-//#endregion
-//#region src/generatorv2/codegen/ts/staticFiles.ts
-const contextFile = `\
-${new ImportDeclaration(["BaseGQLContext"], "./__generated__/context").toString()}
-export type GQLContext = BaseGQLContext & Record<string, never>;
-`;
-const pubsubFile = `\
-${new ImportDeclaration(["PubSub", "PubSubEngine"], "graphql-subscriptions").toString()}
-
-export const pubsub: PubSubEngine = new PubSub();
-`;
-const schemaFile = `\
-${new ImportDeclaration(["assignDeep", "createTypeDef"], "sasat").toString()}
-${new ImportDeclaration(["typeDefs", "inputs"], "./__generated__/typeDefs").toString()}
-${new ImportDeclaration(["resolvers"], "./__generated__/resolver").toString()}
-
-export const schema = {
-  typeDefs: createTypeDef(
-    assignDeep(typeDefs, {}),
-    assignDeep(inputs, {}),
-  ),
-  resolvers: assignDeep(resolvers, {}),
-};
-`;
-const baseDBDataSourceFile = `\
-${new ImportDeclaration([
-	"Fields",
-	"SasatDBDatasource",
-	"EntityType"
-], "sasat").toString()}
-${new ImportDeclaration(["relationMap", "tableInfo"], "./__generated__/relationMap").toString()}
-
-export abstract class BaseDBDataSource<
-  Entity extends EntityType,
-  Identifiable extends object,
-  Creatable extends EntityType,
-  Updatable extends Identifiable,
-  EntityFields extends Fields<Entity>,
-  QueryResult extends Partial<Entity> & Identifiable,
-> extends SasatDBDatasource<Entity, Identifiable, Creatable, Updatable, EntityFields, QueryResult> {
-  protected relationMap = relationMap;
-  protected tableInfo = tableInfo;
-}
-`;
-const staticFiles = [
-	{
-		name: "context",
-		body: contextFile
-	},
-	{
-		name: "pubsub",
-		body: pubsubFile
-	},
-	{
-		name: "schema",
-		body: schemaFile
-	},
-	{
-		name: "baseDBDataSource",
-		body: baseDBDataSourceFile
-	}
-];
-//#endregion
-//#region src/generatorv2/codegen/tscodegen_v2.ts
-var TsCodegen_v2 = class {
-	constructor() {
-		this.fileExtension = "ts";
-		this.generateEntity = (node) => generateEntityFile(node).generate();
-		this.generateDatasource = (node) => generateDatasource(node).generate();
-		this.generateGeneratedDatasource = (node) => generateAutoGeneratedDatasource(node).generate();
-		this.generateGqlTypeDefs = (root) => generateTypeDefs(root).generate();
-		this.generateGqlResolver = (root) => generateResolver(root).generate();
-		this.generateGqlQuery = (root) => generateQueryResolver(root).generate();
-		this.generateGqlMutation = (root) => generateMutationResolver(root).generate();
-		this.generateGqlSubscription = (root) => generateSubscription(root).generate();
-		this.generateGQLContext = (root) => generateContext(root).generate();
-		this.generateFiles = async (root) => {
-			return [{
-				name: "relationMap",
-				body: await generateRelationMap(root).generate()
-			}, {
-				name: "fields",
-				body: await generateFields(root).generate()
-			}];
-		};
-		this.generateOnceFiles = () => {
-			return staticFiles;
-		};
-		this.generateConditions = (root, currentFile) => {
-			return generateUserDefinedCondition(root, currentFile);
-		};
-		this.generateIDEncoders = (root, currentFile) => {
-			return generateIDEncoder(root, currentFile);
-		};
-		this.generateMiddlewares = (root, currentFile) => {
-			return generateMiddlewares(root, currentFile);
-		};
-	}
-};
-//#endregion
-//#region src/generatorv2/parser/makeContextNodes.ts
-const makeContextNodes = (store) => {
-	return store.tables.flatMap((table) => {
-		return table.gqlOption.mutations.flatMap((mutation) => mutation.contextFields.map((it) => ({
-			name: it.contextName || it.column,
-			dbtype: table.column(it.column).dataType()
-		})));
-	});
-};
-//#endregion
-//#region src/generatorv2/parser/makeMutationNodes.ts
-const makeEntityMutationNodes = (table, entity) => {
-	if (!table.gqlOption.enabled) return [];
-	return table.gqlOption.mutations.map((mutation) => {
-		switch (mutation.type) {
-			case "create": return makeCreateMutationNode(table, entity, mutation);
-			case "update": return makeUpdateMutationNode(table, entity, mutation);
-			case "delete": return makeDeleteMutationNode(table, entity, mutation);
-			default: throw new Error(`invalid mutation type: ${mutation.type}`);
-		}
-	});
-};
-const makeContextField = (params) => ({
-	fieldName: params.column,
-	contextName: params.contextName || params.column
-});
-const makeCreateMutationNode = (table, entity, mutation) => {
-	return {
-		entity,
-		contextFields: mutation.contextFields.map(makeContextField),
-		entityName: table.getEntityName(),
-		identifyFields: table.getPrimaryKeyColumns().map((it) => it.fieldName()),
-		mutationName: `create${table.getEntityName().name}`,
-		inputName: entity.name.createInputName(),
-		refetch: !mutation.noReFetch,
-		returnType: {
-			typeName: table.getEntityName().name,
-			nullable: false,
-			array: false,
-			entity: true
-		},
-		args: [{
-			name: table.getEntityName().lowerCase(),
-			type: {
-				typeName: table.getEntityName().createInputName(),
-				nullable: false,
-				array: false,
-				entity: true
-			}
-		}],
-		mutationType: "create",
-		subscription: mutation.subscription.enabled,
-		requireIdDecodeMiddleware: entity.creatable.fields.some((it) => it.hashId),
-		middlewares: mutation.middlewares
-	};
-};
-const makeUpdateMutationNode = (table, entity, mutation) => {
-	return {
-		entity,
-		contextFields: mutation.contextFields.map(makeContextField),
-		entityName: table.getEntityName(),
-		identifyFields: table.getPrimaryKeyColumns().map((it) => it.fieldName()),
-		mutationName: `update${table.getEntityName().name}`,
-		inputName: entity.name.updateInputName(),
-		refetch: !mutation.noReFetch,
-		returnType: {
-			typeName: mutation.noReFetch ? "Boolean" : table.getEntityName().name,
-			dbType: mutation.noReFetch ? "boolean" : void 0,
-			nullable: false,
-			array: false,
-			entity: !mutation.noReFetch
-		},
-		args: [{
-			name: table.getEntityName().lowerCase(),
-			type: {
-				typeName: table.getEntityName().updateInputName(),
-				nullable: false,
-				array: false,
-				entity: true
-			}
-		}],
-		mutationType: "update",
-		subscription: mutation.subscription.enabled,
-		requireIdDecodeMiddleware: entity.updateInput.fields.some((it) => it.hashId),
-		middlewares: mutation.middlewares
-	};
-};
-const makeDeleteMutationNode = (table, entity, mutation) => {
-	return {
-		entity,
-		mutationName: `delete${table.getEntityName().name}`,
-		inputName: entity.name.identifyInputName(),
-		contextFields: mutation.contextFields.map(makeContextField),
-		entityName: table.getEntityName(),
-		identifyFields: table.getPrimaryKeyColumns().map((it) => it.fieldName()),
-		refetch: false,
-		returnType: {
-			typeName: "Boolean",
-			dbType: "boolean",
-			nullable: false,
-			array: false,
-			entity: false
-		},
-		args: [{
-			name: table.getEntityName().lowerCase(),
-			type: {
-				typeName: table.getEntityName().identifyInputName(),
-				nullable: false,
-				array: false,
-				entity: true
-			}
-		}],
-		mutationType: "delete",
-		subscription: mutation.subscription.enabled,
-		requireIdDecodeMiddleware: entity.identifyFields().some((it) => it.hashId),
-		middlewares: mutation.middlewares
-	};
-};
-//#endregion
-//#region src/generatorv2/scripts/columnToGqlType.ts
-const columnTypeToGqlPrimitive = (type) => {
-	switch (type) {
-		case "tinyint":
-		case "smallint":
-		case "mediumint":
-		case "int":
-		case "bigint":
-		case "decimal":
-		case "year": return "Int";
-		case "float":
-		case "double": return "Float";
-		case "char":
-		case "varchar":
-		case "text":
-		case "time":
-		case "date":
-		case "datetime":
-		case "timestamp": return "String";
-		case "boolean": return "Boolean";
-	}
-};
-//#endregion
-//#region src/generatorv2/nodes/FieldNode.ts
-const getHashId = (store, entity, column) => {
-	if (!column.isReference()) {
-		if (column.data.option.autoIncrementHashId) return { encoder: entity.IDEncoderName() };
-		return;
-	}
-	const ref = column.data.reference;
-	const parent = store.table(ref.parentTable);
-	if (!parent.column(ref.parentColumn).data.option.autoIncrementHashId) return void 0;
-	return { encoder: parent.getEntityName().IDEncoderName() };
-};
-const makeFieldNode = (store, entity, column) => {
-	const hashId = getHashId(store, entity.name, column);
-	return {
-		entity,
-		fieldName: column.fieldName(),
-		columnName: column.columnName(),
-		gqlType: hashId ? "ID" : column.gqlType(),
-		dbType: column.dataType(),
-		isAutoIncrement: column.data.autoIncrement,
-		isArray: false,
-		isPrimary: column.isPrimary(),
-		isNullable: column.isNullable(),
-		isUpdatable: !(column.data.onUpdateCurrentTimeStamp || column.isPrimary()) && column.data.option.updatable,
-		isGQLOpen: true,
-		column: column.data,
-		option: column.data.option,
-		hashId
-	};
-};
-const makeCreatableFieldNode = (store, entity, column) => {
-	if (column.data.autoIncrement || column.data.defaultCurrentTimeStamp) return null;
-	const hashId = getHashId(store, entity.name, column);
-	return {
-		entity,
-		fieldName: column.fieldName(),
-		columnName: column.columnName(),
-		gqlType: hashId ? "ID" : column.gqlType(),
-		dbType: column.dataType(),
-		isAutoIncrement: column.data.autoIncrement,
-		isArray: false,
-		isPrimary: column.isPrimary(),
-		isNullable: column.isNullableOnCreate(),
-		isUpdatable: column.isUpdatable(),
-		isGQLOpen: !(column.table.gqlOption.mutations.find((it) => it.type === "create")?.contextFields || []).some((it) => it.column === column.columnName()),
-		column: column.data,
-		option: column.data.option,
-		hashId: getHashId(store, entity.name, column)
-	};
-};
-const makeUpdatableFieldNode = (store, entity, column) => {
-	if (!column.isUpdatable() || !column.data.option.updatable) return null;
-	const hashId = getHashId(store, entity.name, column);
-	return {
-		entity,
-		fieldName: column.fieldName(),
-		columnName: column.columnName(),
-		gqlType: hashId ? "ID" : column.gqlType(),
-		dbType: column.dataType(),
-		isAutoIncrement: column.data.autoIncrement,
-		isArray: false,
-		isNullable: true,
-		isPrimary: false,
-		isUpdatable: true,
-		isGQLOpen: !(column.table.gqlOption.mutations.find((it) => it.type === "update")?.contextFields || []).some((it) => it.column === column.columnName()),
-		column: column.data,
-		option: column.data.option,
-		hashId: getHashId(store, entity.name, column)
-	};
-};
-//#endregion
-//#region src/migration/makeCondition.ts
-const parent = (field) => ({
-	kind: "parent",
-	field
-});
-const child = (field) => ({
-	kind: "child",
-	field
-});
-const contextOrError = (field, errorMessage) => ({
-	kind: "context",
-	field,
-	onNotDefined: {
-		action: "error",
-		message: errorMessage
-	}
-});
-const contextOrDefault = (field, defaultValue) => ({
-	kind: "context",
-	field,
-	onNotDefined: {
-		action: "defaultValue",
-		value: defaultValue
-	}
-});
-const fixed = (value) => ({
-	kind: "fixed",
-	value
-});
-const today = (thresholdHour, date) => ({
-	kind: "today",
-	type: date ? "date" : "datetime",
-	thresholdHour
-});
-const now = () => ({ kind: "now" });
-const values = (begin, end) => ({
-	kind: "range",
-	begin,
-	end
-});
-const betweenToday = (thresholdHour) => ({
-	kind: "date-range",
-	range: "today",
-	thresholdHour
-});
-const custom = (conditionName, parentRequiredFields, childRequiredFields) => ({
-	kind: "custom",
-	conditionName,
-	parentRequiredFields,
-	childRequiredFields
-});
-const field$1 = (column) => ({
-	kind: "field",
-	column
-});
-const arg = (name, type) => ({
-	kind: "arg",
-	name,
-	type
-});
-const betweenRel = (left, range) => ({
-	kind: "comparison",
-	left,
-	operator: "BETWEEN",
-	right: range
-});
-const betweenQuery = (left, begin, end) => ({
-	kind: "between",
-	operator: "BETWEEN",
-	left,
-	begin,
-	end
-});
-const comparisonRel = (left, operator, right) => ({
-	kind: "comparison",
-	left,
-	right,
-	operator
-});
-const inRel = (left, right) => ({
-	kind: "comparison",
-	left,
-	right,
-	operator: "IN"
-});
-const isNullRel = (value) => ({
-	kind: "isNull",
-	value,
-	not: false
-});
-const isNotNullRel = (value) => ({
-	kind: "isNull",
-	value,
-	not: true
-});
-const comparisonQuery = (left, operator, right) => ({
-	kind: "comparison",
-	left,
-	right,
-	operator
-});
-const Conditions = {
-	betweenRel,
-	betweenQuery,
-	custom,
-	rel: {
-		between: betweenRel,
-		comparison: comparisonRel,
-		in: inRel,
-		isNull: isNullRel,
-		isNotNull: isNotNullRel
-	},
-	query: {
-		between: betweenQuery,
-		comparison: comparisonQuery
-	},
-	value: {
-		parent,
-		child,
-		contextOrError,
-		contextOrDefault,
-		fixed,
-		today,
-		now,
-		field: field$1,
-		arg
-	},
-	range: {
-		values,
-		today: betweenToday
-	}
-};
-//#endregion
-//#region src/generatorv2/nodes/ReferencedNode.ts
-var ReferenceNode = class ReferenceNode {
-	static fromReference(entity, column, parentTable) {
-		const ref = column.data.reference;
-		if (!ref.fieldName) return null;
-		return new ReferenceNode(entity, ref.fieldName, column.table.tableName, ref.parentTable, makeJoinCondition(ref.parentColumn, column.columnName()), false, column.isNullable(), column.isPrimary(), column.table.gqlOption.enabled && parentTable.gqlOption.enabled);
-	}
-	static formVirtualRelation(ds, entity, rel) {
-		if (!rel.childFieldName) return null;
-		return new ReferenceNode(entity, rel.childFieldName, rel.childTable, rel.parentTable, rel.conditions, rel.childType === void 0 || rel.childType === "array", rel.childType === "nullable", false, ds.table(rel.parentTable).gqlOption.enabled && ds.table(rel.childTable).gqlOption.enabled);
-	}
-	constructor(entity, fieldName, tableName, parentTableName, joinCondition, isArray, isNullable, isPrimary, isGQLOpen) {
-		this.entity = entity;
-		this.fieldName = fieldName;
-		this.tableName = tableName;
-		this.parentTableName = parentTableName;
-		this.joinCondition = joinCondition;
-		this.isArray = isArray;
-		this.isNullable = isNullable;
-		this.isPrimary = isPrimary;
-		this.isGQLOpen = isGQLOpen;
-	}
-};
-var ReferencedNode = class ReferencedNode {
-	static fromReference(entity, parentTable, column) {
-		const ref = column.data.reference;
-		if (!ref.parentFieldName) return null;
-		return new ReferencedNode(entity, ref.parentFieldName, column.table.tableName, makeJoinCondition(column.columnName(), ref.parentColumn), ref.relation === "Many", ref.relation === "OneOrZero", column.isPrimary(), parentTable.gqlOption.enabled && column.table.gqlOption.enabled);
-	}
-	static fromVirtualRelation(ds, entity, rel) {
-		if (!rel.parentFieldName) return null;
-		return new ReferencedNode(entity, rel.parentFieldName, rel.childTable, rel.conditions.map(reverseConditionNode), rel.parentType === void 0 || rel.parentType === "array", rel.parentType === "nullable", false, ds.table(rel.parentTable).gqlOption.enabled && ds.table(rel.childTable).gqlOption.enabled);
-	}
-	constructor(entity, fieldName, childTable, joinCondition, isArray, isNullable, isPrimary, isGQLOpen) {
-		this.entity = entity;
-		this.fieldName = fieldName;
-		this.childTable = childTable;
-		this.joinCondition = joinCondition;
-		this.isArray = isArray;
-		this.isNullable = isNullable;
-		this.isPrimary = isPrimary;
-		this.isGQLOpen = isGQLOpen;
-	}
-};
-const reverseConditionValue = (cv) => {
-	if (cv.kind === "parent") return {
-		...cv,
-		kind: "child"
-	};
-	else if (cv.kind === "child") return {
-		...cv,
-		kind: "parent"
-	};
-	return cv;
-};
-const reverseRangeCondition = (condition) => {
-	if (condition.kind === "range") return {
-		kind: condition.kind,
-		begin: reverseConditionValue(condition.begin),
-		end: reverseConditionValue(condition.end)
-	};
-	return condition;
-};
-const reverseConditionNode = (condition) => {
-	if (condition.kind === "custom") return {
-		...condition,
-		parentRequiredFields: condition.childRequiredFields,
-		childRequiredFields: condition.parentRequiredFields
-	};
-	if (condition.kind === "isNull") {
-		if (condition.not) return Conditions.rel.isNotNull(reverseConditionValue(condition.value));
-		return Conditions.rel.isNull(reverseConditionValue(condition.value));
-	}
-	if (condition.operator === "BETWEEN") return Conditions.rel.between(reverseConditionValue(condition.left), reverseRangeCondition(condition.right));
-	if (condition.operator === "IN") return Conditions.rel.in(reverseConditionValue(condition.left), condition.right.map(reverseConditionValue));
-	return Conditions.rel.comparison(reverseConditionValue(condition.right), condition.operator, reverseConditionValue(condition.left));
-};
-const makeJoinCondition = (parentColumn, childColumn) => {
-	return [Conditions.rel.comparison(Conditions.value.parent(parentColumn), "=", Conditions.value.child(childColumn))];
-};
-//#endregion
-//#region src/generatorv2/nodes/entityNode.ts
-var EntityNode = class {
-	constructor(store, table) {
-		this.name = EntityName.fromTableName(table.tableName);
-		this.fields = table.columns.map((it) => makeFieldNode(store, this, it));
-		this.tableName = table.tableName;
-		this.gqlEnabled = table.gqlOption.enabled;
-		this.identifyKeys = table.primaryKey;
-		this.queries = table.gqlOption.queries;
-		this.creatable = {
-			gqlEnabled: table.gqlOption.enabled && table.gqlOption.mutations.find((it) => it.type === "create") !== void 0,
-			fields: table.columns.map((it) => makeCreatableFieldNode(store, this, it)).filter(nonNullable)
-		};
-		this.updateInput = {
-			gqlEnabled: table.gqlOption.enabled && table.gqlOption.mutations.find((it) => it.type === "update") !== void 0,
-			fields: [...this.fields.filter((it) => it.isPrimary), ...table.columns.map((it) => makeUpdatableFieldNode(store, this, it)).filter(nonNullable)]
-		};
-		this.references = table.getReferenceColumns().map((column) => ReferenceNode.fromReference(this, column, store.table(column.data.reference.parentTable))).concat(table.virtualRelations.map((it) => ReferenceNode.formVirtualRelation(store, this, it))).filter(nonNullable);
-		this.referencedBy = store.referencedBy(table.tableName).map((column) => ReferencedNode.fromReference(this, table, column)).concat(store.virtualReferencedBy(table.tableName).map((rel) => ReferencedNode.fromVirtualRelation(store, this, rel))).filter(nonNullable);
-		const makeFindMethodNode = (columns, isArray) => {
-			const fields = columns.map((column) => this.fields.find((it) => it.columnName === column));
-			return {
-				name: makeFindQueryName(fields.map((it) => it.fieldName)),
-				params: fields.map((it) => makePrimitiveParameterNode(it.fieldName, it.columnName, it.dbType)),
-				isArray
-			};
-		};
-		this.findMethods = [makeFindMethodNode(table.primaryKey, false)];
-		this.mutations = makeEntityMutationNodes(table, this);
-	}
-	identifyFields() {
-		return this.fields.filter((it) => it.isPrimary);
-	}
-	primaryQueryName() {
-		return makeFindQueryName(this.identifyFields().map((it) => it.fieldName));
-	}
-};
-const makePrimitiveParameterNode = (fieldName, columnName, dbtype) => ({
-	entity: false,
-	fieldName,
-	columnName,
-	dbtype,
-	gqltype: columnTypeToGqlPrimitive(dbtype)
-});
-//#endregion
-//#region src/generatorv2/parser/makeEntityNodes.ts
-const makeEntityNodes = (store) => {
-	const make = makeEntityNode(store);
-	return store.tables.map(make);
-};
-const makeEntityNode = (store) => (table) => {
-	return new EntityNode(store, table);
-};
-//#endregion
-//#region src/generatorv2/parser/makeSubscriptionNode.ts
-const makeSubscriptionNodes = (store) => {
-	return store.tables.flatMap((table) => {
-		return table.gqlOption.mutations.map((it) => {
-			return makeSubscriptionNode(table, it);
-		});
-	}).filter(nonNullable);
-};
-const subscriptionNamePostfix = {
-	create: "Created",
-	update: "Updated",
-	delete: "Deleted"
-};
-const makeSubscriptionNode = (table, mutation) => {
-	if (!mutation.subscription.enabled) return null;
-	const subscriptionName = table.getEntityName().name + subscriptionNamePostfix[mutation.type];
-	return {
-		subscriptionName,
-		entity: table.getEntityName(),
-		publishFunctionName: "publish" + subscriptionName,
-		returnType: {
-			typeName: table.getEntityName().name,
-			nullable: false,
-			array: false,
-			entity: true
-		},
-		args: mutation.subscription.subscriptionFilter.map((it) => {
-			const column = table.column(it);
-			return {
-				name: it,
-				type: {
-					typeName: column.gqlType(),
-					dbType: column.dataType(),
-					nullable: false,
-					array: false,
-					entity: false
-				}
-			};
-		}),
-		filters: (mutation.subscription?.subscriptionFilter || []).map((it) => {
-			const column = table.column(it);
-			return {
-				field: column.fieldName(),
-				gqlType: column.gqlType()
-			};
-		}),
-		mutationType: mutation.type,
-		gqlEnabled: table.gqlOption.enabled && mutation.subscription.enabled
-	};
-};
-//#endregion
-//#region src/generatorv2/parse.ts
-const parse = (store) => {
-	store.tables.forEach((it) => {
-		if (it.primaryKey.length === 0) throw new Error(`Table: ${it.tableName} has no primary key.`);
-	});
-	return {
-		entities: makeEntityNodes(store),
-		subscriptions: makeSubscriptionNodes(store),
-		contexts: makeContextNodes(store)
-	};
-};
-//#endregion
-//#region src/generatorv2/codegen_v2.ts
-var CodeGen_v2 = class {
-	constructor(store) {
-		this.codeGen = new TsCodegen_v2();
-		this.outDir = config().migration.out;
-		this.dbDataSourceDir = path$1.join(this.outDir, Directory.paths.DATA_SOURCES);
-		this.generateDir = path$1.join(this.outDir, Directory.paths.GENERATED);
-		this.generateEntityDir = path$1.join(this.outDir, Directory.paths.ENTITIES);
-		this.generateDbDataSourceDir = path$1.join(this.outDir, Directory.paths.GENERATED_DS);
-		this.root = parse(store);
-	}
-	async generate() {
-		await this.prepareDirs();
-		await Promise.all([
-			...this.root.entities.map((it) => this.generateEntity(it)),
-			...this.root.entities.map((it) => this.generateDatasource(it)),
-			...this.root.entities.map((it) => this.generateGeneratedDatasource(it)),
-			this.generateGql(this.root),
-			this.generateFiles(this.root),
-			...this.generateOnceFiles(),
-			this.generateCondition(this.root),
-			this.generateIDEncoders(this.root),
-			this.generateMiddleware(this.root)
-		]);
-	}
-	async prepareDirs() {
-		mkDirIfNotExist(this.generateDir);
-		await emptyDir(this.generateDir);
-		mkDirIfNotExist(this.generateEntityDir);
-		mkDirIfNotExist(this.generateDbDataSourceDir);
-		mkDirIfNotExist(this.dbDataSourceDir);
-	}
-	getFullPath(basePath, entityName) {
-		return path$1.join(basePath, `${entityName}.${this.codeGen.fileExtension}`);
-	}
-	async generateEntity(node) {
-		return writeFile(this.getFullPath(this.generateEntityDir, node.name.name), await this.codeGen.generateEntity(node));
-	}
-	async generateDatasource(node) {
-		return writeFileIfNotExist(this.getFullPath(this.dbDataSourceDir, node.name.name), await this.codeGen.generateDatasource(node));
-	}
-	async generateGeneratedDatasource(node) {
-		return writeFile(this.getFullPath(this.generateDbDataSourceDir, node.name.name), await this.codeGen.generateGeneratedDatasource(node));
-	}
-	async generateGql(rootNode) {
-		return Promise.all([
-			writeFile(this.getFullPath(this.generateDir, "typeDefs"), await this.codeGen.generateGqlTypeDefs(rootNode)),
-			writeFile(this.getFullPath(this.generateDir, "resolver"), await this.codeGen.generateGqlResolver(rootNode)),
-			writeFile(this.getFullPath(this.generateDir, "query"), await this.codeGen.generateGqlQuery(rootNode)),
-			writeFile(this.getFullPath(this.generateDir, "mutation"), await this.codeGen.generateGqlMutation(rootNode)),
-			writeFile(this.getFullPath(this.generateDir, "subscription"), await this.codeGen.generateGqlSubscription(rootNode)),
-			writeFile(this.getFullPath(this.generateDir, "context"), await this.codeGen.generateGQLContext(rootNode))
-		]);
-	}
-	async generateFiles(rootNode) {
-		const files = await this.codeGen.generateFiles(rootNode);
-		return Promise.all(files.map((it) => writeFileIfNotExist(this.getFullPath(this.generateDir, it.name), it.body)));
-	}
-	generateOnceFiles() {
-		return this.codeGen.generateOnceFiles().map((it) => writeFileIfNotExist(this.getFullPath(this.outDir, it.name), it.body));
-	}
-	async generateCondition(rootNode) {
-		const filePath = this.getFullPath(this.outDir, tsFileNames.conditions);
-		const content = existsSync(filePath) ? readFileSync(filePath).toString() : "";
-		const nextContent = this.codeGen.generateConditions(rootNode, content);
-		if (nextContent) writeFileSync(filePath, nextContent);
-	}
-	async generateIDEncoders(rootNode) {
-		const filePath = this.getFullPath(this.outDir, tsFileNames.encoder);
-		const content = existsSync(filePath) ? readFileSync(filePath).toString() : "";
-		const nextContent = this.codeGen.generateIDEncoders(rootNode, content);
-		if (nextContent) writeFileSync(filePath, nextContent);
-	}
-	async generateMiddleware(rootNode) {
-		const filePath = this.getFullPath(this.outDir, tsFileNames.middleware);
-		const content = existsSync(filePath) ? readFileSync(filePath).toString() : "";
-		const nextContent = this.codeGen.generateMiddlewares(rootNode, content);
-		if (nextContent) writeFileSync(filePath, nextContent);
-	}
-};
-//#endregion
-//#region src/migration/exec/getMigrationFiles.ts
-const getMigrationFileDir = () => {
-	return path.join(process.cwd(), config().migration.dir);
-};
-const getMigrationFileNames = () => {
-	return fs.readdirSync(getMigrationFileDir()).filter((it) => it.split(".").pop() === "ts");
-};
-//#endregion
-//#region src/error.ts
-var SasatError = class extends Error {
-	constructor(message) {
-		super(message);
-		Object.setPrototypeOf(this, new.target.prototype);
-		this.name = "SasatError";
-	}
-};
-//#endregion
-//#region src/runtime/sql/sqlString.ts
-const { escape, escapeId: escapeId$1 } = pkg;
-const SqlString = {
-	escape: (value) => escape(value, true),
-	escapeId: (name) => escapeId$1(name)
-};
-//#endregion
-//#region src/db/sql/columnToSql.ts
-const columnToSql = (column) => {
-	const words = [SqlString.escapeId(column.columnName), column.type];
-	if (column.length) words.push(`(${[column.length, column.scale].filter((it) => it !== void 0).join(",")})`);
-	if (column.signed === true) words.push("SIGNED");
-	else if (column.signed === false) words.push("UNSIGNED");
-	if (column.zerofill) words.push("ZEROFILL");
-	if (column.autoIncrement) words.push("AUTO_INCREMENT");
-	if (column.notNull) words.push("NOT NULL");
-	else if (!column.notNull) words.push("NULL");
-	if ((column.type === "timestamp" || column.type === "datetime") && column.default === "CURRENT_TIMESTAMP") words.push("DEFAULT CURRENT_TIMESTAMP");
-	else if (column.default !== void 0) words.push("DEFAULT " + SqlString.escape(column.default));
-	if (column.onUpdateCurrentTimeStamp) words.push("ON UPDATE CURRENT_TIMESTAMP");
-	return words.join(" ");
-};
-//#endregion
-//#region src/migration/serializable/column.ts
-var BaseColumn = class {
-	constructor(data, table) {
-		this.data = data;
-		this.table = table;
-	}
-	fieldName() {
-		return this.data.fieldName;
-	}
-	columnName() {
-		return this.data.columnName;
-	}
-	dataType() {
-		return this.data.type;
-	}
-	tsType() {
-		return columnTypeToTsType(this.dataType());
-	}
-	gqlType() {
-		return columnTypeToGqlPrimitive(this.dataType());
-	}
-	isNullable() {
-		return !this.data.notNull;
-	}
-	isNullableOnCreate() {
-		return !this.data.notNull || this.data.default !== void 0 || this.data.autoIncrement;
-	}
-	isReference() {
-		return this.data.hasReference;
-	}
-	serialize() {
-		return JSON.parse(JSON.stringify(this.data));
-	}
-	toSql() {
-		return columnToSql(this.data);
-	}
-	isPrimary() {
-		return this.table.primaryKey.includes(this.columnName());
-	}
-	isUpdatable() {
-		return !(this.isPrimary() || this.data.onUpdateCurrentTimeStamp);
-	}
-};
-var NormalColumn = class extends BaseColumn {
-	constructor(data, table) {
-		super(data, table);
-		this.data = data;
-	}
-	addReference(reference) {
-		return new ReferenceColumn({
-			...this.data,
-			hasReference: true,
-			reference
-		}, this.table);
-	}
-};
-var ReferenceColumn = class extends BaseColumn {
-	constructor(data, table) {
-		super(data, table);
-		this.data = data;
-	}
-	getConstraintName() {
-		return `ref_${this.table.tableName}_${this.fieldName()}__${this.data.reference.parentTable}_${this.data.reference.parentColumn}`;
-	}
-};
-//#endregion
-//#region src/migration/data/index.ts
-var DBIndex = class {
-	constructor(tableName, columns) {
-		this.tableName = tableName;
-		this.columns = columns;
-		this.constraintName = this.toConstraintName(columns);
-	}
-	toConstraintName(columns) {
-		return `index_${this.tableName}__${columns.join("_")}`;
-	}
-	addSql() {
-		return `ALTER TABLE ${this.tableName} ADD INDEX ${this.constraintName}(${this.columns.join(",")})`;
-	}
-	dropSql() {
-		return `DROP INDEX ${this.constraintName} ON ${this.tableName}`;
-	}
-	serialize() {
-		return {
-			constraintName: this.constraintName,
-			columns: this.columns
-		};
-	}
-};
-//#endregion
-//#region src/migration/functions/assembleColumn.ts
-const assembleColumn = (data, table) => {
-	if (data.hasReference) return new ReferenceColumn(data, table);
-	return new NormalColumn(data, table);
-};
-//#endregion
-//#region src/migration/serialized/serializedColumn.ts
-const defaultColumnOption = {
-	updatable: true,
-	autoIncrementHashId: false
-};
-const referenceToSql = (constraintName, ref) => {
-	const onUpdate = ref.onUpdate ? ` ON UPDATE ${ref.onUpdate}` : "";
-	const onDelete = ref.onDelete ? ` ON DELETE ${ref.onDelete}` : "";
-	return `CONSTRAINT ${constraintName} FOREIGN KEY(${ref.columnName}) REFERENCES ${SqlString.escapeId(ref.parentTable)}(${SqlString.escapeId(ref.parentColumn)})` + onUpdate + onDelete;
-};
-//#endregion
-//#region src/migration/serializable/table.ts
-var TableHandler = class {
-	get index() {
-		return this.indexes;
-	}
-	get columns() {
-		return this._columns;
-	}
-	get virtualRelations() {
-		return this._virtualRelations;
-	}
-	addVirtualRelation(relation) {
-		this._virtualRelations.push({
-			...relation,
-			childTable: this.tableName
-		});
-	}
-	get gqlOption() {
-		return this._gqlOption;
-	}
-	constructor(table, store) {
-		this.store = store;
-		this._gqlOption = defaultGQLOption();
-		this.tableName = table.tableName;
-		this.primaryKey = table.primaryKey || [];
-		this.uniqueKeys = table.uniqueKeys || [];
-		this.indexes = table.indexes?.map((it) => new DBIndex(this.tableName, it.columns)) || [];
-		this._gqlOption = table.gqlOption || defaultGQLOption();
-		this._columns = (table.columns || []).map((it) => assembleColumn(it, this));
-		this._virtualRelations = table.virtualRelations || [];
-	}
-	column(columnName) {
-		const column = this.columns.find((it) => it.columnName() === columnName);
-		if (!column) throw new Error(`${this.tableName}.${columnName} is Not Found`);
-		return column;
-	}
-	addColumn(column, isPrimary = false, isUnique = false) {
-		this.columns.push(column);
-		if (isPrimary) this.setPrimaryKey(column.columnName());
-		if (isUnique) this.addUniqueKey(column.columnName());
-	}
-	dropColumn(columnName) {
-		this._columns = this._columns.filter((it) => it.fieldName() !== columnName);
-	}
-	serialize() {
-		return {
-			columns: this.columns.map((it) => it.serialize()),
-			primaryKey: this.primaryKey,
-			uniqueKeys: this.uniqueKeys,
-			indexes: this.indexes,
-			tableName: this.tableName,
-			gqlOption: JSON.parse(JSON.stringify(this.gqlOption)),
-			virtualRelations: this._virtualRelations
-		};
-	}
-	addReferences(ref, fieldName, notNull = true) {
-		const data = {
-			...this.store.table(ref.parentTable).column(ref.parentColumn).serialize(),
-			hasReference: true,
-			fieldName: fieldName || ref.columnName,
-			columnName: ref.columnName,
-			notNull,
-			default: void 0,
-			zerofill: false,
-			autoIncrement: false,
-			defaultCurrentTimeStamp: false,
-			onUpdateCurrentTimeStamp: false,
-			reference: ref
-		};
-		this.columns.push(new ReferenceColumn(data, this));
-		return this;
-	}
-	getIndexConstraintName(columns) {
-		return `index_${this.tableName}__${columns.join("_")}`;
-	}
-	addIndex(...columns) {
-		this.indexes.push(new DBIndex(this.tableName, columns));
-		return this;
-	}
-	removeIndex(...columns) {
-		const constraint = this.getIndexConstraintName(columns);
-		this.indexes = this.indexes.filter((it) => it.constraintName !== constraint);
-		return this;
-	}
-	addUniqueKey(...columnNames) {
-		if (columnNames.length === 0) throw new SasatError("No column name specified");
-		this.uniqueKeys.push(columnNames);
-		return this;
-	}
-	setPrimaryKey(...columnNames) {
-		if (columnNames.length === 0) throw new Error("Primary key is required");
-		this.primaryKey = columnNames;
-		return this;
-	}
-	showCreateTable() {
-		const rows = [...this.columns.map((it) => it.toSql())];
-		if (this.primaryKey.length !== 0) rows.push(`PRIMARY KEY (${this.primaryKey.map(SqlString.escapeId).join(",")})`);
-		this.uniqueKeys.forEach((it) => {
-			if (this.uniqueKeys.length !== 0) rows.push(`UNIQUE KEY (${it.join(",")})`);
-		});
-		rows.push(...this._columns.filter((it) => it.isReference() && !it.data.reference.noFKey).map((it) => {
-			const ref = it;
-			return referenceToSql(ref.getConstraintName(), ref.data.reference);
-		}));
-		return `CREATE TABLE ${SqlString.escapeId(this.tableName)}
-            (
-              ${rows.join(", ")}
-            )`;
-	}
-	hasColumn(columnName) {
-		return !!this.columns.find((it) => it.columnName() === columnName);
-	}
-	isColumnPrimary(columnName) {
-		return this.primaryKey.includes(columnName);
-	}
-	getEntityName() {
-		return EntityName.fromTableName(this.tableName);
-	}
-	setGQLOption(option) {
-		this._gqlOption = {
-			...this.gqlOption,
-			...option
-		};
-	}
-	getReferenceColumns() {
-		return this.columns.filter((it) => it.isReference());
-	}
-	addForeignKey(reference) {
-		const columnName = reference.columnName;
-		const column1 = this.column(columnName);
-		if (!column1) throw new Error("Column: `" + columnName + "` Not Found");
-		if (column1.isReference()) throw new Error("Column: `" + columnName + "`already has reference, multiple reference is not supported");
-		const ref = column1.addReference(reference);
-		this._columns = this.columns.map((it) => it.columnName() === columnName ? ref : it);
-	}
-	changeType(columnName, type) {
-		this.updateColumn(columnName, { type });
-	}
-	setDefault(columnName, value) {
-		this.updateColumn(columnName, { default: value });
-	}
-	updateColumn(columnName, diff) {
-		const update = (column) => {
-			if (column.isReference()) return new ReferenceColumn({
-				...column.serialize(),
-				...diff
-			}, this);
-			return new NormalColumn({
-				...column.serialize(),
-				...diff
-			}, this);
-		};
-		if (!this.column(columnName)) throw new Error(this.tableName + "." + columnName + " Not Found");
-		this._columns = this.columns.map((it) => it.columnName() === columnName ? update(it) : it);
-	}
-	getPrimaryKeyColumns() {
-		return this.columns.filter((it) => this.primaryKey.includes(it.columnName()));
-	}
-};
-//#endregion
-//#region src/migration/creators/columnBuilder.ts
-var ColumnBuilderBase = class {
-	constructor(columnName) {
-		this.columnName = columnName;
-		this._primary = false;
-		this._notNull = true;
-		this._unique = false;
-		this._option = defaultColumnOption;
-		this._fieldName = columnName;
-	}
-	fieldName(fieldName) {
-		this._fieldName = fieldName;
-		return this;
-	}
-	notNull() {
-		this._notNull = true;
-		return this;
-	}
-	nullable() {
-		this._notNull = false;
-		return this;
-	}
-	primary() {
-		this._primary = true;
-		return this;
-	}
-	unique() {
-		this._unique = true;
-		return this;
-	}
-	updatable(updatable) {
-		this._option = {
-			...this._option,
-			updatable
-		};
-		return this;
-	}
-};
-var ColumnBuilder = class extends ColumnBuilderBase {
-	constructor(name, type, length, scale) {
-		super(name);
-		this.type = type;
-		this.length = length;
-		this.scale = scale;
-		this._zerofill = false;
-		this._autoIncrement = false;
-		this._defaultCurrentTimeStamp = false;
-		this._onUpdateCurrentTimeStamp = false;
-		this._fieldName = name;
-	}
-	default(value) {
-		this._default = value;
-		return this;
-	}
-	build() {
-		return {
-			data: {
-				hasReference: false,
-				columnName: this.columnName,
-				fieldName: this._fieldName,
-				type: this.type,
-				length: this.length,
-				scale: this.scale,
-				notNull: this._notNull,
-				zerofill: this._zerofill,
-				signed: this._signed,
-				autoIncrement: this._autoIncrement,
-				default: this._default,
-				defaultCurrentTimeStamp: this._defaultCurrentTimeStamp,
-				onUpdateCurrentTimeStamp: this._onUpdateCurrentTimeStamp,
-				option: this._option
-			},
-			isPrimary: this._primary,
-			isUnique: this._unique
-		};
-	}
-};
-var StringColumnBuilder = class extends ColumnBuilder {
-	constructor(name, type, length) {
-		super(name, type);
-		this.name = name;
-		this.type = type;
-		this.length = length;
-	}
-	default(value) {
-		this._default = value;
-		return this;
-	}
-};
-var TextColumnBuilder = class extends ColumnBuilder {
-	constructor(name, type) {
-		super(name, type);
-		this.name = name;
-		this.type = type;
-	}
-	default(value) {
-		this._default = value;
-		return this;
-	}
-};
-var NumberColumnBuilder = class extends ColumnBuilder {
-	signed() {
-		this._signed = true;
-		return this;
-	}
-	unsigned() {
-		this._signed = false;
-		return this;
-	}
-	zerofill() {
-		this._zerofill = true;
-		return this;
-	}
-	default(value) {
-		this._default = value;
-		return this;
-	}
-};
-var IntegerColumnBuilder = class extends NumberColumnBuilder {
-	constructor(name, type, length) {
-		super(name, type, length);
-		this.name = name;
-		this.type = type;
-		this.length = length;
-	}
-	autoIncrement() {
-		this._autoIncrement = true;
-		return this;
-	}
-};
-var FloatColumnBuilder = class extends NumberColumnBuilder {
-	constructor(name, type, length, scale) {
-		super(name, type, length, scale);
-		this.name = name;
-		this.type = type;
-		this.length = length;
-		this.scale = scale;
-	}
-	autoIncrement() {
-		this._autoIncrement = true;
-		return this;
-	}
-};
-var DecimalColumnBuilder = class extends NumberColumnBuilder {
-	constructor(name, type, length, scale) {
-		super(name, type, length, scale);
-		this.name = name;
-		this.type = type;
-		this.length = length;
-		this.scale = scale;
-	}
-};
-var DateColumnBuilder = class extends ColumnBuilder {
-	constructor(name, type) {
-		super(name, type);
-		this.name = name;
-		this.type = type;
-	}
-	default(value) {
-		this._default = value;
-		return this;
-	}
-};
-var TimeStampColumnBuilder = class extends ColumnBuilder {
-	constructor(name, type) {
-		super(name, type);
-		this.name = name;
-		this.type = type;
-	}
-	default(value) {
-		this._default = value;
-		return this;
-	}
-	defaultCurrentTimeStamp() {
-		this._defaultCurrentTimeStamp = true;
-		return this.default("CURRENT_TIMESTAMP");
-	}
-	onUpdateCurrentTimeStamp() {
-		this._onUpdateCurrentTimeStamp = true;
-		return this;
-	}
-};
-var ReferenceColumnBuilder = class extends ColumnBuilderBase {
-	constructor(ref, parent) {
-		super(ref.columnName);
-		this.ref = ref;
-		this.parent = parent;
-		this._option = {
-			...this._option,
-			updatable: false
-		};
-	}
-	notNull() {
-		this._notNull = true;
-		return this;
-	}
-	nullable() {
-		this._notNull = false;
-		return this;
-	}
-	primary() {
-		this._primary = true;
-		return this;
-	}
-	unique() {
-		this._unique = true;
-		return this;
-	}
-	build() {
-		return {
-			data: {
-				...this.parent.serialize(),
-				hasReference: true,
-				fieldName: this._fieldName,
-				columnName: this.columnName,
-				notNull: this._notNull,
-				default: void 0,
-				autoIncrement: false,
-				defaultCurrentTimeStamp: false,
-				onUpdateCurrentTimeStamp: false,
-				reference: this.ref,
-				option: this._option
-			},
-			isPrimary: this._primary,
-			isUnique: this._unique
-		};
-	}
-};
-var AutoIncrementIDColumnBuilder = class extends ColumnBuilderBase {
-	constructor(columnName, option) {
-		super(columnName);
-		this.option = option;
-		this._option = {
-			...this._option,
-			updatable: false,
-			autoIncrementHashId: true,
-			hashSalt: option?.salt
-		};
-	}
-	build() {
-		return {
-			data: {
-				hasReference: false,
-				fieldName: this._fieldName,
-				columnName: this.columnName,
-				type: this.option?.bigint ? "bigint" : "int",
-				notNull: true,
-				default: void 0,
-				zerofill: false,
-				signed: false,
-				autoIncrement: true,
-				length: void 0,
-				scale: void 0,
-				defaultCurrentTimeStamp: false,
-				onUpdateCurrentTimeStamp: false,
-				option: this._option
-			},
-			isPrimary: true,
-			isUnique: false
-		};
-	}
-};
-//#endregion
-//#region src/migration/creators/columnCreator.ts
-var ColumnCreator = class {
-	constructor(table, name) {
-		this.table = table;
-		this.name = name;
-		this.char = (length) => this.create(new StringColumnBuilder(this.name, "char", length));
-		this.varchar = (length) => this.create(new StringColumnBuilder(this.name, "varchar", length));
-		this.text = () => this.create(new TextColumnBuilder(this.name, "text"));
-		this.tinyInt = (length) => this.create(new IntegerColumnBuilder(this.name, "tinyint", length));
-		this.smallInt = (length) => this.create(new IntegerColumnBuilder(this.name, "smallint", length));
-		this.mediumInt = (length) => this.create(new IntegerColumnBuilder(this.name, "mediumint", length));
-		this.int = (length) => this.create(new IntegerColumnBuilder(this.name, "int", length));
-		this.bigInt = (length) => this.create(new IntegerColumnBuilder(this.name, "bigint", length));
-		this.float = (length, scale) => this.create(new FloatColumnBuilder(this.name, "float", length, scale));
-		this.double = (length, scale) => this.create(new FloatColumnBuilder(this.name, "double", length, scale));
-		this.decimal = (length, scale) => this.create(new DecimalColumnBuilder(this.name, "decimal", length, scale));
-		this.year = () => this.create(new DateColumnBuilder(this.name, "year"));
-		this.date = () => this.create(new DateColumnBuilder(this.name, "date"));
-		this.time = () => this.create(new DateColumnBuilder(this.name, "time"));
-		this.dateTime = () => this.create(new TimeStampColumnBuilder(this.name, "datetime"));
-		this.timestamp = () => this.create(new TimeStampColumnBuilder(this.name, "timestamp"));
-	}
-	create(column) {
-		this.table.addColumn(column);
-		return column;
-	}
-};
-//#endregion
-//#region src/migration/creators/tableCreator.ts
-var TableCreator = class {
-	constructor(tableName, store) {
-		this.tableName = tableName;
-		this.store = store;
-		this.columns = [];
-		this.table = new TableHandler({ tableName }, store);
-	}
-	autoIncrementHashId(columnName, option) {
-		this.addColumn(new AutoIncrementIDColumnBuilder(columnName, option));
-		return this;
-	}
-	column(name) {
-		return new ColumnCreator(this, name);
-	}
-	addVirtualRelation(relation) {
-		this.table.addVirtualRelation(relation);
-		return this;
-	}
-	addColumn(column) {
-		if (this.table.hasColumn(column.columnName)) throw new Error(`${this.tableName}.${column.columnName} already exists`);
-		this.columns.push(column);
-	}
-	addUniqueKey(...columnNames) {
-		this.table.addUniqueKey(...columnNames);
-		return this;
-	}
-	references(ref) {
-		const column = new ReferenceColumnBuilder(ref, this.store.table(ref.parentTable).column(ref.parentColumn));
-		this.addColumn(column);
-		return column;
-	}
-	setPrimaryKey(...columnNames) {
-		this.table.setPrimaryKey(...columnNames);
-		return this;
-	}
-	create() {
-		this.columns.forEach((column) => {
-			const { data, isPrimary, isUnique } = column.build();
-			this.table.addColumn(data.hasReference ? new ReferenceColumn(data, this.table) : new NormalColumn(data, this.table), isPrimary, isUnique);
-		});
-		return this.table;
-	}
-	createdAt() {
-		this.column("createdAt").timestamp().defaultCurrentTimeStamp().notNull().updatable(false);
-		return this;
-	}
-	updatedAt() {
-		this.column("updatedAt").timestamp().defaultCurrentTimeStamp().onUpdateCurrentTimeStamp().notNull().updatable(false);
-		return this;
-	}
-	addIndex(...columns) {
-		this.table.addIndex(`index_${this.tableName}__${columns.join("_")}`, ...columns);
-		return this;
-	}
-	enableGQL() {
-		this.table.setGQLOption({
-			...this.table.gqlOption,
-			enabled: true
-		});
-		return this;
-	}
-	setGQLOption(option) {
-		this.table.setGQLOption(option);
-		return this;
-	}
-	addGQLQuery(...query) {
-		this.table.setGQLOption({ queries: [...this.table.gqlOption.queries, ...query] });
-		return this;
-	}
-	addGQLMutation(...mutation) {
-		this.table.setGQLOption({ mutations: [...this.table.gqlOption.mutations, ...mutation] });
-		return this;
-	}
-};
-//#endregion
-//#region src/db/sql/sqlCreater.ts
-const SqlCreator = {
-	addColumn: (tableName, column) => `ALTER TABLE ${tableName} ADD COLUMN ${columnToSql(column)}`,
-	dropColumn: (tableName, columnName) => `ALTER TABLE ${tableName} DROP COLUMN ${columnName}`,
-	addUniqueKey: (tableName, columns) => `ALTER TABLE ${tableName} ADD UNIQUE ${columns.join("__")}(${columns.join(",")})`,
-	addPrimaryKey: (tableName, columns) => `ALTER TABLE ${tableName} ADD PRIMARY KEY ${columns.join("__")}(${columns.join(",")})`,
-	addForeignKey: (tableName, constraintName, reference) => {
-		const onUpdate = reference.onUpdate ? " ON UPDATE " + reference.onUpdate : "";
-		const onDelete = reference.onDelete ? " ON DELETE " + reference.onDelete : "";
-		return `ALTER TABLE ${tableName} ADD CONSTRAINT '${constraintName}' FOREIGN KEY (${reference.columnName}) REFERENCES ${reference.parentTable}(${reference.parentColumn})${onUpdate}${onDelete}`;
-	}
-};
-//#endregion
-//#region src/migration/creators/createColumn.ts
-const createColumn = (name) => ({
-	char: (length) => new StringColumnBuilder(name, "char", length),
-	varchar: (length) => new StringColumnBuilder(name, "varchar", length),
-	text: () => new TextColumnBuilder(name, "text"),
-	tinyInt: (length) => new IntegerColumnBuilder(name, "tinyint", length),
-	smallInt: (length) => new IntegerColumnBuilder(name, "smallint", length),
-	mediumInt: (length) => new IntegerColumnBuilder(name, "mediumint", length),
-	int: (length) => new IntegerColumnBuilder(name, "int", length),
-	bigInt: (length) => new IntegerColumnBuilder(name, "bigint", length),
-	float: (length, scale) => new FloatColumnBuilder(name, "float", length, scale),
-	double: (length, scale) => new FloatColumnBuilder(name, "double", length, scale),
-	decimal: (length, scale) => new DecimalColumnBuilder(name, "decimal", length, scale),
-	year: () => new DateColumnBuilder(name, "year"),
-	date: () => new DateColumnBuilder(name, "date"),
-	time: () => new DateColumnBuilder(name, "time"),
-	dateTime: () => new TimeStampColumnBuilder(name, "datetime"),
-	timestamp: () => new TimeStampColumnBuilder(name, "timestamp")
-});
-//#endregion
-//#region src/migration/front/tableMigrator.ts
-var TableMigrator = class TableMigrator {
-	constructor(table, store) {
-		this.table = table;
-		this.store = store;
-	}
-	get primaryKey() {
-		return this.table.primaryKey;
-	}
-	static deserialize(data, store) {
-		return new TableMigrator(new TableHandler(data, store), store);
-	}
-	get tableName() {
-		return this.table.tableName;
-	}
-	column(columnName) {
-		return this.table.column(columnName);
-	}
-	showCreateTable() {
-		return this.table.showCreateTable();
-	}
-	getIndexes() {
-		return this.table.index;
-	}
-	serialize() {
-		return this.table.serialize();
-	}
-	addIndex(...columns) {
-		this.table.addIndex(...columns);
-		const index = new DBIndex(this.tableName, columns);
-		this.store.addQuery(index.addSql());
-		return this;
-	}
-	removeIndex(...columns) {
-		this.table.removeIndex(...columns);
-		this.store.addQuery(new DBIndex(this.tableName, columns).dropSql());
-		return this;
-	}
-	_addColumn(column) {
-		this.table.addColumn(new NormalColumn(column, this.table));
-		this.store.addQuery(SqlCreator.addColumn(this.tableName, column));
-		return this;
-	}
-	addColumn(name, create) {
-		const column = create(createColumn(name)).build();
-		return this._addColumn(column.data);
-	}
-	dropColumn(columnName) {
-		this.table.dropColumn(columnName);
-		this.store.addQuery(SqlCreator.dropColumn(this.tableName, columnName));
-		return this;
-	}
-	enableGQL() {
-		this.table.setGQLOption({
-			...this.table.gqlOption,
-			enabled: true
-		});
-		return this;
-	}
-	setGQLOption(option) {
-		this.table.setGQLOption(option);
-		return this;
-	}
-	addForeignKey(reference) {
-		this.tableExists(reference.parentTable);
-		this.table.addForeignKey(reference);
-		const column = this.table.column(reference.columnName);
-		const targetColumn = this.store.table(reference.parentTable).column(reference.parentColumn);
-		if (!targetColumn) throw new Error("Column: " + reference.parentTable + "." + reference.parentColumn + " Not Exists");
-		if (column.dataType() !== targetColumn.dataType()) throw new Error(`${this.tableName}.${reference.columnName} AND ${reference.parentTable}.${reference.parentColumn} is different Type( ${column.dataType()} != ${targetColumn.dataType()} )`);
-		this.store.addQuery(SqlCreator.addForeignKey(this.tableName, column.getConstraintName(), reference));
-		return this;
-	}
-	changeColumnType(columnName, type) {
-		this.table.changeType(columnName, type);
-		this.store.addQuery(`ALTER TABLE ${this.tableName} MODIFY ${columnName} ${type}`);
-		return this;
-	}
-	tableExists(tableName) {
-		if (!this.store.table(tableName)) throw new Error("QueryTable: " + tableName + " Not Exists");
-		return true;
-	}
-	setDefault(columnName, value) {
-		this.table.setDefault(columnName, value);
-		this.store.addQuery(`ALTER TABLE ${this.tableName} ALTER ${columnName} SET DEFAULT ${SqlString.escape(value)}`);
-		return this;
-	}
-	get gqlOption() {
-		return this.table.gqlOption;
-	}
-	addGQLQuery(...queries) {
-		this.table.setGQLOption({
-			...this.table.gqlOption,
-			queries: [...this.table.gqlOption.queries, ...queries]
-		});
-		return this;
-	}
-	addGQLMutation(...mutations) {
-		this.table.setGQLOption({
-			...this.table.gqlOption,
-			mutations: [...this.table.gqlOption.mutations, ...mutations]
-		});
-		return this;
-	}
-};
-//#endregion
-//#region src/migration/front/storeMigrator.ts
-var StoreMigrator = class StoreMigrator {
-	constructor() {
-		this.tables = [];
-		this.migrationQueue = [];
-	}
-	static new() {
-		if (fs.existsSync(path.join(config().migration.dir, "initialSchema.yml"))) return StoreMigrator.deserialize(readInitialSchema());
-		return new StoreMigrator();
-	}
-	static deserialize(data) {
-		const store = new StoreMigrator();
-		store.tables = data.tables.map((it) => TableMigrator.deserialize(it, store));
-		store.resetQueue();
-		return store;
-	}
-	table(tableName) {
-		const table = this.tables.find((it) => it.tableName === tableName);
-		if (!table) throw new Error("QueryTable: " + tableName + " Not Found");
-		return table;
-	}
-	addQuery(...query) {
-		this.migrationQueue.push(...query);
-	}
-	createTable(tableName, tableCreator) {
-		if (this.tables.find((it) => it.tableName === tableName)) throw new SasatError(`${tableName} is already exist`);
-		const creator = new TableCreator(tableName, this);
-		tableCreator(creator);
-		const table = new TableMigrator(creator.create(), this);
-		this.tables.push(table);
-		this.addQuery(table.showCreateTable());
-		this.addQuery(...table.getIndexes().map((it) => it.addSql()));
-		return this;
-	}
-	dropTable(tableName) {
-		this.addQuery(`DROP TABLE ${tableName}`);
-		this.tables = this.tables.filter((it) => it.tableName !== tableName);
-		return this;
-	}
-	sql(...sql) {
-		this.addQuery(...sql);
-		return this;
-	}
-	getSql() {
-		return this.migrationQueue;
-	}
-	resetQueue() {
-		this.migrationQueue = [];
-	}
-	serialize() {
-		return { tables: this.tables.map((it) => it.serialize()) };
-	}
-	setConfig(conf) {
-		this.conf = conf;
-		return this;
-	}
-	getUpdateConfig() {
-		return this.conf;
-	}
-};
-//#endregion
-//#region src/db/formatQuery.ts
-const formatQuery = (str, ...params) => {
-	let ret = str[0];
-	for (let i = 0; i < params.length; i++) {
-		if (typeof params[i] === "function") ret += params[i]();
-		else if (Array.isArray(params[i])) ret += params[i].map((it) => SqlString.escape(it)).join(", ");
-		else ret += SqlString.escape(params[i]);
-		ret += str[i + 1];
-	}
-	return ret;
-};
-//#endregion
-//#region src/db/connectors/dbClient.ts
-const noop = () => {};
-var SQLClient = class {
-	constructor() {
-		this.logger = noop;
-	}
-	rawQuery(sql) {
-		this.logger(sql);
-		return this.execSql(sql);
-	}
-	rawCommand(sql) {
-		this.logger(sql);
-		return this.execSql(sql);
-	}
-	query(templateString, ...params) {
-		return this.rawQuery(formatQuery(templateString, ...params));
-	}
-	command(templateString, ...params) {
-		return this.rawCommand(formatQuery(templateString, ...params));
-	}
-};
-var SQLTransaction = class extends SQLClient {};
-var DBClient = class extends SQLClient {
-	constructor(logger = noop) {
-		super();
-		this._released = false;
-		this.logger = logger;
-	}
-	isReleased() {
-		return this._released;
-	}
-};
-//#endregion
-//#region src/db/connectors/mysql/transaction.ts
-var MySqlTransaction = class extends SQLTransaction {
-	constructor(connection) {
-		super();
-		this.connection = connection;
-	}
-	async commit() {
-		const result = await this.connection.commit();
-		await this.connection.end();
-		return result;
-	}
-	async rollback() {
-		await this.connection.rollback();
-		await this.connection.end();
-	}
-	async execSql(sql) {
-		return (await this.connection.query(sql))[0];
-	}
-};
-//#endregion
-//#region src/db/connectors/mysql/poolClient.ts
-var MysqlPoolClient = class extends DBClient {
-	constructor(poolOption, logger) {
-		super(logger);
-		this.poolOption = poolOption;
-		this.pool = createPool({
-			dateStrings: true,
-			...poolOption
-		});
-		this.release = this.release.bind(this);
-	}
-	async transaction() {
-		const connection = await createConnection({
-			...config().db,
-			dateStrings: true,
-			...this.poolOption
-		});
-		await connection.beginTransaction();
-		return new MySqlTransaction(connection);
-	}
-	async release() {
-		await this.pool.end();
-		this._released = true;
-	}
-	async execSql(sql) {
-		return (await this.pool.query(sql))[0];
-	}
-};
-//#endregion
-//#region src/db/getDbClient.ts
-let client;
-const getDbClient = (option, logger) => {
-	if (client && !client.isReleased()) return client;
-	client = new MysqlPoolClient({
-		...config().db,
-		...option
-	}, logger);
-	return client;
-};
-//#endregion
-//#region src/migration/exec/getCurrentMigration.ts
-const calcRunMigrationFileNames = (records) => {
-	const result = [];
-	records.forEach((it) => {
-		if (it.direction === "down") {
-			if (result[result.length] !== it.name) throw new Error("Invalid migration history: `down` migration must be the same migration as the last `up` migration ");
-			result.pop();
-			return;
-		}
-		result.push(it.name);
-	});
-	return result;
-};
-const getCurrentMigration = async (options) => {
-	const migrationTable = SqlString.escapeId(config().migration.table);
-	const files = getMigrationFileNames();
-	const client = getDbClient();
-	const query = `CREATE TABLE IF NOT EXISTS ${migrationTable} (id int auto_increment primary key , name varchar(100) not null,direction enum('up', 'down') not null, migrated_at timestamp default current_timestamp)`;
-	if (!options.silent) {
-		Console.log(`creating migration table: ${migrationTable} :: ${Buffer.from(migrationTable).toString("base64")}`);
-		Console.log(query);
-	}
-	await client.rawQuery(query);
-	const q = `SELECT name, direction FROM ${migrationTable} ORDER BY id ASC`;
-	if (!options.silent) Console.debug(q);
-	const result = await client.rawQuery(q);
-	console.debug(result);
-	if (!result.length) return;
-	const runs = calcRunMigrationFileNames(result);
-	if (runs.length === 0) return;
-	runs.forEach((run, i) => {
-		if (files[i] !== run) throw new Error(`\
-Invalid migration order: Migration must be performed in the same order 
-Found               : ${files[i]} 
-in migration history: ${run}`);
-	});
-	return runs[runs.length - 1];
-};
-//#endregion
-//#region src/migration/exec/migrationFileCompiler.ts
-const changeExtTsToJs = (fileName) => fileName.slice(0, -3) + ".mjs";
-const compileMigrationFiles = () => {
-	const compiles = getMigrationFileNames().map(async (fileName) => {
-		const filePath = path.join(getMigrationFileDir(), fileName);
-		const r = await build({
-			entryPoints: [filePath],
-			bundle: true,
-			outfile: changeExtTsToJs(filePath),
-			platform: "node",
-			format: "esm",
-			outExtension: { ".js": ".mjs" },
-			banner: { js: `import { createRequire as topLevelCreateRequire } from 'module';
-const require = topLevelCreateRequire(import.meta.url);                                                                                                                        
-import { fileURLToPath as __topLevelFileURLToPath } from 'url';
-import { dirname as __topLevelDirname } from 'path';                                                                                                                           
-const __filename = __topLevelFileURLToPath(import.meta.url);
-const __dirname = __topLevelDirname(__filename);   
-` }
-		});
-		if (r.errors.length !== 0) throw r.errors;
-		return fileName;
-	});
-	return Promise.all(compiles);
-};
-//#endregion
-//#region src/migration/exec/readMigrationFile.ts
-const readMigration = async (store, tsFileName, direction) => {
-	const instance = new (await (import(path.join(process.cwd(), config().migration.dir, changeExtTsToJs(tsFileName))))).default();
-	if (direction === "up") {
-		if (instance.beforeUp) await instance.beforeUp();
-		await instance.up(store);
-		if (instance.afterUp) await instance.afterUp();
-	} else {
-		if (instance.beforeDown) await instance.beforeDown();
-		await instance.down(store);
-		if (instance.afterDown) await instance.afterDown();
-	}
-	return store;
-};
-//#endregion
-//#region src/migration/exec/createCurrentMigrationDataStore.ts
-const createCurrentMigrationDataStore = async (targetMigrationName) => {
-	const allFiles = getMigrationFileNames();
-	let store = StoreMigrator.new();
-	if (!targetMigrationName) return store;
-	const files = allFiles.slice(0, allFiles.indexOf(targetMigrationName) + 1);
-	for (const tsFileName of files) store = await readMigration(store, tsFileName, "up");
-	store.resetQueue();
-	return store;
-};
-//#endregion
-//#region src/migration/exec/getMigrationTarget.ts
-const getMigrationTargets = (files, current) => {
-	const currentIndex = current ? files.indexOf(current) + 1 : 0;
-	const targetIndex = files.indexOf(config().migration.target || files[files.length - 1]) + 1;
-	if (currentIndex === -1 || targetIndex === -1) throw new Error("migration target not found");
-	if (targetIndex >= currentIndex) return {
-		direction: "up",
-		files: files.slice(currentIndex, targetIndex)
-	};
-	return {
-		direction: "down",
-		files: files.slice(targetIndex, currentIndex).reverse()
-	};
-};
-//#endregion
-//#region src/migration/exec/runMigration.ts
-const runMigration = async (client, store, migrationName, direction, options) => {
-	const sqls = store.getSql();
-	const conf = store.getUpdateConfig();
-	if (conf) setConfig(conf);
-	store.resetQueue();
-	if (!options.silent) sqls.forEach(Console.log);
-	if (options.dry) return;
-	const transaction = await client.transaction();
-	try {
-		for (const sql of sqls) await transaction.rawQuery(sql).catch((e) => {
-			Console.error(`ERROR ON ${migrationName}`);
-			Console.error(`SQL: ${sql}`);
-			Console.error(`MESSAGE: ${e.message}`);
-			process.exit(1);
-		});
-		await transaction.query`insert into ${() => config().migration.table} (name, direction) values (${[migrationName, direction]})`;
-		return await transaction.commit();
-	} catch (e) {
-		await transaction.rollback();
-		throw e;
-	}
-};
-//#endregion
-//#region src/migration/controller.ts
-var MigrationController = class {
-	async migrate(client, options) {
-		const fileNames = getMigrationFileNames();
-		console.log(4, options);
-		const currentMigration = await getCurrentMigration(options);
-		if (!options.silent) Console.log("--current migration--: " + currentMigration);
-		console.log(2);
-		let store = await createCurrentMigrationDataStore(currentMigration);
-		if (store.getUpdateConfig()) setConfig(store.getUpdateConfig());
-		console.log(1);
-		const target = getMigrationTargets(fileNames, currentMigration);
-		console.log(2);
-		for (const tsFileName of target.files) {
-			if (!options.silent) Console.log("---------\n" + tsFileName);
-			console.log(3, tsFileName);
-			store = await readMigration(store, tsFileName, target.direction);
-			console.log(4);
-			await runMigration(client, store, tsFileName, target.direction, options);
-			store.resetQueue();
-		}
-		return {
-			store: store.serialize(),
-			currentMigration: config().migration.target || fileNames[fileNames.length - 1]
-		};
-	}
-};
-//#endregion
-//#region src/migration/dataStore.ts
-var DataStoreHandler = class {
-	constructor(store) {
-		this.tables = store.tables.map((it) => new TableHandler(it, this));
-	}
-	table(tableName) {
-		const table = this.tables.find((it) => it.tableName === tableName);
-		if (!table) throw new Error(`Table: ${tableName} is Not Found`);
-		return table;
-	}
-	referencedBy(tableName) {
-		return this.tables.flatMap((it) => it.columns.filter((it) => it.isReference() && it.data.reference.parentTable === tableName));
-	}
-	virtualReferencedBy(tableName) {
-		return this.tables.flatMap((it) => it.virtualRelations.filter((it) => it.parentTable === tableName));
-	}
-};
-//#endregion
-//#region src/cli/commands/migrate.ts
-const migrate = async (client, options) => {
-	let current;
-	if (!options.silent) Console.log("--migration started--");
-	try {
-		if (!options.skipBuild) await compileMigrationFiles();
-		const conf = config();
-		if (conf.migration.db) setConfig({ db: conf.migration.db });
-		const result = await new MigrationController().migrate(client, options);
-		current = result.currentMigration;
-		if (options.generateFiles) {
-			const storeHandler = new DataStoreHandler(result.store);
-			writeCurrentSchema(result.store);
-			await new CodeGen_v2(storeHandler).generate();
-		}
-		if (!options.silent) Console.success(`current migration is ${current}`);
-	} catch (e) {
-		Console.error(e.message);
-		throw e;
-	}
-};
-//#endregion
+import { createConnection } from "mysql2/promise";
 //#region src/db/connectors/mysql/client.ts
 var MysqlClient = class extends DBClient {
 	async release() {}
@@ -4356,7 +432,7 @@ const subQueryTable = (query, joins, alias) => ({
 	alias,
 	joins
 });
-const join$1 = (table, conditions, type) => ({
+const join = (table, conditions, type) => ({
 	kind: 3,
 	type,
 	table,
@@ -4385,7 +461,7 @@ const QExpr = {
 	paren,
 	table,
 	subQueryTable,
-	join: join$1,
+	join,
 	value: literal,
 	sort,
 	order: sort,