@rog0x/mcp-database-tools 1.0.0

package/src/tools/sql-formatter.ts

@@ -0,0 +1,233 @@
+/**
+ * SQL Formatter — prettify SQL queries with proper indentation,
+ * uppercased keywords, and aligned columns.
+ * Supports MySQL, PostgreSQL, and SQLite syntax.
+ */
+
+const SQL_KEYWORDS = [
+  "SELECT", "FROM", "WHERE", "AND", "OR", "NOT", "IN", "ON",
+  "JOIN", "INNER JOIN", "LEFT JOIN", "RIGHT JOIN", "FULL JOIN",
+  "LEFT OUTER JOIN", "RIGHT OUTER JOIN", "FULL OUTER JOIN", "CROSS JOIN",
+  "ORDER BY", "GROUP BY", "HAVING", "LIMIT", "OFFSET", "FETCH",
+  "INSERT INTO", "VALUES", "UPDATE", "SET", "DELETE FROM",
+  "CREATE TABLE", "ALTER TABLE", "DROP TABLE", "CREATE INDEX",
+  "DROP INDEX", "CREATE VIEW", "DROP VIEW",
+  "PRIMARY KEY", "FOREIGN KEY", "REFERENCES", "UNIQUE", "CHECK",
+  "DEFAULT", "NOT NULL", "AUTO_INCREMENT", "SERIAL", "BIGSERIAL",
+  "IF EXISTS", "IF NOT EXISTS", "CASCADE", "RESTRICT",
+  "UNION", "UNION ALL", "INTERSECT", "EXCEPT",
+  "EXISTS", "BETWEEN", "LIKE", "ILIKE", "IS NULL", "IS NOT NULL",
+  "ASC", "DESC", "DISTINCT", "ALL", "ANY", "SOME",
+  "CASE", "WHEN", "THEN", "ELSE", "END",
+  "AS", "ON", "USING", "INTO", "WITH", "RECURSIVE",
+  "RETURNING", "CONFLICT", "DO", "NOTHING",
+  "BEGIN", "COMMIT", "ROLLBACK", "SAVEPOINT",
+  "GRANT", "REVOKE", "TRUNCATE", "EXPLAIN", "ANALYZE",
+  "COALESCE", "CAST", "NULLIF", "GREATEST", "LEAST",
+  "COUNT", "SUM", "AVG", "MIN", "MAX",
+  "OVER", "PARTITION BY", "ROW_NUMBER", "RANK", "DENSE_RANK",
+  "CONSTRAINT", "ADD", "COLUMN", "RENAME", "TO",
+  "INTEGER", "INT", "BIGINT", "SMALLINT", "TINYINT",
+  "VARCHAR", "CHAR", "TEXT", "BOOLEAN", "BOOL",
+  "FLOAT", "DOUBLE", "DECIMAL", "NUMERIC", "REAL",
+  "DATE", "TIME", "TIMESTAMP", "DATETIME", "INTERVAL",
+  "JSON", "JSONB", "UUID", "BLOB", "BYTEA",
+];
+
+/** Major clause keywords that start a new line at indent level 0 */
+const MAJOR_CLAUSES = [
+  "WITH", "SELECT", "FROM", "WHERE", "GROUP BY", "HAVING",
+  "ORDER BY", "LIMIT", "OFFSET", "FETCH",
+  "INSERT INTO", "VALUES", "UPDATE", "SET", "DELETE FROM",
+  "UNION", "UNION ALL", "INTERSECT", "EXCEPT",
+  "RETURNING", "ON CONFLICT",
+];
+
+/** Sub-clause keywords that start a new line indented */
+const SUB_CLAUSES = [
+  "INNER JOIN", "LEFT JOIN", "RIGHT JOIN", "FULL JOIN",
+  "LEFT OUTER JOIN", "RIGHT OUTER JOIN", "FULL OUTER JOIN",
+  "CROSS JOIN", "JOIN", "ON", "AND", "OR",
+  "WHEN", "THEN", "ELSE", "END",
+];
+
+type Dialect = "mysql" | "postgresql" | "sqlite" | "generic";
+
+interface FormatOptions {
+  dialect: Dialect;
+  indentSize: number;
+  uppercase: boolean;
+  alignColumns: boolean;
+}
+
+function uppercaseKeywords(sql: string): string {
+  // Sort keywords by length descending so longer multi-word keywords match first
+  const sorted = [...SQL_KEYWORDS].sort((a, b) => b.length - a.length);
+
+  let result = sql;
+  for (const kw of sorted) {
+    // Match keyword as a whole word, case-insensitive, but not inside quotes
+    const escaped = kw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`\\b${escaped}\\b`, "gi");
+    result = replaceOutsideStrings(result, regex, kw);
+  }
+  return result;
+}
+
+function replaceOutsideStrings(
+  sql: string,
+  regex: RegExp,
+  replacement: string
+): string {
+  const segments: string[] = [];
+  let inSingle = false;
+  let inDouble = false;
+  let current = "";
+
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const prev = i > 0 ? sql[i - 1] : "";
+
+    if (ch === "'" && !inDouble && prev !== "\\") {
+      if (!inSingle) {
+        // Leaving non-string zone: process it
+        segments.push(current.replace(regex, replacement));
+        current = ch;
+        inSingle = true;
+      } else {
+        current += ch;
+        segments.push(current);
+        current = "";
+        inSingle = false;
+      }
+      continue;
+    }
+
+    if (ch === '"' && !inSingle && prev !== "\\") {
+      if (!inDouble) {
+        segments.push(current.replace(regex, replacement));
+        current = ch;
+        inDouble = true;
+      } else {
+        current += ch;
+        segments.push(current);
+        current = "";
+        inDouble = false;
+      }
+      continue;
+    }
+
+    current += ch;
+  }
+
+  if (current) {
+    if (inSingle || inDouble) {
+      segments.push(current);
+    } else {
+      segments.push(current.replace(regex, replacement));
+    }
+  }
+
+  return segments.join("");
+}
+
+function formatSql(sql: string, options: FormatOptions): string {
+  // Normalize whitespace
+  let formatted = sql.replace(/\s+/g, " ").trim();
+
+  // Uppercase keywords
+  if (options.uppercase) {
+    formatted = uppercaseKeywords(formatted);
+  }
+
+  const indent = " ".repeat(options.indentSize);
+
+  // Insert newlines before major clauses
+  for (const clause of MAJOR_CLAUSES) {
+    const escaped = clause.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`\\s+${escaped}\\b`, "g");
+    formatted = formatted.replace(regex, `\n${clause}`);
+  }
+
+  // Insert newlines + indent before sub-clauses
+  for (const sub of SUB_CLAUSES) {
+    const escaped = sub.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Don't add newline before ON when it's part of ON CONFLICT
+    if (sub === "ON") {
+      const regex = new RegExp(`\\s+ON\\b(?!\\s+CONFLICT)`, "g");
+      formatted = formatted.replace(regex, `\n${indent}${sub}`);
+    } else {
+      const regex = new RegExp(`\\s+${escaped}\\b`, "g");
+      formatted = formatted.replace(regex, `\n${indent}${sub}`);
+    }
+  }
+
+  // Align SELECT columns: put each column on its own line
+  if (options.alignColumns) {
+    formatted = formatted.replace(
+      /SELECT\s+([\s\S]*?)(?=\nFROM)/gi,
+      (_match, cols: string) => {
+        const columns = splitColumns(cols.trim());
+        if (columns.length > 1) {
+          return (
+            "SELECT\n" +
+            columns.map((c) => `${indent}${c.trim()}`).join(",\n")
+          );
+        }
+        return `SELECT ${cols.trim()}`;
+      }
+    );
+  }
+
+  // Clean up multiple blank lines
+  formatted = formatted.replace(/\n{3,}/g, "\n\n");
+
+  return formatted.trim();
+}
+
+/** Split columns respecting parentheses depth */
+function splitColumns(cols: string): string[] {
+  const result: string[] = [];
+  let depth = 0;
+  let current = "";
+
+  for (const ch of cols) {
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      result.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) result.push(current.trim());
+  return result;
+}
+
+export function sqlFormatter(
+  sql: string,
+  dialect: string = "generic",
+  indentSize: number = 2,
+  uppercase: boolean = true,
+  alignColumns: boolean = true
+): string {
+  const d = (["mysql", "postgresql", "sqlite"].includes(dialect)
+    ? dialect
+    : "generic") as Dialect;
+
+  const options: FormatOptions = {
+    dialect: d,
+    indentSize,
+    uppercase,
+    alignColumns,
+  };
+
+  // Handle multiple statements separated by semicolons
+  const statements = sql
+    .split(";")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  return statements.map((stmt) => formatSql(stmt, options)).join(";\n\n") + ";";
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}