@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,998 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database, NameCase, ReferentialAction } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoName, orderByNameASC } from "../tableName.js";
+import { referentialActionSupport } from "../schema-sql/utils.js";
+import { getNameCase, getPrimitiveType, hasNRelationship, hasOneRelationship, referentialActionEntries } from "./utils.js";
+import { BINARY_TYPES, JSON_TYPES, POSTGRES_BIT_TYPES, UUID_TYPES, getColumnType as getColumnType$1, isMySQLFamily } from "./columnTypes.js";
+//#region src/utils/generator-code/typeorm.ts
+var TYPEORM_NAMES = [
+	"Column",
+	"Entity",
+	"Index",
+	"JoinColumn",
+	"ManyToOne",
+	"OneToMany",
+	"OneToOne",
+	"PrimaryColumn",
+	"PrimaryGeneratedColumn",
+	"Relation"
+];
+var GLOBAL_NAMES = [
+	"Array",
+	"Boolean",
+	"Buffer",
+	"Date",
+	"Number",
+	"Object",
+	"Reflect",
+	"String",
+	"__decorate",
+	"__metadata",
+	"__dirname",
+	"__esModule",
+	"__filename",
+	"__proto__",
+	"exports",
+	"module",
+	"require"
+];
+var THENABLE_NAMES = ["then"];
+var OBJECT_MEMBERS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf"
+]);
+var PROTOTYPE_NAMES = [
+	...OBJECT_MEMBERS,
+	"__defineGetter__",
+	"__defineSetter__",
+	"__lookupGetter__",
+	"__lookupSetter__"
+];
+var MODULE_SCOPE_NAMES = /* @__PURE__ */ new Set([
+	...TYPEORM_NAMES,
+	...GLOBAL_NAMES,
+	...THENABLE_NAMES,
+	...PROTOTYPE_NAMES
+]);
+var convertTypeMap = {
+	int: "number",
+	long: "number",
+	float: "number",
+	double: "number",
+	decimal: "string",
+	boolean: "boolean",
+	string: "string",
+	lob: "string",
+	date: "string",
+	dateTime: "Date",
+	time: "string"
+};
+var bigintTypes = /* @__PURE__ */ new Set([
+	"bigint",
+	"bigserial",
+	"int8",
+	"long",
+	"serial",
+	"serial8",
+	"unsigned big int"
+]);
+var NUMBER_DECIMAL_DATABASES = /* @__PURE__ */ new Set([
+	Database.MSSQL,
+	Database.Oracle,
+	Database.SQLite
+]);
+var objectTypes = /* @__PURE__ */ new Map([[Database.Oracle, /* @__PURE__ */ new Set([
+	"bfile",
+	"interval day to second",
+	"interval year to month"
+])], [Database.PostgreSQL, /* @__PURE__ */ new Set([
+	"circle",
+	"interval",
+	"point"
+])]]);
+var vectorAnnotations = /* @__PURE__ */ new Map([
+	[Database.MariaDB, "Buffer"],
+	[Database.MSSQL, "number[]"],
+	[Database.MySQL, "number[]"],
+	[Database.PostgreSQL, "number[]"]
+]);
+var postgresTemporalTypes = /* @__PURE__ */ new Set([
+	"interval",
+	"time",
+	"time with time zone",
+	"time without time zone",
+	"timestamp",
+	"timestamp with time zone",
+	"timestamp without time zone"
+]);
+var POSTGRES_MAX_TIME_PRECISION = 6;
+var postgresSerialTypes = /* @__PURE__ */ new Map([
+	["bigserial", "bigint"],
+	["serial", "int"],
+	["serial2", "smallint"],
+	["serial4", "int"],
+	["serial8", "bigint"],
+	["smallserial", "smallint"]
+]);
+var postgresParsedArrayTypes = /* @__PURE__ */ new Set([
+	"bigint",
+	"bool",
+	"boolean",
+	"bpchar",
+	"bytea",
+	"char",
+	"character",
+	"character varying",
+	"cidr",
+	"date",
+	"decimal",
+	"double precision",
+	"float",
+	"float4",
+	"float8",
+	"inet",
+	"int",
+	"int2",
+	"int4",
+	"int8",
+	"integer",
+	"json",
+	"jsonb",
+	"macaddr",
+	"money",
+	"numeric",
+	"numrange",
+	"oid",
+	"point",
+	"real",
+	"regproc",
+	"smallint",
+	"text",
+	"time",
+	"time with time zone",
+	"time without time zone",
+	"timestamp",
+	"timestamp with time zone",
+	"timestamp without time zone",
+	"timestamptz",
+	"timetz",
+	"uuid",
+	"varchar"
+]);
+var postgresZonedTypes = /* @__PURE__ */ new Map([["timestamptz", "timestamp with time zone"], ["timetz", "time with time zone"]]);
+var integerTypes = /* @__PURE__ */ new Set([
+	"bigint",
+	"int",
+	"integer",
+	"mediumint",
+	"smallint",
+	"tinyint"
+]);
+var unsignedFractionalTypes = /* @__PURE__ */ new Set([
+	"dec",
+	"decimal",
+	"double",
+	"double precision",
+	"fixed",
+	"float",
+	"numeric",
+	"real"
+]);
+var sizedObjectTypes = /* @__PURE__ */ new Set([
+	"bit",
+	"bit varying",
+	"interval",
+	"varbit"
+]);
+var MAX_LENGTH_TYPES = /* @__PURE__ */ new Set([
+	"nvarchar",
+	"varbinary",
+	"varchar"
+]);
+var MAX_ARGUMENT = /^[^(]*\(\s*max\s*\)/i;
+var INTERVAL = /^interval\b/;
+var SIGN_WORDS = /(^|[^0-9A-Za-z_])(?:unsigned|zerofill|signed)(?![0-9A-Za-z_])/gi;
+var SECONDS_PRECISION = /^\s*interval\s*\(\s*(\d+)\s*\)\s*$|\bsecond\s*\(\s*(\d+)\s*\)\s*$/i;
+var mysqlSynonymTypes = /* @__PURE__ */ new Map([
+	["char varying", "varchar"],
+	["character", "char"],
+	["character varying", "varchar"],
+	["float4", "float"],
+	["float8", "double"],
+	["geomcollection", "geometrycollection"],
+	["int1", "tinyint"],
+	["int2", "smallint"],
+	["int3", "mediumint"],
+	["int4", "int"],
+	["int8", "bigint"],
+	["long", "mediumtext"],
+	["long char varying", "mediumtext"],
+	["long character varying", "mediumtext"],
+	["long varbinary", "mediumblob"],
+	["long varchar", "mediumtext"],
+	["long varcharacter", "mediumtext"],
+	["middleint", "mediumint"],
+	["national character", "national char"],
+	["sql_tsi_year", "year"]
+]);
+var mssqlSynonymTypes = /* @__PURE__ */ new Map([
+	["char varying", "varchar"],
+	["character", "char"],
+	["character varying", "varchar"],
+	["national char", "nchar"],
+	["national char varying", "nvarchar"],
+	["national character", "nchar"],
+	["national character varying", "nvarchar"],
+	["national text", "ntext"]
+]);
+var oracleSynonymTypes = /* @__PURE__ */ new Map([
+	["char varying", "varchar2"],
+	["character", "char"],
+	["character varying", "varchar2"],
+	["long varchar", "long"],
+	["national char", "nchar"],
+	["national char varying", "nvarchar2"],
+	["national character", "nchar"],
+	["national character varying", "nvarchar2"],
+	["nchar varying", "nvarchar2"]
+]);
+var postgresSynonymTypes = /* @__PURE__ */ new Map([["dec", "decimal"]]);
+var sqliteTypes = /* @__PURE__ */ new Map([
+	["bool", "boolean"],
+	["dec", "decimal"],
+	["timestamp", "datetime"]
+]);
+var synonymTypes = /* @__PURE__ */ new Map([
+	[Database.MariaDB, mysqlSynonymTypes],
+	[Database.MSSQL, mssqlSynonymTypes],
+	[Database.MySQL, mysqlSynonymTypes],
+	[Database.Oracle, oracleSynonymTypes],
+	[Database.PostgreSQL, postgresSynonymTypes],
+	[Database.SQLite, sqliteTypes]
+]);
+var generatedNumericTypes = /* @__PURE__ */ new Set([
+	"bigint",
+	"dec",
+	"decimal",
+	"fixed",
+	"int",
+	"int2",
+	"int4",
+	"int8",
+	"integer",
+	"mediumint",
+	"number",
+	"numeric",
+	"smalldecimal",
+	"smallint",
+	"tinyint"
+]);
+var withLengthTypes = /* @__PURE__ */ new Set([
+	"alphanum",
+	"binary",
+	"char",
+	"char varying",
+	"character",
+	"character varying",
+	"half_vector",
+	"halfvec",
+	"national char",
+	"national varchar",
+	"native character",
+	"nchar",
+	"nvarchar",
+	"nvarchar2",
+	"raw",
+	"real_vector",
+	"shorttext",
+	"string",
+	"varbinary",
+	"varchar",
+	"varchar2",
+	"varying character",
+	"vector"
+]);
+var withPrecisionTypes = /* @__PURE__ */ new Set([
+	"datetime",
+	"datetime2",
+	"datetimeoffset",
+	"dec",
+	"decimal",
+	"double",
+	"double precision",
+	"fixed",
+	"float",
+	"number",
+	"numeric",
+	"real",
+	"smalldecimal",
+	"time",
+	"time with time zone",
+	"time without time zone",
+	"timestamp",
+	"timestamp with local time zone",
+	"timestamp with time zone",
+	"timestamp without time zone"
+]);
+var columnTypes = /* @__PURE__ */ new Set([
+	...withLengthTypes,
+	...withPrecisionTypes,
+	"array",
+	"bfile",
+	"bigint",
+	"bit",
+	"bit varying",
+	"blob",
+	"bool",
+	"boolean",
+	"box",
+	"bytea",
+	"bytes",
+	"cidr",
+	"circle",
+	"citext",
+	"clob",
+	"cube",
+	"date",
+	"datemultirange",
+	"daterange",
+	"enum",
+	"float4",
+	"float64",
+	"float8",
+	"geography",
+	"geometry",
+	"geometrycollection",
+	"hierarchyid",
+	"hstore",
+	"image",
+	"inet",
+	"inet4",
+	"inet6",
+	"int",
+	"int2",
+	"int4",
+	"int4multirange",
+	"int4range",
+	"int64",
+	"int8",
+	"int8multirange",
+	"int8range",
+	"integer",
+	"interval",
+	"interval day to second",
+	"interval year to month",
+	"json",
+	"jsonb",
+	"jsonpath",
+	"line",
+	"linestring",
+	"long",
+	"long raw",
+	"longblob",
+	"longtext",
+	"lseg",
+	"ltree",
+	"macaddr",
+	"macaddr8",
+	"mediumblob",
+	"mediumint",
+	"mediumtext",
+	"money",
+	"multilinestring",
+	"multipoint",
+	"multipolygon",
+	"nclob",
+	"ntext",
+	"nummultirange",
+	"numrange",
+	"path",
+	"point",
+	"polygon",
+	"rowid",
+	"rowversion",
+	"seconddate",
+	"set",
+	"simple-array",
+	"simple-enum",
+	"simple-json",
+	"smalldatetime",
+	"smallint",
+	"smallmoney",
+	"sql_variant",
+	"st_geometry",
+	"st_point",
+	"text",
+	"timestamptz",
+	"timetz",
+	"tinyblob",
+	"tinyint",
+	"tinytext",
+	"tsmultirange",
+	"tsquery",
+	"tsrange",
+	"tstzmultirange",
+	"tstzrange",
+	"tsvector",
+	"uniqueidentifier",
+	"unsigned big int",
+	"urowid",
+	"uuid",
+	"varbit",
+	"xml",
+	"year"
+]);
+var fallbackTypeMap = {
+	int: "int",
+	long: "bigint",
+	float: "float",
+	double: "double precision",
+	decimal: "decimal",
+	boolean: "boolean",
+	string: "varchar",
+	lob: "text",
+	date: "date",
+	dateTime: "timestamp",
+	time: "time"
+};
+var LINE_LIMIT = 80;
+var INDENT = "  ";
+var OWNING = "owning";
+var INVERSE = "inverse";
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+	if (tables.length === 0) return "";
+	const stringBuffer = [""];
+	const context = createClassContext(state);
+	tables.forEach((table, index) => {
+		if (index !== 0) stringBuffer.push("");
+		formatClass(state, {
+			buffer: stringBuffer,
+			table
+		}, context);
+	});
+	stringBuffer.push("");
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	formatClass(state, {
+		buffer,
+		table
+	}, createClassContext(state));
+}
+function formatClass(state, { buffer, table }, context) {
+	const { collections } = state;
+	const naming = getNaming(state, context, table);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(naming.columnIds);
+	createIndexEntries(state, table, naming, context).forEach((entry) => formatIndex(buffer, entry));
+	formatDecorator(buffer, "", "Entity", [`"${escapeString(table.name)}"`], {
+		open: "{",
+		entries: table.comment.trim() === "" ? [] : [`comment: "${escapeString(table.comment)}"`]
+	});
+	const bodyBuffer = [];
+	columns.forEach((column) => {
+		formatColumn(state, {
+			buffer: bodyBuffer,
+			column
+		}, { attribute: naming.columnNames.get(column.id) ?? column.name });
+	});
+	formatRelation(state, {
+		buffer: bodyBuffer,
+		table
+	}, context);
+	if (bodyBuffer.length === 0) {
+		buffer.push(`export class ${naming.className} {}`);
+		return;
+	}
+	buffer.push(`export class ${naming.className} {`);
+	bodyBuffer.forEach((line) => buffer.push(line));
+	buffer.push("}");
+}
+function formatColumn({ settings: { database } }, { buffer, column }, { attribute }) {
+	const columnType = getColumnType(column.dataType, database);
+	const { type, annotation, args, typeInOptions, isUnsigned, isSerial } = columnType;
+	const typed = `"${escapeString(type)}"`;
+	const typeArg = typeInOptions ? [] : [typed];
+	const typeEntry = typeInOptions ? [`type: ${typed}`] : [];
+	const isPrimaryKey = bHas(column.options, ColumnOption.primaryKey);
+	const isAutoIncrement = isSerial || bHas(column.options, ColumnOption.autoIncrement);
+	const isNumbered = isAutoIncrement && database !== Database.SQLite;
+	const isNullable = !isPrimaryKey && !isNumbered && !bHas(column.options, ColumnOption.notNull);
+	const isGeneratedKey = isPrimaryKey && isAutoIncrement && takesGeneratedKey(columnType, database);
+	const memberBuffer = [];
+	let generatedAnnotation = annotation;
+	const named = attribute === column.name ? [] : [`name: "${escapeString(column.name)}"`];
+	const comment = column.comment.trim() === "" ? [] : [`comment: "${escapeString(column.comment)}"`];
+	const defaulted = isAutoIncrement || column.default.trim() === "" ? [] : [`default: () => "${escapeString(column.default)}"`];
+	if (isGeneratedKey) {
+		const isUuid = UUID_TYPES.has(type);
+		const numeric = !isUuid && generatedNumericTypes.has(type) ? [`type: ${typed}`] : [];
+		const unsigned = numeric.length !== 0 && isUnsigned ? ["unsigned: true"] : [];
+		generatedAnnotation = isUuid ? "string" : numeric.length === 0 ? "number" : annotation;
+		formatDecorator(memberBuffer, INDENT, "PrimaryGeneratedColumn", isUuid ? ["\"uuid\""] : [], {
+			open: "{",
+			entries: [
+				...numeric,
+				...unsigned,
+				...named,
+				...comment
+			]
+		});
+	} else {
+		const decorator = isPrimaryKey ? "PrimaryColumn" : "Column";
+		const generated = isAutoIncrement ? ["generated: \"increment\""] : [];
+		const constraints = isPrimaryKey ? [] : [...isNullable ? ["nullable: true"] : [], ...bHas(column.options, ColumnOption.unique) || isSerial && isMySQLFamily(database) ? ["unique: true"] : []];
+		formatDecorator(memberBuffer, INDENT, decorator, typeArg, {
+			open: "{",
+			entries: [
+				...typeEntry,
+				...named,
+				...args,
+				...generated,
+				...constraints,
+				...defaulted,
+				...comment
+			]
+		});
+	}
+	memberBuffer.push(`${INDENT}${attribute}: ${generatedAnnotation}${isNullable ? " | null" : ""};`);
+	pushMember(buffer, memberBuffer);
+}
+function takesGeneratedKey({ type, isSized, isArray }, database) {
+	const isNumeric = generatedNumericTypes.has(type);
+	if (isSized && isNumeric) return false;
+	return database !== Database.PostgreSQL || !isArray && (isNumeric || UUID_TYPES.has(type));
+}
+function formatRelation(state, { buffer, table }, context) {
+	const naming = getNaming(state, context, table);
+	context.relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach(({ relationship, startTable, startColumns, endColumns }) => {
+		const attribute = naming.relationshipNames.get(relationshipKey(relationship, OWNING));
+		if (!attribute) return;
+		const parentNaming = getNaming(state, context, startTable);
+		const decorator = hasNRelationship(relationship.relationshipType) ? "ManyToOne" : "OneToOne";
+		const isRequired = carriedColumns(state, naming, endColumns).every((column) => bHas(column.options, ColumnOption.primaryKey) || bHas(column.options, ColumnOption.notNull));
+		const memberBuffer = [];
+		formatDecorator(memberBuffer, INDENT, decorator, relationArguments(parentNaming, startTable, relationship, INVERSE), {
+			open: "{",
+			entries: relationOptions(state, relationship)
+		});
+		formatDecorator(memberBuffer, INDENT, "JoinColumn", [], {
+			open: "[",
+			entries: endColumns.map((column, index) => {
+				const referenced = parentNaming.columnNames.get(startColumns[index].id) ?? startColumns[index].name;
+				return `{ name: "${escapeString(column.name)}", referencedColumnName: "${escapeString(referenced)}" }`;
+			})
+		});
+		memberBuffer.push(`${INDENT}${attribute}: Relation<${parentNaming.className}>${isRequired ? "" : " | null"};`);
+		pushMember(buffer, memberBuffer);
+	});
+	context.relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable }) => {
+		const attribute = naming.relationshipNames.get(relationshipKey(relationship, INVERSE));
+		if (!attribute) return;
+		const childNaming = getNaming(state, context, endTable);
+		const isMany = hasNRelationship(relationship.relationshipType);
+		const decorator = isMany ? "OneToMany" : "OneToOne";
+		const memberBuffer = [];
+		formatDecorator(memberBuffer, INDENT, decorator, relationArguments(childNaming, endTable, relationship, OWNING));
+		memberBuffer.push(`${INDENT}${attribute}: ${isMany ? `${childNaming.className}[]` : `Relation<${childNaming.className}> | null`};`);
+		pushMember(buffer, memberBuffer);
+	});
+}
+function relationOptions(state, relationship) {
+	return referentialActionEntries(relationship, referentialActionSupport(state.settings.database)).filter(({ action }) => action !== ReferentialAction.setDefault).map(({ key, sql }) => `${key}: "${sql}"`);
+}
+function relationArguments(targetNaming, targetTable, relationship, side) {
+	const args = [`() => ${targetNaming.className}`];
+	const inverse = targetNaming.relationshipNames.get(relationshipKey(relationship, side));
+	if (inverse) {
+		const parameter = tsIdentifier(getNameCase(targetTable.name, NameCase.camelCase));
+		args.push(`(${parameter}) => ${parameter}.${inverse}`);
+	}
+	return args;
+}
+function createIndexEntries(state, table, naming, { indexNames }) {
+	const { doc: { indexIds }, collections } = state;
+	const entries = [];
+	query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id).forEach((index) => {
+		const names = Array.from(new Set(query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).map((indexColumn) => naming.columnNames.get(indexColumn.columnId)).filter((name) => name !== void 0)));
+		if (names.length === 0) return;
+		entries.push({
+			name: `"${escapeString(indexNames.get(index.id) ?? index.name)}"`,
+			columns: names.map((name) => `"${escapeString(name)}"`),
+			options: index.unique ? ["unique: true"] : []
+		});
+	});
+	return entries;
+}
+function formatIndex(buffer, { name, columns, options }) {
+	if (options.length === 0) {
+		formatDecorator(buffer, "", "Index", [name], {
+			open: "[",
+			entries: columns
+		});
+		return;
+	}
+	formatDecorator(buffer, "", "Index", [name, `[${columns.join(", ")}]`], {
+		open: "{",
+		entries: options
+	});
+}
+function pushMember(buffer, lines) {
+	if (buffer.length !== 0) buffer.push("");
+	lines.forEach((line) => buffer.push(line));
+}
+function formatDecorator(buffer, indent, name, args, group) {
+	const trailing = group && group.entries.length !== 0 ? group : void 0;
+	const rendered = trailing ? trailing.open === "[" ? `[${trailing.entries.join(", ")}]` : `{ ${trailing.entries.join(", ")} }` : null;
+	const all = rendered === null ? args : [...args, rendered];
+	const line = `${indent}@${name}(${all.join(", ")})`;
+	if (line.length <= LINE_LIMIT) {
+		buffer.push(line);
+		return;
+	}
+	const head = trailing ? `${indent}@${name}(${[...args, trailing.open].join(", ")}` : null;
+	if (trailing && head !== null && head.length <= LINE_LIMIT) {
+		buffer.push(head);
+		trailing.entries.forEach((entry) => buffer.push(`${indent}${INDENT}${entry},`));
+		buffer.push(`${indent}${trailing.open === "[" ? "]" : "}"})`);
+		return;
+	}
+	if (all.length > 1) {
+		buffer.push(`${indent}@${name}(`);
+		all.forEach((arg) => buffer.push(`${indent}${INDENT}${arg},`));
+		buffer.push(`${indent})`);
+		return;
+	}
+	buffer.push(line);
+}
+function getColumnType(dataType, database) {
+	const facts = getColumnType$1(dataType, database);
+	if (facts.base === "") return {
+		type: database === Database.MSSQL ? "nvarchar" : "varchar",
+		annotation: "string",
+		args: [],
+		typeInOptions: false,
+		isSized: false,
+		isArray: false,
+		isUnsigned: false,
+		isSerial: false
+	};
+	const element = elementColumn(facts, database);
+	if (facts.arrayDepth === 0) return element;
+	return {
+		...element,
+		annotation: arrayAnnotation(facts, element),
+		args: [...element.args, "array: true"],
+		isArray: true
+	};
+}
+function arrayAnnotation({ base, arrayDepth }, { type, annotation }) {
+	const stored = postgresSynonymTypes.get(base) ?? base;
+	if (type !== "enum" && !INTERVAL.test(stored) && !postgresParsedArrayTypes.has(stored)) return "string";
+	const element = stored === "date" ? "Date" : stored === "decimal" || stored === "numeric" ? "number" : annotation;
+	return `${element.includes(" ") ? `(${element})` : element}${"[]".repeat(arrayDepth)}`;
+}
+function elementColumn(facts, database) {
+	const { base, element, enumMembers, setMembers } = facts;
+	const members = enumMembers ?? setMembers;
+	if (members) {
+		const quoted = members.map(stringLiteral);
+		const union = quoted.join(" | ");
+		const isSet = enumMembers === null;
+		return {
+			type: isSet ? "set" : "enum",
+			annotation: isSet ? `(${union})[]` : union,
+			args: [`enum: [${quoted.join(", ")}]`],
+			typeInOptions: false,
+			isSized: false,
+			isArray: false,
+			isUnsigned: false,
+			isSerial: false
+		};
+	}
+	const primitiveType = getPrimitiveType(synonymTypes.get(database)?.get(base) ?? (isMySQLFamily(database) ? element.replace(SIGN_WORDS, "$1") : element), database);
+	const type = vendorType(facts, database) ?? (columnTypes.has(base) ? base : fallbackType(base, primitiveType));
+	const isUnsigned = facts.isUnsigned && (integerTypes.has(type) || unsignedFractionalTypes.has(type));
+	const sized = floatWidth(facts, database) === null ? sizeArguments(type, facts, database) : [];
+	return {
+		type,
+		annotation: getAnnotation(facts, type, primitiveType, database),
+		args: [...sized, ...isUnsigned ? ["unsigned: true"] : []],
+		typeInOptions: sized.length !== 0 && sizedObjectTypes.has(type) || isUnsigned && unsignedFractionalTypes.has(type),
+		isSized: sized.length !== 0,
+		isArray: false,
+		isUnsigned,
+		isSerial: facts.isSerial
+	};
+}
+function vendorType(facts, database) {
+	const { base, args, arrayDepth } = facts;
+	const width = floatWidth(facts, database);
+	const isSingle = width !== null && width <= 24;
+	if (database === Database.PostgreSQL) {
+		if (INTERVAL.test(base)) return "interval";
+		if (width !== null) return isSingle ? "real" : "double precision";
+		return (args.length === 0 || arrayDepth !== 0 ? void 0 : postgresZonedTypes.get(base)) ?? postgresSerialTypes.get(base) ?? postgresSynonymTypes.get(base) ?? null;
+	}
+	if (width !== null) {
+		if (database === Database.MSSQL) return isSingle ? "real" : "float";
+		return isSingle ? "float" : "double";
+	}
+	return synonymTypes.get(database)?.get(base) ?? null;
+}
+function floatWidth({ base, args }, database) {
+	if (args.length !== 1 || args[0] > 53) return null;
+	if (isMySQLFamily(database)) return base === "float" || base === "float4" ? args[0] : null;
+	return base === "float" && args[0] >= 1 && (database === Database.PostgreSQL || database === Database.MSSQL) ? args[0] : null;
+}
+function sizeArguments(type, { args, element, arrayDepth, length, precision, scale }, database) {
+	if (database === Database.MSSQL && MAX_LENGTH_TYPES.has(type) && MAX_ARGUMENT.test(element)) return ["length: \"MAX\""];
+	const hasLength = args.length === 1 && args[0] > 0;
+	const unitLength = args.length === 0 && length !== null && length > 0;
+	if ((hasLength || unitLength) && withLengthTypes.has(type)) return [`length: ${hasLength ? args[0] : length}`];
+	if (database === Database.PostgreSQL) {
+		if (hasLength && POSTGRES_BIT_TYPES.has(type)) return [`length: ${args[0]}`];
+		if (postgresTemporalTypes.has(type)) {
+			const seconds = SECONDS_PRECISION.exec(element);
+			const stated = type !== "interval" ? args.length === 1 ? args[0] : null : seconds ? Number(seconds[1] ?? seconds[2]) : null;
+			return arrayDepth !== 0 || stated === null ? [] : [`precision: ${Math.min(stated, POSTGRES_MAX_TIME_PRECISION)}`];
+		}
+	}
+	if (withPrecisionTypes.has(type) && args.length === 1) return [`precision: ${args[0]}`];
+	if (withPrecisionTypes.has(type) && args.length === 2) return [`precision: ${args[0]}`, `scale: ${args[1]}`];
+	if (withPrecisionTypes.has(type) && args.length === 0 && scale !== null) return [`precision: ${precision}`, `scale: ${scale}`];
+	return [];
+}
+function fallbackType(base, primitiveType) {
+	if (base === "char byte") return "binary";
+	if (BINARY_TYPES.has(base)) return "varbinary";
+	if (primitiveType === "long" && !bigintTypes.has(base)) return "int";
+	return fallbackTypeMap[primitiveType];
+}
+function getAnnotation({ base, isRowVersion, isTextInteger }, type, primitiveType, database) {
+	if (type === "date") return "string";
+	if (JSON_TYPES.has(base) || objectTypes.get(database)?.has(type)) return "object";
+	if (BINARY_TYPES.has(base) || isRowVersion || isMySQLFamily(database) && base === "bit" || database === Database.MSSQL && base === "hierarchyid") return "Buffer";
+	const vector = type === "vector" || type === "halfvec" && database === Database.PostgreSQL ? vectorAnnotations.get(database) : void 0;
+	if (vector !== void 0) return vector;
+	if (isTextInteger) return "string";
+	if (primitiveType === "long" && bigintTypes.has(base) && database !== Database.SQLite) return "string";
+	if (primitiveType === "decimal" && NUMBER_DECIMAL_DATABASES.has(database)) return "number";
+	return convertTypeMap[primitiveType];
+}
+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 createClassContext(state) {
+	const context = {
+		indexNames: createIndexNames(state),
+		relationships: resolveRelationships(state),
+		namings: /* @__PURE__ */ new Map(),
+		classNames: new Set(MODULE_SCOPE_NAMES)
+	};
+	query(state.collections).collection("tableEntities").selectByIds(state.doc.tableIds).sort(orderByNameASC).forEach((table) => getNaming(state, context, table));
+	return context;
+}
+function resolveRelationships(state) {
+	const { doc: { relationshipIds }, collections } = state;
+	const tableCollection = query(collections).collection("tableEntities");
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	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 || 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;
+}
+function createTableNaming(state, table, { relationships, classNames }) {
+	const { settings: { tableNameCase, columnNameCase }, collections } = state;
+	const used = /* @__PURE__ */ new Set();
+	const declared = [];
+	const columnRefs = /* @__PURE__ */ new Map();
+	const columnNames = /* @__PURE__ */ new Map();
+	const relationshipNames = /* @__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), OBJECT_MEMBERS)));
+	});
+	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);
+	});
+	relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach(({ relationship, startTable }) => {
+		if (!hasOneRelationship(relationship.relationshipType) && !hasNRelationship(relationship.relationshipType)) return;
+		const name = isSelfReferential(relationship) ? `parent_${startTable.name}` : startTable.name;
+		relationshipNames.set(relationshipKey(relationship, OWNING), uniqueName(used, tsIdentifier(getNameCase(name, columnNameCase), OBJECT_MEMBERS)));
+	});
+	relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable }) => {
+		const name = 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(used, tsIdentifier(name, OBJECT_MEMBERS)));
+	});
+	return {
+		className: uniqueName(classNames, tsIdentifier(getNameCase(table.name, tableNameCase), TYPE_NAMES)),
+		columnIds: declared.map((column) => column.id),
+		columnRefs,
+		columnNames,
+		relationshipNames
+	};
+}
+function carriedColumns(state, naming, columns) {
+	const collection = query(state.collections).collection("tableColumnEntities");
+	return columns.map((column) => collection.selectById(naming.columnRefs.get(column.id) ?? column.id) ?? column);
+}
+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 TYPE_NAMES = /* @__PURE__ */ new Set([
+	"any",
+	"bigint",
+	"boolean",
+	"infer",
+	"keyof",
+	"never",
+	"number",
+	"object",
+	"readonly",
+	"string",
+	"symbol",
+	"undefined",
+	"unique",
+	"unknown"
+]);
+var NO_NAMES = /* @__PURE__ */ new Set();
+var SAFE_PREFIX = "x";
+function tsIdentifier(name, reserved = NO_NAMES) {
+	const value = name.replace(NON_IDENTIFIER, "_");
+	const identifier = IDENTIFIER_START.test(value) ? value : `${SAFE_PREFIX}${value}`;
+	return RESERVED.has(identifier) || reserved.has(identifier) ? `${identifier}_` : identifier;
+}
+var BACKSLASH = /\\/g;
+var DOUBLE_QUOTE = /"/g;
+var NEWLINE = /\r\n|\r|\n/g;
+var literalEscapes = /* @__PURE__ */ new Map([
+	["\\", "\\\\"],
+	["\"", "\\\""],
+	["\n", "\\n"],
+	["\r", "\\r"],
+	["	", "\\t"]
+]);
+function escapeString(value) {
+	return value.replace(BACKSLASH, "\\\\").replace(DOUBLE_QUOTE, "\\\"").replace(NEWLINE, "\\n");
+}
+function stringLiteral(value) {
+	return `"${Array.from(value).map((char) => {
+		const escaped = literalEscapes.get(char);
+		if (escaped !== void 0) return escaped;
+		const code = char.charCodeAt(0);
+		return code < 32 || code === 127 ? `\\x${code.toString(16).padStart(2, "0")}` : char;
+	}).join("")}"`;
+}
+//#endregion
+export { createCode, formatTable };