@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,230 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { orderByNameASC } from "../tableName.js";
+import { getNameCase, getPrimitiveType } from "./utils.js";
+import { BINARY_TYPES, MONEY_TYPES, POSTGRES_OBJECT_ID_TYPES, TIMESTAMP_TZ_TYPES, UUID_TYPES, getColumnType, isMySQLFamily } from "./columnTypes.js";
+//#region src/utils/generator-code/csharp.ts
+var convertTypeMap = {
+	int: "int",
+	long: "long",
+	float: "float",
+	double: "double",
+	decimal: "decimal",
+	boolean: "bool",
+	string: "string",
+	lob: "string",
+	date: "DateTime",
+	dateTime: "DateTime",
+	time: "TimeSpan"
+};
+var NEWLINE = /\r\n|\r|\n|\u0085|\u2028|\u2029/g;
+var unsignedTypes = {
+	u8: "byte",
+	u16: "ushort",
+	u32: "uint",
+	u64: "ulong"
+};
+var mssqlTypes = /* @__PURE__ */ new Map([
+	["rowversion", "byte[]"],
+	["sql_variant", "object"],
+	["timestamp", "byte[]"],
+	["tinyint", "byte"]
+]);
+var postgresTypes = /* @__PURE__ */ new Map([
+	["pg_lsn", "ulong"],
+	["regconfig", "uint"],
+	["regtype", "uint"]
+]);
+var vendorTypes = /* @__PURE__ */ new Map([[Database.MSSQL, mssqlTypes], [Database.PostgreSQL, postgresTypes]]);
+var referenceTypes = /* @__PURE__ */ new Set([
+	"byte[]",
+	"object",
+	"string"
+]);
+var COLUMN_ATTRIBUTE = "global::System.ComponentModel.DataAnnotations.Schema.Column";
+var FORMAT_CHARACTERS = /\p{Cf}/gu;
+var SURROUNDING_SPACE = /^[\s\u0085]+|[\s\u0085]+$/g;
+var CSHARP_KEYWORDS = /* @__PURE__ */ new Set([
+	"__arglist",
+	"__makeref",
+	"__reftype",
+	"__refvalue",
+	"abstract",
+	"as",
+	"base",
+	"bool",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"checked",
+	"class",
+	"const",
+	"continue",
+	"decimal",
+	"default",
+	"delegate",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"event",
+	"explicit",
+	"extension",
+	"extern",
+	"false",
+	"file",
+	"finally",
+	"fixed",
+	"float",
+	"for",
+	"foreach",
+	"goto",
+	"if",
+	"implicit",
+	"in",
+	"int",
+	"interface",
+	"internal",
+	"is",
+	"lock",
+	"long",
+	"namespace",
+	"new",
+	"null",
+	"object",
+	"operator",
+	"out",
+	"override",
+	"params",
+	"private",
+	"protected",
+	"public",
+	"readonly",
+	"record",
+	"ref",
+	"required",
+	"return",
+	"sbyte",
+	"scoped",
+	"sealed",
+	"short",
+	"sizeof",
+	"stackalloc",
+	"static",
+	"string",
+	"struct",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"uint",
+	"ulong",
+	"unchecked",
+	"unsafe",
+	"ushort",
+	"using",
+	"virtual",
+	"void",
+	"volatile",
+	"while"
+]);
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const stringBuffer = [""];
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		formatTable(state, {
+			buffer: stringBuffer,
+			table
+		});
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const { settings: { tableNameCase, columnNameCase }, collections } = state;
+	const className = getNameCase(table.name, tableNameCase);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const properties = toProperties(className, columns.map((column) => {
+		const columnName = getNameCase(column.name, columnNameCase);
+		return columnName.charAt(0).toUpperCase() + columnName.slice(1);
+	}));
+	formatComment(buffer, "", table.comment);
+	buffer.push(`public class ${toIdentifier(className)} {`);
+	columns.forEach((column, index) => {
+		formatColumn(state, {
+			buffer,
+			column
+		}, properties[index]);
+	});
+	buffer.push(`}`);
+}
+function toProperties(className, names) {
+	const owner = identifierText(className);
+	const taken = /* @__PURE__ */ new Set([owner, ...names.map(identifierText)]);
+	return names.map((name) => {
+		if (owner === "" || identifierText(name) !== owner) return {
+			name: toIdentifier(name),
+			isRenamed: false
+		};
+		let suffix = 1;
+		while (taken.has(`${owner}${suffix}`)) suffix++;
+		taken.add(`${owner}${suffix}`);
+		return {
+			name: `${owner}${suffix}`,
+			isRenamed: true
+		};
+	});
+}
+function identifierText(name) {
+	return name.replace(FORMAT_CHARACTERS, "").replace(SURROUNDING_SPACE, "").replace(/^@/, "");
+}
+function formatColumn({ settings: { database } }, { buffer, column }, { name: propertyName, isRenamed }) {
+	const columnType = getColumnType(column.dataType, database);
+	const type = arrayType(getElementType(columnType, database), columnType.arrayDepth);
+	const isNullable = !bHas(column.options, ColumnOption.primaryKey) && !bHas(column.options, ColumnOption.notNull);
+	formatComment(buffer, "  ", column.comment);
+	if (isRenamed) buffer.push(`  [${COLUMN_ATTRIBUTE}(${toStringLiteral(column.name)})]`);
+	if (isNullable) buffer.push(`  public ${type}? ${propertyName} { get; set; }`);
+	else if (columnType.arrayDepth > 0 || referenceTypes.has(type)) buffer.push(`  public ${type} ${propertyName} { get; set; } = null!;`);
+	else buffer.push(`  public ${type} ${propertyName} { get; set; }`);
+}
+function toIdentifier(name) {
+	const word = name.replace(SURROUNDING_SPACE, "");
+	return CSHARP_KEYWORDS.has(word) ? name.replace(word, `@${word}`) : name;
+}
+function toStringLiteral(value) {
+	return JSON.stringify(value).replace(NEWLINE, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+function formatComment(buffer, indent, comment) {
+	const lines = comment.split(NEWLINE).map((line) => line.trimEnd());
+	while (lines[0] === "") lines.shift();
+	while (lines[lines.length - 1] === "") lines.pop();
+	lines.forEach((line) => buffer.push(line === "" ? `${indent}//` : `${indent}// ${line}`));
+}
+function getElementType({ element, base, scalar, isUnsigned }, database) {
+	const unsignedType = isUnsigned || readsUnsigned(base, database) ? unsignedTypes[scalar] : void 0;
+	if (BINARY_TYPES.has(base)) return "byte[]";
+	if (UUID_TYPES.has(base)) return "Guid";
+	if (TIMESTAMP_TZ_TYPES.has(base) || scalar === "timeTz") return "DateTimeOffset";
+	if (MONEY_TYPES.has(base)) return "decimal";
+	if (unsignedType) return unsignedType;
+	if (scalar === "i64") return "long";
+	if (base === "smallint") return "short";
+	if (scalar === "f64") return "double";
+	return vendorTypes.get(database)?.get(base) ?? convertTypeMap[getPrimitiveType(element, database)];
+}
+function readsUnsigned(base, database) {
+	return isMySQLFamily(database) ? base === "bit" : database === Database.PostgreSQL && POSTGRES_OBJECT_ID_TYPES.has(base);
+}
+function arrayType(elementType, depth) {
+	if (depth === 0) return elementType;
+	const rank = `[${",".repeat(depth - 1)}]`;
+	return elementType.endsWith("[]") ? `${elementType.slice(0, -2)}${rank}[]` : `${elementType}${rank}`;
+}
+//#endregion
+export { createCode, formatTable };

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

@@ -0,0 +1,248 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { orderByNameASC } from "../tableName.js";
+import { toDBMLColor } from "../tableColor.js";
+import { hasNRelationship, hasOneRelationship, referentialActionEntries } from "./utils.js";
+//#region src/utils/generator-code/dbml.ts
+var BARE_DATA_TYPE = /^[A-Za-z_][0-9A-Za-z_]*(\([0-9]+(,[0-9]+)*\))?$/;
+var NUMERIC_LITERAL = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+var KEYWORD_LITERAL = /^(true|false|null)$/i;
+var QUOTED_LITERAL = /^'([^']|'')*'$/;
+var ESCAPED_QUOTE = /''/g;
+var NAME_ESCAPE = /["\\\n\r]/g;
+var NOTE_ESCAPE = /['\\\n\r]/g;
+var ESCAPE_MAP = {
+	"\n": "\\n",
+	"\r": "\\r"
+};
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const stringBuffer = [""];
+	const context = createDBMLContext(state);
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		if (!context.tableNames.has(table.id)) return;
+		formatDBMLTable(state, {
+			buffer: stringBuffer,
+			table
+		}, context);
+		stringBuffer.push("");
+	});
+	const relationships = formatRelationships(state, context);
+	if (relationships.length !== 0) {
+		relationships.forEach((line) => stringBuffer.push(line));
+		stringBuffer.push("");
+	}
+	formatTableGroups(state, context).forEach((lines) => {
+		lines.forEach((line) => stringBuffer.push(line));
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	formatDBMLTable(state, {
+		buffer,
+		table
+	}, createDBMLContext(state));
+}
+function formatDBMLTable(state, { buffer, table }, context) {
+	const { collections } = state;
+	const name = context.tableNames.get(table.id);
+	if (name === void 0) return;
+	buffer.push(`Table ${quoteName(name)}${formatTableSettings(table)} {`);
+	query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).forEach((column) => {
+		if (!context.columnIds.has(column.id)) return;
+		buffer.push(`  ${formatColumn(column)}`);
+	});
+	if (table.comment.trim() !== "") {
+		buffer.push("");
+		buffer.push(`  Note: ${quoteNote(table.comment)}`);
+	}
+	const indexes = formatIndexes(state, table, context);
+	if (indexes.length !== 0) {
+		buffer.push("");
+		buffer.push("  Indexes {");
+		indexes.forEach((line) => buffer.push(line));
+		buffer.push("  }");
+	}
+	buffer.push("}");
+}
+function formatTableSettings(table) {
+	const color = toDBMLColor(table.ui.color);
+	return color === null ? "" : ` [headercolor: ${color}]`;
+}
+function formatColumn(column) {
+	const settings = [];
+	if (bHas(column.options, ColumnOption.primaryKey)) settings.push("pk");
+	if (bHas(column.options, ColumnOption.autoIncrement)) settings.push("increment");
+	if (bHas(column.options, ColumnOption.unique)) settings.push("unique");
+	if (bHas(column.options, ColumnOption.notNull)) settings.push("not null");
+	if (column.default.trim() !== "") settings.push(`default: ${formatDefault(column.default)}`);
+	if (column.comment.trim() !== "") settings.push(`note: ${quoteNote(column.comment)}`);
+	return `${quoteName(column.name)} ${formatDataType(column.dataType)}${settings.length === 0 ? "" : ` [${settings.join(", ")}]`}`;
+}
+function formatIndexes({ doc: { indexIds }, collections }, table, context) {
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const indexColumnCollection = query(collections).collection("indexColumnEntities");
+	const buffer = [];
+	query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id).forEach((index) => {
+		const names = [];
+		indexColumnCollection.selectByIds(index.indexColumnIds).forEach((indexColumn) => {
+			const column = columnCollection.selectById(indexColumn.columnId);
+			if (!column || column.tableId !== table.id || !context.columnIds.has(column.id)) return;
+			names.push(quoteName(column.name));
+		});
+		if (names.length === 0) return;
+		const settings = [];
+		if (index.name.trim() !== "") settings.push(`name: ${quoteName(index.name)}`);
+		if (index.unique) settings.push("unique");
+		buffer.push(`    (${names.join(", ")})${settings.length === 0 ? "" : ` [${settings.join(", ")}]`}`);
+	});
+	return buffer;
+}
+function formatRelationships({ doc: { relationshipIds }, collections }, context) {
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const buffer = [];
+	const used = /* @__PURE__ */ new Set();
+	const resolveEndpoint = (point) => {
+		const table = context.tableNames.get(point.tableId);
+		if (table === void 0 || point.columnIds.length === 0) return null;
+		const columns = [];
+		for (const columnId of point.columnIds) {
+			const column = columnCollection.selectById(columnId);
+			if (!column || column.tableId !== point.tableId || !context.columnIds.has(column.id)) return null;
+			columns.push(column.name);
+		}
+		return {
+			table,
+			columns
+		};
+	};
+	query(collections).collection("relationshipEntities").selectByIds(relationshipIds).forEach((relationship) => {
+		const operator = relationshipOperator(relationship);
+		const start = resolveEndpoint(relationship.start);
+		const end = resolveEndpoint(relationship.end);
+		if (operator === "" || start === null || end === null || start.columns.length !== end.columns.length) return;
+		const startText = formatEndpoint(start);
+		const endText = formatEndpoint(end);
+		const key = [startText, endText].sort().join(" ");
+		if (used.has(key)) return;
+		used.add(key);
+		buffer.push(`Ref: ${startText} ${operator} ${endText}${formatRefSettings(relationship)}`);
+	});
+	return buffer;
+}
+function formatTableGroups({ doc: { tableIds, tableGroupIds }, collections }, context) {
+	const membersByGroup = /* @__PURE__ */ new Map();
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		const name = context.tableNames.get(table.id);
+		if (name === void 0 || !table.groupId) return;
+		const members = membersByGroup.get(table.groupId);
+		members ? members.push(name) : membersByGroup.set(table.groupId, [name]);
+	});
+	const groups = query(collections).collection("tableGroupEntities").selectByIds(tableGroupIds).filter((group) => membersByGroup.has(group.id));
+	const names = tableGroupNames(groups);
+	return groups.map((group, index) => ({
+		group,
+		name: names[index]
+	})).sort(orderByNameASC).map(({ group, name }) => [
+		`TableGroup ${quoteName(name)}${formatTableGroupSettings(group)} {`,
+		...membersByGroup.get(group.id).map((member) => `  ${quoteName(member)}`),
+		"}"
+	]);
+}
+function formatTableGroupSettings(group) {
+	const color = toDBMLColor(group.color);
+	return color === null ? "" : ` [color: ${color}]`;
+}
+function tableGroupNames(groups) {
+	const held = new Set(groups.map(({ name }) => name).filter((name) => name.trim() !== ""));
+	const used = /* @__PURE__ */ new Set();
+	let unnamed = 0;
+	const free = (name) => !used.has(name) && !held.has(name);
+	return groups.map(({ name }) => {
+		let result = name;
+		if (name.trim() === "") do {
+			unnamed += 1;
+			result = `group_${unnamed}`;
+		} while (!free(result));
+		else if (used.has(name)) {
+			let index = 2;
+			result = `${name}_${index}`;
+			while (!free(result)) {
+				index += 1;
+				result = `${name}_${index}`;
+			}
+		}
+		used.add(result);
+		return result;
+	});
+}
+function createDBMLContext(state) {
+	const { doc: { tableIds }, collections } = state;
+	const context = {
+		tableNames: /* @__PURE__ */ new Map(),
+		columnIds: /* @__PURE__ */ new Set()
+	};
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const usedTableNames = /* @__PURE__ */ new Set();
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		const usedColumnNames = /* @__PURE__ */ new Set();
+		let count = 0;
+		columnCollection.selectByIds(table.columnIds).forEach((column) => {
+			if (column.dataType.trim() === "" || usedColumnNames.has(column.name)) return;
+			usedColumnNames.add(column.name);
+			context.columnIds.add(column.id);
+			count += 1;
+		});
+		if (count === 0) return;
+		context.tableNames.set(table.id, uniqueName(usedTableNames, table.name));
+	});
+	return context;
+}
+function formatEndpoint({ table, columns }) {
+	const names = columns.map(quoteName);
+	return `${quoteName(table)}.${names.length === 1 ? names[0] : `(${names.join(", ")})`}`;
+}
+function formatRefSettings(relationship) {
+	const settings = referentialActionEntries(relationship).map(({ key, sql }) => `${key === "onDelete" ? "delete" : "update"}: ${sql.toLowerCase()}`);
+	return settings.length ? ` [${settings.join(", ")}]` : "";
+}
+function relationshipOperator(relationship) {
+	if (hasNRelationship(relationship.relationshipType)) return "<";
+	if (hasOneRelationship(relationship.relationshipType)) return "-";
+	return "";
+}
+function formatDataType(dataType) {
+	const value = dataType.trim();
+	return BARE_DATA_TYPE.test(value) ? value : quoteName(value);
+}
+function formatDefault(value) {
+	const trimmed = value.trim();
+	if (NUMERIC_LITERAL.test(trimmed)) return trimmed;
+	if (KEYWORD_LITERAL.test(trimmed)) return trimmed.toLocaleLowerCase();
+	if (QUOTED_LITERAL.test(trimmed)) return quoteNote(trimmed.slice(1, -1).replace(ESCAPED_QUOTE, "'"));
+	if (trimmed.includes("`")) return quoteNote(trimmed);
+	return `\`${trimmed}\``;
+}
+function quoteName(value) {
+	return `"${escapeValue(value, NAME_ESCAPE)}"`;
+}
+function quoteNote(value) {
+	return `'${escapeValue(value, NOTE_ESCAPE)}'`;
+}
+function escapeValue(value, pattern) {
+	return value.replace(pattern, (char) => ESCAPE_MAP[char] ?? `\\${char}`);
+}
+function uniqueName(used, name) {
+	let result = name;
+	let index = 2;
+	while (used.has(result)) {
+		result = `${name}${index}`;
+		index += 1;
+	}
+	used.add(result);
+	return result;
+}
+//#endregion
+export { createCode, formatTable };