@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,130 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnUIKey, RelationshipType, StartRelationshipType } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { orderByNameASC } from "../tableName.js";
+import { getUniqueIndexKeys } from "../tableKeys.js";
+//#region src/utils/generator-code/mermaid.ts
+var ATTRIBUTE_WORD = /^[*A-Za-z_\u00c0-\uffff][A-Za-z0-9\-_[\]().,\u00c0-\uffff*]*$/i;
+var ATTRIBUTE_KEY = /^(PK|FK|UK)\b/i;
+var LEADING_SPACE = /^\s/;
+var ENTITY_NAME_EXCLUDED = /["%\r\n\v\b\\]/g;
+var BACKTICK = /`/g;
+var DOUBLE_QUOTE = /"/g;
+var LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/g;
+var GENERIC_TYPE_RUN = /^\S*~.*~/;
+var TILDE = /~/g;
+var FULLWIDTH_TILDE = "～";
+var DIRECTIVE_OPEN = /%%\{/g;
+var DIRECTIVE_OPEN_FULLWIDTH = "%%｛";
+var DIRECTION_STATEMENT = /d;*i;*r;*e;*c;*t;*i;*o;*n(?=[\s;]*\s[\s;]*(?:T;*B|B;*T|R;*L|L;*R))/gi;
+var ZERO_WIDTH_SPACE = "​";
+var UNNAMED = "unnamed";
+var UNKNOWN_TYPE = "unknown";
+var CHILD_CARDINALITY = {
+	[1]: "o{",
+	[RelationshipType.ZeroOne]: "o|",
+	[RelationshipType.ZeroN]: "o{",
+	[RelationshipType.OneOnly]: "||",
+	[RelationshipType.OneN]: "|{",
+	[32]: "||",
+	[64]: "|{"
+};
+function createCode(state) {
+	const tables = selectTables(state);
+	if (tables.length === 0) return "";
+	const entityNames = createEntityNames(tables);
+	const buffer = ["", "erDiagram"];
+	tables.forEach((table) => {
+		formatEntity(state, buffer, table, entityNames.get(table.id));
+		buffer.push("");
+	});
+	const relationships = formatRelationships(state, tables, entityNames);
+	if (relationships.length !== 0) {
+		relationships.forEach((line) => buffer.push(line));
+		buffer.push("");
+	}
+	return buffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const name = createEntityNames(selectTables(state)).get(table.id) ?? toEntityName(table.name);
+	buffer.push("erDiagram");
+	formatEntity(state, buffer, table, name);
+}
+function selectTables({ doc: { tableIds }, collections }) {
+	return query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+}
+function createEntityNames(tables) {
+	const used = /* @__PURE__ */ new Set();
+	return new Map(tables.map((table) => [table.id, uniqueName(used, toEntityName(table.name))]));
+}
+function formatEntity(state, buffer, table, name) {
+	if (table.comment.trim() !== "") buffer.push(`  %% ${toText(table.comment)}`);
+	buffer.push(`  "${name}" {`);
+	const uniqueColumnIds = getUniqueIndexColumnIds(state, table);
+	query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds).forEach((column) => {
+		buffer.push(`    ${formatAttribute(column, uniqueColumnIds)}`);
+	});
+	buffer.push("  }");
+}
+function formatAttribute(column, uniqueColumnIds) {
+	const dataType = column.dataType.trim();
+	const parts = [`${dataType === "" ? UNKNOWN_TYPE : toAttributeWord(dataType)}${bHas(column.options, ColumnOption.notNull) ? "" : "?"}`, toAttributeWord(columnName(column))];
+	const keys = [];
+	if (bHas(column.options, ColumnOption.primaryKey)) keys.push("PK");
+	if (bHas(column.ui.keys, ColumnUIKey.foreignKey)) keys.push("FK");
+	if (bHas(column.options, ColumnOption.unique) || uniqueColumnIds.has(column.id)) keys.push("UK");
+	if (keys.length !== 0) parts.push(keys.join(", "));
+	if (column.comment.trim() !== "") parts.push(`"${toQuoted(column.comment)}"`);
+	return joinAttribute(parts);
+}
+function joinAttribute(parts) {
+	const line = parts.join(" ");
+	return parts.some((_, index) => GENERIC_TYPE_RUN.test(parts.slice(index).join(" "))) ? line.replace(TILDE, FULLWIDTH_TILDE) : line;
+}
+function getUniqueIndexColumnIds(state, table) {
+	return new Set(getUniqueIndexKeys(state, table).filter((key) => key.columnIds.length === 1).map((key) => key.columnIds[0]));
+}
+function formatRelationships({ doc: { relationshipIds }, collections }, tables, entityNames) {
+	const columns = query(collections).collection("tableColumnEntities");
+	const tableColumnIds = new Set(tables.flatMap((table) => table.columnIds));
+	return query(collections).collection("relationshipEntities").selectByIds(relationshipIds).flatMap((relationship) => {
+		const parent = entityNames.get(relationship.start.tableId);
+		const child = entityNames.get(relationship.end.tableId);
+		const childCardinality = CHILD_CARDINALITY[relationship.relationshipType];
+		if (parent === void 0 || child === void 0 || childCardinality === void 0) return [];
+		const label = columns.selectByIds(relationship.end.columnIds).filter((column) => column.tableId === relationship.end.tableId && tableColumnIds.has(column.id)).map(columnName).join(", ");
+		return [`  "${parent}" ${relationship.startRelationshipType === StartRelationshipType.ring ? "|o" : "||"}${relationship.identification ? "--" : ".."}${childCardinality} "${child}" : "${breakDirection(toQuoted(label))}"`];
+	});
+}
+function columnName({ name }) {
+	return name.trim() === "" ? UNNAMED : name;
+}
+function toEntityName(name) {
+	const value = name.replace(ENTITY_NAME_EXCLUDED, "");
+	return value.trim() === "" ? UNNAMED : breakDirection(value);
+}
+function toAttributeWord(value) {
+	if (ATTRIBUTE_WORD.test(value) && !LEADING_SPACE.test(value) && !ATTRIBUTE_KEY.test(value)) return value;
+	return `\`${toText(value).replace(BACKTICK, "'")}\``;
+}
+function toQuoted(value) {
+	return toText(value).replace(DOUBLE_QUOTE, "'");
+}
+function toText(value) {
+	return value.replace(LINE_TERMINATOR, " ").replace(DIRECTIVE_OPEN, DIRECTIVE_OPEN_FULLWIDTH);
+}
+function breakDirection(value) {
+	return value.replace(DIRECTION_STATEMENT, `$&${ZERO_WIDTH_SPACE}`);
+}
+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 };

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

@@ -0,0 +1,211 @@
+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 { baseTypeName, fractionalNumber, getNameCase, getPrimitiveType } from "./utils.js";
+import { POSTGRES_BIT_TYPES } from "./columnTypes.js";
+//#region src/utils/generator-code/php.ts
+var PHP_HEADER = [
+	"<?php",
+	"",
+	"declare(strict_types=1);"
+];
+var INDENT = "    ";
+var convertTypeMap = {
+	int: "int",
+	long: "int",
+	float: "float",
+	double: "float",
+	decimal: "string",
+	boolean: "bool",
+	string: "string",
+	lob: "string",
+	date: "\\DateTimeImmutable",
+	dateTime: "\\DateTimeImmutable",
+	time: "string"
+};
+var stringTypes = /* @__PURE__ */ new Set([
+	"money",
+	"pg_lsn",
+	"smallmoney"
+]);
+var mssqlTypes = /* @__PURE__ */ new Map([["bit", "bool"], ["numeric", "string"]]);
+var RESERVED_CLASS_NAMES = /* @__PURE__ */ new Set([
+	"_",
+	"__class__",
+	"__dir__",
+	"__file__",
+	"__function__",
+	"__halt_compiler",
+	"__line__",
+	"__method__",
+	"__namespace__",
+	"__property__",
+	"__trait__",
+	"abstract",
+	"and",
+	"array",
+	"as",
+	"bool",
+	"break",
+	"callable",
+	"case",
+	"catch",
+	"class",
+	"clone",
+	"const",
+	"continue",
+	"declare",
+	"default",
+	"die",
+	"do",
+	"echo",
+	"else",
+	"elseif",
+	"empty",
+	"enddeclare",
+	"endfor",
+	"endforeach",
+	"endif",
+	"endswitch",
+	"endwhile",
+	"eval",
+	"exit",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"fn",
+	"for",
+	"foreach",
+	"function",
+	"global",
+	"goto",
+	"if",
+	"implements",
+	"include",
+	"include_once",
+	"instanceof",
+	"insteadof",
+	"int",
+	"interface",
+	"isset",
+	"iterable",
+	"list",
+	"match",
+	"mixed",
+	"namespace",
+	"never",
+	"new",
+	"null",
+	"object",
+	"or",
+	"parent",
+	"print",
+	"private",
+	"protected",
+	"public",
+	"readonly",
+	"require",
+	"require_once",
+	"return",
+	"self",
+	"static",
+	"string",
+	"switch",
+	"throw",
+	"trait",
+	"true",
+	"try",
+	"unset",
+	"use",
+	"var",
+	"void",
+	"while",
+	"xor",
+	"yield"
+]);
+var LINE_BREAK = /\r\n|\r|\n/;
+var COMMENT_END = /\*\//g;
+var POSTGRES_ARRAY = /(\[\s*\d*\s*\]|\barray)\s*$/i;
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+	if (tables.length === 0) return "";
+	const buffer = [...PHP_HEADER];
+	tables.forEach((table) => {
+		buffer.push("");
+		formatTable(state, {
+			buffer,
+			table
+		});
+	});
+	buffer.push("");
+	return buffer.join("\n");
+}
+function createTableCode(state, table) {
+	const buffer = [...PHP_HEADER, ""];
+	formatTable(state, {
+		buffer,
+		table
+	});
+	buffer.push("");
+	return buffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const { settings: { tableNameCase }, collections } = state;
+	const className = toClassName(getNameCase(table.name, tableNameCase));
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	formatDocComment(buffer, "", table.comment);
+	if (columns.length === 0) {
+		buffer.push(`class ${className} {}`);
+		return;
+	}
+	buffer.push(`class ${className}`);
+	buffer.push("{");
+	columns.forEach((column) => {
+		formatColumn(state, {
+			buffer,
+			column
+		});
+	});
+	buffer.push("}");
+}
+function formatColumn({ settings: { columnNameCase, database } }, { buffer, column }) {
+	const name = getNameCase(column.name, columnNameCase);
+	const type = getColumnType(column.dataType, database);
+	const isNullable = !bHas(column.options, ColumnOption.primaryKey) && !bHas(column.options, ColumnOption.notNull);
+	formatDocComment(buffer, INDENT, column.comment);
+	buffer.push(isNullable ? `${INDENT}public ?${type} $${name} = null;` : `${INDENT}public ${type} $${name};`);
+}
+function getColumnType(dataType, database) {
+	const base = baseTypeName(dataType);
+	if (stringTypes.has(base) || isPostgresArray(dataType, database) || database === Database.PostgreSQL && POSTGRES_BIT_TYPES.has(base) || fractionalNumber(dataType, database) !== null) return "string";
+	if (database === Database.MSSQL) {
+		const mssqlType = mssqlTypes.get(base);
+		if (mssqlType) return mssqlType;
+	}
+	return convertTypeMap[getPrimitiveType(dataType, database)];
+}
+function isPostgresArray(dataType, database) {
+	return database === Database.PostgreSQL && POSTGRES_ARRAY.test(dataType);
+}
+function toClassName(name) {
+	return RESERVED_CLASS_NAMES.has(name.toLowerCase()) ? `${name}_` : name;
+}
+function formatDocComment(buffer, indent, comment) {
+	const lines = comment.replace(COMMENT_END, "*\\/").split(LINE_BREAK).map((line) => line.trimEnd());
+	while (lines[0] === "") lines.shift();
+	while (lines[lines.length - 1] === "") lines.pop();
+	if (lines.length === 0) return;
+	if (lines.length === 1) {
+		buffer.push(`${indent}/** ${lines[0].trim()} */`);
+		return;
+	}
+	buffer.push(`${indent}/**`);
+	lines.forEach((line) => buffer.push(line === "" ? `${indent} *` : `${indent} * ${line}`));
+	buffer.push(`${indent} */`);
+}
+//#endregion
+export { INDENT, PHP_HEADER, createCode, createTableCode, formatDocComment, formatTable, isPostgresArray, toClassName };

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

@@ -0,0 +1,143 @@
+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 { getNameCase } from "./utils.js";
+import { getRustColumnType } from "./rustTypes.js";
+//#region src/utils/generator-code/rust.ts
+var INDENT = "    ";
+var RUST_KEYWORDS = /* @__PURE__ */ new Set([
+	"abstract",
+	"as",
+	"async",
+	"await",
+	"become",
+	"box",
+	"break",
+	"const",
+	"continue",
+	"do",
+	"dyn",
+	"else",
+	"enum",
+	"extern",
+	"false",
+	"final",
+	"fn",
+	"for",
+	"gen",
+	"if",
+	"impl",
+	"in",
+	"let",
+	"loop",
+	"macro",
+	"match",
+	"mod",
+	"move",
+	"mut",
+	"override",
+	"priv",
+	"pub",
+	"ref",
+	"return",
+	"static",
+	"struct",
+	"trait",
+	"true",
+	"try",
+	"type",
+	"typeof",
+	"unsafe",
+	"unsized",
+	"use",
+	"virtual",
+	"where",
+	"while",
+	"yield"
+]);
+var NON_RAW_NAMES = /* @__PURE__ */ new Set([
+	"_",
+	"crate",
+	"self",
+	"Self",
+	"super"
+]);
+var TYPE_NAMES = /* @__PURE__ */ new Set([
+	"Option",
+	"String",
+	"Vec",
+	"bool",
+	"chrono",
+	"f32",
+	"f64",
+	"i16",
+	"i32",
+	"i64",
+	"i8",
+	"rust_decimal",
+	"serde_json",
+	"u16",
+	"u32",
+	"u64",
+	"u8",
+	"uuid"
+]);
+var LINE_BREAK = /\r\n|\r|\n/;
+var BIDI_CONTROLS = /[\u202A-\u202E\u2066-\u2069]/g;
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const buffer = [""];
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		formatTable(state, {
+			buffer,
+			table
+		});
+		buffer.push("");
+	});
+	return buffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const { settings: { tableNameCase }, collections } = state;
+	const structName = toStructName(getNameCase(table.name, tableNameCase));
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	formatComment(buffer, "", table.comment);
+	buffer.push("#[derive(Debug, Clone, PartialEq)]");
+	if (columns.length === 0) {
+		buffer.push(`pub struct ${structName} {}`);
+		return;
+	}
+	buffer.push(`pub struct ${structName} {`);
+	columns.forEach((column) => {
+		formatColumn(state, {
+			buffer,
+			column
+		});
+	});
+	buffer.push("}");
+}
+function formatColumn({ settings: { columnNameCase, database } }, { buffer, column }) {
+	const name = toRustIdentifier(getNameCase(column.name, columnNameCase));
+	const { rust } = getRustColumnType(column.dataType, database);
+	const isNullable = !bHas(column.options, ColumnOption.primaryKey) && !bHas(column.options, ColumnOption.notNull);
+	formatComment(buffer, INDENT, column.comment);
+	buffer.push(`${INDENT}pub ${name}: ${isNullable ? `Option<${rust}>` : rust},`);
+}
+function toRustIdentifier(name) {
+	if (NON_RAW_NAMES.has(name)) return `${name}_`;
+	return RUST_KEYWORDS.has(name) ? `r#${name}` : name;
+}
+function toStructName(name) {
+	return TYPE_NAMES.has(name) ? `${name}_` : toRustIdentifier(name);
+}
+function formatComment(buffer, indent, comment) {
+	const lines = comment.replace(BIDI_CONTROLS, escapeCodePoint).split(LINE_BREAK).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 escapeCodePoint(character) {
+	return `\\u{${character.charCodeAt(0).toString(16).toUpperCase()}}`;
+}
+//#endregion
+export { INDENT, RUST_KEYWORDS, createCode, formatComment, formatTable, toRustIdentifier, toStructName };

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

@@ -0,0 +1,132 @@
+import { Database } from "../../constants/schema.js";
+import { baseTypeName, findDataTypeHint } from "./utils.js";
+import { MONEY_TYPES, POSTGRES_OBJECT_ID_TYPES, columnScalar, getColumnType, isMySQLFamily } from "./columnTypes.js";
+//#region src/utils/generator-code/rustTypes.ts
+var RUST_SCALAR_PATHS = {
+	bool: "bool",
+	i8: "i8",
+	i16: "i16",
+	i32: "i32",
+	i64: "i64",
+	u8: "u8",
+	u16: "u16",
+	u32: "u32",
+	u64: "u64",
+	f32: "f32",
+	f64: "f64",
+	decimal: "rust_decimal::Decimal",
+	string: "String",
+	bytes: "Vec<u8>",
+	uuid: "uuid::Uuid",
+	json: "serde_json::Value",
+	date: "chrono::NaiveDate",
+	time: "chrono::NaiveTime",
+	dateTime: "chrono::NaiveDateTime",
+	dateTimeUtc: "chrono::DateTime<chrono::Utc>",
+	dateTimeOffset: "chrono::DateTime<chrono::FixedOffset>"
+};
+var RUST_SCALARS = {
+	bool: "bool",
+	i8: "i8",
+	i16: "i16",
+	i32: "i32",
+	i64: "i64",
+	u8: "u8",
+	u16: "u16",
+	u32: "u32",
+	u64: "u64",
+	f32: "f32",
+	f64: "f64",
+	decimal: "decimal",
+	string: "string",
+	bytes: "bytes",
+	uuid: "uuid",
+	json: "json",
+	date: "date",
+	time: "time",
+	timeTz: "string",
+	dateTime: "dateTime",
+	dateTimeUtc: "dateTimeUtc",
+	dateTimeOffset: "dateTimeOffset",
+	interval: "string"
+};
+var POSTGRES_CHARACTER_TYPES = /* @__PURE__ */ new Set([
+	"bpchar",
+	"char",
+	"character",
+	"character varying",
+	"citext",
+	"name",
+	"text",
+	"varchar"
+]);
+var rustPrimitiveTypes = /* @__PURE__ */ new Map([
+	[Database.MSSQL, /* @__PURE__ */ new Map([
+		["binary", "lob"],
+		["bit", "int"],
+		["money", "double"],
+		["numeric", "float"],
+		["smallmoney", "float"]
+	])],
+	[Database.Oracle, /* @__PURE__ */ new Map([
+		["date", "date"],
+		["raw", "lob"],
+		["real", "float"]
+	])],
+	[Database.PostgreSQL, /* @__PURE__ */ new Map([
+		["bit", "int"],
+		["bit varying", "int"],
+		["money", "double"],
+		["pg_lsn", "int"],
+		["varbit", "int"]
+	])],
+	[Database.SQLite, /* @__PURE__ */ new Map([
+		["bool", "string"],
+		["time", "string"],
+		["timestamp", "string"]
+	])]
+]);
+var UNSIGNED = /(^|[^0-9a-z_])unsigned([^0-9a-z_]|$)/;
+var ZEROFILL = /(^|[^0-9a-z_])zerofill([^0-9a-z_]|$)/;
+var WHITESPACE = /\s+/g;
+function getRustColumnType(dataType, database) {
+	const column = getColumnType(dataType, database);
+	const { element, args, arrayDepth, isUnsigned } = column;
+	const base = isMySQLFamily(database) ? baseTypeName(element).replace(UNSIGNED, "$1$2").replace(ZEROFILL, "$1$2").replace(WHITESPACE, " ").trim() : column.base;
+	const scalar = rustScalar(columnScalar(element, base, args, database, isUnsigned, rustPrimitiveType), base, database, column.isSemiStructured);
+	const isNested = arrayDepth > 1;
+	return {
+		scalar,
+		rust: wrapVec(RUST_SCALAR_PATHS[scalar], arrayDepth),
+		base,
+		args,
+		arrayDepth,
+		isUnsigned,
+		isFloat: scalar === "f32" || scalar === "f64",
+		selectAs: isNested ? "text" : postgresSelectAs(database, base, scalar, arrayDepth),
+		entityScalar: isNested ? "string" : scalar
+	};
+}
+function wrapVec(type, depth) {
+	let wrapped = type;
+	for (let i = 0; i < depth; i++) wrapped = `Vec<${wrapped}>`;
+	return wrapped;
+}
+function rustScalar(scalar, base, database, isSemiStructured) {
+	if (database === Database.MariaDB && base === "uuid" || database === Database.PostgreSQL && POSTGRES_OBJECT_ID_TYPES.has(base) || isSemiStructured) return "string";
+	return RUST_SCALARS[scalar];
+}
+function rustPrimitiveType(dataType, database) {
+	const hint = findDataTypeHint(dataType, database);
+	if (!hint) return "string";
+	return rustPrimitiveTypes.get(database)?.get(hint.name.toLowerCase()) ?? hint.primitiveType;
+}
+function postgresSelectAs(database, base, scalar, arrayDepth) {
+	if (database !== Database.PostgreSQL) return null;
+	const brackets = "[]".repeat(arrayDepth);
+	if (MONEY_TYPES.has(base)) return `numeric${brackets}`;
+	if (scalar === "string" && base !== "" && !POSTGRES_CHARACTER_TYPES.has(base)) return `text${brackets}`;
+	return null;
+}
+//#endregion
+export { POSTGRES_CHARACTER_TYPES, RUST_SCALAR_PATHS, getRustColumnType, wrapVec };