sasat 0.22.0 → 0.22.2

package/dist/migrate-BRNxkHCx.cjs

@@ -0,0 +1,4162 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_fs_promises = require("node:fs/promises");
+let js_yaml = require("js-yaml");
+js_yaml = __toESM(js_yaml, 1);
+require("pluralize");
+let typescript = require("typescript");
+typescript = __toESM(typescript, 1);
+let chalk = require("chalk");
+chalk = __toESM(chalk, 1);
+let sqlstring = require("sqlstring");
+sqlstring = __toESM(sqlstring, 1);
+let mysql2_promise = require("mysql2/promise");
+let esbuild = require("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) => js_yaml.default.load((0, node_fs.readFileSync)(filepath, "utf8"));
+const mkDirIfNotExist = (path) => {
+	if (!(0, node_fs.existsSync)(path)) (0, node_fs.mkdirSync)(path, { recursive: true });
+};
+const writeFileIfNotExist = (path, data) => {
+	if ((0, node_fs.existsSync)(path)) return Promise.resolve();
+	return (0, node_fs_promises.writeFile)(path, data);
+};
+const writeYmlFile = (path, fileName, obj) => {
+	mkDirIfNotExist(path);
+	(0, node_fs.writeFileSync)((0, node_path.join)(path, fileName), js_yaml.default.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((0, node_path.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 = node_path.default.join(process.cwd(), "sasat.yml");
+		if (!(0, node_fs.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 (0, node_fs_promises.readdir)(dir);
+	} catch {
+		return (0, node_fs_promises.mkdir)(dir, {
+			mode: 511,
+			recursive: true
+		});
+	}
+	return Promise.all(items.map((item) => (0, node_fs_promises.rm)(node_path.default.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
+let DBColumnTypes = /* @__PURE__ */ function(DBColumnTypes) {
+	DBColumnTypes["char"] = "char";
+	DBColumnTypes["varchar"] = "varchar";
+	DBColumnTypes["text"] = "text";
+	DBColumnTypes["tinyInt"] = "tinyint";
+	DBColumnTypes["smallInt"] = "smallint";
+	DBColumnTypes["mediumInt"] = "mediumint";
+	DBColumnTypes["int"] = "int";
+	DBColumnTypes["bigInt"] = "bigint";
+	DBColumnTypes["float"] = "float";
+	DBColumnTypes["double"] = "double";
+	DBColumnTypes["decimal"] = "decimal";
+	DBColumnTypes["year"] = "year";
+	DBColumnTypes["date"] = "date";
+	DBColumnTypes["time"] = "time";
+	DBColumnTypes["dateTime"] = "datetime";
+	DBColumnTypes["timestamp"] = "timestamp";
+	DBColumnTypes["boolean"] = "boolean";
+	return DBColumnTypes;
+}({});
+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 = node_path.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.default;
+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.default;
+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.default;
+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.default;
+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 = tsg.identifier("identifiable");
+const makeMutation$1 = (node) => {
+	return tsg.propertyAssign(node.mutationName, makeResolver$1.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$1 = 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, 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.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.default.green(msg));
+	},
+	error: (msg) => {
+		console.error(chalk.default.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 = () => 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().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.default;
+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 = (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,
+		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 = node_path.join(this.outDir, Directory.paths.DATA_SOURCES);
+		this.generateDir = node_path.join(this.outDir, Directory.paths.GENERATED);
+		this.generateEntityDir = node_path.join(this.outDir, Directory.paths.ENTITIES);
+		this.generateDbDataSourceDir = node_path.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 node_path.join(basePath, `${entityName}.${this.codeGen.fileExtension}`);
+	}
+	async generateEntity(node) {
+		return (0, node_fs_promises.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 (0, node_fs_promises.writeFile)(this.getFullPath(this.generateDbDataSourceDir, node.name.name), await this.codeGen.generateGeneratedDatasource(node));
+	}
+	async generateGql(rootNode) {
+		return Promise.all([
+			(0, node_fs_promises.writeFile)(this.getFullPath(this.generateDir, "typeDefs"), await this.codeGen.generateGqlTypeDefs(rootNode)),
+			(0, node_fs_promises.writeFile)(this.getFullPath(this.generateDir, "resolver"), await this.codeGen.generateGqlResolver(rootNode)),
+			(0, node_fs_promises.writeFile)(this.getFullPath(this.generateDir, "query"), await this.codeGen.generateGqlQuery(rootNode)),
+			(0, node_fs_promises.writeFile)(this.getFullPath(this.generateDir, "mutation"), await this.codeGen.generateGqlMutation(rootNode)),
+			(0, node_fs_promises.writeFile)(this.getFullPath(this.generateDir, "subscription"), await this.codeGen.generateGqlSubscription(rootNode)),
+			(0, node_fs_promises.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 = (0, node_fs.existsSync)(filePath) ? (0, node_fs.readFileSync)(filePath).toString() : "";
+		const nextContent = this.codeGen.generateConditions(rootNode, content);
+		if (nextContent) (0, node_fs.writeFileSync)(filePath, nextContent);
+	}
+	async generateIDEncoders(rootNode) {
+		const filePath = this.getFullPath(this.outDir, tsFileNames.encoder);
+		const content = (0, node_fs.existsSync)(filePath) ? (0, node_fs.readFileSync)(filePath).toString() : "";
+		const nextContent = this.codeGen.generateIDEncoders(rootNode, content);
+		if (nextContent) (0, node_fs.writeFileSync)(filePath, nextContent);
+	}
+	async generateMiddleware(rootNode) {
+		const filePath = this.getFullPath(this.outDir, tsFileNames.middleware);
+		const content = (0, node_fs.existsSync)(filePath) ? (0, node_fs.readFileSync)(filePath).toString() : "";
+		const nextContent = this.codeGen.generateMiddlewares(rootNode, content);
+		if (nextContent) (0, node_fs.writeFileSync)(filePath, nextContent);
+	}
+};
+//#endregion
+//#region src/migration/exec/getMigrationFiles.ts
+const getMigrationFileDir = () => {
+	return node_path.default.join(process.cwd(), config().migration.dir);
+};
+const getMigrationFileNames = () => {
+	return node_fs.default.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 } = sqlstring.default;
+const SqlString = {
+	escape: (value) => escape(value, true),
+	escapeId: (name) => escapeId(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 (node_fs.default.existsSync(node_path.default.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 = (0, mysql2_promise.createPool)({
+			dateStrings: true,
+			...poolOption
+		});
+		this.release = this.release.bind(this);
+	}
+	async transaction() {
+		const connection = await (0, mysql2_promise.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 = node_path.default.join(getMigrationFileDir(), fileName);
+		const r = await (0, esbuild.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(node_path.default.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();
+		const currentMigration = await getCurrentMigration(options);
+		if (!options.silent) Console.log("--current migration--: " + currentMigration);
+		let store = await createCurrentMigrationDataStore(currentMigration);
+		if (store.getUpdateConfig()) setConfig(store.getUpdateConfig());
+		const target = getMigrationTargets(fileNames, currentMigration);
+		for (const tsFileName of target.files) {
+			if (!options.silent) Console.log("---------\n" + tsFileName);
+			store = await readMigration(store, tsFileName, target.direction);
+			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
+Object.defineProperty(exports, "CodeGen_v2", {
+	enumerable: true,
+	get: function() {
+		return CodeGen_v2;
+	}
+});
+Object.defineProperty(exports, "Conditions", {
+	enumerable: true,
+	get: function() {
+		return Conditions;
+	}
+});
+Object.defineProperty(exports, "Console", {
+	enumerable: true,
+	get: function() {
+		return Console;
+	}
+});
+Object.defineProperty(exports, "DBClient", {
+	enumerable: true,
+	get: function() {
+		return DBClient;
+	}
+});
+Object.defineProperty(exports, "DBColumnTypes", {
+	enumerable: true,
+	get: function() {
+		return DBColumnTypes;
+	}
+});
+Object.defineProperty(exports, "DataStoreHandler", {
+	enumerable: true,
+	get: function() {
+		return DataStoreHandler;
+	}
+});
+Object.defineProperty(exports, "Directory", {
+	enumerable: true,
+	get: function() {
+		return Directory;
+	}
+});
+Object.defineProperty(exports, "MySqlTransaction", {
+	enumerable: true,
+	get: function() {
+		return MySqlTransaction;
+	}
+});
+Object.defineProperty(exports, "SasatError", {
+	enumerable: true,
+	get: function() {
+		return SasatError;
+	}
+});
+Object.defineProperty(exports, "SqlString", {
+	enumerable: true,
+	get: function() {
+		return SqlString;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "assignDeep", {
+	enumerable: true,
+	get: function() {
+		return assignDeep;
+	}
+});
+Object.defineProperty(exports, "camelize", {
+	enumerable: true,
+	get: function() {
+		return camelize;
+	}
+});
+Object.defineProperty(exports, "capitalizeFirstLetter", {
+	enumerable: true,
+	get: function() {
+		return capitalizeFirstLetter;
+	}
+});
+Object.defineProperty(exports, "columnTypeToGqlPrimitive", {
+	enumerable: true,
+	get: function() {
+		return columnTypeToGqlPrimitive;
+	}
+});
+Object.defineProperty(exports, "compileMigrationFiles", {
+	enumerable: true,
+	get: function() {
+		return compileMigrationFiles;
+	}
+});
+Object.defineProperty(exports, "config", {
+	enumerable: true,
+	get: function() {
+		return config;
+	}
+});
+Object.defineProperty(exports, "createCurrentMigrationDataStore", {
+	enumerable: true,
+	get: function() {
+		return createCurrentMigrationDataStore;
+	}
+});
+Object.defineProperty(exports, "defaultColumnOption", {
+	enumerable: true,
+	get: function() {
+		return defaultColumnOption;
+	}
+});
+Object.defineProperty(exports, "defaultConf", {
+	enumerable: true,
+	get: function() {
+		return defaultConf;
+	}
+});
+Object.defineProperty(exports, "defaultGQLOption", {
+	enumerable: true,
+	get: function() {
+		return defaultGQLOption;
+	}
+});
+Object.defineProperty(exports, "formatQuery", {
+	enumerable: true,
+	get: function() {
+		return formatQuery;
+	}
+});
+Object.defineProperty(exports, "getDbClient", {
+	enumerable: true,
+	get: function() {
+		return getDbClient;
+	}
+});
+Object.defineProperty(exports, "getMigrationFileNames", {
+	enumerable: true,
+	get: function() {
+		return getMigrationFileNames;
+	}
+});
+Object.defineProperty(exports, "migrate", {
+	enumerable: true,
+	get: function() {
+		return migrate;
+	}
+});
+Object.defineProperty(exports, "mkDirIfNotExist", {
+	enumerable: true,
+	get: function() {
+		return mkDirIfNotExist;
+	}
+});
+Object.defineProperty(exports, "nonNullable", {
+	enumerable: true,
+	get: function() {
+		return nonNullable;
+	}
+});
+Object.defineProperty(exports, "pick", {
+	enumerable: true,
+	get: function() {
+		return pick;
+	}
+});
+Object.defineProperty(exports, "setConfig", {
+	enumerable: true,
+	get: function() {
+		return setConfig;
+	}
+});
+Object.defineProperty(exports, "unique", {
+	enumerable: true,
+	get: function() {
+		return unique;
+	}
+});
+Object.defineProperty(exports, "writeCurrentSchema", {
+	enumerable: true,
+	get: function() {
+		return writeCurrentSchema;
+	}
+});
+Object.defineProperty(exports, "writeYmlFile", {
+	enumerable: true,
+	get: function() {
+		return writeYmlFile;
+	}
+});