@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,1225 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoName, orderByNameASC } from "../tableName.js";
+import { referentialActionSupport } from "../schema-sql/utils.js";
+import { getDataTypeHints, getNameCase, getPrimitiveType, hasNRelationship, hasOneRelationship, referentialActionEntries } from "./utils.js";
+import { getColumnType as getColumnType$1, isMySQLFamily } from "./columnTypes.js";
+//#region src/utils/generator-code/sequelize.ts
+var SEQUELIZE_NAMES = [
+	"CreationOptional",
+	"DataTypes",
+	"InferAttributes",
+	"InferCreationAttributes",
+	"Model",
+	"NonAttribute",
+	"Range",
+	"Sequelize",
+	"sequelize"
+];
+var GLOBAL_NAMES = [
+	"Buffer",
+	"Date",
+	"Float32Array",
+	"Float64Array",
+	"Int8Array",
+	"Uint8Array"
+];
+var MODEL_MEMBER_NAMES = [
+	"_attributes",
+	"_changed",
+	"_creationAttributes",
+	"_customGetters",
+	"_customSetters",
+	"_hasCustomGetters",
+	"_hasCustomSetters",
+	"_initValues",
+	"_isAttribute",
+	"_model",
+	"_options",
+	"_previousDataValues",
+	"_setInclude",
+	"_setupHooks",
+	"addHook",
+	"changed",
+	"dataValues",
+	"decrement",
+	"destroy",
+	"equals",
+	"equalsOneOf",
+	"get",
+	"getDataValue",
+	"hasHook",
+	"hasHooks",
+	"increment",
+	"isNewRecord",
+	"isSoftDeleted",
+	"previous",
+	"prototype",
+	"rawAttributes",
+	"reload",
+	"removeHook",
+	"restore",
+	"runHooks",
+	"save",
+	"sequelize",
+	"set",
+	"setAttributes",
+	"setDataValue",
+	"setValidators",
+	"toJSON",
+	"uniqno",
+	"update",
+	"validate",
+	"validators",
+	"where",
+	"__defineGetter__",
+	"__defineSetter__",
+	"__lookupGetter__",
+	"__lookupSetter__",
+	"__proto__",
+	"constructor",
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf"
+];
+var MODULE_SCOPE_NAMES = /* @__PURE__ */ new Set([...SEQUELIZE_NAMES, ...GLOBAL_NAMES]);
+var TYPES = "DataTypes";
+var MODEL = "Model";
+var NAMESPACE = "Sequelize";
+var INSTANCE = "sequelize";
+function wrap(name, inner) {
+	return `${name}<${inner}>`;
+}
+var LINE_LIMIT = 80;
+var INDENT = "  ";
+var OWNING = "owning";
+var INVERSE = "inverse";
+var CHAR = `${TYPES}.CHAR`;
+var STRING = `${TYPES}.STRING`;
+var BIGINT = `${TYPES}.BIGINT`;
+var DECIMAL = `${TYPES}.DECIMAL`;
+var DATE_TIME = `${TYPES}.DATE`;
+var FLOAT = `${TYPES}.FLOAT`;
+var DOUBLE = `${TYPES}.DOUBLE`;
+var VENDOR_TYPES = [
+	[[
+		"bpchar",
+		"char",
+		"character",
+		"national char",
+		"national character",
+		"native character",
+		"nchar"
+	], {
+		expr: CHAR,
+		ts: "string",
+		args: "length"
+	}],
+	[["text"], {
+		expr: `${TYPES}.TEXT`,
+		ts: "string",
+		args: "none"
+	}],
+	[["tinytext"], {
+		expr: `${TYPES}.TEXT("tiny")`,
+		ts: "string",
+		args: "none"
+	}],
+	[["mediumtext"], {
+		expr: `${TYPES}.TEXT("medium")`,
+		ts: "string",
+		args: "none"
+	}],
+	[["longtext"], {
+		expr: `${TYPES}.TEXT("long")`,
+		ts: "string",
+		args: "none"
+	}],
+	[["tinyblob"], {
+		expr: `${TYPES}.BLOB("tiny")`,
+		ts: "Buffer",
+		args: "none"
+	}],
+	[["mediumblob"], {
+		expr: `${TYPES}.BLOB("medium")`,
+		ts: "Buffer",
+		args: "none"
+	}],
+	[["longblob"], {
+		expr: `${TYPES}.BLOB("long")`,
+		ts: "Buffer",
+		args: "none"
+	}],
+	[[
+		"byte",
+		"int1",
+		"tinyint"
+	], {
+		expr: `${TYPES}.TINYINT`,
+		ts: "number",
+		args: "none"
+	}],
+	[[
+		"int2",
+		"serial2",
+		"short",
+		"smallint",
+		"smallserial"
+	], {
+		expr: `${TYPES}.SMALLINT`,
+		ts: "number",
+		args: "none"
+	}],
+	[[
+		"int3",
+		"mediumint",
+		"middleint"
+	], {
+		expr: `${TYPES}.MEDIUMINT`,
+		ts: "number",
+		args: "none"
+	}],
+	[[
+		"dec",
+		"decimal",
+		"fixed",
+		"number",
+		"numeric"
+	], {
+		expr: DECIMAL,
+		ts: "string",
+		args: "precision"
+	}],
+	[["uniqueidentifier", "uuid"], {
+		expr: `${TYPES}.UUID`,
+		ts: "string",
+		args: "none"
+	}],
+	[["json"], {
+		expr: `${TYPES}.JSON`,
+		ts: "unknown",
+		args: "none"
+	}],
+	[["jsonb"], {
+		expr: `${TYPES}.JSONB`,
+		ts: "unknown",
+		args: "none"
+	}],
+	[["cidr"], {
+		expr: `${TYPES}.CIDR`,
+		ts: "string",
+		args: "none"
+	}],
+	[["inet"], {
+		expr: `${TYPES}.INET`,
+		ts: "string",
+		args: "none"
+	}],
+	[["macaddr"], {
+		expr: `${TYPES}.MACADDR`,
+		ts: "string",
+		args: "none"
+	}],
+	[["tsvector"], {
+		expr: `${TYPES}.TSVECTOR`,
+		ts: "string",
+		args: "none"
+	}]
+];
+var BLOB = {
+	expr: `${TYPES}.BLOB`,
+	ts: "Buffer",
+	args: "none"
+};
+var NUMERIC_EXPRESSIONS = /* @__PURE__ */ new Set([
+	BIGINT,
+	DECIMAL,
+	DOUBLE,
+	FLOAT,
+	`${TYPES}.INTEGER`,
+	`${TYPES}.MEDIUMINT`,
+	`${TYPES}.SMALLINT`,
+	`${TYPES}.TINYINT`
+]);
+var vendorTypeMap = new Map(VENDOR_TYPES.flatMap(([names, emission]) => names.map((name) => [name, emission])));
+var fallbackTypeMap = {
+	int: {
+		expr: `${TYPES}.INTEGER`,
+		ts: "number",
+		args: "none"
+	},
+	long: {
+		expr: BIGINT,
+		ts: "string",
+		args: "none"
+	},
+	float: {
+		expr: FLOAT,
+		ts: "number",
+		args: "none"
+	},
+	double: {
+		expr: DOUBLE,
+		ts: "number",
+		args: "none"
+	},
+	decimal: {
+		expr: DECIMAL,
+		ts: "string",
+		args: "precision"
+	},
+	boolean: {
+		expr: `${TYPES}.BOOLEAN`,
+		ts: "boolean",
+		args: "none"
+	},
+	string: {
+		expr: STRING,
+		ts: "string",
+		args: "length"
+	},
+	lob: {
+		expr: `${TYPES}.TEXT`,
+		ts: "string",
+		args: "none"
+	},
+	date: {
+		expr: `${TYPES}.DATEONLY`,
+		ts: "string",
+		args: "none"
+	},
+	dateTime: {
+		expr: DATE_TIME,
+		ts: "Date",
+		args: "none"
+	},
+	time: {
+		expr: `${TYPES}.TIME`,
+		ts: "string",
+		args: "none"
+	}
+};
+var SCALAR_ANNOTATIONS = {
+	bool: "boolean",
+	i8: "number",
+	i16: "number",
+	i32: "number",
+	i64: "string",
+	u8: "number",
+	u16: "number",
+	u32: "number",
+	u64: "string",
+	f32: "number",
+	f64: "number",
+	decimal: "string",
+	string: "string",
+	bytes: "Buffer",
+	uuid: "string",
+	json: "unknown",
+	date: "string",
+	time: "string",
+	timeTz: "string",
+	dateTime: "Date",
+	dateTimeUtc: "Date",
+	dateTimeOffset: "Date",
+	interval: "string"
+};
+var BIGINT_ANNOTATIONS = /* @__PURE__ */ new Map([
+	[Database.MariaDB, "number | string"],
+	[Database.MySQL, "number | string"],
+	[Database.SQLite, "number"]
+]);
+var DECIMAL_ANNOTATIONS = /* @__PURE__ */ new Map([
+	[Database.MariaDB, "number | string"],
+	[Database.MSSQL, "number"],
+	[Database.SQLite, "number"]
+]);
+var POSTGRES_MEMBER_TYPES = /* @__PURE__ */ new Set([
+	"bigint",
+	"bigserial",
+	"bool",
+	"boolean",
+	"bpchar",
+	"bytea",
+	"char",
+	"character",
+	"character varying",
+	"cidr",
+	"date",
+	"dec",
+	"decimal",
+	"double precision",
+	"float",
+	"float4",
+	"float8",
+	"inet",
+	"int",
+	"int2",
+	"int4",
+	"int8",
+	"integer",
+	"json",
+	"jsonb",
+	"macaddr",
+	"numeric",
+	"real",
+	"serial",
+	"serial2",
+	"serial4",
+	"serial8",
+	"smallint",
+	"smallserial",
+	"text",
+	"time",
+	"time without time zone",
+	"timestamp with time zone",
+	"timestamptz",
+	"tsvector",
+	"uuid",
+	"varchar"
+]);
+var MYSQL_MEMBER_TYPES = /* @__PURE__ */ new Set([
+	"bigint",
+	"blob",
+	"bool",
+	"boolean",
+	"char",
+	"char varying",
+	"character",
+	"character varying",
+	"date",
+	"datetime",
+	"dec",
+	"decimal",
+	"double",
+	"double precision",
+	"enum",
+	"fixed",
+	"float",
+	"float4",
+	"float8",
+	"int",
+	"int1",
+	"int2",
+	"int3",
+	"int4",
+	"int8",
+	"integer",
+	"json",
+	"longblob",
+	"longtext",
+	"mediumblob",
+	"mediumint",
+	"mediumtext",
+	"middleint",
+	"national char",
+	"national char varying",
+	"national character",
+	"national character varying",
+	"national varchar",
+	"national varcharacter",
+	"nchar",
+	"nchar varchar",
+	"nchar varcharacter",
+	"nchar varying",
+	"numeric",
+	"nvarchar",
+	"real",
+	"serial",
+	"smallint",
+	"text",
+	"time",
+	"tinyblob",
+	"tinyint",
+	"tinytext",
+	"varchar",
+	"varcharacter"
+]);
+var MSSQL_MEMBER_TYPES = /* @__PURE__ */ new Set([
+	"bigint",
+	"bit",
+	"char",
+	"character",
+	"date",
+	"dec",
+	"decimal",
+	"double precision",
+	"float",
+	"int",
+	"integer",
+	"national char varying",
+	"national character varying",
+	"numeric",
+	"nvarchar",
+	"real",
+	"smallint",
+	"tinyint",
+	"varbinary"
+]);
+var MEMBER_TYPES = /* @__PURE__ */ new Map([
+	[Database.MariaDB, MYSQL_MEMBER_TYPES],
+	[Database.MSSQL, MSSQL_MEMBER_TYPES],
+	[Database.MySQL, MYSQL_MEMBER_TYPES],
+	[Database.PostgreSQL, POSTGRES_MEMBER_TYPES]
+]);
+var POSTGRES_RANGE_TYPES = /* @__PURE__ */ new Map([
+	["daterange", [`${TYPES}.DATEONLY`, "string"]],
+	["int4range", [`${TYPES}.INTEGER`, "number"]],
+	["int8range", [BIGINT, "string"]],
+	["numrange", [DECIMAL, "string"]],
+	["tsrange", [null, "Date"]],
+	["tstzrange", [DATE_TIME, "Date"]]
+]);
+var POSTGRES_OBJECT_TYPES = /* @__PURE__ */ new Set(["circle", "point"]);
+var POSTGRES_TEXT_ARRAY_TYPES = /* @__PURE__ */ new Set([
+	"bit",
+	"bit varying",
+	"box",
+	"cid",
+	"circle",
+	"datemultirange",
+	"int4multirange",
+	"int8multirange",
+	"jsonpath",
+	"line",
+	"lseg",
+	"macaddr8",
+	"name",
+	"nummultirange",
+	"path",
+	"pg_lsn",
+	"pg_snapshot",
+	"polygon",
+	"regclass",
+	"regcollation",
+	"regconfig",
+	"regdictionary",
+	"regnamespace",
+	"regoper",
+	"regoperator",
+	"regprocedure",
+	"regrole",
+	"regtype",
+	"tid",
+	"tsmultirange",
+	"tsquery",
+	"tstzmultirange",
+	"tsvector",
+	"txid_snapshot",
+	"varbit",
+	"xid",
+	"xid8",
+	"xml"
+]);
+var ARGUMENT_DROPPING_TYPES = /* @__PURE__ */ new Set([
+	"blob",
+	"text",
+	"time",
+	"time without time zone",
+	"timestamp with time zone",
+	"timestamptz"
+]);
+var MYSQL_GEOMETRY_MEMBERS = /* @__PURE__ */ new Map([
+	["geometry", `${TYPES}.GEOMETRY`],
+	["linestring", `${TYPES}.GEOMETRY("LINESTRING")`],
+	["point", `${TYPES}.GEOMETRY("POINT")`],
+	["polygon", `${TYPES}.GEOMETRY("POLYGON")`]
+]);
+var MYSQL_GEOMETRY_TYPES = /* @__PURE__ */ new Set([
+	"geomcollection",
+	"geometry",
+	"geometrycollection",
+	"linestring",
+	"multilinestring",
+	"multipoint",
+	"multipolygon",
+	"point",
+	"polygon"
+]);
+var SQLSERVER_ANNOTATIONS = /* @__PURE__ */ new Map([
+	["geography", "Buffer"],
+	["geometry", "Buffer"],
+	["hierarchyid", "Buffer"],
+	["json", "string"],
+	["sql_variant", "unknown"]
+]);
+var ORACLE_VECTOR_ARRAYS = /* @__PURE__ */ new Map([
+	["binary", "Uint8Array"],
+	["float32", "Float32Array"],
+	["float64", "Float64Array"],
+	["int8", "Int8Array"]
+]);
+var ORACLE_ANY_VECTOR = Array.from(ORACLE_VECTOR_ARRAYS.values()).sort().join(" | ");
+var TYPE_ARGUMENTS = /\(([^)]*)\)/;
+var SQLSERVER_MAX_TYPES = /* @__PURE__ */ new Set([
+	"national char varying",
+	"national character varying",
+	"nvarchar"
+]);
+var SQLSERVER_DATE_TYPES = /* @__PURE__ */ new Set([
+	"datetime2",
+	"datetimeoffset",
+	"time"
+]);
+var listedNames = /* @__PURE__ */ new Map();
+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 = createModelContext(state);
+	tables.forEach((table, index) => {
+		if (index !== 0) stringBuffer.push("");
+		formatModel(state, {
+			buffer: stringBuffer,
+			table
+		}, context);
+	});
+	formatAssociations(state, stringBuffer, context, context.relationships);
+	stringBuffer.push("");
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const context = createModelContext(state);
+	formatModel(state, {
+		buffer,
+		table
+	}, context);
+	formatAssociations(state, buffer, context, context.relationships.filter(({ relationship }) => relationship.start.tableId === table.id || relationship.end.tableId === table.id));
+}
+function formatModel(state, { buffer, table }, context) {
+	const { settings: { database }, collections } = state;
+	const naming = getNaming(state, context, table);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(naming.columnIds);
+	const columnBuffer = [];
+	const attributes = {
+		open: "{",
+		entries: []
+	};
+	let hasAutoIncrement = columns.some((column) => bHas(column.options, ColumnOption.autoIncrement));
+	columns.forEach((column) => {
+		const facts = getColumnType$1(column.dataType, database);
+		const columnContext = {
+			property: naming.columnNames.get(column.id) ?? column.name,
+			type: getColumnType(column.dataType, facts, database),
+			flags: columnFlags(column, facts, database, hasAutoIncrement)
+		};
+		hasAutoIncrement ||= columnContext.flags.isAutoIncrement;
+		formatColumnProperty({
+			buffer: columnBuffer,
+			column
+		}, columnContext);
+		attributes.entries.push(createAttribute(column, columnContext));
+	});
+	const relationBuffer = [];
+	formatRelationProperty(state, {
+		buffer: relationBuffer,
+		table
+	}, context);
+	buffer.push(`export class ${naming.className} extends ${MODEL}<`);
+	buffer.push(`${INDENT}${wrap("InferAttributes", naming.className)},`);
+	buffer.push(`${INDENT}${wrap("InferCreationAttributes", naming.className)}`);
+	if (columnBuffer.length === 0 && relationBuffer.length === 0) buffer.push("> {}");
+	else {
+		buffer.push("> {");
+		columnBuffer.forEach((line) => buffer.push(line));
+		if (columnBuffer.length !== 0 && relationBuffer.length !== 0) buffer.push("");
+		relationBuffer.forEach((line) => buffer.push(line));
+		buffer.push("}");
+	}
+	buffer.push("");
+	buffer.push(`${naming.className}.init(`);
+	formatGroup(buffer, INDENT, "", attributes, ",");
+	formatGroup(buffer, INDENT, "", createOptions(state, table, naming, context), "");
+	buffer.push(");");
+}
+function formatColumnProperty({ buffer, column }, { property, type, flags: { isAutoIncrement, isNullable, isWrittenByDatabase } }) {
+	const annotation = isNullable ? `${type.ts} | null` : isAutoIncrement || isWrittenByDatabase || column.default.trim() !== "" ? wrap("CreationOptional", type.ts) : type.ts;
+	buffer.push(`${INDENT}declare ${property}: ${annotation};`);
+}
+function formatRelationProperty(state, { buffer, table }, context) {
+	const naming = getNaming(state, context, table);
+	context.relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach(({ relationship, startTable }) => {
+		const property = naming.relationshipNames.get(relationshipKey(relationship, OWNING));
+		if (!property) return;
+		const parentNaming = getNaming(state, context, startTable);
+		buffer.push(`${INDENT}declare ${property}?: ${wrap("NonAttribute", parentNaming.className)};`);
+	});
+	context.relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable }) => {
+		const property = naming.relationshipNames.get(relationshipKey(relationship, INVERSE));
+		if (!property) return;
+		const childNaming = getNaming(state, context, endTable);
+		const target = hasNRelationship(relationship.relationshipType) ? `${childNaming.className}[]` : childNaming.className;
+		buffer.push(`${INDENT}declare ${property}?: ${wrap("NonAttribute", target)};`);
+	});
+}
+function formatAssociations(state, buffer, context, relationships) {
+	const lines = [];
+	relationships.forEach(({ relationship, startTable, endTable, startColumns, endColumns }) => {
+		const parentNaming = getNaming(state, context, startTable);
+		const childNaming = getNaming(state, context, endTable);
+		const inverse = parentNaming.relationshipNames.get(relationshipKey(relationship, INVERSE));
+		const owning = childNaming.relationshipNames.get(relationshipKey(relationship, OWNING));
+		if (!inverse || !owning) return;
+		const foreignKey = childNaming.columnNames.get(endColumns[0].id);
+		const referenced = parentNaming.columnNames.get(startColumns[0].id);
+		if (!foreignKey || !referenced) return;
+		const method = hasNRelationship(relationship.relationshipType) ? "hasMany" : "hasOne";
+		const actions = referentialActionEntries(relationship, referentialActionSupport(state.settings.database)).map(({ key, sql }) => `${key}: "${sql}"`);
+		formatGroup(lines, "", `${parentNaming.className}.${method}(${childNaming.className}, `, {
+			open: "{",
+			entries: [
+				`foreignKey: "${escapeString(foreignKey)}"`,
+				`sourceKey: "${escapeString(referenced)}"`,
+				`as: "${escapeString(inverse)}"`,
+				...actions
+			]
+		}, ");");
+		formatGroup(lines, "", `${childNaming.className}.belongsTo(${parentNaming.className}, `, {
+			open: "{",
+			entries: [
+				`foreignKey: "${escapeString(foreignKey)}"`,
+				`targetKey: "${escapeString(referenced)}"`,
+				`as: "${escapeString(owning)}"`,
+				...actions
+			]
+		}, ");");
+	});
+	if (lines.length === 0) return;
+	buffer.push("");
+	lines.forEach((line) => buffer.push(line));
+}
+function columnFlags(column, { isSerial, isRowVersion }, database, hasAutoIncrement) {
+	const isPrimaryKey = bHas(column.options, ColumnOption.primaryKey);
+	const isAutoIncrement = bHas(column.options, ColumnOption.autoIncrement) || isSerial && !hasAutoIncrement;
+	return {
+		isPrimaryKey,
+		isAutoIncrement,
+		isNullable: !isPrimaryKey && !(isSerial && database === Database.PostgreSQL) && !bHas(column.options, ColumnOption.notNull),
+		isUnique: !isPrimaryKey && (bHas(column.options, ColumnOption.unique) || isSerial && isMySQLFamily(database)),
+		isWrittenByDatabase: isRowVersion || isSerial && !isAutoIncrement
+	};
+}
+var DATABASE_DEFAULT = `defaultValue: () => ${NAMESPACE}.literal("DEFAULT")`;
+function createAttribute(column, { property, type, flags: { isPrimaryKey, isAutoIncrement, isNullable, isUnique, isWrittenByDatabase } }) {
+	const value = column.default.trim();
+	return {
+		prefix: `${property}: `,
+		group: {
+			open: "{",
+			entries: [
+				`type: ${type.expr}`,
+				...property === column.name ? [] : [`field: "${escapeString(column.name)}"`],
+				...isPrimaryKey ? ["primaryKey: true"] : [],
+				...isAutoIncrement ? ["autoIncrement: true"] : [],
+				`allowNull: ${isNullable}`,
+				...isUnique ? ["unique: true"] : [],
+				...isWrittenByDatabase ? [DATABASE_DEFAULT] : !isAutoIncrement && value !== "" ? [defaultValue(value)] : [],
+				...column.comment.trim() === "" ? [] : [`comment: "${escapeComment(column.comment)}"`]
+			]
+		},
+		suffix: ""
+	};
+}
+var NUMERIC_LITERAL = /^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+var LEADING_PLUS = /^\+/;
+var TRAILING_ZEROS = /\.?0+$/;
+var QUOTED_LITERAL = /^'([^']|'')*'$/;
+var ESCAPED_QUOTE = /''/g;
+function defaultValue(value) {
+	if (NUMERIC_LITERAL.test(value) && isExactNumber(value)) return `defaultValue: ${value}`;
+	if (QUOTED_LITERAL.test(value)) return `defaultValue: "${escapeString(value.slice(1, -1).replace(ESCAPED_QUOTE, "'"))}"`;
+	const lowered = value.toLocaleLowerCase();
+	if (lowered === "true" || lowered === "false") return `defaultValue: ${lowered}`;
+	return `defaultValue: ${NAMESPACE}.literal("${escapeString(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 createOptions(state, table, naming, context) {
+	const indexes = createIndexEntries(state, table, naming, context);
+	return {
+		open: "{",
+		entries: [
+			INSTANCE,
+			`tableName: "${escapeString(table.name)}"`,
+			"timestamps: false",
+			...table.comment.trim() === "" ? [] : [`comment: "${escapeComment(table.comment)}"`],
+			...indexes.length === 0 ? [] : [{
+				prefix: "indexes: ",
+				group: {
+					open: "[",
+					entries: indexes
+				},
+				suffix: ""
+			}]
+		]
+	};
+}
+function createIndexEntries(state, table, naming, { indexNames }) {
+	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 fields = Array.from(new Set(query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).flatMap((indexColumn) => {
+			const column = columnCollection.selectById(indexColumn.columnId);
+			return column && naming.columnNames.has(column.id) ? [column.name] : [];
+		})));
+		if (fields.length === 0) return;
+		entries.push({
+			prefix: "",
+			group: {
+				open: "{",
+				entries: [
+					`name: "${escapeString(indexNames.get(index.id) ?? index.name)}"`,
+					{
+						prefix: "fields: ",
+						group: {
+							open: "[",
+							entries: fields.map((field) => `"${escapeString(field)}"`)
+						},
+						suffix: ""
+					},
+					...index.unique ? ["unique: true"] : []
+				]
+			},
+			suffix: ""
+		});
+	});
+	return entries;
+}
+function inlineEntry(entry) {
+	return typeof entry === "string" ? entry : `${entry.prefix}${inlineGroup(entry.group)}${entry.suffix}`;
+}
+function inlineGroup(group) {
+	if (group.entries.length === 0) return group.open === "[" ? "[]" : "{}";
+	const body = group.entries.map(inlineEntry).join(", ");
+	return group.open === "[" ? `[${body}]` : `{ ${body} }`;
+}
+function formatGroup(buffer, indent, prefix, group, suffix) {
+	const line = `${indent}${prefix}${inlineGroup(group)}${suffix}`;
+	if (line.length <= LINE_LIMIT) {
+		buffer.push(line);
+		return;
+	}
+	buffer.push(`${indent}${prefix}${group.open}`);
+	group.entries.forEach((entry) => {
+		if (typeof entry === "string") {
+			buffer.push(`${indent}${INDENT}${entry},`);
+			return;
+		}
+		formatGroup(buffer, `${indent}${INDENT}`, entry.prefix, entry.group, `${entry.suffix},`);
+	});
+	buffer.push(`${indent}${group.open === "[" ? "]" : "}"}${suffix}`);
+}
+var ZEROFILL = /(^|[^0-9a-z_])zerofill([^0-9a-z_]|$)/i;
+var MAX_LENGTH = /^[^(]*\(\s*max\s*\)/i;
+function getColumnType(dataType, facts, database) {
+	if (facts.base === "") return {
+		expr: STRING,
+		ts: "string"
+	};
+	const element = elementType(facts, database);
+	if (facts.arrayDepth === 0) return element;
+	const isText = POSTGRES_TEXT_ARRAY_TYPES.has(facts.base);
+	const ts = isText ? "string" : `${element.ts.includes(" ") ? `(${element.ts})` : element.ts}${"[]".repeat(facts.arrayDepth)}`;
+	return {
+		expr: facts.arrayDepth === 1 && !isText && !isWrittenAsIs(element.expr) ? `${TYPES}.ARRAY(${element.expr})` : writeAsIs(dataType),
+		ts
+	};
+}
+function elementType(facts, database) {
+	if (facts.base === "enum" && facts.enumMembers) {
+		const quoted = facts.enumMembers.map((member) => `"${escapeString(member)}"`);
+		return {
+			expr: `${TYPES}.ENUM(${quoted.join(", ")})`,
+			ts: quoted.join(" | ")
+		};
+	}
+	return dialectType(facts, database) ?? memberType(facts, database);
+}
+function dialectType(facts, database) {
+	const { base, args, scalar } = facts;
+	if (database === Database.PostgreSQL) {
+		const range = POSTGRES_RANGE_TYPES.get(base);
+		if (range) {
+			const [subtype, bound] = range;
+			return {
+				expr: subtype ? `${TYPES}.RANGE(${subtype})` : writeAsIs(facts.element),
+				ts: `Range<${bound}>`
+			};
+		}
+	}
+	if ((database === Database.PostgreSQL || database === Database.MSSQL) && scalar === "f32") return {
+		expr: `${TYPES}.REAL`,
+		ts: "number"
+	};
+	if (isMySQLFamily(database)) {
+		const geometry = MYSQL_GEOMETRY_MEMBERS.get(base);
+		if (geometry) return {
+			expr: geometry,
+			ts: "object"
+		};
+		if (base === "datetime" && args.length === 1) return {
+			expr: `${TYPES}.DATE(${args[0]})`,
+			ts: "Date"
+		};
+	}
+	if (database === Database.MSSQL) {
+		const isMax = MAX_LENGTH.test(facts.element);
+		if (SQLSERVER_MAX_TYPES.has(base) && isMax) return {
+			expr: `${TYPES}.TEXT`,
+			ts: "string"
+		};
+		if (base === "varbinary" && !isMax) return {
+			expr: writeAsIs(facts.element),
+			ts: "Buffer"
+		};
+		if (SQLSERVER_DATE_TYPES.has(base)) return {
+			expr: DATE_TIME,
+			ts: "Date"
+		};
+	}
+	if (database === Database.Oracle && base === "vector") return {
+		expr: STRING,
+		ts: oracleVectorAnnotation(facts.element)
+	};
+	if (database === Database.Oracle && base === "bfile") return {
+		expr: BLOB.expr,
+		ts: "object"
+	};
+	if (database === Database.SQLite && base === "timestamp") return {
+		expr: writeAsIs(facts.element),
+		ts: "string"
+	};
+	if (scalar === "interval" && database !== Database.PostgreSQL) return {
+		expr: STRING,
+		ts: database === Database.Oracle ? "object" : "string"
+	};
+	return asWritten(facts, database);
+}
+function oracleVectorAnnotation(element) {
+	const [, format = "*", storage = ""] = (TYPE_ARGUMENTS.exec(element)?.[1] ?? "").split(",").map((part) => part.trim().toLowerCase());
+	if (storage === "sparse") return "object";
+	return ORACLE_VECTOR_ARRAYS.get(format) ?? ORACLE_ANY_VECTOR;
+}
+function asWritten(facts, database) {
+	const members = MEMBER_TYPES.get(database);
+	if (!members || !isListedName(facts.base, database) || members.has(facts.base) && !(facts.args.length !== 0 && ARGUMENT_DROPPING_TYPES.has(facts.base))) return null;
+	return {
+		expr: writeAsIs(facts.element),
+		ts: writtenAnnotation(facts, database)
+	};
+}
+function writtenAnnotation(facts, database) {
+	const { base, scalar } = facts;
+	if (database === Database.PostgreSQL && (POSTGRES_OBJECT_TYPES.has(base) || scalar === "interval")) return "object";
+	if (isMySQLFamily(database) && base === "bit") return database === Database.MariaDB && scalar === "bool" ? "boolean" : "Buffer";
+	if (database === Database.MariaDB && base === "set") {
+		const members = facts.setMembers?.map((member) => `"${escapeString(member)}"`);
+		return members ? `(${members.join(" | ")})[]` : "string[]";
+	}
+	if (database === Database.MariaDB && base === "vector") return "Buffer";
+	if (isMySQLFamily(database) && MYSQL_GEOMETRY_TYPES.has(base)) return "object";
+	if (database === Database.MSSQL) {
+		const annotation = SQLSERVER_ANNOTATIONS.get(base);
+		if (annotation) return annotation;
+	}
+	if (facts.isTextInteger) return "string";
+	if (scalar === "decimal") return DECIMAL_ANNOTATIONS.get(database) ?? SCALAR_ANNOTATIONS[scalar];
+	return SCALAR_ANNOTATIONS[scalar];
+}
+function memberType(facts, database) {
+	const emission = vendorTypeMap.get(facts.base) ?? (facts.scalar === "bytes" ? BLOB : fallbackTypeMap[getPrimitiveType(facts.element, database)]);
+	const expr = isMySQLFamily(database) && facts.args.length === 2 && (emission.expr === FLOAT || emission.expr === DOUBLE) ? `${emission.expr}(${facts.args[0]}, ${facts.args[1]})` : applyArguments(emission, facts.args);
+	const isNumeric = isMySQLFamily(database) && NUMERIC_EXPRESSIONS.has(emission.expr);
+	const unsigned = isNumeric && facts.isUnsigned ? ".UNSIGNED" : "";
+	const zerofill = isNumeric && ZEROFILL.test(facts.element) ? ".ZEROFILL" : "";
+	const ts = emission.expr === BIGINT ? BIGINT_ANNOTATIONS.get(database) : emission.expr === DECIMAL ? DECIMAL_ANNOTATIONS.get(database) : void 0;
+	return {
+		expr: `${expr}${unsigned}${zerofill}`,
+		ts: ts ?? emission.ts
+	};
+}
+function applyArguments(emission, args) {
+	if (emission.args === "length" && args.length === 1 && args[0] > 0) return `${emission.expr}(${args[0]})`;
+	if (emission.args === "precision" && args.length === 1) return `${emission.expr}(${args[0]})`;
+	if (emission.args === "precision" && args.length === 2) return `${emission.expr}(${args[0]}, ${args[1]})`;
+	return emission.expr === CHAR ? STRING : emission.expr;
+}
+function isListedName(base, database) {
+	let names = listedNames.get(database);
+	if (!names) {
+		names = new Set(getDataTypeHints(database).map((hint) => hint.name.toLowerCase()));
+		listedNames.set(database, names);
+	}
+	return names.has(base);
+}
+function writeAsIs(dataType) {
+	return `"${escapeString(dataType.trim())}"`;
+}
+function isWrittenAsIs(expr) {
+	return expr.startsWith("\"");
+}
+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 createModelContext(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, 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;
+}
+function createTableNaming(state, table, { relationships, classNames }) {
+	const { settings: { tableNameCase, columnNameCase }, collections } = state;
+	const used = new Set(MODEL_MEMBER_NAMES);
+	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 className = uniqueName(classNames, classIdentifier(tsIdentifier(getNameCase(table.name, tableNameCase))));
+	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);
+	});
+	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), uniqueAlias(used, tsIdentifier(getNameCase(name, columnNameCase)), ONE_ACCESSORS, className));
+	});
+	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), uniqueAlias(used, tsIdentifier(name), hasNRelationship(relationship.relationshipType) ? MANY_ACCESSORS : ONE_ACCESSORS, className));
+	});
+	return {
+		className,
+		columnIds: declared.map((column) => column.id),
+		columnNames,
+		relationshipNames
+	};
+}
+function relationshipKey(relationship, side) {
+	return `${relationship.id}:${side}`;
+}
+function isSelfReferential(relationship) {
+	return relationship.start.tableId === relationship.end.tableId;
+}
+var ONE_ACCESSORS = [
+	"create",
+	"get",
+	"set"
+];
+var MANY_ACCESSORS = [
+	"add",
+	"count",
+	"create",
+	"get",
+	"has",
+	"remove",
+	"set"
+];
+function numberName(name, isTaken) {
+	let result = name;
+	let index = 2;
+	while (isTaken(result)) {
+		result = `${name}${index}`;
+		index += 1;
+	}
+	return result;
+}
+function uniqueName(used, name) {
+	const result = numberName(name, (candidate) => used.has(candidate));
+	used.add(result);
+	return result;
+}
+function uniqueAlias(used, name, accessors, className) {
+	const tableAlias = className.toLowerCase();
+	const accessorsOf = (alias) => accessors.map((verb) => `${verb}${upperFirst(alias)}`);
+	const result = numberName(name, (candidate) => used.has(candidate) || candidate.toLowerCase() === tableAlias || accessorsOf(candidate).some((accessor) => used.has(accessor)));
+	used.add(result);
+	accessorsOf(result).forEach((accessor) => used.add(accessor));
+	return result;
+}
+function upperFirst(name) {
+	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+}
+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 RESERVED_CLASS_NAMES = /* @__PURE__ */ new Set([
+	"Object",
+	"__dirname",
+	"__filename",
+	"__proto__",
+	"any",
+	"bigint",
+	"boolean",
+	"exports",
+	"infer",
+	"keyof",
+	"module",
+	"never",
+	"number",
+	"object",
+	"readonly",
+	"require",
+	"string",
+	"symbol",
+	"undefined",
+	"unique",
+	"unknown"
+]);
+function classIdentifier(identifier) {
+	return RESERVED_CLASS_NAMES.has(identifier) ? `${identifier}_` : identifier;
+}
+var BACKSLASH = /\\/g;
+var DOUBLE_QUOTE = /"/g;
+var NEWLINE = /\r\n|\r|\n/g;
+var CARRIAGE_RETURN = /\r/g;
+var LINE_FEED = /\n/g;
+function escapeString(value) {
+	return value.replace(BACKSLASH, "\\\\").replace(DOUBLE_QUOTE, "\\\"").replace(CARRIAGE_RETURN, "\\r").replace(LINE_FEED, "\\n");
+}
+function escapeComment(value) {
+	return escapeString(value.replace(NEWLINE, "\n"));
+}
+//#endregion
+export { createCode, formatTable };