@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,964 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { BracketType, ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoNameIgnoreCase, isDelimitedPart, orderByNameASC, splitNameParts, tableNamePart, unquoteNamePart } from "../tableName.js";
+import { referentialActionSupport } from "../schema-sql/utils.js";
+import { baseTypeName, fractionalNumber, getNameCase, getPrimitiveType, hasNRelationship, hasOneRelationship, referentialActionEntries } from "./utils.js";
+import { POSTGRES_BIT_TYPES, enumMembers } from "./columnTypes.js";
+import { DOCTRINE_RESERVED_WORDS } from "./doctrineReservedWords.js";
+import { INDENT, PHP_HEADER, isPostgresArray, toClassName } from "./php.js";
+//#region src/utils/generator-code/doctrine.ts
+var PHP_TYPES = {
+	BIGINT: "int",
+	BINARY: "string",
+	BLOB: "mixed",
+	BOOLEAN: "bool",
+	DATE_IMMUTABLE: "\\DateTimeImmutable",
+	DATETIME_IMMUTABLE: "\\DateTimeImmutable",
+	DATETIMETZ_IMMUTABLE: "\\DateTimeImmutable",
+	DECIMAL: "string",
+	ENUM: "string",
+	FLOAT: "float",
+	GUID: "string",
+	INTEGER: "int",
+	JSON: "array",
+	SIMPLE_ARRAY: "array",
+	SMALLFLOAT: "float",
+	SMALLINT: "int",
+	STRING: "string",
+	TEXT: "string",
+	TIME_IMMUTABLE: "\\DateTimeImmutable"
+};
+var convertTypeMap = {
+	int: "INTEGER",
+	long: "BIGINT",
+	float: "FLOAT",
+	double: "FLOAT",
+	decimal: "DECIMAL",
+	boolean: "BOOLEAN",
+	string: "STRING",
+	lob: "TEXT",
+	date: "DATE_IMMUTABLE",
+	dateTime: "DATETIME_IMMUTABLE",
+	time: "STRING"
+};
+var namedTypes = /* @__PURE__ */ new Map([
+	["bfile", "BLOB"],
+	["binary", "BINARY"],
+	["binary varying", "BINARY"],
+	["binary_float", "FLOAT"],
+	["blob", "BLOB"],
+	["bytea", "BLOB"],
+	["datetimeoffset", "DATETIMETZ_IMMUTABLE"],
+	["image", "BLOB"],
+	["int2", "SMALLINT"],
+	["json", "JSON"],
+	["jsonb", "JSON"],
+	["long raw", "BLOB"],
+	["long varbinary", "BLOB"],
+	["longblob", "BLOB"],
+	["mediumblob", "BLOB"],
+	["money", "DECIMAL"],
+	["raw", "BINARY"],
+	["serial2", "SMALLINT"],
+	["smallint", "SMALLINT"],
+	["smallmoney", "DECIMAL"],
+	["smallserial", "SMALLINT"],
+	["time", "TIME_IMMUTABLE"],
+	["time with time zone", "TIME_IMMUTABLE"],
+	["time without time zone", "TIME_IMMUTABLE"],
+	["timestamp with time zone", "DATETIMETZ_IMMUTABLE"],
+	["timestamp_tz", "DATETIMETZ_IMMUTABLE"],
+	["timestamptz", "DATETIMETZ_IMMUTABLE"],
+	["timetz", "TIME_IMMUTABLE"],
+	["tinyblob", "BLOB"],
+	["tinyint", "SMALLINT"],
+	["uniqueidentifier", "GUID"],
+	["uuid", "GUID"],
+	["varbinary", "BINARY"]
+]);
+var vendorTypes = /* @__PURE__ */ new Map([
+	[Database.MSSQL, /* @__PURE__ */ new Map([["bit", "BOOLEAN"], ["numeric", "DECIMAL"]])],
+	[Database.Oracle, /* @__PURE__ */ new Map([["date", "DATE_IMMUTABLE"], ["smallint", "INTEGER"]])],
+	[Database.MySQL, /* @__PURE__ */ new Map([["char byte", "BINARY"]])],
+	[Database.MariaDB, /* @__PURE__ */ new Map([["char byte", "BINARY"]])]
+]);
+var rowVersionTypes = /* @__PURE__ */ new Set(["rowversion", "timestamp"]);
+var nationalTypes = /* @__PURE__ */ new Set([
+	"national char varying",
+	"national character varying",
+	"nvarchar"
+]);
+var unicodeTextTypes = /* @__PURE__ */ new Set(["national text", "ntext"]);
+var mysqlNationalTypes = /* @__PURE__ */ new Set([
+	"national char",
+	"national char varying",
+	"national character",
+	"national character varying",
+	"national varchar",
+	"national varcharacter",
+	"nchar",
+	"nchar varchar",
+	"nchar varcharacter",
+	"nchar varying",
+	"nvarchar"
+]);
+var oracleNumberTypes = /* @__PURE__ */ new Set([
+	"dec",
+	"decimal",
+	"number",
+	"numeric"
+]);
+var lengthTypes = /* @__PURE__ */ new Set([
+	"binary",
+	"binary varying",
+	"bpchar",
+	"char",
+	"char byte",
+	"char varying",
+	"character",
+	"character varying",
+	"national char",
+	"national char varying",
+	"national character",
+	"national character varying",
+	"national varchar",
+	"national varcharacter",
+	"native character",
+	"nchar",
+	"nchar varchar",
+	"nchar varcharacter",
+	"nchar varying",
+	"nvarchar",
+	"nvarchar2",
+	"raw",
+	"string",
+	"text",
+	"varbinary",
+	"varchar",
+	"varchar2",
+	"varcharacter",
+	"varying character"
+]);
+var fixedLengthTypes = /* @__PURE__ */ new Set([
+	"binary",
+	"bpchar",
+	"char",
+	"char byte",
+	"character",
+	"national char",
+	"national character",
+	"nchar"
+]);
+var oneCharacterTypes = /* @__PURE__ */ new Set([
+	"char",
+	"character",
+	"national char",
+	"national character",
+	"nchar"
+]);
+var unboundedStringTypes = /* @__PURE__ */ new Set(["string", "text"]);
+var mysqlLobLengths = /* @__PURE__ */ new Map([
+	["long", 16777215],
+	["long char varying", 16777215],
+	["long character varying", 16777215],
+	["long varbinary", 16777215],
+	["long varchar", 16777215],
+	["long varcharacter", 16777215],
+	["mediumblob", 16777215],
+	["mediumtext", 16777215],
+	["tinyblob", 255],
+	["tinytext", 255],
+	["blob", 65535],
+	["text", 65535]
+]);
+var MYSQL_TEXT_BYTES = [
+	255,
+	65535,
+	16777215
+];
+var serialTypes = /* @__PURE__ */ new Set([
+	"bigserial",
+	"serial",
+	"serial2",
+	"serial4",
+	"serial8",
+	"smallserial"
+]);
+var integerTypes = /* @__PURE__ */ new Set([
+	"BIGINT",
+	"INTEGER",
+	"SMALLINT"
+]);
+var unsignedTypes = /* @__PURE__ */ new Set([
+	...integerTypes,
+	"DECIMAL",
+	"FLOAT",
+	"SMALLFLOAT"
+]);
+var timestampTypes = /* @__PURE__ */ new Set(["DATETIME_IMMUTABLE", "DATETIMETZ_IMMUTABLE"]);
+var IMPORTED_NAMES = [
+	"ArrayCollection",
+	"Collection",
+	"ORM",
+	"Types"
+];
+var USE_COLLECTIONS = ["use Doctrine\\Common\\Collections\\ArrayCollection;", "use Doctrine\\Common\\Collections\\Collection;"];
+var USE_TYPES = "use Doctrine\\DBAL\\Types\\Types;";
+var USE_ORM = "use Doctrine\\ORM\\Mapping as ORM;";
+var LINE_LIMIT = 120;
+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 context = createClassContext(state);
+	const uses = {
+		collections: false,
+		types: false
+	};
+	const classBuffer = [];
+	tables.forEach((table) => {
+		classBuffer.push("");
+		formatClass(state, {
+			buffer: classBuffer,
+			table
+		}, context, uses);
+	});
+	return joinFile(uses, classBuffer);
+}
+function createTableCode(state, table) {
+	const uses = {
+		collections: false,
+		types: false
+	};
+	const classBuffer = [""];
+	formatClass(state, {
+		buffer: classBuffer,
+		table
+	}, createClassContext(state), uses);
+	return joinFile(uses, classBuffer);
+}
+function joinFile(uses, classBuffer) {
+	return [
+		...PHP_HEADER,
+		"",
+		...uses.collections ? USE_COLLECTIONS : [],
+		...uses.types ? [USE_TYPES] : [],
+		USE_ORM,
+		...classBuffer,
+		""
+	].join("\n");
+}
+function formatClass(state, { buffer, table }, context, uses) {
+	const naming = getNaming(state, context, table);
+	const columns = query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const fieldIds = new Set(naming.fields.map((column) => column.id));
+	const quotedIds = quotedColumnIds(state, naming.owning);
+	const identifierCount = naming.fields.filter(isPrimaryKey).length + naming.owning.filter(({ relationship }) => context.derivedIds.has(relationship.id)).length;
+	const uniqueColumnIds = /* @__PURE__ */ new Set();
+	const members = [];
+	const collectionNames = [];
+	columns.forEach((column) => {
+		if (fieldIds.has(column.id)) {
+			uses.types = true;
+			members.push(columnMember(state, naming, column, identifierCount === 1, quotedIds));
+		}
+		naming.owning.filter((resolved) => firstJoinColumnId(columns, resolved) === column.id).forEach((resolved) => {
+			members.push(owningMember(state, context, naming, resolved, uniqueColumnIds, quotedIds));
+		});
+	});
+	context.relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable }) => {
+		const name = relationshipName(naming, relationship, INVERSE);
+		const childNaming = getNaming(state, context, endTable);
+		const target = childNaming.className;
+		const mappedBy = phpString(relationshipName(childNaming, relationship, OWNING));
+		if (context.oneToOneIds.has(relationship.id)) {
+			members.push([...formatAttribute(INDENT, "OneToOne", [`targetEntity: ${target}::class`, `mappedBy: ${mappedBy}`]), propertyLine(target, name, true)]);
+			return;
+		}
+		collectionNames.push(name);
+		members.push([
+			`${INDENT}/** @var Collection<int, ${target}> */`,
+			...formatAttribute(INDENT, "OneToMany", [`targetEntity: ${target}::class`, `mappedBy: ${mappedBy}`]),
+			`${INDENT}public Collection $${name};`
+		]);
+	});
+	if (collectionNames.length !== 0) {
+		uses.collections = true;
+		members.push([
+			`${INDENT}public function __construct()`,
+			`${INDENT}{`,
+			...collectionNames.map((name) => `${INDENT}${INDENT}$this->${name} = new ArrayCollection();`),
+			`${INDENT}}`
+		]);
+	}
+	[
+		"#[ORM\\Entity]",
+		...formatAttribute("", "Table", [...tableNameArguments(state, table.name), ...optionsArgument(commentEntry(table.comment))]),
+		...indexAttributes(state, context, table, quotedIds)
+	].forEach((line) => buffer.push(line));
+	if (members.length === 0) {
+		buffer.push(`class ${naming.className} {}`);
+		return;
+	}
+	buffer.push(`class ${naming.className}`);
+	buffer.push("{");
+	members.forEach((lines, index) => {
+		if (index !== 0) buffer.push("");
+		lines.forEach((line) => buffer.push(line));
+	});
+	buffer.push("}");
+}
+function columnMember(state, naming, column, isSingleIdentifier, quotedIds) {
+	const { database } = state.settings;
+	const isPrimary = isPrimaryKey(column);
+	const columnType = getColumnType(column.dataType, database, isPrimary);
+	const { type, php, args, options, definition, isReadOnly } = columnType;
+	const isGenerated = isPrimary && isSingleIdentifier && integerTypes.has(type) && (bHas(column.options, ColumnOption.autoIncrement) || serialTypes.has(baseTypeName(column.dataType)));
+	const isNullable = !isReadOnly && !isRequired(column);
+	const isUnset = isNullable || isGenerated || isReadOnly;
+	return [
+		...isPrimary ? [`${INDENT}#[ORM\\Id]`] : [],
+		...isGenerated ? [`${INDENT}#[ORM\\GeneratedValue]`] : [],
+		...formatAttribute(INDENT, "Column", [
+			`name: ${phpString(sqlText(columnSqlName(state, column, quotedIds)))}`,
+			`type: Types::${type}`,
+			...args,
+			...!isPrimary && bHas(column.options, ColumnOption.unique) ? ["unique: true"] : [],
+			...isNullable ? ["nullable: true"] : [],
+			...isReadOnly ? ["insertable: false", "updatable: false"] : [],
+			...optionsArgument([
+				...options,
+				...defaultEntry(database, column.default, columnType, isGenerated),
+				...commentEntry(column.comment)
+			]),
+			...definitionArgument(database, column, definition, isNullable),
+			...isReadOnly ? ["generated: 'ALWAYS'"] : []
+		]),
+		propertyLine(php, naming.propertyNames.get(column.id), isUnset)
+	];
+}
+function owningMember(state, context, naming, { relationship, startTable, startColumns, endColumns }, uniqueColumnIds, quotedIds) {
+	const { database } = state.settings;
+	const parentNaming = getNaming(state, context, startTable);
+	const isDerived = context.derivedIds.has(relationship.id);
+	const isOneToOne = context.oneToOneIds.has(relationship.id);
+	const onDelete = referentialActionEntries(relationship, referentialActionSupport(database)).filter(({ key }) => key === "onDelete").map(({ sql }) => `onDelete: ${phpString(sql)}`);
+	const joinColumns = endColumns.flatMap((column, index) => {
+		const parent = startColumns[index];
+		const isCarried = isDerived || !isPrimaryKey(column);
+		const isUnique = !isPrimaryKey(column) && bHas(column.options, ColumnOption.unique) && !(isOneToOne && endColumns.length === 1) && !uniqueColumnIds.has(column.id);
+		const parentType = getColumnType(parent.dataType, database, isPrimaryKey(parent));
+		if (isUnique) uniqueColumnIds.add(column.id);
+		return formatAttribute(INDENT, "JoinColumn", [
+			...joinColumnNames(state, column, parent, quotedIds.has(column.id)),
+			...isUnique ? ["unique: true"] : [],
+			...isRequired(column) ? ["nullable: false"] : [],
+			...onDelete,
+			...isCarried ? definitionArgument(database, column, parentType.definition, !isRequired(column)) : [],
+			...optionsArgument(isCarried ? carriedOptions(database, column, parent, parentType) : [])
+		]);
+	});
+	return [
+		...isDerived ? [`${INDENT}#[ORM\\Id]`] : [],
+		...formatAttribute(INDENT, isOneToOne ? "OneToOne" : "ManyToOne", [`targetEntity: ${parentNaming.className}::class`, `inversedBy: ${phpString(relationshipName(parentNaming, relationship, INVERSE))}`]),
+		...joinColumns,
+		propertyLine(parentNaming.className, relationshipName(naming, relationship, OWNING), !endColumns.every(isRequired))
+	];
+}
+function carriedOptions(database, column, parent, parentType) {
+	const ownDefault = defaultEntry(database, column.default, parentType, false);
+	const parentDefault = defaultEntry(database, parent.default, parentType, false);
+	return [...ownDefault.length === 0 && parentDefault.length !== 0 ? ["'default' => null"] : ownDefault, ...column.comment.trim() === "" && parent.comment.trim() !== "" ? ["'comment' => ''"] : commentEntry(column.comment)];
+}
+function firstJoinColumnId(columns, { endColumns }) {
+	return columns.find((column) => endColumns.some((end) => end.id === column.id))?.id;
+}
+function joinColumnNames(state, column, parent, isQuoted) {
+	return [`name: ${phpString(sqlText({
+		...sqlName(state, column.name),
+		isQuoted
+	}))}`, `referencedColumnName: ${phpString(sqlText({
+		...sqlName(state, parent.name),
+		isQuoted
+	}))}`];
+}
+function quotedColumnIds(state, owning) {
+	return new Set(owning.flatMap(({ startColumns, endColumns }) => endColumns.filter((column, index) => sqlName(state, column.name).isQuoted || sqlName(state, startColumns[index].name).isQuoted).map((column) => column.id)));
+}
+function columnSqlName(state, column, quotedIds) {
+	const name = sqlName(state, column.name);
+	return quotedIds.has(column.id) ? {
+		...name,
+		isQuoted: true
+	} : name;
+}
+function indexAttributes(state, { indexNames }, table, quotedIds) {
+	const { doc: { indexIds }, collections } = state;
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const indexColumnCollection = query(collections).collection("indexColumnEntities");
+	const unnamed = /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set(["primary"]);
+	return query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id).flatMap((index) => {
+		const columns = indexColumnCollection.selectByIds(index.indexColumnIds).map((indexColumn) => columnCollection.selectById(indexColumn.columnId)).filter((column) => column !== void 0 && table.columnIds.includes(column.id));
+		const written = indexName(indexNames.get(index.id) ?? index.name);
+		const name = written === null || names.has(written.toLowerCase()) ? null : written;
+		const key = `${index.unique}:${columns.map(({ id }) => id).join(",")}`;
+		if (columns.length === 0 || name === null && unnamed.has(key)) return [];
+		if (name === null) unnamed.add(key);
+		else names.add(name.toLowerCase());
+		return formatAttribute("", index.unique ? "UniqueConstraint" : "Index", [...name === null ? [] : [`name: ${phpString(name)}`], `columns: [${columns.map((column) => phpString(sqlText(columnSqlName(state, column, quotedIds)))).join(", ")}]`]);
+	});
+}
+var INDEX_NAME = /^[0-9A-Za-z_]+$/;
+var NUMERIC_NAME = /^[0-9]+([Ee][0-9]+)?$/;
+var BACKTICKED = /^`((?:[^`]|``)*)`$/;
+function indexName(name) {
+	const text = name.trim();
+	const value = backtickedName(text) ?? unquoteNamePart(text);
+	return INDEX_NAME.test(value) && !NUMERIC_NAME.test(value) ? value : null;
+}
+function backtickedName(text) {
+	const matched = BACKTICKED.exec(text);
+	return matched ? matched[1].replaceAll("``", "`") : null;
+}
+function propertyLine(type, name, isNullable) {
+	return isNullable ? `${INDENT}public ${nullableType(type)} $${name} = null;` : `${INDENT}public ${type} $${name};`;
+}
+function nullableType(type) {
+	if (type === "mixed") return type;
+	return type.includes("|") ? `${type}|null` : `?${type}`;
+}
+function isRequired(column) {
+	return isPrimaryKey(column) || bHas(column.options, ColumnOption.notNull);
+}
+function definitionArgument(database, column, definition, isNullable) {
+	if (definition === null) return [];
+	const isOracleKey = database === Database.Oracle && isPrimaryKey(column) && (baseTypeName(definition) !== "date" || column.default.trim() !== "");
+	const text = isNullable || isOracleKey ? definition : `${definition} NOT NULL`;
+	return [`columnDefinition: ${phpString(isMySQLFamily(database) && column.comment.trim() !== "" ? `${text} COMMENT ${mysqlString(column.comment)}` : text)}`];
+}
+function mysqlString(value) {
+	return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
+}
+function isMySQLFamily(database) {
+	return database === Database.MySQL || database === Database.MariaDB;
+}
+function commentEntry(comment) {
+	return comment.trim() === "" ? [] : [`'comment' => ${phpString(comment)}`];
+}
+function optionsArgument(entries) {
+	return entries.length === 0 ? [] : [`options: [${entries.join(", ")}]`];
+}
+function formatAttribute(indent, name, args) {
+	const line = `${indent}#[ORM\\${name}(${args.join(", ")})]`;
+	if (line.length <= LINE_LIMIT || args.length < 2) return [line];
+	return [
+		`${indent}#[ORM\\${name}(`,
+		...args.map((arg) => `${indent}${INDENT}${arg},`),
+		`${indent})]`
+	];
+}
+var NUMBER_LITERAL = /^([+-]?)([0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[Ee]([+-]?[0-9]+))?$/;
+var LEADING_ZEROS = /^0+(?=[0-9])/;
+var TRAILING_ZEROS = /0+$/;
+var MYSQL_STRING = /^(?:[Nn]|_[0-9A-Za-z]+\s*)?'((?:[^'\\]|''|\\[\s\S])*)'$/;
+var MYSQL_ESCAPE = /''|\\([\s\S])/g;
+var STRING_LITERAL = /^([Nn]?)'((?:[^']|'')*)'$/;
+var PRINTABLE_ASCII = /^[ -~]*$/;
+var BOOLEAN_LITERAL = /^(true|false)$/i;
+var POSTGRES_TRUE = /^(t|true|y|yes|on|1)$/i;
+var POSTGRES_FALSE = /^(f|false|n|no|off|0)$/i;
+var CURRENT_TIMESTAMP = /^current_timestamp(\(\s*\))?$/i;
+var MYSQL_NOW = /^(current_timestamp|now|localtime|localtimestamp)(\(\s*\))?$/i;
+var PHP_INT_MAX = 9223372036854775807n;
+var mysqlEscapes = /* @__PURE__ */ new Map([
+	["0", String.fromCharCode(0)],
+	["b", "\b"],
+	["n", "\n"],
+	["r", "\r"],
+	["t", "	"],
+	["Z", String.fromCharCode(26)]
+]);
+var currentTimes = /* @__PURE__ */ new Map([
+	[Database.MariaDB, MYSQL_NOW],
+	[Database.MSSQL, /^(current_timestamp|getdate\(\s*\))$/i],
+	[Database.MySQL, MYSQL_NOW],
+	[Database.PostgreSQL, /^(current_timestamp|localtimestamp|(now|transaction_timestamp)\(\s*\))$/i]
+]);
+function defaultEntry(database, value, columnType, isGenerated) {
+	const text = value.trim();
+	if (text === "" || isGenerated || columnType.definition !== null) return [];
+	const literal = stringLiteral(database, text);
+	const entry = literal === null ? bareDefault(database, text, columnType) : literalDefault(database, literal, columnType);
+	return entry === null ? [] : [`'default' => ${entry}`];
+}
+function literalDefault(database, literal, columnType) {
+	const { type } = columnType;
+	if (type === "BOOLEAN") return booleanDefault(database, literal.trim());
+	if (NUMBER_LITERAL.test(literal) && isNumberType(type)) return numberDefault(database, literal, columnType);
+	if (type === "JSON" && database === Database.MySQL) return null;
+	return phpString(literal);
+}
+function bareDefault(database, text, columnType) {
+	const { type } = columnType;
+	if (NUMBER_LITERAL.test(text)) return isNumberType(type) ? numberDefault(database, text, columnType) : phpString(numberText(database, text));
+	if (BOOLEAN_LITERAL.test(text)) {
+		if (integerTypes.has(type) && (isMySQLFamily(database) || database === Database.SQLite)) return text.toLowerCase() === "true" ? "1" : "0";
+		return type === "BOOLEAN" ? text.toLowerCase() : null;
+	}
+	if (timestampTypes.has(type) && (currentTimes.get(database) ?? CURRENT_TIMESTAMP).test(text)) return "'CURRENT_TIMESTAMP'";
+	return null;
+}
+function booleanDefault(database, text) {
+	if (database === Database.PostgreSQL) {
+		if (POSTGRES_TRUE.test(text)) return "true";
+		return POSTGRES_FALSE.test(text) ? "false" : null;
+	}
+	if (BOOLEAN_LITERAL.test(text)) return text.toLowerCase();
+	const number = NUMBER_LITERAL.test(text) ? canonicalNumber(text) : null;
+	return number === "0" || number === "1" ? number : null;
+}
+function isNumberType(type) {
+	return integerTypes.has(type) || type === "BOOLEAN" || type === "DECIMAL" || type === "FLOAT" || type === "SMALLFLOAT";
+}
+function numberDefault(database, text, { type, scale }) {
+	if (type === "BOOLEAN") return booleanDefault(database, text);
+	const isMySQL = isMySQLFamily(database);
+	if (integerTypes.has(type)) {
+		const value = isMySQL ? decimalAtScale(canonicalNumber(text), 0) : numberText(database, text);
+		return value === canonicalNumber(value) && !value.includes(".") && BigInt(value.replace("-", "")) <= PHP_INT_MAX ? value : phpString(value);
+	}
+	if (isMySQL && scale !== null) return phpString(decimalAtScale(canonicalNumber(text), scale));
+	return phpString(numberText(database, text));
+}
+function numberText(database, text) {
+	return database === Database.Oracle || database === Database.SQLite ? text : canonicalNumber(text);
+}
+function canonicalNumber(text) {
+	const [, sign, mantissa, exponent = "0"] = NUMBER_LITERAL.exec(text);
+	const [whole, fraction = ""] = mantissa.split(".");
+	const digits = `${whole}${fraction}`;
+	const point = whole.length + Number(exponent);
+	const padded = point < 0 ? `${"0".repeat(-point)}${digits}` : digits.padEnd(point, "0");
+	const at = Math.max(point, 0);
+	const integer = (padded.slice(0, at) || "0").replace(LEADING_ZEROS, "");
+	const decimals = padded.slice(at).replace(TRAILING_ZEROS, "");
+	const value = decimals === "" ? integer : `${integer}.${decimals}`;
+	return value === "0" || sign !== "-" ? value : `-${value}`;
+}
+function decimalAtScale(number, scale) {
+	const [whole, fraction = ""] = number.replace("-", "").split(".");
+	const digits = BigInt(`${whole}${fraction.slice(0, scale).padEnd(scale, "0")}`) + (fraction.charAt(scale) >= "5" ? 1n : 0n);
+	const text = digits.toString().padStart(scale + 1, "0");
+	const value = scale === 0 ? text : `${text.slice(0, -scale)}.${text.slice(-scale)}`;
+	return number.startsWith("-") && digits !== 0n ? `-${value}` : value;
+}
+function stringLiteral(database, text) {
+	if (isMySQLFamily(database)) {
+		const matched = MYSQL_STRING.exec(text);
+		return matched ? unescapeMySQL(matched[1]) : null;
+	}
+	const matched = STRING_LITERAL.exec(text);
+	if (!matched) return null;
+	const [, prefix, body] = matched;
+	const value = body.replaceAll("''", "'");
+	return database === Database.MSSQL && prefix !== "" && !PRINTABLE_ASCII.test(value) ? null : value;
+}
+function unescapeMySQL(body) {
+	return body.replace(MYSQL_ESCAPE, (escape, char) => {
+		if (char === void 0) return "'";
+		return char === "%" || char === "_" ? escape : mysqlEscapes.get(char) ?? char;
+	});
+}
+var ASCII_IDENTIFIER = /^[A-Za-z_][0-9A-Za-z_]*$/;
+var ASCII_CAPITALS = /[A-Z]+/g;
+function quotesNames({ settings: { bracketType } }) {
+	return bracketType !== BracketType.none;
+}
+function needsQuotes(name) {
+	return !ASCII_IDENTIFIER.test(name) || DOCTRINE_RESERVED_WORDS.has(name.toLowerCase());
+}
+function foldName(database, name) {
+	if (database === Database.Oracle) return Array.from(name, oracleCapital).join("");
+	if (database === Database.PostgreSQL) return name.replace(ASCII_CAPITALS, (letters) => letters.toLowerCase());
+	return name;
+}
+function oracleCapital(char) {
+	const upper = char.toUpperCase();
+	const code = char.codePointAt(0);
+	if (Array.from(upper).length === 1) return upper;
+	if (code >= 8064 && code <= 8103 && (code & 15) < 8) return String.fromCodePoint(code + 8);
+	return code === 8115 || code === 8131 || code === 8179 ? String.fromCodePoint(code + 9) : char;
+}
+function sqlName(state, name) {
+	if (quotesNames(state)) return {
+		text: name,
+		isQuoted: true
+	};
+	if (isDelimitedPart(name)) return {
+		text: unquoteNamePart(name),
+		isQuoted: true
+	};
+	const text = foldName(state.settings.database, name);
+	return {
+		text,
+		isQuoted: needsQuotes(text)
+	};
+}
+function sqlText({ text, isQuoted }) {
+	return isQuoted ? `\`${text}\`` : text;
+}
+var BACKTICK_DATABASES = /* @__PURE__ */ new Set([
+	Database.Databricks,
+	Database.MariaDB,
+	Database.MySQL,
+	Database.SQLite
+]);
+function tableNameArguments(state, name) {
+	const { database } = state.settings;
+	if (quotesNames(state) && !name.includes(".")) return [`name: ${phpString(sqlText({
+		text: name,
+		isQuoted: true
+	}))}`];
+	const parts = splitNameParts(name).slice(-2).map((part) => {
+		const backticked = BACKTICK_DATABASES.has(database) ? backtickedName(part) : null;
+		if (backticked !== null) return {
+			text: backticked,
+			isQuoted: true
+		};
+		if (isDelimitedPart(part)) return {
+			text: unquoteNamePart(part),
+			isQuoted: true
+		};
+		return sqlName(state, part);
+	});
+	const table = parts[parts.length - 1];
+	return [`name: ${phpString(sqlText({
+		...table,
+		isQuoted: parts.some((part) => part.isQuoted)
+	}))}`, ...parts.length === 1 ? [] : [`schema: ${phpString(parts[0].text)}`]];
+}
+var TYPE_ARGUMENTS = /\(\s*([^)]*)\)/;
+var DIGITS = /^[0-9]+$/;
+var LENGTH = /^([0-9]+)(?:\s+(?:byte|char))?$/i;
+var MAX_ARGUMENT = /\(\s*max\s*\)/i;
+var UNSIGNED = /(^|[^0-9a-z_])unsigned([^0-9a-z_]|$)/;
+var ZEROFILL = /(^|[^0-9a-z_])zerofill([^0-9a-z_]|$)/;
+var SPACES = /\s+/g;
+var DEFAULT_DECIMAL = [10, 0];
+var moneyDecimals = /* @__PURE__ */ new Map([["money", [19, 2]], ["smallmoney", [10, 4]]]);
+var MSSQL_MONEY = [19, 4];
+var MSSQL_DECIMAL = [18, 0];
+var FIXED = "'fixed' => true";
+var UTF8MB3 = "'charset' => 'utf8mb3'";
+var JSONB = "'jsonb' => true";
+var UNSIGNED_OPTION = "'unsigned' => true";
+function createColumnType(type, rest = {}) {
+	return {
+		type,
+		php: PHP_TYPES[type],
+		args: [],
+		options: [],
+		definition: null,
+		isReadOnly: false,
+		scale: null,
+		...rest
+	};
+}
+function getColumnType(dataType, database, isKey) {
+	const isMySQL = isMySQLFamily(database);
+	const typeName = baseTypeName(dataType);
+	const isUnsigned = isMySQL && (UNSIGNED.test(typeName) || ZEROFILL.test(typeName) || typeName === "serial");
+	const resolved = resolveColumnType(dataType, isMySQL ? typeName.replace(UNSIGNED, "$1$2").replace(ZEROFILL, "$1$2").replace(SPACES, " ").trim() : typeName, database, isKey);
+	if (!isUnsigned || !unsignedTypes.has(resolved.type) || resolved.definition !== null) return resolved;
+	return {
+		...resolved,
+		options: [...resolved.options, UNSIGNED_OPTION],
+		php: resolved.type === "BIGINT" ? "int|string" : resolved.php
+	};
+}
+function resolveColumnType(dataType, base, database, isKey) {
+	const isMySQL = isMySQLFamily(database);
+	const args = typeArguments(dataType);
+	if (database === Database.MSSQL && rowVersionTypes.has(base)) return createColumnType("BINARY", {
+		args: ["length: 8"],
+		definition: "ROWVERSION",
+		isReadOnly: true
+	});
+	if (isPostgresArray(dataType, database) || database === Database.PostgreSQL && (POSTGRES_BIT_TYPES.has(base) || base === "pg_lsn")) return createColumnType("TEXT", { definition: dataType.trim() });
+	if (isMySQL && base === "enum") {
+		const members = enumMembers(dataType);
+		if (members) return createColumnType("ENUM", { options: [`'values' => [${members.map(phpString).join(", ")}]`] });
+	}
+	if (isMySQL && base === "set") return createColumnType("SIMPLE_ARRAY");
+	const fraction = fractionalNumber(dataType, database);
+	if (fraction) return createColumnType("DECIMAL", {
+		args: [`precision: ${fraction[0]}`, `scale: ${fraction[1]}`],
+		scale: fraction[1]
+	});
+	if (database === Database.Oracle && oracleNumberTypes.has(base)) {
+		if (args.length === 1 || args.length === 2 && args[1] === 0) return createColumnType(oracleIntegerType(args[0]));
+		if (base !== "number" && args.length === 0) return createColumnType("INTEGER");
+	}
+	if (database === Database.MSSQL && (unicodeTextTypes.has(base) || nationalTypes.has(base) && MAX_ARGUMENT.test(dataType))) return createColumnType("STRING", {
+		args: ["length: -1"],
+		definition: "NVARCHAR(MAX)"
+	});
+	const type = vendorTypes.get(database)?.get(base) ?? namedTypes.get(base) ?? (isSmallFloat(base, database, args) ? "SMALLFLOAT" : void 0) ?? convertTypeMap[getPrimitiveType(dataType, database)];
+	if (isKey && PHP_TYPES[type] === "\\DateTimeImmutable") return createColumnType("STRING", {
+		args: ["length: 255"],
+		definition: dataType.trim()
+	});
+	if (isKey && type === "BLOB" && (database === Database.PostgreSQL || database === Database.SQLite)) return createColumnType("BINARY");
+	if (type === "STRING" || type === "BINARY") {
+		const resolved = lengthType(type, base, dataType, database);
+		return isKey && resolved.type === "STRING" && resolved.args.length === 0 ? {
+			...resolved,
+			args: ["length: 255"]
+		} : resolved;
+	}
+	if (isMySQL && (type === "TEXT" || type === "BLOB")) {
+		const length = mysqlLobLength(base, database, args);
+		return createColumnType(type, { args: length === void 0 ? [] : [`length: ${length}`] });
+	}
+	if (type === "DECIMAL" && args.length === 1) return createColumnType(type, {
+		args: [`precision: ${args[0]}`],
+		scale: 0
+	});
+	if (type === "DECIMAL") {
+		const [precision, scale] = decimalDigits(base, database, args);
+		return createColumnType(type, {
+			args: [`precision: ${precision}`, `scale: ${scale}`],
+			scale
+		});
+	}
+	if (type === "JSON" && base === "jsonb") return createColumnType(type, { options: [JSONB] });
+	if (isMySQL && (type === "FLOAT" || type === "SMALLFLOAT") && args.length === 2) return createColumnType(type, { scale: args[1] });
+	return createColumnType(type);
+}
+function mysqlLobLength(base, database, args) {
+	if (args.length !== 1 || base !== "text" && base !== "blob") return mysqlLobLengths.get(base);
+	if (args[0] === 0) return database === Database.MariaDB ? mysqlLobLengths.get(base) : 255;
+	if (base === "text") return MYSQL_TEXT_BYTES.find((bytes) => args[0] * 4 <= bytes);
+	return args[0];
+}
+function decimalDigits(base, database, args) {
+	if (args.length === 2) return args;
+	if (base === "money" && database === Database.MSSQL) return MSSQL_MONEY;
+	return moneyDecimals.get(base) ?? (database === Database.MSSQL ? MSSQL_DECIMAL : DEFAULT_DECIMAL);
+}
+function oracleIntegerType(precision) {
+	if (precision === 5) return "SMALLINT";
+	return precision <= 10 ? "INTEGER" : "BIGINT";
+}
+function lengthType(type, base, dataType, database) {
+	const length = lengthTypes.has(base) ? lengthArgument(dataType) : null;
+	const options = [...fixedLengthTypes.has(base) ? [FIXED] : [], ...isMySQLFamily(database) && mysqlNationalTypes.has(base) ? [UTF8MB3] : []];
+	if (length !== null) return createColumnType(type, {
+		args: [`length: ${length}`],
+		options,
+		definition: database === Database.MSSQL && type === "STRING" && !nationalTypes.has(base) && length > 4e3 ? dataType.trim() : null
+	});
+	if (type === "BINARY" && (isMySQLFamily(database) || database === Database.MSSQL) && !MAX_ARGUMENT.test(dataType)) return createColumnType("BINARY", {
+		args: ["length: 1"],
+		options
+	});
+	if (type === "BINARY") return createColumnType("BLOB");
+	if (MAX_ARGUMENT.test(dataType) || unboundedStringTypes.has(base)) return createColumnType("TEXT");
+	if (oneCharacterTypes.has(base)) return createColumnType("STRING", {
+		args: ["length: 1"],
+		options
+	});
+	return createColumnType("STRING");
+}
+function isSmallFloat(base, database, args) {
+	const isSinglePrecision = base === "float" && args.length === 1 && args[0] <= 24;
+	switch (database) {
+		case Database.MySQL:
+		case Database.MariaDB: return (base === "float" || base === "float4") && (args.length !== 1 || args[0] <= 24);
+		case Database.PostgreSQL: return base === "real" || base === "float4" || isSinglePrecision;
+		case Database.MSSQL: return base === "real" || isSinglePrecision;
+		case Database.Oracle: return base === "real" || base === "float" && args.length === 1 && args[0] === 63;
+		case Database.SQLite: return base === "real";
+	}
+	return false;
+}
+function typeArguments(dataType) {
+	const matched = TYPE_ARGUMENTS.exec(dataType);
+	if (!matched) return [];
+	const values = matched[1].split(",").map((value) => value.trim());
+	return values.every((value) => DIGITS.test(value)) ? values.map(Number) : [];
+}
+function lengthArgument(dataType) {
+	const matched = LENGTH.exec(TYPE_ARGUMENTS.exec(dataType)?.[1].trim() ?? "");
+	const length = Number(matched?.[1]);
+	return length > 0 ? length : null;
+}
+function createClassContext(state) {
+	const relationships = resolveRelationships(state);
+	const derivedIds = new Set(relationships.filter((resolved) => isDerivedIdentity(state, resolved, relationships)).map(({ relationship }) => relationship.id));
+	const context = {
+		relationships,
+		derivedIds,
+		oneToOneIds: new Set(relationships.filter(({ relationship, endTable }) => !hasNRelationship(relationship.relationshipType) || derivedIds.has(relationship.id) && keyColumns(state, endTable).length === 1).map(({ relationship }) => relationship.id)),
+		indexNames: createIndexNames(state),
+		namings: /* @__PURE__ */ new Map(),
+		classNames: new Set(IMPORTED_NAMES.map((name) => name.toLowerCase()))
+	};
+	query(state.collections).collection("tableEntities").selectByIds(state.doc.tableIds).sort(orderByNameASC).forEach((table) => getNaming(state, context, table));
+	return context;
+}
+function createIndexNames(state) {
+	const { doc: { indexIds }, settings: { bracketType }, collections } = state;
+	const tableCollection = query(collections).collection("tableEntities");
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const indexColumnCollection = query(collections).collection("indexColumnEntities");
+	const used = [];
+	const names = /* @__PURE__ */ new Map();
+	query(collections).collection("indexEntities").selectByIds(indexIds).forEach((index) => {
+		const table = tableCollection.selectById(index.tableId);
+		const hasColumns = indexColumnCollection.selectByIds(index.indexColumnIds).some(({ columnId }) => columnCollection.selectById(columnId));
+		if (!table || index.name.trim() !== "" || !hasColumns) return;
+		const name = autoNameIgnoreCase(used, `IDX_${tableNamePart(table.name, bracketType)}`);
+		used.push({
+			id: index.id,
+			name
+		});
+		names.set(index.id, name);
+	});
+	return names;
+}
+function resolveRelationships(state) {
+	const { doc: { relationshipIds, tableIds }, collections } = state;
+	const documentTableIds = new Set(tableIds);
+	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 !isMapped(relationship) || !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) && isPrimaryKey(column)) || !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, derivedIds, oneToOneIds, classNames }) {
+	const { settings: { tableNameCase, columnNameCase }, collections } = state;
+	const used = /* @__PURE__ */ new Set();
+	const propertyNames = /* @__PURE__ */ new Map();
+	const relationshipNames = /* @__PURE__ */ new Map();
+	const owning = relationships.filter(({ relationship }) => relationship.end.tableId === table.id);
+	const carried = new Set(owning.flatMap(({ relationship, endColumns }) => endColumns.filter((column) => derivedIds.has(relationship.id) || !isPrimaryKey(column)).map((column) => column.id)));
+	const columnNames = /* @__PURE__ */ new Set();
+	const fields = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).filter((column) => {
+		if (carried.has(column.id) || columnNames.has(column.name)) return false;
+		columnNames.add(column.name);
+		return true;
+	});
+	fields.forEach((column) => {
+		propertyNames.set(column.id, uniqueName(used, phpIdentifier(getNameCase(column.name, columnNameCase))));
+	});
+	owning.forEach(({ relationship, startTable }) => {
+		const name = isSelfReferential(relationship) ? `parent_${startTable.name}` : startTable.name;
+		relationshipNames.set(relationshipKey(relationship, OWNING), uniqueName(used, phpIdentifier(getNameCase(name, columnNameCase))));
+	});
+	relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable }) => {
+		const name = oneToOneIds.has(relationship.id) ? endTable.name : `${endTable.name}List`;
+		relationshipNames.set(relationshipKey(relationship, INVERSE), uniqueName(used, phpIdentifier(getNameCase(name, columnNameCase))));
+	});
+	return {
+		className: uniqueClassName(classNames, toClassName(phpIdentifier(getNameCase(table.name, tableNameCase)))),
+		fields,
+		owning,
+		propertyNames,
+		relationshipNames
+	};
+}
+function isDerivedIdentity(state, { startTable, startColumns, endColumns }, relationships) {
+	const parentKey = keyColumns(state, startTable);
+	return endColumns.every(isPrimaryKey) && parentKey.length === 1 && startColumns.length === 1 && startColumns[0].id === parentKey[0].id && !relationships.some(({ relationship, endColumns: parentColumns }) => relationship.end.tableId === startTable.id && parentColumns.every(isPrimaryKey) && parentColumns.some((column) => column.id === parentKey[0].id));
+}
+function keyColumns(state, table) {
+	return query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds).filter(isPrimaryKey);
+}
+function isMapped(relationship) {
+	return hasOneRelationship(relationship.relationshipType) || hasNRelationship(relationship.relationshipType);
+}
+function isPrimaryKey(column) {
+	return bHas(column.options, ColumnOption.primaryKey);
+}
+function relationshipKey(relationship, side) {
+	return `${relationship.id}:${side}`;
+}
+function relationshipName(naming, relationship, side) {
+	return naming.relationshipNames.get(relationshipKey(relationship, 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;
+}
+function uniqueClassName(used, name) {
+	let result = name;
+	let index = 2;
+	while (used.has(result.toLowerCase())) {
+		result = `${name}${index}`;
+		index += 1;
+	}
+	used.add(result.toLowerCase());
+	return result;
+}
+var WORD_CHARACTER = /^[0-9A-Za-z_]$/;
+var DIGIT_START = /^[0-9]/;
+function phpIdentifier(name) {
+	const value = Array.from(name, (char) => char.charCodeAt(0) >= 128 || WORD_CHARACTER.test(char) ? char : "_").join("");
+	return value === "" || DIGIT_START.test(value) ? `_${value}` : value;
+}
+var SINGLE_QUOTED = /[\\']/g;
+var doubleQuotedEscapes = /* @__PURE__ */ new Map([
+	["\\", "\\\\"],
+	["\"", "\\\""],
+	["$", "\\$"],
+	["\n", "\\n"],
+	["\r", "\\r"],
+	["	", "\\t"]
+]);
+function phpString(value) {
+	const chars = Array.from(value);
+	if (!chars.some(isControlCharacter)) return `'${value.replace(SINGLE_QUOTED, "\\$&")}'`;
+	return `"${chars.map(escapeDoubleQuoted).join("")}"`;
+}
+function escapeDoubleQuoted(char) {
+	const escape = doubleQuotedEscapes.get(char);
+	if (escape !== void 0) return escape;
+	return isControlCharacter(char) ? `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}` : char;
+}
+function isControlCharacter(char) {
+	const code = char.charCodeAt(0);
+	return code < 32 || code === 127;
+}
+//#endregion
+export { createCode, createTableCode };