feat(types): add database type help

This commit is contained in:
二丫讲梵 authored and GitHub committed 2026-07-12 13:28:46 +08:00
1 parent fdb33ef477
commit 4f1997d8eb
30 files changed
+2006 -79

No files matched your search

@@ -0,0 +1,20 @@
import { describe, expect, it } from "vitest";
import { optionHelpPanelOffsetTop } from "@/lib/common/optionHelpPanelOffset";
describe("optionHelpPanelOffsetTop", () => {
it("aligns a help panel with the active option when there is room", () => {
expect(optionHelpPanelOffsetTop({ activeItemTop: 48, listCardHeight: 260, panelHeight: 80 })).toBe(48);
});
it("does not produce a negative offset", () => {
expect(optionHelpPanelOffsetTop({ activeItemTop: -12, listCardHeight: 260, panelHeight: 80 })).toBe(0);
});
it("clamps the panel upward at the list card bottom", () => {
expect(optionHelpPanelOffsetTop({ activeItemTop: 210, listCardHeight: 260, panelHeight: 80 })).toBe(180);
});
it("pins a panel taller than the list card to the top", () => {
expect(optionHelpPanelOffsetTop({ activeItemTop: 48, listCardHeight: 80, panelHeight: 120 })).toBe(0);
});
});
@@ -0,0 +1,36 @@
import { describe, expect, it } from "vitest";
import { SEARCHABLE_SELECT_HELP_PANEL_ALIGN, searchableSelectKeyboardTooltipOption, searchableSelectSelectedOrFirstHelpOption } from "@/lib/common/searchableSelectTooltip";
describe("searchableSelectKeyboardTooltipOption", () => {
it("anchors the help panel to the trigger's left edge", () => {
expect(SEARCHABLE_SELECT_HELP_PANEL_ALIGN).toBe("start");
});
it("activates the highlighted option help during Arrow-key navigation", () => {
const optionTooltip = (option: string) => (option === "json" ? "Validated JSON document" : undefined);
// ArrowDown moves highlight from int (index 0) to json (index 1) while the search input retains focus.
expect(searchableSelectKeyboardTooltipOption(["int", "json"], 0, optionTooltip)).toBeUndefined();
expect(searchableSelectKeyboardTooltipOption(["int", "json"], 1, optionTooltip)).toBe("json");
});
it("does not activate help for the initial unhighlighted list state", () => {
const optionTooltip = () => "Type help";
expect(searchableSelectKeyboardTooltipOption(["int"], -1, optionTooltip)).toBeUndefined();
});
it("activates selected help on open and the first matching option after search", () => {
const optionTooltip = (option: string) => (option === "json" || option === "int" ? `${option} help` : undefined);
expect(searchableSelectSelectedOrFirstHelpOption(["int", "json"], "json", optionTooltip)).toBe("json");
expect(searchableSelectSelectedOrFirstHelpOption(["int", "json"], "unknown", optionTooltip)).toBe("int");
expect(searchableSelectSelectedOrFirstHelpOption(["custom"], "unknown", optionTooltip)).toBeUndefined();
expect(searchableSelectSelectedOrFirstHelpOption(["dynamic_unknown", "json"], "dynamic_unknown", optionTooltip)).toBe("json");
});
it("does not activate a tooltip when the optional callback is absent or returns no content", () => {
expect(searchableSelectKeyboardTooltipOption(["int", "json"], 1)).toBeUndefined();
expect(searchableSelectKeyboardTooltipOption(["int", "json"], 0, () => undefined)).toBeUndefined();
});
});
@@ -0,0 +1,44 @@
import { describe, expect, it } from "vitest";
import { REDIS_CREATE_KEY_TYPE_VALUES, getRedisCreateKeyTypeHelp, redisCreateKeyTypeHelpOptionOnOpen, shouldActivateRedisCreateKeyTypeHelpOnFocus } from "@/lib/redis/redisCreateKeyTypeHelp";
import en from "@/i18n/locales/en";
import zhCN from "@/i18n/locales/zh-CN";
function redisCreateTypeHelpMessages(locale: unknown): Record<string, unknown> {
const messages = locale as { redis?: { createKeyTypeHelp?: Record<string, unknown> } };
return messages.redis?.createKeyTypeHelp ?? {};
}
describe("getRedisCreateKeyTypeHelp", () => {
it("covers every key type offered by the Create key dialog", () => {
for (const type of REDIS_CREATE_KEY_TYPE_VALUES) {
expect(getRedisCreateKeyTypeHelp(type)).toEqual({ key: type });
}
});
it("normalizes casing and leaves unsupported types undocumented", () => {
expect(getRedisCreateKeyTypeHelp(" ZSET ")).toEqual({ key: "zset" });
expect(getRedisCreateKeyTypeHelp("bitmap")).toBeUndefined();
});
it("activates help only for focus reached through Arrow navigation", () => {
expect(shouldActivateRedisCreateKeyTypeHelpOnFocus({ openedByArrow: true, keyboardNavigating: true })).toBe(true);
expect(shouldActivateRedisCreateKeyTypeHelpOnFocus({ openedByArrow: false, keyboardNavigating: true })).toBe(true);
expect(shouldActivateRedisCreateKeyTypeHelpOnFocus({ openedByArrow: false, keyboardNavigating: false })).toBe(false);
});
it("shows the selected offered type's help when the Select opens", () => {
expect(redisCreateKeyTypeHelpOptionOnOpen("string")).toBe("string");
expect(redisCreateKeyTypeHelpOptionOnOpen(" JSON ")).toBe("json");
expect(redisCreateKeyTypeHelpOptionOnOpen("bitmap")).toBeUndefined();
});
it("has English and Simplified Chinese copy for every offered type", () => {
const english = redisCreateTypeHelpMessages(en);
const chinese = redisCreateTypeHelpMessages(zhCN);
for (const type of REDIS_CREATE_KEY_TYPE_VALUES) {
expect(english[type], `English: ${type}`).toEqual(expect.any(String));
expect(chinese[type], `Simplified Chinese: ${type}`).toEqual(expect.any(String));
}
});
});
@@ -0,0 +1,96 @@
import { describe, expect, it } from "vitest";
import { DATA_TYPE_OPTIONS } from "@/lib/table/tableStructureEditorState";
import { getMysqlDataTypeHelp } from "@/lib/table/mysqlDataTypeHelp";
import en from "@/i18n/locales/en";
import zhCN from "@/i18n/locales/zh-CN";
function mysqlHelpMessages(locale: unknown): Record<string, unknown> {
const messages = locale as { structureEditor?: { mysqlDataTypeHelp?: Record<string, unknown> } };
return messages.structureEditor?.mysqlDataTypeHelp ?? {};
}
describe("getMysqlDataTypeHelp", () => {
it("normalizes MySQL attributes, aliases, parameters, casing, and whitespace", () => {
expect(getMysqlDataTypeHelp(" INT(11) UNSIGNED ")).toEqual({ key: "int", warningKeys: ["integerDisplayWidth"] });
expect(getMysqlDataTypeHelp("integer zerofill")).toEqual({ key: "int", warningKeys: ["zerofill"] });
expect(getMysqlDataTypeHelp("NUMERIC(10, 2)")).toEqual({ key: "decimal" });
expect(getMysqlDataTypeHelp(" double precision ")).toEqual({ key: "double" });
expect(getMysqlDataTypeHelp("BOOL")).toEqual({ key: "boolean" });
expect(getMysqlDataTypeHelp("DEC(20, 6)")).toEqual({ key: "decimal" });
expect(getMysqlDataTypeHelp("CHARACTER VARYING(120)")).toEqual({ key: "varchar" });
expect(getMysqlDataTypeHelp("CHARACTER(12)")).toEqual({ key: "char" });
expect(getMysqlDataTypeHelp("CHAR VARYING(120)")).toEqual({ key: "varchar" });
expect(getMysqlDataTypeHelp("CHAR BYTE")).toEqual({ key: "char" });
});
it("covers phpMyAdmin's additional MySQL type aliases for dynamic type lists", () => {
expect(getMysqlDataTypeHelp("FIXED")?.key).toBe("decimal");
expect(getMysqlDataTypeHelp("FLOAT4")?.key).toBe("float");
expect(getMysqlDataTypeHelp("FLOAT8")?.key).toBe("double");
expect(getMysqlDataTypeHelp("INT1")?.key).toBe("tinyint");
expect(getMysqlDataTypeHelp("INT2")?.key).toBe("smallint");
expect(getMysqlDataTypeHelp("INT3")?.key).toBe("mediumint");
expect(getMysqlDataTypeHelp("INT4")?.key).toBe("int");
expect(getMysqlDataTypeHelp("INT8")?.key).toBe("bigint");
expect(getMysqlDataTypeHelp("MIDDLEINT")?.key).toBe("mediumint");
expect(getMysqlDataTypeHelp("LONG")?.key).toBe("mediumtext");
expect(getMysqlDataTypeHelp("LONG VARCHAR")?.key).toBe("mediumtext");
expect(getMysqlDataTypeHelp("LONG VARBINARY")?.key).toBe("mediumblob");
expect(getMysqlDataTypeHelp("GEOMCOLLECTION")?.key).toBe("geometrycollection");
expect(getMysqlDataTypeHelp("NCHAR(30)")?.key).toBe("nationalCharacter");
expect(getMysqlDataTypeHelp("NVARCHAR(30)")?.key).toBe("nationalCharacter");
expect(getMysqlDataTypeHelp("NATIONAL CHARACTER VARYING(30)")?.key).toBe("nationalCharacter");
});
it("documents numeric, text, binary, enum, temporal, JSON, and spatial types", () => {
expect(getMysqlDataTypeHelp("bigint unsigned")?.key).toBe("bigint");
expect(getMysqlDataTypeHelp("varchar")?.key).toBe("varchar");
expect(getMysqlDataTypeHelp("mediumblob")?.key).toBe("mediumblob");
expect(getMysqlDataTypeHelp("enum")?.key).toBe("enum");
expect(getMysqlDataTypeHelp("timestamp")?.key).toBe("timestamp");
expect(getMysqlDataTypeHelp("json")?.key).toBe("json");
expect(getMysqlDataTypeHelp("geometrycollection")?.key).toBe("geometrycollection");
});
it("uses product-specific JSON help when the connection profile identifies the server", () => {
expect(getMysqlDataTypeHelp("json")).toEqual({ key: "json" });
expect(getMysqlDataTypeHelp("json", { product: "mysql" })).toEqual({ key: "jsonMysql" });
expect(getMysqlDataTypeHelp("json", { product: "mariadb" })).toEqual({ key: "jsonMariaDb" });
});
it("warns about MySQL 8 numeric syntax based on the exact raw type", () => {
expect(getMysqlDataTypeHelp("INT(11) ZEROFILL")).toEqual({ key: "int", warningKeys: ["integerDisplayWidth", "zerofill"] });
expect(getMysqlDataTypeHelp("DECIMAL(10,2) UNSIGNED")).toEqual({ key: "decimal", warningKeys: ["unsignedNumeric"] });
expect(getMysqlDataTypeHelp("FLOAT(30)")).toEqual({ key: "float", warningKeys: ["floatPrecision"] });
expect(getMysqlDataTypeHelp("DOUBLE(10,2) UNSIGNED")).toEqual({ key: "double", warningKeys: ["unsignedNumeric", "floatingPointDisplay"] });
});
it("also recognizes compatible-server extensions and leaves unknown custom types alone", () => {
expect(getMysqlDataTypeHelp("inet4")?.key).toBe("inet4");
expect(getMysqlDataTypeHelp("inet6")?.key).toBe("inet6");
expect(getMysqlDataTypeHelp("uuid")?.key).toBe("uuid");
expect(getMysqlDataTypeHelp("vector(1536)")?.key).toBe("vector");
expect(getMysqlDataTypeHelp("xmltype")?.key).toBe("xmltype");
expect(getMysqlDataTypeHelp("my_private_type")).toBeUndefined();
});
it("covers every built-in MySQL type option", () => {
const undocumented = DATA_TYPE_OPTIONS.mysql.filter((type) => !getMysqlDataTypeHelp(type));
expect(undocumented).toEqual([]);
});
it("has an English and Simplified Chinese message for every supported help key", () => {
const options = [...DATA_TYPE_OPTIONS.mysql, "inet4", "inet6", "uuid", "vector", "xmltype", "character", "char varying", "char byte", "geomcollection", "nchar", "nvarchar", "national character varying", "int(11) zerofill", "decimal(10,2) unsigned", "float(30)", "double(10,2)"];
const english = mysqlHelpMessages(en);
const chinese = mysqlHelpMessages(zhCN);
for (const option of options) {
const key = getMysqlDataTypeHelp(option)?.key;
expect(key, option).toBeTruthy();
for (const helpKey of [key!, ...(getMysqlDataTypeHelp(option)?.warningKeys ?? [])]) {
expect(english[helpKey], `English: ${option}`).toEqual(expect.any(String));
expect(chinese[helpKey], `Simplified Chinese: ${option}`).toEqual(expect.any(String));
}
}
});
});
@@ -0,0 +1,64 @@
import { describe, expect, it } from "vitest";
import { DATA_TYPE_OPTIONS } from "@/lib/table/tableStructureEditorState";
import { getPostgresDataTypeHelp } from "@/lib/table/postgresDataTypeHelp";
import en from "@/i18n/locales/en";
import zhCN from "@/i18n/locales/zh-CN";
function postgresHelpMessages(locale: unknown): Record<string, unknown> {
const messages = locale as { structureEditor?: { postgresDataTypeHelp?: Record<string, unknown> } };
return messages.structureEditor?.postgresDataTypeHelp ?? {};
}
describe("getPostgresDataTypeHelp", () => {
it("covers every built-in PostgreSQL type option", () => {
expect(DATA_TYPE_OPTIONS.postgres.filter((type) => !getPostgresDataTypeHelp(type))).toEqual([]);
});
it("normalizes aliases and float precision parameters", () => {
expect(getPostgresDataTypeHelp("int2")).toEqual({ key: "smallint" });
expect(getPostgresDataTypeHelp("INT4")).toEqual({ key: "integer" });
expect(getPostgresDataTypeHelp("int8")).toEqual({ key: "bigint" });
expect(getPostgresDataTypeHelp("decimal(10, 2)")).toEqual({ key: "numeric" });
expect(getPostgresDataTypeHelp("float")).toEqual({ key: "double" });
expect(getPostgresDataTypeHelp("float(24)")).toEqual({ key: "real" });
expect(getPostgresDataTypeHelp("float(25)")).toEqual({ key: "double" });
expect(getPostgresDataTypeHelp("float(0)")).toBeUndefined();
expect(getPostgresDataTypeHelp("float(54)")).toBeUndefined();
expect(getPostgresDataTypeHelp("float(1.5)")).toBeUndefined();
expect(getPostgresDataTypeHelp("float(precision)")).toBeUndefined();
expect(getPostgresDataTypeHelp("character varying(255)")).toEqual({ key: "varchar" });
});
it("documents serial, temporal aliases, dynamic built-ins, and arrays", () => {
expect(getPostgresDataTypeHelp("bigserial")).toEqual({ key: "serial" });
expect(getPostgresDataTypeHelp("timestamp with time zone")).toEqual({ key: "timestamptz" });
expect(getPostgresDataTypeHelp("int4multirange")).toEqual({ key: "multirange" });
expect(getPostgresDataTypeHelp("jsonpath")).toEqual({ key: "jsonpath" });
expect(getPostgresDataTypeHelp("pg_lsn")).toEqual({ key: "pgLsn" });
expect(getPostgresDataTypeHelp("pg_snapshot")).toEqual({ key: "pgSnapshot" });
expect(getPostgresDataTypeHelp("uuid[][]")).toEqual({ key: "array" });
expect(getPostgresDataTypeHelp("my_schema.order_status[]")).toEqual({ key: "array" });
});
it("leaves extensions and named user types undocumented", () => {
expect(getPostgresDataTypeHelp("vector(1536)")).toBeUndefined();
expect(getPostgresDataTypeHelp("geometry(Point, 4326)")).toBeUndefined();
expect(getPostgresDataTypeHelp("citext")).toBeUndefined();
expect(getPostgresDataTypeHelp("hstore")).toBeUndefined();
expect(getPostgresDataTypeHelp("order_status")).toBeUndefined();
expect(getPostgresDataTypeHelp("order_status_multirange")).toBeUndefined();
});
it("has English and Simplified Chinese copy for every supported static key", () => {
const english = postgresHelpMessages(en);
const chinese = postgresHelpMessages(zhCN);
const dynamic = ["int4multirange", "jsonpath", "pg_lsn", "pg_snapshot", "any_type[]"];
for (const option of [...DATA_TYPE_OPTIONS.postgres, ...dynamic]) {
const key = getPostgresDataTypeHelp(option)?.key;
expect(key, option).toBeTruthy();
expect(english[key!], `English: ${option}`).toEqual(expect.any(String));
expect(chinese[key!], `Simplified Chinese: ${option}`).toEqual(expect.any(String));
}
});
});
@@ -0,0 +1,63 @@
import { describe, expect, it } from "vitest";
import { DATA_TYPE_OPTIONS } from "@/lib/table/tableStructureEditorState";
import { getSqliteDataTypeHelp } from "@/lib/table/sqliteDataTypeHelp";
import en from "@/i18n/locales/en";
import zhCN from "@/i18n/locales/zh-CN";
function sqliteHelpMessages(locale: unknown): Record<string, unknown> {
const messages = locale as { structureEditor?: { sqliteDataTypeHelp?: Record<string, unknown> } };
return messages.structureEditor?.sqliteDataTypeHelp ?? {};
}
describe("getSqliteDataTypeHelp", () => {
it("covers every built-in SQLite type option", () => {
expect(DATA_TYPE_OPTIONS.sqlite.filter((type) => !getSqliteDataTypeHelp(type))).toEqual([]);
});
it("normalizes whitespace, casing, and declared type parameters", () => {
expect(getSqliteDataTypeHelp(" INTEGER ")).toEqual({ key: "integer" });
expect(getSqliteDataTypeHelp("VARCHAR(255)")).toEqual({ key: "text" });
expect(getSqliteDataTypeHelp(" decimal(10, 2) ")).toEqual({ key: "numeric" });
});
it("applies SQLite's ordered declared-type affinity rules", () => {
expect(getSqliteDataTypeHelp("char(12)")).toEqual({ key: "text" });
expect(getSqliteDataTypeHelp("boolean")).toEqual({ key: "numeric" });
expect(getSqliteDataTypeHelp("unsigned big int")).toEqual({ key: "integer" });
expect(getSqliteDataTypeHelp("double precision")).toEqual({ key: "real" });
expect(getSqliteDataTypeHelp("date")).toEqual({ key: "numeric" });
expect(getSqliteDataTypeHelp("datetime")).toEqual({ key: "numeric" });
expect(getSqliteDataTypeHelp("time")).toEqual({ key: "numeric" });
expect(getSqliteDataTypeHelp("VARCHAR2")).toEqual({ key: "text" });
expect(getSqliteDataTypeHelp("CHARACTER")).toEqual({ key: "text" });
expect(getSqliteDataTypeHelp("INT64")).toEqual({ key: "integer" });
expect(getSqliteDataTypeHelp("FLOATING POINT")).toEqual({ key: "integer" });
expect(getSqliteDataTypeHelp("STRING")).toEqual({ key: "numeric" });
expect(getSqliteDataTypeHelp("application_status")).toEqual({ key: "numeric" });
expect(getSqliteDataTypeHelp("")).toEqual({ key: "blob" });
});
it("has English and Simplified Chinese copy for static and common help keys", () => {
const english = sqliteHelpMessages(en);
const chinese = sqliteHelpMessages(zhCN);
const types = [...DATA_TYPE_OPTIONS.sqlite, "varchar", "boolean", "datetime"];
for (const type of types) {
const key = getSqliteDataTypeHelp(type)?.key;
expect(key, type).toBeTruthy();
expect(english[key!], `English: ${type}`).toEqual(expect.any(String));
expect(chinese[key!], `Simplified Chinese: ${type}`).toEqual(expect.any(String));
}
});
it("calls out SQLite affinity and its important storage exceptions", () => {
const english = sqliteHelpMessages(en);
expect(english.integer).toContain("rowid");
expect(english.integer).toContain("does not enforce");
expect(english.real).toContain("IEEE 754");
expect(english.text).toContain("do not enforce n");
expect(english.blob).toContain("without type conversion");
expect(english.numeric).toContain("not a separate SQLite storage class");
});
});
@@ -3,6 +3,8 @@ import {
combineDataTypeForDatabase,
createColumnDrafts,
dataTypeLengthInputValue,
DATA_TYPE_OPTIONS,
defaultNewColumnDataType,
getDefaultLengthForType,
hasExistingColumnTypeChange,
isDataTypeLengthDisabled,
@@ -109,6 +111,30 @@ describe("tableStructureEditorState", () => {
expect(getDefaultLengthForType("mysql", "integer")).toBe("11");
});
it("uses MySQL 8-safe defaults only when the native MySQL profile is known", () => {
const mysql8Defaults = { omitMysqlDeprecatedDefaults: true };
expect(getDefaultLengthForType("mysql", "int", mysql8Defaults)).toBe("");
expect(getDefaultLengthForType("mysql", "bigint unsigned", mysql8Defaults)).toBe("");
expect(getDefaultLengthForType("mysql", "float", mysql8Defaults)).toBe("");
expect(getDefaultLengthForType("mysql", "double", mysql8Defaults)).toBe("");
expect(combineDataTypeForDatabase("mysql", "int", getDefaultLengthForType("mysql", "int", mysql8Defaults))).toBe("int");
expect(combineDataTypeForDatabase("mysql", "float", getDefaultLengthForType("mysql", "float", mysql8Defaults))).toBe("float");
expect(getDefaultLengthForType("mysql", "decimal", mysql8Defaults)).toBe("10,0");
// A compatibility profile cannot be version-identified, so its existing behavior is retained.
expect(getDefaultLengthForType("mysql", "int")).toBe("11");
expect(getDefaultLengthForType("mysql", "float")).toBe("10,2");
});
it("uses TEXT for a new native SQLite column without changing compatible defaults", () => {
expect(DATA_TYPE_OPTIONS.sqlite).toContain("text");
expect(defaultNewColumnDataType("sqlite")).toBe("text");
expect(defaultNewColumnDataType("rqlite")).toBe("varchar(255)");
expect(defaultNewColumnDataType("turso")).toBe("varchar(255)");
expect(defaultNewColumnDataType("mysql")).toBe("varchar(255)");
});
it("requires a SQLite rebuild only for a retained existing column type change", () => {
const [column] = createColumnDrafts(
[