mysql-orm-lite 1.0.1 → 2.1.0

package/dist/lib/crud.js

@@ -0,0 +1,435 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = exports.deleteWhere = exports.updateQuery = exports.updateWhere = exports.query = exports.findWhere = exports.select = exports.buildAndExecuteDeleteQuery = exports.buildAndExecuteUpdateQuery = exports.buildAndExecuteSelectQuery = exports.bulkUpsert = exports.upsert = exports.bulkInsert = exports.delete = exports._delete = exports.update = exports.insert = exports.findCount = exports.find = exports.utils = void 0;
+const connectionManager_1 = __importDefault(require("./connectionManager"));
+const performanceMonitor_1 = __importDefault(require("./performanceMonitor"));
+exports.utils = {
+    handleConnectionError(err) {
+        const errorMessages = {
+            PROTOCOL_CONNECTION_LOST: 'Database connection was closed.',
+            ER_CON_COUNT_ERROR: 'Database has too many connections.',
+            ECONNREFUSED: 'Database connection was refused.',
+            POOL_CLOSED: 'Connection pool was closed'
+        };
+        return new Error(errorMessages[err.code] || err.message);
+    },
+    logQueryPerformance(query, startTime, params = []) {
+        const logger = connectionManager_1.default.getLogger();
+        const duration = Date.now() - startTime;
+        if (duration > 1000) {
+            logger.warn(' Slow Query ================================================================== ');
+            logger.warn(` Execution Time: ${duration}ms`);
+            logger.warn(` Query: ${query}`);
+            if (params.length)
+                logger.warn(` Parameters: ${JSON.stringify(params)}`);
+            logger.warn(' =========================================================================== ');
+        }
+        return duration;
+    },
+    async executeQuery({ query, params = [], dbConfig, operation = 'query' }) {
+        const startTime = Date.now();
+        const logger = connectionManager_1.default.getLogger();
+        try {
+            const pool = await connectionManager_1.default.getPool(dbConfig);
+            const [results] = await pool.query(query, params);
+            const duration = this.logQueryPerformance(query, startTime, params);
+            // Record in performance monitor if enabled
+            performanceMonitor_1.default.recordQuery(query, duration, params);
+            return results;
+        }
+        catch (error) {
+            logger.error(`${operation} Error: ${error.message}`);
+            logger.error(`Query: ${query}`);
+            if (params.length)
+                logger.error('Parameters:', JSON.stringify(params));
+            throw error;
+        }
+    },
+    validateUpdateParams(table, data, query) {
+        const errors = [];
+        if (!table || typeof table !== 'string')
+            errors.push('Invalid table name');
+        else if (!/^[a-zA-Z0-9_]+$/.test(table))
+            errors.push('Table name contains invalid characters');
+        if (!data || typeof data !== 'object' || Array.isArray(data))
+            errors.push('Data must be a non-null object');
+        else if (Object.keys(data).length === 0)
+            errors.push('Data object cannot be empty');
+        if (!query || typeof query !== 'string')
+            errors.push('Invalid WHERE clause');
+        else if (!query.toLowerCase().includes('where'))
+            errors.push('WHERE clause is required for security');
+        return errors;
+    },
+    prepareUpdateParams(data) {
+        const setFields = [];
+        const params = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined)
+                continue;
+            if (value && typeof value === 'object' && value.__raw) {
+                setFields.push(`${key} = ${value.value}`);
+                continue;
+            }
+            if (value === null) {
+                setFields.push(`${key} = NULL`);
+            }
+            else {
+                setFields.push(`${key} = ?`);
+                params.push(value);
+            }
+        }
+        return { setFields, params };
+    },
+    _buildWhereClause(conditions) {
+        const params = [];
+        const buildCondition = (key, value) => {
+            const column = key;
+            if (value === null)
+                return `${column} IS NULL`;
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                return Object.entries(value).map(([op, val]) => {
+                    switch (op) {
+                        case '$eq':
+                            params.push(val);
+                            return `${column} = ?`;
+                        case '$ne':
+                            params.push(val);
+                            return `${column} != ?`;
+                        case '$gt':
+                            params.push(val);
+                            return `${column} > ?`;
+                        case '$gte':
+                            params.push(val);
+                            return `${column} >= ?`;
+                        case '$lt':
+                            params.push(val);
+                            return `${column} < ?`;
+                        case '$lte':
+                            params.push(val);
+                            return `${column} <= ?`;
+                        case '$in':
+                            if (!val.length)
+                                return 'FALSE';
+                            params.push(...val);
+                            return `${column} IN (${val.map(() => '?').join(', ')})`;
+                        case '$notIn':
+                        case '$nIn':
+                        case '$nin':
+                            if (!val.length)
+                                return 'TRUE';
+                            params.push(...val);
+                            return `${column} NOT IN (${val.map(() => '?').join(', ')})`;
+                        case '$like':
+                            params.push(val);
+                            return `${column} LIKE ?`;
+                        case '$between':
+                            if (val.length !== 2)
+                                throw new Error('$between requires [min, max]');
+                            params.push(val[0], val[1]);
+                            return `${column} BETWEEN ? AND ?`;
+                        default: throw new Error(`Unsupported operator: ${op}`);
+                    }
+                }).join(' AND ');
+            }
+            params.push(value);
+            return `${column} = ?`;
+        };
+        const walk = (cond) => {
+            if (!cond || typeof cond !== 'object')
+                return '';
+            if (Array.isArray(cond))
+                return cond.map(walk).join(' AND ');
+            if ('$and' in cond)
+                return `(${cond.$and.map(walk).join(' AND ')})`;
+            if ('$or' in cond)
+                return `(${cond.$or.map(walk).join(' OR ')})`;
+            if ('$not' in cond)
+                return `(NOT ${walk(cond.$not)})`;
+            return Object.entries(cond).map(([k, v]) => buildCondition(k, v)).join(' AND ');
+        };
+        const clause = walk(conditions);
+        return { clause, params };
+    },
+    _buildSelectQuery(options) {
+        let { table, fields = '*', joins = [], where, orderBy, limit, offset, groupBy, having, alias, forUpdate = false } = options;
+        if (fields && Array.isArray(fields) && fields.length > 0) {
+            fields = fields.filter(field => field && field.trim() !== '').join(', ');
+        }
+        else if (fields && Array.isArray(fields)) {
+            fields = '*';
+        }
+        let query = `SELECT ${fields} FROM ${table}${alias ? ' ' + alias : ''}`;
+        const allParams = [];
+        for (const join of joins) {
+            let { type = 'INNER', table: joinTable, alias, on } = join;
+            const onClause = Array.isArray(on) ? on.join(' AND ') : on;
+            query += ` ${type.toUpperCase()} JOIN ${joinTable}${alias ? ' ' + alias : ''} ON ${onClause}`;
+        }
+        if (where) {
+            const { clause, params } = this._buildWhereClause(where);
+            if (clause) {
+                query += ` WHERE ${clause}`;
+                allParams.push(...params);
+            }
+        }
+        if (groupBy)
+            query += ` GROUP BY ${groupBy}`;
+        if (having)
+            query += ` HAVING ${having}`;
+        if (orderBy)
+            query += ` ORDER BY ${orderBy}`;
+        if (typeof limit === 'number' && limit && limit > 0) {
+            query += ` LIMIT ${limit}`;
+            if (typeof offset === 'number')
+                query += ` OFFSET ${offset}`;
+        }
+        if (forUpdate) {
+            query += ' FOR UPDATE';
+        }
+        return { query, params: allParams };
+    },
+    _buildUpdateQuery(options) {
+        const { table, data, where } = options;
+        const { setFields, params } = this.prepareUpdateParams(data);
+        if (setFields.length === 0)
+            throw new Error('No valid fields to update');
+        let query = `UPDATE ${table} SET ${setFields.join(', ')}`;
+        const allParams = [...params];
+        if (where) {
+            const { clause, params: whereParams } = this._buildWhereClause(where);
+            if (clause) {
+                query += ` WHERE ${clause}`;
+                allParams.push(...whereParams);
+            }
+        }
+        return { query, params: allParams };
+    },
+    _buildDeleteQuery(options) {
+        const { table, where } = options;
+        if (!table)
+            throw new Error('Table name is required for delete');
+        let query = `DELETE FROM ${table}`;
+        const allParams = [];
+        if (where) {
+            const { clause, params: whereParams } = this._buildWhereClause(where);
+            if (clause) {
+                query += ` WHERE ${clause}`;
+                allParams.push(...whereParams);
+            }
+            else {
+                throw new Error('DELETE requires a valid WHERE clause for safety');
+            }
+        }
+        else {
+            throw new Error('DELETE requires a WHERE clause for safety');
+        }
+        return { query, params: allParams };
+    }
+};
+// Public API
+const find = async function (query, params = [], dbConfig) {
+    if (!query)
+        return [];
+    return await exports.utils.executeQuery({ query, params, dbConfig, operation: 'find' });
+};
+exports.find = find;
+const findCount = async function (query, params = [], dbConfig) {
+    if (!query)
+        return 0;
+    const results = await exports.utils.executeQuery({ query, params, dbConfig, operation: 'findCount' });
+    return results && results[0] ? results[0].count : 0;
+};
+exports.findCount = findCount;
+const insert = async function (table, data, dbConfig, debug = false, isIgnore = false) {
+    if (!table || !data || typeof data !== 'object')
+        throw new Error('Invalid table or data');
+    const logger = connectionManager_1.default.getLogger();
+    const fields = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = fields.map(() => '?').join(', ');
+    const sql = isIgnore
+        ? `INSERT IGNORE INTO ${table} (${fields.join(', ')}) VALUES (${placeholders})`
+        : `INSERT INTO ${table} (${fields.join(', ')}) VALUES (${placeholders})`;
+    const result = await exports.utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'insert' });
+    if (debug) {
+        logger.info({ operation: 'INSERT', table, insertId: result.insertId });
+    }
+    return result.insertId;
+};
+exports.insert = insert;
+const update = async function (table, data, query, dbConfig, debug = false) {
+    const errors = exports.utils.validateUpdateParams(table, data, query);
+    if (errors.length > 0)
+        throw new Error(`Validation failed: ${errors.join(', ')}`);
+    const logger = connectionManager_1.default.getLogger();
+    const { setFields, params } = exports.utils.prepareUpdateParams(data);
+    if (setFields.length === 0)
+        throw new Error('No valid fields to update');
+    const sql = `UPDATE ${table} SET ${setFields.join(', ')} ${query}`;
+    const result = await exports.utils.executeQuery({ query: sql, params, dbConfig, operation: 'update' });
+    if (debug) {
+        logger.info({ operation: 'UPDATE', table, affectedRows: result.affectedRows });
+    }
+    return result.affectedRows;
+};
+exports.update = update;
+const _delete = async function (query, table, dbConfig) {
+    if (!query || !query.toLowerCase().includes('where'))
+        throw new Error('Invalid query or missing WHERE clause');
+    const logger = connectionManager_1.default.getLogger();
+    const sql = table ? `DELETE FROM ${table} ${query}` : query;
+    const result = await exports.utils.executeQuery({ query: sql, params: [], dbConfig, operation: 'delete' });
+    logger.info(`Deleted ${result.affectedRows} records from ${table || 'custom query'}`);
+    return result.affectedRows;
+};
+exports._delete = _delete;
+exports.delete = exports._delete;
+// Bulk Operations
+const bulkInsert = async function (table, records, options, dbConfig) {
+    if (!table || !records || !Array.isArray(records) || records.length === 0) {
+        throw new Error('Table name and records are required for bulk insert');
+    }
+    const batchSize = options?.batchSize || 1000;
+    const isIgnore = options?.ignore || false;
+    const logger = connectionManager_1.default.getLogger();
+    // Validate all records have the same fields
+    const fields = Object.keys(records[0]);
+    for (const record of records) {
+        const recordFields = Object.keys(record);
+        if (recordFields.length !== fields.length || !recordFields.every(f => fields.includes(f))) {
+            throw new Error('All records must have the same fields for bulk insert');
+        }
+    }
+    let totalInserted = 0;
+    let firstInsertId;
+    let lastInsertId;
+    const batches = Math.ceil(records.length / batchSize);
+    for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const values = [];
+        const placeholders = [];
+        for (const record of batch) {
+            const recordValues = fields.map(field => record[field]);
+            values.push(...recordValues);
+            placeholders.push(`(${fields.map(() => '?').join(', ')})`);
+        }
+        const sql = isIgnore
+            ? `INSERT IGNORE INTO ${table} (${fields.join(', ')}) VALUES ${placeholders.join(', ')}`
+            : `INSERT INTO ${table} (${fields.join(', ')}) VALUES ${placeholders.join(', ')}`;
+        const result = await exports.utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'bulkInsert' });
+        totalInserted += result.affectedRows || 0;
+        if (i === 0 && result.insertId) {
+            firstInsertId = result.insertId;
+        }
+        if (result.insertId) {
+            lastInsertId = result.insertId + (result.affectedRows || 1) - 1;
+        }
+    }
+    logger.info(`Bulk inserted ${totalInserted} records into ${table} in ${batches} batches`);
+    return {
+        totalInserted,
+        batches,
+        firstInsertId,
+        lastInsertId
+    };
+};
+exports.bulkInsert = bulkInsert;
+const upsert = async function (table, data, options, dbConfig) {
+    if (!table || !data || !options.conflictKey) {
+        throw new Error('Table, data, and conflictKey are required for upsert');
+    }
+    const fields = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = fields.map(() => '?').join(', ');
+    // Determine which fields to update on duplicate key
+    const conflictKeys = Array.isArray(options.conflictKey) ? options.conflictKey : [options.conflictKey];
+    const updateFields = options.updateFields || fields.filter(f => !conflictKeys.includes(f));
+    if (updateFields.length === 0) {
+        throw new Error('No fields to update on duplicate key');
+    }
+    // Build UPDATE clause
+    const updateClause = updateFields.map(field => `${field} = VALUES(${field})`).join(', ');
+    const sql = `INSERT INTO ${table} (${fields.join(', ')}) VALUES (${placeholders}) ON DUPLICATE KEY UPDATE ${updateClause}`;
+    const result = await exports.utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'upsert' });
+    // affectedRows = 1 means inserted, 2 means updated, 0 means no change
+    const action = result.affectedRows === 1 ? 'inserted' : 'updated';
+    return {
+        action,
+        affectedRows: result.affectedRows,
+        insertId: result.insertId
+    };
+};
+exports.upsert = upsert;
+const bulkUpsert = async function (table, records, options, dbConfig) {
+    if (!table || !records || records.length === 0) {
+        throw new Error('Table name and records are required for bulk upsert');
+    }
+    const batchSize = options?.batchSize || 1000;
+    const logger = connectionManager_1.default.getLogger();
+    // Validate all records have the same fields
+    const fields = Object.keys(records[0]);
+    for (const record of records) {
+        const recordFields = Object.keys(record);
+        if (recordFields.length !== fields.length || !recordFields.every(f => fields.includes(f))) {
+            throw new Error('All records must have the same fields for bulk upsert');
+        }
+    }
+    // Determine which fields to update on duplicate key
+    const conflictKeys = Array.isArray(options.conflictKey) ? options.conflictKey : [options.conflictKey];
+    const updateFields = options.updateFields || fields.filter(f => !conflictKeys.includes(f));
+    if (updateFields.length === 0) {
+        throw new Error('No fields to update on duplicate key');
+    }
+    const updateClause = updateFields.map(field => `${field} = VALUES(${field})`).join(', ');
+    let totalAffected = 0;
+    const batches = Math.ceil(records.length / batchSize);
+    for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const values = [];
+        const placeholders = [];
+        for (const record of batch) {
+            const recordValues = fields.map(field => record[field]);
+            values.push(...recordValues);
+            placeholders.push(`(${fields.map(() => '?').join(', ')})`);
+        }
+        const sql = `INSERT INTO ${table} (${fields.join(', ')}) VALUES ${placeholders.join(', ')} ON DUPLICATE KEY UPDATE ${updateClause}`;
+        const result = await exports.utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'bulkUpsert' });
+        totalAffected += result.affectedRows || 0;
+    }
+    logger.info(`Bulk upsert affected ${totalAffected} records in ${table} in ${batches} batches`);
+    return {
+        totalAffected,
+        batches
+    };
+};
+exports.bulkUpsert = bulkUpsert;
+// Query Builder Methods
+const buildAndExecuteSelectQuery = async function (options, dbConfig) {
+    const { query, params } = exports.utils._buildSelectQuery(options);
+    return await exports.utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteSelectQuery' });
+};
+exports.buildAndExecuteSelectQuery = buildAndExecuteSelectQuery;
+const buildAndExecuteUpdateQuery = async function (options, dbConfig) {
+    const { query, params } = exports.utils._buildUpdateQuery(options);
+    const result = await exports.utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteUpdateQuery' });
+    return result.affectedRows;
+};
+exports.buildAndExecuteUpdateQuery = buildAndExecuteUpdateQuery;
+const buildAndExecuteDeleteQuery = async function (options, dbConfig) {
+    const { query, params } = exports.utils._buildDeleteQuery(options);
+    const result = await exports.utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteDeleteQuery' });
+    return result.affectedRows;
+};
+exports.buildAndExecuteDeleteQuery = buildAndExecuteDeleteQuery;
+// Aliases
+exports.select = exports.buildAndExecuteSelectQuery;
+exports.findWhere = exports.buildAndExecuteSelectQuery;
+exports.query = exports.buildAndExecuteSelectQuery;
+exports.updateWhere = exports.buildAndExecuteUpdateQuery;
+exports.updateQuery = exports.buildAndExecuteUpdateQuery;
+exports.deleteWhere = exports.buildAndExecuteDeleteQuery;
+exports.remove = exports.buildAndExecuteDeleteQuery;

package/dist/lib/performanceMonitor.d.ts

@@ -0,0 +1,50 @@
+import { QueryMetric, PerformanceStats } from '../types';
+declare class PerformanceMonitor {
+    private enabled;
+    private queries;
+    private startTime;
+    private queryCountByType;
+    /**
+     * Enable performance monitoring
+     */
+    enable(): void;
+    /**
+     * Disable performance monitoring
+     */
+    disable(): void;
+    /**
+     * Check if monitoring is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Record a query execution
+     */
+    recordQuery(query: string, duration: number, params?: any[]): void;
+    /**
+     * Detect query type from SQL string
+     */
+    private detectQueryType;
+    /**
+     * Get current performance statistics
+     */
+    getStats(): PerformanceStats;
+    /**
+     * Get slowest queries
+     */
+    getSlowQueries(limit?: number): QueryMetric[];
+    /**
+     * Reset all collected metrics
+     */
+    reset(): void;
+    /**
+     * Get queries executed in the last N milliseconds
+     */
+    getRecentQueries(milliseconds?: number): QueryMetric[];
+    /**
+     * Get queries per second
+     */
+    getQueriesPerSecond(): number;
+}
+declare const performanceMonitor: PerformanceMonitor;
+export default performanceMonitor;
+export { performanceMonitor, PerformanceMonitor };

package/dist/lib/performanceMonitor.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMonitor = exports.performanceMonitor = void 0;
+class PerformanceMonitor {
+    enabled = false;
+    queries = [];
+    startTime = 0;
+    queryCountByType = {
+        SELECT: 0,
+        INSERT: 0,
+        UPDATE: 0,
+        DELETE: 0,
+        OTHER: 0
+    };
+    /**
+     * Enable performance monitoring
+     */
+    enable() {
+        this.enabled = true;
+        this.startTime = Date.now();
+        console.log('[Performance Monitor] Enabled');
+    }
+    /**
+     * Disable performance monitoring
+     */
+    disable() {
+        this.enabled = false;
+        console.log('[Performance Monitor] Disabled');
+    }
+    /**
+     * Check if monitoring is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Record a query execution
+     */
+    recordQuery(query, duration, params) {
+        if (!this.enabled)
+            return;
+        const type = this.detectQueryType(query);
+        const metric = {
+            query,
+            duration,
+            timestamp: Date.now(),
+            type,
+            params
+        };
+        this.queries.push(metric);
+        this.queryCountByType[type]++;
+        // Keep only last 1000 queries to prevent memory issues
+        if (this.queries.length > 1000) {
+            this.queries.shift();
+        }
+    }
+    /**
+     * Detect query type from SQL string
+     */
+    detectQueryType(query) {
+        const normalized = query.trim().toUpperCase();
+        if (normalized.startsWith('SELECT'))
+            return 'SELECT';
+        if (normalized.startsWith('INSERT'))
+            return 'INSERT';
+        if (normalized.startsWith('UPDATE'))
+            return 'UPDATE';
+        if (normalized.startsWith('DELETE'))
+            return 'DELETE';
+        return 'OTHER';
+    }
+    /**
+     * Get current performance statistics
+     */
+    getStats() {
+        const totalQueries = this.queries.length;
+        const totalDuration = this.queries.reduce((sum, q) => sum + q.duration, 0);
+        const averageQueryTime = totalQueries > 0 ? totalDuration / totalQueries : 0;
+        const slowestQueries = [...this.queries]
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, 10);
+        return {
+            enabled: this.enabled,
+            totalQueries,
+            averageQueryTime: Math.round(averageQueryTime * 100) / 100,
+            slowestQueries,
+            queryCountByType: { ...this.queryCountByType },
+            startTime: this.startTime,
+            uptime: this.startTime > 0 ? Date.now() - this.startTime : 0
+        };
+    }
+    /**
+     * Get slowest queries
+     */
+    getSlowQueries(limit = 10) {
+        return [...this.queries]
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, limit);
+    }
+    /**
+     * Reset all collected metrics
+     */
+    reset() {
+        this.queries = [];
+        this.queryCountByType = {
+            SELECT: 0,
+            INSERT: 0,
+            UPDATE: 0,
+            DELETE: 0,
+            OTHER: 0
+        };
+        this.startTime = Date.now();
+        console.log('[Performance Monitor] Reset');
+    }
+    /**
+     * Get queries executed in the last N milliseconds
+     */
+    getRecentQueries(milliseconds = 60000) {
+        const cutoff = Date.now() - milliseconds;
+        return this.queries.filter(q => q.timestamp >= cutoff);
+    }
+    /**
+     * Get queries per second
+     */
+    getQueriesPerSecond() {
+        const uptime = this.startTime > 0 ? (Date.now() - this.startTime) / 1000 : 0;
+        return uptime > 0 ? this.queries.length / uptime : 0;
+    }
+}
+exports.PerformanceMonitor = PerformanceMonitor;
+// Singleton instance
+const performanceMonitor = new PerformanceMonitor();
+exports.performanceMonitor = performanceMonitor;
+exports.default = performanceMonitor;

package/dist/lib/schema.d.ts

@@ -0,0 +1,39 @@
+import { DbConfig, ColumnInfo, IndexInfo, ForeignKeyInfo } from '../types';
+declare const schema: {
+    /**
+     * Get list of all tables in the database
+     * @param dbConfig - Optional database configuration
+     * @returns Array of table names
+     */
+    tables(dbConfig?: DbConfig): Promise<string[]>;
+    /**
+     * Get column information for a specific table
+     * @param tableName - Name of the table
+     * @param dbConfig - Optional database configuration
+     * @returns Array of column information
+     */
+    columns(tableName: string, dbConfig?: DbConfig): Promise<ColumnInfo[]>;
+    /**
+     * Get index information for a specific table
+     * @param tableName - Name of the table
+     * @param dbConfig - Optional database configuration
+     * @returns Array of index information
+     */
+    indexes(tableName: string, dbConfig?: DbConfig): Promise<IndexInfo[]>;
+    /**
+     * Get foreign key relationships for a specific table or all tables
+     * @param tableName - Name of the table (optional, if not provided returns all foreign keys)
+     * @param dbConfig - Optional database configuration
+     * @returns Array of foreign key information
+     */
+    foreignKeys(tableName?: string, dbConfig?: DbConfig): Promise<ForeignKeyInfo[]>;
+    /**
+     * Get the correct order to delete/truncate tables based on foreign key dependencies
+     * Uses topological sort to ensure child tables are deleted before parent tables
+     * @param dbConfig - Optional database configuration
+     * @returns Array of table names in deletion order (children first)
+     */
+    deleteOrder(dbConfig?: DbConfig): Promise<string[]>;
+};
+export default schema;
+export { schema };