@bytebase/dbhub 0.16.0 → 0.17.0

package/dist/{chunk-IBBG4PSO.js → chunk-YKDZH7G5.js}

@@ -1339,6 +1339,18 @@ function validateSourceConfig(source, configPath) {
       );
     }
   }
+  if (source.search_path !== void 0) {
+    if (source.type !== "postgres") {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has 'search_path' but it is only supported for PostgreSQL sources.`
+      );
+    }
+    if (typeof source.search_path !== "string" || source.search_path.trim().length === 0) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has invalid search_path. Must be a non-empty string of comma-separated schema names (e.g., "myschema,public").`
+      );
+    }
+  }
   if (source.readonly !== void 0) {
     throw new Error(
       `Configuration file ${configPath}: source '${source.id}' has 'readonly' field, but readonly must be configured per-tool, not per-source. Move 'readonly' to [[tools]] configuration instead.`
@@ -1606,6 +1618,9 @@ var ConnectorManager = class {
     if (source.readonly !== void 0) {
       config.readonly = source.readonly;
     }
+    if (source.search_path) {
+      config.searchPath = source.search_path;
+    }
     await connector.connect(actualDSN, source.init_script, config);
     this.connectors.set(sourceId, connector);
     if (!this.sourceIds.includes(sourceId)) {

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   resolveSourceConfigs,
   resolveTransport,
   stripCommentsAndStrings
-} from "./chunk-IBBG4PSO.js";
+} from "./chunk-YKDZH7G5.js";
 
 // src/connectors/postgres/index.ts
 import pg from "pg";
@@ -141,6 +141,36 @@ var SQLRowLimiter = class {
   }
 };
 
+// src/utils/identifier-quoter.ts
+function quoteIdentifier(identifier, dbType) {
+  if (/[\0\x08\x09\x1a\n\r]/.test(identifier)) {
+    throw new Error(`Invalid identifier: contains control characters: ${identifier}`);
+  }
+  if (!identifier) {
+    throw new Error("Identifier cannot be empty");
+  }
+  switch (dbType) {
+    case "postgres":
+    case "sqlite":
+      return `"${identifier.replace(/"/g, '""')}"`;
+    case "mysql":
+    case "mariadb":
+      return `\`${identifier.replace(/`/g, "``")}\``;
+    case "sqlserver":
+      return `[${identifier.replace(/]/g, "]]")}]`;
+    default:
+      return `"${identifier.replace(/"/g, '""')}"`;
+  }
+}
+function quoteQualifiedIdentifier(tableName, schemaName, dbType) {
+  const quotedTable = quoteIdentifier(tableName, dbType);
+  if (schemaName) {
+    const quotedSchema = quoteIdentifier(schemaName, dbType);
+    return `${quotedSchema}.${quotedTable}`;
+  }
+  return quotedTable;
+}
+
 // src/connectors/postgres/index.ts
 var { Pool } = pg;
 var PostgresDSNParser = class {
@@ -209,6 +239,8 @@ var PostgresConnector = class _PostgresConnector {
     this.pool = null;
     // Source ID is set by ConnectorManager after cloning
     this.sourceId = "default";
+    // Default schema for discovery methods (first entry from search_path, or "public")
+    this.defaultSchema = "public";
   }
   getId() {
     return this.sourceId;
@@ -217,11 +249,21 @@ var PostgresConnector = class _PostgresConnector {
     return new _PostgresConnector();
   }
   async connect(dsn, initScript, config) {
+    this.defaultSchema = "public";
     try {
       const poolConfig = await this.dsnParser.parse(dsn, config);
       if (config?.readonly) {
         poolConfig.options = (poolConfig.options || "") + " -c default_transaction_read_only=on";
       }
+      if (config?.searchPath) {
+        const schemas = config.searchPath.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        if (schemas.length > 0) {
+          this.defaultSchema = schemas[0];
+          const quotedSchemas = schemas.map((s) => quoteIdentifier(s, "postgres"));
+          const optionsValue = quotedSchemas.join(",").replace(/\\/g, "\\\\").replace(/ /g, "\\ ");
+          poolConfig.options = (poolConfig.options || "") + ` -c search_path=${optionsValue}`;
+        }
+      }
       this.pool = new Pool(poolConfig);
       const client = await this.pool.connect();
       client.release();
@@ -259,7 +301,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT table_name 
@@ -280,7 +322,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT EXISTS (
@@ -302,7 +344,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT 
@@ -350,18 +392,27 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
-        SELECT 
-          column_name, 
-          data_type, 
-          is_nullable,
-          column_default
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        ORDER BY ordinal_position
+        SELECT
+          c.column_name,
+          c.data_type,
+          c.is_nullable,
+          c.column_default,
+          pgd.description
+        FROM information_schema.columns c
+        LEFT JOIN pg_catalog.pg_namespace nsp
+          ON nsp.nspname = c.table_schema
+        LEFT JOIN pg_catalog.pg_class cls
+          ON cls.relnamespace = nsp.oid
+          AND cls.relname = c.table_name
+        LEFT JOIN pg_catalog.pg_description pgd
+          ON pgd.objoid = cls.oid
+          AND pgd.objsubid = c.ordinal_position
+        WHERE c.table_schema = $1
+        AND c.table_name = $2
+        ORDER BY c.ordinal_position
       `,
         [schemaToUse, tableName]
       );
@@ -370,22 +421,82 @@ var PostgresConnector = class _PostgresConnector {
       client.release();
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableRowCount(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
-        SELECT 
+        SELECT c.reltuples::bigint as count
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1
+        AND n.nspname = $2
+        AND c.relkind IN ('r','p','m','f')
+      `,
+        [tableName, schemaToUse]
+      );
+      if (result.rows.length > 0) {
+        const count = Number(result.rows[0].count);
+        return count >= 0 ? count : null;
+      }
+      return null;
+    } finally {
+      client.release();
+    }
+  }
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT obj_description(c.oid) as table_comment
+        FROM pg_catalog.pg_class c
+        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1
+        AND n.nspname = $2
+        AND c.relkind IN ('r','p','m','f')
+      `,
+        [tableName, schemaToUse]
+      );
+      if (result.rows.length > 0) {
+        return result.rows[0].table_comment || null;
+      }
+      return null;
+    } finally {
+      client.release();
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const params = [schemaToUse];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND routine_type = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND routine_type = 'PROCEDURE'";
+      }
+      const result = await client.query(
+        `
+        SELECT
           routine_name
         FROM information_schema.routines
-        WHERE routine_schema = $1
+        WHERE routine_schema = $1${typeFilter}
         ORDER BY routine_name
       `,
-        [schemaToUse]
+        params
       );
       return result.rows.map((row) => row.routine_name);
     } finally {
@@ -398,7 +509,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT 
@@ -789,33 +900,78 @@ var SQLServerConnector = class _SQLServerConnector {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
       const query = `
-          SELECT COLUMN_NAME as    column_name,
-                 DATA_TYPE as      data_type,
-                 IS_NULLABLE as    is_nullable,
-                 COLUMN_DEFAULT as column_default
-          FROM INFORMATION_SCHEMA.COLUMNS
-          WHERE TABLE_NAME = @tableName
-            AND TABLE_SCHEMA = @schema
-          ORDER BY ORDINAL_POSITION
+          SELECT c.COLUMN_NAME as    column_name,
+                 c.DATA_TYPE as      data_type,
+                 c.IS_NULLABLE as    is_nullable,
+                 c.COLUMN_DEFAULT as column_default,
+                 ep.value as         description
+          FROM INFORMATION_SCHEMA.COLUMNS c
+          LEFT JOIN sys.columns sc
+            ON sc.name = c.COLUMN_NAME
+            AND sc.object_id = OBJECT_ID(QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME))
+          LEFT JOIN sys.extended_properties ep
+            ON ep.major_id = sc.object_id
+            AND ep.minor_id = sc.column_id
+            AND ep.name = 'MS_Description'
+          WHERE c.TABLE_NAME = @tableName
+            AND c.TABLE_SCHEMA = @schema
+          ORDER BY c.ORDINAL_POSITION
       `;
       const result = await request.query(query);
-      return result.recordset;
+      return result.recordset.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
     } catch (error) {
       throw new Error(`Failed to get schema for table ${tableName}: ${error.message}`);
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableComment(tableName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT ep.value as table_comment
+          FROM sys.extended_properties ep
+          JOIN sys.tables t ON ep.major_id = t.object_id
+          JOIN sys.schemas s ON t.schema_id = s.schema_id
+          WHERE ep.minor_id = 0
+            AND ep.name = 'MS_Description'
+            AND t.name = @tableName
+            AND s.name = @schema
+      `;
+      const result = await request.query(query);
+      if (result.recordset.length > 0) {
+        return result.recordset[0].table_comment || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
+      let typeFilter;
+      if (routineType === "function") {
+        typeFilter = "AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = "AND ROUTINE_TYPE = 'PROCEDURE'";
+      } else {
+        typeFilter = "AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')";
+      }
       const query = `
           SELECT ROUTINE_NAME
           FROM INFORMATION_SCHEMA.ROUTINES
           WHERE ROUTINE_SCHEMA = @schema
-            AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')
+            ${typeFilter}
           ORDER BY ROUTINE_NAME
       `;
       const result = await request.query(query);
@@ -948,38 +1104,6 @@ ConnectorRegistry.register(sqlServerConnector);
 
 // src/connectors/sqlite/index.ts
 import Database from "better-sqlite3";
-
-// src/utils/identifier-quoter.ts
-function quoteIdentifier(identifier, dbType) {
-  if (/[\0\x08\x09\x1a\n\r]/.test(identifier)) {
-    throw new Error(`Invalid identifier: contains control characters: ${identifier}`);
-  }
-  if (!identifier) {
-    throw new Error("Identifier cannot be empty");
-  }
-  switch (dbType) {
-    case "postgres":
-    case "sqlite":
-      return `"${identifier.replace(/"/g, '""')}"`;
-    case "mysql":
-    case "mariadb":
-      return `\`${identifier.replace(/`/g, "``")}\``;
-    case "sqlserver":
-      return `[${identifier.replace(/]/g, "]]")}]`;
-    default:
-      return `"${identifier.replace(/"/g, '""')}"`;
-  }
-}
-function quoteQualifiedIdentifier(tableName, schemaName, dbType) {
-  const quotedTable = quoteIdentifier(tableName, dbType);
-  if (schemaName) {
-    const quotedSchema = quoteIdentifier(schemaName, dbType);
-    return `${quotedSchema}.${quotedTable}`;
-  }
-  return quotedTable;
-}
-
-// src/connectors/sqlite/index.ts
 var SQLiteDSNParser = class {
   async parse(dsn, config) {
     if (!this.isValidDSN(dsn)) {
@@ -1181,14 +1305,15 @@ var SQLiteConnector = class _SQLiteConnector {
         data_type: row.type,
         // In SQLite, primary key columns are automatically NOT NULL even if notnull=0
         is_nullable: row.notnull === 1 || row.pk > 0 ? "NO" : "YES",
-        column_default: row.dflt_value
+        column_default: row.dflt_value,
+        description: null
       }));
       return columns;
     } catch (error) {
       throw error;
     }
   }
-  async getStoredProcedures(schema) {
+  async getStoredProcedures(schema, routineType) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
@@ -1566,11 +1691,12 @@ var MySQLConnector = class _MySQLConnector {
       const queryParams = schema ? [schema, tableName] : [tableName];
       const [rows] = await this.pool.query(
         `
-        SELECT 
-          COLUMN_NAME as column_name, 
-          DATA_TYPE as data_type, 
+        SELECT
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
           IS_NULLABLE as is_nullable,
-          COLUMN_DEFAULT as column_default
+          COLUMN_DEFAULT as column_default,
+          COLUMN_COMMENT as description
         FROM INFORMATION_SCHEMA.COLUMNS
         ${schemaClause}
         AND TABLE_NAME = ?
@@ -1578,24 +1704,57 @@ var MySQLConnector = class _MySQLConnector {
       `,
         queryParams
       );
-      return rows;
+      return rows.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
     } catch (error) {
       console.error("Error getting table schema:", error);
       throw error;
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [rows] = await this.pool.query(
+        `
+        SELECT TABLE_COMMENT
+        FROM INFORMATION_SCHEMA.TABLES
+        ${schemaClause}
+        AND TABLE_NAME = ?
+      `,
+        queryParams
+      );
+      if (rows.length > 0) {
+        return rows[0].TABLE_COMMENT || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
       const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema] : [];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND ROUTINE_TYPE = 'PROCEDURE'";
+      }
       const [rows] = await this.pool.query(
         `
         SELECT ROUTINE_NAME
         FROM INFORMATION_SCHEMA.ROUTINES
-        ${schemaClause}
+        ${schemaClause}${typeFilter}
         ORDER BY ROUTINE_NAME
       `,
         queryParams
@@ -1757,7 +1916,7 @@ var mysqlConnector = new MySQLConnector();
 ConnectorRegistry.register(mysqlConnector);
 
 // src/connectors/mariadb/index.ts
-import mariadb from "mariadb";
+import * as mariadb from "mariadb";
 var MariadbDSNParser = class {
   async parse(dsn, config) {
     const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
@@ -1979,11 +2138,12 @@ var MariaDBConnector = class _MariaDBConnector {
       const queryParams = schema ? [schema, tableName] : [tableName];
       const rows = await this.pool.query(
         `
-        SELECT 
-          COLUMN_NAME as column_name, 
-          DATA_TYPE as data_type, 
+        SELECT
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
           IS_NULLABLE as is_nullable,
-          COLUMN_DEFAULT as column_default
+          COLUMN_DEFAULT as column_default,
+          COLUMN_COMMENT as description
         FROM INFORMATION_SCHEMA.COLUMNS
         ${schemaClause}
         AND TABLE_NAME = ?
@@ -1991,24 +2151,57 @@ var MariaDBConnector = class _MariaDBConnector {
       `,
         queryParams
       );
-      return rows;
+      return rows.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
     } catch (error) {
       console.error("Error getting table schema:", error);
       throw error;
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const rows = await this.pool.query(
+        `
+        SELECT TABLE_COMMENT
+        FROM INFORMATION_SCHEMA.TABLES
+        ${schemaClause}
+        AND TABLE_NAME = ?
+      `,
+        queryParams
+      );
+      if (rows.length > 0) {
+        return rows[0].TABLE_COMMENT || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
       const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema] : [];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND ROUTINE_TYPE = 'PROCEDURE'";
+      }
       const rows = await this.pool.query(
         `
         SELECT ROUTINE_NAME
         FROM INFORMATION_SCHEMA.ROUTINES
-        ${schemaClause}
+        ${schemaClause}${typeFilter}
         ORDER BY ROUTINE_NAME
       `,
         queryParams
@@ -2389,7 +2582,7 @@ function createExecuteSqlToolHandler(sourceId) {
 // src/tools/search-objects.ts
 import { z as z2 } from "zod";
 var searchDatabaseObjectsSchema = {
-  object_type: z2.enum(["schema", "table", "column", "procedure", "index"]).describe("Object type to search"),
+  object_type: z2.enum(["schema", "table", "column", "procedure", "function", "index"]).describe("Object type to search"),
   pattern: z2.string().optional().default("%").describe("LIKE pattern (% = any chars, _ = one char). Default: %"),
   schema: z2.string().optional().describe("Filter to schema"),
   table: z2.string().optional().describe("Filter to table (requires schema; column/index only)"),
@@ -2402,6 +2595,9 @@ function likePatternToRegex(pattern) {
 }
 async function getTableRowCount(connector, tableName, schemaName) {
   try {
+    if (connector.getTableRowCount) {
+      return await connector.getTableRowCount(tableName, schemaName);
+    }
     const qualifiedTable = quoteQualifiedIdentifier(tableName, schemaName, connector.id);
     const countQuery = `SELECT COUNT(*) as count FROM ${qualifiedTable}`;
     const result = await connector.executeSQL(countQuery, { maxRows: 1 });
@@ -2413,6 +2609,16 @@ async function getTableRowCount(connector, tableName, schemaName) {
   }
   return null;
 }
+async function getTableComment(connector, tableName, schemaName) {
+  try {
+    if (connector.getTableComment) {
+      return await connector.getTableComment(tableName, schemaName);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
 async function searchSchemas(connector, pattern, detailLevel, limit) {
   const schemas = await connector.getSchemas();
   const regex = likePatternToRegex(pattern);
@@ -2463,11 +2669,13 @@ async function searchTables(connector, pattern, schemaFilter, detailLevel, limit
           try {
             const columns = await connector.getTableSchema(tableName, schemaName);
             const rowCount = await getTableRowCount(connector, tableName, schemaName);
+            const comment = await getTableComment(connector, tableName, schemaName);
             results.push({
               name: tableName,
               schema: schemaName,
               column_count: columns.length,
-              row_count: rowCount
+              row_count: rowCount,
+              ...comment ? { comment } : {}
             });
           } catch (error) {
             results.push({
@@ -2482,16 +2690,19 @@ async function searchTables(connector, pattern, schemaFilter, detailLevel, limit
             const columns = await connector.getTableSchema(tableName, schemaName);
             const indexes = await connector.getTableIndexes(tableName, schemaName);
             const rowCount = await getTableRowCount(connector, tableName, schemaName);
+            const comment = await getTableComment(connector, tableName, schemaName);
             results.push({
               name: tableName,
               schema: schemaName,
               column_count: columns.length,
               row_count: rowCount,
+              ...comment ? { comment } : {},
               columns: columns.map((col) => ({
                 name: col.column_name,
                 type: col.data_type,
                 nullable: col.is_nullable === "YES",
-                default: col.column_default
+                default: col.column_default,
+                ...col.description ? { description: col.description } : {}
               })),
               indexes: indexes.map((idx) => ({
                 name: idx.index_name,
@@ -2553,7 +2764,8 @@ async function searchColumns(connector, pattern, schemaFilter, tableFilter, deta
                 schema: schemaName,
                 type: column.data_type,
                 nullable: column.is_nullable === "YES",
-                default: column.column_default
+                default: column.column_default,
+                ...column.description ? { description: column.description } : {}
               });
             }
           }
@@ -2567,7 +2779,7 @@ async function searchColumns(connector, pattern, schemaFilter, tableFilter, deta
   }
   return results;
 }
-async function searchProcedures(connector, pattern, schemaFilter, detailLevel, limit) {
+async function searchProcedures(connector, pattern, schemaFilter, detailLevel, limit, routineType) {
   const regex = likePatternToRegex(pattern);
   const results = [];
   let schemasToSearch;
@@ -2579,7 +2791,7 @@ async function searchProcedures(connector, pattern, schemaFilter, detailLevel, l
   for (const schemaName of schemasToSearch) {
     if (results.length >= limit) break;
     try {
-      const procedures = await connector.getStoredProcedures(schemaName);
+      const procedures = await connector.getStoredProcedures(schemaName, routineType);
       const matched = procedures.filter((proc) => regex.test(proc));
       for (const procName of matched) {
         if (results.length >= limit) break;
@@ -2716,7 +2928,10 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
           results = await searchColumns(connector, pattern, schema, table, detail_level, limit);
           break;
         case "procedure":
-          results = await searchProcedures(connector, pattern, schema, detail_level, limit);
+          results = await searchProcedures(connector, pattern, schema, detail_level, limit, "procedure");
+          break;
+        case "function":
+          results = await searchProcedures(connector, pattern, schema, detail_level, limit, "function");
           break;
         case "index":
           results = await searchIndexes(connector, pattern, schema, table, detail_level, limit);
@@ -2836,7 +3051,7 @@ function getSearchObjectsMetadata(sourceId) {
   const isSingleSource = sourceIds.length === 1;
   const toolName = isSingleSource ? "search_objects" : `search_objects_${normalizeSourceId(sourceId)}`;
   const title = isSingleSource ? `Search Database Objects (${dbType})` : `Search Database Objects on ${sourceId} (${dbType})`;
-  const description = isSingleSource ? `Search and list database objects (schemas, tables, columns, procedures, indexes) on the ${dbType} database` : `Search and list database objects (schemas, tables, columns, procedures, indexes) on the '${sourceId}' ${dbType} database`;
+  const description = isSingleSource ? `Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the ${dbType} database` : `Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the '${sourceId}' ${dbType} database`;
   return {
     name: toolName,
     description,
@@ -3392,7 +3607,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 } = await import("./registry-D77Y4CIA.js");
+    const { initializeToolRegistry } = await import("./registry-7HJVUJCM.js");
     initializeToolRegistry({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -3430,9 +3645,6 @@ See documentation for more details on configuring database connections.
       app.use(express.json());
       app.use((req, res, next) => {
         const origin = req.headers.origin;
-        if (origin && !origin.startsWith("http://localhost") && !origin.startsWith("https://localhost")) {
-          return res.status(403).json({ error: "Forbidden origin" });
-        }
         res.header("Access-Control-Allow-Origin", origin || "http://localhost");
         res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
         res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");

package/dist/{registry-D77Y4CIA.js → registry-7HJVUJCM.js}

@@ -2,7 +2,7 @@ import {
   ToolRegistry,
   getToolRegistry,
   initializeToolRegistry
-} from "./chunk-IBBG4PSO.js";
+} from "./chunk-YKDZH7G5.js";
 export {
   ToolRegistry,
   getToolRegistry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "mcpName": "io.github.bytebase/dbhub",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {