@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,285 @@
+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, 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 { toReferentialAction } from "../referentialAction.js";
+import { findByName } from "../schema-sql-parser/utils.js";
+import { enumCommentSuffix, resolveDataType } from "./dataType.js";
+import { EMPTY_NAMESPACE } from "./types.js";
+//#region src/utils/schema-aml-parser/convert.ts
+var DEFAULT_NAMESPACE_KEY = namespaceKeyOf(EMPTY_NAMESPACE);
+function convertToSchema(model, ctx, database) {
+	const schema = parser({});
+	const qualify = createQualifier(model.entities);
+	const contexts = model.entities.map((source) => convertEntity(schema, ctx, model, database, source, qualify(source)));
+	convertRelationships(schema, ctx, contexts, model, createTableIndex(model.entities, contexts));
+	convertIndexes(schema, contexts);
+	return schema;
+}
+function createQualifier(entities) {
+	const namespaceKeys = new Set(entities.map((entity) => namespaceKeyOf(entity.namespace)));
+	return (entity) => {
+		const key = namespaceKeyOf(entity.namespace);
+		return namespaceKeys.size > 1 && key !== DEFAULT_NAMESPACE_KEY ? `${namespacePrefixOf(entity.namespace)}_${entity.name}` : entity.name;
+	};
+}
+function namespaceKeyOf({ database, catalog, schema }) {
+	return `${database}.${catalog}.${schema}`;
+}
+function namespacePrefixOf({ database, catalog, schema }) {
+	return [
+		database,
+		catalog,
+		schema
+	].filter((segment) => segment !== "").join("_");
+}
+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 = namespaceKeyOf(source.namespace);
+		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 = namespaceKeyOf(endpoint.namespace);
+		return byKey.get(`${key}.${endpoint.entityName}`.toLowerCase()) ?? (key === DEFAULT_NAMESPACE_KEY ? byKey.get(endpoint.entityName.toLowerCase()) ?? null : null);
+	};
+}
+function convertEntity({ doc, collections }, ctx, model, database, source, entityName) {
+	const { toWidth } = ctx;
+	const name = toSafeString(entityName);
+	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: []
+	};
+	source.attributes.forEach((attribute) => {
+		const columnName = toSafeString(attribute.path);
+		const dataType = resolveDataType(attribute.typeName, database, model, attribute.enumValues);
+		const columnComment = `${toSafeString(attribute.comment)}${enumCommentSuffix(attribute.typeName, model, database, attribute.enumValues)}`.trim();
+		const defaultValue = toSafeString(attribute.default);
+		appendColumn(collections, context, createColumn({
+			tableId: newTable.id,
+			name: columnName,
+			comment: columnComment,
+			dataType,
+			default: defaultValue,
+			options: (attribute.autoIncrement ? ColumnOption.autoIncrement : 0) | (attribute.primaryKey ? ColumnOption.primaryKey : 0) | (hasColumnUnique(attribute) ? ColumnOption.unique : 0) | (attribute.notNull ? ColumnOption.notNull : 0),
+			ui: {
+				widthName: textInRange(toWidth(columnName)),
+				widthComment: textInRange(toWidth(columnComment)),
+				widthDataType: textInRange(toWidth(dataType)),
+				widthDefault: textInRange(toWidth(defaultValue)),
+				keys: attribute.primaryKey ? ColumnUIKey.primaryKey : 0
+			}
+		}));
+	});
+	doc.tableIds.push(newTable.id);
+	query(collections).collection("tableEntities").setOne(newTable);
+	return context;
+}
+function hasColumnUnique(attribute) {
+	return attribute.indexes.some((entry) => entry.unique && entry.name === "");
+}
+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();
+	model.relations.forEach((relation) => {
+		const child = findContext(relation.src);
+		const parent = findContext(relation.ref);
+		if (!child || !parent) return;
+		const childColumns = resolveColumns(child, relation.src);
+		const parentColumns = resolveColumns(parent, relation.ref);
+		if (childColumns.length === 0 || parentColumns.length === 0 || childColumns.length !== parentColumns.length) return;
+		if (relation.srcCardinality === "n" && relation.refCardinality === "n") {
+			appendJunctionTable(schema, ctx, contexts, child, parent);
+			return;
+		}
+		appendRelationship(schema, ctx, relationshipKeys, {
+			parent,
+			parentColumns,
+			child,
+			childColumns,
+			toMany: relation.refCardinality === "n",
+			onDelete: toReferentialAction(relation.onDelete),
+			onUpdate: toReferentialAction(relation.onUpdate)
+		});
+	});
+}
+function resolveColumns(context, endpoint) {
+	if (endpoint.attributePaths.length === 0) return primaryKeyColumns(context.columns);
+	const columns = [];
+	for (const path of endpoint.attributePaths) {
+		const column = findByName(context.columns, path);
+		if (!column) return [];
+		columns.push(column);
+	}
+	return columns;
+}
+function appendRelationship({ doc, collections }, { toWidth }, relationshipKeys, { parent, parentColumns, child, childColumns, toMany, onDelete, onUpdate }) {
+	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, index) => {
+		if (column.dataType === "") {
+			const { dataType } = parentColumns[index];
+			column.dataType = dataType;
+			column.ui.widthDataType = textInRange(toWidth(dataType));
+		}
+		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: {
+			namespace: EMPTY_NAMESPACE,
+			name,
+			alias: "",
+			comment,
+			color: "",
+			attributes: []
+		},
+		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 }) => {
+		const groups = /* @__PURE__ */ new Map();
+		source.attributes.forEach((attribute, attributeIndex) => {
+			const column = columns[attributeIndex];
+			if (!column) return;
+			attribute.indexes.forEach((entry, entryIndex) => {
+				if (entry.unique && entry.name === "") return;
+				const key = entry.name === "" ? `b:${attributeIndex}:${entryIndex}` : `n:${entry.name}`;
+				const group = groups.get(key) ?? {
+					index: createIndex({
+						name: toSafeString(entry.name),
+						tableId: table.id
+					}),
+					indexColumns: []
+				};
+				group.index.unique = group.index.unique || entry.unique;
+				group.indexColumns.push(createIndexColumn({
+					indexId: group.index.id,
+					columnId: column.id,
+					orderType: OrderType.ASC
+				}));
+				groups.set(key, group);
+			});
+		});
+		groups.forEach(({ index, indexColumns }) => {
+			indexColumns.forEach((indexColumn) => {
+				index.indexColumnIds.push(indexColumn.id);
+				index.seqIndexColumnIds.push(indexColumn.id);
+				query(collections).collection("indexColumnEntities").setOne(indexColumn);
+			});
+			doc.indexIds.push(index.id);
+			query(collections).collection("indexEntities").setOne(index);
+		});
+	});
+}
+//#endregion
+export { convertToSchema };

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

@@ -0,0 +1,57 @@
+import { Database } from "../../constants/schema.js";
+//#region src/utils/schema-aml-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, database, model, enumValues = []) {
+	const resolved = resolveType(typeName, model, enumValues);
+	if (!resolved.members) return resolved.typeName;
+	return enumDataType(resolved.members, database) ?? stringTypes[database] ?? resolved.typeName;
+}
+function enumCommentSuffix(typeName, model, database, enumValues = []) {
+	const { members } = resolveType(typeName, model, enumValues);
+	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 resolveType(typeName, model, enumValues) {
+	if (enumValues.length) return {
+		typeName,
+		members: enumValues
+	};
+	const seen = /* @__PURE__ */ new Set();
+	let current = typeName;
+	while (!seen.has(current)) {
+		seen.add(current);
+		const type = getType(current, model);
+		if (!type) break;
+		if (type.values.length) return {
+			typeName: current,
+			members: type.values
+		};
+		if (!type.alias) break;
+		current = type.alias;
+	}
+	return {
+		typeName: current,
+		members: null
+	};
+}
+function getType(typeName, model) {
+	const type = model.types[typeName];
+	if (type) return type;
+	const qualified = Object.keys(model.types).find((name) => name.slice(name.lastIndexOf(".") + 1) === typeName);
+	return qualified === void 0 ? void 0 : model.types[qualified];
+}
+//#endregion
+export { enumCommentSuffix, resolveDataType };

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

@@ -0,0 +1,22 @@
+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 { parseAMLModel } from "./parser.js";
+//#region src/utils/schema-aml-parser/index.ts
+var EMPTY_MODEL = {
+	entities: [],
+	relations: [],
+	types: {},
+	skipped: []
+};
+function schemaAMLParserToSchemaJson(aml, ctx, prepare) {
+	const result = parseAMLModel(aml);
+	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 { schemaAMLParserToSchemaJson };