@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,185 @@
+//#region src/utils/schema-dbml-parser/tokenizer.ts
+var TokenKind = {
+	identifier: 1,
+	quoted: 2,
+	string: 3,
+	expression: 4,
+	number: 5,
+	punctuation: 6,
+	operator: 7,
+	newline: 8
+};
+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 ESCAPE_MAP = {
+	n: "\n",
+	r: "\r",
+	t: "	",
+	b: "\b",
+	f: "\f",
+	v: "\v",
+	"0": "\0"
+};
+function tokenize(source) {
+	const tokens = [];
+	let index = 0;
+	let start = 0;
+	let line = 1;
+	let depth = 0;
+	const push = (kind, value) => {
+		tokens.push({
+			kind,
+			value,
+			line,
+			offset: start
+		});
+	};
+	const pushNewline = () => {
+		if (depth === 0) push(TokenKind.newline, "\n");
+	};
+	while (index < source.length) {
+		const char = source[index];
+		start = index;
+		if (SPACE.test(char)) {
+			index += 1;
+			continue;
+		}
+		if (char === "\r" || char === "\n") {
+			if (char === "\r" && source[index + 1] === "\n") index += 1;
+			index += 1;
+			pushNewline();
+			line += 1;
+			continue;
+		}
+		if (char === "/" && source[index + 1] === "/") {
+			index += 2;
+			while (index < source.length && source[index] !== "\n") index += 1;
+			continue;
+		}
+		if (char === "/" && source[index + 1] === "*") {
+			index += 2;
+			let broke = false;
+			while (index < source.length) {
+				if (source[index] === "*" && source[index + 1] === "/") {
+					index += 2;
+					break;
+				}
+				if (source[index] === "\n") {
+					broke = true;
+					line += 1;
+				}
+				index += 1;
+			}
+			if (broke) pushNewline();
+			continue;
+		}
+		if (char === "\"") {
+			const result = readDelimited(source, index + 1, "\"", true);
+			index = result.index;
+			line += result.lines;
+			push(TokenKind.quoted, result.value);
+			continue;
+		}
+		if (char === "'") {
+			if (source.startsWith("'''", index)) {
+				const result = readDelimited(source, index + 3, "'''", true);
+				index = result.index;
+				line += result.lines;
+				push(TokenKind.string, dedent(result.value));
+				continue;
+			}
+			const result = readDelimited(source, index + 1, "'", true);
+			index = result.index;
+			line += result.lines;
+			push(TokenKind.string, result.value);
+			continue;
+		}
+		if (char === "`") {
+			const result = readDelimited(source, index + 1, "`", false);
+			index = result.index;
+			line += result.lines;
+			push(TokenKind.expression, result.value);
+			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;
+			}
+			if ((source[end] === "e" || source[end] === "E") && DIGIT.test(source[end + 1] ?? "")) {
+				end += 2;
+				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;
+			push(TokenKind.identifier, source.slice(index, end));
+			index = end;
+			continue;
+		}
+		const operator = readOperator(source, index);
+		if (operator) {
+			push(TokenKind.operator, operator);
+			index += operator.length;
+			continue;
+		}
+		if (char === "[" || char === "(") depth += 1;
+		else if (char === "]" || char === ")") depth = Math.max(0, depth - 1);
+		push(TokenKind.punctuation, char);
+		index += 1;
+	}
+	return tokens;
+}
+function readOperator(source, index) {
+	const char = source[index];
+	if (char === "-") return source[index + 1] === "?" ? "-?" : "";
+	if (char !== "<" && char !== ">" && char !== "?") return "";
+	const match = /^\??(?:<>|<|>|-)\??/.exec(source.slice(index));
+	return match && /[<>-]/.test(match[0]) ? match[0] : "";
+}
+function readDelimited(source, start, closing, escaped) {
+	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
+		};
+		const char = source[index];
+		if (escaped && char === "\\" && index + 1 < source.length) {
+			const next = source[index + 1];
+			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
+	};
+}
+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-graphql-parser/convert.js

@@ -0,0 +1,410 @@
+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 { pascalCase } from "../index.js";
+import { createIndex } from "../collection/index.entity.js";
+import { createIndexColumn } from "../collection/indexColumn.entity.js";
+import { createRelationship } from "../collection/relationship.entity.js";
+import { findByName } from "../schema-sql-parser/utils.js";
+import { enumCommentSuffix, resolveDataType } from "./dataType.js";
+import { lowerFirst, snakeCase } from "es-toolkit";
+//#region src/utils/schema-graphql-parser/convert.ts
+var UNDERSCORES = /_/g;
+var TRAILING_DIGITS = /\d+$/;
+function convertToSchema(model, ctx, database) {
+	const schema = parser({});
+	const findTable = createNameIndex(model.tables);
+	const skipped = new Set(model.skipped);
+	const contexts = model.tables.map((source) => convertTable(schema, ctx, model, database, source, findTable, skipped));
+	convertRelationships(schema, ctx, contexts);
+	convertIndexes(schema, contexts);
+	return schema;
+}
+function createNameIndex(list) {
+	const exact = /* @__PURE__ */ new Map();
+	const lower = /* @__PURE__ */ new Map();
+	for (const item of list) {
+		exact.set(item.name, item);
+		const key = item.name.toLowerCase();
+		if (!lower.has(key)) lower.set(key, item);
+	}
+	return (name) => exact.get(name) ?? lower.get(name.toLowerCase()) ?? null;
+}
+function convertTable({ doc, collections }, ctx, model, database, source, findTable, skipped) {
+	const { toWidth } = ctx;
+	const columnFields = [];
+	const referenceFields = [];
+	for (const field of source.fields) {
+		const { named } = field.typeRef;
+		if (skipped.has(named)) continue;
+		if (findTable(named)) referenceFields.push(field);
+		else columnFields.push(field);
+	}
+	const primaryKeyFields = new Set(resolvePrimaryKeyFields(columnFields));
+	const name = toSafeString(source.name);
+	const comment = toSafeString(source.comment);
+	const newTable = createTable({
+		name,
+		comment,
+		ui: {
+			widthName: textInRange(toWidth(name)),
+			widthComment: textInRange(toWidth(comment))
+		}
+	});
+	const context = {
+		name,
+		source,
+		table: newTable,
+		columns: [],
+		referenceFields
+	};
+	columnFields.forEach((field) => {
+		appendColumn(collections, context, createFieldColumn(ctx, model, database, newTable.id, field, primaryKeyFields.has(field)));
+	});
+	doc.tableIds.push(newTable.id);
+	query(collections).collection("tableEntities").setOne(newTable);
+	return context;
+}
+function resolvePrimaryKeyFields(fields) {
+	const declared = fields.filter((field) => field.primaryKey);
+	if (declared.length) return declared;
+	const idType = fields.find((field) => field.typeRef.named === "ID" && !field.typeRef.isList);
+	if (idType) return [idType];
+	const idName = fields.find((field) => field.name.toLowerCase() === "id");
+	return idName ? [idName] : [];
+}
+function createFieldColumn({ toWidth }, model, database, tableId, field, primaryKey) {
+	const { named, nonNull } = field.typeRef;
+	const name = toSafeString(field.name);
+	const override = toSafeString(field.dataType);
+	const dataType = override ? override : resolveDataType(named, database, model);
+	const defaultValue = toSafeString(field.default);
+	const comment = toColumnComment(field, model, database);
+	return createColumn({
+		tableId,
+		name,
+		comment,
+		dataType,
+		default: defaultValue,
+		options: (field.autoIncrement ? ColumnOption.autoIncrement : 0) | (primaryKey ? ColumnOption.primaryKey : 0) | (field.unique ? ColumnOption.unique : 0) | (nonNull ? ColumnOption.notNull : 0),
+		ui: {
+			widthName: textInRange(toWidth(name)),
+			widthComment: textInRange(toWidth(comment)),
+			widthDataType: textInRange(toWidth(dataType)),
+			widthDefault: textInRange(toWidth(defaultValue)),
+			keys: primaryKey ? ColumnUIKey.primaryKey : 0
+		}
+	});
+}
+function toColumnComment(field, model, database) {
+	const { named, isList } = field.typeRef;
+	const parts = [];
+	const comment = toSafeString(field.comment);
+	if (comment) parts.push(comment);
+	if (isList) parts.push(`list of ${named}`);
+	return `${parts.join(" ")}${enumCommentSuffix(named, model, database)}`.trim();
+}
+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) {
+	const findContext = createNameIndex(contexts);
+	const edges = [];
+	contexts.forEach((source) => {
+		source.referenceFields.forEach((field) => {
+			const target = findContext(field.typeRef.named);
+			if (!target) return;
+			edges.push({
+				source,
+				target,
+				field,
+				consumed: false,
+				namedReciprocal: null,
+				named: false
+			});
+		});
+	});
+	const state = {
+		claimedColumnIds: /* @__PURE__ */ new Set(),
+		relationshipKeys: /* @__PURE__ */ new Set()
+	};
+	const singularEdges = edges.filter((edge) => !edge.field.typeRef.isList);
+	pairByName(edges, singularEdges);
+	[...singularEdges.filter((edge) => edge.field.relationFields.length), ...singularEdges.filter((edge) => !edge.field.relationFields.length)].forEach((edge) => {
+		if (edge.consumed || edge.named && !edge.namedReciprocal) return;
+		const reciprocal = edge.namedReciprocal ?? findReciprocalEdge(edges, edge);
+		edge.consumed = true;
+		if (reciprocal) reciprocal.consumed = true;
+		const toMany = Boolean(reciprocal?.field.typeRef.isList);
+		appendRelationship(schema, ctx, state, {
+			parent: edge.target,
+			child: edge.source,
+			field: edge.field,
+			childSide: true,
+			relationshipType: edge.field.typeRef.nonNull ? toMany ? RelationshipType.OneN : RelationshipType.OneOnly : toMany ? RelationshipType.ZeroN : RelationshipType.ZeroOne
+		});
+	});
+	edges.filter((edge) => edge.field.typeRef.isList).forEach((edge) => {
+		if (edge.consumed) return;
+		const pair = findManyToManyEdge(edges, edge);
+		edge.consumed = true;
+		if (pair) {
+			pair.consumed = true;
+			appendJunctionTable(schema, ctx, contexts, edge);
+			return;
+		}
+		appendRelationship(schema, ctx, state, {
+			parent: edge.source,
+			child: edge.target,
+			field: edge.field,
+			childSide: false,
+			relationshipType: edge.field.typeRef.nonNull ? RelationshipType.OneN : RelationshipType.ZeroN
+		});
+	});
+}
+function pairByName(edges, singularEdges) {
+	pairBySuffix(edges, singularEdges, toPairingKey);
+	pairBySuffix(edges, singularEdges, toUnnumberedKey);
+}
+function pairBySuffix(edges, singularEdges, toKey) {
+	const keyOf = (edge) => toKey(edge.field.name);
+	[...singularEdges].sort((a, b) => keyOf(b).length - keyOf(a).length).forEach((edge) => {
+		if (edge.named || edge.field.relationName) return;
+		const suffix = `by${keyOf(edge)}`;
+		const matches = edges.filter((candidate) => candidate !== edge && !candidate.named && !candidate.field.relationName && !candidate.field.relationFields.length && candidate.source === edge.target && candidate.target === edge.source && keyOf(candidate).endsWith(suffix));
+		if (matches.length !== 1) return;
+		const [reciprocal] = matches;
+		edge.namedReciprocal = reciprocal;
+		edge.named = true;
+		reciprocal.named = true;
+	});
+}
+function toPairingKey(name) {
+	return name.replace(UNDERSCORES, "").toLowerCase();
+}
+function toUnnumberedKey(name) {
+	return toPairingKey(name).replace(TRAILING_DIGITS, "");
+}
+function findReciprocalEdge(edges, edge) {
+	const candidates = edges.filter((candidate) => candidate !== edge && !candidate.consumed && !candidate.named && candidate.source === edge.target && candidate.target === edge.source);
+	if (!candidates.length) return null;
+	const { relationName } = edge.field;
+	if (relationName) return candidates.find((candidate) => candidate.field.relationName === relationName) ?? null;
+	if (edge.source === edge.target) return candidates.length === 1 ? candidates[0] : null;
+	const forward = edges.filter((candidate) => !candidate.consumed && !candidate.named && candidate.source === edge.source && candidate.target === edge.target);
+	return candidates.length === 1 && forward.length === 1 ? candidates[0] : null;
+}
+function findManyToManyEdge(edges, edge) {
+	if (edges.some((candidate) => !candidate.field.typeRef.isList && (candidate.source === edge.source && candidate.target === edge.target || candidate.source === edge.target && candidate.target === edge.source))) return null;
+	const candidates = edges.filter((candidate) => candidate !== edge && !candidate.consumed && candidate.field.typeRef.isList && candidate.source === edge.target && candidate.target === edge.source);
+	if (!candidates.length) return null;
+	const { relationName } = edge.field;
+	if (relationName) return candidates.find((candidate) => candidate.field.relationName === relationName) ?? null;
+	return candidates[0];
+}
+function appendRelationship(schema, ctx, state, input) {
+	const { doc, collections } = schema;
+	const { parent, child, relationshipType } = input;
+	const parentKeys = primaryKeyColumns(parent.columns);
+	if (!parentKeys.length) return;
+	const { startColumns, endColumns } = resolveForeignKeyColumns(schema, ctx, state, input, parentKeys);
+	if (!endColumns.length) return;
+	const key = `${parent.table.id}:${child.table.id}:${endColumns.map((column) => column.id).join(",")}`;
+	if (state.relationshipKeys.has(key)) return;
+	state.relationshipKeys.add(key);
+	endColumns.forEach((column) => {
+		if (bHas(column.ui.keys, ColumnUIKey.primaryKey)) column.ui.keys |= ColumnUIKey.foreignKey;
+		else column.ui.keys = ColumnUIKey.foreignKey;
+		state.claimedColumnIds.add(column.id);
+	});
+	const newRelationship = createRelationship({
+		identification: endColumns.every((column) => bHas(column.ui.keys, ColumnUIKey.primaryKey) && bHas(column.ui.keys, ColumnUIKey.foreignKey)),
+		relationshipType,
+		start: {
+			tableId: parent.table.id,
+			columnIds: startColumns.map((column) => column.id)
+		},
+		end: {
+			tableId: child.table.id,
+			columnIds: endColumns.map((column) => column.id)
+		}
+	});
+	doc.relationshipIds.push(newRelationship.id);
+	query(collections).collection("relationshipEntities").setOne(newRelationship);
+}
+function resolveForeignKeyColumns(schema, ctx, state, { parent, child, field, childSide }, parentKeys) {
+	if (childSide && field.relationFields.length) {
+		const startColumns = [];
+		const endColumns = [];
+		field.relationFields.forEach((columnName, index) => {
+			const endColumn = findByName(child.columns, columnName);
+			const referenceName = field.relationReferences[index];
+			const startColumn = referenceName ? findByName(parent.columns, referenceName) : parentKeys[index] ?? null;
+			if (!endColumn || !startColumn) return;
+			startColumns.push(startColumn);
+			endColumns.push(endColumn);
+		});
+		if (endColumns.length) return {
+			startColumns,
+			endColumns
+		};
+	}
+	const prefix = childSide ? toSafeString(field.name) : lowerFirst(parent.name);
+	const taken = /* @__PURE__ */ new Set();
+	const startColumns = [];
+	const endColumns = [];
+	parentKeys.forEach((parentKey) => {
+		const candidates = foreignKeyNames(prefix, parent.name, parentKey.name);
+		const endColumn = findUnclaimedColumn(child.columns, candidates, (id) => taken.has(id) ? true : state.claimedColumnIds.has(id)) ?? createForeignKeyColumn(schema, ctx, child, field, parentKey, candidates[0]);
+		taken.add(endColumn.id);
+		startColumns.push(parentKey);
+		endColumns.push(endColumn);
+	});
+	return {
+		startColumns,
+		endColumns
+	};
+}
+function foreignKeyNames(prefix, typeName, primaryKeyName) {
+	return [
+		`${prefix}${pascalCase(primaryKeyName)}`,
+		`${snakeCase(prefix)}_${snakeCase(primaryKeyName)}`,
+		`${typeName}${pascalCase(primaryKeyName)}`,
+		`${snakeCase(typeName)}_${snakeCase(primaryKeyName)}`,
+		`${prefix}Id`,
+		`${snakeCase(prefix)}_id`
+	];
+}
+function findUnclaimedColumn(columns, candidates, isClaimed) {
+	for (const candidate of candidates) {
+		const column = findByName(columns, candidate);
+		if (column && !isClaimed(column.id)) return column;
+	}
+	return null;
+}
+function createForeignKeyColumn({ collections }, { toWidth }, child, field, parentKey, preferredName) {
+	const name = autoName(child.columns, "", preferredName);
+	const { dataType } = parentKey;
+	const newColumn = createColumn({
+		tableId: child.table.id,
+		name,
+		dataType,
+		options: field.typeRef.nonNull ? ColumnOption.notNull : 0,
+		ui: {
+			keys: ColumnUIKey.foreignKey,
+			widthName: textInRange(toWidth(name)),
+			widthDataType: textInRange(toWidth(dataType))
+		}
+	});
+	appendColumn(collections, child, newColumn);
+	return newColumn;
+}
+function appendJunctionTable(schema, ctx, contexts, edge) {
+	const { doc, collections } = schema;
+	const { toWidth } = ctx;
+	const left = edge.source;
+	const right = edge.target;
+	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.name}_${right.name}`);
+	const comment = `Junction table inferred from ${left.name} <-> ${right.name}`;
+	const newTable = createTable({
+		name,
+		comment,
+		ui: {
+			widthName: textInRange(toWidth(name)),
+			widthComment: textInRange(toWidth(comment))
+		}
+	});
+	const junction = {
+		name,
+		source: {
+			name,
+			comment,
+			fields: [],
+			indexes: []
+		},
+		table: newTable,
+		columns: [],
+		referenceFields: []
+	};
+	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 endColumns = parentKeys.map((parentKey) => {
+		const name = autoName(junction.columns, "", `${lowerFirst(parent.name)}${pascalCase(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: endColumns.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) => {
+			const newIndex = createIndex({
+				name: toSafeString(index.name),
+				tableId: table.id,
+				unique: index.unique
+			});
+			const indexColumns = [];
+			index.fieldNames.forEach((fieldName) => {
+				const column = findByName(columns, fieldName);
+				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);
+		});
+	});
+}
+//#endregion
+export { convertToSchema };