Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

8.0 KB
Raw Blame
import { describe, expect, it } from "vitest";
import { DEFAULT_SQL_FORMATTER_SETTINGS, parseSqlFormatterConfig, serializeSqlFormatterConfig, sqlFormatterOptions } from "@/lib/sql/sqlFormatterConfig";

describe("sqlFormatterConfig shortcut storage", () => {
  it("does not serialize JSON editor shortcut settings", () => {
    const config = JSON.parse(serializeSqlFormatterConfig(DEFAULT_SQL_FORMATTER_SETTINGS));

    expect(config.editor).toBeUndefined();
  });

  it("ignores legacy JSON editor shortcut settings on import", () => {
    const result = parseSqlFormatterConfig(
      JSON.stringify({
        version: 1,
        formatter: "sql-formatter",
        options: {},
        editor: {
          scope: "legacyJsonEditorScope",
          shortcuts: [{ id: "unknownLegacyShortcut", enabled: "yes" }],
        },
      }),
    );

    expect(result.ok).toBe(true);
  });

  it("merges DBX custom parameter types with user paramTypes", () => {
    const options = sqlFormatterOptions({
      paramTypes: {
        positional: false,
        named: ["@"],
        custom: [{ regex: String.raw`\{\{[^}]+\}\}` }],
      },
    });

    expect(options.paramTypes).toEqual({
      positional: false,
      named: ["@"],
      custom: [{ regex: String.raw`\{\{[^}]+\}\}` }, { regex: String.raw`\$\{[^}]+\}` }, { regex: String.raw`#\{[^}]+\}` }],
    });
  });

  it("recognizes DBX positional and named parameter syntaxes by default", () => {
    expect(sqlFormatterOptions({}).paramTypes).toEqual({
      positional: true,
      named: [":", "@"],
      custom: [{ regex: String.raw`\$\{[^}]+\}` }, { regex: String.raw`#\{[^}]+\}` }],
    });
  });

  it("accepts the same-line logical operator mode", () => {
    const result = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { logicalOperatorNewline: "none" } }));

    expect(result).toEqual(expect.objectContaining({ ok: true }));
    if (result.ok) expect(result.settings.logicalOperatorNewline).toBe("none");
    expect(sqlFormatterOptions({ logicalOperatorNewline: "none" }).logicalOperatorNewline).toBe("before");
  });

  it("accepts and serializes the FROM clause layout", () => {
    const result = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { fromClauseLayout: "sameLine" } }));

    expect(result).toEqual(expect.objectContaining({ ok: true }));
    if (result.ok) expect(result.settings.fromClauseLayout).toBe("sameLine");
    expect(JSON.parse(serializeSqlFormatterConfig({ fromClauseLayout: "sameLine" })).options.fromClauseLayout).toBe("sameLine");
  });

  it("defaults empty-line preservation off and serializes an explicit opt-in", () => {
    const defaultConfig = JSON.parse(serializeSqlFormatterConfig({}));
    const optIn = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { preserveEmptyLines: true } }));

    expect(defaultConfig.options.preserveEmptyLines).toBe(false);
    expect(optIn).toEqual(expect.objectContaining({ ok: true }));
    if (optIn.ok) expect(optIn.settings.preserveEmptyLines).toBe(true);
  });

  it("defaults commaPosition to after and accepts before", () => {
    const defaultConfig = JSON.parse(serializeSqlFormatterConfig({}));
    expect(defaultConfig.options.commaPosition).toBe("after");

    const beforeResult = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { commaPosition: "before" } }));
    expect(beforeResult).toEqual(expect.objectContaining({ ok: true }));
    if (beforeResult.ok) expect(beforeResult.settings.commaPosition).toBe("before");
    expect(JSON.parse(serializeSqlFormatterConfig({ commaPosition: "before" })).options.commaPosition).toBe("before");

    const invalidResult = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { commaPosition: "invalid" } }));
    expect(invalidResult).toEqual(expect.objectContaining({ ok: false }));

    // sqlFormatterOptions must not include commaPosition so third-party sql-formatter does not throw
    expect("commaPosition" in sqlFormatterOptions({ commaPosition: "before" })).toBe(false);
  });
});

describe("sqlFormatterConfig layout style", () => {
  it("defaults to the DBX layout and keeps the style out of sql-formatter options", () => {
    const config = JSON.parse(serializeSqlFormatterConfig({}));

    expect(config.options.layoutStyle).toBe("dbx");
    // layoutStyle is DBX-private: handing it to sql-formatter would throw.
    expect("layoutStyle" in sqlFormatterOptions({ layoutStyle: "dbx" })).toBe(false);
  });

  it("round-trips the classic layout style", () => {
    const serialized = JSON.parse(serializeSqlFormatterConfig({ layoutStyle: "classic" }));
    expect(serialized.options.layoutStyle).toBe("classic");

    const parsed = parseSqlFormatterConfig(serializeSqlFormatterConfig({ layoutStyle: "classic" }));
    expect(parsed).toEqual(expect.objectContaining({ ok: true }));
    if (parsed.ok) expect(parsed.settings.layoutStyle).toBe("classic");
  });

  it("rejects a layout style outside the accepted values", () => {
    const result = parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { layoutStyle: "upstream" } }));

    expect(result).toEqual({ ok: false, message: "Invalid formatter option value: layoutStyle." });
  });

  it("accepts both config versions and rejects anything else", () => {
    // Version 1 predates layoutStyle; absence normalizes to the current default.
    const version1 = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { keywordCase: "lower" } }));
    expect(version1).toEqual(expect.objectContaining({ ok: true }));
    if (version1.ok) {
      expect(version1.settings.layoutStyle).toBe("dbx");
      expect(version1.settings.keywordCase).toBe("lower");
    }

    expect(parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { layoutStyle: "classic" } }))).toEqual(expect.objectContaining({ ok: true }));
    expect(parseSqlFormatterConfig(JSON.stringify({ version: 3, formatter: "sql-formatter", options: {} }))).toEqual({ ok: false, message: "Unsupported config version." });
  });
});

describe("SQL formatter custom rule configuration", () => {
  it.each([20, 50, 76, 80, 120, 500])("accepts a width of %i columns", (expressionWidth) => {
    const result = parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { expressionWidth } }));
    expect(result.ok).toBe(true);
    if (result.ok) expect(result.settings.expressionWidth).toBe(expressionWidth);
  });

  it.each([19, 501, 76.5, "76", null])("rejects an invalid width %s", (expressionWidth) => {
    expect(parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: { expressionWidth } }))).toEqual({ ok: false, message: "Invalid formatter option value: expressionWidth." });
  });

  it.each([
    { listLayout: "unknown" },
    { selectListLayout: "unknown" },
    { insertListLayout: false },
    { updateListLayout: 3 },
    { customRulesEnabled: "true" },
    { alignSelectAliases: 1 },
    { alignUpdateAssignments: null },
    { selectCommaPosition: "middle" },
    { insertCommaPosition: true },
    { updateCommaPosition: "middle" },
    { whereLogicalOperatorNewline: "unknown" },
    { onLogicalOperatorNewline: 1 },
    { expressionLogicalOperatorNewline: false },
    { listItemAlignment: "left" },
    { newlineBeforeJoinOn: 1 },
    { collapseShortStatements: null },
    { emptyLineMode: "unknown" },
  ])("rejects invalid explicit custom options %j", (options) => {
    const result = parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options }));
    expect(result.ok).toBe(false);
  });

  it("keeps custom rule settings out of third-party formatter options", () => {
    const options = sqlFormatterOptions({ customRulesEnabled: true, selectListLayout: "singleLine", expressionWidth: 76 });
    expect(options.expressionWidth).toBe(76);
    expect(options).not.toHaveProperty("customRulesEnabled");
    expect(options).not.toHaveProperty("selectListLayout");
  });
});