@yeyuan98/opencode-bioresearcher-plugin 1.4.1 → 1.5.0-alpha.0

package/dist/db-tools/backends/mongodb/translator.js

@@ -0,0 +1,407 @@
+export class SQLParseError extends Error {
+    constructor(message) {
+        super(`SQL Parse Error: ${message}`);
+        this.name = 'SQLParseError';
+    }
+}
+export function parseSelectQuery(sql) {
+    const normalized = sql.trim().replace(/\s+/g, ' ');
+    if (!normalized.toUpperCase().startsWith('SELECT')) {
+        throw new SQLParseError('Only SELECT queries are supported');
+    }
+    const result = {
+        collection: '',
+        fields: null,
+        where: null,
+        orderBy: null,
+        limit: null,
+        offset: null,
+        groupBy: null,
+        having: null,
+        aggregations: null,
+    };
+    const selectMatch = normalized.match(/^SELECT\s+(.+?)\s+FROM\s+(\w+)/i);
+    if (!selectMatch) {
+        throw new SQLParseError('Invalid SELECT syntax: expected SELECT ... FROM table');
+    }
+    const fieldsStr = selectMatch[1].trim();
+    const tableName = selectMatch[2].trim();
+    result.collection = tableName;
+    if (fieldsStr === '*') {
+        result.fields = null;
+    }
+    else {
+        result.fields = fieldsStr.split(',').map(f => f.trim());
+    }
+    result.aggregations = parseAggregations(fieldsStr);
+    let remaining = normalized.substring(selectMatch[0].length).trim();
+    const whereMatch = remaining.match(/^WHERE\s+(.+?)(?=\s+(?:ORDER|GROUP|LIMIT|OFFSET|$))/i);
+    if (whereMatch) {
+        result.where = parseWhereClause(whereMatch[1].trim());
+        remaining = remaining.substring(whereMatch[0].length).trim();
+    }
+    const groupByMatch = remaining.match(/^GROUP\s+BY\s+(.+?)(?=\s+(?:HAVING|ORDER|LIMIT|OFFSET|$))/i);
+    if (groupByMatch) {
+        result.groupBy = groupByMatch[1].trim().split(',').map(f => f.trim());
+        remaining = remaining.substring(groupByMatch[0].length).trim();
+    }
+    const havingMatch = remaining.match(/^HAVING\s+(.+?)(?=\s+(?:ORDER|LIMIT|OFFSET|$))/i);
+    if (havingMatch) {
+        result.having = parseWhereClause(havingMatch[1].trim());
+        remaining = remaining.substring(havingMatch[0].length).trim();
+    }
+    const orderByMatch = remaining.match(/^ORDER\s+BY\s+(.+?)(?=\s+(?:LIMIT|OFFSET|$))/i);
+    if (orderByMatch) {
+        result.orderBy = parseOrderBy(orderByMatch[1].trim());
+        remaining = remaining.substring(orderByMatch[0].length).trim();
+    }
+    const limitMatch = remaining.match(/^LIMIT\s+(\d+)/i);
+    if (limitMatch) {
+        result.limit = parseInt(limitMatch[1], 10);
+        remaining = remaining.substring(limitMatch[0].length).trim();
+    }
+    const offsetMatch = remaining.match(/^OFFSET\s+(\d+)/i);
+    if (offsetMatch) {
+        result.offset = parseInt(offsetMatch[1], 10);
+    }
+    return result;
+}
+function parseAggregations(fieldsStr) {
+    const aggRegex = /(COUNT|SUM|AVG|MIN|MAX)\s*\(\s*(\*|\w+)\s*\)(?:\s+(?:AS\s+)?(\w+))?/gi;
+    const aggregations = [];
+    let match;
+    while ((match = aggRegex.exec(fieldsStr)) !== null) {
+        aggregations.push({
+            type: match[1].toUpperCase(),
+            field: match[2] === '*' ? '_all' : match[2],
+            alias: match[3],
+        });
+    }
+    return aggregations.length > 0 ? aggregations : null;
+}
+function parseWhereClause(whereStr) {
+    const conditions = [];
+    const andParts = whereStr.split(/\s+AND\s+/i);
+    for (const part of andParts) {
+        const orConditions = [];
+        const orParts = part.split(/\s+OR\s+/i);
+        for (const orPart of orParts) {
+            const condition = parseCondition(orPart.trim());
+            if (condition) {
+                orConditions.push(condition);
+            }
+        }
+        if (orConditions.length === 1) {
+            conditions.push(orConditions[0]);
+        }
+        else if (orConditions.length > 1) {
+            conditions.push({ $or: orConditions });
+        }
+    }
+    if (conditions.length === 0) {
+        return {};
+    }
+    else if (conditions.length === 1) {
+        return conditions[0];
+    }
+    else {
+        return { $and: conditions };
+    }
+}
+function parseCondition(conditionStr) {
+    const comparisonMatch = conditionStr.match(/^(\w+)\s*(=|!=|<>|>=|<=|>|<|LIKE|NOT\s+LIKE)\s*['"]?([^'"]+)['"]?$/i);
+    if (!comparisonMatch) {
+        const inMatch = conditionStr.match(/^(\w+)\s+(NOT\s+)?IN\s*\((.+)\)$/i);
+        if (inMatch) {
+            const field = inMatch[1];
+            const isNot = !!inMatch[2];
+            const values = inMatch[3].split(',').map(v => {
+                const trimmed = v.trim();
+                if (trimmed.startsWith("'") || trimmed.startsWith('"')) {
+                    return trimmed.slice(1, -1);
+                }
+                const num = Number(trimmed);
+                return isNaN(num) ? trimmed : num;
+            });
+            if (isNot) {
+                return { [field]: { $nin: values } };
+            }
+            return { [field]: { $in: values } };
+        }
+        const isNullMatch = conditionStr.match(/^(\w+)\s+IS\s+(NOT\s+)?NULL$/i);
+        if (isNullMatch) {
+            const field = isNullMatch[1];
+            const isNot = !!isNullMatch[2];
+            return { [field]: { $exists: isNot } };
+        }
+        return null;
+    }
+    const field = comparisonMatch[1];
+    const operator = comparisonMatch[2].toUpperCase().replace(/\s+/g, ' ');
+    let value = comparisonMatch[3];
+    if (typeof value === 'string') {
+        if (value.toLowerCase() === 'true')
+            value = true;
+        else if (value.toLowerCase() === 'false')
+            value = false;
+        else {
+            const num = Number(value);
+            if (!isNaN(num))
+                value = num;
+        }
+    }
+    switch (operator) {
+        case '=':
+            return { [field]: value };
+        case '!=':
+        case '<>':
+            return { [field]: { $ne: value } };
+        case '>':
+            return { [field]: { $gt: value } };
+        case '>=':
+            return { [field]: { $gte: value } };
+        case '<':
+            return { [field]: { $lt: value } };
+        case '<=':
+            return { [field]: { $lte: value } };
+        case 'LIKE':
+            return { [field]: { $regex: sqlLikeToRegex(value) } };
+        case 'NOT LIKE':
+            return { [field]: { $not: { $regex: sqlLikeToRegex(value) } } };
+        default:
+            return null;
+    }
+}
+function sqlLikeToRegex(pattern) {
+    return pattern
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/%/g, '.*')
+        .replace(/_/g, '.');
+}
+function parseOrderBy(orderByStr) {
+    const sort = {};
+    const parts = orderByStr.split(',').map(p => p.trim());
+    for (const part of parts) {
+        const match = part.match(/^(\w+)(?:\s+(ASC|DESC))?$/i);
+        if (match) {
+            const field = match[1];
+            const direction = (match[2] || 'ASC').toUpperCase();
+            sort[field] = direction === 'DESC' ? -1 : 1;
+        }
+    }
+    return sort;
+}
+export async function executeParsedQuery(collection, parsed, params) {
+    if (parsed.groupBy || parsed.aggregations) {
+        return executeAggregationQuery(collection, parsed);
+    }
+    let filter = (parsed.where || {});
+    if (params && !Array.isArray(params)) {
+        filter = replaceParams(filter, params);
+    }
+    const options = {};
+    if (parsed.fields && parsed.fields.length > 0) {
+        const projection = {};
+        for (const field of parsed.fields) {
+            projection[field] = 1;
+        }
+        options.projection = projection;
+    }
+    if (parsed.limit !== null) {
+        options.limit = parsed.limit;
+    }
+    if (parsed.offset !== null) {
+        options.skip = parsed.offset;
+    }
+    if (parsed.orderBy) {
+        options.sort = parsed.orderBy;
+    }
+    const cursor = collection.find(filter, options);
+    const docs = await cursor.toArray();
+    return docs.map(doc => {
+        const row = {};
+        for (const [key, value] of Object.entries(doc)) {
+            if (key === '_id') {
+                row[key] = value.toString();
+            }
+            else {
+                row[key] = value;
+            }
+        }
+        return row;
+    });
+}
+async function executeAggregationQuery(collection, parsed) {
+    const pipeline = [];
+    if (parsed.where) {
+        pipeline.push({ $match: parsed.where });
+    }
+    if (parsed.groupBy && parsed.aggregations) {
+        const groupId = {};
+        for (const field of parsed.groupBy) {
+            groupId[field] = `$${field}`;
+        }
+        const groupAccumulators = {};
+        for (const agg of parsed.aggregations) {
+            const alias = agg.alias || `${agg.type.toLowerCase()}_${agg.field}`;
+            switch (agg.type) {
+                case 'COUNT':
+                    groupAccumulators[alias] = agg.field === '_all' ? { $sum: 1 } : { $sum: { $cond: [`$${agg.field}`, 1, 0] } };
+                    break;
+                case 'SUM':
+                    groupAccumulators[alias] = { $sum: `$${agg.field}` };
+                    break;
+                case 'AVG':
+                    groupAccumulators[alias] = { $avg: `$${agg.field}` };
+                    break;
+                case 'MIN':
+                    groupAccumulators[alias] = { $min: `$${agg.field}` };
+                    break;
+                case 'MAX':
+                    groupAccumulators[alias] = { $max: `$${agg.field}` };
+                    break;
+            }
+        }
+        pipeline.push({
+            $group: {
+                _id: groupId,
+                ...groupAccumulators,
+            },
+        });
+    }
+    else if (parsed.aggregations) {
+        const groupAccumulators = {};
+        for (const agg of parsed.aggregations) {
+            const alias = agg.alias || `${agg.type.toLowerCase()}_${agg.field}`;
+            switch (agg.type) {
+                case 'COUNT':
+                    groupAccumulators[alias] = agg.field === '_all' ? { $sum: 1 } : { $sum: { $cond: [`$${agg.field}`, 1, 0] } };
+                    break;
+                case 'SUM':
+                    groupAccumulators[alias] = { $sum: `$${agg.field}` };
+                    break;
+                case 'AVG':
+                    groupAccumulators[alias] = { $avg: `$${agg.field}` };
+                    break;
+                case 'MIN':
+                    groupAccumulators[alias] = { $min: `$${agg.field}` };
+                    break;
+                case 'MAX':
+                    groupAccumulators[alias] = { $max: `$${agg.field}` };
+                    break;
+            }
+        }
+        pipeline.push({
+            $group: {
+                _id: null,
+                ...groupAccumulators,
+            },
+        });
+    }
+    if (parsed.having) {
+        pipeline.push({ $match: parsed.having });
+    }
+    if (parsed.orderBy) {
+        pipeline.push({ $sort: parsed.orderBy });
+    }
+    if (parsed.limit !== null) {
+        pipeline.push({ $limit: parsed.limit });
+    }
+    if (parsed.offset !== null) {
+        pipeline.push({ $skip: parsed.offset });
+    }
+    const results = await collection.aggregate(pipeline).toArray();
+    return results.map(doc => {
+        const row = {};
+        for (const [key, value] of Object.entries(doc)) {
+            if (key === '_id' && typeof value === 'object' && value !== null) {
+                Object.assign(row, value);
+            }
+            else if (key !== '_id') {
+                row[key] = value;
+            }
+        }
+        return row;
+    });
+}
+function replaceParams(obj, params) {
+    if (typeof obj === 'string') {
+        let result = obj;
+        for (const [key, value] of Object.entries(params)) {
+            const placeholder = `:${key}`;
+            if (result.includes(placeholder)) {
+                result = result.replace(placeholder, String(value));
+            }
+        }
+        return result;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => replaceParams(item, params));
+    }
+    if (obj && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = replaceParams(value, params);
+        }
+        return result;
+    }
+    return obj;
+}
+export async function listMongoDBCollections(db) {
+    const collections = await db.listCollections().toArray();
+    return collections.map(col => ({
+        name: col.name,
+        type: col.type === 'view' ? 'view' : 'collection',
+        engine: null,
+        rowCount: null,
+        createdAt: null,
+        comment: null,
+    }));
+}
+export async function describeMongoDBCollection(db, collectionName) {
+    const collections = await db.listCollections({ name: collectionName }, { nameOnly: false }).toArray();
+    if (collections.length === 0) {
+        return [];
+    }
+    const collectionInfo = collections[0];
+    const columns = [];
+    const options = collectionInfo.options;
+    if (options?.validator?.$jsonSchema?.properties) {
+        const props = options.validator.$jsonSchema.properties;
+        const required = options.validator.$jsonSchema.required || [];
+        for (const [fieldName, fieldDef] of Object.entries(props)) {
+            const def = fieldDef;
+            columns.push({
+                field: fieldName,
+                type: def.bsonType || def.type || 'unknown',
+                nullable: !required.includes(fieldName),
+                key: fieldName === '_id' ? 'PRI' : null,
+                defaultValue: null,
+                extra: null,
+                comment: def.description || null,
+            });
+        }
+    }
+    if (columns.length === 0) {
+        columns.push({
+            field: '_id',
+            type: 'ObjectId',
+            nullable: false,
+            key: 'PRI',
+            defaultValue: null,
+            extra: null,
+            comment: null,
+        });
+    }
+    return columns;
+}
+export function createFieldInfoFromRow(row) {
+    return Object.keys(row).map(key => ({
+        name: key,
+        type: typeof row[key] === 'number' ? 'number' : typeof row[key] === 'boolean' ? 'boolean' : 'string',
+        nullable: true,
+        key: key === '_id' ? 'PRI' : null,
+        default: null,
+        extra: null,
+    }));
+}

package/dist/db-tools/backends/mysql/backend.d.ts

@@ -0,0 +1,15 @@
+import type { IConnectionConfig, IQuery, IQueryResult, ICollectionInfo, IColumnSchema, IConnectionPool } from '../../interface';
+import { BaseBackend } from '../../core/base';
+import { MySQLConnectionConfig } from './connection';
+export declare class MySQLBackend extends BaseBackend {
+    readonly type = "mysql";
+    readonly config: MySQLConnectionConfig;
+    constructor(config: IConnectionConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getPool(): IConnectionPool | null;
+    executeQuery(query: IQuery): Promise<IQueryResult>;
+    listCollections(): Promise<ICollectionInfo[]>;
+    describeCollection(name: string): Promise<IColumnSchema[]>;
+}
+export declare function createMySQLBackend(config: IConnectionConfig): MySQLBackend;

package/dist/db-tools/backends/mysql/backend.js

@@ -0,0 +1,57 @@
+import { BaseBackend } from '../../core/base';
+import { getPool, closePool, validateMySQLConfig, MySQLConnectionPool, } from './connection';
+import { extractFieldInfo, mapMySQLTablesToCollections, mapMySQLColumnsToSchema, LIST_TABLES_SQL, DESCRIBE_TABLE_SQL, } from './translator';
+export class MySQLBackend extends BaseBackend {
+    type = 'mysql';
+    config;
+    constructor(config) {
+        super();
+        this.config = {
+            ...config,
+            charset: config.options?.charset || 'utf8mb4',
+        };
+    }
+    async connect() {
+        validateMySQLConfig(this.config);
+        getPool(this.config);
+        this._connected = true;
+    }
+    async disconnect() {
+        await closePool();
+        this._connected = false;
+    }
+    getPool() {
+        const mysqlPool = getPool(this.config);
+        return new MySQLConnectionPool(mysqlPool);
+    }
+    async executeQuery(query) {
+        const startTime = Date.now();
+        try {
+            if (!this._connected) {
+                await this.connect();
+            }
+            const pool = getPool(this.config);
+            const params = query.params ?? {};
+            const [rows, fields] = await pool.query(query.sql, params);
+            const executionTimeMs = Date.now() - startTime;
+            return this.createSuccessResult(rows, extractFieldInfo(fields), executionTimeMs);
+        }
+        catch (error) {
+            const executionTimeMs = Date.now() - startTime;
+            return this.createErrorResult(error, executionTimeMs);
+        }
+    }
+    async listCollections() {
+        const pool = getPool(this.config);
+        const [rows] = await pool.query(LIST_TABLES_SQL);
+        return mapMySQLTablesToCollections(rows);
+    }
+    async describeCollection(name) {
+        const pool = getPool(this.config);
+        const [rows] = await pool.query(DESCRIBE_TABLE_SQL, [name]);
+        return mapMySQLColumnsToSchema(rows);
+    }
+}
+export function createMySQLBackend(config) {
+    return new MySQLBackend(config);
+}

package/dist/db-tools/backends/mysql/connection.d.ts

@@ -0,0 +1,25 @@
+import * as mysql from 'mysql2/promise';
+import type { IConnectionConfig, IConnectionPool, IConnection } from '../../interface';
+export interface MySQLConnectionConfig extends IConnectionConfig {
+    charset?: string;
+}
+export interface MySQLPoolOptions extends mysql.PoolOptions {
+    namedPlaceholders: boolean;
+}
+declare let pool: mysql.Pool | null;
+export declare function createPoolConfig(config: MySQLConnectionConfig): MySQLPoolOptions;
+export declare function getPool(config: MySQLConnectionConfig): mysql.Pool;
+export declare function closePool(): Promise<void>;
+export declare function getPoolStatus(): {
+    initialized: boolean;
+    hasConfig: boolean;
+};
+export declare function validateMySQLConfig(config: MySQLConnectionConfig): void;
+export declare class MySQLConnectionPool implements IConnectionPool {
+    private pool;
+    constructor(pool: mysql.Pool);
+    getConnection(): Promise<IConnection>;
+    end(): Promise<void>;
+    isHealthy(): boolean;
+}
+export { pool as _internalPool };

package/dist/db-tools/backends/mysql/connection.js

@@ -0,0 +1,83 @@
+import * as mysql from 'mysql2/promise';
+let pool = null;
+let currentConfig = null;
+export function createPoolConfig(config) {
+    return {
+        host: config.host,
+        port: config.port,
+        user: config.username,
+        password: config.password,
+        database: config.database,
+        charset: config.charset || 'utf8mb4',
+        connectTimeout: config.connectionTimeout || 10000,
+        waitForConnections: true,
+        connectionLimit: 10,
+        queueLimit: 0,
+        namedPlaceholders: true,
+    };
+}
+export function getPool(config) {
+    if (pool && currentConfig && isSameConfig(currentConfig, config)) {
+        return pool;
+    }
+    if (pool) {
+        pool.end().catch(err => console.error('[mysql-backend] Previous pool cleanup failed:', err.message));
+    }
+    pool = mysql.createPool(createPoolConfig(config));
+    currentConfig = config;
+    return pool;
+}
+function isSameConfig(a, b) {
+    return (a.host === b.host &&
+        a.port === b.port &&
+        a.username === b.username &&
+        a.password === b.password &&
+        a.database === b.database);
+}
+export async function closePool() {
+    if (pool) {
+        await pool.end().catch(err => console.error('[mysql-backend] Pool close failed:', err.message));
+        pool = null;
+        currentConfig = null;
+    }
+}
+export function getPoolStatus() {
+    return {
+        initialized: pool !== null,
+        hasConfig: currentConfig !== null,
+    };
+}
+export function validateMySQLConfig(config) {
+    const missing = [];
+    if (!config.username)
+        missing.push('DB_USER (or DB_USERNAME)');
+    if (!config.database)
+        missing.push('DB_DATABASE');
+    if (missing.length > 0) {
+        throw new Error(`Missing required MySQL configuration: ${missing.join(', ')}.\n` +
+            `Set these environment variables or provide in config.`);
+    }
+    if (config.port < 1 || config.port > 65535) {
+        throw new Error(`Invalid MySQL port: ${config.port}. Must be between 1 and 65535.`);
+    }
+}
+export class MySQLConnectionPool {
+    pool;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async getConnection() {
+        const conn = await this.pool.getConnection();
+        return {
+            isConnected: () => true,
+            close: async () => conn.release(),
+        };
+    }
+    async end() {
+        await this.pool.end();
+    }
+    isHealthy() {
+        return true;
+    }
+}
+export { pool as _internalPool };

package/dist/db-tools/backends/mysql/index.d.ts

@@ -0,0 +1,3 @@
+export { MySQLBackend, createMySQLBackend } from './backend';
+export { getPool, closePool, validateMySQLConfig } from './connection';
+export type { MySQLConnectionConfig } from './connection';

package/dist/db-tools/backends/mysql/index.js

@@ -0,0 +1,2 @@
+export { MySQLBackend, createMySQLBackend } from './backend';
+export { getPool, closePool, validateMySQLConfig } from './connection';

package/dist/db-tools/backends/mysql/translator.d.ts

@@ -0,0 +1,7 @@
+import type { FieldPacket, RowDataPacket } from 'mysql2/promise';
+import type { IFieldInfo, IColumnSchema, ICollectionInfo } from '../../interface';
+export declare function extractFieldInfo(fieldPackets: FieldPacket[] | null | undefined): IFieldInfo[];
+export declare function mapMySQLTablesToCollections(rows: RowDataPacket[]): ICollectionInfo[];
+export declare function mapMySQLColumnsToSchema(rows: RowDataPacket[]): IColumnSchema[];
+export declare const LIST_TABLES_SQL = "\n  SELECT \n    TABLE_NAME,\n    TABLE_TYPE,\n    ENGINE,\n    TABLE_ROWS,\n    CREATE_TIME,\n    TABLE_COMMENT\n  FROM information_schema.TABLES \n  WHERE TABLE_SCHEMA = DATABASE()\n  ORDER BY TABLE_NAME\n";
+export declare const DESCRIBE_TABLE_SQL = "\n  SELECT \n    COLUMN_NAME as Field,\n    COLUMN_TYPE as Type,\n    IS_NULLABLE as `Null`,\n    COLUMN_KEY as `Key`,\n    COLUMN_DEFAULT as `Default`,\n    EXTRA as Extra,\n    COLUMN_COMMENT as Comment\n  FROM information_schema.COLUMNS \n  WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?\n  ORDER BY ORDINAL_POSITION\n";

package/dist/db-tools/backends/mysql/translator.js

@@ -0,0 +1,67 @@
+export function extractFieldInfo(fieldPackets) {
+    if (!fieldPackets || !Array.isArray(fieldPackets)) {
+        return [];
+    }
+    return fieldPackets.map((field) => ({
+        name: field.name ?? 'unknown',
+        type: String(field.type ?? 'unknown'),
+        nullable: true,
+        key: null,
+        default: null,
+        extra: null,
+    }));
+}
+export function mapMySQLTablesToCollections(rows) {
+    return rows.map((row) => ({
+        name: row.TABLE_NAME || row.table_name || row.name || String(row[0] ?? 'unknown'),
+        type: mapTableType(row.TABLE_TYPE || row.table_type || row.type),
+        engine: row.ENGINE || row.engine || null,
+        rowCount: row.TABLE_ROWS ?? row.table_rows ?? row.rows ?? null,
+        createdAt: row.CREATE_TIME instanceof Date
+            ? row.CREATE_TIME.toISOString()
+            : (row.create_time || null),
+        comment: row.TABLE_COMMENT || row.table_comment || row.comment || null,
+    }));
+}
+function mapTableType(mysqlType) {
+    const upper = (mysqlType || '').toUpperCase();
+    if (upper.includes('VIEW'))
+        return 'view';
+    return 'table';
+}
+export function mapMySQLColumnsToSchema(rows) {
+    return rows.map((row) => ({
+        field: row.Field || row.COLUMN_NAME || row.field || row.column_name || 'unknown',
+        type: row.Type || row.COLUMN_TYPE || row.type || row.column_type || 'unknown',
+        nullable: (row.Null || row.IS_NULLABLE || row.nullable) === 'YES',
+        key: row.Key || row.COLUMN_KEY || row.key || null,
+        defaultValue: row.Default ?? row.COLUMN_DEFAULT ?? row.default ?? null,
+        extra: row.Extra || row.EXTRA || row.extra || null,
+        comment: row.Comment || row.COLUMN_COMMENT || row.comment || null,
+    }));
+}
+export const LIST_TABLES_SQL = `
+  SELECT 
+    TABLE_NAME,
+    TABLE_TYPE,
+    ENGINE,
+    TABLE_ROWS,
+    CREATE_TIME,
+    TABLE_COMMENT
+  FROM information_schema.TABLES 
+  WHERE TABLE_SCHEMA = DATABASE()
+  ORDER BY TABLE_NAME
+`;
+export const DESCRIBE_TABLE_SQL = `
+  SELECT 
+    COLUMN_NAME as Field,
+    COLUMN_TYPE as Type,
+    IS_NULLABLE as \`Null\`,
+    COLUMN_KEY as \`Key\`,
+    COLUMN_DEFAULT as \`Default\`,
+    EXTRA as Extra,
+    COLUMN_COMMENT as Comment
+  FROM information_schema.COLUMNS 
+  WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+  ORDER BY ORDINAL_POSITION
+`;

package/dist/db-tools/core/base.d.ts

@@ -0,0 +1,17 @@
+import type { IDatabaseBackend, IConnectionConfig, IConnectionPool, IQuery, IQueryResult, ICollectionInfo, IColumnSchema, IFieldInfo, IRow } from '../interface';
+export declare abstract class BaseBackend implements IDatabaseBackend {
+    abstract readonly type: string;
+    abstract readonly config: IConnectionConfig;
+    protected _connected: boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract getPool(): IConnectionPool | null;
+    isConnected(): boolean;
+    abstract executeQuery(query: IQuery): Promise<IQueryResult>;
+    abstract listCollections(): Promise<ICollectionInfo[]>;
+    abstract describeCollection(name: string): Promise<IColumnSchema[]>;
+    protected createSuccessResult(rows: IRow[], fields: IFieldInfo[], executionTimeMs: number): IQueryResult;
+    protected createErrorResult(error: unknown, executionTimeMs: number, additionalHints?: string[]): IQueryResult;
+    protected createFieldInfo(name: string, type?: string, nullable?: boolean): IFieldInfo;
+}
+export { loadDbConfig as getConfigFromEnv } from './config-loader';