@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/schema-sql/utils.js

@@ -0,0 +1,251 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database, OrderType, ReferentialAction, ReferentialActionToSQL } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { orderByNameASC, primaryKeyColumns } from "../tableName.js";
+import { SchemaSQLStatements } from "./options.js";
+//#region src/utils/schema-sql/utils.ts
+function createWrittenObjects() {
+	return {
+		tables: [],
+		sequences: [],
+		identifiers: []
+	};
+}
+function commentToWrite({ comment, logicalName }, logicalNameAsComment = false) {
+	if (comment.trim() !== "") return comment;
+	return logicalNameAsComment && logicalName.trim() !== "" ? logicalName : "";
+}
+function toForeignKeyPairs({ doc: { tableIds }, collections }, { start, end }) {
+	if (!tableIds.includes(start.tableId) || !tableIds.includes(end.tableId)) return null;
+	const tableCollection = query(collections).collection("tableEntities");
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const startTable = tableCollection.selectById(start.tableId);
+	const endTable = tableCollection.selectById(end.tableId);
+	if (!startTable || !endTable) return null;
+	const pairs = [];
+	const length = Math.min(start.columnIds.length, end.columnIds.length);
+	for (let i = 0; i < length; i++) {
+		const startId = start.columnIds[i];
+		const endId = end.columnIds[i];
+		if (!startTable.columnIds.includes(startId) || !endTable.columnIds.includes(endId)) continue;
+		const startColumn = columnCollection.selectById(startId);
+		const endColumn = columnCollection.selectById(endId);
+		if (startColumn && endColumn) pairs.push([startColumn, endColumn]);
+	}
+	if (pairs.length === 0) return null;
+	const keyIds = new Set(primaryKeyColumns(columnCollection.selectByIds(startTable.columnIds)).map((column) => column.id));
+	const startIds = new Set(pairs.map(([column]) => column.id));
+	if (keyIds.size === startIds.size && [...startIds].every((id) => keyIds.has(id))) {
+		const position = (column) => startTable.columnIds.indexOf(column.id);
+		pairs.sort(([a], [b]) => position(a) - position(b));
+	}
+	return {
+		startTable,
+		endTable,
+		start: pairs.map(([column]) => column),
+		end: pairs.map(([, column]) => column)
+	};
+}
+function selectIndexColumns(collections, table, index) {
+	const listed = new Set(table.columnIds);
+	return query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).flatMap((indexColumn) => {
+		const column = listed.has(indexColumn.columnId) ? query(collections).collection("tableColumnEntities").selectById(indexColumn.columnId) : void 0;
+		return column ? [{
+			indexColumn,
+			column
+		}] : [];
+	});
+}
+function toSchemaEntities({ doc, collections }, tableIds) {
+	const named = tableIds ? new Set(tableIds) : null;
+	const listed = new Set(doc.tableIds);
+	const writes = (tableId) => !named || named.has(tableId);
+	return {
+		tables: query(collections).collection("tableEntities").selectByIds(doc.tableIds.filter(writes)).sort(orderByNameASC),
+		relationships: query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds).filter(({ end }) => writes(end.tableId)),
+		indexes: query(collections).collection("indexEntities").selectByIds(doc.indexIds).filter(({ tableId }) => listed.has(tableId) && writes(tableId))
+	};
+}
+function formatNames(list, backtick, backtick2) {
+	const buf = [];
+	list.forEach((v, i) => {
+		if (backtick) {
+			if (backtick2) buf.push(`${backtick}${v.name}${backtick2}`);
+			else buf.push(`${backtick}${v.name}${backtick}`);
+		} else buf.push(v.name);
+		if (list.length !== i + 1) buf.push(", ");
+	});
+	return buf.join("");
+}
+function formatSize(columns) {
+	let name = 0;
+	let dataType = 0;
+	columns.forEach((column) => {
+		if (name < column.name.length) name = column.name.length;
+		if (dataType < column.dataType.length) dataType = column.dataType.length;
+	});
+	return {
+		name,
+		dataType
+	};
+}
+function formatSpace(size) {
+	const buf = [];
+	for (let i = 0; i < size; i++) buf.push(" ");
+	return buf.join("");
+}
+function primaryKey(columns) {
+	return columns.some(({ options }) => bHas(options, ColumnOption.primaryKey));
+}
+function unique(columns) {
+	return columns.some(({ options }) => bHas(options, ColumnOption.unique));
+}
+function uniqueColumns(columns) {
+	return columns.filter(({ options }) => bHas(options, ColumnOption.unique));
+}
+function ifNotExists(statements) {
+	return statements === SchemaSQLStatements.ifNotExists ? " IF NOT EXISTS" : "";
+}
+function toOrderName(orderType) {
+	switch (orderType) {
+		case OrderType.ASC: return "ASC";
+		case OrderType.DESC: return "DESC";
+		default: return "";
+	}
+}
+var REFERENTIAL_ACTIONS = [
+	ReferentialAction.noAction,
+	ReferentialAction.cascade,
+	ReferentialAction.setNull,
+	ReferentialAction.setDefault,
+	ReferentialAction.restrict
+];
+var ALL_REFERENTIAL_ACTIONS = {
+	onDelete: REFERENTIAL_ACTIONS,
+	onUpdate: REFERENTIAL_ACTIONS
+};
+function withoutReferentialAction(...refused) {
+	const actions = REFERENTIAL_ACTIONS.filter((value) => !refused.includes(value));
+	return {
+		onDelete: actions,
+		onUpdate: actions
+	};
+}
+var REFERENTIAL_ACTION_SUPPORT = {
+	[Database.Databricks]: {
+		onDelete: [ReferentialAction.noAction],
+		onUpdate: [ReferentialAction.noAction]
+	},
+	[Database.MariaDB]: withoutReferentialAction(ReferentialAction.setDefault),
+	[Database.MSSQL]: withoutReferentialAction(ReferentialAction.restrict),
+	[Database.MySQL]: withoutReferentialAction(ReferentialAction.setDefault),
+	[Database.Oracle]: {
+		onDelete: [ReferentialAction.cascade, ReferentialAction.setNull],
+		onUpdate: []
+	},
+	[Database.PostgreSQL]: ALL_REFERENTIAL_ACTIONS,
+	[Database.SQLite]: ALL_REFERENTIAL_ACTIONS,
+	[Database.Snowflake]: {
+		onDelete: [ReferentialAction.noAction],
+		onUpdate: [ReferentialAction.noAction]
+	}
+};
+function referentialActionSupport(database) {
+	return REFERENTIAL_ACTION_SUPPORT[database] ?? ALL_REFERENTIAL_ACTIONS;
+}
+function formatReferentialActions({ onDelete, onUpdate }, support) {
+	const clauses = [];
+	if (support.onDelete.includes(onDelete)) clauses.push(`ON DELETE ${ReferentialActionToSQL[onDelete]}`);
+	if (support.onUpdate.includes(onUpdate)) clauses.push(`ON UPDATE ${ReferentialActionToSQL[onUpdate]}`);
+	return clauses;
+}
+function toStringLiteral(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+var DEFAULT_PIECE = /'(?:[^']|'')*'?|"(?:[^"]|"")*"?|`(?:[^`]|``)*`?|\[[^\]]*\]?|[a-z_][\w$]*|\d[\w.]*|[^]/giu;
+function isWrapped(text) {
+	const pieces = text.match(DEFAULT_PIECE) ?? [];
+	let depth = 0;
+	return pieces[0] === "(" && pieces.every((piece, index) => {
+		if (piece === "(") depth++;
+		else if (piece === ")") depth--;
+		return depth > 0 || index === pieces.length - 1;
+	});
+}
+function topLevelWords(text) {
+	const words = [];
+	let depth = 0;
+	for (const piece of text.match(DEFAULT_PIECE) ?? []) if (piece === "(") depth++;
+	else if (piece === ")") depth--;
+	else if (depth === 0 && /^[a-z_]/i.test(piece)) words.push(piece.toUpperCase());
+	return words;
+}
+function isCall(text) {
+	const name = /^[a-z_][\w$]*(?:\.[a-z_][\w$]*)*\s*(?=\()/i.exec(text);
+	return !!name && isWrapped(text.slice(name[0].length));
+}
+var NUMBER = String.raw`[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?`;
+var MYSQL_NOW = "(?:current_timestamp|now|localtime|localtimestamp)";
+var MYSQL_BARE = new RegExp("^(?:" + [
+	NUMBER,
+	String.raw`0x[\da-f]+`,
+	String.raw`0b[01]+`,
+	String.raw`(?:_\w+\s*|n)?'(?:[^'\\]|''|\\.)*'`,
+	String.raw`(?:_\w+\s*|n)?"(?:[^"\\]|""|\\.)*"`,
+	String.raw`x'[\da-f]*'`,
+	String.raw`b'[01]*'`,
+	String.raw`(?:date|time|timestamp)\s*'[^']*'`,
+	"null|true|false",
+	String.raw`${MYSQL_NOW}(?:\s*\(\s*\d*\s*\))?`
+].join("|") + String.raw`)(\s+on\s+update\s.*)?$`, "is");
+var MYSQL_EXPRESSION_TYPE = /^(?:(?:tiny|medium|long)?(?:blob|text)|long|json|geometry|geom(?:etry)?collection|(?:multi)?(?:point|linestring|polygon))\b/i;
+var MYSQL_CURRENT_TIME = new RegExp(String.raw`^${MYSQL_NOW}\b`, "i");
+function takesBareMySQL(text, dataType) {
+	const bare = MYSQL_BARE.exec(text);
+	if (!bare) return false;
+	if (bare[1] || /^null$/i.test(text)) return true;
+	if (MYSQL_EXPRESSION_TYPE.test(dataType)) return false;
+	return !MYSQL_CURRENT_TIME.test(text) || /^(?:timestamp|datetime)\b/i.test(dataType);
+}
+var SQLITE_BARE = new RegExp("^(?:" + [
+	NUMBER,
+	String.raw`[+-]?0x[\da-f]+`,
+	`'(?:[^']|'')*'`,
+	String.raw`x'[\da-f]*'`,
+	String.raw`[a-z_][\w$]*`,
+	`"(?:[^"]|"")*"`,
+	"`(?:[^`]|``)*`",
+	String.raw`\[[^\]]*\]`
+].join("|") + ")$", "i");
+var POSTGRESQL_EXPRESSION_WORDS = [
+	"ALL",
+	"AND",
+	"ANY",
+	"AT",
+	"BETWEEN",
+	"COLLATE",
+	"ILIKE",
+	"IN",
+	"IS",
+	"ISNULL",
+	"LIKE",
+	"NOT",
+	"NOTNULL",
+	"OR",
+	"OVERLAPS",
+	"SIMILAR",
+	"SOME"
+];
+var TAKES_BARE = {
+	[Database.MariaDB]: (text) => MYSQL_BARE.test(text) || isCall(text) || /^[a-z_][\w$]*$/i.test(text),
+	[Database.MySQL]: takesBareMySQL,
+	[Database.PostgreSQL]: (text) => !topLevelWords(text).some((word) => POSTGRESQL_EXPRESSION_WORDS.includes(word)),
+	[Database.SQLite]: (text) => SQLITE_BARE.test(text)
+};
+function formatDefault(value, database, dataType = "") {
+	const text = value.trim();
+	const takesBare = TAKES_BARE[database];
+	return !takesBare || isWrapped(text) || takesBare(text, dataType.trim()) ? value : `(${text})`;
+}
+//#endregion
+export { ALL_REFERENTIAL_ACTIONS, commentToWrite, createWrittenObjects, formatDefault, formatNames, formatReferentialActions, formatSize, formatSpace, ifNotExists, primaryKey, referentialActionSupport, selectIndexColumns, toForeignKeyPairs, toOrderName, toSchemaEntities, toStringLiteral, unique, uniqueColumns, withoutReferentialAction };

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

@@ -0,0 +1,312 @@
+import { parser } from "../../erd-editor-schema/dist/v3/parser/index.js";
+import { toJson } from "../../erd-editor-schema/dist/parser.js";
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnUIKey, OrderType, RelationshipType } from "../../constants/schema.js";
+import { DatabaseVendor, DatabaseVendorToDatabase } from "../../constants/sql/database.js";
+import { textInRange } from "../validation.js";
+import { createTable } from "../collection/table.entity.js";
+import { createColumn } from "../collection/tableColumn.entity.js";
+import { bHas } from "../bit.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 "./utils.js";
+import { SortType, StatementType } from "../../schema-sql-parser/dist/parser/statement/index.js";
+import { schemaSQLParser } from "../../schema-sql-parser/dist/parser/index.js";
+//#region src/utils/schema-sql-parser/index.ts
+function schemaSQLParserToSchemaJson(sql, ctx, prepare, database) {
+	const schema = parser({});
+	const vendor = Object.values(DatabaseVendor).find((value) => DatabaseVendorToDatabase[value] === database);
+	const tables = mergeTables(getStatementMap(schemaSQLParser(sql, { database: vendor })));
+	tables.forEach((table) => convertTable(schema, table, ctx));
+	convertRelationship(schema, tables);
+	convertIndex(schema, tables);
+	return toJson(prepare ? prepare(schema) : schema);
+}
+function getStatementMap(statements) {
+	const map = {
+		tables: [],
+		indexes: [],
+		primaryKeys: [],
+		foreignKeys: [],
+		uniques: [],
+		defaults: [],
+		autoIncrements: [],
+		tableComments: [],
+		columnComments: []
+	};
+	for (const statement of statements) switch (statement.type) {
+		case StatementType.createTable:
+			if (statement.name) map.tables.push(statement);
+			break;
+		case StatementType.createIndex:
+			if (statement.tableName && statement.columns.length) map.indexes.push(statement);
+			break;
+		case StatementType.alterTableAddPrimaryKey:
+			if (statement.name && statement.columnNames.length) map.primaryKeys.push(statement);
+			break;
+		case StatementType.alterTableAddForeignKey:
+			if (statement.name && statement.columnNames.length && statement.refTableName && (!statement.refColumnNames.length || statement.columnNames.length === statement.refColumnNames.length)) map.foreignKeys.push(statement);
+			break;
+		case StatementType.alterTableAddUnique:
+			if (statement.name && statement.columns.length) map.uniques.push(statement);
+			break;
+		case StatementType.alterTableAddDefault:
+			if (statement.name && statement.columnName && statement.default) map.defaults.push(statement);
+			break;
+		case StatementType.alterTableAlterColumnAutoIncrement:
+			if (statement.name && statement.columnName) map.autoIncrements.push(statement);
+			break;
+		case StatementType.commentOnTable:
+			if (statement.name) map.tableComments.push(statement);
+			break;
+		case StatementType.commentOnColumn: if (statement.tableName && statement.columnName) map.columnComments.push(statement);
+	}
+	return map;
+}
+function mergeTables({ tables, indexes, primaryKeys, foreignKeys, uniques, defaults, autoIncrements, tableComments, columnComments }) {
+	indexes.forEach((index) => {
+		const table = findByName(tables, index.tableName);
+		if (!table) return;
+		const created = keyOf(index);
+		const sameIndex = table.indexes.find((other) => mayRepeat(table, other) && isKeyIndex(keyOf(other), created));
+		if (sameIndex) {
+			sameIndex.name ||= index.name;
+			sameIndex.unique ||= index.unique;
+			return;
+		}
+		if (table.keys.some((key) => isKeyIndex(key, created))) return;
+		table.indexes.push({
+			name: index.name,
+			unique: index.unique,
+			columns: index.columns
+		});
+	});
+	primaryKeys.forEach((primaryKey) => {
+		const table = findByName(tables, primaryKey.name);
+		if (!table) return;
+		const keyIndex = findKeyIndex(table, {
+			name: primaryKey.usingIndexName || primaryKey.constraintName,
+			columnNames: primaryKey.columnNames
+		});
+		if (keyIndex) table.indexes.splice(table.indexes.indexOf(keyIndex), 1);
+		primaryKey.columnNames.forEach((columnName) => {
+			const column = findByName(table.columns, columnName);
+			if (!column) return;
+			column.primaryKey = true;
+		});
+	});
+	uniques.forEach((unique) => {
+		const table = findByName(tables, unique.name);
+		if (!table) return;
+		const keyIndex = findKeyIndex(table, {
+			name: unique.usingIndexName || unique.constraintName,
+			columnNames: namesOf(unique.columns)
+		});
+		if (keyIndex && unique.columns.length > 1) {
+			keyIndex.unique = true;
+			return;
+		}
+		if (keyIndex) table.indexes.splice(table.indexes.indexOf(keyIndex), 1);
+		if (unique.columns.length > 1) {
+			table.indexes.push({
+				name: unique.constraintName,
+				unique: true,
+				columns: unique.columns
+			});
+			return;
+		}
+		unique.columns.forEach(({ name }) => {
+			const column = findByName(table.columns, name);
+			if (!column) return;
+			column.unique = true;
+		});
+	});
+	foreignKeys.forEach((foreignKey) => {
+		const table = findByName(tables, foreignKey.name);
+		if (!table) return;
+		table.foreignKeys.push({
+			columnNames: foreignKey.columnNames,
+			refTableName: foreignKey.refTableName,
+			refColumnNames: foreignKey.refColumnNames,
+			onDelete: foreignKey.onDelete,
+			onUpdate: foreignKey.onUpdate
+		});
+	});
+	defaults.forEach(({ name, columnName, default: value }) => {
+		const table = findByName(tables, name);
+		if (!table) return;
+		const column = findByName(table.columns, columnName);
+		if (!column) return;
+		column.default = value;
+	});
+	autoIncrements.forEach(({ name, columnName }) => {
+		const table = findByName(tables, name);
+		if (!table) return;
+		const column = findByName(table.columns, columnName);
+		if (!column) return;
+		column.autoIncrement = true;
+		column.default = "";
+	});
+	tableComments.forEach(({ name, comment }) => {
+		const table = findCommentTable(tables, name);
+		if (!table) return;
+		table.comment = comment;
+	});
+	columnComments.forEach(({ tableName, columnName, comment }) => {
+		const table = findCommentTable(tables, tableName);
+		if (!table) return;
+		const column = findByName(table.columns, columnName);
+		if (!column) return;
+		column.comment = comment;
+	});
+	return tables;
+}
+function findCommentTable(tables, name) {
+	return findByName(tables, name) ?? findByName(tables, name.slice(name.lastIndexOf(".") + 1));
+}
+function mayRepeat(table, index) {
+	return index.name !== "" || table.keys.some((key) => isKeyIndex(key, keyOf(index)));
+}
+function findKeyIndex(table, key) {
+	return table.indexes.find((index) => isKeyIndex(key, keyOf(index))) ?? null;
+}
+function isKeyIndex(key, index) {
+	return key.name ? isSameName(key.name, index.name) && hasSameColumns(key.columnNames, index.columnNames) : hasColumnsInOrder(key.columnNames, index.columnNames);
+}
+var keyOf = ({ name, columns }) => ({
+	name,
+	columnNames: namesOf(columns)
+});
+var namesOf = (columns) => columns.map(({ name }) => name);
+var isSameName = (a, b) => a.toUpperCase() === b.toUpperCase();
+function hasSameColumns(a, b) {
+	const names = new Set(a.map((name) => name.toUpperCase()));
+	return a.length === b.length && b.every((name) => names.has(name.toUpperCase()));
+}
+function hasColumnsInOrder(a, b) {
+	return a.length === b.length && a.every((name, i) => isSameName(name, b[i]));
+}
+function convertTable({ doc, collections }, table, { toWidth }) {
+	const newTable = createTable({
+		name: table.name,
+		comment: table.comment,
+		ui: {
+			widthName: textInRange(toWidth(table.name)),
+			widthComment: textInRange(toWidth(table.comment))
+		}
+	});
+	table.columns.forEach((column) => {
+		const newColumn = createColumn({
+			tableId: newTable.id,
+			name: column.name,
+			comment: column.comment,
+			dataType: column.dataType,
+			default: column.default,
+			options: (column.autoIncrement ? ColumnOption.autoIncrement : 0) | (column.primaryKey ? ColumnOption.primaryKey : 0) | (column.unique ? ColumnOption.unique : 0) | (column.nullable ? 0 : ColumnOption.notNull),
+			ui: {
+				widthName: textInRange(toWidth(column.name)),
+				widthComment: textInRange(toWidth(column.comment)),
+				widthDataType: textInRange(toWidth(column.dataType)),
+				widthDefault: textInRange(toWidth(column.default)),
+				keys: column.primaryKey ? ColumnUIKey.primaryKey : 0
+			}
+		});
+		newTable.columnIds.push(newColumn.id);
+		newTable.seqColumnIds.push(newColumn.id);
+		query(collections).collection("tableColumnEntities").setOne(newColumn);
+	});
+	doc.tableIds.push(newTable.id);
+	query(collections).collection("tableEntities").setOne(newTable);
+}
+function convertRelationship({ doc, collections }, tables) {
+	const newTables = query(collections).collection("tableEntities").selectByIds(doc.tableIds);
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	tables.forEach((table) => {
+		if (!table.foreignKeys.length) return;
+		const endTable = findByName(newTables, table.name);
+		if (!endTable) return;
+		const eColumns = columnCollection.selectByIds(endTable.columnIds);
+		table.foreignKeys.forEach((foreignKey) => {
+			const startTable = findByName(newTables, foreignKey.refTableName);
+			if (!startTable) return;
+			const sColumns = columnCollection.selectByIds(startTable.columnIds);
+			const startColumns = [];
+			const endColumns = [];
+			if (foreignKey.refColumnNames.length) foreignKey.refColumnNames.forEach((refColumnName) => {
+				const column = findByName(sColumns, refColumnName);
+				if (!column) return;
+				startColumns.push(column);
+			});
+			else {
+				const primaryKeys = sColumns.filter((column) => bHas(column.ui.keys, ColumnUIKey.primaryKey));
+				if (primaryKeys.length === 1) startColumns.push(...primaryKeys);
+			}
+			foreignKey.columnNames.forEach((columnName) => {
+				const column = findByName(eColumns, columnName);
+				if (!column) return;
+				endColumns.push(column);
+			});
+			if (!startColumns.length || startColumns.length !== endColumns.length) return;
+			endColumns.forEach((column) => {
+				if (bHas(column.ui.keys, ColumnUIKey.primaryKey)) column.ui.keys |= ColumnUIKey.foreignKey;
+				else column.ui.keys = ColumnUIKey.foreignKey;
+			});
+			const newRelationship = createRelationship({
+				identification: !endColumns.some((column) => !(bHas(column.ui.keys, ColumnUIKey.primaryKey) && bHas(column.ui.keys, ColumnUIKey.foreignKey))),
+				relationshipType: RelationshipType.ZeroN,
+				onDelete: toReferentialAction(foreignKey.onDelete),
+				onUpdate: toReferentialAction(foreignKey.onUpdate),
+				start: {
+					tableId: startTable.id,
+					columnIds: startColumns.map((column) => column.id)
+				},
+				end: {
+					tableId: endTable.id,
+					columnIds: endColumns.map((column) => column.id)
+				}
+			});
+			doc.relationshipIds.push(newRelationship.id);
+			query(collections).collection("relationshipEntities").setOne(newRelationship);
+		});
+	});
+}
+function convertIndex({ doc, collections }, tables) {
+	const newTables = query(collections).collection("tableEntities").selectByIds(doc.tableIds);
+	tables.forEach((table) => {
+		table.indexes.forEach((index) => {
+			const targetTable = findByName(newTables, table.name);
+			if (!targetTable) return;
+			const columns = query(collections).collection("tableColumnEntities").selectByIds(targetTable.columnIds);
+			const indexColumns = [];
+			const newIndex = createIndex({
+				name: index.name,
+				tableId: targetTable.id,
+				unique: index.unique
+			});
+			index.columns.forEach((column) => {
+				const targetColumn = findByName(columns, column.name);
+				if (!targetColumn) return;
+				const newIndexColumn = createIndexColumn({
+					indexId: newIndex.id,
+					columnId: targetColumn.id,
+					orderType: column.sort === SortType.asc ? OrderType.ASC : OrderType.DESC
+				});
+				indexColumns.push(newIndexColumn);
+			});
+			const complete = indexColumns.length === index.columns.length;
+			if (indexColumns.length !== 0 && (complete || !index.unique)) {
+				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 { schemaSQLParserToSchemaJson };

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

@@ -0,0 +1,7 @@
+//#region src/utils/schema-sql-parser/utils.ts
+function findByName(list, name) {
+	for (const item of list) if (item.name.toUpperCase() === name.toUpperCase()) return item;
+	return null;
+}
+//#endregion
+export { findByName };

package/dist/utils/sharedColor.js

@@ -0,0 +1,19 @@
+import { Palette } from "../themes/radix-ui-theme.js";
+import { get } from "es-toolkit/compat";
+var SharedColors = [
+	"tomato",
+	"gold",
+	"grass",
+	"teal",
+	"iris",
+	"purple",
+	"plum",
+	"pink"
+].map((hue) => get(Palette, `${hue}.${hue}9`) ?? "");
+function toSharedColor(id) {
+	let hash = 0;
+	for (let i = 0; i < id.length; i++) hash = hash * 31 + id.charCodeAt(i) | 0;
+	return SharedColors[Math.abs(hash) % SharedColors.length];
+}
+//#endregion
+export { SharedColors, toSharedColor };

package/dist/utils/stageCursor.js

@@ -0,0 +1,20 @@
+//#region src/utils/stageCursor.ts
+var CURSOR_GRABBING = "grabbing";
+var stageCursorHolds = /* @__PURE__ */ new WeakMap();
+function setStageCursor(container, cursor) {
+	const hold = stageCursorHolds.get(container);
+	if (hold) hold.requested = cursor;
+	else container.style.cursor = cursor;
+}
+function holdStageCursor(container, cursor) {
+	const hold = { requested: stageCursorHolds.get(container)?.requested ?? container.style.cursor };
+	stageCursorHolds.set(container, hold);
+	container.style.cursor = cursor;
+	return () => {
+		if (stageCursorHolds.get(container) !== hold) return;
+		stageCursorHolds.delete(container);
+		container.style.cursor = hold.requested;
+	};
+}
+//#endregion
+export { CURSOR_GRABBING, holdStageCursor, setStageCursor };