@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,402 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { orderByNameASC } from "../tableName.js";
+import { getNameCase } from "./utils.js";
+import { getJsonShape, isNullableColumn } from "./jsonShape.js";
+//#region src/utils/generator-code/jsonSchema.ts
+var DIALECT = "https://json-schema.org/draft/2020-12/schema";
+var TIME_PATTERN = "^(?:[01][0-9]|2[0-3]):[0-5][0-9](?::[0-5][0-9](?:\\.[0-9]+)?)?$";
+var NAIVE_DATE_TIME_PATTERN = "^[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])T(?:[01][0-9]|2[0-3]):[0-5][0-9](?::[0-5][0-9](?:\\.[0-9]+)?Z?)?$";
+var INDENT = "  ";
+var LINE_LIMIT = 80;
+var PRINTABLE_ASCII = /^[\x20-\x7f]*$/;
+var WIDE_RUNS = [
+	4352,
+	4447,
+	8986,
+	8987,
+	9001,
+	9002,
+	9193,
+	9196,
+	9200,
+	9200,
+	9203,
+	9203,
+	9725,
+	9726,
+	9748,
+	9749,
+	9776,
+	9783,
+	9800,
+	9811,
+	9855,
+	9855,
+	9866,
+	9871,
+	9875,
+	9875,
+	9889,
+	9889,
+	9898,
+	9899,
+	9917,
+	9918,
+	9924,
+	9925,
+	9934,
+	9934,
+	9940,
+	9940,
+	9962,
+	9962,
+	9970,
+	9971,
+	9973,
+	9973,
+	9978,
+	9978,
+	9981,
+	9981,
+	9989,
+	9989,
+	9994,
+	9995,
+	10024,
+	10024,
+	10060,
+	10060,
+	10062,
+	10062,
+	10067,
+	10069,
+	10071,
+	10071,
+	10133,
+	10135,
+	10160,
+	10160,
+	10175,
+	10175,
+	11035,
+	11036,
+	11088,
+	11088,
+	11093,
+	11093,
+	11904,
+	11929,
+	11931,
+	12019,
+	12032,
+	12245,
+	12272,
+	12350,
+	12353,
+	12438,
+	12441,
+	12543,
+	12549,
+	12591,
+	12593,
+	12686,
+	12688,
+	12773,
+	12783,
+	12830,
+	12832,
+	12871,
+	12880,
+	42124,
+	42128,
+	42182,
+	43360,
+	43388,
+	44032,
+	55203,
+	63744,
+	64255,
+	65040,
+	65049,
+	65072,
+	65106,
+	65108,
+	65126,
+	65128,
+	65131,
+	65281,
+	65376,
+	65504,
+	65510,
+	94176,
+	94180,
+	94192,
+	94198,
+	94208,
+	101589,
+	101631,
+	101662,
+	101760,
+	101874,
+	110576,
+	110579,
+	110581,
+	110587,
+	110589,
+	110590,
+	110592,
+	110882,
+	110898,
+	110898,
+	110928,
+	110930,
+	110933,
+	110933,
+	110948,
+	110951,
+	110960,
+	111355,
+	119552,
+	119638,
+	119648,
+	119670,
+	126980,
+	126980,
+	127183,
+	127183,
+	127374,
+	127374,
+	127377,
+	127386,
+	127488,
+	127490,
+	127504,
+	127547,
+	127552,
+	127560,
+	127568,
+	127569,
+	127584,
+	127589,
+	127744,
+	127776,
+	127789,
+	127797,
+	127799,
+	127868,
+	127870,
+	127891,
+	127904,
+	127946,
+	127951,
+	127955,
+	127968,
+	127984,
+	127988,
+	127988,
+	127992,
+	128062,
+	128064,
+	128064,
+	128066,
+	128252,
+	128255,
+	128317,
+	128331,
+	128334,
+	128336,
+	128359,
+	128378,
+	128378,
+	128405,
+	128406,
+	128420,
+	128420,
+	128507,
+	128591,
+	128640,
+	128709,
+	128716,
+	128716,
+	128720,
+	128722,
+	128725,
+	128728,
+	128732,
+	128735,
+	128747,
+	128748,
+	128756,
+	128764,
+	128992,
+	129003,
+	129008,
+	129008,
+	129292,
+	129338,
+	129340,
+	129349,
+	129351,
+	129535,
+	129648,
+	129660,
+	129664,
+	129674,
+	129678,
+	129734,
+	129736,
+	129736,
+	129741,
+	129756,
+	129759,
+	129770,
+	129775,
+	129784,
+	131072,
+	196605,
+	196608,
+	262141
+];
+var WIDE_EMOJI = /* @__PURE__ */ new Set([
+	9757,
+	9977,
+	9996,
+	9997,
+	127947,
+	127948,
+	128372,
+	128373,
+	128400
+]);
+function createCode(state) {
+	const { doc: { tableIds }, settings: { tableNameCase }, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+	if (tables.length === 0) return "";
+	const keys = toDefinitionKeys(tables.map((table) => getNameCase(table.name, tableNameCase)));
+	const definitions = new Map(tables.map((table, index) => [keys[index], tableSchema(state, table, keys[index])]));
+	return `\n${formatJson(/* @__PURE__ */ new Map([["$schema", DIALECT], ["$defs", definitions]]))}\n`;
+}
+function createTableCode(state, table) {
+	const { settings: { tableNameCase } } = state;
+	const schema = tableSchema(state, table, getNameCase(table.name, tableNameCase));
+	return `\n${formatJson(new Map([["$schema", DIALECT], ...schema]))}\n`;
+}
+function toDefinitionKeys(names) {
+	const taken = new Set(names);
+	const used = /* @__PURE__ */ new Set();
+	const isFree = (key) => !taken.has(key) && !used.has(key);
+	return names.map((name) => {
+		let key = name;
+		if (used.has(name)) {
+			let index = 2;
+			while (!isFree(`${name}${index}`)) index++;
+			key = `${name}${index}`;
+		}
+		used.add(key);
+		return key;
+	});
+}
+function toValueSchema(shape) {
+	let schema = elementSchema(shape);
+	for (let depth = 0; depth < shape.arrayDepth; depth++) schema = /* @__PURE__ */ new Map([["type", "array"], ["items", schema]]);
+	return schema;
+}
+function withNull(schema) {
+	const type = schema.get("type");
+	if (typeof type !== "string" || type === "null") return schema;
+	const result = new Map(schema).set("type", [type, "null"]);
+	const members = schema.get("enum");
+	if (Array.isArray(members)) result.set("enum", [...members, null]);
+	return result;
+}
+function formatJson(object, indent = "") {
+	if (object.size === 0) return "{}";
+	const inner = indent + INDENT;
+	const entries = [...object];
+	return `{\n${entries.map(([key, value], index) => {
+		const head = `${inner}${JSON.stringify(key)}: `;
+		if (value instanceof Map) return head + formatJson(value, inner);
+		if (Array.isArray(value)) {
+			const isFollowed = index < entries.length - 1;
+			return head + formatArray(value, inner, textWidth(head) + (isFollowed ? 1 : 0));
+		}
+		return head + JSON.stringify(value);
+	}).join(",\n")}\n${indent}}`;
+}
+function textWidth(text) {
+	if (PRINTABLE_ASCII.test(text)) return text.length;
+	let width = 0;
+	for (const character of text) {
+		const codePoint = character.codePointAt(0);
+		if (!isZeroWidth(codePoint)) width += isWide(codePoint) || WIDE_EMOJI.has(codePoint) ? 2 : 1;
+	}
+	return width;
+}
+function tableSchema({ settings: { columnNameCase, database }, collections }, table, title) {
+	const properties = /* @__PURE__ */ new Map();
+	query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).forEach((column) => {
+		const key = getNameCase(column.name, columnNameCase);
+		if (!properties.has(key)) properties.set(key, propertySchema(column, database));
+	});
+	const schema = /* @__PURE__ */ new Map([["title", title]]);
+	if (hasText(table.comment)) schema.set("description", table.comment);
+	return schema.set("type", "object").set("properties", properties).set("required", [...properties.keys()]).set("additionalProperties", false);
+}
+function propertySchema(column, database) {
+	const schema = toValueSchema(getJsonShape(column.dataType, database));
+	const value = isNullableColumn(column) ? withNull(schema) : schema;
+	return hasText(column.comment) ? new Map([["description", column.comment], ...value]) : value;
+}
+function elementSchema(shape) {
+	switch (shape.kind) {
+		case "boolean":
+		case "number":
+		case "null": return typed(shape.kind);
+		case "integer": {
+			const schema = typed("integer");
+			if (shape.minimum !== null) schema.set("minimum", shape.minimum);
+			if (shape.maximum !== null) schema.set("maximum", shape.maximum);
+			return schema;
+		}
+		case "string": return Number.isSafeInteger(shape.maxLength) ? typed("string").set("maxLength", shape.maxLength) : typed("string");
+		case "uuid":
+		case "guid": return typed("string").set("format", "uuid");
+		case "date": return typed("string").set("format", "date");
+		case "time": return typed("string").set("pattern", TIME_PATTERN);
+		case "naiveDateTime": return typed("string").set("pattern", NAIVE_DATE_TIME_PATTERN);
+		case "offsetDateTime": return typed("string").set("format", "date-time");
+		case "base64": return typed("string").set("contentEncoding", "base64");
+		case "json": return /* @__PURE__ */ new Map();
+		case "enum": return typed("string").set("enum", shape.members);
+		case "ipv4":
+		case "ipv6": return typed("string").set("format", shape.kind);
+	}
+}
+function typed(type) {
+	return /* @__PURE__ */ new Map([["type", type]]);
+}
+function hasText(comment) {
+	return comment.trim() !== "";
+}
+function formatArray(items, indent, restWidth) {
+	const texts = items.map((item) => JSON.stringify(item));
+	if (texts.reduce((sum, text) => sum + textWidth(text) + 2, restWidth) <= LINE_LIMIT) return `[${texts.join(", ")}]`;
+	const inner = indent + INDENT;
+	return `[\n${texts.map((text) => inner + text).join(",\n")}\n${indent}]`;
+}
+function isZeroWidth(codePoint) {
+	return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint >= 768 && codePoint <= 879 || codePoint >= 65024 && codePoint <= 65039;
+}
+function isWide(codePoint) {
+	let low = 0;
+	let high = WIDE_RUNS.length / 2 - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		if (codePoint < WIDE_RUNS[middle * 2]) high = middle - 1;
+		else if (codePoint > WIDE_RUNS[middle * 2 + 1]) low = middle + 1;
+		else return true;
+	}
+	return false;
+}
+//#endregion
+export { DIALECT, NAIVE_DATE_TIME_PATTERN, TIME_PATTERN, createCode, createTableCode, formatJson, textWidth, toDefinitionKeys, toValueSchema, withNull };

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

@@ -0,0 +1,169 @@
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { getColumnType, isMySQLFamily } from "./columnTypes.js";
+//#region src/utils/generator-code/jsonShape.ts
+var KINDS = {
+	bool: "boolean",
+	i8: "integer",
+	i16: "integer",
+	i32: "integer",
+	i64: "integer",
+	u8: "integer",
+	u16: "integer",
+	u32: "integer",
+	u64: "integer",
+	f32: "number",
+	f64: "number",
+	decimal: "string",
+	string: "string",
+	bytes: "base64",
+	uuid: "uuid",
+	json: "json",
+	date: "date",
+	time: "time",
+	timeTz: "string",
+	dateTime: "naiveDateTime",
+	dateTimeUtc: "offsetDateTime",
+	dateTimeOffset: "offsetDateTime",
+	interval: "string"
+};
+var UNSIGNED_SCALARS = /* @__PURE__ */ new Set([
+	"u8",
+	"u16",
+	"u32"
+]);
+var RESERVED_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"any",
+	"await",
+	"bigint",
+	"boolean",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"never",
+	"new",
+	"null",
+	"number",
+	"object",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"string",
+	"super",
+	"switch",
+	"symbol",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"undefined",
+	"unknown",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+var IDENTIFIER_NAME = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+var NEWER_IDENTIFIER_CHARACTER = new RegExp(`[${[
+	[2191, 2199],
+	[3163, 3164],
+	[3287, 3292],
+	[6863, 6911],
+	[7305, 7311],
+	[42955, 42959],
+	[42962, 42962],
+	[42964, 42964],
+	[42970, 42993],
+	[67005, 67071],
+	[67898, 67967],
+	[68922, 69247],
+	[69298, 69372],
+	[70517, 70655],
+	[71370, 71423],
+	[72441, 72703],
+	[73130, 73439],
+	[73562, 73647],
+	[78934, 82943],
+	[83527, 92159],
+	[93072, 93759],
+	[93824, 93951],
+	[94194, 94207],
+	[100344, 100351],
+	[101590, 101631],
+	[101641, 110575],
+	[113823, 118527],
+	[124154, 124895],
+	[177978, 177983],
+	[183970, 183983],
+	[205744, 917759]
+].map(([first, last]) => `\\u{${first.toString(16)}}-\\u{${last.toString(16)}}`).join("")}]`, "u");
+function getJsonShape(dataType, database) {
+	const columnType = getColumnType(dataType, database);
+	const kind = shapeKind(columnType, database);
+	const [minimum, maximum] = kind === "integer" ? integerRange(columnType) : [null, null];
+	return {
+		kind,
+		minimum,
+		maximum,
+		maxLength: kind === "string" ? columnType.length : null,
+		members: listMembers(columnType, database),
+		arrayDepth: columnType.arrayDepth
+	};
+}
+function isNullableColumn(column) {
+	return !bHas(column.options, ColumnOption.primaryKey) && !bHas(column.options, ColumnOption.notNull);
+}
+function toTypeScriptTypeName(name) {
+	return RESERVED_TYPE_NAMES.has(name) ? `${name}_` : name;
+}
+function toTypeScriptPropertyKey(name) {
+	return IDENTIFIER_NAME.test(name) && !NEWER_IDENTIFIER_CHARACTER.test(name) ? name : JSON.stringify(name);
+}
+function listMembers({ enumMembers }, database) {
+	const members = enumMembers ?? [];
+	return [...new Set(isMySQLFamily(database) ? members.map((member) => member.replace(/ +$/, "")) : members)];
+}
+function shapeKind(columnType, database) {
+	if (columnType.enumMembers) return "enum";
+	if (columnType.isNullOnly) return "null";
+	if (columnType.isTextInteger) return "string";
+	if (columnType.isGuid) return "guid";
+	if (columnType.network === "ipv4" || columnType.network === "ipv6") return columnType.network;
+	if (columnType.scalar === "decimal" && database === Database.SQLite) return "number";
+	return KINDS[columnType.scalar];
+}
+function integerRange({ scalar, bits }) {
+	if (scalar === "i64") return [null, null];
+	if (scalar === "u64") return [0, null];
+	const half = 2 ** (bits - 1);
+	return UNSIGNED_SCALARS.has(scalar) ? [0, 2 * half - 1] : [-half, half - 1];
+}
+//#endregion
+export { getJsonShape, isNullableColumn, toTypeScriptPropertyKey, toTypeScriptTypeName };

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

@@ -0,0 +1,102 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { orderByNameASC } from "../tableName.js";
+import { getNameCase } from "./utils.js";
+import { formatLineComment, getJvmType } from "./java.js";
+//#region src/utils/generator-code/kotlin.ts
+var INDENT = "    ";
+var UNDERSCORES = /^_+$/;
+var kotlinTypes = {
+	BigDecimal: "BigDecimal",
+	Boolean: "Boolean",
+	Byte: "Byte",
+	bytes: "ByteArray",
+	Double: "Double",
+	Duration: "Duration",
+	Float: "Float",
+	Integer: "Int",
+	LocalDate: "LocalDate",
+	LocalDateTime: "LocalDateTime",
+	LocalTime: "LocalTime",
+	Long: "Long",
+	OffsetDateTime: "OffsetDateTime",
+	OffsetTime: "OffsetTime",
+	Short: "Short",
+	String: "String",
+	UUID: "UUID"
+};
+var KOTLIN_KEYWORDS = /* @__PURE__ */ new Set([
+	"as",
+	"break",
+	"class",
+	"continue",
+	"do",
+	"else",
+	"false",
+	"for",
+	"fun",
+	"if",
+	"in",
+	"interface",
+	"is",
+	"null",
+	"object",
+	"package",
+	"return",
+	"super",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typealias",
+	"typeof",
+	"val",
+	"var",
+	"when",
+	"while"
+]);
+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 tableName = toKotlinName(getNameCase(table.name, tableNameCase));
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	formatLineComment(buffer, "", table.comment);
+	if (columns.length === 0) {
+		buffer.push(`class ${tableName}`);
+		return;
+	}
+	buffer.push(`data class ${tableName}(`);
+	columns.forEach((column) => {
+		formatColumn(state, {
+			buffer,
+			column
+		});
+	});
+	buffer.push(`)`);
+}
+function formatColumn({ settings: { columnNameCase, database } }, { buffer, column }) {
+	const columnName = toKotlinName(getNameCase(column.name, columnNameCase));
+	const { type, arrayDepth } = getJvmType(column.dataType, database);
+	let kotlinType = kotlinTypes[type];
+	for (let depth = 0; depth < arrayDepth; depth++) kotlinType = `List<${kotlinType}>`;
+	const isNotNull = bHas(column.options, ColumnOption.primaryKey) || bHas(column.options, ColumnOption.notNull);
+	formatLineComment(buffer, INDENT, column.comment);
+	buffer.push(isNotNull ? `${INDENT}val ${columnName}: ${kotlinType},` : `${INDENT}val ${columnName}: ${kotlinType}? = null,`);
+}
+function toKotlinName(name) {
+	return KOTLIN_KEYWORDS.has(name) || UNDERSCORES.test(name) ? `\`${name}\`` : name;
+}
+//#endregion
+export { createCode, formatTable, toKotlinName };