@teckedd-code2save/datafy 0.17.0 → 1.0.0

package/dist/{chunk-PQOTKZVK.js → chunk-KAW6SKAC.js}

@@ -302,7 +302,9 @@ var SSHTunnel = class {
           privateKey,
           targetConfig.passphrase,
           previousStream,
-          `jump host ${i + 1}`
+          `jump host ${i + 1}`,
+          targetConfig.keepaliveInterval,
+          targetConfig.keepaliveCountMax
         );
         console.error(`  \u2192 Forwarding through ${jumpHost.host}:${jumpHost.port} to ${nextHost.host}:${nextHost.port}`);
         forwardStream = await this.forwardTo(client, nextHost.host, nextHost.port);
@@ -328,7 +330,9 @@ var SSHTunnel = class {
       privateKey,
       targetConfig.passphrase,
       previousStream,
-      jumpHosts.length > 0 ? "target host" : void 0
+      jumpHosts.length > 0 ? "target host" : void 0,
+      targetConfig.keepaliveInterval,
+      targetConfig.keepaliveCountMax
     );
     this.sshClients.push(finalClient);
     return finalClient;
@@ -336,7 +340,7 @@ var SSHTunnel = class {
   /**
    * Connect to a single SSH host.
    */
-  connectToHost(hostInfo, password, privateKey, passphrase, sock, label) {
+  connectToHost(hostInfo, password, privateKey, passphrase, sock, label, keepaliveInterval, keepaliveCountMax) {
     return new Promise((resolve, reject) => {
       const client = new Client();
       const sshConfig = {
@@ -356,6 +360,17 @@ var SSHTunnel = class {
       if (sock) {
         sshConfig.sock = sock;
       }
+      if (keepaliveInterval !== void 0) {
+        if (Number.isNaN(keepaliveInterval) || keepaliveInterval < 0) {
+          const desc = label || `${hostInfo.host}:${hostInfo.port}`;
+          console.warn(
+            `Invalid SSH keepaliveInterval (${keepaliveInterval}) for ${desc}; keepalive configuration will be ignored.`
+          );
+        } else if (keepaliveInterval > 0) {
+          sshConfig.keepaliveInterval = keepaliveInterval * 1e3;
+          sshConfig.keepaliveCountMax = keepaliveCountMax ?? 3;
+        }
+      }
       const onError = (err) => {
         client.removeListener("ready", onReady);
         client.destroy();
@@ -1017,6 +1032,27 @@ function resolveSSHConfig() {
     config.proxyJump = process.env.SSH_PROXY_JUMP;
     sources.push("SSH_PROXY_JUMP from environment");
   }
+  const parseNonNegativeInteger = (value, name) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+      throw new Error(`Invalid value for ${name}: "${value}". Expected a non-negative integer.`);
+    }
+    return parsed;
+  };
+  if (args["ssh-keepalive-interval"]) {
+    config.keepaliveInterval = parseNonNegativeInteger(args["ssh-keepalive-interval"], "ssh-keepalive-interval");
+    sources.push("ssh-keepalive-interval from command line");
+  } else if (process.env.SSH_KEEPALIVE_INTERVAL) {
+    config.keepaliveInterval = parseNonNegativeInteger(process.env.SSH_KEEPALIVE_INTERVAL, "SSH_KEEPALIVE_INTERVAL");
+    sources.push("SSH_KEEPALIVE_INTERVAL from environment");
+  }
+  if (args["ssh-keepalive-count-max"]) {
+    config.keepaliveCountMax = parseNonNegativeInteger(args["ssh-keepalive-count-max"], "ssh-keepalive-count-max");
+    sources.push("ssh-keepalive-count-max from command line");
+  } else if (process.env.SSH_KEEPALIVE_COUNT_MAX) {
+    config.keepaliveCountMax = parseNonNegativeInteger(process.env.SSH_KEEPALIVE_COUNT_MAX, "SSH_KEEPALIVE_COUNT_MAX");
+    sources.push("SSH_KEEPALIVE_COUNT_MAX from environment");
+  }
   if (!config.host || !config.username) {
     throw new Error("SSH tunnel configuration requires at least --ssh-host and --ssh-user");
   }
@@ -1096,6 +1132,8 @@ async function resolveSourceConfigs() {
       source.ssh_password = sshResult.config.password;
       source.ssh_key = sshResult.config.privateKey;
       source.ssh_passphrase = sshResult.config.passphrase;
+      source.ssh_keepalive_interval = sshResult.config.keepaliveInterval;
+      source.ssh_keepalive_count_max = sshResult.config.keepaliveCountMax;
     }
     if (dsnResult.isDemo) {
       const { getSqliteInMemorySetupSql } = await import("./demo-loader-PSMTLZ2T.js");
@@ -1345,6 +1383,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.`
@@ -1412,7 +1462,8 @@ function buildDSNFromSource(source) {
         `Source '${source.id}': 'database' field is required for SQLite`
       );
     }
-    return `sqlite:///${source.database}`;
+    const prefix = source.database.startsWith("/") ? "sqlite://" : "sqlite:///";
+    return `${prefix}${source.database}`;
   }
   if (source.type === "redis") {
     const host = source.host || "localhost";
@@ -1596,7 +1647,9 @@ var ConnectorManager = class {
         password: source.ssh_password,
         privateKey: source.ssh_key,
         passphrase: source.ssh_passphrase,
-        proxyJump: source.ssh_proxy_jump
+        proxyJump: source.ssh_proxy_jump,
+        keepaliveInterval: source.ssh_keepalive_interval,
+        keepaliveCountMax: source.ssh_keepalive_count_max
       };
       if (!sshConfig.password && !sshConfig.privateKey) {
         throw new Error(
@@ -1637,6 +1690,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)) {
@@ -1772,60 +1828,213 @@ var ConnectorManager = class {
 };
 
 // src/utils/sql-parser.ts
-function stripCommentsAndStrings(sql) {
-  let result = "";
+var TokenType = { Plain: 0, Comment: 1, QuotedBlock: 2 };
+function plainToken(i) {
+  return { type: TokenType.Plain, end: i + 1 };
+}
+function scanSingleLineComment(sql, i) {
+  if (sql[i] !== "-" || sql[i + 1] !== "-") {
+    return null;
+  }
+  let j = i;
+  while (j < sql.length && sql[j] !== "\n") {
+    j++;
+  }
+  return { type: TokenType.Comment, end: j };
+}
+function scanMultiLineComment(sql, i) {
+  if (sql[i] !== "/" || sql[i + 1] !== "*") {
+    return null;
+  }
+  let j = i + 2;
+  while (j < sql.length && !(sql[j] === "*" && sql[j + 1] === "/")) {
+    j++;
+  }
+  if (j < sql.length) {
+    j += 2;
+  }
+  return { type: TokenType.Comment, end: j };
+}
+function scanNestedMultiLineComment(sql, i) {
+  if (sql[i] !== "/" || sql[i + 1] !== "*") {
+    return null;
+  }
+  let j = i + 2;
+  let depth = 1;
+  while (j < sql.length && depth > 0) {
+    if (sql[j] === "/" && sql[j + 1] === "*") {
+      depth++;
+      j += 2;
+    } else if (sql[j] === "*" && sql[j + 1] === "/") {
+      depth--;
+      j += 2;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.Comment, end: j };
+}
+function scanSingleQuotedString(sql, i) {
+  if (sql[i] !== "'") {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === "'" && sql[j + 1] === "'") {
+      j += 2;
+    } else if (sql[j] === "'") {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+function scanDoubleQuotedString(sql, i) {
+  if (sql[i] !== '"') {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === '"' && sql[j + 1] === '"') {
+      j += 2;
+    } else if (sql[j] === '"') {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+var dollarQuoteOpenRegex = /^\$([a-zA-Z_]\w*)?\$/;
+function scanDollarQuotedBlock(sql, i) {
+  if (sql[i] !== "$") {
+    return null;
+  }
+  const next = sql[i + 1];
+  if (next >= "0" && next <= "9") {
+    return null;
+  }
+  const remaining = sql.substring(i);
+  const m = dollarQuoteOpenRegex.exec(remaining);
+  if (!m) {
+    return null;
+  }
+  const tag = m[0];
+  const bodyStart = i + tag.length;
+  const closeIdx = sql.indexOf(tag, bodyStart);
+  const end = closeIdx !== -1 ? closeIdx + tag.length : sql.length;
+  return { type: TokenType.QuotedBlock, end };
+}
+function scanBacktickQuotedIdentifier(sql, i) {
+  if (sql[i] !== "`") {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === "`" && sql[j + 1] === "`") {
+      j += 2;
+    } else if (sql[j] === "`") {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+function scanBracketQuotedIdentifier(sql, i) {
+  if (sql[i] !== "[") {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === "]" && sql[j + 1] === "]") {
+      j += 2;
+    } else if (sql[j] === "]") {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+function scanTokenAnsi(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? plainToken(i);
+}
+function scanTokenPostgres(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanNestedMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanDollarQuotedBlock(sql, i) ?? plainToken(i);
+}
+function scanTokenMySQL(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBacktickQuotedIdentifier(sql, i) ?? plainToken(i);
+}
+function scanTokenSQLite(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBacktickQuotedIdentifier(sql, i) ?? scanBracketQuotedIdentifier(sql, i) ?? plainToken(i);
+}
+function scanTokenSQLServer(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBracketQuotedIdentifier(sql, i) ?? plainToken(i);
+}
+var dialectScanners = {
+  postgres: scanTokenPostgres,
+  mysql: scanTokenMySQL,
+  mariadb: scanTokenMySQL,
+  sqlite: scanTokenSQLite,
+  sqlserver: scanTokenSQLServer
+};
+function getScanner(dialect) {
+  return dialect ? dialectScanners[dialect] ?? scanTokenAnsi : scanTokenAnsi;
+}
+function stripCommentsAndStrings(sql, dialect) {
+  const scanToken = getScanner(dialect);
+  const parts = [];
+  let plainStart = -1;
   let i = 0;
   while (i < sql.length) {
-    if (sql[i] === "-" && sql[i + 1] === "-") {
-      while (i < sql.length && sql[i] !== "\n") {
-        i++;
+    const token = scanToken(sql, i);
+    if (token.type === TokenType.Plain) {
+      if (plainStart === -1) {
+        plainStart = i;
       }
-      result += " ";
-      continue;
-    }
-    if (sql[i] === "/" && sql[i + 1] === "*") {
-      i += 2;
-      while (i < sql.length && !(sql[i] === "*" && sql[i + 1] === "/")) {
-        i++;
+    } else {
+      if (plainStart !== -1) {
+        parts.push(sql.substring(plainStart, i));
+        plainStart = -1;
       }
-      i += 2;
-      result += " ";
-      continue;
+      parts.push(" ");
     }
-    if (sql[i] === "'") {
-      i++;
-      while (i < sql.length) {
-        if (sql[i] === "'" && sql[i + 1] === "'") {
-          i += 2;
-        } else if (sql[i] === "'") {
-          i++;
-          break;
-        } else {
-          i++;
-        }
+    i = token.end;
+  }
+  if (plainStart !== -1) {
+    parts.push(sql.substring(plainStart));
+  }
+  return parts.join("");
+}
+function splitSQLStatements(sql, dialect) {
+  const scanToken = getScanner(dialect);
+  const statements = [];
+  let stmtStart = 0;
+  let i = 0;
+  while (i < sql.length) {
+    if (sql[i] === ";") {
+      const trimmed2 = sql.substring(stmtStart, i).trim();
+      if (trimmed2.length > 0) {
+        statements.push(trimmed2);
       }
-      result += " ";
-      continue;
-    }
-    if (sql[i] === '"') {
+      stmtStart = i + 1;
       i++;
-      while (i < sql.length) {
-        if (sql[i] === '"' && sql[i + 1] === '"') {
-          i += 2;
-        } else if (sql[i] === '"') {
-          i++;
-          break;
-        } else {
-          i++;
-        }
-      }
-      result += " ";
       continue;
     }
-    result += sql[i];
-    i++;
+    const token = scanToken(sql, i);
+    i = token.end;
+  }
+  const trimmed = sql.substring(stmtStart).trim();
+  if (trimmed.length > 0) {
+    statements.push(trimmed);
   }
-  return result;
+  return statements;
 }
 
 // src/utils/parameter-mapper.ts
@@ -2172,6 +2381,7 @@ export {
   getDatabaseTypeFromDSN,
   getDefaultPortForType,
   stripCommentsAndStrings,
+  splitSQLStatements,
   isDemoMode,
   resolveTransport,
   resolvePort,

package/dist/index.js

@@ -17,8 +17,9 @@ import {
   resolvePort,
   resolveSourceConfigs,
   resolveTransport,
+  splitSQLStatements,
   stripCommentsAndStrings
-} from "./chunk-PQOTKZVK.js";
+} from "./chunk-KAW6SKAC.js";
 
 // src/connectors/postgres/index.ts
 import pg from "pg";
@@ -143,6 +144,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 {
@@ -211,6 +242,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;
@@ -219,11 +252,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();
@@ -261,7 +304,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 
@@ -282,7 +325,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 (
@@ -304,7 +347,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 
@@ -352,18 +395,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]
       );
@@ -372,22 +424,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 {
@@ -400,7 +512,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 
@@ -476,7 +588,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+      const statements = splitSQLStatements(sql2, "postgres");
       if (statements.length === 1) {
         const processedStatement = SQLRowLimiter.applyMaxRows(statements[0], options.maxRows);
         let result;
@@ -791,33 +903,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);
@@ -950,38 +1107,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)) {
@@ -1183,14 +1308,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");
     }
@@ -1209,7 +1335,7 @@ var SQLiteConnector = class _SQLiteConnector {
       throw new Error("Not connected to SQLite database");
     }
     try {
-      const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+      const statements = splitSQLStatements(sql2, "sqlite");
       if (statements.length === 1) {
         let processedStatement = statements[0];
         const trimmedStatement = statements[0].toLowerCase().trim();
@@ -1568,11 +1694,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 = ?
@@ -1580,24 +1707,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
@@ -1721,7 +1881,7 @@ var MySQLConnector = class _MySQLConnector {
     try {
       let processedSQL = sql2;
       if (options.maxRows) {
-        const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+        const statements = splitSQLStatements(sql2, "mysql");
         const processedStatements = statements.map(
           (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
         );
@@ -1759,7 +1919,7 @@ var mysqlConnector = new MySQLConnector();
 ConnectorRegistry.register(mysqlConnector);
 
 // src/connectors/mariadb/index.ts
-import mariadb from "mariadb";
+import { createPool } from "mariadb";
 var MariadbDSNParser = class {
   async parse(dsn, config) {
     const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
@@ -1843,7 +2003,7 @@ var MariaDBConnector = class _MariaDBConnector {
   async connect(dsn, initScript, config) {
     try {
       const connectionConfig = await this.dsnParser.parse(dsn, config);
-      this.pool = mariadb.createPool(connectionConfig);
+      this.pool = createPool(connectionConfig);
       await this.pool.query("SELECT 1");
     } catch (err) {
       console.error("Failed to connect to MariaDB database:", err);
@@ -1981,11 +2141,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 = ?
@@ -1993,24 +2154,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
@@ -2134,7 +2328,7 @@ var MariaDBConnector = class _MariaDBConnector {
     try {
       let processedSQL = sql2;
       if (options.maxRows) {
-        const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+        const statements = splitSQLStatements(sql2, "mariadb");
         const processedStatements = statements.map(
           (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
         );
@@ -2834,7 +3028,7 @@ var allowedKeywords = {
   sqlserver: ["select", "with", "explain", "showplan"]
 };
 function isReadOnlySQL(sql2, connectorType) {
-  const cleanedSQL = stripCommentsAndStrings(sql2).trim().toLowerCase();
+  const cleanedSQL = stripCommentsAndStrings(sql2, connectorType).trim().toLowerCase();
   if (!cleanedSQL) {
     return true;
   }
@@ -2927,11 +3121,8 @@ function trackToolRequest(metadata, startTime, extra, success, error) {
 var executeSqlSchema = {
   sql: z.string().describe("SQL to execute (multiple statements separated by ;)")
 };
-function splitSQLStatements(sql2) {
-  return sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
-}
 function areAllStatementsReadOnly(sql2, connectorType) {
-  const statements = splitSQLStatements(sql2);
+  const statements = splitSQLStatements(sql2, connectorType);
   return statements.every((statement) => isReadOnlySQL(statement, connectorType));
 }
 function createExecuteSqlToolHandler(sourceId) {
@@ -2988,7 +3179,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)"),
@@ -3001,6 +3192,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 });
@@ -3012,6 +3206,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);
@@ -3062,11 +3266,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({
@@ -3081,16 +3287,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,
@@ -3152,7 +3361,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 } : {}
               });
             }
           }
@@ -3166,7 +3376,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;
@@ -3178,7 +3388,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;
@@ -3315,7 +3525,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);
@@ -3796,9 +4009,9 @@ function generateCode(request) {
 
 // src/tools/generate-code-handler.ts
 function createGenerateCodeToolHandler() {
-  return async (request) => {
+  return async (args, extra) => {
     try {
-      const params = generateCodeSchema.parse(request.input);
+      const params = generateCodeSchema.parse(args);
       const result = generateCode(params);
       return {
         content: [
@@ -3975,7 +4188,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,
@@ -4655,7 +4868,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-U5HSB2VB.js");
+    const { initializeToolRegistry } = await import("./registry-TGSADHCH.js");
     initializeToolRegistry({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -4693,9 +4906,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-U5HSB2VB.js → registry-TGSADHCH.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teckedd-code2save/datafy",
-  "version": "0.17.0",
+  "version": "1.0.0",
   "mcpName": "io.github.teckedd-code2save/datafy",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB, Redis, and Elasticsearch with code generation",
   "repository": {
@@ -17,21 +17,6 @@
     "LICENSE",
     "README.md"
   ],
-  "scripts": {
-    "build": "pnpm run generate:api-types && tsup && cd frontend && pnpm run build",
-    "build:backend": "pnpm run generate:api-types && tsup",
-    "build:frontend": "cd frontend && pnpm run build",
-    "start": "node dist/index.js",
-    "dev": "concurrently --kill-others \"pnpm run dev:backend\" \"pnpm run dev:frontend\"",
-    "dev:backend": "NODE_ENV=development tsx src/index.ts --transport=http",
-    "dev:frontend": "cd frontend && pnpm run dev",
-    "crossdev": "cross-env NODE_ENV=development tsx src/index.ts",
-    "generate:api-types": "openapi-typescript src/api/openapi.yaml -o src/api/openapi.d.ts",
-    "test": "vitest run",
-    "test:unit": "vitest run --project unit",
-    "test:watch": "vitest",
-    "test:integration": "vitest run --project integration"
-  },
   "keywords": [],
   "author": "",
   "license": "MIT",
@@ -86,5 +71,19 @@
   "include": [
     "src/**/*"
   ],
-  "packageManager": "pnpm@10.12.1+sha512.f0dda8580f0ee9481c5c79a1d927b9164f2c478e90992ad268bbb2465a736984391d6333d2c327913578b2804af33474ca554ba29c04a8b13060a717675ae3ac"
+  "scripts": {
+    "build": "pnpm run generate:api-types && tsup && cd frontend && pnpm run build",
+    "build:backend": "pnpm run generate:api-types && tsup",
+    "build:frontend": "cd frontend && pnpm run build",
+    "start": "node dist/index.js",
+    "dev": "concurrently --kill-others \"pnpm run dev:backend\" \"pnpm run dev:frontend\"",
+    "dev:backend": "NODE_ENV=development tsx src/index.ts --transport=http",
+    "dev:frontend": "cd frontend && pnpm run dev",
+    "crossdev": "cross-env NODE_ENV=development tsx src/index.ts",
+    "generate:api-types": "openapi-typescript src/api/openapi.yaml -o src/api/openapi.d.ts",
+    "test": "vitest run",
+    "test:unit": "vitest run --project unit",
+    "test:watch": "vitest",
+    "test:integration": "vitest run --project integration"
+  }
 }