25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(formatter): add custom default SQL layout engine
t8y2455117b8c511
diff --git a/apps/desktop/src/components/editor/__tests__/QueryEditor.formatCompressRequestReplay.spec.ts b/apps/desktop/src/components/editor/__tests__/QueryEditor.formatCompressRequestReplay.spec.tsindex cc90b98191..6d8e6d8122 100644--- a/apps/desktop/src/components/editor/__tests__/QueryEditor.formatCompressRequestReplay.spec.ts+++ b/apps/desktop/src/components/editor/__tests__/QueryEditor.formatCompressRequestReplay.spec.ts@@ -14,7 +14,11 @@ import { DEFAULT_SQL_FORMATTER_SETTINGS } from "@/lib/sql/sqlFormatterConfig";// QueryEditor.vue survives across the editor mounts in this file, so every test// must advance its ids monotonically (never reuse a smaller id) to mirror the// production counter.-const ORIGINAL_SQL = "select id, name\nfrom users\nwhere id = 1";+//+// The sample is long enough that formatting cannot collapse it onto one line:+// the default style joins a statement that fits onto one line, and the replay+// assertions below need a multi-line result.+const ORIGINAL_SQL = "select id, name, email, status, created_at, updated_at, tenant_id\nfrom users\nwhere status = 'active'\nand tenant_id = 42\nand deleted_at is null";const COMPRESSED_SQL = compressSqlText(ORIGINAL_SQL, "mysql");const FORMATTED_SQL = await formatSqlForEditing(COMPRESSED_SQL, "mysql", DEFAULT_SQL_FORMATTER_SETTINGS);diff --git a/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.tsindex c367d54f7c..b04edee1d6 100644--- a/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts+++ b/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts@@ -34,10 +34,10 @@ describe("sqlFormatter", () => {expect(defaultFormatted).toContain("-- tstt\nSELECT");expect(preserved).toContain("-- tstt\n\nSELECT");expect(preservedConsecutive).toContain("-- section\n\n\nSELECT");- expect(preservedQueriesNoSpacing).toBe("SELECT\n 1;\n\nSELECT\n 2;");- expect(preservedQueries).toBe("SELECT\n 1;\n\nSELECT\n 2;");- expect(preservedQueriesWideSpacing).toBe("SELECT\n 1;\n\n\nSELECT\n 2;");- expect(preservedQueriesWithTwoEmptyLines).toBe("SELECT\n 1;\n\n\nSELECT\n 2;");+ expect(preservedQueriesNoSpacing).toBe("SELECT 1;\n\nSELECT 2;");+ expect(preservedQueries).toBe("SELECT 1;\n\nSELECT 2;");+ expect(preservedQueriesWideSpacing).toBe("SELECT 1;\n\n\nSELECT 2;");+ expect(preservedQueriesWithTwoEmptyLines).toBe("SELECT 1;\n\n\nSELECT 2;");expect(preserved).not.toContain("__DBX_PRESERVE_EMPTY_LINE_");});@@ -69,7 +69,7 @@ describe("sqlFormatter", () => {});it("formats an OceanBase Oracle single-line view DDL into readable multi-line SQL (issue #7540)", async () => {- const singleLine = `CREATE OR REPLACE VIEW "APP"."ACTIVE_USERS" AS SELECT ID, NAME FROM USERS WHERE STATUS = 'ACTIVE'`;+ const singleLine = `create or replace view "APP"."ACTIVE_USERS" as select ID, NAME, EMAIL, CREATED_AT from USERS where STATUS = 'ACTIVE' and DELETED_AT is null order by CREATED_AT desc`;const formatted = await formatSqlForDisplay(singleLine, sqlFormatDialectForDbType("oceanbase-oracle"));expect(formatted).not.toBe(singleLine);@@ -83,11 +83,23 @@ describe("sqlFormatter", () => {expect(formatted).toContain('"ACTIVE_USERS"');});+ it("collapses a short OceanBase Oracle view DDL onto one line (issue #7540)", async () => {+ // The default style joins a statement that fits the line width onto one+ // line, so a short view body comes back with its keywords cased rather+ // than spread over several.+ const singleLine = `create or replace view "APP"."ACTIVE_USERS" as select ID, NAME from USERS where STATUS = 'ACTIVE'`;+ const formatted = await formatSqlForDisplay(singleLine, sqlFormatDialectForDbType("oceanbase-oracle"));++ expect(formatted).toBe(`CREATE OR REPLACE VIEW "APP"."ACTIVE_USERS" AS SELECT ID, NAME FROM USERS WHERE STATUS = 'ACTIVE'`);+ expect(formatted).toContain("'ACTIVE'");+ expect(formatted).toContain('"ACTIVE_USERS"');+ });+it("formats a bare OceanBase Oracle view source wrapped as CREATE VIEW (issue #7540)", async () => {// Mirrors the backend build_view_ddl_sql output for a fallback ALL_VIEWS.TEXT// body: `CREATE VIEW <name> AS <single-line SELECT>`.- const wrapped = `CREATE VIEW "APP"."ACTIVE_USERS" AS-SELECT ID, NAME FROM USERS WHERE STATUS = 'ACTIVE';`;+ const wrapped = `create view "APP"."ACTIVE_USERS" as+select ID, NAME, EMAIL, CREATED_AT from USERS where STATUS = 'ACTIVE' and DELETED_AT is null order by CREATED_AT desc;`;const formatted = await formatSqlForDisplay(wrapped, sqlFormatDialectForDbType("oceanbase-oracle"));expect(formatted.split("\n").length).toBeGreaterThan(2);@@ -121,27 +133,40 @@ WHERE STATUS = 'ACTIVE';`;});it("keeps issue #7138 Oracle hierarchy clauses intact", async () => {+ const sql = "SELECT ctt.u_dm, ctt.u_mc, ctt.parent_id, ctt.level_num, ctt.create_time FROM cte_test ctt WHERE ctt.status = 'A' AND ctt.deleted = 0 START WITH ctt.su_dm IN ('16','17','18') CONNECT BY PRIOR ctt.u_dm = ctt.su_dm;";++ // `START WITH` and `CONNECT BY PRIOR` are clauses of their own, not part of+ // the WHERE condition: each opens a line, and the hierarchy is never dropped.+ await expect(formatSqlForEditing(sql, sqlFormatDialectForDbType("oracle"))).resolves.toBe(`SELECT ctt.u_dm,+ ctt.u_mc,+ ctt.parent_id,+ ctt.level_num,+ ctt.create_time+FROM cte_test ctt+WHERE ctt.status = 'A'+ AND ctt.deleted = 0+START WITH ctt.su_dm IN ('16', '17', '18')+CONNECT BY PRIOR ctt.u_dm = ctt.su_dm;`);+ });++ it("collapses a short Oracle hierarchy query onto one line", async () => {const sql = "SELECT ctt.U_DM FROM cte_test ctt START WITH ctt.SU_DM IN ('16','17','18','19') CONNECT BY PRIOR ctt.U_DM = HY.SU_DM;";- await expect(formatSqlForEditing(sql, sqlFormatDialectForDbType("oracle"))).resolves.toBe(`SELECT- ctt.U_DM-FROM- cte_test ctt-START WITH ctt.SU_DM IN ('16', '17', '18', '19')-CONNECT BY PRIOR ctt.U_DM = HY.SU_DM;`);+ await expect(formatSqlForEditing(sql, sqlFormatDialectForDbType("oracle"))).resolves.toBe(`SELECT ctt.U_DM FROM cte_test ctt START WITH ctt.SU_DM IN ('16', '17', '18', '19') CONNECT BY PRIOR ctt.U_DM = HY.SU_DM;`);});it("formats valid Oracle hierarchy clauses with the same alias", async () => {- const sql = "SELECT ctt.U_DM FROM cte_test ctt START WITH ctt.SU_DM = '16' CONNECT BY PRIOR ctt.U_DM = ctt.SU_DM;";+ const sql = "select ctt.u_dm, ctt.u_mc, ctt.parent_id, ctt.level_num, ctt.create_time from cte_test ctt where ctt.status = 'A' and ctt.deleted = 0 start with ctt.su_dm = '16' connect by prior ctt.u_dm = ctt.su_dm;";const formatted = await formatSqlForEditing(sql, sqlFormatDialectForDbType("oracle"));- expect(formatted).toContain("FROM\n cte_test ctt\nSTART WITH ctt.SU_DM = '16'");- expect(formatted).toContain("\nCONNECT BY PRIOR ctt.U_DM = ctt.SU_DM;");+ expect(formatted).toContain("FROM cte_test ctt");+ expect(formatted).toContain("\nSTART WITH ctt.su_dm = '16'");+ expect(formatted).toContain("\nCONNECT BY PRIOR ctt.u_dm = ctt.su_dm;");});it("formats ordinary Oracle SQL and anonymous PL/SQL", async () => {- await expect(formatSqlForEditing("select employee_id from employees where department_id = 10;", sqlFormatDialectForDbType("oracle"))).resolves.toBe("SELECT\n employee_id\nFROM\n employees\nWHERE\n department_id = 10;");+ await expect(formatSqlForEditing("select employee_id from employees where department_id = 10;", sqlFormatDialectForDbType("oracle"))).resolves.toBe("SELECT employee_id FROM employees WHERE department_id = 10;");await expect(formatSqlForEditing("declare v_count number := 1; begin v_count := v_count + 1; end;", sqlFormatDialectForDbType("oracle"))).resolves.toBe("DECLARE v_count number := 1;\n\nBEGIN v_count := v_count + 1;\n\nEND;");});@@ -243,14 +268,15 @@ OR inside$$ as noteit("preserves the ClickHouse table alias from issue #7079", async () => {const formatted = await formatSqlText("SELECT *\nFROM MATERIAL m\nLIMIT 100;", sqlFormatDialectForDbType("clickhouse"));- expect(formatted).toBe("SELECT\n *\nFROM\n MATERIAL m\nLIMIT\n 100;");+ expect(formatted).toBe("SELECT * FROM MATERIAL m LIMIT 100;");});it.each(["d", "dd", "h", "hh", "m", "mcs", "mi", "mm", "ms", "n", "ns", "q", "qq", "s", "ss", "wk", "ww", "yy", "yyyy"])("preserves ClickHouse identifier-like date part %s while formatting keywords", async (identifier) => {const formatted = await formatSqlText(`select ${identifier}, t.${identifier} from material ${identifier} limit 100;`, sqlFormatDialectForDbType("clickhouse"));- expect(formatted).toContain(` ${identifier},`);- expect(formatted).toContain(`material ${identifier}`);+ // Alias casing is the tokenizer's business, not the keyword casing's: the+ // date part stays an identifier, so `keywordCase: "upper"` leaves it alone.+ expect(formatted).toBe(`SELECT ${identifier}, t.${identifier} FROM material ${identifier} LIMIT 100;`);expect(formatted).toContain("SELECT");expect(formatted).toContain("FROM");expect(formatted).toContain("LIMIT");@@ -262,17 +288,15 @@ OR inside$$ as noteconst lowerKeywords = await formatSqlText(sql, sqlFormatDialectForDbType("clickhouse"), { keywordCase: "lower", identifierCase: "preserve" });const lowerIdentifiers = await formatSqlText(sql, sqlFormatDialectForDbType("clickhouse"), { keywordCase: "upper", identifierCase: "lower" });- expect(lowerKeywords).toContain("from\n MATERIAL M");- expect(lowerKeywords).toContain("limit\n 100");- expect(lowerIdentifiers).toContain("FROM\n material m");- expect(lowerIdentifiers).toContain("LIMIT\n 100");+ expect(lowerKeywords).toBe("select * from MATERIAL M limit 100;");+ expect(lowerIdentifiers).toBe("SELECT * FROM material m LIMIT 100;");});it("still formats unambiguous ClickHouse interval keywords", async () => {const formatted = await formatSqlText("select now() + interval 1 minutes from source_table m;", sqlFormatDialectForDbType("clickhouse"));expect(formatted).toContain("INTERVAL 1 MINUTES");- expect(formatted).toContain("FROM\n source_table m");+ expect(formatted).toContain("FROM source_table m");});it("preserves DBX brace placeholders in generic and MySQL SQL", async () => {@@ -344,19 +368,19 @@ OR inside$$ as noteit("formats complete backtick-quoted spans with the PostgreSQL dialect", async () => {const formatted = await formatSqlText("select `schema`.`odd``name` from user;", "postgres");- expect(formatted).toBe("SELECT\n `schema`.`odd``name`\nFROM\n user;");+ expect(formatted).toBe("SELECT `schema`.`odd``name` FROM user;");});it("keeps PostgreSQL double-quoted identifiers and casts unchanged", async () => {const formatted = await formatSqlText('select "display""name" from records where payload::jsonb is not null;', "postgres");- expect(formatted).toBe('SELECT\n "display""name"\nFROM\n records\nWHERE\n payload::jsonb IS NOT NULL;');+ expect(formatted).toBe('SELECT "display""name" FROM records WHERE payload::jsonb IS NOT NULL;');});it("keeps MySQL backtick formatting unchanged", async () => {const formatted = await formatSqlText("select `schema`.`odd``name` from `user`;", "mysql");- expect(formatted).toBe("SELECT\n `schema`.`odd``name`\nFROM\n `user`;");+ expect(formatted).toBe("SELECT `schema`.`odd``name` FROM `user`;");});it("keeps malformed PostgreSQL backtick input unchanged while editing", async () => {@@ -372,7 +396,9 @@ OR inside$$ as noteconst formatted = await formatSqlForEditing(sql, sqlFormatDialectForDbType("dameng"));expect(formatted).toContain('JS1.REC_CREATOR AS "recCreator"');- expect(formatted).toContain("DECODE (");+ // Known and unknown functions alike are written without a space before the+ // parenthesis.+ expect(formatted).toContain("DECODE(");expect(formatted.endsWith("JS1.REC_CREATE_TIME DESC .")).toBe(true);});@@ -383,7 +409,7 @@ OR inside$$ as note});it("preserves whitespace after a recovered trailing dot", async () => {- await expect(formatSqlForEditing("SELECT 1 .\n", "dameng")).resolves.toBe("SELECT\n 1 .\n");+ await expect(formatSqlForEditing("SELECT 1 .\n", "dameng")).resolves.toBe("SELECT 1 .\n");});it("preserves the newline before a trailing dot after a line comment", async () => {@@ -438,7 +464,18 @@ OR inside$$ as noteit("still formats selected SQL comparison fragments", async () => {await expect(formatSqlText(`< 10`, "postgres")).resolves.toBe(`< 10`);- await expect(formatSqlText(`< 10 AND score > 2`, "postgres")).resolves.toBe(`< 10\nAND score > 2`);+ // A short fragment collapses like any other short statement.+ await expect(formatSqlText(`< 10 AND score > 2`, "postgres")).resolves.toBe(`< 10 AND score > 2`);+ // A wider one has no clause to lay out, so it falls back to sql-formatter's+ // own operand-per-line rendering of a fragment rather than the clause rules.+ await expect(formatSqlText(`< 10 AND score > 2 AND status = 'active' AND deleted_at IS NULL AND created_at > now() - interval '30 days' AND owner_id = 42`, "postgres")).resolves.toBe(+ `< 10+AND score > 2+AND status = 'active'+AND deleted_at IS NULL+AND created_at > now() - interval '30 days'+AND owner_id = 42`,+ );});it("keeps logical conditions on one line when configured", async () => {@@ -492,16 +529,22 @@ OR inside$$ as notetabWidth: 4,});- expect(formatted).toContain("FROM\ttVillage AS tv");- expect(formatted).toContain("ON tv.villageId = tl.villageId AND 1 = 1");+ // The join keeps `FROM` and its source together (the setting's whole point),+ // indents by one tab width, and the `ON` condition stays on the join's line.+ expect(formatted).toBe("SELECT *\nFROM tVillage AS tv\n\tINNER JOIN tLand AS tl ON tv.villageId = tl.villageId AND 1 = 1");});it("keeps derived tables multiline with FROM same-line layout", async () => {- const formatted = await formatSqlText("SELECT * FROM (SELECT * FROM tVillage) AS tv", "sqlserver", { fromClauseLayout: "sameLine" });+ const sql = "SELECT * FROM (SELECT villageId, villageName, townshipId, createdAt, updatedAt, deletedAt FROM tVillage WHERE deletedAt IS NULL AND villageName LIKE '%x%') AS tv";++ const formatted = await formatSqlText(sql, "sqlserver", { fromClauseLayout: "sameLine" });- expect(formatted).toContain("FROM\n");- expect(formatted).toContain("\n SELECT");- expect(formatted).toContain("FROM tVillage");+ // The derived table still expands — `FROM (` stays on the line it opens and+ // the subquery's clauses align under that parenthesis, so the same-line+ // setting only decides whether the group starts on the keyword's line.+ expect(formatted).toContain("FROM (SELECT villageId,");+ expect(formatted).toContain("\n FROM tVillage");+ expect(formatted.endsWith(") AS tv")).toBe(true);});it("keeps display formatting lossless for XML/JSON-looking input", async () => {diff --git a/apps/desktop/src/lib/__tests__/sql/sqlLayout.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlLayout.spec.tsnew file mode 100644index 0000000000..1a24fd74c2--- /dev/null+++ b/apps/desktop/src/lib/__tests__/sql/sqlLayout.spec.ts@@ -0,0 +1,235 @@+import { describe, expect, it } from "vitest";+import { formatSqlText } from "@/lib/sql/sqlFormatter";+import { DEFAULT_SQL_FORMATTER_SETTINGS, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";++/**+ * Golden tests for the layout engine behind DBX's default formatting style.+ * The expectations for the queries in issues #827, #4850 and #5170 pin the+ * real-world shapes those reports asked for; the rest pin the rules those+ * examples exercise — the collapse of short statements, the wrap of long ones,+ * element alignment, and column alignment in `CREATE TABLE`.+ */++type Dialect = Parameters<typeof formatSqlText>[1];++async function format(sql: string, overrides: Partial<SqlFormatterSettings> = {}, dialect: Dialect = "mysql") {+ return formatSqlText(sql, dialect, { ...DEFAULT_SQL_FORMATTER_SETTINGS, ...overrides });+}++const lines = (...rows: string[]) => rows.join("\n");++describe("sql layout", () => {+ it("formats a query with a derived table (#827)", async () => {+ const sql = lines(+ "SELECT loc_id, loc_name, loc_type, delivery_emp_num, update_time",+ "FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY loc_id ORDER BY update_time DESC) AS rn",+ " FROM responsible_area_info",+ " WHERE DATE_FORMAT(update_time, '%Y-%m') = DATE_FORMAT(NOW(), '%Y-%m')) t",+ "WHERE rn = 1;",+ );++ // The subquery's clauses align under the `(` that opens it, and the closing+ // `)` stays on the last clause's line.+ //+ // The subquery's two select elements could be split; the screenshots in+ // #827 and #4850 disagree on that point (both are two-element lists, one+ // split, one not), so the keeping rule here is the one #4850's rendering+ // matches.+ expect(await format(sql)).toBe(+ lines(+ "SELECT loc_id,",+ " loc_name,",+ " loc_type,",+ " delivery_emp_num,",+ " update_time",+ "FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY loc_id ORDER BY update_time DESC) AS rn",+ " FROM responsible_area_info",+ " WHERE DATE_FORMAT(update_time, '%Y-%m') = DATE_FORMAT(NOW(), '%Y-%m')) t",+ "WHERE rn = 1;",+ ),+ );+ });++ it("keeps a long statement's clauses apart (#4850)", async () => {+ const sql = lines(+ "SELECT HIMMS_XDSBDJ.HIMMS_XDSBDJ_ID, HIMMS_XDSBDJ.YNKE, himms_zwxsysj_sysj(V_HIMMS_XDSBDJ.HIMMS_XDSBDJ_ID) AS SJSYSJ",+ "FROM HIMMS_XDSBDJ",+ "LEFT JOIN (SELECT himms_xdsbdj_id, MAX(SJ) SJ FROM himms_zwxqdjc GROUP BY himms_xdsbdj_id) SUB_QDJC ON HIMMS_XDSBDJ.HIMMS_XDSBDJ_ID = SUB_QDJC.himms_xdsbdj_id",+ "WHERE HIMMS_XDSBDJ.tybz IS NULL;",+ );++ // The user-defined function is written without a space, and the join's+ // subquery expands rather than pushing `ON` onto a line of its own.+ expect(await format(sql)).toBe(+ lines(+ "SELECT HIMMS_XDSBDJ.HIMMS_XDSBDJ_ID, HIMMS_XDSBDJ.YNKE, himms_zwxsysj_sysj(V_HIMMS_XDSBDJ.HIMMS_XDSBDJ_ID) AS SJSYSJ",+ "FROM HIMMS_XDSBDJ",+ " LEFT JOIN (SELECT himms_xdsbdj_id, MAX(SJ) SJ",+ " FROM himms_zwxqdjc",+ " GROUP BY himms_xdsbdj_id) SUB_QDJC ON HIMMS_XDSBDJ.HIMMS_XDSBDJ_ID = SUB_QDJC.himms_xdsbdj_id",+ "WHERE HIMMS_XDSBDJ.tybz IS NULL;",+ ),+ );+ });++ it("collapses a statement that fits on one line (#5170)", async () => {+ const sql = lines("SELECT", " *", "FROM", " task", "ORDER BY", " created_at DESC;");++ expect(await format(sql)).toBe("SELECT * FROM task ORDER BY created_at DESC;");+ });++ it("aligns CREATE TABLE columns", async () => {+ const sql = lines(+ "CREATE TABLE IF NOT EXISTS `delivery_emp_info`",+ "(",+ " `id` varchar(20) PRIMARY KEY NOT NULL COMMENT '主键',",+ " `emp_id` varchar(20) NOT NULL COMMENT '员工id',",+ " `delivery_type_ids` varchar(512) DEFAULT NULL COMMENT '负责的运送类型id集合',",+ " `update_time` datetime NOT NULL COMMENT '更新时间',",+ " CONSTRAINT idx_emp_phone UNIQUE (emp_id, emp_phone_num) COMMENT '运送员id电话唯一'",+ ") ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_bin COMMENT '运达员信息表';",+ );++ // Name, type and modifiers each get their own column, so the definitions'+ // `COMMENT`s line up; the constraint's `(` keeps its space.+ expect(await format(sql)).toBe(+ lines(+ "CREATE TABLE IF NOT EXISTS `delivery_emp_info`",+ "(",+ " `id` varchar(20) PRIMARY KEY NOT NULL COMMENT '主键',",+ " `emp_id` varchar(20) NOT NULL COMMENT '员工id',",+ " `delivery_type_ids` varchar(512) DEFAULT NULL COMMENT '负责的运送类型id集合',",+ " `update_time` datetime NOT NULL COMMENT '更新时间',",+ " CONSTRAINT idx_emp_phone UNIQUE (emp_id, emp_phone_num) COMMENT '运送员id电话唯一'",+ ") ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_bin COMMENT '运达员信息表';",+ ),+ );+ });++ it("keeps a call shaped like a call at any nesting depth", async () => {+ const sql = "INSERT INTO t (a, b) VALUES (f(x), g(y)) ON DUPLICATE KEY UPDATE b = f(g(b));";++ // The insert target's column list is spaced; the calls inside the values,+ // and inside another call's arguments, are not.+ expect(await format(sql)).toBe("INSERT INTO t (a, b) VALUES (f(x), g(y)) ON DUPLICATE KEY UPDATE b = f(g(b));");+ });++ it("breaks a long condition before each logical operator", async () => {+ const sql = "SELECT a, b FROM t WHERE alpha = 1 AND beta = 2 AND gamma = 3 AND delta = 4 AND epsilon = 5 AND zeta = 6 AND eta = 7 AND theta = 8;";++ // The statement is too long to collapse, and the default+ // `logicalOperatorNewline: "before"` starts each continuation line with the+ // operator, aligned under the condition's first operand like any other+ // clause item.+ expect(await format(sql)).toBe(lines("SELECT a, b", "FROM t", "WHERE alpha = 1", " AND beta = 2", " AND gamma = 3", " AND delta = 4", " AND epsilon = 5", " AND zeta = 6", " AND eta = 7", " AND theta = 8;"));+ });++ it("puts a wrapped condition's operators where the setting asks", async () => {+ const sql = "SELECT a, b FROM t WHERE alpha = 1 AND beta = 2 AND gamma = 3 AND delta = 4 AND epsilon = 5 AND zeta = 6 AND eta = 7 AND theta = 8;";++ // `after` ends the previous line with the operator instead.+ expect(await format(sql, { logicalOperatorNewline: "after" })).toContain("WHERE alpha = 1 AND\n beta = 2 AND");+ // `none` keeps the condition on the clause's line, however long it gets.+ expect(await format(sql, { logicalOperatorNewline: "none" })).toBe(lines("SELECT a, b", "FROM t", "WHERE alpha = 1 AND beta = 2 AND gamma = 3 AND delta = 4 AND epsilon = 5 AND zeta = 6 AND eta = 7 AND theta = 8;"));+ });++ it("expands a parenthesized list that does not fit, aligned under its first item", async () => {+ const sql = `SELECT * FROM t WHERE id IN (${Array.from({ length: 16 }, (_, index) => 100000 + index).join(", ")});`;++ expect(await format(sql)).toBe(+ lines(+ "SELECT *",+ "FROM t",+ "WHERE id IN (100000,",+ " 100001,",+ " 100002,",+ " 100003,",+ " 100004,",+ " 100005,",+ " 100006,",+ " 100007,",+ " 100008,",+ " 100009,",+ " 100010,",+ " 100011,",+ " 100012,",+ " 100013,",+ " 100014,",+ " 100015);",+ ),+ );+ });++ it("keeps a small subquery inline", async () => {+ expect(await format("SELECT * FROM t WHERE id IN (SELECT id FROM u WHERE a = 1 AND b = 2);")).toBe("SELECT * FROM t WHERE id IN (SELECT id FROM u WHERE a = 1 AND b = 2);");+ });++ it("collapses each clause independently", async () => {+ const sql = "SELECT (SELECT count(*) FROM orders o WHERE o.customer_id = c.id AND o.status = 'paid') AS order_count, c.name FROM customers c;";++ // The scalar subquery fits, the select list does not: only the second one+ // breaks.+ expect(await format(sql)).toBe(lines("SELECT (SELECT count(*) FROM orders o WHERE o.customer_id = c.id AND o.status = 'paid') AS order_count, c.name", "FROM customers c;"));+ });++ it("never joins a CASE onto one line", async () => {+ expect(await format("SELECT CASE WHEN a = 1 THEN 'one' WHEN a = 2 THEN 'two' ELSE 'other' END AS label FROM t;")).toBe(lines("SELECT CASE", " WHEN a = 1 THEN 'one'", " WHEN a = 2 THEN 'two'", " ELSE 'other'", " END AS label", "FROM t;"));+ });++ it("gives a set operation its own line", async () => {+ expect(await format("SELECT a FROM t UNION ALL SELECT b FROM u;")).toBe(lines("SELECT a", "FROM t", "UNION ALL", "SELECT b", "FROM u;"));+ });++ it("keeps comments and does not fold them onto a line", async () => {+ const sql = lines("-- heading", "SELECT a, -- why", " b", "FROM t; /* trailing */");++ expect(await format(sql)).toBe(lines("-- heading", "SELECT a,", " -- why", " b", "FROM t;", "", "/* trailing */"));+ });++ it("keeps PostgreSQL casts tight", async () => {+ expect(await format("select coalesce(a, b)::text, (x + y)::int from t;", {}, "postgres")).toBe("SELECT coalesce(a, b)::text, (x + y)::int FROM t;");+ });++ it("keeps the comma of a MySQL LIMIT offset", async () => {+ expect(await format("SELECT a FROM t LIMIT 5, 10;", {}, "mysql")).toBe("SELECT a FROM t LIMIT 5, 10;");+ });++ it("indents with tabs when asked", async () => {+ const sql = "SELECT alpha_column, beta_column, gamma_column, delta_column FROM some_really_long_table_name WHERE first_condition = 1 AND second_condition = 2 AND third_condition = 3;";++ // Only the leading indentation becomes a tab; the alignment padding stays+ // spaces so a continuation column lands where it was measured.+ expect(await format(sql, { useTabs: true, tabWidth: 4 })).toBe(["SELECT alpha_column,", "\t beta_column,", "\t gamma_column,", "\t delta_column", "FROM some_really_long_table_name", "WHERE first_condition = 1", "\t AND second_condition = 2", "\t AND third_condition = 3;"].join("\n"));+ });++ it("moves a FROM source to its own line when configured", async () => {+ const sql = "SELECT alpha_column, beta_column, gamma_column, delta_column FROM some_really_long_table_name WHERE first_condition = 1 AND second_condition = 2 AND third_condition = 3;";++ expect(await format(sql, { fromClauseLayout: "newLine" })).toBe(+ lines("SELECT alpha_column,", " beta_column,", " gamma_column,", " delta_column", "FROM", " some_really_long_table_name", "WHERE first_condition = 1", " AND second_condition = 2", " AND third_condition = 3;"),+ );+ });++ it("honours the blank lines between queries", async () => {+ const sql = "SELECT 1;\nSELECT 2;";++ expect(await format(sql, { linesBetweenQueries: 0 })).toBe(lines("SELECT 1;", "SELECT 2;"));+ expect(await format(sql, { linesBetweenQueries: 1 })).toBe(lines("SELECT 1;", "", "SELECT 2;"));+ expect(await format(sql, { linesBetweenQueries: 2 })).toBe(lines("SELECT 1;", "", "", "SELECT 2;"));+ });++ it("keeps a blank source line when the setting is on", async () => {+ expect(await format(lines("-- heading", "", "SELECT a FROM t;"), { preserveEmptyLines: true })).toBe(lines("-- heading", "", "SELECT a", "FROM t;"));+ });++ it("falls back to sql-formatter for the tabular indent styles", async () => {+ // The tabular layouts pad every clause to a fixed column; the default+ // layout rules do not reproduce them, so those settings keep the upstream+ // formatter.+ expect(await format("SELECT a, b FROM t WHERE x = 1;", { indentStyle: "tabularLeft" })).toBe(lines("SELECT a,", " b", "FROM t", "WHERE x = 1;"));+ });++ it("formats a dialect without its own grammar", async () => {+ expect(await format("select * from t where a = 1 and b = 2;", {}, "generic")).toBe("SELECT * FROM t WHERE a = 1 AND b = 2;");+ });+});diff --git a/apps/desktop/src/lib/sql/layout/ddl.ts b/apps/desktop/src/lib/sql/layout/ddl.tsnew file mode 100644index 0000000000..3d6848f93d--- /dev/null+++ b/apps/desktop/src/lib/sql/layout/ddl.ts@@ -0,0 +1,160 @@+import type { AstNode, ClauseNode, ParenthesisNode, StatementNode } from "sql-formatter/dist/esm/parser/ast.js";+import { CREATE_TABLE_KEYWORD, keywordText, renderInline, splitByComma, Writer, type SqlLayoutContext } from "./primitives";++/**+ * Column alignment for `CREATE TABLE`.+ *+ * The definition list is laid out on a character grid so the three parts of+ * every column — name, type, nullability/default — line up, which is what makes+ * a wide table readable:+ *+ * `id` varchar(20) PRIMARY KEY NOT NULL COMMENT '主键',+ * `delivery_type_ids` varchar(512) DEFAULT NULL COMMENT '…',+ * `update_time` datetime NOT NULL COMMENT '…'+ *+ * The definition list goes one column per line under its own `(`, and the table+ * options move below the closing `)`.+ *+ * This is applied only to statements that match the shape exactly (see+ * `isCreateTable`). Anything else — a `CREATE TABLE ... AS SELECT`, a dialect+ * keyword sql-formatter parses differently — keeps the ordinary query layout+ * rather than being aligned on a guess.+ */++/** The pieces of one column definition, already rendered. */+interface ColumnDefinition {+ name: string;+ type: string;+ modifiers: string;+ /** Everything from `COMMENT` onwards. */+ tail: string;+}++type Definition = { kind: "column"; column: ColumnDefinition } | { kind: "other"; nodes: AstNode[] };++function isDataType(node: AstNode | undefined): boolean {+ return node?.type === "data_type" || node?.type === "parameterized_data_type";+}++function isCommentNode(node: AstNode | undefined): boolean {+ return node?.type === "identifier" && node.text.toUpperCase() === "COMMENT";+}++/**+ * Splits one comma-separated definition into its aligned parts, or `null` when+ * the item is not a plain `name type [modifiers] [COMMENT …]` column.+ */+function splitColumn(ctx: SqlLayoutContext, item: AstNode[]): ColumnDefinition | null {+ const [nameNode, typeNode] = item;+ if (nameNode?.type !== "identifier" || !isDataType(typeNode)) return null;++ const commentAt = item.findIndex((node, index) => index >= 2 && isCommentNode(node));+ const modifierNodes = item.slice(2, commentAt === -1 ? item.length : commentAt);+ const tailNodes = commentAt === -1 ? [] : item.slice(commentAt);++ const name = renderInline(ctx, [nameNode], ctx.options.lineWidth);+ const type = renderInline(ctx, [typeNode], ctx.options.lineWidth);+ const modifiers = renderInline(ctx, modifierNodes, ctx.options.lineWidth);+ const tail = renderInline(ctx, tailNodes, ctx.options.lineWidth);++ if (!name || !type || (modifierNodes.length > 0 && !modifiers) || (tailNodes.length > 0 && !tail)) return null;+ return { name, type, modifiers: modifiers ?? "", tail: tail ?? "" };+}++/**+ * Whether `statement` is a `CREATE TABLE` whose body is a list of column+ * definitions this module can align. Everything else keeps the query layout.+ */+export function isCreateTable(statement: StatementNode): boolean {+ return createTableParts(statement) !== null;+}++function createTableParts(statement: StatementNode): { clause: ClauseNode; name: AstNode; paren: ParenthesisNode; rest: AstNode[] } | null {+ if (statement.children.length !== 1) return null;+ const clause = statement.children[0];+ if (clause.type !== "clause") return null;+ if (!CREATE_TABLE_KEYWORD.test(clause.nameKw.text.trim())) return null;++ const [name, paren] = clause.children;+ if (name?.type !== "identifier" || paren?.type !== "parenthesis") return null;+ // A `CREATE TABLE ... AS SELECT` has no column list to align.+ if (paren.children.length === 0) return null;+ return { clause, name, paren, rest: clause.children.slice(2) };+}++/** Emits a `CREATE TABLE`, aligning the definition list. */+export function createTableLayout(statement: StatementNode, ctx: SqlLayoutContext): string {+ const parts = createTableParts(statement);+ if (!parts) throw new Error("createTableLayout called on a statement that is not a CREATE TABLE");+ const { clause, name, paren, rest } = parts;++ const writer = new Writer(ctx.options);+ const indent = ctx.options.indentWidth;+ const nameText = renderInline(ctx, [name], ctx.options.lineWidth - clause.nameKw.text.length - 1);+ if (!nameText) throw new Error("a CREATE TABLE table name must fit on one line");++ writer.write(`${keywordText(clause.nameKw.text, ctx)} ${nameText}`);+ writer.newline(0);+ writer.write("(");++ const definitions: Definition[] = splitByComma(paren.children).map((item) => {+ const column = splitColumn(ctx, item);+ return column ? { kind: "column", column } : { kind: "other", nodes: item };+ });++ // Column widths are shared by every line, so measure before emitting.+ const columns = definitions.flatMap((definition) => (definition.kind === "column" ? [definition.column] : []));+ const nameWidth = Math.max(0, ...columns.map((column) => column.name.length));+ const typeWidth = Math.max(0, ...columns.map((column) => column.type.length));+ const modifierWidth = Math.max(0, ...columns.map((column) => column.modifiers.length));++ definitions.forEach((definition, index) => {+ writer.newline(indent);+ if (definition.kind === "column") {+ const { name: columnName, type, modifiers, tail } = definition.column;+ writer.write(columnName.padEnd(nameWidth));+ if (type) writer.write(` ${type.padEnd(typeWidth)}`);+ if (modifiers) writer.write(` ${modifiers.padStart(modifierWidth)}`);+ if (tail) writer.write(` ${tail}`);+ } else {+ emitDefinition(writer, definition.nodes, indent, ctx);+ }+ if (index < definitions.length - 1) writer.write(",");+ });++ writer.newline(0);+ writer.write(")");+ if (rest.length > 0) {+ const options = renderInline(ctx, rest, ctx.options.lineWidth - 1);+ if (options) {+ writer.write(` ${options}`);+ } else {+ writer.newline(indent);+ writer.write(ctx.renderers.block(rest).trim());+ }+ }+ if (statement.hasSemicolon) writer.write(";");+ return writer.toString();+}++/**+ * Emits a definition that is not a plain column — a table constraint. The+ * constraint name gets its own line and its body is indented one step.+ */+function emitDefinition(writer: Writer, nodes: AstNode[], indent: number, ctx: SqlLayoutContext): void {+ const flat = renderInline(ctx, nodes, ctx.options.lineWidth - indent);+ if (flat) {+ writer.write(flat);+ return;+ }++ const [first, second] = nodes;+ if (first?.type === "keyword" && second?.type === "identifier") {+ writer.write(`${keywordText(first.text, ctx)} ${renderInline(ctx, [second], ctx.options.lineWidth) ?? second.text}`);+ writer.newline(indent + ctx.options.indentWidth);+ writer.write(ctx.renderers.block(nodes.slice(2)).trim());+ return;+ }++ writer.write(ctx.renderers.block(nodes).trim());+}diff --git a/apps/desktop/src/lib/sql/layout/index.ts b/apps/desktop/src/lib/sql/layout/index.tsnew file mode 100644index 0000000000..41104b9b43--- /dev/null+++ b/apps/desktop/src/lib/sql/layout/index.ts@@ -0,0 +1,83 @@+import type { DialectOptions } from "sql-formatter/dist/esm/dialect.js";+import { createRenderers, loadEngine, type SqlFormatterEngine, type SqlFormatterParamValues } from "./internals";+import { printSqlLayout, type SqlLayoutOptions } from "./printer";++export type { SqlLayoutOptions } from "./printer";++/**+ * Default layout knobs: a 120-column hard wrap, element lists of up to three+ * kept on one line, a two-space indent, and joins indented one step below their+ * FROM clause.+ */+export const DEFAULT_SQL_LAYOUT_OPTIONS: SqlLayoutOptions = {+ lineWidth: 120,+ keepElementsOnOneLine: 3,+ indentWidth: 2,+ joinIndentWidth: 4,+ keywordCase: "preserve",+ logicalOperatorNewline: "before",+ linesBetweenQueries: 1,+ useTabs: false,+ fromClauseSourceOnSameLine: true,+};++export interface SqlLayoutRequest {+ sql: string;+ /** sql-formatter dialect key, e.g. `mysql` / `postgresql` / `plsql`. */+ language: string;+ /**+ * The dialect options to parse with, when the caller has already resolved+ * them. Parsing with anything but the caller's own dialect would make this+ * layout disagree with the statements the public formatter produces for the+ * same input — DBX's ClickHouse tweak, which keeps date-part abbreviations+ * out of the reserved list, is exactly such a case.+ */+ dialectOptions?: DialectOptions;+ /** sql-formatter `FormatOptions` (casing flags, tab width, param types, ...). */+ cfg: Record<string, unknown>;+ options?: Partial<SqlLayoutOptions>;+}++function dialectFor(engine: SqlFormatterEngine, request: SqlLayoutRequest) {+ const dialectOptions = request.dialectOptions ?? engine.dialects[request.language] ?? engine.dialects.sql;+ return engine.createDialect(dialectOptions);+}++/**+ * Formats `sql` with the default style's layout rules.+ *+ * Returns `null` when sql-formatter's internals are unavailable or the input+ * cannot be parsed, so callers can fall back to the public `format()` API+ * instead of surfacing a failure to the user.+ */+export async function formatSqlLayout(request: SqlLayoutRequest): Promise<string | null> {+ const engine = await loadEngine();+ if (!engine) return null;++ const dialect = dialectFor(engine, request);+ const options: SqlLayoutOptions = {+ ...DEFAULT_SQL_LAYOUT_OPTIONS,+ keywordCase: (request.cfg.keywordCase as SqlLayoutOptions["keywordCase"]) ?? "preserve",+ ...request.options,+ };+ // `indentStyle` selects sql-formatter's tabular layouts, which pad every clause+ // to a fixed column, and `useTabs` makes it indent with tabs. The rules here+ // replace that layout and write their own indentation, so both are pinned: the+ // renderers must emit space-indented text relative to column 0, which the+ // printer then re-bases onto the column it measured.+ // The annotation keeps the index signature spread objects would otherwise lose,+ // so `paramTypes`/`params` stay readable below.+ const cfg: Record<string, unknown> = { ...request.cfg, indentStyle: "standard", useTabs: false };++ try {+ const statements = engine.parse(request.sql, dialect, (cfg.paramTypes as Record<string, unknown>) ?? {});+ return printSqlLayout(statements, {+ renderers: createRenderers(engine, dialect, cfg, new engine.Params(cfg.params as SqlFormatterParamValues), options.indentWidth),+ options,+ });+ } catch {+ // Parse failures are the formatter's normal "not supported yet" signal; the+ // caller degrades to sql-formatter's own output or to the original text.+ return null;+ }+}diff --git a/apps/desktop/src/lib/sql/layout/internals.ts b/apps/desktop/src/lib/sql/layout/internals.tsnew file mode 100644index 0000000000..f872a1cb22--- /dev/null+++ b/apps/desktop/src/lib/sql/layout/internals.ts@@ -0,0 +1,198 @@+import type { Dialect, DialectOptions } from "sql-formatter/dist/esm/dialect.js";+import type ExpressionFormatter from "sql-formatter/dist/esm/formatter/ExpressionFormatter.js";+import type Indentation from "sql-formatter/dist/esm/formatter/Indentation.js";+import type InlineLayout from "sql-formatter/dist/esm/formatter/InlineLayout.js";+import type Layout from "sql-formatter/dist/esm/formatter/Layout.js";+import type Params from "sql-formatter/dist/esm/formatter/Params.js";+import type { AstNode, StatementNode } from "sql-formatter/dist/esm/parser/ast.js";++/**+ * Access to sql-formatter's bundled parser and layout machinery.+ *+ * sql-formatter's public surface is `format()` / `formatDialect()`, and its+ * output layout is not configurable enough for the default style DBX targets:+ * clause keywords must sit flush left, a clause's continuation lines align under+ * its first item, and parenthesized groups stay inline while they fit. All of+ * that needs the AST plus the "measure, don't wrap" layout the package only+ * ships internally, so these imports go through the `sql-formatter/dist/` alias+ * set up in vite.config.ts and vitest.config.ts.+ *+ * This module is the single place that reaches into the package internals. If a+ * dependency bump ever breaks one of these shapes, `loadEngine()` reports that+ * and every caller falls back to the public `format()` API rather than throwing.+ */++type InlineLayoutCtor = typeof InlineLayout;+type InlineLayoutErrorCtor = typeof import("sql-formatter/dist/esm/formatter/InlineLayout.js").InlineLayoutError;+type ExpressionFormatterCtor = typeof ExpressionFormatter;+type ParamsCtor = typeof Params;+type LayoutCtor = typeof Layout;+type IndentationCtor = typeof Indentation;++/**+ * The values `Params` resolves placeholders against, as sql-formatter types them:+ * `cfg.params`, which DBX never sets — the config importer rejects that legacy+ * key — so placeholders keep their literal text in the output.+ */+export type SqlFormatterParamValues = ConstructorParameters<ParamsCtor>[0];++/** The subset of sql-formatter's internals the layout printer needs. */+export interface SqlFormatterEngine {+ /** Every bundled dialect, keyed by the name `format()` accepts. */+ readonly dialects: Record<string, DialectOptions>;+ readonly createDialect: (options: DialectOptions) => Dialect;+ readonly parse: (sql: string, dialect: Dialect, paramTypes: Record<string, unknown>) => StatementNode[];+ readonly ExpressionFormatter: ExpressionFormatterCtor;+ readonly InlineLayout: InlineLayoutCtor;+ readonly InlineLayoutError: InlineLayoutErrorCtor;+ readonly Params: ParamsCtor;+ readonly Layout: LayoutCtor;+ readonly Indentation: IndentationCtor;+}++let enginePromise: Promise<SqlFormatterEngine | null> | null = null;++async function importEngine(): Promise<SqlFormatterEngine | null> {+ try {+ // Literal specifiers only: Vite cannot statically analyse a computed path,+ // and these must resolve through the `sql-formatter/dist/` alias.+ const [parserMod, dialectMod, allDialects, expressionMod, inlineLayoutMod, paramsMod, layoutMod, indentationMod] = await Promise.all([+ import("sql-formatter/dist/esm/parser/createParser.js"),+ import("sql-formatter/dist/esm/dialect.js"),+ import("sql-formatter/dist/esm/allDialects.js"),+ import("sql-formatter/dist/esm/formatter/ExpressionFormatter.js"),+ import("sql-formatter/dist/esm/formatter/InlineLayout.js"),+ import("sql-formatter/dist/esm/formatter/Params.js"),+ import("sql-formatter/dist/esm/formatter/Layout.js"),+ import("sql-formatter/dist/esm/formatter/Indentation.js"),+ ]);++ const createParser = parserMod.createParser;+ const createDialect = dialectMod.createDialect;+ const ExpressionFormatter = expressionMod.default;+ const InlineLayout = inlineLayoutMod.default;+ const InlineLayoutError = inlineLayoutMod.InlineLayoutError;+ const Params = paramsMod.default;+ const Layout = layoutMod.default;+ const Indentation = indentationMod.default;++ if (+ typeof createParser !== "function" ||+ typeof createDialect !== "function" ||+ typeof ExpressionFormatter !== "function" ||+ typeof InlineLayout !== "function" ||+ typeof InlineLayoutError !== "function" ||+ typeof Params !== "function" ||+ typeof Layout !== "function" ||+ typeof Indentation !== "function" ||+ !allDialects ||+ typeof allDialects !== "object"+ ) {+ return null;+ }++ return {+ dialects: allDialects as unknown as Record<string, DialectOptions>,+ createDialect,+ parse: (sql, dialect, paramTypes) => createParser(dialect.tokenizer).parse(sql, paramTypes),+ ExpressionFormatter,+ InlineLayout,+ InlineLayoutError,+ Params,+ Layout,+ Indentation,+ };+ } catch {+ // Older/newer sql-formatter layouts move these files around. Report "no+ // engine" so the caller uses the public formatter instead of failing the+ // user's format action outright.+ return null;+ }+}++/** Loads (and caches) the engine, or `null` when the internals are unavailable. */+export function loadEngine(): Promise<SqlFormatterEngine | null> {+ enginePromise ??= importEngine();+ return enginePromise;+}++/**+ * The two rendering primitives the layout printer builds on.+ *+ * Both render *relative to column 0*; positioning is the printer's job, which is+ * what lets it align clause items under a column that depends on the enclosing+ * `(` rather than on a fixed indent level.+ */+export interface SqlLayoutRenderers {+ /** Renders `nodes` on a single line, or `null` when they do not fit `width`. */+ inline(nodes: AstNode[], width: number): string | null;+ /** Renders `nodes` on one or more lines, indented relative to column 0. */+ block(nodes: AstNode[]): string;+ /**+ * Whether the dialect writes `text` without a space in front of it.+ *+ * The printer renders a parenthesis group and its surroundings in separate+ * steps, so it decides the separating space itself and has to agree with the+ * renderer: sql-formatter drops the space for a "dense" operator such as+ * PostgreSQL's `::`, and `cfg.denseOperators` makes every operator dense.+ */+ denseOperator(text: string): boolean;+}++/**+ * Measures `nodes` with sql-formatter's `InlineLayout`, returning `null` instead+ * of throwing when the group cannot be a single line.+ *+ * `InlineLayout` raises for both reasons we care about — a construct that+ * genuinely requires a line break (a clause, a `--` comment) and text that would+ * overflow `width` — so one call answers "would this fit on the line?" exactly,+ * which is what the collapse rule is decided on.+ */+export function renderInline(engine: SqlFormatterEngine, nodes: AstNode[], dialect: Dialect, cfg: Record<string, unknown>, params: InstanceType<ParamsCtor>, width: number): string | null {+ if (nodes.length === 0 || width <= 0) return null;++ // `formatParenthesis` measures nested groups against `cfg.expressionWidth`, so+ // point it at the width available here. Rendering is synchronous, and the+ // previous value is restored below.+ const previousWidth = cfg.expressionWidth;+ cfg.expressionWidth = width;+ try {+ const formatter = new engine.ExpressionFormatter({+ cfg: cfg as never,+ dialectCfg: dialect.formatOptions,+ params: params as never,+ layout: new engine.InlineLayout(width) as never,+ inline: true,+ });+ // No whitespace collapsing here: an inline layout never emits a newline (it+ // raises first) and squashing runs of spaces would corrupt string literals.+ const text = formatter.format(nodes).toString().trim();+ return text || null;+ } catch (error) {+ if (error instanceof engine.InlineLayoutError) return null;+ throw error;+ } finally {+ cfg.expressionWidth = previousWidth;+ }+}++/** Creates the inline/block renderer pair for one dialect and configuration. */+export function createRenderers(engine: SqlFormatterEngine, dialect: Dialect, cfg: Record<string, unknown>, params: InstanceType<ParamsCtor>, indentWidth: number): SqlLayoutRenderers {+ const indent = " ".repeat(Math.max(1, indentWidth));+ const alwaysDenseOperators = dialect.formatOptions.alwaysDenseOperators ?? [];+ return {+ inline: (nodes, width) => renderInline(engine, nodes, dialect, cfg, params, width),+ block: (nodes) => {+ const layout = new engine.Layout(new engine.Indentation(indent));+ const formatter = new engine.ExpressionFormatter({+ cfg: cfg as never,+ dialectCfg: dialect.formatOptions,+ params: params as never,+ layout: layout as never,+ inline: false,+ });+ return formatter.format(nodes).toString();+ },+ denseOperator: (text) => cfg.denseOperators === true || alwaysDenseOperators.includes(text),+ };+}diff --git a/apps/desktop/src/lib/sql/layout/primitives.ts b/apps/desktop/src/lib/sql/layout/primitives.tsnew file mode 100644index 0000000000..eda899feca--- /dev/null+++ b/apps/desktop/src/lib/sql/layout/primitives.ts@@ -0,0 +1,440 @@+import type { AstNode, ClauseNode, KeywordNode, LimitClauseNode, ParenthesisNode, SetOperationNode } from "sql-formatter/dist/esm/parser/ast.js";+import type { SqlLayoutRenderers } from "./internals";++/**+ * The building blocks both layout strategies share: a column-tracking output+ * buffer, the width measurements that decide whether a group fits, and the+ * helpers that recognise the structural nodes of a statement body.+ *+ * The layout rules themselves live in `printer.ts` (queries) and `ddl.ts`+ * (`CREATE TABLE` column alignment).+ */++export interface SqlLayoutOptions {+ /** Hard wrap column; a group wider than this is broken across lines. */+ lineWidth: number;+ /** Maximum number of clause items kept on the keyword's line. */+ keepElementsOnOneLine: number;+ /** One indent step, in columns. */+ indentWidth: number;+ /** Extra indent applied to JOIN keywords, in columns. */+ joinIndentWidth: number;+ /** Keyword casing, matching sql-formatter's `keywordCase`. */+ keywordCase: "preserve" | "upper" | "lower";+ /**+ * Where a wrapped condition puts its `AND`/`OR`, matching DBX's own+ * "logical operator newline" setting.+ *+ * `before` starts the continuation line with the operator, `after` ends the+ * previous line with it, and `none` keeps the whole condition on one line+ * wherever it fits, matching the element alignment rule.+ */+ logicalOperatorNewline: "before" | "after" | "none";+ /** Blank lines left between two statements. */+ linesBetweenQueries: number;+ /** Whether indentation is written with tab characters. */+ useTabs: boolean;+ /**+ * Whether a `FROM` clause's first source stays on the keyword's line.+ *+ * The default keeps it there; DBX exposes the alternative as its+ * "FROM clause" setting.+ */+ fromClauseSourceOnSameLine: boolean;+}++export interface SqlLayoutContext {+ renderers: SqlLayoutRenderers;+ options: SqlLayoutOptions;+ /**+ * Parentheses that must not be glued to the name before them, even though it+ * is an identifier. Set only for an `INSERT` target's column list; see+ * {@link clauseChildContext}.+ */+ nonCallParens?: ReadonlySet<AstNode>;+ /**+ * Whether a condition may be joined onto one line here.+ *+ * Defaults to `logicalOperatorNewline === "none"`: the other two values exist+ * precisely because the caller wants the operators broken out. Collapse+ * measurements override it — see {@link collapsedContext}.+ */+ joinLogicalOperators?: boolean;+}++/**+ * Column-tracking output buffer.+ *+ * Positions are tracked as display columns rather than string offsets, because+ * the layout aligns continuations under a column that depends on the enclosing+ * `(`. With `useTabs` only the leading indentation becomes tabs — the padding+ * used for alignment stays spaces, so a column target that is not a multiple of+ * the tab width still lands where it was measured.+ */+export class Writer {+ private lines: string[] = [""];+ private columns: number[] = [0];++ constructor(private readonly options: Pick<SqlLayoutOptions, "useTabs" | "indentWidth">) {}++ /** Column the cursor currently sits at, on the last line. */+ get column(): number {+ return this.columns[this.columns.length - 1];+ }++ /** Appends text verbatim. */+ write(text: string): void {+ this.lines[this.lines.length - 1] += text;+ this.columns[this.columns.length - 1] += text.length;+ }++ /** Appends a single separating space, unless one is already there. */+ space(): void {+ const line = this.lines[this.lines.length - 1];+ if (line.length > 0 && !line.endsWith(" ")) {+ this.lines[this.lines.length - 1] = `${line} `;+ this.columns[this.columns.length - 1] += 1;+ }+ }++ /** Starts a new line at `indent` columns, dropping trailing blanks first. */+ newline(indent: number): void {+ const last = this.lines.length - 1;+ this.lines[last] = this.lines[last].trimEnd();+ const column = Math.max(0, indent);+ this.lines.push(this.indentation(column));+ this.columns.push(column);+ }++ toString(): string {+ return this.lines+ .map((line) => line.trimEnd())+ .join("\n")+ .trim();+ }++ /** The whitespace achieving `column` columns of indentation. */+ private indentation(column: number): string {+ if (!this.options.useTabs) return " ".repeat(column);+ const width = Math.max(1, this.options.indentWidth);+ return "\t".repeat(Math.floor(column / width)) + " ".repeat(column % width);+ }+}++export function isParenthesis(node: AstNode): node is ParenthesisNode {+ return node.type === "parenthesis";+}++/**+ * The keyword a node opens its line with, or `null` for a node that is part of+ * an expression. Clauses, set operations and limit clauses each start a line.+ */+export function bodyKeyword(node: AstNode): string | null {+ if (node.type === "clause" || node.type === "set_operation") {+ return (node as ClauseNode | SetOperationNode).nameKw.text;+ }+ if (node.type === "limit_clause") {+ return (node as LimitClauseNode).limitKw.text;+ }+ return null;+}++export function isBodyNode(node: AstNode): boolean {+ return bodyKeyword(node) !== null;+}++/**+ * The context a collapse measurement renders in.+ *+ * The collapse rule *joins* statements the element placement would otherwise+ * spread over several lines, so a condition inside a+ * statement — or a subquery — being measured for one line joins its operators+ * even when the user asked for `logicalOperatorNewline: "before"`.+ */+export function collapsedContext(ctx: SqlLayoutContext): SqlLayoutContext {+ return ctx.joinLogicalOperators ? ctx : { ...ctx, joinLogicalOperators: true };+}++/**+ * The comma the parser does not materialise for `LIMIT 5, 10`, where the offset+ * and the count are separate expression chains. sql-formatter writes the+ * separator itself while formatting; here the two are joined as ordinary clause+ * items, so the separator has to be an item.+ */+const LIMIT_SEPARATOR = { type: "comma" } as unknown as AstNode;++/** The expressions a `LIMIT` clause renders, in sql-formatter's own order. */+export function limitChildren(node: LimitClauseNode): AstNode[] {+ return node.offset ? [...node.offset, LIMIT_SEPARATOR, ...node.count] : [...node.count];+}++export function keywordText(text: string, ctx: SqlLayoutContext): string {+ switch (ctx.options.keywordCase) {+ case "upper":+ return text.toUpperCase();+ case "lower":+ return text.toLowerCase();+ default:+ return text;+ }+}++export function splitByComma(children: AstNode[]): AstNode[][] {+ const groups: AstNode[][] = [];+ let current: AstNode[] = [];+ for (const child of children) {+ if (child.type === "comma") {+ groups.push(current);+ current = [];+ } else {+ current.push(child);+ }+ }+ groups.push(current);+ return groups;+}++/**+ * Keywords that introduce an object name rather than an expression operand, so+ * a parenthesis directly after that name is a definition list, not a call:+ * `INTO t (a, b)`, `REFERENCES t (col)`, `ON t (col)`.+ */+const OBJECT_NAME_KEYWORD = /^(?:INTO|TABLE|VIEW|INDEX|REFERENCES|ON)$/i;++/**+ * Whether `(` at `index` is a function call on the name before it. The default+ * style writes `f(x)`, not `f (x)`; sql-formatter separates an unknown function name+ * from its argument list because it cannot tell a call from a keyword.+ *+ * `INSERT INTO t (a, b)` and `REFERENCES t (col)` have the same shape but are+ * not calls. The keyword in front of the name is what tells the two apart here;+ * a statement head puts its object name in a clause of its own, where that+ * keyword is not a sibling — see {@link clauseChildContext}.+ */+export function isCallParen(nodes: AstNode[], index: number, ctx: SqlLayoutContext): boolean {+ const node = nodes[index];+ if (ctx.nonCallParens?.has(node)) return false;+ const previous = index > 0 ? nodes[index - 1] : undefined;+ if (previous?.type !== "identifier" && previous?.type !== "property_access") return false;++ const before = index > 1 ? nodes[index - 2] : undefined;+ return !(before?.type === "keyword" && OBJECT_NAME_KEYWORD.test(before.text.trim()));+}++/** `CREATE TABLE` plus the modifiers dialects may put around it. */+const CREATE_TABLE_HEAD = "CREATE\\s+(?:OR\\s+REPLACE\\s+)?(?:GLOBAL\\s+|LOCAL\\s+)?(?:TEMP(?:ORARY)?\\s+)?(?:UNLOGGED\\s+)?TABLE(?:\\s+IF\\s+NOT\\s+EXISTS)?";++/**+ * A `CREATE TABLE` head. Shared with `ddl.ts` so that the column alignment and+ * the definition-list rule below agree on exactly which statements they describe.+ */+export const CREATE_TABLE_KEYWORD = new RegExp(`^${CREATE_TABLE_HEAD}$`, "i");++/**+ * Clause keywords whose object name is followed by a parenthesized *definition+ * list* rather than call arguments: `INSERT INTO t (a, b)` takes column names,+ * `CREATE TABLE t (id int)` takes column definitions.+ */+const DEFINITION_LIST_KEYWORD = new RegExp(`^(?:INSERT\\b[\\s\\S]*\\bINTO|${CREATE_TABLE_HEAD})$`, "i");++/**+ * The context a clause's own children are rendered in.+ *+ * A statement head holds its object name as a clause child (`t` in+ * `INSERT INTO t (a, b)`), so the keyword identifying it is the clause's own and+ * {@link isCallParen}'s lookback cannot see it. Marking the group rather than+ * the whole clause leaves every other parenthesis in the clause — an+ * `ON DUPLICATE KEY UPDATE b = f(c)`, which the parser also puts here — a call.+ */+export function clauseChildContext(ctx: SqlLayoutContext, clause: ClauseNode): SqlLayoutContext {+ if (clause.children.length < 2 || !DEFINITION_LIST_KEYWORD.test(clause.nameKw.text.trim())) return ctx;++ const at = clause.children.findIndex(isParenthesis);+ if (at <= 0) return ctx;+ return { ...ctx, nonCallParens: new Set([...(ctx.nonCallParens ?? []), clause.children[at]]) };+}++/**+ * Renders `nodes` on one line, or `null` when they do not fit in `width`.+ *+ * Two cases go beyond a straight call to `renderers.inline`:+ *+ * - Parenthesized groups are rendered here, by {@link renderParenGroup}. Going+ * through our own rules at every nesting depth is what keeps `f(x)` free of a+ * space — inside another call's arguments as much as at the top level.+ * - A run of clauses is collapsible. `renderers.inline` refuses anything whose+ * layout needs a line break, clauses included, but the default style does put+ * `SELECT a FROM t` on one line when it fits, and the same rule keeps a small+ * subquery inline.+ *+ * Logical operators are joined by {@link renderLogicalJoin} when the caller's+ * `logicalOperatorNewline` asks for it, so a condition stays on its clause's line+ * while it fits; the printer splits the operators onto their own lines otherwise.+ */+export function renderInline(ctx: SqlLayoutContext, nodes: AstNode[], width: number): string | null {+ if (nodes.length === 0 || width <= 0) return null;++ const parenAt = nodes.findIndex(isParenthesis);+ if (parenAt >= 0) {+ const group = renderParenGroup(ctx, nodes, parenAt, width);+ if (group) return group;+ }++ const direct = ctx.renderers.inline(nodes, width);+ if (direct) return direct;++ const joinsOperators = ctx.joinLogicalOperators ?? ctx.options.logicalOperatorNewline === "none";+ const joined = joinsOperators && nodes.some(isLogicalOperator) ? renderLogicalJoin(ctx, nodes, width) : null;+ if (joined) return joined;++ if (!nodes.some(isBodyNode)) return null;++ const parts: string[] = [];+ let used = 0;+ for (const node of nodes) {+ const keyword = bodyKeyword(node);+ if (!keyword) return null;+ const childCtx = node.type === "limit_clause" ? ctx : clauseChildContext(ctx, node as ClauseNode);+ const children = node.type === "limit_clause" ? limitChildren(node as LimitClauseNode) : (node as ClauseNode).children;+ const text = renderInline(childCtx, children, width - used - keyword.length - 2);+ if (!text) return null;+ used += (parts.length > 0 ? 1 : 0) + keyword.length + 1 + text.length;+ if (used > width) return null;+ parts.push(`${keywordText(keyword, ctx)} ${text}`);+ }+ return parts.join(" ");+}++/**+ * Renders the parenthesis group at `at` and the rest of `nodes` behind it, or+ * `null` when the line does not fit.+ *+ * The group is measured from the inside out: its contents get the width left+ * after the name before it, and whatever follows gets what the group left. A+ * call — a name directly in front of the group — is written without a+ * separator, everything else with one, which is the only difference between+ * `f(x)` and `IN (x)`.+ */+function renderParenGroup(ctx: SqlLayoutContext, nodes: AstNode[], at: number, width: number): string | null {+ const node = nodes[at] as ParenthesisNode;+ // A group that fits is a collapsed statement in its own right, so its contents+ // join their logical operators whatever the caller's operator placement is.+ const groupCtx = collapsedContext(ctx);+ const head = at === 0 ? "" : renderInline(groupCtx, nodes.slice(0, at), width);+ if (head === null) return null;++ const separator = at === 0 || isCallParen(nodes, at, ctx) ? "" : " ";+ const inner = renderInline(groupCtx, node.children, width - head.length - separator.length - node.openParen.length - node.closeParen.length);+ if (!inner) return null;+ const group = `${head}${separator}${node.openParen}${inner}${node.closeParen}`;++ const rest = nodes.slice(at + 1);+ if (rest.length === 0) return group.length <= width ? group : null;++ const tail = renderInline(groupCtx, rest, width - group.length - 1);+ if (!tail) return null;+ const text = `${group}${separatorBefore(rest[0], ctx)}${tail}`;+ return text.length <= width ? text : null;+}++/** The space that belongs between a rendered group and the node following it. */+function separatorBefore(node: AstNode, ctx: SqlLayoutContext): string {+ if (node.type === "comma") return "";+ if (node.type === "operator" && ctx.renderers.denseOperator(node.text)) return "";+ return " ";+}++/** Whether `node` is an `AND`/`OR`/`XOR` joining two conditions. */+export function isLogicalOperator(node: AstNode): node is KeywordNode {+ return node.type === "keyword" && (node.tokenType === "AND" || node.tokenType === "OR" || node.tokenType === "XOR");+}++/** Whether `node` opens a new join element — the `JOIN` keyword itself. */+export function isJoinKeyword(node: AstNode): node is KeywordNode {+ return node.type === "keyword" && node.tokenType === "RESERVED_JOIN";+}++/**+ * The operands of a condition, each after the first starting with the `AND`/`OR`+ * that introduces it, or `null` when `nodes` is not such a chain.+ *+ * Only the operators at this level count: one nested inside a parenthesis belongs+ * to that group, which is printed — and split — on its own.+ */+export function splitLogicalOperands(nodes: AstNode[]): AstNode[][] | null {+ const operands: AstNode[][] = [];+ let current: AstNode[] = [];+ for (const node of nodes) {+ if (!isLogicalOperator(node)) {+ current.push(node);+ continue;+ }+ if (current.length === 0) return null;+ operands.push(current);+ current = [node];+ }+ if (operands.length === 0 || current.length === 0) return null;+ operands.push(current);+ return operands;+}++/**+ * Joins the operands of a condition onto one line, or returns `null` when the+ * result would not fit.+ *+ * `renderers.inline` raises on a logical operator because sql-formatter always+ * breaks the line there. The default style instead keeps a clause's elements on+ * the clause's line and wraps them only past the hard wrap column, so `WHERE a = 1+ * AND b = 2` is one line while `... AND <a long enough operand>` is not.+ *+ * Splitting here rather than relaxing the renderer keeps the refusal intact for+ * the constructs that must stay multi-line: a JOIN or a CASE is not a split+ * point, so neither is ever folded onto one line by this.+ */+function renderLogicalJoin(ctx: SqlLayoutContext, nodes: AstNode[], width: number): string | null {+ const parts: string[] = [];+ let run: AstNode[] = [];+ let used = 0;++ const flush = (): boolean => {+ if (run.length === 0) return true;+ const text = renderInline(ctx, run, width - used);+ if (!text) return false;+ used += text.length + 1;+ parts.push(text);+ run = [];+ return true;+ };++ for (const node of nodes) {+ if (!isLogicalOperator(node)) {+ run.push(node);+ continue;+ }+ if (!flush()) return null;+ const operator = keywordText(node.text, ctx);+ used += operator.length + 1;+ parts.push(operator);+ }+ if (!flush()) return null;+ return used - 1 <= width ? parts.join(" ") : null;+}++/**+ * Writes possibly multi-line `text`, re-basing each continuation line on the+ * column the block starts at. `text` is rendered relative to column 0, so its+ * own leading whitespace carries the nesting levels and only needs shifting.+ */+export function emitText(writer: Writer, text: string, baseColumn: number): void {+ const lines = text.split("\n");+ writer.write(lines[0].trimEnd());+ for (let index = 1; index < lines.length; index++) {+ const line = lines[index];+ if (line.trim() === "") {+ writer.newline(0);+ continue;+ }+ writer.newline(baseColumn + line.length - line.trimStart().length);+ writer.write(line.trimStart());+ }+}diff --git a/apps/desktop/src/lib/sql/layout/printer.ts b/apps/desktop/src/lib/sql/layout/printer.tsnew file mode 100644index 0000000000..4bcbea6970--- /dev/null+++ b/apps/desktop/src/lib/sql/layout/printer.ts@@ -0,0 +1,282 @@+import type { AstNode, ClauseNode, LimitClauseNode, ParenthesisNode, StatementNode } from "sql-formatter/dist/esm/parser/ast.js";+import { createTableLayout, isCreateTable } from "./ddl";+import { clauseChildContext, collapsedContext, emitText, isBodyNode, isCallParen, isJoinKeyword, isLogicalOperator, isParenthesis, keywordText, limitChildren, renderInline, splitByComma, splitLogicalOperands, Writer, type SqlLayoutContext } from "./primitives";++export type { SqlLayoutContext, SqlLayoutOptions } from "./primitives";++/**+ * SQL layout — DBX's default formatting style.+ *+ * The rules:+ *+ * - Clause keywords start at the block's left margin, with no padding after+ * them.+ * - A clause's first item stays on the keyword's line, and its remaining items+ * align under the first item's column.+ * - Short element lists stay collapsed.+ * - A statement whose clauses all fit the line width is emitted as a single+ * line.+ * - Join keywords are indented relative to their FROM clause.+ *+ * Alignment is *column-relative*, not indent-level-relative: a subquery's+ * clauses line up under the `(` that opens it, wherever that `(` happens to be.+ * sql-formatter's `Layout`/`Indentation` model cannot express that, which is why+ * this printer walks the AST itself and only delegates the rendering of+ * individual expressions to sql-formatter (see `internals.ts`).+ *+ * Everything here degrades towards "expand": whenever a group cannot be measured+ * or does not fit, it is laid out across multiple lines rather than truncated.+ */++/**+ * Emits one clause: its keyword, then its items — the first kept on the keyword's+ * line and the rest aligned under it — unless the whole list is short enough to+ * stay on one line.+ */+function printClause(writer: Writer, clause: ClauseNode, baseColumn: number, ctx: SqlLayoutContext): void {+ const keyword = keywordText(clause.nameKw.text, ctx);+ const items = splitByComma(clause.children);+ const itemColumn = baseColumn + keyword.length + 1;+ // `FROM` is the one clause DBX lets users push its first source off of, so it+ // skips both the collapse and the "element on the keyword's line" rule.+ const sourceOnOwnLine = clause.nameKw.text.toUpperCase() === "FROM" && !ctx.options.fromClauseSourceOnSameLine;+ const childCtx = clauseChildContext(ctx, clause);++ if (!sourceOnOwnLine && items.length <= ctx.options.keepElementsOnOneLine) {+ const flat = renderInline(childCtx, clause.children, ctx.options.lineWidth - writer.column - keyword.length - 1);+ if (flat) {+ writer.write(`${keyword} ${flat}`);+ return;+ }+ }++ items.forEach((item, index) => {+ if (index === 0) {+ writer.write(keyword);+ if (sourceOnOwnLine) writer.newline(baseColumn + ctx.options.indentWidth);+ else writer.space();+ } else {+ writer.newline(itemColumn);+ }+ printElement(writer, item, baseColumn, childCtx);+ if (index < items.length - 1) writer.write(",");+ });+}++/** Emits a `LIMIT` clause, which sql-formatter renders as keyword + expressions. */+function printLimitClause(writer: Writer, clause: LimitClauseNode, ctx: SqlLayoutContext): void {+ const keyword = keywordText(clause.limitKw.text, ctx);+ const children = limitChildren(clause);+ const flat = renderInline(ctx, children, ctx.options.lineWidth - writer.column - keyword.length - 1);+ if (flat) {+ writer.write(`${keyword} ${flat}`);+ return;+ }+ writer.write(keyword);+ writer.newline(writer.column + ctx.options.indentWidth);+ emitText(writer, ctx.renderers.block(children).trim(), writer.column);+}++/** Index just past the nodes that share a line with the group at `from`. */+function joinElementEnd(nodes: AstNode[], from: number): number {+ let end = from;+ while (end < nodes.length && !isJoinKeyword(nodes[end])) end += 1;+ return end;+}++/**+ * Renders the contents of the parenthesis at `index` on one line, or `null` when+ * the group has to expand across lines.+ *+ * The measurement covers the rest of the join element, not just the group: a+ * subquery stays inline only while `(SELECT ...) alias ON ...` fits the line as+ * a whole. The group expands when it does not, rather than keeping a+ * short subquery inline and pushing a long `ON` onto a line of its own.+ */+function measureParen(writer: Writer, nodes: AstNode[], index: number, ctx: SqlLayoutContext): string | null {+ const node = nodes[index] as ParenthesisNode;+ const width = ctx.options.lineWidth;+ const afterOpen = writer.column + node.openParen.length;+ const collapseCtx = collapsedContext(ctx);+ const inner = renderInline(collapseCtx, node.children, width - afterOpen - node.closeParen.length);+ if (!inner) return null;++ const end = joinElementEnd(nodes, index + 1);+ if (end === index + 1) return inner;++ const remaining = width - afterOpen - inner.length - node.closeParen.length;+ return renderInline(collapseCtx, nodes.slice(index + 1, end), remaining) ? inner : null;+}++/**+ * Emits a condition that does not fit on one line, breaking it at its top-level+ * logical operators the way `logicalOperatorNewline` asks: `before` starts each+ * continuation line with the operator, `after` ends the previous line with it.+ *+ * The operands align under the first one, the same rule a clause's other items+ * follow — the style keeps a clause's elements in one column rather than+ * indenting them another step.+ */+function printCondition(writer: Writer, operands: AstNode[][], baseColumn: number, ctx: SqlLayoutContext): void {+ const column = writer.column;+ for (const [head, ...rest] of operands) {+ if (!isLogicalOperator(head)) {+ printElement(writer, [head, ...rest], baseColumn, ctx);+ continue;+ }++ const operator = keywordText(head.text, ctx);+ if (ctx.options.logicalOperatorNewline === "before") {+ writer.newline(column);+ writer.write(operator);+ writer.space();+ } else {+ writer.space();+ writer.write(operator);+ writer.newline(column);+ }+ printElement(writer, rest, baseColumn, ctx);+ }+}++/**+ * Emits one clause item, expanding only those parentheses that do not fit on the+ * current line.+ */+function printElement(writer: Writer, nodes: AstNode[], baseColumn: number, ctx: SqlLayoutContext): void {+ const whole = renderInline(ctx, nodes, ctx.options.lineWidth - writer.column);+ if (whole) {+ writer.write(whole);+ return;+ }++ // A condition is split at its own operators before anything else is tried, so+ // `AND`/`OR` end up on the lines the setting asks for rather than wherever the+ // block fallback happens to place them. `none` asks for no break of its own,+ // and is folded back together after formatting (see the caller's post-pass).+ const operands = ctx.options.logicalOperatorNewline === "none" ? null : splitLogicalOperands(nodes);+ if (operands) {+ printCondition(writer, operands, baseColumn, ctx);+ return;+ }++ let index = 0;+ while (index < nodes.length) {+ const node = nodes[index];++ if (isParenthesis(node)) {+ if (!isCallParen(nodes, index, ctx)) writer.space();+ const inner = measureParen(writer, nodes, index, ctx);+ if (inner) {+ writer.write(`${node.openParen}${inner}${node.closeParen}`);+ } else {+ writer.write(node.openParen);+ printBlock(writer, node.children, writer.column, ctx);+ writer.write(node.closeParen);+ }+ index += 1;+ continue;+ }++ // A JOIN keyword opens a new line one "Join indent" in from the FROM clause.+ if (isJoinKeyword(node)) {+ writer.newline(baseColumn + ctx.options.joinIndentWidth);+ writer.write(keywordText(node.text, ctx));+ index += 1;+ continue;+ }++ // Gather the run of plain nodes up to the next construct needing care, so+ // they are measured together instead of one node at a time.+ let end = index;+ while (end < nodes.length && !isParenthesis(nodes[end]) && !isJoinKeyword(nodes[end])) {+ end += 1;+ }+ const run = nodes.slice(index, end);+ const rendered = renderInline(ctx, run, ctx.options.lineWidth - writer.column);+ writer.space();+ if (rendered) {+ writer.write(rendered);+ } else {+ // A construct too wide to inline (a long CASE, a nested function call):+ // fall back to sql-formatter's own multi-line rendering of it.+ emitText(writer, ctx.renderers.block(run).trim(), writer.column);+ }+ index = end;+ }+}++/**+ * Emits a statement body: a subquery's clauses or a statement's own clauses.+ *+ * Called only once the caller has established that the body does not fit on one+ * line, so there is no second collapse attempt here — re-flattening would undo+ * the very expansion the caller asked for.+ */+function printBlock(writer: Writer, nodes: AstNode[], baseColumn: number, ctx: SqlLayoutContext): void {+ if (!nodes.some(isBodyNode)) {+ // A plain expression group (not a subquery) that did not fit: let+ // sql-formatter break it, then re-base the block on this column.+ emitText(writer, ctx.renderers.block(nodes).trim(), baseColumn);+ return;+ }++ let first = true;+ for (const node of nodes) {+ if (!first) writer.newline(baseColumn);+ writeBodyNode(writer, node, baseColumn, ctx);+ first = false;+ }+}++/** Emits one clause / set operation / limit clause of a statement body. */+function writeBodyNode(writer: Writer, node: AstNode, baseColumn: number, ctx: SqlLayoutContext): void {+ if (node.type === "clause") printClause(writer, node, baseColumn, ctx);+ else if (node.type === "set_operation") writer.write(keywordText(node.nameKw.text, ctx));+ else if (node.type === "limit_clause") printLimitClause(writer, node, ctx);+ else emitText(writer, ctx.renderers.block([node]).trim(), writer.column);+}++/** Emits a whole statement, one clause per line unless the statement collapses. */+function printStatement(statement: StatementNode, ctx: SqlLayoutContext): string | null {+ const collapsed = renderInline(collapsedContext(ctx), statement.children, ctx.options.lineWidth);+ if (collapsed) return statement.hasSemicolon ? `${collapsed};` : collapsed;++ if (isCreateTable(statement)) return createTableLayout(statement, ctx);++ // A statement without clauses is a bare expression — a fragment the user+ // selected in the editor — and has no clause layout to apply. Declining hands+ // the whole input to sql-formatter, which formats such a fragment operand by+ // operand; emitting it clause by clause would put every token on its own line.+ if (!statement.children.some(isBodyNode)) return null;++ const writer = new Writer(ctx.options);+ let first = true;+ for (const node of statement.children) {+ if (!first) writer.newline(0);+ writeBodyNode(writer, node, 0, ctx);+ first = false;+ }+ if (statement.hasSemicolon) writer.write(";");+ return writer.toString();+}++/**+ * Formats already-parsed statements using the default style's layout rules.+ *+ * Returns `null` when any statement lies outside the model these rules describe,+ * so the caller can format the input as a whole with sql-formatter instead of+ * mixing two styles inside one script.+ */+export function printSqlLayout(statements: StatementNode[], ctx: SqlLayoutContext): string | null {+ // Same convention as sql-formatter: the setting counts blank lines, so the+ // separator is one newline longer.+ const separator = "\n".repeat(ctx.options.linesBetweenQueries + 1);+ const rendered: string[] = [];+ for (const statement of statements) {+ const text = printStatement(statement, ctx);+ if (text === null) return null;+ rendered.push(text);+ }+ return rendered.join(separator);+}diff --git a/apps/desktop/src/lib/sql/sqlFormatter.ts b/apps/desktop/src/lib/sql/sqlFormatter.tsindex 8612a48baf..837fdd0604 100644--- a/apps/desktop/src/lib/sql/sqlFormatter.ts+++ b/apps/desktop/src/lib/sql/sqlFormatter.ts@@ -1,4 +1,5 @@import { DEFAULT_SQL_FORMATTER_SETTINGS, normalizeSqlFormatterSettings, sqlFormatterOptions, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";+import { formatSqlLayout, type SqlLayoutOptions } from "@/lib/sql/layout";import { looksLikeXml } from "@/lib/sql/autoFormat";export type SqlFormatDialect = "mysql" | "postgres" | "sqlite" | "sqlserver" | "oracle" | "clickhouse" | "dameng" | "duckdb" | "generic";@@ -361,10 +362,11 @@ export async function formatSqlText(sql: string, dialect: SqlFormatDialect = "ge},}: options;+ const resolvedDialect = dialect === "clickhouse" ? resolveClickHouseIdentifierSafeDialect(sqlFormatter) : undefined;const formatWithFallback = (input: string): string => {try {- if (dialect === "clickhouse") {- return formatDialect(input, { ...formatterOptions, dialect: resolveClickHouseIdentifierSafeDialect(sqlFormatter) });+ if (resolvedDialect) {+ return formatDialect(input, { ...formatterOptions, dialect: resolvedDialect });}return format(input, { language, ...formatterOptions });} catch (err) {@@ -389,14 +391,35 @@ export async function formatSqlText(sql: string, dialect: SqlFormatDialect = "gereturn emptyLineProtection ? restoreProtectedEmptyLines(laidOut, emptyLineProtection.markers) : laidOut;};+ // DBX's own layout printer produces the default style. It needs the AST and+ // sql-formatter's internal layout machinery, so it can decline an input — an+ // unparseable statement, an internal shape that moved. `null` means "use the+ // public formatter", which is also what the tabular indent styles ask for:+ // those are an alternative layout this printer deliberately does not reproduce.+ const layoutOptions: Partial<SqlLayoutOptions> = {+ lineWidth: normalizedSettings.expressionWidth,+ indentWidth: normalizedSettings.tabWidth,+ useTabs: normalizedSettings.useTabs,+ linesBetweenQueries: normalizedSettings.linesBetweenQueries,+ fromClauseSourceOnSameLine: normalizedSettings.fromClauseLayout === "sameLine",+ keywordCase: normalizedSettings.keywordCase,+ logicalOperatorNewline: normalizedSettings.logicalOperatorNewline,+ };+ const usesDefaultStyle = normalizedSettings.indentStyle === "standard";++ const formatOnce = async (input: string): Promise<string> => {+ const laidOut = usesDefaultStyle ? await formatSqlLayout({ sql: input, language, dialectOptions: resolvedDialect, cfg: formatterOptions, options: layoutOptions }) : null;+ return laidOut ?? formatWithFallback(input);+ };+try {- return finalizeFormattedSql(formatWithFallback(protectedInput.sql));+ return finalizeFormattedSql(await formatOnce(protectedInput.sql));} catch (err) {const trailingDot = dialect === "dameng" ? splitTrailingStandaloneDot(protectedInput.sql) : null;if (!trailingDot) throw err;try {- return finalizeFormattedSql(`${formatWithFallback(trailingDot.body)}${trailingDot.suffix}`);+ return finalizeFormattedSql(`${await formatOnce(trailingDot.body)}${trailingDot.suffix}`);} catch {throw err;}@@ -640,6 +663,18 @@ function keepFromClauseAndFirstSourceOnSameLine(sql: string): string {return lines.join("\n");}+/**+ * The text-level passes applied to whatever the formatter produced, whether the+ * default style's layout printer or sql-formatter itself.+ *+ * The two settings-driven passes fix shapes the printer already gets right on+ * its own — it keeps a `FROM` source on the keyword's line and joins operators+ * for `none` — so they are no-ops on its output. They stay because a statement+ * the printer declines falls back to sql-formatter's layout for the whole input,+ * which does break those shapes; see `formatSqlText`. {@link+ * normalizeLikeOperatorCase} is unrelated to either: it corrects a dialect quirk+ * in both paths.+ */function applySqlFormatterLayout(sql: string, settings: SqlFormatterSettings, dialect: SqlFormatDialect): string {let formatted = normalizeLikeOperatorCase(sql, settings, dialect);if (settings.logicalOperatorNewline === "none") formatted = keepLogicalOperatorsOnSameLine(formatted, dialect);diff --git a/apps/desktop/src/lib/sql/sqlFormatterConfig.ts b/apps/desktop/src/lib/sql/sqlFormatterConfig.tsindex 6bcea73478..4a28a2fe4d 100644--- a/apps/desktop/src/lib/sql/sqlFormatterConfig.ts+++ b/apps/desktop/src/lib/sql/sqlFormatterConfig.ts@@ -74,8 +74,8 @@ export const DEFAULT_SQL_FORMATTER_SETTINGS: SqlFormatterSettings = {useTabs: false,tabWidth: 2,logicalOperatorNewline: "before",- fromClauseLayout: "newLine",- expressionWidth: 50,+ fromClauseLayout: "sameLine",+ expressionWidth: 120,linesBetweenQueries: 1,preserveEmptyLines: false,denseOperators: false,diff --git a/apps/desktop/tsconfig.json b/apps/desktop/tsconfig.jsonindex 17cb3661ba..783e8a06c2 100644--- a/apps/desktop/tsconfig.json+++ b/apps/desktop/tsconfig.json@@ -19,7 +19,8 @@"noUnusedParameters": true,"noFallthroughCasesInSwitch": true,"paths": {- "@/*": ["./src/*"]+ "@/*": ["./src/*"],+ "sql-formatter/dist/*": ["../../node_modules/sql-formatter/dist/*"]}},"include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"],diff --git a/apps/desktop/vite.config.ts b/apps/desktop/vite.config.tsindex fea4337f6e..f972a63533 100644--- a/apps/desktop/vite.config.ts+++ b/apps/desktop/vite.config.ts@@ -71,6 +71,10 @@ export default defineConfig(async () => ({"@": path.resolve(import.meta.dirname, "./src"),// Prefer package source during app dev so shell parse changes need no rebuild."@dbx-app/mongo-shell": path.resolve(import.meta.dirname, "../../packages/mongo-shell/src/index.ts"),+ // sql-formatter's `exports` map only declares ".", so deep imports into its+ // bundled parser/tokenizer are rejected by Vite's exports handling. The+ // The default layout engine needs that AST; see src/lib/sql/layout/internals.ts.+ "sql-formatter/dist/": `${path.resolve(import.meta.dirname, "../../node_modules/sql-formatter/dist")}/`,},},clearScreen: false,diff --git a/crates/dbx-core/assets/docs-export.manifest.json b/crates/dbx-core/assets/docs-export.manifest.jsonindex c9f41fbebe..60cfafbae1 100644--- a/crates/dbx-core/assets/docs-export.manifest.json+++ b/crates/dbx-core/assets/docs-export.manifest.json@@ -40,7 +40,7 @@"apps/desktop/src/lib/common/utils.ts": "76c4b2af1e03edeb8db389d9b2c1b56b72a57a1b5198d4e224671c1445c527da","apps/desktop/src/lib/diagram/erDiagram.ts": "e28aa2b5fbba001ae78bc0c4218b11f93b0e14ab9f54562f14254386b98bad11","apps/desktop/src/styles/tokens.css": "b8852ce50865ad98ebc992971f7a06670c5d830ca82efcee956f8d3eb7c2e9a3",- "apps/desktop/tsconfig.json": "5ad521941835ad8529e9b81ba79c11650e5f020f0e376b7a9f17e22a9306fa76",+ "apps/desktop/tsconfig.json": "ee02ba8f2f257b86235cd3053e8d6fbfefd7c39e0807b4ea5e36e133a78e836c","apps/desktop/vite.docs-export.config.ts": "833bc2cbd99f9c0740cbc1584640458492bad75c9518db4d1ce0edd6958881ec"},"deps": {diff --git a/docs/content/docs/sql-formatter.cn.mdx b/docs/content/docs/sql-formatter.cn.mdxindex db3a1d1aa9..a75b62fda2 100644--- a/docs/content/docs/sql-formatter.cn.mdx+++ b/docs/content/docs/sql-formatter.cn.mdx@@ -26,6 +26,10 @@ DBX 当前对以下方言使用专用格式化语法:MongoDB 查询编辑器使用单独的 Mongo Shell 格式化器,不使用本页的 SQL 方言映射。+## 默认风格++默认排版规则:能放下的语句保持一行,放不下的按子句逐行展开,子句的后续元素与第一个元素对齐;条件的逻辑操作符放在续行行首;`CREATE TABLE` 的列定义按列对齐。下面的设置用于调整这些规则,**恢复默认值**会回到该风格。+## 配置格式化选项前往 **设置 → SQL 格式化**。表单模式提供以下选项:@@ -36,9 +40,11 @@ MongoDB 查询编辑器使用单独的 Mongo Shell 格式化器,不使用本| 缩进样式 | `standard`、`tabularLeft`、`tabularRight` || 缩进字符 | 空格或 Tab || Tab 宽度 | `2` 或 `4` |-| 逻辑操作符换行 | 操作符之前或之后 |+| 逻辑操作符换行 | `before`、`after`,或 `none` 保持在同一行 |+| FROM 子句排版 | `sameLine` 让首个表留在 `FROM` 行,`newLine` 让它换到下一行 || 表达式宽度 | `50`、`80` 或 `120` || 查询间空行 | `0`、`1` 或 `2` |+| 保留空行 | 保留语句之间的空行 || 紧凑操作符 | 减少操作符周围的空格 || 分号前换行 | 把语句结尾分号放到新行 || 参数类型 | 识别位置参数、编号参数、命名参数、引号参数或自定义正则参数 |@@ -62,8 +68,10 @@ JSON 模式适合精确编辑、复制或迁移格式化器配置。当前配置"useTabs": false,"tabWidth": 2,"logicalOperatorNewline": "before",- "expressionWidth": 50,+ "fromClauseLayout": "sameLine",+ "expressionWidth": 120,"linesBetweenQueries": 1,+ "preserveEmptyLines": false,"denseOperators": false,"newlineBeforeSemicolon": false,"paramTypes": nulldiff --git a/docs/content/docs/sql-formatter.mdx b/docs/content/docs/sql-formatter.mdxindex 7254515ae1..9088617061 100644--- a/docs/content/docs/sql-formatter.mdx+++ b/docs/content/docs/sql-formatter.mdx@@ -26,6 +26,10 @@ DBX currently uses dedicated formatter grammars for:The MongoDB query editor uses a separate Mongo Shell formatter rather than this SQL dialect mapping.+## Default Style++The default layout keeps a statement that fits the width on one line, puts each clause of a longer one on its own line, and aligns a clause's remaining elements under its first element. Conditions keep their logical operators at the start of the continuation line, and `CREATE TABLE` definitions are aligned on a column grid. The settings below change those rules; **Restore Defaults** returns to this style.+## Configure Formatting OptionsOpen **Settings → SQL Formatter**. Form mode exposes:@@ -36,9 +40,11 @@ Open **Settings → SQL Formatter**. Form mode exposes:| Indent style | `standard`, `tabularLeft`, or `tabularRight` || Indentation | Spaces or tabs || Tab width | `2` or `4` |-| Logical operator newline | Before or after the operator |+| Logical operator newline | `before`, `after`, or `none` to keep them on the same line |+| FROM clause layout | `sameLine` keeps the first table on the `FROM` line, `newLine` moves it below || Expression width | `50`, `80`, or `120` || Lines between queries | `0`, `1`, or `2` |+| Preserve empty lines | Keeps blank lines between statements || Dense operators | Reduces spaces around operators || Newline before semicolon | Places a statement-ending semicolon on a new line || Parameter types | Recognizes positional, numbered, named, quoted, or custom-regex parameters |@@ -62,8 +68,10 @@ JSON mode is useful for exact editing, copying, or moving formatter settings. Th"useTabs": false,"tabWidth": 2,"logicalOperatorNewline": "before",- "expressionWidth": 50,+ "fromClauseLayout": "sameLine",+ "expressionWidth": 120,"linesBetweenQueries": 1,+ "preserveEmptyLines": false,"denseOperators": false,"newlineBeforeSemicolon": false,"paramTypes": nulldiff --git a/package.json b/package.jsonindex fbed35f2be..1efb36529d 100644--- a/package.json+++ b/package.json@@ -109,7 +109,7 @@"shiki": "^4.2.0","smol-toml": "^1.8.0","splitpanes": "^4.1.2",- "sql-formatter": "^15.8.0",+ "sql-formatter": "15.8.0","tailwind-merge": "^3.6.0","tw-animate-css": "^1.4.0","vue": "^3.5.35",diff --git a/packages/app-tests/sqlFormatter.test.ts b/packages/app-tests/sqlFormatter.test.tsindex de75faf3fb..f93beab288 100644--- a/packages/app-tests/sqlFormatter.test.ts+++ b/packages/app-tests/sqlFormatter.test.ts@@ -18,7 +18,10 @@ test("rejects very large SQL before importing formatter", async () => {});test("formats SQL with uppercase keywords and readable line breaks by default", async () => {- const formatted = await formatSqlText("select id, name from users where active = 1 order by name", "postgres");+ const formatted = await formatSqlText(+ "select id, name, email, created_at, updated_at, deleted_at, tenant_id from users where active = 1 and verified = 1 order by name, created_at desc",+ "postgres",+ );assert.match(formatted, /^SELECT\b/);assert.match(formatted, /\nFROM\b/);@@ -26,22 +29,35 @@ test("formats SQL with uppercase keywords and readable line breaks by default",assert.match(formatted, /\nORDER BY\b/);});+test("collapses a statement that fits on one line", async () => {+ const formatted = await formatSqlText("select id, name from users where active = 1 order by name", "postgres");++ assert.equal(formatted, "SELECT id, name FROM users WHERE active = 1 ORDER BY name");+});+test("formats SQL with custom keyword case and indentation settings", async () => {- const formatted = await formatSqlText("select id from users where active = 1", "postgres", {- keywordCase: "lower",- dataTypeCase: "preserve",- functionCase: "preserve",- useTabs: true,- tabWidth: 2,- logicalOperatorNewline: "before",- expressionWidth: 50,- linesBetweenQueries: 1,- denseOperators: false,- newlineBeforeSemicolon: false,- });+ const formatted = await formatSqlText(+ "select id, name, email, created_at, updated_at, deleted_at, tenant_id from users where active = 1 and verified = 1 order by name, created_at desc",+ "postgres",+ {+ keywordCase: "lower",+ dataTypeCase: "preserve",+ functionCase: "preserve",+ useTabs: true,+ tabWidth: 2,+ logicalOperatorNewline: "before",+ expressionWidth: 50,+ linesBetweenQueries: 1,+ denseOperators: false,+ newlineBeforeSemicolon: false,+ },+ );assert.match(formatted, /^select\b/);assert.match(formatted, /\nfrom\b/);+ // Continuations align under the first element, and that padding is indentation+ // at a column past the first tab stop, so it starts with tabs.+ assert.match(formatted, /\n\t+ name,/);assert.doesNotMatch(formatted, /^SELECT\b/);});diff --git a/packages/app-tests/sqlFormatterConfig.test.ts b/packages/app-tests/sqlFormatterConfig.test.tsindex f33f223755..2bf4d8fc39 100644--- a/packages/app-tests/sqlFormatterConfig.test.ts+++ b/packages/app-tests/sqlFormatterConfig.test.ts@@ -245,7 +245,7 @@ test("maps DBX formatter settings to sql-formatter options", () => {useTabs: true,tabWidth: 2,logicalOperatorNewline: "before",- expressionWidth: 50,+ expressionWidth: 120,linesBetweenQueries: 1,denseOperators: false,newlineBeforeSemicolon: true,@@ -271,7 +271,7 @@ test("maps DBX formatter settings to sql-formatter options", () => {useTabs: false,tabWidth: 2,logicalOperatorNewline: "before",- expressionWidth: 50,+ expressionWidth: 120,linesBetweenQueries: 1,denseOperators: false,newlineBeforeSemicolon: false,diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex 98ea13d844..39b0dd5a28 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -189,7 +189,7 @@ importers:specifier: ^4.1.2version: 4.1.2([email protected]([email protected]))sql-formatter:- specifier: ^15.8.0+ specifier: 15.8.0version: 15.8.0tailwind-merge:specifier: ^3.6.0@@ -604,78 +604,6 @@ packages:'@codemirror/[email protected]':resolution: {integrity: sha512-V7ZCLQO3Jus9hzh2jVCCPW3mO4IBMr43O37PqSUYautJSnnJF41YlgLw21x0fLJTYvJ+Vkm6Gp+qKGH9pltgXA==}- '@dbx-app/[email protected]':- resolution: {integrity: sha512-wFOyHD/ZYLbZsCPHnZgiyf8l1YRtIAl6KwBckJJV4Mo1Gk4e7ihrznd3whwcDZP1TXe+bBa16VCaEKitTFZIkw==}- cpu: [arm64]- os: [darwin]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-+5ZffZtbsm9HimNkL8NcD30rtYxhyRsSuR+mvE6/0ztDM8sZq2XzgsVIx7ve32+o2CmiSBR3pWRAG7vyDvhkqw==}- cpu: [x64]- os: [darwin]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-3t7PghU8VAttSIjdBtH8VRTNZq2InKlc1i7LzZD48lv1N4lUQjL1jtgw6M7QWesjT7zlWUjmjlR1pBZej+7HCg==}- cpu: [arm64]- os: [linux]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-9KKweZhj4hxjaHJBloc5OQw4/o+ouJTPucQGKz+82fIj2kHmIPPGGUAqGPYv2D3xj0k+sV2qCwd7cz6nga5GfQ==}- cpu: [x64]- os: [linux]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-bcqrVynvUqg+sCKc2pyN8s6tdZDZEjXGYO6y9V8SdY42K1iGpzCIcyvO+PNtHRgi5ICt6j9sw6AoGgPT8OoThA==}- cpu: [arm64]- os: [win32]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-o3qlOay55BR4eiSku2oGVNc6+Q77fWV6I3Ch8pULvXIS836mmnZ1OSJYCvHOc5mqyHNQ91ddtrQixmCYpGQRiQ==}- cpu: [x64]- os: [win32]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-msvgntUBKclbi1VwDTq4WVnMuk58BUB9JfevIKSqcC20w4dl0BiOo+J3utu15aU6ZJBlvp/M4I4hc5OmrgDIPA==}- cpu: [arm64]- os: [darwin]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-U1hWBUxejENDteENrrbs2QYcdr6UEeU42IJiiXHnERIR4nhdcXOiAG3eOMLoWN07+vUrMNzo3K4eZjX0xIeiwA==}- cpu: [x64]- os: [darwin]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-IRPH7GzIR86Vy+LtvIEL/V/XjsSaybyOec7IbR7LXBhAxd8WyC8TXHOKtLwLKrkY8dTFI1/orJXD0ils9euxcg==}- cpu: [arm64]- os: [linux]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-G42Wkh1i7XZxwAJQD0+FPDx42GHOpLr4m8FC9SGoR4g8aa+JFUw0UVYrWzQDjKcKhGsgM0TRhTRgW45rp8tymA==}- cpu: [x64]- os: [linux]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-5Aj8DwPuj9N7ui/tplFeoYWwpczw23g8kNF46K+OsLVCJVcuNeolmbH242UUpooIKDGrhz5uvS673MEeMBlUZg==}- cpu: [arm64]- os: [win32]- hasBin: true-- '@dbx-app/[email protected]':- resolution: {integrity: sha512-bZonwNVxcePJYgpZo/X2uO+RqSIPVchIWKJ7HjEnNmd1AcLylAoHyIvh52LGXC2GvfGBVRrRC9OsHVOG/o/qSg==}- cpu: [x64]- os: [win32]- hasBin: true-'@dotenvx/[email protected]':resolution: {integrity: sha512-/BITOC9dmS/edY2zQwZNicQ059O6RKabtQfyEafV0nGtfYRNHYy1DIPiYVcov40+tob9hfmBnbR963dS+EQ1DQ==}hasBin: true@@ -4459,42 +4387,6 @@ snapshots:style-mod: 4.1.3w3c-keyname: 2.2.8- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-- '@dbx-app/[email protected]':- optional: true-'@dotenvx/[email protected]':dependencies:'@dotenvx/primitives': 0.8.0diff --git a/vitest.config.ts b/vitest.config.tsindex 91bbb1089f..eb8f9738b7 100644--- a/vitest.config.ts+++ b/vitest.config.ts@@ -8,6 +8,10 @@ export default defineConfig({alias: {"@": path.resolve(import.meta.dirname, "apps/desktop/src"),"@dbx-app/mongo-shell": path.resolve(import.meta.dirname, "packages/mongo-shell/src/index.ts"),+ // sql-formatter's `exports` map only declares ".", so deep imports into its+ // bundled parser/tokenizer are rejected by Vite's exports handling. The+ // The default layout engine needs that AST; see lib/sql/layout/internals.ts.+ "sql-formatter/dist/": `${path.resolve(import.meta.dirname, "node_modules/sql-formatter/dist")}/`,},},test: {