@bytebase/dbhub 1.3.1 → 1.5.0

package/dist/{chunk-YIGJHEU6.js → chunk-X5OCFRNL.js}

@@ -1,6 +1,6 @@
 import {
   hasMutatingKeyword
-} from "./chunk-ABTVMHD6.js";
+} from "./chunk-55X2VY5D.js";
 import {
   blankCommentsAndStrings
 } from "./chunk-IXC4NQGC.js";
@@ -135,20 +135,124 @@ LIMIT ${maxRows}${semicolon}`;
       value: match[1] !== void 0 ? parseInt(match[1], 10) : null
     };
   }
-  /** The statement's own `SELECT TOP n` clause (SQL Server). */
+  /**
+   * The statement's own TOP clause (SQL Server), located on its own SELECT
+   * (after an optional DISTINCT/ALL). `index`/`length` span the `TOP ...`
+   * text only, so it can be spliced without disturbing `SELECT DISTINCT`.
+   *
+   * `value` is the clause's literal row count (`TOP 3`, `TOP (3)`), or null
+   * when that number is not an upper bound on the rows returned: a
+   * parenthesised expression or parameter (`TOP (@p1)`), `PERCENT`, or
+   * `WITH TIES`. Such a TOP cannot simply be tightened; the statement has to
+   * be wrapped and capped from the outside.
+   */
   static findTopLevelTop(sql) {
-    const match = this.findTopLevelMatch(sql, /\(|\)|\bselect\s+top\s+(\d+)/gi, "first", "sqlserver");
+    const match = this.findTopLevelMatch(
+      sql,
+      /\(|\)|\bselect\s+(?:(?:distinct|all)\s+)?(top)\b/gi,
+      "first",
+      "sqlserver"
+    );
     if (match === null) {
       return null;
     }
-    return { index: match.index, length: match[0].length, value: parseInt(match[1], 10) };
+    const blanked = blankCommentsAndStrings(sql, "sqlserver");
+    const index = match.index + match[0].length - match[1].length;
+    let end = match.index + match[0].length;
+    let literal;
+    const operand = /\s*(?:(\()|(\d+)\b)/y;
+    operand.lastIndex = end;
+    const operandMatch = operand.exec(blanked);
+    if (operandMatch === null) {
+      return null;
+    }
+    end = operand.lastIndex;
+    if (operandMatch[1] !== void 0) {
+      const close = this.findClosingParen(blanked, end - 1);
+      if (close === -1) {
+        return null;
+      }
+      const inner = blanked.slice(end, close);
+      literal = /^\s*(\d+)\s*$/.exec(inner)?.[1];
+      end = close + 1;
+    } else {
+      literal = operandMatch[2];
+    }
+    const modifiers = operandMatch[1] !== void 0 ? /(?:\s*percent\b)?(?:\s*with\s+ties\b)?/iy : /(?:\s+percent\b)?(?:\s+with\s+ties\b)?/iy;
+    modifiers.lastIndex = end;
+    const modifierMatch = modifiers.exec(blanked);
+    const unbounded = modifierMatch !== null && modifierMatch[0].length > 0;
+    end = modifiers.lastIndex;
+    return {
+      index,
+      length: end - index,
+      value: literal !== void 0 && !unbounded ? parseInt(literal, 10) : null
+    };
+  }
+  /** Index of the `)` matching the `(` at `openIndex` in blanked SQL, or -1. */
+  static findClosingParen(blankedSQL, openIndex) {
+    let depth = 0;
+    for (let i = openIndex; i < blankedSQL.length; i++) {
+      const ch = blankedSQL[i];
+      if (ch === "(") {
+        depth++;
+      } else if (ch === ")") {
+        depth--;
+        if (depth === 0) {
+          return i;
+        }
+      }
+    }
+    return -1;
   }
   /**
-   * The statement's own SELECT keyword (SQL Server). For a CTE this is the
-   * final SELECT, not the one inside a CTE body.
+   * The statement's own SELECT keyword (SQL Server), together with a
+   * DISTINCT/ALL that follows it: T-SQL places TOP after those
+   * (`SELECT DISTINCT TOP n`), so that is where a TOP gets inserted. For a
+   * CTE this is the final SELECT, not the one inside a CTE body.
    */
   static findTopLevelSelect(sql) {
-    return this.findTopLevelMatch(sql, /\(|\)|\bselect\b/gi, "first", "sqlserver");
+    return this.findTopLevelMatch(sql, /\(|\)|\bselect\b(?:\s+(?:distinct|all)\b)?/gi, "first", "sqlserver");
+  }
+  /**
+   * The statement's own `OFFSET ... ROWS [FETCH NEXT n ROWS ONLY]` clause
+   * (SQL Server). T-SQL forbids TOP in a query that has OFFSET, so such a
+   * statement is capped through its FETCH count instead.
+   *
+   * `fetch` is the FETCH count (null when the clause has no FETCH);
+   * `fetchInsertIndex` is where a FETCH can be appended, or -1 when the
+   * OFFSET clause has a shape this scanner does not parse (an arithmetic
+   * expression, say), in which case the statement is wrapped.
+   */
+  static findTopLevelOffset(sql) {
+    const offset = this.findTopLevelMatch(sql, /\(|\)|\boffset\b/gi, "first", "sqlserver");
+    if (offset === null) {
+      return null;
+    }
+    const blanked = blankCommentsAndStrings(sql, "sqlserver");
+    const clause = /(offset\s+(?:\d+|@\w+|\?)\s+rows?\b)(?:(\s+fetch\s+(?:first|next)\s+)((\d+)|@\w+|\?)\s+rows?\s+only\b)?/iy;
+    clause.lastIndex = offset.index;
+    const match = clause.exec(blanked);
+    if (match === null) {
+      return { fetch: null, fetchInsertIndex: -1 };
+    }
+    if (match[2] === void 0) {
+      const end = match.index + match[0].length;
+      const unparsedFetch = /\s*fetch\b/iy;
+      unparsedFetch.lastIndex = end;
+      if (unparsedFetch.test(blanked)) {
+        return { fetch: null, fetchInsertIndex: -1 };
+      }
+      return { fetch: null, fetchInsertIndex: end };
+    }
+    return {
+      fetch: {
+        index: match.index + match[1].length + match[2].length,
+        length: match[3].length,
+        value: match[4] !== void 0 ? parseInt(match[4], 10) : null
+      },
+      fetchInsertIndex: -1
+    };
   }
   /**
    * Check if a SQL statement combines multiple SELECTs with a set operator
@@ -170,31 +274,72 @@ LIMIT ${maxRows}${semicolon}`;
    * Add or modify TOP clause in a SQL statement (SQL Server)
    */
   static applyTopToQuery(sql, maxRows) {
-    if (this.hasSetOperator(sql)) {
-      const { sql: sqlWithoutSemicolon, semicolon } = trimSemicolon(sql);
-      const cteIndex = this.findTopLevelSelect(sqlWithoutSemicolon)?.index ?? 0;
-      const ctePrefix = sqlWithoutSemicolon.slice(0, cteIndex);
-      const body = sqlWithoutSemicolon.slice(cteIndex);
-      const orderByIndex = this.findTopLevelOrderByIndex(body);
-      if (orderByIndex !== -1) {
-        const innerSql = body.slice(0, orderByIndex).trimEnd();
-        const orderByClause = body.slice(orderByIndex).trim();
-        return `${ctePrefix}SELECT TOP ${maxRows} * FROM (${innerSql}
-) AS subq ${orderByClause}${semicolon}`;
+    const offset = this.findTopLevelOffset(sql);
+    if (offset !== null) {
+      if (offset.fetch !== null && offset.fetch.value !== null) {
+        const effectiveFetch = Math.min(offset.fetch.value, maxRows);
+        return `${sql.slice(0, offset.fetch.index)}${effectiveFetch}${sql.slice(offset.fetch.index + offset.fetch.length)}`;
+      }
+      if (offset.fetch === null && offset.fetchInsertIndex !== -1) {
+        return `${sql.slice(0, offset.fetchInsertIndex)} FETCH NEXT ${maxRows} ROWS ONLY${sql.slice(offset.fetchInsertIndex)}`;
       }
-      return `${ctePrefix}SELECT TOP ${maxRows} * FROM (${body}
-) AS subq${semicolon}`;
+      return this.wrapWithTop(sql, maxRows, false);
+    }
+    if (this.hasSetOperator(sql)) {
+      return this.wrapWithTop(sql, maxRows, true);
     }
     const existingTop = this.findTopLevelTop(sql);
     if (existingTop !== null) {
+      if (existingTop.value === null) {
+        return this.wrapWithTop(sql, maxRows, false);
+      }
       const effectiveTop = Math.min(existingTop.value, maxRows);
-      return `${sql.slice(0, existingTop.index)}SELECT TOP ${effectiveTop}${sql.slice(existingTop.index + existingTop.length)}`;
+      return `${sql.slice(0, existingTop.index)}TOP ${effectiveTop}${sql.slice(existingTop.index + existingTop.length)}`;
     }
     const selectMatch = this.findTopLevelSelect(sql);
     if (selectMatch === null) {
       return sql;
     }
-    return `${sql.slice(0, selectMatch.index)}SELECT TOP ${maxRows}${sql.slice(selectMatch.index + selectMatch[0].length)}`;
+    const insertAt = selectMatch.index + selectMatch[0].length;
+    return `${sql.slice(0, insertAt)} TOP ${maxRows}${sql.slice(insertAt)}`;
+  }
+  /**
+   * Cap a statement from the outside: `SELECT TOP n * FROM (<body>) AS subq`.
+   *
+   * A leading CTE stays outside the derived table: T-SQL has no
+   * `SELECT ... FROM (WITH ...) AS subq` form, but a CTE declared before the
+   * SELECT is still in scope inside that derived table.
+   *
+   * T-SQL disallows ORDER BY inside a derived table unless that derived table
+   * itself has TOP/OFFSET/FOR XML. With `hoistOrderBy` a top-level trailing
+   * ORDER BY moves outside the wrap (the set-operator case, where no TOP
+   * belongs to the body as a whole); without it the ORDER BY stays inside,
+   * which callers use when the body's own TOP/OFFSET both legalises it and
+   * depends on it.
+   */
+  static wrapWithTop(sql, maxRows, hoistOrderBy) {
+    const { sql: sqlWithoutSemicolon, semicolon } = trimSemicolon(sql);
+    const cteIndex = this.findTopLevelSelect(sqlWithoutSemicolon)?.index ?? 0;
+    const ctePrefix = sqlWithoutSemicolon.slice(0, cteIndex);
+    let body = sqlWithoutSemicolon.slice(cteIndex);
+    const optionIndex = this.findTopLevelOptionIndex(body);
+    const optionClause = optionIndex === -1 ? "" : ` ${body.slice(optionIndex).trim()}`;
+    if (optionIndex !== -1) {
+      body = body.slice(0, optionIndex).trimEnd();
+    }
+    const orderByIndex = hoistOrderBy ? this.findTopLevelOrderByIndex(body) : -1;
+    if (orderByIndex !== -1) {
+      const innerSql = body.slice(0, orderByIndex).trimEnd();
+      const orderByClause = body.slice(orderByIndex).trim();
+      return `${ctePrefix}SELECT TOP ${maxRows} * FROM (${innerSql}
+) AS subq ${orderByClause}${optionClause}${semicolon}`;
+    }
+    return `${ctePrefix}SELECT TOP ${maxRows} * FROM (${body}
+) AS subq${optionClause}${semicolon}`;
+  }
+  /** Start index of the statement's own trailing `OPTION (...)` query hint, or -1. */
+  static findTopLevelOptionIndex(sql) {
+    return this.findTopLevelMatch(sql, /\(|\)|\boption\s*(?=\()/gi, "last", "sqlserver")?.index ?? -1;
   }
   /**
    * Apply maxRows limit to a row-returning query only
@@ -301,11 +446,9 @@ LIMIT ${maxRows}${semicolon}`;
     if (!maxRows || !this.isSelectQuery(sql, "sqlserver")) {
       return { sql, probeApplied: false };
     }
-    if (!this.hasSetOperator(sql)) {
-      const existingTop = this.extractTopValue(sql);
-      if (existingTop !== null && existingTop <= maxRows) {
-        return { sql, probeApplied: false };
-      }
+    const ownCap = this.findTopLevelOffset(sql)?.fetch?.value ?? (this.hasSetOperator(sql) ? null : this.extractTopValue(sql));
+    if (ownCap !== null && ownCap <= maxRows) {
+      return { sql, probeApplied: false };
     }
     return { sql: this.applyMaxRowsForSQLServer(sql, maxRows + 1), probeApplied: true };
   }

package/dist/index.js

@@ -5,6 +5,7 @@ import {
   BUILTIN_TOOL_HEALTH_CHECK,
   BUILTIN_TOOL_SEARCH_OBJECTS,
   ConnectorManager,
+  ToolRegistry,
   classifyConnectionError,
   getToolRegistry,
   initializeToolRegistry,
@@ -18,10 +19,11 @@ import {
   resolveSourceConfigs,
   resolveTomlConfigPath,
   resolveTransport
-} from "./chunk-5FL4XMWG.js";
+} from "./chunk-PDKPK25P.js";
 import {
   loadConnectors
 } from "./chunk-WVVMH6FJ.js";
+import "./chunk-5XSBOK3W.js";
 import {
   quoteQualifiedIdentifier
 } from "./chunk-X2EC47W4.js";
@@ -31,7 +33,7 @@ import {
   hasEscapeHatchFunction,
   isReadOnlySQL,
   sqlServerDynamicSqlPattern
-} from "./chunk-ABTVMHD6.js";
+} from "./chunk-55X2VY5D.js";
 import {
   ConnectorRegistry,
   getDatabaseTypeFromDSN,
@@ -1633,6 +1635,78 @@ function buildSourceDisplayInfo(sourceConfigs, getToolsForSource2, isDemo) {
 // src/utils/config-watcher.ts
 import fs from "fs";
 var DEBOUNCE_MS = 500;
+function sourceConfigEquals(a, b) {
+  return stableStringify(a) === stableStringify(b);
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([x], [y]) => x < y ? -1 : x > y ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function selectTools(applied, rolledBack, newTools, oldTools) {
+  if (newTools === void 0 && oldTools === void 0) {
+    return void 0;
+  }
+  const liveIds = new Set(applied.map((s) => s.id));
+  return [
+    ...(newTools ?? []).filter((t) => liveIds.has(t.source) && !rolledBack.has(t.source)),
+    ...(oldTools ?? []).filter((t) => rolledBack.has(t.source))
+  ];
+}
+async function applySourceDiff(connectorManager, oldSources, newSources) {
+  const oldById = new Map(oldSources.map((s) => [s.id, s]));
+  const newById = new Map(newSources.map((s) => [s.id, s]));
+  const applied = /* @__PURE__ */ new Map();
+  const rolledBack = /* @__PURE__ */ new Set();
+  for (const oldSource of oldSources) {
+    const newSource = newById.get(oldSource.id);
+    if (!newSource) {
+      console.error(`Config reload: removing source '${oldSource.id}'`);
+      await connectorManager.removeSource(oldSource.id);
+    } else if (sourceConfigEquals(oldSource, newSource)) {
+      applied.set(oldSource.id, oldSource);
+    }
+  }
+  for (const newSource of newSources) {
+    if (applied.has(newSource.id)) {
+      continue;
+    }
+    const oldSource = oldById.get(newSource.id);
+    if (oldSource) {
+      console.error(`Config reload: reconnecting changed source '${newSource.id}'`);
+      await connectorManager.removeSource(newSource.id);
+    } else {
+      console.error(`Config reload: adding source '${newSource.id}'`);
+    }
+    try {
+      await connectorManager.addSource(newSource);
+      applied.set(newSource.id, newSource);
+    } catch (error) {
+      console.error(`Config reload: failed to connect source '${newSource.id}':`, error);
+      if (oldSource) {
+        try {
+          await connectorManager.addSource(oldSource);
+          applied.set(oldSource.id, oldSource);
+          rolledBack.add(oldSource.id);
+          console.error(`Config reload: rolled back source '${oldSource.id}' to its previous config.`);
+        } catch (rollbackError) {
+          console.error(`Config reload: rollback of source '${oldSource.id}' also failed:`, rollbackError);
+        }
+      }
+    }
+  }
+  const order = newSources.map((s) => s.id);
+  connectorManager.reorderSources(order);
+  return {
+    sources: order.filter((id) => applied.has(id)).map((id) => applied.get(id)),
+    rolledBack
+  };
+}
 function startConfigWatcher(options) {
   const { connectorManager, initialTools } = options;
   const configPath = resolveTomlConfigPath();
@@ -1665,34 +1739,44 @@ Detected change in ${configPath}, reloading configuration...`);
         console.error("Config reload: failed to load TOML config, keeping existing connections.");
         return;
       }
-      const oldSources = lastGoodSources;
-      const oldTools = lastGoodTools;
-      await connectorManager.disconnect();
+      new ToolRegistry({ sources: newConfig.sources, tools: newConfig.tools });
+      const { sources: applied, rolledBack } = await applySourceDiff(
+        connectorManager,
+        lastGoodSources,
+        newConfig.sources
+      );
+      lastGoodSources = applied;
+      let live = applied;
+      let tools = selectTools(applied, rolledBack, newConfig.tools, lastGoodTools);
       try {
-        await connectorManager.connectWithSources(newConfig.sources);
-        initializeToolRegistry({
-          sources: newConfig.sources,
-          tools: newConfig.tools
-        });
-        lastGoodSources = newConfig.sources;
-        lastGoodTools = newConfig.tools;
-        console.error("Configuration reloaded successfully.");
-      } catch (connectError) {
-        console.error("Failed to connect with new config, rolling back:", connectError);
-        try {
-          await connectorManager.disconnect();
-        } catch {
+        initializeToolRegistry({ sources: live, tools });
+      } catch (error) {
+        if (rolledBack.size === 0) {
+          throw error;
         }
-        try {
-          await connectorManager.connectWithSources(oldSources);
-          initializeToolRegistry({ sources: oldSources, tools: oldTools });
-          console.error("Rolled back to previous configuration.");
-        } catch (rollbackError) {
-          console.error("Rollback also failed, server has no active connections:", rollbackError);
+        console.error(
+          `Config reload: previous tools of rolled-back source(s) ${[...rolledBack].join(", ")} conflict with the new configuration; taking them offline:`,
+          error
+        );
+        for (const id of rolledBack) {
+          await connectorManager.removeSource(id);
         }
+        live = applied.filter((s) => !rolledBack.has(s.id));
+        lastGoodSources = live;
+        tools = selectTools(live, /* @__PURE__ */ new Set(), newConfig.tools, void 0);
+        initializeToolRegistry({ sources: live, tools });
+      }
+      lastGoodTools = tools;
+      const unavailable = newConfig.sources.length - live.length;
+      if (unavailable === 0 && rolledBack.size === 0) {
+        console.error("Configuration reloaded successfully.");
+      } else {
+        console.error(
+          `Configuration reloaded with ${unavailable} source(s) unavailable and ${rolledBack.size} source(s) rolled back to their previous configuration.`
+        );
       }
     } catch (error) {
-      console.error("Config reload failed, keeping existing connections:", error);
+      console.error("Config reload failed:", error);
     } finally {
       isReloading = false;
       if (reloadPending) {
@@ -1913,7 +1997,7 @@ See documentation for more details on configuring database connections.
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
     await connectorManager.connectWithSources(sources);
-    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-ZTHDPLKP.js");
+    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-ZIVIYCB2.js");
     initializeToolRegistry2({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -2068,12 +2152,12 @@ See documentation for more details on configuring database connections.
 
 // src/index.ts
 var connectorModules = [
-  { load: () => import("./postgres-6XJ7V4J4.js"), name: "PostgreSQL", driver: "pg" },
-  { load: () => import("./sqlserver-AJUK6L55.js"), name: "SQL Server", driver: "mssql" },
-  { load: () => import("./sqlite-AO2BKIC6.js"), name: "SQLite", driver: "node:sqlite" },
-  { load: () => import("./mysql-XXIHWQGR.js"), name: "MySQL", driver: "mysql2" },
-  { load: () => import("./mariadb-L7Z55ROY.js"), name: "MariaDB", driver: "mariadb" },
-  { load: () => import("./oracle-OUKBU52X.js"), name: "Oracle", driver: "oracledb" }
+  { load: () => import("./postgres-KCFNDQLG.js"), name: "PostgreSQL", driver: "pg" },
+  { load: () => import("./sqlserver-25MAE77Q.js"), name: "SQL Server", driver: "mssql" },
+  { load: () => import("./sqlite-WKY6543Q.js"), name: "SQLite", driver: "node:sqlite" },
+  { load: () => import("./mysql-ZXO4TWLG.js"), name: "MySQL", driver: "mysql2" },
+  { load: () => import("./mariadb-RWOMZTA6.js"), name: "MariaDB", driver: "mariadb" },
+  { load: () => import("./oracle-UAVN3F4U.js"), name: "Oracle", driver: "oracledb" }
 ];
 loadConnectors(connectorModules).then(() => main()).catch((error) => {
   console.error("Fatal error:", error);