@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/generator-code/drizzle.js

@@ -0,0 +1,1853 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database, OrderType } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoName, orderByNameASC } from "../tableName.js";
+import { referentialActionSupport } from "../schema-sql/utils.js";
+import { escapeTypeScriptDirective, getNameCase, getPrimitiveType, hasNRelationship, hasOneRelationship, referentialActionEntries, splitLines } from "./utils.js";
+import { BINARY_TYPES, JSON_TYPES, MONEY_TYPES, POSTGRES_BIT_TYPES, POSTGRES_TIME_TZ_TYPES, TIMESTAMP_LTZ_TYPES, TIMESTAMP_TZ_TYPES, UUID_TYPES, getColumnType as getColumnType$1, isMySQLFamily, isUnsigned } from "./columnTypes.js";
+//#region src/utils/generator-code/drizzle.ts
+var LINE_LIMIT = 80;
+var INDENT = "  ";
+var CORE_MODULE = "drizzle-orm";
+var RELATIONS = "relations";
+var SQL = "sql";
+var INDEX = "index";
+var UNIQUE_INDEX = "uniqueIndex";
+var PRIMARY_KEY = "primaryKey";
+var FOREIGN_KEY = "foreignKey";
+var PG_ENUM = "pgEnum";
+var MYSQL_ENUM = "mysqlEnum";
+var CUSTOM_TYPE = "customType";
+var ANY_COLUMN = {
+	pg: "AnyPgColumn",
+	mysql: "AnyMySqlColumn",
+	sqlite: "AnySQLiteColumn"
+};
+var EXTRA_CONFIG_VALUE = {
+	pg: "PgTableExtraConfigValue",
+	mysql: "MySqlTableExtraConfigValue",
+	sqlite: "SQLiteTableExtraConfigValue"
+};
+var SELF = "table";
+var FALLBACK_DIALECT = "pg";
+var DIALECT_BY_DATABASE = {
+	[Database.PostgreSQL]: "pg",
+	[Database.MySQL]: "mysql",
+	[Database.MariaDB]: "mysql",
+	[Database.SQLite]: "sqlite"
+};
+var TABLE_FUNCTION = {
+	pg: "pgTable",
+	mysql: "mysqlTable",
+	sqlite: "sqliteTable"
+};
+var DIALECT_MODULE = {
+	pg: `${CORE_MODULE}/pg-core`,
+	mysql: `${CORE_MODULE}/mysql-core`,
+	sqlite: `${CORE_MODULE}/sqlite-core`
+};
+var CORE_NAMES = [RELATIONS, SQL];
+var GLOBAL_NAMES = [
+	"Buffer",
+	"Date",
+	SELF,
+	"one",
+	"many"
+];
+var DIALECT_NAMES = {
+	pg: [
+		"bigint",
+		"bigserial",
+		"bit",
+		"boolean",
+		"char",
+		"check",
+		"cidr",
+		"customType",
+		"date",
+		"decimal",
+		"doublePrecision",
+		"foreignKey",
+		"geometry",
+		"halfvec",
+		"index",
+		"inet",
+		"integer",
+		"interval",
+		"json",
+		"jsonb",
+		"line",
+		"macaddr",
+		"macaddr8",
+		"numeric",
+		"pgEnum",
+		"pgSchema",
+		"pgTable",
+		"pgView",
+		"point",
+		"primaryKey",
+		"real",
+		"serial",
+		"smallint",
+		"smallserial",
+		"sparsevec",
+		"text",
+		"time",
+		"timestamp",
+		"unique",
+		"uniqueIndex",
+		"uuid",
+		"varchar",
+		"vector"
+	],
+	mysql: [
+		"bigint",
+		"binary",
+		"boolean",
+		"char",
+		"check",
+		"customType",
+		"date",
+		"datetime",
+		"decimal",
+		"double",
+		"float",
+		"foreignKey",
+		"index",
+		"int",
+		"json",
+		"longtext",
+		"mediumint",
+		"mediumtext",
+		"mysqlEnum",
+		"mysqlSchema",
+		"mysqlTable",
+		"mysqlView",
+		"primaryKey",
+		"real",
+		"serial",
+		"smallint",
+		"text",
+		"time",
+		"timestamp",
+		"tinyint",
+		"tinytext",
+		"unique",
+		"uniqueIndex",
+		"varbinary",
+		"varchar",
+		"year"
+	],
+	sqlite: [
+		"blob",
+		"check",
+		"customType",
+		"foreignKey",
+		"index",
+		"int",
+		"integer",
+		"numeric",
+		"primaryKey",
+		"real",
+		"sqliteTable",
+		"sqliteView",
+		"text",
+		"unique",
+		"uniqueIndex"
+	]
+};
+var OWNING = "owning";
+var INVERSE = "inverse";
+var INTERVAL_FIELDS = /* @__PURE__ */ new Set([
+	"day",
+	"day to hour",
+	"day to minute",
+	"day to second",
+	"hour",
+	"hour to minute",
+	"hour to second",
+	"minute",
+	"minute to second",
+	"month",
+	"second",
+	"year",
+	"year to month"
+]);
+var CHAR_NAMES = [
+	"bpchar",
+	"char",
+	"character",
+	"national char",
+	"national character",
+	"native character",
+	"nchar"
+];
+var VARCHAR_NAMES = [
+	"char varying",
+	"character varying",
+	"national char varying",
+	"national character varying",
+	"national varchar",
+	"national varcharacter",
+	"nchar varchar",
+	"nchar varcharacter",
+	"nchar varying",
+	"nvarchar",
+	"nvarchar2",
+	"varchar",
+	"varchar2",
+	"varcharacter",
+	"varying character"
+];
+var LONG_TEXT_NAMES = [
+	"long",
+	"long char varying",
+	"long character varying",
+	"long varchar",
+	"long varcharacter"
+];
+var PLAIN_TEXT_NAMES = [
+	"clob",
+	"national text",
+	"nclob",
+	"ntext",
+	"text"
+];
+var TEXT_NAMES = [...PLAIN_TEXT_NAMES, ...LONG_TEXT_NAMES];
+var BINARY_NAMES = Array.from(BINARY_TYPES);
+function namedCustomType(name, data) {
+	const head = `const ${name} = ${CUSTOM_TYPE}<{ data: ${data} }>({`;
+	const line = `${head} dataType: () => "${name}" });`;
+	return {
+		name,
+		lines: line.length <= LINE_LIMIT ? [line] : [
+			head,
+			`${INDENT}dataType: () => "${name}",`,
+			"});"
+		]
+	};
+}
+function bitCustomType(data) {
+	return {
+		name: "bit",
+		lines: [
+			`const bit = ${CUSTOM_TYPE}<{ data: ${data}; config: { length?: number } }>({`,
+			`${INDENT}dataType: (config) => \`bit(\${config?.length ?? 1})\`,`,
+			"});"
+		]
+	};
+}
+var VARBIT_TYPE = {
+	name: "varbit",
+	lines: [
+		`const varbit = ${CUSTOM_TYPE}<{ data: string; config: { length?: number } }>({`,
+		`${INDENT}dataType: (config) =>`,
+		`${INDENT}${INDENT}typeof config?.length === "number"`,
+		`${INDENT}${INDENT}${INDENT}? \`bit varying(\${config.length})\``,
+		`${INDENT}${INDENT}${INDENT}: "bit varying",`,
+		"});"
+	]
+};
+var SET_TYPE = {
+	name: "set",
+	lines: [
+		`const set = ${CUSTOM_TYPE}<{`,
+		`${INDENT}data: string;`,
+		`${INDENT}config: { values: string[] };`,
+		`${INDENT}configRequired: true;`,
+		"}>({",
+		`${INDENT}dataType: (config) =>`,
+		`${INDENT}${INDENT}\`set(\${config.values`,
+		`${INDENT}${INDENT}${INDENT}.map((value) => \`'\${value.replace(/\\\\/g, "\\\\\\\\").replace(/'/g, "''")}'\`)`,
+		`${INDENT}${INDENT}${INDENT}.join(",")})\`,`,
+		"});"
+	]
+};
+function customEmission(custom, ts, args = "none") {
+	return {
+		builder: custom.name,
+		ts,
+		args,
+		custom
+	};
+}
+var PG_TEXT = {
+	builder: "text",
+	ts: "string",
+	args: "none"
+};
+var PG_BYTEA = customEmission(namedCustomType("bytea", "Buffer"), "other");
+var PG_SMALLINT = {
+	builder: "smallint",
+	ts: "number",
+	args: "none",
+	autoInc: true
+};
+var PG_INTEGER = {
+	builder: "integer",
+	ts: "number",
+	args: "none",
+	autoInc: true
+};
+var PG_BIGINT = {
+	builder: "bigint",
+	ts: "number",
+	args: "none",
+	options: ["mode: \"number\""],
+	autoInc: true
+};
+var PG_REAL = {
+	builder: "real",
+	ts: "number",
+	args: "none"
+};
+var PG_DOUBLE = {
+	builder: "doublePrecision",
+	ts: "number",
+	args: "none"
+};
+var PG_DATE = {
+	builder: "date",
+	ts: "string",
+	args: "none"
+};
+var PG_TIMESTAMP = {
+	builder: "timestamp",
+	ts: "other",
+	args: "seconds"
+};
+var PG_TIMESTAMP_TZ = {
+	...PG_TIMESTAMP,
+	options: ["withTimezone: true"]
+};
+var POSTGRES_TYPES = new Map([
+	...[
+		"box",
+		"datemultirange",
+		"daterange",
+		"int4multirange",
+		"int4range",
+		"int8multirange",
+		"int8range",
+		"lseg",
+		"money",
+		"nummultirange",
+		"numrange",
+		"path",
+		"polygon",
+		"tsmultirange",
+		"tsquery",
+		"tsrange",
+		"tstzmultirange",
+		"tstzrange",
+		"tsvector",
+		"xml"
+	].map((name) => [name, customEmission(namedCustomType(name, "string"), "string")]),
+	["bit", customEmission(bitCustomType("string"), "string", "length")],
+	["bit varying", customEmission(VARBIT_TYPE, "string", "length")],
+	["varbit", customEmission(VARBIT_TYPE, "string", "length")]
+]);
+var PG_TYPES = [
+	[CHAR_NAMES, {
+		builder: "char",
+		ts: "string",
+		args: "length"
+	}],
+	[VARCHAR_NAMES, {
+		builder: "varchar",
+		ts: "string",
+		args: "length"
+	}],
+	[[
+		...TEXT_NAMES,
+		"longtext",
+		"mediumtext",
+		"tinytext"
+	], PG_TEXT],
+	[BINARY_NAMES, PG_BYTEA],
+	[[...UUID_TYPES], {
+		builder: "uuid",
+		ts: "string",
+		args: "none"
+	}],
+	[["json"], {
+		builder: "json",
+		ts: "other",
+		args: "none"
+	}],
+	[["jsonb"], {
+		builder: "jsonb",
+		ts: "other",
+		args: "none"
+	}],
+	[["bool", "boolean"], {
+		builder: "boolean",
+		ts: "boolean",
+		args: "none"
+	}],
+	[[
+		"byte",
+		"int1",
+		"int2",
+		"short",
+		"smallint",
+		"tinyint"
+	], PG_SMALLINT],
+	[[
+		"int",
+		"int3",
+		"int4",
+		"integer",
+		"mediumint",
+		"middleint"
+	], PG_INTEGER],
+	[["bigint", "int8"], PG_BIGINT],
+	[["serial", "serial4"], {
+		builder: "serial",
+		ts: "number",
+		args: "none"
+	}],
+	[["serial2", "smallserial"], {
+		builder: "smallserial",
+		ts: "number",
+		args: "none"
+	}],
+	[["bigserial", "serial8"], {
+		builder: "bigserial",
+		ts: "number",
+		args: "none",
+		options: ["mode: \"number\""]
+	}],
+	[[
+		"binary_float",
+		"float4",
+		"real"
+	], PG_REAL],
+	[[
+		"binary_double",
+		"double",
+		"double precision",
+		"float8"
+	], PG_DOUBLE],
+	[[
+		"dec",
+		"decimal",
+		"fixed",
+		...MONEY_TYPES,
+		"number",
+		"numeric"
+	], {
+		builder: "numeric",
+		ts: "string",
+		args: "precision",
+		numericString: true
+	}],
+	[["date"], PG_DATE],
+	[["time", "time without time zone"], {
+		builder: "time",
+		ts: "string",
+		args: "seconds"
+	}],
+	[[...POSTGRES_TIME_TZ_TYPES], {
+		builder: "time",
+		ts: "string",
+		args: "seconds",
+		options: ["withTimezone: true"]
+	}],
+	[[
+		"datetime",
+		"datetime2",
+		"smalldatetime",
+		"timestamp",
+		"timestamp_ntz",
+		"timestamp without time zone"
+	], PG_TIMESTAMP],
+	[[...TIMESTAMP_TZ_TYPES, ...TIMESTAMP_LTZ_TYPES], PG_TIMESTAMP_TZ],
+	[["cidr"], {
+		builder: "cidr",
+		ts: "string",
+		args: "none"
+	}],
+	[[
+		"inet",
+		"inet4",
+		"inet6"
+	], {
+		builder: "inet",
+		ts: "string",
+		args: "none"
+	}],
+	[["macaddr"], {
+		builder: "macaddr",
+		ts: "string",
+		args: "none"
+	}],
+	[["macaddr8"], {
+		builder: "macaddr8",
+		ts: "string",
+		args: "none"
+	}],
+	[[...POSTGRES_BIT_TYPES], {
+		builder: "varchar",
+		ts: "string",
+		args: "length"
+	}],
+	[["point"], {
+		builder: "point",
+		ts: "other",
+		args: "none"
+	}],
+	[["line"], {
+		builder: "line",
+		ts: "other",
+		args: "none"
+	}]
+];
+var PG_FALLBACK = {
+	int: PG_INTEGER,
+	long: PG_BIGINT,
+	float: PG_REAL,
+	double: PG_DOUBLE,
+	decimal: {
+		builder: "numeric",
+		ts: "string",
+		args: "precision",
+		numericString: true
+	},
+	boolean: {
+		builder: "boolean",
+		ts: "boolean",
+		args: "none"
+	},
+	string: {
+		builder: "varchar",
+		ts: "string",
+		args: "length"
+	},
+	lob: PG_TEXT,
+	date: PG_DATE,
+	dateTime: PG_TIMESTAMP,
+	time: {
+		builder: "time",
+		ts: "string",
+		args: "seconds"
+	}
+};
+var MYSQL_TEXT = {
+	builder: "text",
+	ts: "string",
+	args: "none"
+};
+var MYSQL_DOUBLE = {
+	builder: "double",
+	ts: "number",
+	args: "precisionAndScale",
+	autoInc: true,
+	unsigned: true
+};
+var MYSQL_FLOAT = {
+	builder: "float",
+	ts: "number",
+	args: "floatPrecision",
+	autoInc: true,
+	unsigned: true
+};
+function mysqlBlob(name) {
+	return customEmission(namedCustomType(name, "Buffer"), "other");
+}
+var MYSQL_TINYBLOB = mysqlBlob("tinyblob");
+var MYSQL_BLOB = mysqlBlob("blob");
+var MYSQL_MEDIUMBLOB = mysqlBlob("mediumblob");
+var MYSQL_LONGBLOB = mysqlBlob("longblob");
+var MYSQL_BLOB_SIZES = [
+	[255, MYSQL_TINYBLOB],
+	[65535, MYSQL_BLOB],
+	[16777215, MYSQL_MEDIUMBLOB]
+];
+var MYSQL_SPATIAL_TYPES = [
+	"geomcollection",
+	"geometry",
+	"geometrycollection",
+	"linestring",
+	"multilinestring",
+	"multipoint",
+	"multipolygon",
+	"point",
+	"polygon"
+];
+var MYSQL_SET = customEmission(SET_TYPE, "string", "members");
+var MYSQL_TYPES = [
+	[BINARY_NAMES, MYSQL_BLOB],
+	[["blob"], {
+		...MYSQL_BLOB,
+		args: "blobLength"
+	}],
+	[["tinyblob"], MYSQL_TINYBLOB],
+	[["long varbinary", "mediumblob"], MYSQL_MEDIUMBLOB],
+	[["longblob"], MYSQL_LONGBLOB],
+	...MYSQL_SPATIAL_TYPES.map((name) => [[name], customEmission(namedCustomType(name, "unknown"), "other")]),
+	[["bit"], customEmission(bitCustomType("Buffer"), "other", "length")],
+	[[
+		"byte",
+		"int1",
+		"tinyint"
+	], {
+		builder: "tinyint",
+		ts: "number",
+		args: "none",
+		autoInc: true,
+		unsigned: true
+	}],
+	[[
+		"int2",
+		"short",
+		"smallint"
+	], {
+		builder: "smallint",
+		ts: "number",
+		args: "none",
+		autoInc: true,
+		unsigned: true
+	}],
+	[[
+		"int3",
+		"mediumint",
+		"middleint"
+	], {
+		builder: "mediumint",
+		ts: "number",
+		args: "none",
+		autoInc: true,
+		unsigned: true
+	}],
+	[[
+		"int",
+		"int4",
+		"integer"
+	], {
+		builder: "int",
+		ts: "number",
+		args: "none",
+		autoInc: true,
+		unsigned: true
+	}],
+	[["bigint", "int8"], {
+		builder: "bigint",
+		ts: "number",
+		args: "none",
+		options: ["mode: \"number\""],
+		autoInc: true,
+		unsigned: true
+	}],
+	[["serial"], {
+		builder: "serial",
+		ts: "number",
+		args: "none"
+	}],
+	[[
+		"dec",
+		"decimal",
+		"fixed",
+		"number",
+		"numeric"
+	], {
+		builder: "decimal",
+		ts: "string",
+		args: "precision",
+		unsigned: true,
+		numericString: true
+	}],
+	[[
+		"binary_float",
+		"float",
+		"float4"
+	], MYSQL_FLOAT],
+	[[
+		"binary_double",
+		"double",
+		"double precision",
+		"float8",
+		"real"
+	], MYSQL_DOUBLE],
+	[["bool", "boolean"], {
+		builder: "boolean",
+		ts: "boolean",
+		args: "none"
+	}],
+	[CHAR_NAMES, {
+		builder: "char",
+		ts: "string",
+		args: "length"
+	}],
+	[VARCHAR_NAMES, {
+		builder: "varchar",
+		ts: "string",
+		args: "lengthRequired",
+		degraded: MYSQL_TEXT
+	}],
+	[PLAIN_TEXT_NAMES, MYSQL_TEXT],
+	[["tinytext"], {
+		builder: "tinytext",
+		ts: "string",
+		args: "none"
+	}],
+	[["mediumtext", ...LONG_TEXT_NAMES], {
+		builder: "mediumtext",
+		ts: "string",
+		args: "none"
+	}],
+	[["longtext"], {
+		builder: "longtext",
+		ts: "string",
+		args: "none"
+	}],
+	[["json"], {
+		builder: "json",
+		ts: "other",
+		args: "none"
+	}],
+	[["date"], {
+		builder: "date",
+		ts: "other",
+		args: "none"
+	}],
+	[["datetime"], {
+		builder: "datetime",
+		ts: "other",
+		args: "seconds"
+	}],
+	[["timestamp"], {
+		builder: "timestamp",
+		ts: "other",
+		args: "seconds"
+	}],
+	[["time"], {
+		builder: "time",
+		ts: "string",
+		args: "seconds"
+	}],
+	[["sql_tsi_year", "year"], {
+		builder: "year",
+		ts: "number",
+		args: "none"
+	}],
+	[["binary", "char byte"], {
+		builder: "binary",
+		ts: "other",
+		args: "length"
+	}],
+	[[
+		"binary varying",
+		"raw",
+		"varbinary"
+	], {
+		builder: "varbinary",
+		ts: "other",
+		args: "lengthRequired",
+		degraded: MYSQL_BLOB
+	}]
+];
+var MARIADB_TYPES = new Map([
+	["serial", {
+		builder: "bigint",
+		ts: "number",
+		args: "none",
+		options: ["mode: \"number\""],
+		unsigned: true,
+		serial: true
+	}],
+	...[
+		"inet4",
+		"inet6",
+		"uuid"
+	].map((name) => [name, customEmission(namedCustomType(name, "string"), "string")]),
+	["clob", {
+		builder: "longtext",
+		ts: "string",
+		args: "none"
+	}]
+]);
+var MYSQL_FALLBACK = {
+	int: {
+		builder: "int",
+		ts: "number",
+		args: "none",
+		autoInc: true,
+		unsigned: true
+	},
+	long: {
+		builder: "bigint",
+		ts: "number",
+		args: "none",
+		options: ["mode: \"number\""],
+		autoInc: true,
+		unsigned: true
+	},
+	float: MYSQL_FLOAT,
+	double: MYSQL_DOUBLE,
+	decimal: {
+		builder: "decimal",
+		ts: "string",
+		args: "precision",
+		unsigned: true,
+		numericString: true
+	},
+	boolean: {
+		builder: "boolean",
+		ts: "boolean",
+		args: "none"
+	},
+	string: {
+		builder: "varchar",
+		ts: "string",
+		args: "lengthRequired",
+		degraded: MYSQL_TEXT
+	},
+	lob: MYSQL_TEXT,
+	date: {
+		builder: "date",
+		ts: "other",
+		args: "none"
+	},
+	dateTime: {
+		builder: "datetime",
+		ts: "other",
+		args: "seconds"
+	},
+	time: {
+		builder: "time",
+		ts: "string",
+		args: "seconds"
+	}
+};
+var SQLITE_INTEGER = {
+	builder: "integer",
+	ts: "number",
+	args: "none",
+	autoInc: true
+};
+var SQLITE_REAL = {
+	builder: "real",
+	ts: "number",
+	args: "none"
+};
+var SQLITE_NUMERIC = {
+	builder: "numeric",
+	ts: "string",
+	args: "none",
+	numericString: true
+};
+var SQLITE_TEXT = {
+	builder: "text",
+	ts: "string",
+	args: "length"
+};
+var SQLITE_LOB = {
+	builder: "text",
+	ts: "string",
+	args: "none"
+};
+var SQLITE_BOOLEAN = {
+	builder: "integer",
+	ts: "boolean",
+	args: "none",
+	options: ["mode: \"boolean\""]
+};
+var SQLITE_TYPES = [
+	[["bool", "boolean"], SQLITE_BOOLEAN],
+	[[
+		"bigint",
+		"byte",
+		"int",
+		"int1",
+		"int2",
+		"int3",
+		"int4",
+		"int8",
+		"integer",
+		"mediumint",
+		"middleint",
+		"serial",
+		"short",
+		"smallint",
+		"tinyint",
+		"unsigned big int",
+		"year"
+	], SQLITE_INTEGER],
+	[[
+		"binary_double",
+		"binary_float",
+		"double",
+		"double precision",
+		"float",
+		"float4",
+		"float8",
+		"real"
+	], SQLITE_REAL],
+	[[
+		"dec",
+		"decimal",
+		"fixed",
+		...MONEY_TYPES,
+		"number",
+		"numeric"
+	], SQLITE_NUMERIC],
+	[BINARY_NAMES, {
+		builder: "blob",
+		ts: "other",
+		args: "none",
+		options: ["mode: \"buffer\""]
+	}],
+	[CHAR_NAMES, SQLITE_TEXT],
+	[VARCHAR_NAMES, SQLITE_TEXT],
+	[[
+		...TEXT_NAMES,
+		...JSON_TYPES,
+		...UUID_TYPES,
+		"longtext",
+		"mediumtext",
+		"tinytext",
+		"xml"
+	], SQLITE_LOB]
+];
+var SQLITE_FALLBACK = {
+	int: SQLITE_INTEGER,
+	long: SQLITE_INTEGER,
+	float: SQLITE_REAL,
+	double: SQLITE_REAL,
+	decimal: SQLITE_NUMERIC,
+	boolean: SQLITE_BOOLEAN,
+	string: SQLITE_TEXT,
+	lob: SQLITE_LOB,
+	date: SQLITE_LOB,
+	dateTime: SQLITE_LOB,
+	time: SQLITE_LOB
+};
+function toVendorMap(rows) {
+	return new Map(rows.flatMap(([names, emission]) => names.map((name) => [name, emission])));
+}
+var VENDOR_TYPES = {
+	pg: toVendorMap(PG_TYPES),
+	mysql: toVendorMap(MYSQL_TYPES),
+	sqlite: toVendorMap(SQLITE_TYPES)
+};
+var FALLBACK_TYPES = {
+	pg: PG_FALLBACK,
+	mysql: MYSQL_FALLBACK,
+	sqlite: SQLITE_FALLBACK
+};
+var DATABASE_TYPES = {
+	[Database.PostgreSQL]: POSTGRES_TYPES,
+	[Database.MariaDB]: MARIADB_TYPES
+};
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+	if (tables.length === 0) return "";
+	const context = createSchemaContext(state);
+	const imports = createImportSet();
+	const bodyBuffer = [];
+	tables.forEach((table, index) => {
+		if (index !== 0) bodyBuffer.push("");
+		formatDeclarations(state, {
+			buffer: bodyBuffer,
+			table
+		}, context, imports);
+	});
+	const stringBuffer = [""];
+	formatImports(stringBuffer, context, imports);
+	stringBuffer.push("");
+	formatCustomTypes(stringBuffer, imports);
+	bodyBuffer.forEach((line) => stringBuffer.push(line));
+	stringBuffer.push("");
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const context = createSchemaContext(state);
+	const imports = createImportSet();
+	const bodyBuffer = [];
+	formatDeclarations(state, {
+		buffer: bodyBuffer,
+		table
+	}, context, imports);
+	formatImports(buffer, context, imports);
+	buffer.push("");
+	formatCustomTypes(buffer, imports);
+	bodyBuffer.forEach((line) => buffer.push(line));
+}
+function createImportSet() {
+	return {
+		core: /* @__PURE__ */ new Set(),
+		dialect: /* @__PURE__ */ new Set(),
+		types: /* @__PURE__ */ new Set(),
+		customs: /* @__PURE__ */ new Map()
+	};
+}
+function formatImports(buffer, { dialect }, imports) {
+	if (imports.core.size !== 0) formatImport(buffer, CORE_MODULE, imports.core);
+	formatImport(buffer, DIALECT_MODULE[dialect], imports.dialect);
+	if (imports.types.size !== 0) formatImport(buffer, DIALECT_MODULE[dialect], imports.types, "import type");
+}
+function formatCustomTypes(buffer, { customs }) {
+	if (customs.size === 0) return;
+	Array.from(customs.values()).sort((a, b) => a.name < b.name ? -1 : 1).forEach((custom) => custom.lines.forEach((line) => buffer.push(line)));
+	buffer.push("");
+}
+function formatImport(buffer, module, names, keyword = "import") {
+	const sorted = Array.from(names).sort();
+	const line = `${keyword} { ${sorted.join(", ")} } from "${module}";`;
+	if (line.length <= LINE_LIMIT) {
+		buffer.push(line);
+		return;
+	}
+	buffer.push(`${keyword} {`);
+	sorted.forEach((name) => buffer.push(`${INDENT}${name},`));
+	buffer.push(`} from "${module}";`);
+}
+function formatDeclarations(state, { buffer, table }, context, imports) {
+	const { settings: { database }, collections } = state;
+	const naming = getNaming(state, context, table);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(naming.columnIds);
+	const primaryKeyIds = new Set(columns.filter((column) => bHas(column.options, ColumnOption.primaryKey)).map((column) => column.id));
+	const isComposite = primaryKeyIds.size > 1;
+	const references = createReferences(state, context, table, imports);
+	const columnBuffer = [];
+	const enumBuffer = [];
+	columns.forEach((column) => {
+		const property = naming.columnNames.get(column.id) ?? column.name;
+		const enumNaming = naming.enumNames.get(column.id) ?? null;
+		const columnType = getColumnType(column, property, {
+			database,
+			dialect: context.dialect,
+			enumNaming
+		});
+		if (columnType.custom !== null) {
+			imports.dialect.add(CUSTOM_TYPE);
+			imports.customs.set(columnType.custom.name, columnType.custom);
+		} else if (columnType.builder !== null) imports.dialect.add(columnType.builder);
+		if (enumNaming !== null && columnType.members !== null) {
+			const list = memberList(columnType.members);
+			imports.dialect.add(PG_ENUM);
+			enumBuffer.push(`export const ${enumNaming.constName} = ${PG_ENUM}("${escapeString(enumNaming.typeName)}", ${list});`);
+			enumBuffer.push("");
+		}
+		formatColumn({
+			buffer: columnBuffer,
+			column
+		}, {
+			property,
+			columnType,
+			isComposite,
+			reference: references.get(column.id) ?? null,
+			dialect: context.dialect,
+			imports
+		});
+	});
+	const extras = createExtras(state, {
+		table,
+		naming,
+		columns,
+		primaryKeyIds,
+		isComposite
+	}, context, imports);
+	imports.dialect.add(TABLE_FUNCTION[context.dialect]);
+	enumBuffer.forEach((line) => buffer.push(line));
+	formatComment(buffer, "", table.comment);
+	const annotation = context.annotated.has(table.id) ? EXTRA_CONFIG_VALUE[context.dialect] : null;
+	if (annotation !== null) imports.types.add(annotation);
+	formatTableCall(buffer, table, naming, columnBuffer, extras, annotation, context);
+	formatRelations(state, buffer, table, naming, context, imports);
+}
+function formatTableCall(buffer, table, naming, columnBuffer, extras, annotation, { dialect }) {
+	const head = `export const ${naming.constName} = ${TABLE_FUNCTION[dialect]}(`;
+	const name = `"${escapeString(table.name)}"`;
+	if (extras.length === 0) {
+		if (columnBuffer.length === 0) {
+			buffer.push(`${head}${name}, {});`);
+			return;
+		}
+		buffer.push(`${head}${name}, {`);
+		columnBuffer.forEach((line) => buffer.push(line));
+		buffer.push("});");
+		return;
+	}
+	buffer.push(head);
+	buffer.push(`${INDENT}${name},`);
+	if (columnBuffer.length === 0) buffer.push(`${INDENT}{},`);
+	else {
+		buffer.push(`${INDENT}{`);
+		columnBuffer.forEach((line) => buffer.push(`${INDENT}${line}`));
+		buffer.push(`${INDENT}},`);
+	}
+	const arrow = annotation === null ? `${SELF} =>` : `(${SELF}): ${annotation}[] =>`;
+	const inline = `${INDENT}${arrow} [${extras.map(inlineExtra).join(", ")}]`;
+	if (inline.length <= LINE_LIMIT) buffer.push(inline);
+	else {
+		buffer.push(`${INDENT}${arrow} [`);
+		extras.forEach((entry) => formatExtra(buffer, `${INDENT}${INDENT}`, entry));
+		buffer.push(`${INDENT}]`);
+	}
+	buffer.push(");");
+}
+function formatColumn({ buffer, column }, { property, columnType, isComposite, reference, dialect, imports }) {
+	const { isPrimaryKey, isAutoIncrement, isNotNull } = columnFlags(column);
+	const autoInc = isAutoIncrement && columnType.autoInc || columnType.serial;
+	const single = isPrimaryKey && !isComposite;
+	const marked = autoInc && (dialect !== "sqlite" || single);
+	const chain = [];
+	if (single && dialect === "sqlite") chain.push(autoInc ? ".primaryKey({ autoIncrement: true })" : ".primaryKey()");
+	else {
+		if (autoInc && dialect === "mysql") chain.push(".autoincrement()");
+		if (single) chain.push(".primaryKey()");
+		if (autoInc && dialect === "pg") chain.push(".generatedAlwaysAsIdentity()");
+	}
+	if ((isNotNull || columnType.serial) && !single) chain.push(".notNull()");
+	if ((bHas(column.options, ColumnOption.unique) || columnType.serial) && !single) chain.push(".unique()");
+	const value = column.default.trim();
+	if (!marked && value !== "") chain.push(defaultModifier(value, columnType, imports));
+	if (reference !== null) chain.push(reference);
+	formatComment(buffer, INDENT, column.comment);
+	const line = `${INDENT}${property}: ${columnType.head}${chain.join("")},`;
+	if (line.length <= LINE_LIMIT || chain.length === 0) {
+		buffer.push(line);
+		return;
+	}
+	buffer.push(`${INDENT}${property}: ${columnType.head}`);
+	chain.forEach((link, index) => buffer.push(`${INDENT}${INDENT}${link}${index === chain.length - 1 ? "," : ""}`));
+}
+function formatComment(buffer, indent, comment) {
+	if (comment.trim() === "") return;
+	splitLines(comment).forEach((line) => buffer.push(`${indent}// ${escapeTypeScriptDirective(line)}`));
+}
+function columnFlags(column) {
+	const isPrimaryKey = bHas(column.options, ColumnOption.primaryKey);
+	return {
+		isPrimaryKey,
+		isAutoIncrement: bHas(column.options, ColumnOption.autoIncrement),
+		isNotNull: isPrimaryKey || bHas(column.options, ColumnOption.notNull)
+	};
+}
+var NUMERIC_LITERAL = /^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+var LEADING_PLUS = /^\+/;
+var TRAILING_ZEROS = /\.?0+$/;
+var QUOTED_LITERAL = /^'([^']|'')*'$/;
+var ESCAPED_QUOTE = /''/g;
+var BOOLEAN_DEFAULTS = /* @__PURE__ */ new Map([
+	["0", "false"],
+	["1", "true"],
+	["false", "false"],
+	["true", "true"]
+]);
+function defaultModifier(value, { ts, members, numericString }, imports) {
+	if (NUMERIC_LITERAL.test(value) && isExactNumber(value)) {
+		if (ts === "number") return `.default(${value})`;
+		if (numericString) return `.default("${value}")`;
+	}
+	if (ts === "string" && QUOTED_LITERAL.test(value)) {
+		const unquoted = value.slice(1, -1).replace(ESCAPED_QUOTE, "'");
+		if (members === null || members.includes(unquoted)) return `.default("${escapeString(unquoted)}")`;
+	}
+	const flag = BOOLEAN_DEFAULTS.get(value.toLocaleLowerCase());
+	if (ts === "boolean" && flag !== void 0) return `.default(${flag})`;
+	imports.core.add(SQL);
+	return `.default(${SQL}\`${escapeTemplate(value)}\`)`;
+}
+function isExactNumber(value) {
+	return normalizeNumber(value) === normalizeNumber(String(Number(value)));
+}
+function normalizeNumber(value) {
+	const signed = value.replace(LEADING_PLUS, "");
+	return signed.includes(".") ? signed.replace(TRAILING_ZEROS, "") : signed;
+}
+function createReferences(state, context, table, imports) {
+	const references = /* @__PURE__ */ new Map();
+	context.relationships.filter(({ relationship }) => relationship.end.tableId === table.id && context.inlined.has(relationship.id)).forEach(({ relationship, startTable, startColumns, endColumns }) => {
+		const parentNaming = getNaming(state, context, startTable);
+		const referenced = parentNaming.columnNames.get(startColumns[0].id);
+		if (referenced === void 0) return;
+		const carrier = carrierOf(state, context, table, endColumns[0].id);
+		const target = `${parentNaming.constName}.${referenced}`;
+		const actions = referentialActionEntries(relationship, context.actionSupport).map(({ key, sql }) => `${key}: "${sql.toLowerCase()}"`);
+		const options = actions.length ? `, { ${actions.join(", ")} }` : "";
+		if (!context.cyclic.has(relationship.id)) {
+			references.set(carrier, `.references(() => ${target}${options})`);
+			return;
+		}
+		const annotation = ANY_COLUMN[context.dialect];
+		imports.types.add(annotation);
+		references.set(carrier, `.references((): ${annotation} => ${target}${options})`);
+	});
+	return references;
+}
+function carrierOf(state, context, table, columnId) {
+	return getNaming(state, context, table).carriers.get(columnId) ?? columnId;
+}
+function planReferences(state, context) {
+	const claimed = /* @__PURE__ */ new Set();
+	context.relationships.forEach(({ relationship, endTable, endColumns }) => {
+		if (endColumns.length !== 1) return;
+		const carrier = carrierOf(state, context, endTable, endColumns[0].id);
+		if (claimed.has(carrier)) return;
+		claimed.add(carrier);
+		context.inlined.add(relationship.id);
+	});
+	const edges = /* @__PURE__ */ new Map();
+	const add = (from, to) => {
+		const targets = edges.get(from) ?? /* @__PURE__ */ new Set();
+		targets.add(to);
+		edges.set(from, targets);
+	};
+	context.relationships.forEach(({ relationship }) => {
+		const { tableId: parent } = relationship.start;
+		const { tableId: child } = relationship.end;
+		if (context.inlined.has(relationship.id) || parent !== child) add(child, parent);
+	});
+	context.relationships.forEach(({ relationship }) => {
+		const { tableId: parent } = relationship.start;
+		const { tableId: child } = relationship.end;
+		if (!context.inlined.has(relationship.id) && parent === child) return;
+		if (!reaches(edges, parent, child)) return;
+		if (context.inlined.has(relationship.id)) context.cyclic.add(relationship.id);
+		else context.annotated.add(child);
+	});
+}
+function reaches(edges, from, to) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [from];
+	while (stack.length !== 0) {
+		const current = stack.pop();
+		if (current === to) return true;
+		if (seen.has(current)) continue;
+		seen.add(current);
+		edges.get(current)?.forEach((next) => stack.push(next));
+	}
+	return false;
+}
+function createExtras(state, { table, naming, columns, primaryKeyIds, isComposite }, context, imports) {
+	const entries = [];
+	if (isComposite) {
+		const members = columns.filter((column) => primaryKeyIds.has(column.id)).map((column) => `${SELF}.${naming.columnNames.get(column.id)}`);
+		imports.dialect.add(PRIMARY_KEY);
+		entries.push({
+			kind: "object",
+			builder: PRIMARY_KEY,
+			entries: [`columns: [${members.join(", ")}]`]
+		});
+	}
+	createForeignKeys(state, table, naming, context).forEach((entry) => {
+		imports.dialect.add(FOREIGN_KEY);
+		entries.push(entry);
+	});
+	createIndexEntries(state, table, naming, context).forEach((entry) => {
+		imports.dialect.add(entry.unique ? UNIQUE_INDEX : INDEX);
+		entries.push(entry.value);
+	});
+	return entries;
+}
+function inlineExtra(extra) {
+	return extra.kind === "object" ? `${extra.builder}({ ${extra.entries.join(", ")} })${chainOf(extra)}` : `${extra.head}(${extra.args.join(", ")})`;
+}
+function chainOf(extra) {
+	return (extra.chain ?? []).join("");
+}
+function formatExtra(buffer, indent, extra) {
+	const line = `${indent}${inlineExtra(extra)},`;
+	if (line.length <= LINE_LIMIT) {
+		buffer.push(line);
+		return;
+	}
+	if (extra.kind === "object") {
+		buffer.push(`${indent}${extra.builder}({`);
+		extra.entries.forEach((entry) => buffer.push(`${indent}${INDENT}${entry},`));
+		buffer.push(`${indent}})${chainOf(extra)},`);
+		return;
+	}
+	buffer.push(`${indent}${extra.head}(`);
+	extra.args.forEach((arg, index) => buffer.push(`${indent}${INDENT}${arg}${index === extra.args.length - 1 ? "" : ","}`));
+	buffer.push(`${indent}),`);
+}
+function createForeignKeys(state, table, naming, context) {
+	return context.relationships.filter(({ relationship }) => relationship.end.tableId === table.id && !context.inlined.has(relationship.id)).flatMap(({ relationship, startTable, startColumns, endColumns }) => {
+		const parentNaming = getNaming(state, context, startTable);
+		const own = endColumns.map((column) => naming.columnNames.get(column.id));
+		const target = startColumns.map((column) => parentNaming.columnNames.get(column.id));
+		if (own.some((name) => name === void 0) || target.some((name) => name === void 0)) return [];
+		const scope = startTable.id === table.id ? SELF : parentNaming.constName;
+		const columns = own.map((name) => `${SELF}.${name}`).join(", ");
+		const foreignColumns = target.map((name) => `${scope}.${name}`).join(", ");
+		return [{
+			kind: "object",
+			builder: FOREIGN_KEY,
+			entries: [`columns: [${columns}]`, `foreignColumns: [${foreignColumns}]`],
+			chain: referentialActionEntries(relationship, context.actionSupport).map(({ key, sql }) => `.${key}("${sql.toLowerCase()}")`)
+		}];
+	});
+}
+function createIndexEntries(state, table, naming, { indexNames, dialect }) {
+	const { doc: { indexIds }, collections } = state;
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const entries = [];
+	query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id).forEach((index) => {
+		const properties = Array.from(new Set(query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).flatMap((indexColumn) => {
+			const property = naming.columnNames.get(indexColumn.columnId);
+			if (property === void 0 || !columnCollection.selectById(indexColumn.columnId)) return [];
+			return dialect === "pg" && indexColumn.orderType === OrderType.DESC ? [`${SELF}.${property}.desc()`] : [`${SELF}.${property}`];
+		})));
+		if (properties.length === 0) return;
+		const builder = index.unique ? UNIQUE_INDEX : INDEX;
+		const name = escapeString(indexNames.get(index.id) ?? index.name);
+		entries.push({
+			value: {
+				kind: "call",
+				head: `${builder}("${name}").on`,
+				args: properties
+			},
+			unique: index.unique
+		});
+	});
+	return entries;
+}
+function formatRelations(state, buffer, table, naming, context, imports) {
+	const entries = [];
+	context.relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach(({ relationship, startTable, startColumns, endColumns }) => {
+		const property = naming.relationshipNames.get(relationshipKey(relationship, OWNING));
+		if (!property || endColumns.length !== 1) return;
+		const parentNaming = getNaming(state, context, startTable);
+		const own = naming.columnNames.get(endColumns[0].id);
+		const target = parentNaming.columnNames.get(startColumns[0].id);
+		if (own === void 0 || target === void 0) return;
+		entries.push({
+			property,
+			helper: "one",
+			target: parentNaming.constName,
+			options: [
+				`fields: [${naming.constName}.${own}]`,
+				`references: [${parentNaming.constName}.${target}]`,
+				...aliasOption(context, relationship)
+			]
+		});
+	});
+	context.relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable, startColumns, endColumns }) => {
+		const property = naming.relationshipNames.get(relationshipKey(relationship, INVERSE));
+		if (!property) return;
+		const childNaming = getNaming(state, context, endTable);
+		const many = hasNRelationship(relationship.relationshipType);
+		const alias = aliasOption(context, relationship);
+		const own = naming.columnNames.get(startColumns[0].id);
+		const target = childNaming.columnNames.get(endColumns[0].id);
+		const spelled = !many && alias.length !== 0 && own !== void 0 && target !== void 0;
+		entries.push({
+			property,
+			helper: many ? "many" : "one",
+			target: childNaming.constName,
+			options: spelled ? [
+				`fields: [${naming.constName}.${own}]`,
+				`references: [${childNaming.constName}.${target}]`,
+				...alias
+			] : alias
+		});
+	});
+	if (entries.length === 0) return;
+	const callback = `({ ${[...entries.some((entry) => entry.helper === "one") ? ["one"] : [], ...entries.some((entry) => entry.helper === "many") ? ["many"] : []].join(", ")} }) => ({`;
+	const head = `export const ${naming.relationsName} = ${RELATIONS}(`;
+	const line = `${head}${naming.constName}, ${callback}`;
+	imports.core.add(RELATIONS);
+	buffer.push("");
+	if (line.length <= LINE_LIMIT) {
+		buffer.push(line);
+		entries.forEach((entry) => formatRelationEntry(buffer, INDENT, entry));
+		buffer.push("}));");
+		return;
+	}
+	buffer.push(head);
+	buffer.push(`${INDENT}${naming.constName},`);
+	buffer.push(`${INDENT}${callback}`);
+	entries.forEach((entry) => formatRelationEntry(buffer, `${INDENT}${INDENT}`, entry));
+	buffer.push(`${INDENT}})`);
+	buffer.push(");");
+}
+function formatRelationEntry(buffer, indent, { property, helper, target, options }) {
+	const head = `${property}: ${helper}(${target}`;
+	if (options.length === 0) {
+		buffer.push(`${indent}${head}),`);
+		return;
+	}
+	const inline = `${indent}${head}, { ${options.join(", ")} }),`;
+	if (inline.length <= LINE_LIMIT) {
+		buffer.push(inline);
+		return;
+	}
+	buffer.push(`${indent}${head}, {`);
+	options.forEach((option) => buffer.push(`${indent}${INDENT}${option},`));
+	buffer.push(`${indent}}),`);
+}
+function aliasOption({ aliases }, relationship) {
+	const alias = aliases.get(relationship.id);
+	return alias === void 0 ? [] : [`relationName: "${escapeString(alias)}"`];
+}
+var WHITESPACE = /\s+/g;
+var SIGN_WORDS = /(^|[^0-9a-z_])(?:signed|unsigned|zerofill)(?=[^0-9a-z_]|$)/g;
+var CHARACTER_ATTRIBUTES = /(?: (?:ascii|binary|unicode|(?:char set|character set|charset|collate) \S+))+$/;
+var INTERVAL = "interval";
+var SECONDS_PRECISION = /\b(?:interval|second)\s*\(/i;
+var BARE_NUMBER = "number";
+var SINGLE_PRECISION_DIGITS = 24;
+var AMBIGUOUS_NAMES = /* @__PURE__ */ new Set([
+	"bit",
+	"long",
+	"timestamp"
+]);
+function getColumnType(column, property, { database, dialect, enumNaming }) {
+	const { dataType, name } = column;
+	const classified = getColumnType$1(dataType, database);
+	const argument = name === property ? null : `"${escapeString(name)}"`;
+	const members = classified.enumMembers;
+	return arrayType(members === null ? scalarType(classified, argument, {
+		database,
+		dialect
+	}) : enumType(members, dialect, property, argument, enumNaming), classified.arrayDepth);
+}
+function scalarType(classified, argument, { database, dialect }) {
+	const resolved = resolveScalar(classified, database, dialect);
+	const options = [...resolved.options];
+	if (dialect === "mysql" && resolved.emission.unsigned === true && isUnsigned(classified.element, database)) options.push("unsigned: true");
+	return {
+		head: call(resolved.emission.builder, argument, options),
+		builder: resolved.emission.custom ? null : resolved.emission.builder,
+		custom: resolved.emission.custom ?? null,
+		ts: resolved.emission.ts,
+		members: null,
+		autoInc: resolved.emission.autoInc === true,
+		serial: resolved.emission.serial === true,
+		numericString: resolved.emission.numericString === true
+	};
+}
+function resolveScalar(classified, database, dialect) {
+	const emission = resolveEmission(classified, database, dialect);
+	return emission.args === "members" ? {
+		emission,
+		options: [memberOption(classified.setMembers ?? [])]
+	} : applyArguments(emission, builderArguments(classified), dialect);
+}
+function resolveEmission(classified, database, dialect) {
+	const { base, element, setMembers } = classified;
+	const lookup = isMySQLFamily(database) ? base.replace(CHARACTER_ATTRIBUTES, "") : base.replace(SIGN_WORDS, "$1").replace(WHITESPACE, " ").trim();
+	if (lookup === INTERVAL || lookup.startsWith(`${INTERVAL} `)) return intervalEmission(lookup, element, dialect);
+	if (dialect === "mysql" && setMembers !== null) return MYSQL_SET;
+	if (database === Database.MariaDB && lookup === BARE_NUMBER && classified.scalar === "f64") return MYSQL_DOUBLE;
+	const own = DATABASE_TYPES[database]?.get(lookup);
+	const borrowed = DIALECT_BY_DATABASE[database] === void 0;
+	const vendor = borrowed && AMBIGUOUS_NAMES.has(lookup) ? void 0 : VENDOR_TYPES[dialect].get(lookup);
+	const emission = own ?? vendor ?? FALLBACK_TYPES[dialect][getPrimitiveType(element, database)];
+	return borrowed ? widenBorrowed(emission, classified) : emission;
+}
+function widenBorrowed(emission, { bits, scalar }) {
+	if (bits === 64 && (emission === PG_SMALLINT || emission === PG_INTEGER)) return PG_BIGINT;
+	if (scalar === "f64" && emission === PG_REAL) return PG_DOUBLE;
+	if (scalar === "dateTime" && emission === PG_DATE) return PG_TIMESTAMP;
+	if (scalar === "dateTimeUtc" && emission === PG_TIMESTAMP) return PG_TIMESTAMP_TZ;
+	return emission;
+}
+function arrayType(element, depth) {
+	if (depth === 0) return element;
+	return {
+		...element,
+		head: `${element.head}${".array()".repeat(depth)}`,
+		ts: "other",
+		autoInc: false,
+		serial: false,
+		numericString: false
+	};
+}
+function memberOption(members) {
+	return `values: ${memberList(members)}`;
+}
+function intervalEmission(base, element, dialect) {
+	if (dialect === "mysql") return MYSQL_TEXT;
+	if (dialect === "sqlite") return SQLITE_LOB;
+	const fields = base.slice(8).trim();
+	const args = SECONDS_PRECISION.test(element) ? "seconds" : "none";
+	return INTERVAL_FIELDS.has(fields) ? {
+		builder: INTERVAL,
+		ts: "string",
+		args,
+		options: [`fields: "${fields}"`]
+	} : {
+		builder: INTERVAL,
+		ts: "string",
+		args
+	};
+}
+function enumType(members, dialect, property, argument, enumNaming) {
+	if (dialect === "mysql") {
+		const written = members.map((member) => member.replace(BACKSLASH, "\\\\"));
+		return {
+			head: call(MYSQL_ENUM, argument ?? `"${escapeString(property)}"`, [], memberList(written)),
+			builder: MYSQL_ENUM,
+			custom: null,
+			ts: "string",
+			members: written,
+			autoInc: false,
+			serial: false,
+			numericString: false
+		};
+	}
+	if (dialect === "sqlite") return {
+		head: call("text", argument, [`enum: ${memberList(members)}`]),
+		builder: "text",
+		custom: null,
+		ts: "string",
+		members,
+		autoInc: false,
+		serial: false,
+		numericString: false
+	};
+	return {
+		head: call(enumNaming?.constName ?? property, argument, []),
+		builder: null,
+		custom: null,
+		ts: "string",
+		members,
+		autoInc: false,
+		serial: false,
+		numericString: false
+	};
+}
+function memberList(members) {
+	return `[${members.map((member) => `"${escapeString(member)}"`).join(", ")}]`;
+}
+function call(builder, argument, options, extra) {
+	const config = options.length === 0 ? null : `{ ${options.join(", ")} }`;
+	return `${builder}(${[
+		argument,
+		extra ?? null,
+		config
+	].filter((value) => value !== null && value !== void 0).join(", ")})`;
+}
+function applyArguments(emission, args, dialect) {
+	const options = [...emission.options ?? []];
+	const shortest = dialect === "mysql" ? 0 : 1;
+	if ((emission.args === "length" || emission.args === "lengthRequired") && args.length === 1 && args[0] >= shortest) return {
+		emission,
+		options: [...options, `length: ${args[0]}`]
+	};
+	if (emission.args === "lengthRequired") {
+		const degraded = emission.degraded ?? emission;
+		return {
+			emission: degraded,
+			options: [...degraded.options ?? []]
+		};
+	}
+	if (emission.args === "blobLength" && args.length === 1 && args[0] > 0) return {
+		emission: MYSQL_BLOB_SIZES.find(([bytes]) => args[0] <= bytes)?.[1] ?? MYSQL_LONGBLOB,
+		options
+	};
+	if (emission.args === "seconds" && args.length === 1 && args[0] >= 0 && args[0] <= 6) {
+		const key = dialect === "mysql" ? "fsp" : "precision";
+		return {
+			emission,
+			options: [...options, `${key}: ${args[0]}`]
+		};
+	}
+	if (emission.args === "floatPrecision" && args.length === 1) return {
+		emission: args[0] > SINGLE_PRECISION_DIGITS ? MYSQL_DOUBLE : emission,
+		options
+	};
+	if (emission.args === "precision" && args.length === 1) return {
+		emission,
+		options: [...options, `precision: ${args[0]}`]
+	};
+	if ((emission.args === "precision" || emission.args === "floatPrecision" || emission.args === "precisionAndScale") && args.length === 2) return {
+		emission,
+		options: [
+			...options,
+			`precision: ${args[0]}`,
+			`scale: ${args[1]}`
+		]
+	};
+	return {
+		emission,
+		options
+	};
+}
+function builderArguments({ element, args }) {
+	return element.indexOf("(") === element.lastIndexOf("(") && args.every(Number.isSafeInteger) ? args : [];
+}
+function createIndexNames(state) {
+	const { doc: { indexIds, tableIds }, collections } = state;
+	const tableCollection = query(collections).collection("tableEntities");
+	const indexes = query(collections).collection("indexEntities").selectByIds(indexIds);
+	const names = /* @__PURE__ */ new Map();
+	const used = [];
+	const rank = /* @__PURE__ */ new Map();
+	tableCollection.selectByIds(tableIds).sort(orderByNameASC).forEach((table, index) => rank.set(table.id, index));
+	indexes.forEach((index) => {
+		if (index.name.trim() !== "") {
+			names.set(index.id, index.name);
+			used.push({
+				id: index.id,
+				name: index.name
+			});
+		}
+	});
+	indexes.map((index, order) => ({
+		index,
+		order
+	})).filter(({ index }) => index.name.trim() === "").sort((a, b) => (rank.get(a.index.tableId) ?? rank.size) - (rank.get(b.index.tableId) ?? rank.size) || a.order - b.order).forEach(({ index }) => {
+		const table = tableCollection.selectById(index.tableId);
+		const name = autoName(used, "", `IDX_${table?.name ?? ""}`);
+		used.push({
+			id: index.id,
+			name
+		});
+		names.set(index.id, name);
+	});
+	return names;
+}
+function createSchemaContext(state) {
+	const { settings: { database } } = state;
+	const dialect = DIALECT_BY_DATABASE[database] ?? FALLBACK_DIALECT;
+	const relationships = resolveRelationships(state);
+	const tables = query(state.collections).collection("tableEntities").selectByIds(state.doc.tableIds).sort(orderByNameASC);
+	const context = {
+		database,
+		dialect,
+		actionSupport: referentialActionSupport(DIALECT_BY_DATABASE[database] === void 0 ? Database.PostgreSQL : database),
+		indexNames: createIndexNames(state),
+		relationships,
+		namings: /* @__PURE__ */ new Map(),
+		moduleNames: /* @__PURE__ */ new Set([
+			...CORE_NAMES,
+			...DIALECT_NAMES[dialect],
+			...GLOBAL_NAMES,
+			ANY_COLUMN[dialect],
+			EXTRA_CONFIG_VALUE[dialect]
+		]),
+		enumTypeNames: new Set(tables.map((table) => table.name)),
+		aliases: /* @__PURE__ */ new Map(),
+		inlined: /* @__PURE__ */ new Set(),
+		cyclic: /* @__PURE__ */ new Set(),
+		annotated: /* @__PURE__ */ new Set()
+	};
+	reserveCustomTypeNames(state, tables, context);
+	tables.forEach((table) => getNaming(state, context, table));
+	planReferences(state, context);
+	createAliases(state, context);
+	return context;
+}
+function reserveCustomTypeNames({ collections }, tables, { database, dialect, moduleNames }) {
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	tables.forEach((table) => columnCollection.selectByIds(table.columnIds).forEach((column) => {
+		const classified = getColumnType$1(column.dataType, database);
+		const custom = classified.enumMembers === null ? resolveScalar(classified, database, dialect).emission.custom : void 0;
+		if (custom !== void 0) moduleNames.add(custom.name);
+	}));
+}
+function createAliases(state, context) {
+	const counts = /* @__PURE__ */ new Map();
+	context.relationships.forEach(({ relationship }) => {
+		const key = pairKey(relationship);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	});
+	const used = /* @__PURE__ */ new Set();
+	context.relationships.forEach(({ relationship, endTable }) => {
+		if (!isSelfReferential(relationship) && (counts.get(pairKey(relationship)) ?? 0) < 2) return;
+		const naming = getNaming(state, context, endTable);
+		const property = naming.relationshipNames.get(relationshipKey(relationship, OWNING));
+		if (property === void 0) return;
+		context.aliases.set(relationship.id, uniqueName(used, `${naming.constName}_${property}`));
+	});
+}
+function pairKey({ start, end }) {
+	return [start.tableId, end.tableId].sort().join(":");
+}
+function resolveRelationships(state) {
+	const { doc: { relationshipIds, tableIds }, collections } = state;
+	const tableCollection = query(collections).collection("tableEntities");
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const documentTableIds = new Set(tableIds);
+	return query(collections).collection("relationshipEntities").selectByIds(relationshipIds).map((relationship) => {
+		const startTable = tableCollection.selectById(relationship.start.tableId);
+		const endTable = tableCollection.selectById(relationship.end.tableId);
+		const startColumns = columnCollection.selectByIds(relationship.start.columnIds);
+		const endColumns = columnCollection.selectByIds(relationship.end.columnIds);
+		return !startTable || !endTable || !documentTableIds.has(startTable.id) || !documentTableIds.has(endTable.id) || endColumns.length === 0 || startColumns.length !== relationship.start.columnIds.length || endColumns.length !== relationship.end.columnIds.length || startColumns.length !== endColumns.length || !startColumns.every((column) => startTable.columnIds.includes(column.id)) || !endColumns.every((column) => endTable.columnIds.includes(column.id)) ? null : {
+			relationship,
+			startTable,
+			endTable,
+			startColumns,
+			endColumns
+		};
+	}).filter((resolved) => resolved !== null);
+}
+function getNaming(state, context, table) {
+	const cached = context.namings.get(table.id);
+	if (cached) return cached;
+	const naming = createTableNaming(state, table, context);
+	context.namings.set(table.id, naming);
+	return naming;
+}
+var PROTOTYPE_KEY = "__proto__";
+var TABLE_MEMBER_NAMES = [
+	"$inferInsert",
+	"$inferSelect",
+	"_",
+	PROTOTYPE_KEY,
+	"enableRLS",
+	"getSQL"
+];
+var RELATIONS_SUFFIX = "Relations";
+function createTableNaming(state, table, context) {
+	const { settings: { tableNameCase, columnNameCase }, collections } = state;
+	const { relationships, moduleNames, enumTypeNames, dialect, database } = context;
+	const used = new Set(TABLE_MEMBER_NAMES);
+	const relationUsed = /* @__PURE__ */ new Set([PROTOTYPE_KEY]);
+	const declared = [];
+	const columnRefs = /* @__PURE__ */ new Map();
+	const columnNames = /* @__PURE__ */ new Map();
+	const relationshipNames = /* @__PURE__ */ new Map();
+	const enumNames = /* @__PURE__ */ new Map();
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const carriers = /* @__PURE__ */ new Map();
+	columns.forEach((column) => {
+		const carrier = carriers.get(column.name);
+		if (carrier !== void 0) {
+			columnRefs.set(column.id, carrier);
+			return;
+		}
+		carriers.set(column.name, column.id);
+		columnRefs.set(column.id, column.id);
+		declared.push(column);
+		columnNames.set(column.id, uniqueName(used, tsIdentifier(getNameCase(column.name, columnNameCase))));
+	});
+	columns.forEach((column) => {
+		const carrier = columnRefs.get(column.id);
+		if (carrier === void 0 || carrier === column.id) return;
+		const name = columnNames.get(carrier);
+		if (name !== void 0) columnNames.set(column.id, name);
+	});
+	const constName = uniqueName(moduleNames, tsIdentifier(getNameCase(table.name, tableNameCase)));
+	if (dialect === "pg") declared.forEach((column) => {
+		if (getColumnType$1(column.dataType, database).enumMembers === null) return;
+		enumNames.set(column.id, {
+			constName: uniqueName(moduleNames, tsIdentifier(`${getNameCase(`${table.name}_${column.name}_enum`, tableNameCase)}`)),
+			typeName: uniqueName(enumTypeNames, `${table.name}_${column.name}`)
+		});
+	});
+	relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach(({ relationship, startTable, endColumns }) => {
+		if (endColumns.length !== 1 || !hasOneRelationship(relationship.relationshipType) && !hasNRelationship(relationship.relationshipType)) return;
+		const name = isSelfReferential(relationship) ? `parent_${startTable.name}` : startTable.name;
+		relationshipNames.set(relationshipKey(relationship, OWNING), uniqueName(relationUsed, tsIdentifier(getNameCase(name, columnNameCase))));
+	});
+	relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable, endColumns }) => {
+		const name = endColumns.length !== 1 ? null : hasNRelationship(relationship.relationshipType) ? getNameCase(`${endTable.name}List`, columnNameCase) : hasOneRelationship(relationship.relationshipType) ? getNameCase(endTable.name, columnNameCase) : null;
+		if (name === null) return;
+		relationshipNames.set(relationshipKey(relationship, INVERSE), uniqueName(relationUsed, tsIdentifier(name)));
+	});
+	return {
+		constName,
+		relationsName: uniqueName(moduleNames, `${constName}${RELATIONS_SUFFIX}`),
+		columnIds: declared.map((column) => column.id),
+		carriers: columnRefs,
+		columnNames,
+		relationshipNames,
+		enumNames
+	};
+}
+function relationshipKey(relationship, side) {
+	return `${relationship.id}:${side}`;
+}
+function isSelfReferential(relationship) {
+	return relationship.start.tableId === relationship.end.tableId;
+}
+function uniqueName(used, name) {
+	let result = name;
+	let index = 2;
+	while (used.has(result)) {
+		result = `${name}${index}`;
+		index += 1;
+	}
+	used.add(result);
+	return result;
+}
+var NON_IDENTIFIER = /[^$0-9A-Za-z_]/g;
+var IDENTIFIER_START = /^[$A-Za-z_]/;
+var RESERVED = /* @__PURE__ */ new Set([
+	"arguments",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"constructor",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+var SAFE_PREFIX = "x";
+function tsIdentifier(name) {
+	const value = name.replace(NON_IDENTIFIER, "_");
+	const identifier = IDENTIFIER_START.test(value) ? value : `${SAFE_PREFIX}${value}`;
+	return RESERVED.has(identifier) ? `${identifier}_` : identifier;
+}
+var BACKSLASH = /\\/g;
+var DOUBLE_QUOTE = /"/g;
+var LINE_BREAK = /[\n\r\u2028\u2029]/g;
+var BACKTICK = /`/g;
+var INTERPOLATION = /\$\{/g;
+var LINE_BREAK_ESCAPES = {
+	"\n": "\\n",
+	"\r": "\\r",
+	"\u2028": "\\u2028",
+	"\u2029": "\\u2029"
+};
+function escapeLineBreak(value) {
+	return value.replace(LINE_BREAK, (char) => LINE_BREAK_ESCAPES[char]);
+}
+function escapeString(value) {
+	return escapeLineBreak(value.replace(BACKSLASH, "\\\\").replace(DOUBLE_QUOTE, "\\\""));
+}
+function escapeTemplate(value) {
+	return escapeLineBreak(value.replace(BACKSLASH, "\\\\").replace(BACKTICK, "\\`").replace(INTERPOLATION, "\\$&"));
+}
+//#endregion
+export { createCode, formatTable };