@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/schema-aml-parser/tokenizer.js

@@ -0,0 +1,208 @@
+//#region src/utils/schema-aml-parser/tokenizer.ts
+var TokenKind = {
+	identifier: 1,
+	quoted: 2,
+	string: 3,
+	expression: 4,
+	number: 5,
+	punctuation: 6,
+	doc: 7,
+	comment: 8,
+	newline: 9
+};
+var SPACE = /[ \t\f\v]/;
+var DIGIT = /[0-9]/;
+var IDENTIFIER_START = /[A-Za-z_\u0080-\uffff]/;
+var IDENTIFIER_PART = /[0-9A-Za-z_#\u0080-\uffff]/;
+var INDENT = /^[ \t]*/;
+var ESCAPED_HASH = /\\#/g;
+var ESCAPE_MAP = { n: "\n" };
+function tokenize(source) {
+	const tokens = [];
+	let index = 0;
+	let line = 1;
+	let depth = indentDepth(source, 0);
+	const push = (kind, value) => {
+		tokens.push({
+			kind,
+			value,
+			line,
+			depth
+		});
+	};
+	tokens.push({
+		kind: TokenKind.newline,
+		value: "",
+		line: 0,
+		depth
+	});
+	while (index < source.length) {
+		const char = source[index];
+		if (SPACE.test(char)) {
+			index += 1;
+			continue;
+		}
+		if (char === "\r" || char === "\n") {
+			if (char === "\r" && source[index + 1] === "\n") index += 1;
+			index += 1;
+			depth = indentDepth(source, index);
+			push(TokenKind.newline, "\n");
+			line += 1;
+			continue;
+		}
+		if (char === "#") {
+			let end = index + 1;
+			while (end < source.length && source[end] !== "\n" && source[end] !== "\r") end += 1;
+			push(TokenKind.comment, source.slice(index + 1, end).trim());
+			index = end;
+			continue;
+		}
+		if (char === "|") {
+			if (source.startsWith("|||", index)) {
+				const result = readMultilineDoc(source, index + 3);
+				push(TokenKind.doc, dedent(result.value));
+				index = result.index;
+				line += result.lines;
+				continue;
+			}
+			const result = readDoc(source, index + 1);
+			push(TokenKind.doc, result.value);
+			index = result.index;
+			continue;
+		}
+		if (char === "\"") {
+			const result = readDelimited(source, index + 1, "\"", true, false);
+			push(TokenKind.quoted, result.value);
+			index = result.index;
+			continue;
+		}
+		if (char === "'") {
+			const result = readDelimited(source, index + 1, "'", true, false);
+			push(TokenKind.string, result.value);
+			index = result.index;
+			continue;
+		}
+		if (char === "`") {
+			const result = readDelimited(source, index + 1, "`", false, true);
+			push(TokenKind.expression, result.value);
+			index = result.index;
+			line += result.lines;
+			continue;
+		}
+		if (DIGIT.test(char)) {
+			let end = index;
+			while (end < source.length && DIGIT.test(source[end])) end += 1;
+			if (source[end] === "." && DIGIT.test(source[end + 1] ?? "")) {
+				end += 1;
+				while (end < source.length && DIGIT.test(source[end])) end += 1;
+			}
+			push(TokenKind.number, source.slice(index, end));
+			index = end;
+			continue;
+		}
+		if (IDENTIFIER_START.test(char)) {
+			let end = index + 1;
+			while (end < source.length && IDENTIFIER_PART.test(source[end])) end += 1;
+			while (end > index && source[end - 1] === "#") end -= 1;
+			push(TokenKind.identifier, source.slice(index, end));
+			index = end;
+			continue;
+		}
+		push(TokenKind.punctuation, char);
+		index += 1;
+	}
+	return tokens;
+}
+function indentDepth(source, index) {
+	let width = 0;
+	for (let i = index; i < source.length; i++) {
+		const char = source[i];
+		if (char === "	") width += 1;
+		else if (char === " ") width += .5;
+		else break;
+	}
+	return Math.round(width) - 1;
+}
+function readDoc(source, start) {
+	let index = start;
+	while (index < source.length && SPACE.test(source[index])) index += 1;
+	if (index > start && source[index] === "\"") {
+		const quoted = readDelimited(source, index + 1, "\"", true, false);
+		if (quoted.terminated) return {
+			value: quoted.value,
+			index: quoted.index
+		};
+	}
+	const buffer = [];
+	index = start;
+	while (index < source.length) {
+		const char = source[index];
+		if (char === "\n" || char === "\r") break;
+		if (char !== " " && source[index + 1] === "#") {
+			buffer.push(char, "#");
+			index += 2;
+			continue;
+		}
+		if (char === "#") break;
+		buffer.push(char);
+		index += 1;
+	}
+	return {
+		value: unquote(buffer.join("").trim().replace(ESCAPED_HASH, "#")),
+		index
+	};
+}
+function readMultilineDoc(source, start) {
+	const closing = source.indexOf("|||", start);
+	const end = closing === -1 ? source.length : closing;
+	const value = source.slice(start, end);
+	return {
+		value,
+		index: closing === -1 ? source.length : closing + 3,
+		lines: value.split("\n").length - 1
+	};
+}
+function readDelimited(source, start, closing, escaped, multiline) {
+	const buffer = [];
+	let index = start;
+	let lines = 0;
+	while (index < source.length) {
+		if (source.startsWith(closing, index)) return {
+			value: buffer.join(""),
+			index: index + closing.length,
+			lines,
+			terminated: true
+		};
+		const char = source[index];
+		if (!multiline && (char === "\n" || char === "\r")) break;
+		const next = source[index + 1];
+		if (escaped && char === "\\" && next !== void 0) {
+			buffer.push(ESCAPE_MAP[next] ?? next);
+			index += 2;
+			continue;
+		}
+		if (char === "\n") lines += 1;
+		buffer.push(char);
+		index += 1;
+	}
+	return {
+		value: buffer.join(""),
+		index,
+		lines,
+		terminated: false
+	};
+}
+function unquote(value) {
+	const quote = value[0];
+	return value.length > 1 && (quote === "\"" || quote === "'") && value.endsWith(quote) ? value.slice(1, -1) : value;
+}
+function dedent(value) {
+	const lines = value.replace(/\r\n|\r/g, "\n").split("\n");
+	if (lines[0]?.trim() === "") lines.shift();
+	if (lines.length && lines[lines.length - 1].trim() === "") lines.pop();
+	const indents = lines.filter((line) => line.trim() !== "").map((line) => (INDENT.exec(line)?.[0] ?? "").length);
+	const common = indents.length ? Math.min(...indents) : 0;
+	return lines.map((line) => line.slice(common)).join("\n");
+}
+//#endregion
+export { TokenKind, tokenize };

package/dist/utils/schema-aml-parser/types.js

@@ -0,0 +1,8 @@
+//#region src/utils/schema-aml-parser/types.ts
+var EMPTY_NAMESPACE = {
+	database: "",
+	catalog: "",
+	schema: ""
+};
+//#endregion
+export { EMPTY_NAMESPACE };

package/dist/utils/schema-dbml-parser/convert.js

@@ -0,0 +1,324 @@
+import { parser } from "../../erd-editor-schema/dist/v3/parser/index.js";
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnUIKey, OrderType, ReferentialAction, RelationshipType } from "../../constants/schema.js";
+import { textInRange, toSafeString } from "../validation.js";
+import { createTable } from "../collection/table.entity.js";
+import { createColumn } from "../collection/tableColumn.entity.js";
+import { bHas } from "../bit.js";
+import { autoName, primaryKeyColumns } from "../tableName.js";
+import { createIndex } from "../collection/index.entity.js";
+import { createIndexColumn } from "../collection/indexColumn.entity.js";
+import { createRelationship } from "../collection/relationship.entity.js";
+import { createTableGroup } from "../collection/tableGroup.entity.js";
+import { toReferentialAction } from "../referentialAction.js";
+import { findByName } from "../schema-sql-parser/utils.js";
+import { enumCommentSuffix, resolveDataType } from "./dataType.js";
+//#region src/utils/schema-dbml-parser/convert.ts
+var DEFAULT_SCHEMA = "public";
+function convertToSchema(model, ctx, database) {
+	const schema = parser({});
+	const qualify = createQualifier(model.tables);
+	const contexts = model.tables.map((source) => convertTable(schema, ctx, model, database, source, qualify(source)));
+	const findContext = createTableIndex(model.tables, contexts);
+	convertRelationships(schema, ctx, contexts, model, findContext);
+	convertIndexes(schema, contexts);
+	convertTableGroups(schema, model, findContext);
+	return schema;
+}
+function createQualifier(tables) {
+	const schemaNames = new Set(tables.map((table) => schemaKeyOf(table.schemaName)));
+	return (table) => {
+		const key = schemaKeyOf(table.schemaName);
+		return schemaNames.size > 1 && key !== DEFAULT_SCHEMA ? `${key}_${table.name}` : table.name;
+	};
+}
+function schemaKeyOf(schemaName) {
+	return schemaName === "" ? DEFAULT_SCHEMA : schemaName;
+}
+function createTableIndex(sources, contexts) {
+	const byKey = /* @__PURE__ */ new Map();
+	const set = (key, context) => {
+		const lowered = key.toLowerCase();
+		if (!byKey.has(lowered)) byKey.set(lowered, context);
+	};
+	sources.forEach((source, index) => {
+		const context = contexts[index];
+		const key = schemaKeyOf(source.schemaName);
+		set(`${key}.${source.name}`, context);
+		set(source.name, context);
+		if (source.alias) {
+			set(source.alias, context);
+			set(`${key}.${source.alias}`, context);
+		}
+	});
+	return (endpoint) => {
+		const key = schemaKeyOf(endpoint.schemaName);
+		return byKey.get(`${key}.${endpoint.tableName}`.toLowerCase()) ?? (endpoint.schemaName === "" ? byKey.get(endpoint.tableName.toLowerCase()) ?? null : null);
+	};
+}
+function convertTable({ doc, collections }, ctx, model, database, source, tableName) {
+	const { toWidth } = ctx;
+	const name = toSafeString(tableName);
+	const comment = toSafeString(source.comment);
+	const newTable = createTable({
+		name,
+		comment,
+		ui: {
+			widthName: textInRange(toWidth(name)),
+			widthComment: textInRange(toWidth(comment)),
+			color: source.color
+		}
+	});
+	const context = {
+		source,
+		table: newTable,
+		columns: []
+	};
+	const primaryKeyNames = new Set(source.indexes.filter((index) => index.primaryKey).flatMap((index) => index.columnNames).map((columnName) => columnName.toUpperCase()));
+	source.columns.forEach((column) => {
+		const columnName = toSafeString(column.name);
+		const primaryKey = column.primaryKey || primaryKeyNames.has(columnName.toUpperCase());
+		const dataType = resolveDataType(column.typeName, column.typeSchemaName, database, model);
+		const columnComment = `${toSafeString(column.comment)}${enumCommentSuffix(column.typeName, column.typeSchemaName, model, database)}`.trim();
+		const defaultValue = toSafeString(column.default);
+		appendColumn(collections, context, createColumn({
+			tableId: newTable.id,
+			name: columnName,
+			comment: columnComment,
+			dataType,
+			default: defaultValue,
+			options: (column.autoIncrement ? ColumnOption.autoIncrement : 0) | (primaryKey ? ColumnOption.primaryKey : 0) | (column.unique ? ColumnOption.unique : 0) | (column.notNull ? ColumnOption.notNull : 0),
+			ui: {
+				widthName: textInRange(toWidth(columnName)),
+				widthComment: textInRange(toWidth(columnComment)),
+				widthDataType: textInRange(toWidth(dataType)),
+				widthDefault: textInRange(toWidth(defaultValue)),
+				keys: primaryKey ? ColumnUIKey.primaryKey : 0
+			}
+		}));
+	});
+	doc.tableIds.push(newTable.id);
+	query(collections).collection("tableEntities").setOne(newTable);
+	return context;
+}
+function appendColumn(collections, context, column) {
+	context.table.columnIds.push(column.id);
+	context.table.seqColumnIds.push(column.id);
+	context.columns.push(column);
+	query(collections).collection("tableColumnEntities").setOne(column);
+}
+function convertRelationships(schema, ctx, contexts, model, findContext) {
+	const relationshipKeys = /* @__PURE__ */ new Set();
+	const append = (input) => appendRelationship(schema, relationshipKeys, input);
+	contexts.forEach((source) => {
+		source.source.columns.forEach((column, index) => {
+			const owner = source.columns[index];
+			if (!owner) return;
+			column.inlineRefs.forEach((inlineRef) => {
+				const target = findContext(inlineRef.target);
+				if (!target) return;
+				const targetColumns = resolveColumns(target, inlineRef.target);
+				if (targetColumns.length !== 1) return;
+				if (inlineRef.operator === "<>") {
+					appendJunctionTable(schema, ctx, contexts, source, target);
+					return;
+				}
+				const childIsOwner = inlineRef.operator !== "<";
+				append(childIsOwner ? {
+					parent: target,
+					parentColumns: targetColumns,
+					child: source,
+					childColumns: [owner],
+					toMany: inlineRef.operator === ">"
+				} : {
+					parent: source,
+					parentColumns: [owner],
+					child: target,
+					childColumns: targetColumns,
+					toMany: true
+				});
+			});
+		});
+	});
+	model.refs.forEach((ref) => {
+		const left = findContext(ref.left);
+		const right = findContext(ref.right);
+		if (!left || !right) return;
+		const leftColumns = resolveColumns(left, ref.left);
+		const rightColumns = resolveColumns(right, ref.right);
+		if (leftColumns.length === 0 || leftColumns.length !== ref.left.columnNames.length || rightColumns.length !== ref.right.columnNames.length || leftColumns.length !== rightColumns.length) return;
+		if (ref.operator === "<>") {
+			appendJunctionTable(schema, ctx, contexts, left, right);
+			return;
+		}
+		const parentIsLeft = ref.operator !== ">";
+		append({
+			parent: parentIsLeft ? left : right,
+			parentColumns: parentIsLeft ? leftColumns : rightColumns,
+			child: parentIsLeft ? right : left,
+			childColumns: parentIsLeft ? rightColumns : leftColumns,
+			toMany: ref.operator !== "-",
+			onDelete: toReferentialAction(ref.onDelete),
+			onUpdate: toReferentialAction(ref.onUpdate)
+		});
+	});
+}
+function resolveColumns(context, endpoint) {
+	const columns = [];
+	for (const columnName of endpoint.columnNames) {
+		const column = findByName(context.columns, columnName);
+		if (!column) return [];
+		columns.push(column);
+	}
+	return columns;
+}
+function appendRelationship({ doc, collections }, relationshipKeys, { parent, parentColumns, child, childColumns, toMany, onDelete = ReferentialAction.none, onUpdate = ReferentialAction.none }) {
+	if (parentColumns.length === 0 || childColumns.length === 0) return;
+	const key = `${parent.table.id}:${child.table.id}:${childColumns.map((column) => column.id).join(",")}`;
+	if (relationshipKeys.has(key)) return;
+	relationshipKeys.add(key);
+	const mandatory = childColumns.every((column) => bHas(column.options, ColumnOption.notNull));
+	childColumns.forEach((column) => {
+		column.ui.keys = bHas(column.ui.keys, ColumnUIKey.primaryKey) ? column.ui.keys | ColumnUIKey.foreignKey : ColumnUIKey.foreignKey;
+	});
+	const newRelationship = createRelationship({
+		identification: childColumns.every((column) => bHas(column.ui.keys, ColumnUIKey.primaryKey) && bHas(column.ui.keys, ColumnUIKey.foreignKey)),
+		relationshipType: toMany ? mandatory ? RelationshipType.OneN : RelationshipType.ZeroN : mandatory ? RelationshipType.OneOnly : RelationshipType.ZeroOne,
+		onDelete,
+		onUpdate,
+		start: {
+			tableId: parent.table.id,
+			columnIds: parentColumns.map((column) => column.id)
+		},
+		end: {
+			tableId: child.table.id,
+			columnIds: childColumns.map((column) => column.id)
+		}
+	});
+	doc.relationshipIds.push(newRelationship.id);
+	query(collections).collection("relationshipEntities").setOne(newRelationship);
+}
+function appendJunctionTable(schema, ctx, contexts, left, right) {
+	const { doc, collections } = schema;
+	const { toWidth } = ctx;
+	const leftKeys = primaryKeyColumns(left.columns);
+	const rightKeys = primaryKeyColumns(right.columns);
+	if (!leftKeys.length || !rightKeys.length) return;
+	const name = autoName(contexts.map((context) => context.table), "", `${left.table.name}_${right.table.name}`);
+	const comment = `Junction table inferred from ${left.table.name} <-> ${right.table.name}`;
+	const newTable = createTable({
+		name,
+		comment,
+		ui: {
+			widthName: textInRange(toWidth(name)),
+			widthComment: textInRange(toWidth(comment))
+		}
+	});
+	const junction = {
+		source: {
+			schemaName: "",
+			name,
+			alias: "",
+			comment,
+			color: "",
+			columns: [],
+			indexes: []
+		},
+		table: newTable,
+		columns: []
+	};
+	doc.tableIds.push(newTable.id);
+	query(collections).collection("tableEntities").setOne(newTable);
+	contexts.push(junction);
+	appendJunctionSide(schema, ctx, junction, left, leftKeys);
+	appendJunctionSide(schema, ctx, junction, right, rightKeys);
+}
+function appendJunctionSide(schema, { toWidth }, junction, parent, parentKeys) {
+	const { doc, collections } = schema;
+	const childColumns = parentKeys.map((parentKey) => {
+		const name = autoName(junction.columns, "", `${parent.table.name}_${parentKey.name}`);
+		const { dataType } = parentKey;
+		const newColumn = createColumn({
+			tableId: junction.table.id,
+			name,
+			dataType,
+			options: ColumnOption.primaryKey | ColumnOption.notNull,
+			ui: {
+				keys: ColumnUIKey.primaryKey | ColumnUIKey.foreignKey,
+				widthName: textInRange(toWidth(name)),
+				widthDataType: textInRange(toWidth(dataType))
+			}
+		});
+		appendColumn(collections, junction, newColumn);
+		return newColumn;
+	});
+	const newRelationship = createRelationship({
+		identification: true,
+		relationshipType: RelationshipType.ZeroN,
+		start: {
+			tableId: parent.table.id,
+			columnIds: parentKeys.map((column) => column.id)
+		},
+		end: {
+			tableId: junction.table.id,
+			columnIds: childColumns.map((column) => column.id)
+		}
+	});
+	doc.relationshipIds.push(newRelationship.id);
+	query(collections).collection("relationshipEntities").setOne(newRelationship);
+}
+function convertIndexes({ doc, collections }, contexts) {
+	contexts.forEach(({ source, table, columns }) => {
+		source.indexes.forEach((index) => {
+			if (index.primaryKey) return;
+			const newIndex = createIndex({
+				name: toSafeString(index.name),
+				tableId: table.id,
+				unique: index.unique
+			});
+			const indexColumns = [];
+			index.columnNames.forEach((columnName) => {
+				const column = findByName(columns, columnName);
+				if (!column) return;
+				indexColumns.push(createIndexColumn({
+					indexId: newIndex.id,
+					columnId: column.id,
+					orderType: OrderType.ASC
+				}));
+			});
+			if (!indexColumns.length) return;
+			indexColumns.forEach((indexColumn) => {
+				newIndex.indexColumnIds.push(indexColumn.id);
+				newIndex.seqIndexColumnIds.push(indexColumn.id);
+				query(collections).collection("indexColumnEntities").setOne(indexColumn);
+			});
+			doc.indexIds.push(newIndex.id);
+			query(collections).collection("indexEntities").setOne(newIndex);
+		});
+	});
+}
+function convertTableGroups({ doc, collections }, model, findContext) {
+	const grouped = /* @__PURE__ */ new Set();
+	model.tableGroups.forEach((source) => {
+		const members = [];
+		source.tables.forEach((name) => {
+			const context = findContext(name);
+			if (!context || grouped.has(context.table.id)) return;
+			grouped.add(context.table.id);
+			members.push(context.table);
+		});
+		if (!members.length) return;
+		const group = createTableGroup({
+			name: toSafeString(source.name),
+			color: source.color,
+			ui: { zIndex: doc.tableGroupIds.length + 1 }
+		});
+		members.forEach((table) => {
+			table.groupId = group.id;
+		});
+		doc.tableGroupIds.push(group.id);
+		query(collections).collection("tableGroupEntities").setOne(group);
+	});
+}
+//#endregion
+export { convertToSchema };

package/dist/utils/schema-dbml-parser/dataType.js

@@ -0,0 +1,32 @@
+import { Database } from "../../constants/schema.js";
+//#region src/utils/schema-dbml-parser/dataType.ts
+var stringTypes = {
+	[Database.MariaDB]: "VARCHAR(255)",
+	[Database.MSSQL]: "varchar(255)",
+	[Database.MySQL]: "VARCHAR(255)",
+	[Database.Oracle]: "VARCHAR2(255)",
+	[Database.PostgreSQL]: "varchar(255)",
+	[Database.SQLite]: "TEXT",
+	[Database.Databricks]: "STRING",
+	[Database.Snowflake]: "VARCHAR(255)"
+};
+function resolveDataType(typeName, typeSchemaName, database, model) {
+	const members = getMembers(typeName, typeSchemaName, model);
+	if (!members) return typeName;
+	return enumDataType(members, database) ?? stringTypes[database] ?? typeName;
+}
+function enumCommentSuffix(typeName, typeSchemaName, model, database) {
+	const members = getMembers(typeName, typeSchemaName, model);
+	if (!members || enumDataType(members, database) !== void 0) return "";
+	return ` ${typeName}: ${members.join(" | ")}`;
+}
+function enumDataType(members, database) {
+	if (database !== Database.MySQL && database !== Database.MariaDB) return;
+	return `ENUM(${members.map((member) => `'${member.replace(/'/g, "''")}'`).join(",")})`;
+}
+function getMembers(typeName, typeSchemaName, model) {
+	const qualified = typeSchemaName ? `${typeSchemaName}.${typeName}` : "";
+	return model.enums[qualified] ?? model.enums[typeName] ?? null;
+}
+//#endregion
+export { enumCommentSuffix, resolveDataType };

package/dist/utils/schema-dbml-parser/index.js

@@ -0,0 +1,23 @@
+import { parser } from "../../erd-editor-schema/dist/v3/parser/index.js";
+import { toJson } from "../../erd-editor-schema/dist/parser.js";
+import { convertToSchema } from "./convert.js";
+import { parseDBMLModel } from "./parser.js";
+//#region src/utils/schema-dbml-parser/index.ts
+var EMPTY_MODEL = {
+	tables: [],
+	refs: [],
+	tableGroups: [],
+	enums: {},
+	skipped: []
+};
+function schemaDBMLParserToSchemaJson(dbml, ctx, prepare) {
+	const result = parseDBMLModel(dbml);
+	const model = result.ok ? result.model : EMPTY_MODEL;
+	const schema = parser({});
+	const { settings } = prepare ? prepare(schema) : schema;
+	const converted = convertToSchema(model, ctx, settings.database);
+	converted.settings = settings;
+	return toJson(converted);
+}
+//#endregion
+export { schemaDBMLParserToSchemaJson };