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

package/dist/db-tools/core/base.js

@@ -0,0 +1,51 @@
+import { getErrorHints } from './validator';
+export class BaseBackend {
+    _connected = false;
+    isConnected() {
+        return this._connected;
+    }
+    createSuccessResult(rows, fields, executionTimeMs) {
+        return {
+            success: true,
+            data: {
+                rows,
+                rowCount: rows.length,
+                fields,
+            },
+            metadata: {
+                executionTimeMs,
+                backend: this.type,
+            },
+        };
+    }
+    createErrorResult(error, executionTimeMs, additionalHints) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        const errorCode = err.code;
+        const baseHints = getErrorHints(errorCode);
+        const hints = additionalHints ? [...baseHints, ...additionalHints] : [...baseHints];
+        const structuredError = {
+            code: errorCode || 'UNKNOWN_ERROR',
+            message: err.message || 'Unknown error occurred',
+            hints,
+        };
+        return {
+            success: false,
+            error: structuredError,
+            metadata: {
+                executionTimeMs,
+                backend: this.type,
+            },
+        };
+    }
+    createFieldInfo(name, type = 'unknown', nullable = true) {
+        return {
+            name,
+            type,
+            nullable,
+            key: null,
+            default: null,
+            extra: null,
+        };
+    }
+}
+export { loadDbConfig as getConfigFromEnv } from './config-loader';

package/dist/db-tools/core/config-loader.d.ts

@@ -0,0 +1,3 @@
+import type { IConnectionConfig } from '../interface';
+export declare function loadDbConfig(): IConnectionConfig;
+export declare function getConfigFromEnv(): IConnectionConfig;

package/dist/db-tools/core/config-loader.js

@@ -0,0 +1,46 @@
+import path from 'path';
+import { readJsoncFile } from './jsonc-parser';
+import { validateBaseConfig } from '../interface/connection';
+export function loadDbConfig() {
+    const configPath = path.join(process.cwd(), 'env.jsonc');
+    let rawConfig;
+    try {
+        rawConfig = readJsoncFile(configPath);
+    }
+    catch (error) {
+        throw new Error(`Failed to load env.jsonc from ${configPath}.\n` +
+            `Reason: ${error instanceof Error ? error.message : String(error)}\n` +
+            `Create env.jsonc in your working directory by using the "env-jsonc-setup" skill.\n` +
+            `Load the skill and follow the guided setup to create your database configuration.`);
+    }
+    const envJsonc = rawConfig;
+    if (!envJsonc['db-tools']) {
+        throw new Error(`Missing "db-tools" section in env.jsonc.\n` +
+            `Use the "env-jsonc-setup" skill to recreate the configuration file, or\n` +
+            `manually add a "db-tools" object with your database configuration.`);
+    }
+    const dbConfig = envJsonc['db-tools'];
+    const rawType = dbConfig.type || 'mysql';
+    const validTypes = ['mysql', 'mongodb'];
+    if (!validTypes.includes(rawType)) {
+        throw new Error(`Invalid type "${rawType}" in db-tools config. Supported types: ${validTypes.join(', ')}`);
+    }
+    const type = rawType;
+    const baseConfig = {
+        type,
+        host: dbConfig.host || 'localhost',
+        port: dbConfig.port || (type === 'mongodb' ? 27017 : 3306),
+        database: dbConfig.database || '',
+        username: dbConfig.username,
+        password: dbConfig.password,
+        connectionTimeout: dbConfig.connectionTimeout || 10000,
+    };
+    if (type === 'mongodb' && dbConfig.uri) {
+        baseConfig.options = { uri: dbConfig.uri };
+    }
+    validateBaseConfig(baseConfig);
+    return baseConfig;
+}
+export function getConfigFromEnv() {
+    return loadDbConfig();
+}

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

@@ -0,0 +1,2 @@
+export * from './validator';
+export * from './base';

package/dist/db-tools/core/index.js

@@ -0,0 +1,2 @@
+export * from './validator';
+export * from './base';

package/dist/db-tools/core/jsonc-parser.d.ts

@@ -0,0 +1,2 @@
+export declare function parseJsonc(text: string): unknown;
+export declare function readJsoncFile(filePath: string): unknown;

package/dist/db-tools/core/jsonc-parser.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+export function parseJsonc(text) {
+    let result = '';
+    let i = 0;
+    const len = text.length;
+    let inString = false;
+    let stringQuote = null;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+    while (i < len) {
+        const char = text[i];
+        const nextChar = i + 1 < len ? text[i + 1] : null;
+        if (inLineComment) {
+            if (char === '\n') {
+                inLineComment = false;
+                result += char;
+            }
+        }
+        else if (inBlockComment) {
+            if (char === '*' && nextChar === '/') {
+                inBlockComment = false;
+                i += 2;
+                continue;
+            }
+        }
+        else if (inString) {
+            if (escaped) {
+                result += char;
+                escaped = false;
+            }
+            else if (char === '\\') {
+                result += char;
+                escaped = true;
+            }
+            else if (char === stringQuote) {
+                result += char;
+                inString = false;
+                stringQuote = null;
+            }
+            else {
+                result += char;
+            }
+        }
+        else {
+            if (char === '"' || char === "'") {
+                inString = true;
+                stringQuote = char;
+                result += char;
+            }
+            else if (char === '/' && nextChar === '/') {
+                inLineComment = true;
+                i += 2;
+                continue;
+            }
+            else if (char === '/' && nextChar === '*') {
+                inBlockComment = true;
+                i += 2;
+                continue;
+            }
+            else {
+                result += char;
+            }
+        }
+        i++;
+    }
+    return JSON.parse(result);
+}
+export function readJsoncFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Configuration file not found: ${absolutePath}`);
+    }
+    const content = fs.readFileSync(absolutePath, 'utf-8');
+    return parseJsonc(content);
+}

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

@@ -0,0 +1,16 @@
+import type { IQueryResult } from '../interface';
+export interface ValidationResult {
+    valid: boolean;
+    error?: IQueryResult;
+}
+export declare function validateReadOnlyQuery(sql: string, backendType: string): ValidationResult;
+export declare function validateCollectionName(name: string, backendType: string): ValidationResult;
+export declare const ERROR_HINTS: {
+    readonly CONNECTION: readonly ["Check that the database server is running", "Verify DB_HOST and DB_PORT environment variables", "Ensure network connectivity to the database"];
+    readonly AUTH: readonly ["Verify DB_USER and DB_PASSWORD environment variables", "Check that the user has permissions for the database"];
+    readonly UNKNOWN_TABLE: readonly ["Use dbListTables to see available collections/tables", "Check the collection/table name for typos"];
+    readonly UNKNOWN_COLUMN: readonly ["Use dbDescribeTable to see available columns/fields", "Check the column/field name for typos"];
+    readonly SYNTAX: readonly ["Check your SQL syntax", "Ensure all identifiers are properly quoted if needed"];
+    readonly GENERIC: readonly ["Check your query syntax", "Use dbListTables to see available collections/tables", "Use dbDescribeTable to check column/field names"];
+};
+export declare function getErrorHints(errorCode: string | undefined): readonly string[];

package/dist/db-tools/core/validator.js

@@ -0,0 +1,118 @@
+const FORBIDDEN_KEYWORDS = [
+    'INSERT', 'UPDATE', 'DELETE', 'DROP', 'CREATE',
+    'ALTER', 'TRUNCATE', 'GRANT', 'REVOKE', 'EXEC', 'EXECUTE'
+];
+export function validateReadOnlyQuery(sql, backendType) {
+    const trimmed = sql.trim();
+    if (!trimmed) {
+        return {
+            valid: false,
+            error: createValidationError('EMPTY_QUERY', 'SQL query cannot be empty', ['Provide a valid SELECT query'], backendType),
+        };
+    }
+    if (trimmed.includes(';')) {
+        return {
+            valid: false,
+            error: createValidationError('MULTIPLE_STATEMENTS', 'Multiple SQL statements are not allowed (semicolon detected)', ['Remove the semicolon and use only one SELECT statement'], backendType),
+        };
+    }
+    const upper = trimmed.toUpperCase();
+    if (!upper.startsWith('SELECT') && !upper.startsWith('SHOW') && !upper.startsWith('DESCRIBE') && !upper.startsWith('EXPLAIN')) {
+        return {
+            valid: false,
+            error: createValidationError('NOT_READ_ONLY', 'Only SELECT, SHOW, DESCRIBE, and EXPLAIN queries are allowed. This toolkit is read-only.', ['Use a SELECT statement to query data'], backendType),
+        };
+    }
+    for (const keyword of FORBIDDEN_KEYWORDS) {
+        const regex = new RegExp(`\\b${keyword}\\b`, 'i');
+        if (regex.test(trimmed)) {
+            return {
+                valid: false,
+                error: createValidationError('FORBIDDEN_KEYWORD', `Forbidden keyword detected: ${keyword}. This toolkit is read-only.`, ['Remove the forbidden keyword', 'Only read-only queries are permitted'], backendType),
+            };
+        }
+    }
+    return { valid: true };
+}
+export function validateCollectionName(name, backendType) {
+    const TABLE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    if (!name || !name.trim()) {
+        return {
+            valid: false,
+            error: createValidationError('EMPTY_COLLECTION_NAME', 'Collection/table name cannot be empty', ['Provide a valid collection/table name', 'Use dbListTables to see available collections'], backendType),
+        };
+    }
+    if (!TABLE_NAME_REGEX.test(name)) {
+        return {
+            valid: false,
+            error: createValidationError('INVALID_COLLECTION_NAME', `Invalid collection/table name format: '${name}'`, [
+                'Names must start with a letter or underscore',
+                'Names can only contain letters, numbers, and underscores',
+                'Use dbListTables to see valid names',
+            ], backendType),
+        };
+    }
+    return { valid: true };
+}
+function createValidationError(code, message, hints, backendType) {
+    const error = {
+        code,
+        message,
+        hints,
+    };
+    const metadata = {
+        executionTimeMs: 0,
+        backend: backendType,
+    };
+    return {
+        success: false,
+        error,
+        metadata,
+    };
+}
+export const ERROR_HINTS = {
+    CONNECTION: [
+        'Check that the database server is running',
+        'Verify DB_HOST and DB_PORT environment variables',
+        'Ensure network connectivity to the database',
+    ],
+    AUTH: [
+        'Verify DB_USER and DB_PASSWORD environment variables',
+        'Check that the user has permissions for the database',
+    ],
+    UNKNOWN_TABLE: [
+        'Use dbListTables to see available collections/tables',
+        'Check the collection/table name for typos',
+    ],
+    UNKNOWN_COLUMN: [
+        'Use dbDescribeTable to see available columns/fields',
+        'Check the column/field name for typos',
+    ],
+    SYNTAX: [
+        'Check your SQL syntax',
+        'Ensure all identifiers are properly quoted if needed',
+    ],
+    GENERIC: [
+        'Check your query syntax',
+        'Use dbListTables to see available collections/tables',
+        'Use dbDescribeTable to check column/field names',
+    ],
+};
+export function getErrorHints(errorCode) {
+    const hintMap = {
+        'ECONNREFUSED': ERROR_HINTS.CONNECTION,
+        'ETIMEDOUT': ERROR_HINTS.CONNECTION,
+        'ENOTFOUND': ERROR_HINTS.CONNECTION,
+        'ER_ACCESS_DENIED_ERROR': ERROR_HINTS.AUTH,
+        'ER_BAD_DB_ERROR': ERROR_HINTS.AUTH,
+        'ER_NO_SUCH_TABLE': ERROR_HINTS.UNKNOWN_TABLE,
+        'ER_BAD_TABLE_ERROR': ERROR_HINTS.UNKNOWN_TABLE,
+        'ER_BAD_FIELD_ERROR': ERROR_HINTS.UNKNOWN_COLUMN,
+        'ER_UNKNOWN_COLUMN': ERROR_HINTS.UNKNOWN_COLUMN,
+        'ER_PARSE_ERROR': ERROR_HINTS.SYNTAX,
+        'ER_SYNTAX_ERROR': ERROR_HINTS.SYNTAX,
+        'MongoServerError': ERROR_HINTS.AUTH,
+        'MongoNetworkError': ERROR_HINTS.CONNECTION,
+    };
+    return hintMap[errorCode ?? ''] ?? ERROR_HINTS.GENERIC;
+}

package/dist/db-tools/executor.d.ts

@@ -0,0 +1,13 @@
+import * as mysql from 'mysql2/promise';
+import type { DbConfig, QueryResponse } from './types';
+type QueryParams = Record<string, unknown> | unknown[];
+interface ExecuteQueryOptions {
+    sql: string;
+    params?: QueryParams;
+}
+export declare function getConfigFromEnv(): DbConfig;
+export declare function validateConfig(config: DbConfig): void;
+export declare function executeQuery(options: ExecuteQueryOptions): Promise<QueryResponse>;
+export declare function executeRawQuery<T extends mysql.RowDataPacket[]>(sql: string, params?: QueryParams): Promise<[T, mysql.FieldPacket[]]>;
+export { getPool } from './pool';
+export { closePool } from './pool';

package/dist/db-tools/executor.js

@@ -0,0 +1,54 @@
+import { DEFAULT_CONFIG as defaultConfig } from './types';
+import { formatQueryResult, formatQueryError } from './utils';
+import { getPool } from './pool';
+export function getConfigFromEnv() {
+    const envConfig = {
+        host: process.env.DB_HOST || defaultConfig.host,
+        port: parseInt(process.env.DB_PORT || '', 10) || defaultConfig.port,
+        user: process.env.DB_USER || '',
+        password: process.env.DB_PASSWORD || '',
+        database: process.env.DB_DATABASE || '',
+        charset: process.env.DB_CHARSET || defaultConfig.charset,
+        connectionTimeout: parseInt(process.env.DB_CONNECTION_TIMEOUT || '', 10) || defaultConfig.connectionTimeout,
+    };
+    return envConfig;
+}
+export function validateConfig(config) {
+    const missing = [];
+    if (!config.user)
+        missing.push('DB_USER');
+    if (!config.database)
+        missing.push('DB_DATABASE');
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+    if (config.port < 1 || config.port > 65535) {
+        throw new Error(`Invalid port number: ${config.port}. Must be between 1 and 65535.`);
+    }
+}
+export async function executeQuery(options) {
+    const startTime = Date.now();
+    try {
+        const config = getConfigFromEnv();
+        validateConfig(config);
+        const pool = getPool(config);
+        const params = options.params ?? [];
+        const [rows, fields] = await pool.query(options.sql, params);
+        const executionTimeMs = Date.now() - startTime;
+        return formatQueryResult(rows, fields, executionTimeMs);
+    }
+    catch (error) {
+        const executionTimeMs = Date.now() - startTime;
+        return formatQueryError(error, executionTimeMs);
+    }
+}
+export async function executeRawQuery(sql, params) {
+    const config = getConfigFromEnv();
+    validateConfig(config);
+    const pool = getPool(config);
+    const queryParams = params ?? [];
+    const result = await pool.query(sql, queryParams);
+    return result;
+}
+export { getPool } from './pool';
+export { closePool } from './pool';

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

@@ -0,0 +1,51 @@
+export declare const dbToolsMetadata: {
+    category: string;
+    description: string;
+    capabilities: string[];
+    supportedBackends: string[];
+    typicalWorkflow: string[];
+    configMethod: string;
+    configPath: string;
+};
+export declare const dbTools: {
+    dbQuery: {
+        description: string;
+        args: {
+            sql: import("zod").ZodString;
+            params: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        };
+        execute(args: {
+            sql: string;
+            params?: Record<string, any> | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    dbListTables: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    dbDescribeTable: {
+        description: string;
+        args: {
+            table_name: import("zod").ZodString;
+        };
+        execute(args: {
+            table_name: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+export { dbQuery, dbListTables, dbDescribeTable } from './tools';
+export { createBackend, initializeBackend, closeBackend, getBackend, getDefaultBackend, getSupportedTypes, isBackendSupported, registerBackend, } from './backends';
+export { MySQLBackend, createMySQLBackend, } from './backends/mysql';
+export { MongoDBBackend, createMongoDBBackend, parseSelectQuery, SQLParseError, } from './backends/mongodb';
+export { validateReadOnlyQuery, validateCollectionName, ERROR_HINTS, } from './core/validator';
+export { BaseBackend, getConfigFromEnv, } from './core/base';
+export { loadDbConfig, } from './core/config-loader';
+export { parseJsonc, readJsoncFile, } from './core/jsonc-parser';
+export type { IDatabaseBackend, IWriteableBackend, BackendType, IBackendFactory, } from './interface/backend';
+export type { IConnectionConfig, IConnectionPool, IConnection, DatabaseType, } from './interface/connection';
+export type { IQuery, IQueryOptions, IFieldInfo, IResultMetadata, IStructuredError, IQueryResult, IRow, IInsertResult, IUpdateResult, IDeleteResult, } from './interface/query';
+export type { ICollectionInfo, IColumnSchema, ISchemaResult, } from './interface/schema';
+export type { ValidationResult, } from './core/validator';
+export type { MySQLConnectionConfig } from './backends/mysql/connection';
+export type { MongoDBConnectionConfig } from './backends/mongodb/connection';

package/dist/db-tools/index.js

@@ -0,0 +1,27 @@
+import { dbQuery, dbListTables, dbDescribeTable } from './tools';
+export const dbToolsMetadata = {
+    category: 'database',
+    description: 'Read-only database query tools with multi-backend support',
+    capabilities: ['query', 'list_tables', 'describe_schema'],
+    supportedBackends: ['mysql', 'mongodb'],
+    typicalWorkflow: [
+        '1. Use dbListTables to discover available tables/collections',
+        '2. Use dbDescribeTable to understand column/field schema',
+        '3. Use dbQuery to execute SELECT queries with named parameters',
+    ],
+    configMethod: 'env.jsonc file in working directory',
+    configPath: '<cwd>/env.jsonc with "db-tools" section',
+};
+export const dbTools = {
+    dbQuery,
+    dbListTables,
+    dbDescribeTable,
+};
+export { dbQuery, dbListTables, dbDescribeTable } from './tools';
+export { createBackend, initializeBackend, closeBackend, getBackend, getDefaultBackend, getSupportedTypes, isBackendSupported, registerBackend, } from './backends';
+export { MySQLBackend, createMySQLBackend, } from './backends/mysql';
+export { MongoDBBackend, createMongoDBBackend, parseSelectQuery, SQLParseError, } from './backends/mongodb';
+export { validateReadOnlyQuery, validateCollectionName, ERROR_HINTS, } from './core/validator';
+export { BaseBackend, getConfigFromEnv, } from './core/base';
+export { loadDbConfig, } from './core/config-loader';
+export { parseJsonc, readJsoncFile, } from './core/jsonc-parser';

package/dist/db-tools/interface/backend.d.ts

@@ -0,0 +1,24 @@
+import type { IConnectionConfig, IConnectionPool } from './connection';
+import type { IQuery, IQueryResult, IInsertResult, IUpdateResult, IDeleteResult } from './query';
+import type { ICollectionInfo, IColumnSchema } from './schema';
+export interface IDatabaseBackend {
+    readonly type: string;
+    readonly config: IConnectionConfig;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getPool(): IConnectionPool | null;
+    executeQuery(query: IQuery): Promise<IQueryResult>;
+    listCollections(): Promise<ICollectionInfo[]>;
+    describeCollection(name: string): Promise<IColumnSchema[]>;
+}
+export interface IWriteableBackend extends IDatabaseBackend {
+    insert(collection: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<IInsertResult>;
+    update(collection: string, filter: Record<string, unknown>, data: Record<string, unknown>): Promise<IUpdateResult>;
+    delete(collection: string, filter: Record<string, unknown>): Promise<IDeleteResult>;
+}
+export type BackendType = 'mysql' | 'mongodb';
+export interface IBackendFactory {
+    create(config: IConnectionConfig): IDatabaseBackend;
+    getSupportedTypes(): BackendType[];
+}

package/dist/db-tools/interface/backend.js

@@ -0,0 +1 @@
+export {};

package/dist/db-tools/interface/connection.d.ts

@@ -0,0 +1,21 @@
+export type DatabaseType = 'mysql' | 'mongodb';
+export interface IConnectionConfig {
+    type: DatabaseType;
+    host: string;
+    port: number;
+    database: string;
+    username?: string;
+    password?: string;
+    connectionTimeout?: number;
+    options?: Record<string, unknown>;
+}
+export interface IConnectionPool {
+    getConnection(): Promise<IConnection>;
+    end(): Promise<void>;
+    isHealthy(): boolean;
+}
+export interface IConnection {
+    isConnected(): boolean;
+    close(): Promise<void>;
+}
+export declare function validateBaseConfig(config: IConnectionConfig): void;

package/dist/db-tools/interface/connection.js

@@ -0,0 +1,11 @@
+export function validateBaseConfig(config) {
+    const missing = [];
+    if (!config.database)
+        missing.push('DB_DATABASE');
+    if (missing.length > 0) {
+        throw new Error(`Missing required configuration: ${missing.join(', ')}`);
+    }
+    if (config.port < 1 || config.port > 65535) {
+        throw new Error(`Invalid port number: ${config.port}. Must be between 1 and 65535.`);
+    }
+}

package/dist/db-tools/interface/index.d.ts

@@ -0,0 +1,4 @@
+export * from './backend';
+export * from './connection';
+export * from './query';
+export * from './schema';

package/dist/db-tools/interface/index.js

@@ -0,0 +1,4 @@
+export * from './backend';
+export * from './connection';
+export * from './query';
+export * from './schema';

package/dist/db-tools/interface/query.d.ts

@@ -0,0 +1,60 @@
+export interface IQuery {
+    sql: string;
+    params?: Record<string, unknown> | unknown[];
+    options?: IQueryOptions;
+}
+export interface IQueryOptions {
+    timeout?: number;
+    limit?: number;
+    offset?: number;
+}
+export interface IFieldInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    key: string | null;
+    default: unknown;
+    extra: string | null;
+}
+export interface IResultMetadata {
+    executionTimeMs: number;
+    backend: string;
+    [key: string]: unknown;
+}
+export interface IStructuredError {
+    code: string;
+    message: string;
+    details?: string;
+    hints?: string[];
+}
+export interface IQueryResult {
+    success: boolean;
+    data?: {
+        rows: IRow[];
+        rowCount: number;
+        fields: IFieldInfo[];
+    };
+    error?: IStructuredError;
+    metadata: IResultMetadata;
+}
+export type IRow = Record<string, unknown>;
+export interface IInsertResult {
+    success: boolean;
+    insertedId?: unknown;
+    insertedCount?: number;
+    error?: IStructuredError;
+    metadata: IResultMetadata;
+}
+export interface IUpdateResult {
+    success: boolean;
+    matchedCount?: number;
+    modifiedCount?: number;
+    error?: IStructuredError;
+    metadata: IResultMetadata;
+}
+export interface IDeleteResult {
+    success: boolean;
+    deletedCount?: number;
+    error?: IStructuredError;
+    metadata: IResultMetadata;
+}

package/dist/db-tools/interface/query.js

@@ -0,0 +1 @@
+export {};

package/dist/db-tools/interface/schema.d.ts

@@ -0,0 +1,22 @@
+export interface ICollectionInfo {
+    name: string;
+    type: 'table' | 'view' | 'collection';
+    engine?: string | null;
+    rowCount?: number | null;
+    createdAt?: string | null;
+    comment?: string | null;
+}
+export interface IColumnSchema {
+    field: string;
+    type: string;
+    nullable: boolean;
+    key: string | null;
+    defaultValue: unknown;
+    extra: string | null;
+    comment?: string | null;
+}
+export interface ISchemaResult {
+    collection: string;
+    columns: IColumnSchema[];
+    columnCount: number;
+}

package/dist/db-tools/interface/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/db-tools/pool.d.ts

@@ -0,0 +1,8 @@
+import * as mysql from 'mysql2/promise';
+import type { DbConfig } from './types';
+export declare function getPool(config: DbConfig): mysql.Pool;
+export declare function closePool(): Promise<void>;
+export declare function getPoolStatus(): {
+    initialized: boolean;
+    hasConfig: boolean;
+};