@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,646 @@
+import { fromDBMLColor } from "../tableColor.js";
+import { TokenKind, tokenize } from "./tokenizer.js";
+//#region src/utils/schema-dbml-parser/parser.ts
+var SETTING_KEY = /^[0-9a-z ]+$/;
+var QUOTE = /'/g;
+var QUESTION = /\?/g;
+function parseDBMLModel(source) {
+	try {
+		return {
+			ok: true,
+			model: parseDocument(tokenize(source))
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: error instanceof Error ? error.message : "Invalid DBML"
+		};
+	}
+}
+function createReader(tokens) {
+	let index = 0;
+	return {
+		peek: (offset = 0) => tokens[index + offset] ?? null,
+		next: () => tokens[index++] ?? null,
+		atEnd: () => index >= tokens.length
+	};
+}
+function parseDocument(tokens) {
+	const reader = createReader(tokens);
+	const model = {
+		tables: [],
+		refs: [],
+		tableGroups: [],
+		enums: {},
+		skipped: []
+	};
+	const partials = /* @__PURE__ */ new Map();
+	const skipped = /* @__PURE__ */ new Set();
+	const record = (kind) => {
+		if (!skipped.has(kind)) {
+			skipped.add(kind);
+			model.skipped.push(kind);
+		}
+	};
+	const skip = (kind) => {
+		record(kind);
+		skipElement(reader);
+	};
+	while (!reader.atEnd()) {
+		if (skipNewlines(reader)) continue;
+		const token = reader.peek();
+		if (!token) break;
+		if (!isName(token)) {
+			reader.next();
+			continue;
+		}
+		const keyword = token.value.toLowerCase();
+		if (keyword === "table" && token.kind === TokenKind.identifier) {
+			reader.next();
+			const table = parseTable(reader, partials);
+			if (table) model.tables.push(table);
+			continue;
+		}
+		if (keyword === "tablepartial" && token.kind === TokenKind.identifier) {
+			reader.next();
+			const partial = parseTable(reader, partials);
+			if (partial) partials.set(partial.name, partial.columns);
+			continue;
+		}
+		if (keyword === "ref" && token.kind === TokenKind.identifier) {
+			reader.next();
+			model.refs.push(...parseRef(reader));
+			continue;
+		}
+		if (keyword === "enum" && token.kind === TokenKind.identifier) {
+			reader.next();
+			parseEnum(reader, model.enums);
+			continue;
+		}
+		if (keyword === "tablegroup" && token.kind === TokenKind.identifier) {
+			reader.next();
+			model.tableGroups.push(parseTableGroup(reader, record));
+			continue;
+		}
+		skip(keyword);
+	}
+	return model;
+}
+function parseTableGroup(reader, record) {
+	const { name } = readQualifiedName(reader);
+	const group = {
+		name,
+		color: "",
+		tables: []
+	};
+	readSettings(reader).forEach(({ key, tokens }) => {
+		if (key === "color") group.color = fromDBMLColor(colorOf(tokens));
+		else if (key !== "") record(`tablegroup ${key}`);
+	});
+	if (!consumeBrace(reader)) {
+		skipLine(reader);
+		return group;
+	}
+	while (!reader.atEnd()) {
+		if (skipNewlines(reader)) continue;
+		const token = reader.peek();
+		if (!token) break;
+		if (isPunctuation(token, "}")) {
+			reader.next();
+			break;
+		}
+		const following = reader.peek(1);
+		if (token.kind === TokenKind.identifier && token.value.toLowerCase() === "note" && following && (isPunctuation(following, ":") || isPunctuation(following, "{"))) {
+			reader.next();
+			reader.next();
+			if (isPunctuation(following, "{")) skipBlock(reader);
+			else skipLine(reader);
+			record("tablegroup note");
+			continue;
+		}
+		if (isName(token)) {
+			const { schemaName, name: tableName } = readQualifiedName(reader);
+			group.tables.push({
+				schemaName,
+				tableName
+			});
+		}
+		skipLine(reader);
+	}
+	return group;
+}
+function parseTable(reader, partials) {
+	const { schemaName, name } = readQualifiedName(reader);
+	const table = {
+		schemaName,
+		name,
+		alias: "",
+		comment: "",
+		color: "",
+		columns: [],
+		indexes: []
+	};
+	const alias = reader.peek();
+	if (alias && alias.kind === TokenKind.identifier && alias.value.toLowerCase() === "as") {
+		reader.next();
+		table.alias = readName(reader);
+	}
+	applyTableSettings(table, readSettings(reader));
+	if (!consumeBrace(reader)) return name === "" ? null : table;
+	while (!reader.atEnd()) {
+		if (skipNewlines(reader)) continue;
+		const token = reader.peek();
+		if (!token) break;
+		if (token.kind === TokenKind.punctuation && token.value === "}") {
+			reader.next();
+			break;
+		}
+		if (token.kind === TokenKind.punctuation && token.value === "~") {
+			reader.next();
+			const injected = partials.get(readName(reader));
+			if (injected) table.columns.push(...injected.map((column) => ({ ...column })));
+			continue;
+		}
+		if (token.kind === TokenKind.identifier) {
+			const keyword = token.value.toLowerCase();
+			const following = reader.peek(1);
+			if (keyword === "note" && following && isPunctuation(following, ":")) {
+				reader.next();
+				reader.next();
+				table.comment = readTextValue(reader);
+				continue;
+			}
+			if (keyword === "note" && following && isPunctuation(following, "{")) {
+				reader.next();
+				reader.next();
+				table.comment = readBlockText(reader);
+				continue;
+			}
+			if (keyword === "indexes" && following && isPunctuation(following, "{")) {
+				reader.next();
+				reader.next();
+				table.indexes.push(...parseIndexes(reader));
+				continue;
+			}
+			if (following && isPunctuation(following, "{")) {
+				reader.next();
+				reader.next();
+				skipBlock(reader);
+				continue;
+			}
+		}
+		const column = parseColumn(reader);
+		if (column) table.columns.push(column);
+	}
+	return table;
+}
+function parseColumn(reader) {
+	const nameToken = reader.peek();
+	if (!nameToken || !isName(nameToken)) {
+		skipLine(reader);
+		return null;
+	}
+	reader.next();
+	const column = {
+		name: nameToken.value,
+		comment: "",
+		typeName: "",
+		typeSchemaName: "",
+		primaryKey: false,
+		unique: false,
+		notNull: false,
+		autoIncrement: false,
+		default: "",
+		inlineRefs: []
+	};
+	const type = readColumnType(reader);
+	column.typeName = type.name;
+	column.typeSchemaName = type.schemaName;
+	applyColumnSettings(column, readSettings(reader));
+	skipLine(reader);
+	return column.typeName === "" ? null : column;
+}
+function readColumnType(reader) {
+	const { schemaName, name } = readQualifiedName(reader);
+	if (name === "") return {
+		name: "",
+		schemaName: ""
+	};
+	const parts = [name];
+	const open = reader.peek();
+	if (open && isPunctuation(open, "(")) {
+		reader.next();
+		parts.push(`(${readArguments(reader)})`);
+	}
+	const bracket = reader.peek();
+	const closing = reader.peek(1);
+	if (bracket && closing && isPunctuation(bracket, "[") && isPunctuation(closing, "]")) {
+		reader.next();
+		reader.next();
+		parts.push("[]");
+	}
+	return {
+		name: parts.join(""),
+		schemaName
+	};
+}
+function readArguments(reader) {
+	const parts = [];
+	while (!reader.atEnd()) {
+		const token = reader.next();
+		if (!token || isPunctuation(token, ")")) break;
+		if (token.kind === TokenKind.newline) continue;
+		parts.push(token.kind === TokenKind.string ? `'${token.value}'` : token.value);
+	}
+	return parts.join("");
+}
+function parseIndexes(reader) {
+	const indexes = [];
+	while (!reader.atEnd()) {
+		if (skipNewlines(reader)) continue;
+		const token = reader.peek();
+		if (!token) break;
+		if (isPunctuation(token, "}")) {
+			reader.next();
+			break;
+		}
+		const index = {
+			name: "",
+			unique: false,
+			primaryKey: false,
+			columnNames: []
+		};
+		if (isPunctuation(token, "(")) {
+			reader.next();
+			index.columnNames.push(...readIndexColumns(reader));
+		} else if (isName(token)) {
+			reader.next();
+			index.columnNames.push(token.value);
+		} else reader.next();
+		applyIndexSettings(index, readSettings(reader));
+		skipLine(reader);
+		if (index.columnNames.length !== 0) indexes.push(index);
+	}
+	return indexes;
+}
+function readIndexColumns(reader) {
+	const names = [];
+	while (!reader.atEnd()) {
+		const token = reader.next();
+		if (!token || isPunctuation(token, ")")) break;
+		if (isName(token)) names.push(token.value);
+	}
+	return names;
+}
+function parseRef(reader) {
+	const named = reader.peek();
+	if (named && isName(named)) {
+		const following = reader.peek(1);
+		if (following && (isPunctuation(following, ":") || isPunctuation(following, "{"))) reader.next();
+	}
+	const opening = reader.peek();
+	if (opening && isPunctuation(opening, ":")) {
+		reader.next();
+		const ref = readRefBody(reader);
+		skipLine(reader);
+		return ref ? [ref] : [];
+	}
+	if (!consumeBrace(reader)) {
+		skipLine(reader);
+		return [];
+	}
+	const refs = [];
+	while (!reader.atEnd()) {
+		if (skipNewlines(reader)) continue;
+		const token = reader.peek();
+		if (!token) break;
+		if (isPunctuation(token, "}")) {
+			reader.next();
+			break;
+		}
+		const ref = readRefBody(reader);
+		if (ref) refs.push(ref);
+		else skipLine(reader);
+	}
+	return refs;
+}
+function readRefBody(reader) {
+	const left = readEndpoint(reader);
+	const operator = readOperator(reader);
+	if (operator === "") return null;
+	const right = readEndpoint(reader);
+	const actions = refActionsOf(readSettings(reader));
+	return left.tableName === "" || right.tableName === "" ? null : {
+		operator,
+		left,
+		right,
+		...actions
+	};
+}
+function refActionsOf(settings) {
+	const actions = {
+		onDelete: "",
+		onUpdate: ""
+	};
+	settings.forEach(({ key, tokens }) => {
+		if (key === "delete") actions.onDelete = wordsOf(tokens);
+		else if (key === "update") actions.onUpdate = wordsOf(tokens);
+	});
+	return actions;
+}
+function wordsOf(tokens) {
+	return tokens.filter((token) => token.kind !== TokenKind.newline).map((token) => token.value).join(" ");
+}
+function readOperator(reader) {
+	const token = reader.peek();
+	if (!token) return "";
+	if (token.kind === TokenKind.operator) {
+		reader.next();
+		return token.value.replace(QUESTION, "");
+	}
+	if (isPunctuation(token, "-")) {
+		reader.next();
+		return "-";
+	}
+	return "";
+}
+function readEndpoint(reader) {
+	const names = [];
+	const columnNames = [];
+	while (!reader.atEnd()) {
+		const token = reader.peek();
+		if (!token || !isName(token)) break;
+		reader.next();
+		names.push(token.value);
+		const dot = reader.peek();
+		if (!dot || !isPunctuation(dot, ".")) break;
+		reader.next();
+		const tuple = reader.peek();
+		if (tuple && isPunctuation(tuple, "(")) {
+			reader.next();
+			columnNames.push(...readIndexColumns(reader));
+			break;
+		}
+	}
+	if (columnNames.length === 0 && names.length !== 0) columnNames.push(names.pop());
+	const tableName = names.pop() ?? "";
+	return {
+		schemaName: names.pop() ?? "",
+		tableName,
+		columnNames
+	};
+}
+function parseEnum(reader, enums) {
+	const { schemaName, name } = readQualifiedName(reader);
+	readSettings(reader);
+	if (!consumeBrace(reader)) {
+		skipLine(reader);
+		return;
+	}
+	const members = [];
+	while (!reader.atEnd()) {
+		if (skipNewlines(reader)) continue;
+		const token = reader.peek();
+		if (!token) break;
+		if (isPunctuation(token, "}")) {
+			reader.next();
+			break;
+		}
+		if (isName(token)) {
+			reader.next();
+			members.push(token.value);
+			readSettings(reader);
+		} else reader.next();
+		skipLine(reader);
+	}
+	if (name === "") return;
+	enums[schemaName ? `${schemaName}.${name}` : name] = members;
+	if (schemaName && !(name in enums)) enums[name] = members;
+}
+function readSettings(reader) {
+	const opening = reader.peek();
+	if (!opening || !isPunctuation(opening, "[")) return [];
+	reader.next();
+	const settings = [];
+	let keyParts = [];
+	let tokens = [];
+	let separated = false;
+	const flush = () => {
+		const key = keyParts.join(" ").toLowerCase();
+		if (key !== "" || tokens.length !== 0) settings.push({
+			key,
+			tokens
+		});
+		keyParts = [];
+		tokens = [];
+		separated = false;
+	};
+	while (!reader.atEnd()) {
+		const token = reader.next();
+		if (!token) break;
+		if (isPunctuation(token, "]")) break;
+		if (isPunctuation(token, ",")) {
+			flush();
+			continue;
+		}
+		if (!separated && isPunctuation(token, ":")) {
+			separated = true;
+			continue;
+		}
+		if (separated) {
+			tokens.push(token);
+			continue;
+		}
+		if (isName(token) && SETTING_KEY.test(token.value.toLowerCase())) {
+			keyParts.push(token.value);
+			continue;
+		}
+		separated = true;
+		tokens.push(token);
+	}
+	flush();
+	return settings;
+}
+function applyColumnSettings(column, settings) {
+	settings.forEach(({ key, tokens }) => {
+		switch (key) {
+			case "pk":
+			case "primary key":
+				column.primaryKey = true;
+				break;
+			case "unique":
+				column.unique = true;
+				break;
+			case "not null":
+				column.notNull = true;
+				break;
+			case "increment":
+				column.autoIncrement = true;
+				break;
+			case "note":
+				column.comment = textOf(tokens);
+				break;
+			case "default":
+				column.default = defaultOf(tokens);
+				break;
+			case "ref": {
+				const inlineRef = inlineRefOf(tokens);
+				if (inlineRef) column.inlineRefs.push(inlineRef);
+				break;
+			}
+		}
+	});
+}
+function applyIndexSettings(index, settings) {
+	settings.forEach(({ key, tokens }) => {
+		switch (key) {
+			case "name":
+				index.name = textOf(tokens);
+				break;
+			case "unique":
+				index.unique = true;
+				break;
+			case "pk":
+			case "primary key": index.primaryKey = true;
+		}
+	});
+}
+function applyTableSettings(table, settings) {
+	settings.forEach(({ key, tokens }) => {
+		if (key === "note") table.comment = textOf(tokens);
+		else if (key === "headercolor") table.color = fromDBMLColor(colorOf(tokens));
+	});
+}
+function colorOf(tokens) {
+	return tokens.every((token, index) => {
+		const previous = tokens[index - 1];
+		return (token.kind === TokenKind.punctuation || token.kind === TokenKind.number || token.kind === TokenKind.identifier) && (!previous || token.offset === previous.offset + previous.value.length);
+	}) ? tokens.map((token) => token.value).join("") : "";
+}
+function inlineRefOf(tokens) {
+	const reader = createReader(tokens);
+	const operator = readOperator(reader);
+	if (operator === "") return null;
+	const target = readEndpoint(reader);
+	return target.tableName === "" ? null : {
+		operator,
+		target
+	};
+}
+function textOf(tokens) {
+	const token = tokens.find((candidate) => candidate.kind === TokenKind.string || candidate.kind === TokenKind.quoted || candidate.kind === TokenKind.identifier);
+	return token ? token.value : "";
+}
+function defaultOf(tokens) {
+	const values = tokens.filter((token) => token.kind !== TokenKind.newline);
+	const first = values[0];
+	if (!first) return "";
+	if (isPunctuation(first, "-") && values[1]?.kind === TokenKind.number) return `-${values[1].value}`;
+	switch (first.kind) {
+		case TokenKind.string: return `'${first.value.replace(QUOTE, "''")}'`;
+		case TokenKind.expression:
+		case TokenKind.number:
+		case TokenKind.identifier:
+		case TokenKind.quoted: return first.value;
+		default: return values.map((token) => token.value).join("");
+	}
+}
+function readQualifiedName(reader) {
+	const first = readName(reader);
+	if (first === "") return {
+		schemaName: "",
+		name: ""
+	};
+	const dot = reader.peek();
+	if (!dot || !isPunctuation(dot, ".")) return {
+		schemaName: "",
+		name: first
+	};
+	reader.next();
+	return {
+		schemaName: first,
+		name: readName(reader)
+	};
+}
+function readName(reader) {
+	const token = reader.peek();
+	if (!token || !isName(token)) return "";
+	reader.next();
+	return token.value;
+}
+function readTextValue(reader) {
+	const token = reader.peek();
+	if (token && (token.kind === TokenKind.string || token.kind === TokenKind.quoted)) {
+		reader.next();
+		return token.value;
+	}
+	return "";
+}
+function readBlockText(reader) {
+	let text = "";
+	while (!reader.atEnd()) {
+		const token = reader.next();
+		if (!token || isPunctuation(token, "}")) break;
+		if (text === "" && token.kind === TokenKind.string) text = token.value;
+	}
+	return text;
+}
+function consumeBrace(reader) {
+	let offset = 0;
+	while (reader.peek(offset)?.kind === TokenKind.newline) offset += 1;
+	const token = reader.peek(offset);
+	if (!token || !isPunctuation(token, "{")) return false;
+	for (let step = 0; step <= offset; step += 1) reader.next();
+	return true;
+}
+function skipBlock(reader) {
+	let depth = 1;
+	while (!reader.atEnd() && depth !== 0) {
+		const token = reader.next();
+		if (!token) break;
+		if (isPunctuation(token, "{")) depth += 1;
+		else if (isPunctuation(token, "}")) depth -= 1;
+	}
+}
+function skipElement(reader) {
+	if (consumeBrace(reader)) {
+		skipBlock(reader);
+		return;
+	}
+	while (!reader.atEnd()) {
+		const token = reader.next();
+		if (!token || token.kind === TokenKind.newline) return;
+		if (isPunctuation(token, "{")) {
+			skipBlock(reader);
+			return;
+		}
+	}
+}
+function skipLine(reader) {
+	while (!reader.atEnd()) {
+		const token = reader.peek();
+		if (!token) return;
+		if (token.kind === TokenKind.newline) {
+			reader.next();
+			return;
+		}
+		if (isPunctuation(token, "}")) return;
+		reader.next();
+	}
+}
+function skipNewlines(reader) {
+	const token = reader.peek();
+	if (token && token.kind === TokenKind.newline) {
+		reader.next();
+		return true;
+	}
+	return false;
+}
+function isName(token) {
+	return token.kind === TokenKind.identifier || token.kind === TokenKind.quoted;
+}
+function isPunctuation(token, value) {
+	return token.kind === TokenKind.punctuation && token.value === value;
+}
+//#endregion
+export { parseDBMLModel };