@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/utils/generator-code/go.js

@@ -0,0 +1,160 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database, NameCase } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { orderByNameASC } from "../tableName.js";
+import { getNameCase, splitLines } from "./utils.js";
+import { getColumnType, isMySQLFamily } from "./columnTypes.js";
+import { upperFirst } from "es-toolkit";
+//#region src/utils/generator-code/go.ts
+var SCALAR_TYPES = {
+	bool: "bool",
+	i8: "int8",
+	i16: "int16",
+	i32: "int32",
+	i64: "int64",
+	u8: "uint8",
+	u16: "uint16",
+	u32: "uint32",
+	u64: "uint64",
+	f32: "float32",
+	f64: "float64",
+	decimal: "decimal.Decimal",
+	string: "string",
+	bytes: "[]byte",
+	uuid: "string",
+	json: "json.RawMessage",
+	date: "time.Time",
+	time: "time.Time",
+	timeTz: "string",
+	dateTime: "time.Time",
+	dateTimeUtc: "time.Time",
+	dateTimeOffset: "time.Time",
+	interval: "string"
+};
+var TEXT_TIME_DATABASES = /* @__PURE__ */ new Set([
+	Database.MariaDB,
+	Database.MySQL,
+	Database.PostgreSQL,
+	Database.SQLite
+]);
+var RAW_JSON_DATABASES = /* @__PURE__ */ new Set([
+	Database.MariaDB,
+	Database.MySQL,
+	Database.Oracle,
+	Database.PostgreSQL
+]);
+var UPPER_CASE_START = /^\p{Lu}/u;
+var MARK = /\p{M}/u;
+var MARKS = /\p{M}/gu;
+var GO_SPACE = /[\s\x85]/;
+var PLUS_BUILD = /^[\s\x85]*\+build(?:[\s\x85]|$)/;
+var TAG_ESCAPE = /["\\\uFEFF]|(?!\t)\p{Cc}/gu;
+var TAG_ESCAPES = {
+	"\"": "\\\"",
+	"\\": "\\\\",
+	"\n": "\\n",
+	"\r": "\\r"
+};
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const stringBuffer = [""];
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		formatTable(state, {
+			buffer: stringBuffer,
+			table
+		});
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const { settings: { tableNameCase }, collections } = state;
+	const structName = exportedName(table.name, tableNameCase);
+	formatComment(buffer, "", commentText(table.comment));
+	buffer.push(`type ${structName} struct {`);
+	alignmentRunsOf(query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).map((column) => createField(state, column))).forEach((run) => {
+		const nameWidth = Math.max(...run.map((field) => runeCount(field.name)));
+		const typeWidth = Math.max(...run.map((field) => field.type.length));
+		run.forEach((field) => {
+			const padding = " ".repeat(nameWidth - runeCount(field.name));
+			formatComment(buffer, "	", field.comment);
+			buffer.push(`\t${field.name}${padding} ${field.type.padEnd(typeWidth)} ${field.tag}`);
+		});
+	});
+	buffer.push(`}`);
+}
+function alignmentRunsOf(fields) {
+	const runs = [];
+	fields.forEach((field) => {
+		if (field.comment !== "" || runs.length === 0) runs.push([]);
+		runs[runs.length - 1].push(field);
+	});
+	return runs;
+}
+function createField({ settings: { columnNameCase, database } }, column) {
+	const columnType = getColumnType(column.dataType, database);
+	const type = elementType(columnType, database);
+	const isNullable = !bHas(column.options, ColumnOption.notNull) && !bHas(column.options, ColumnOption.primaryKey);
+	return {
+		name: exportedName(column.name, columnNameCase),
+		type: fieldType(type, columnType.arrayDepth, isNullable),
+		tag: structTag(column.name),
+		comment: commentText(column.comment)
+	};
+}
+function elementType({ scalar, base, isGuid, isMoney }, database) {
+	if (isMySQLFamily(database) && base === "bit") return "[]byte";
+	if (base === "bfile") return "string";
+	if (scalar === "time" && TEXT_TIME_DATABASES.has(database)) return "string";
+	if (isMoney && database === Database.PostgreSQL) return "string";
+	if (scalar === "json" && !RAW_JSON_DATABASES.has(database)) return "string";
+	if (isGuid && database === Database.MSSQL) return "mssql.UniqueIdentifier";
+	return SCALAR_TYPES[scalar];
+}
+function fieldType(type, arrayDepth, isNullable) {
+	if (arrayDepth > 0) return `${"[]".repeat(arrayDepth)}${type}`;
+	return isNullable && !type.startsWith("[]") ? `*${type}` : type;
+}
+function commentText(comment) {
+	return trimEndSpace(trimStartSpace(comment.replaceAll("\0", "").replaceAll("", "")));
+}
+function trimEndSpace(text) {
+	let end = text.length;
+	while (end > 0 && GO_SPACE.test(text[end - 1])) end -= 1;
+	return text.slice(0, end);
+}
+function trimStartSpace(text) {
+	let start = 0;
+	while (start < text.length && GO_SPACE.test(text[start])) start += 1;
+	return text.slice(start);
+}
+function formatComment(buffer, indent, comment) {
+	if (comment === "") return;
+	const lines = splitLines(comment).map(trimEndSpace);
+	lines.forEach((text, index) => {
+		if (text === "" && lines[index - 1] === "") return;
+		buffer.push(`${indent}${commentLine(text)}`);
+	});
+}
+function commentLine(text) {
+	if (text === "") return "//";
+	return PLUS_BUILD.test(text) && !text.includes("*/") ? `/* ${text.replaceAll("\f", " ")} */` : `// ${text}`;
+}
+function structTag(columnName) {
+	const tag = `json:"${columnName === "-" ? "-," : escaped(columnName)}"`;
+	return tag.includes("`") ? `"${escaped(tag)}"` : `\`${tag}\``;
+}
+function escaped(value) {
+	return value.replace(TAG_ESCAPE, (char) => TAG_ESCAPES[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+function exportedName(name, nameCase) {
+	const composed = name.normalize("NFC");
+	const cased = upperFirst(getNameCase(composed, nameCase)).normalize("NFC");
+	const letters = nameCase === NameCase.none && MARK.test(composed) ? cased : cased.replace(MARKS, "");
+	return UPPER_CASE_START.test(letters) ? letters : `X${letters}`;
+}
+function runeCount(value) {
+	return [...value].length;
+}
+//#endregion
+export { createCode, formatTable };

package/dist/utils/generator-code/graphql.js

@@ -0,0 +1,347 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnUIKey, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { orderByNameASC } from "../tableName.js";
+import { isSingleWord } from "../../engine/modules/relationship/fkColumns.js";
+import { getNameCase, hasNRelationship, hasOneRelationship } from "./utils.js";
+import { getColumnType, isMySQLFamily } from "./columnTypes.js";
+//#region src/utils/generator-code/graphql.ts
+var CUSTOM_SCALARS = [
+	"BigInt",
+	"Byte",
+	"Date",
+	"DateTime",
+	"Decimal",
+	"JSON"
+];
+var BUILT_IN_TYPES = [
+	"Boolean",
+	"Float",
+	"ID",
+	"Int",
+	"String"
+];
+var scalarTypes = {
+	bool: "Boolean",
+	i8: "Int",
+	i16: "Int",
+	i32: "Int",
+	i64: "BigInt",
+	u8: "Int",
+	u16: "Int",
+	u32: "BigInt",
+	u64: "BigInt",
+	f32: "Float",
+	f64: "Float",
+	decimal: "Decimal",
+	string: "String",
+	bytes: "Byte",
+	uuid: "String",
+	json: "JSON",
+	date: "Date",
+	time: "String",
+	timeTz: "String",
+	dateTime: "DateTime",
+	dateTimeUtc: "DateTime",
+	dateTimeOffset: "DateTime",
+	interval: "String"
+};
+var INT_DIGITS = 9;
+var PARSED_ARRAY_TYPES = /* @__PURE__ */ new Set([
+	"bool",
+	"boolean",
+	"bytea",
+	"int2",
+	"smallint",
+	"int4",
+	"int",
+	"integer",
+	"int8",
+	"bigint",
+	"oid",
+	"float4",
+	"real",
+	"float8",
+	"float",
+	"double precision",
+	"numeric",
+	"decimal",
+	"dec",
+	"money",
+	"bpchar",
+	"char",
+	"character",
+	"nchar",
+	"national char",
+	"national character",
+	"varchar",
+	"char varying",
+	"character varying",
+	"nchar varying",
+	"national char varying",
+	"national character varying",
+	"text",
+	"regproc",
+	"uuid",
+	"macaddr",
+	"inet",
+	"cidr",
+	"numrange",
+	"date",
+	"time",
+	"time without time zone",
+	"timetz",
+	"time with time zone",
+	"timestamp",
+	"timestamp without time zone",
+	"timestamptz",
+	"timestamp with time zone",
+	"json",
+	"jsonb",
+	"point"
+]);
+var NON_NAME = /[^_0-9A-Za-z]/g;
+var NAME_START = /^[_A-Za-z]/;
+var FALLBACK_NAME = "_";
+var LEADING_UNDERSCORES = /^_+/;
+var LEADING_RUN = /^__/;
+var NAME_INFORMATIVE = /[0-9A-Za-z]/;
+var BLOCK_STRING = /"""/g;
+var NEWLINE = /\r\n|\r|\n/g;
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+var REPLACEMENT_CHARACTER = "�";
+var TYPE_WRAPPERS = /[[\]!]/g;
+var ID_SUFFIX = /id$/i;
+var TRAILING_SEPARATORS = /[^\p{L}\p{M}\p{N}]+$/u;
+var LAST_LETTER = /\p{L}(?=[\p{M}\p{N}]*$)/u;
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const stringBuffer = [""];
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+	const context = createTypeContext(state);
+	pushScalars(stringBuffer, context.scalars);
+	tables.forEach((table) => {
+		formatType(state, {
+			buffer: stringBuffer,
+			table
+		}, context);
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	pushScalars(buffer, usedScalars(getColumnFields(state, table)));
+	formatType(state, {
+		buffer,
+		table
+	}, createTypeContext(state));
+}
+function formatType(state, { buffer, table }, context) {
+	const { settings: { tableNameCase } } = state;
+	const typeName = getTypeName(state, context, table);
+	const bodyBuffer = [];
+	const fields = getColumnFields(state, table);
+	const fieldNames = new Set(fields.map(({ name }) => name));
+	pushDescription(buffer, "", describe(table.name, graphqlName(getNameCase(table.name, tableNameCase)), table.comment));
+	fields.forEach(({ column, name, type }) => {
+		pushDescription(bodyBuffer, "  ", describe(column.name, name, column.comment));
+		bodyBuffer.push(`  ${name}: ${type}`);
+	});
+	formatRelation(state, {
+		buffer: bodyBuffer,
+		table
+	}, context, fieldNames);
+	if (bodyBuffer.length === 0) {
+		buffer.push(`type ${typeName}`);
+		return;
+	}
+	buffer.push(`type ${typeName} {`);
+	bodyBuffer.forEach((line) => buffer.push(line));
+	buffer.push("}");
+}
+function getColumnFields({ collections, settings: { columnNameCase, database } }, table) {
+	const fieldNames = /* @__PURE__ */ new Set();
+	const fields = [];
+	query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).forEach((column) => {
+		const isPK = bHas(column.ui.keys, ColumnUIKey.primaryKey);
+		const isFK = bHas(column.ui.keys, ColumnUIKey.foreignKey);
+		if (!isPK && isFK) return;
+		const name = graphqlName(getNameCase(column.name, columnNameCase));
+		if (fieldNames.has(name)) return;
+		fieldNames.add(name);
+		fields.push({
+			column,
+			name,
+			type: getFieldType(column, isFK, database)
+		});
+	});
+	return fields;
+}
+function getFieldType(column, isFK, database) {
+	const isPrimaryKey = bHas(column.options, ColumnOption.primaryKey);
+	const nonNull = isPrimaryKey || bHas(column.options, ColumnOption.notNull) ? "!" : "";
+	if (isPrimaryKey || isFK) return `ID${nonNull}`;
+	return `${getDataType(column.dataType, database)}${nonNull}`;
+}
+function getDataType(dataType, database) {
+	const columnType = getColumnType(dataType, database);
+	const { arrayDepth, base, scalar } = columnType;
+	if (arrayDepth > 0 && scalar !== "interval" && !PARSED_ARRAY_TYPES.has(base)) return "String";
+	return `${"[".repeat(arrayDepth)}${getScalar(columnType, database)}${"]".repeat(arrayDepth)}`;
+}
+function getScalar(columnType, database) {
+	const { scalar, base, bits, isMoney } = columnType;
+	if (isMoney && database === Database.PostgreSQL) return "String";
+	if (base === "number" && scalar === "i64" && (database === Database.Oracle || database === Database.Snowflake)) return getNumberScalar(columnType, database);
+	if (scalar === "bool" && base === "bit" && isMySQLFamily(database)) return "Int";
+	return bits === 24 ? "Int" : scalarTypes[scalar];
+}
+function getNumberScalar({ args, precision, scale }, database) {
+	if (database === Database.Oracle && args.length === 0 && scale === null) return "Decimal";
+	if (precision === null) return "BigInt";
+	return precision - Math.min(scale ?? 0, 0) <= INT_DIGITS ? "Int" : "BigInt";
+}
+function formatRelation(state, { buffer, table }, context, fieldNames) {
+	const { doc: { relationshipIds }, collections, settings: { columnNameCase } } = state;
+	const tableCollection = query(collections).collection("tableEntities");
+	const relationships = query(collections).collection("relationshipEntities").selectByIds(relationshipIds);
+	const tableNamedFields = /* @__PURE__ */ new Set();
+	const pushField = (relationship, relatedTable, fieldName, fieldType) => {
+		if (!isNamedByForeignKey(context, relationship)) {
+			if (tableNamedFields.has(fieldName)) return;
+			tableNamedFields.add(fieldName);
+		}
+		const name = uniqueName(fieldNames, fieldName);
+		pushDescription(buffer, "  ", describe(relatedTable.name, graphqlName(getNameCase(relatedTable.name, columnNameCase)), relatedTable.comment));
+		buffer.push(`  ${name}: ${fieldType}`);
+	};
+	relationships.filter((relationship) => relationship.end.tableId === table.id).forEach((relationship) => {
+		const startTable = tableCollection.selectById(relationship.start.tableId);
+		if (startTable) pushField(relationship, startTable, getChildFieldName(state, context, relationship, startTable), getTypeName(state, context, startTable));
+	});
+	relationships.filter((relationship) => relationship.start.tableId === table.id).forEach((relationship) => {
+		const endTable = tableCollection.selectById(relationship.end.tableId);
+		if (!endTable) return;
+		const typeName = getTypeName(state, context, endTable);
+		if (hasOneRelationship(relationship.relationshipType)) pushField(relationship, endTable, getParentFieldName(state, context, relationship, endTable, false), typeName);
+		else if (hasNRelationship(relationship.relationshipType)) pushField(relationship, endTable, getParentFieldName(state, context, relationship, endTable, true), `[${typeName}!]!`);
+	});
+}
+function getChildFieldName(state, context, relationship, parent) {
+	const { columnNameCase } = state.settings;
+	const name = getNameCase(parent.name, columnNameCase);
+	const stem = getRelationStem(state, context, relationship);
+	if (stem !== null) return graphqlName(stem);
+	return graphqlName(isSelfRelationship(relationship) ? getNameCase(`parent_${name}`, columnNameCase) : name);
+}
+function getParentFieldName(state, context, relationship, child, many) {
+	const { columnNameCase } = state.settings;
+	const name = getNameCase(child.name, columnNameCase);
+	const stem = getRelationStem(state, context, relationship);
+	if (stem !== null) return graphqlName(getNameCase(many ? `${name}List_by_${stem}` : `${name}_by_${stem}`, columnNameCase));
+	return many ? graphqlName(getNameCase(`${name}List`, columnNameCase)) : graphqlName(name);
+}
+function getRelationStem(state, context, relationship) {
+	return isNamedByForeignKey(context, relationship) ? getForeignKeyStem(state, relationship) : null;
+}
+function isNamedByForeignKey({ sharedPairs }, relationship) {
+	return isSelfRelationship(relationship) || sharedPairs.has(pairKey(relationship));
+}
+function isSelfRelationship({ start, end }) {
+	return start.tableId === end.tableId;
+}
+function pairKey({ start, end }) {
+	return [start.tableId, end.tableId].sort().join(":");
+}
+function findSharedPairs({ collections, doc: { relationshipIds } }) {
+	const pairs = /* @__PURE__ */ new Set();
+	const sharedPairs = /* @__PURE__ */ new Set();
+	query(collections).collection("relationshipEntities").selectByIds(relationshipIds).forEach((relationship) => {
+		const key = pairKey(relationship);
+		if (pairs.has(key)) sharedPairs.add(key);
+		pairs.add(key);
+	});
+	return sharedPairs;
+}
+function getForeignKeyStem({ collections, settings: { columnNameCase } }, relationship) {
+	const { columnIds } = relationship.end;
+	if (columnIds.length !== 1) return null;
+	const column = query(collections).collection("tableColumnEntities").selectById(columnIds[0]);
+	const stem = column ? stripIdWord(column.name) : null;
+	if (stem === null) return null;
+	const name = getNameCase(stem, columnNameCase);
+	return NAME_INFORMATIVE.test(name) && !LEADING_RUN.test(sanitizeName(name)) ? name : null;
+}
+function stripIdWord(name) {
+	const id = name.slice(-2);
+	if (!ID_SUFFIX.test(name) || !isSingleWord(id)) return null;
+	const head = name.slice(0, -2);
+	const stem = head.replace(TRAILING_SEPARATORS, "");
+	if (stem === "") return null;
+	if (stem !== head) return stem;
+	const letter = LAST_LETTER.exec(head)?.[0];
+	return letter !== void 0 && !isSingleWord(`${letter}${id}`) ? head : null;
+}
+function createTypeContext(state) {
+	const tables = query(state.collections).collection("tableEntities").selectByIds(state.doc.tableIds).sort(orderByNameASC);
+	const scalars = usedScalars(tables.flatMap((table) => getColumnFields(state, table)));
+	const context = {
+		typeNames: /* @__PURE__ */ new Map(),
+		usedTypeNames: /* @__PURE__ */ new Set([...BUILT_IN_TYPES, ...scalars]),
+		sharedPairs: findSharedPairs(state),
+		scalars
+	};
+	tables.forEach((table) => getTypeName(state, context, table));
+	return context;
+}
+function usedScalars(fields) {
+	const named = new Set(fields.map(({ type }) => type.replace(TYPE_WRAPPERS, "")));
+	return CUSTOM_SCALARS.filter((scalar) => named.has(scalar));
+}
+function pushScalars(buffer, scalars) {
+	if (scalars.length === 0) return;
+	scalars.forEach((scalar) => buffer.push(`scalar ${scalar}`));
+	buffer.push("");
+}
+function getTypeName({ settings: { tableNameCase } }, context, table) {
+	const cached = context.typeNames.get(table.id);
+	if (cached !== void 0) return cached;
+	const typeName = uniqueName(context.usedTypeNames, graphqlName(getNameCase(table.name, tableNameCase)));
+	context.typeNames.set(table.id, typeName);
+	return typeName;
+}
+function uniqueName(used, name) {
+	let result = name;
+	let index = 2;
+	while (used.has(result)) {
+		result = `${name}${index}`;
+		index += 1;
+	}
+	used.add(result);
+	return result;
+}
+function describe(name, exported, comment) {
+	if (NAME_INFORMATIVE.test(exported)) return comment;
+	return comment.trim() === "" ? name : `${name} - ${comment}`;
+}
+function graphqlName(name) {
+	return sanitizeName(name).replace(LEADING_UNDERSCORES, "_");
+}
+function sanitizeName(name) {
+	const value = name.replace(NON_NAME, "_");
+	if (value === "") return FALLBACK_NAME;
+	return NAME_START.test(value) ? value : `_${value}`;
+}
+function pushDescription(buffer, indent, comment) {
+	if (comment.trim() === "") return;
+	const value = comment.replace(LONE_SURROGATE, REPLACEMENT_CHARACTER).replace(BLOCK_STRING, "\\\"\"\"");
+	if (value.includes("\n") || value.includes("\r") || value.endsWith("\"") || value.endsWith("\\")) {
+		buffer.push(`${indent}"""`);
+		value.split(NEWLINE).forEach((line) => buffer.push(line === "" ? "" : `${indent}${line}`));
+		buffer.push(`${indent}"""`);
+		return;
+	}
+	buffer.push(`${indent}"""${value}"""`);
+}
+//#endregion
+export { createCode, formatTable, stripIdWord };

package/dist/utils/generator-code/heck.js

@@ -0,0 +1,47 @@
+//#region src/utils/generator-code/heck.ts
+var ALPHANUMERIC = /[\p{Alphabetic}\p{N}]/u;
+var LOWERCASE = /\p{Lowercase}/u;
+var UPPERCASE = /\p{Uppercase}/u;
+function heckWords(value) {
+	const words = [];
+	const pieces = [[]];
+	for (const char of value) if (ALPHANUMERIC.test(char)) pieces[pieces.length - 1].push(char);
+	else pieces.push([]);
+	pieces.forEach((piece) => {
+		let start = 0;
+		let mode = "boundary";
+		for (let i = 0; i < piece.length; i++) {
+			const char = piece[i];
+			if (i === piece.length - 1) {
+				words.push(piece.slice(start));
+				break;
+			}
+			const next = piece[i + 1];
+			const nextMode = LOWERCASE.test(char) ? "lowercase" : UPPERCASE.test(char) ? "uppercase" : mode;
+			if (nextMode === "lowercase" && UPPERCASE.test(next)) {
+				words.push(piece.slice(start, i + 1));
+				start = i + 1;
+				mode = "boundary";
+			} else if (mode === "uppercase" && UPPERCASE.test(char) && LOWERCASE.test(next)) {
+				words.push(piece.slice(start, i));
+				start = i;
+				mode = "boundary";
+			} else mode = nextMode;
+		}
+	});
+	return words;
+}
+function lowerWord(chars) {
+	return chars.map((char, i) => char === "Σ" && i === chars.length - 1 ? "ς" : char.toLowerCase()).join("");
+}
+function capitalizeWord(chars) {
+	return chars.length === 0 ? "" : chars[0].toUpperCase() + lowerWord(chars.slice(1));
+}
+function toSnakeCase(value) {
+	return heckWords(value).map(lowerWord).join("_");
+}
+function toUpperCamelCase(value) {
+	return heckWords(value).map(capitalizeWord).join("");
+}
+//#endregion
+export { toSnakeCase, toUpperCamelCase };