mysql-orm-lite 1.0.1 → 2.1.0

package/dist/lib/schema.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+const connectionManager_1 = __importDefault(require("./connectionManager"));
+const schema = {
+    /**
+     * Get list of all tables in the database
+     * @param dbConfig - Optional database configuration
+     * @returns Array of table names
+     */
+    async tables(dbConfig) {
+        const pool = await connectionManager_1.default.getPool(dbConfig);
+        const config = dbConfig || connectionManager_1.default.defaultConfig;
+        if (!config || !config.database) {
+            throw new Error('Database name is required for schema introspection');
+        }
+        const query = `
+            SELECT TABLE_NAME 
+            FROM INFORMATION_SCHEMA.TABLES 
+            WHERE TABLE_SCHEMA = ? 
+            AND TABLE_TYPE = 'BASE TABLE'
+            ORDER BY TABLE_NAME
+        `;
+        const [rows] = await pool.query(query, [config.database]);
+        return rows.map(row => row.TABLE_NAME);
+    },
+    /**
+     * Get column information for a specific table
+     * @param tableName - Name of the table
+     * @param dbConfig - Optional database configuration
+     * @returns Array of column information
+     */
+    async columns(tableName, dbConfig) {
+        if (!tableName) {
+            throw new Error('Table name is required');
+        }
+        const pool = await connectionManager_1.default.getPool(dbConfig);
+        const config = dbConfig || connectionManager_1.default.defaultConfig;
+        if (!config || !config.database) {
+            throw new Error('Database name is required for schema introspection');
+        }
+        const query = `
+            SELECT 
+                COLUMN_NAME as name,
+                COLUMN_TYPE as type,
+                IS_NULLABLE as nullable,
+                COLUMN_KEY as \`key\`,
+                COLUMN_DEFAULT as \`default\`,
+                EXTRA as extra
+            FROM INFORMATION_SCHEMA.COLUMNS
+            WHERE TABLE_SCHEMA = ?
+            AND TABLE_NAME = ?
+            ORDER BY ORDINAL_POSITION
+        `;
+        const [rows] = await pool.query(query, [config.database, tableName]);
+        return rows.map(row => ({
+            name: row.name,
+            type: row.type,
+            nullable: row.nullable === 'YES',
+            key: row.key || '',
+            default: row.default,
+            extra: row.extra || ''
+        }));
+    },
+    /**
+     * Get index information for a specific table
+     * @param tableName - Name of the table
+     * @param dbConfig - Optional database configuration
+     * @returns Array of index information
+     */
+    async indexes(tableName, dbConfig) {
+        if (!tableName) {
+            throw new Error('Table name is required');
+        }
+        const pool = await connectionManager_1.default.getPool(dbConfig);
+        const config = dbConfig || connectionManager_1.default.defaultConfig;
+        if (!config || !config.database) {
+            throw new Error('Database name is required for schema introspection');
+        }
+        const query = `
+            SELECT 
+                INDEX_NAME as name,
+                COLUMN_NAME as \`column\`,
+                NON_UNIQUE as non_unique,
+                INDEX_TYPE as type
+            FROM INFORMATION_SCHEMA.STATISTICS
+            WHERE TABLE_SCHEMA = ?
+            AND TABLE_NAME = ?
+            ORDER BY INDEX_NAME, SEQ_IN_INDEX
+        `;
+        const [rows] = await pool.query(query, [config.database, tableName]);
+        return rows.map(row => ({
+            name: row.name,
+            column: row.column,
+            unique: row.non_unique === 0,
+            type: row.type
+        }));
+    },
+    /**
+     * 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
+     */
+    async foreignKeys(tableName, dbConfig) {
+        const pool = await connectionManager_1.default.getPool(dbConfig);
+        const config = dbConfig || connectionManager_1.default.defaultConfig;
+        if (!config || !config.database) {
+            throw new Error('Database name is required for schema introspection');
+        }
+        let query = `
+            SELECT 
+                TABLE_NAME as childTable,
+                REFERENCED_TABLE_NAME as parentTable,
+                CONSTRAINT_NAME as constraintName,
+                COLUMN_NAME as columnName,
+                REFERENCED_COLUMN_NAME as referencedColumnName
+            FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+            WHERE TABLE_SCHEMA = ?
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        `;
+        const params = [config.database];
+        if (tableName) {
+            query += ` AND (TABLE_NAME = ? OR REFERENCED_TABLE_NAME = ?)`;
+            params.push(tableName, tableName);
+        }
+        query += ` ORDER BY TABLE_NAME, ORDINAL_POSITION`;
+        const [rows] = await pool.query(query, params);
+        return rows;
+    },
+    /**
+     * 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)
+     */
+    async deleteOrder(dbConfig) {
+        const foreignKeys = await this.foreignKeys(undefined, dbConfig);
+        // Build dependency graph
+        const graph = {};
+        for (const fk of foreignKeys) {
+            if (!graph[fk.childTable]) {
+                graph[fk.childTable] = [];
+            }
+            if (!graph[fk.childTable].includes(fk.parentTable)) {
+                graph[fk.childTable].push(fk.parentTable);
+            }
+        }
+        // Perform topological sort
+        const visited = new Set();
+        const result = [];
+        function visit(table) {
+            if (!visited.has(table)) {
+                visited.add(table);
+                const parents = graph[table] || [];
+                parents.forEach(visit);
+                result.push(table);
+            }
+        }
+        // Visit all child tables
+        Object.keys(graph).forEach(visit);
+        // Include all tables (both parents and children)
+        const allTables = new Set([
+            ...Object.keys(graph),
+            ...Object.values(graph).flat()
+        ]);
+        // Add orphan tables (tables with no dependencies)
+        for (const table of allTables) {
+            if (!visited.has(table)) {
+                result.push(table);
+            }
+        }
+        // Reverse to get child-first order and remove duplicates
+        return [...new Set(result)].reverse();
+    }
+};
+exports.schema = schema;
+exports.default = schema;

package/dist/lib/transactionManager.d.ts

@@ -0,0 +1,9 @@
+import TransactionCRUD from './TransactionCRUD';
+declare const transactionManager: {
+    setInstance: (instance: TransactionCRUD) => void;
+    getInstance: () => TransactionCRUD | null;
+    clearInstance: () => void;
+    hasActiveTransaction: () => boolean;
+};
+export default transactionManager;
+export { transactionManager };

package/{lib → dist/lib}/transactionManager.js

@@ -1,21 +1,21 @@
-'use strict';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionManager = void 0;
 let transactionInstance = null;
-
-module.exports = {
+const transactionManager = {
     setInstance: (instance) => {
         transactionInstance = instance;
     },
-
     getInstance: () => {
         return transactionInstance || null;
     },
-
     clearInstance: () => {
         transactionInstance = null;
     },
-
     hasActiveTransaction: () => {
+        // Accessing private property via any cast since it's an internal check
         return transactionInstance !== null && transactionInstance.transactionActive;
     }
 };
+exports.transactionManager = transactionManager;
+exports.default = transactionManager;

package/dist/types.d.ts

@@ -0,0 +1,124 @@
+export interface DbConfig {
+    host?: string;
+    user?: string;
+    password?: string;
+    database?: string;
+    port?: number;
+    connectionLimit?: number;
+    [key: string]: any;
+}
+export interface Logger {
+    info: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+}
+export interface JoinOptions {
+    type?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+    table: string;
+    alias?: string;
+    on: string | string[];
+}
+export interface WhereConditions {
+    [key: string]: any;
+}
+export interface SelectOptions {
+    table: string;
+    fields?: string | string[];
+    joins?: JoinOptions[];
+    where?: WhereConditions;
+    orderBy?: string;
+    limit?: number;
+    offset?: number;
+    groupBy?: string;
+    having?: string;
+    alias?: string;
+    forUpdate?: boolean;
+}
+export interface UpdateOptions {
+    table: string;
+    data: Record<string, any>;
+    where?: WhereConditions;
+}
+export interface DeleteOptions {
+    table: string;
+    where: WhereConditions;
+}
+export interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    key: string;
+    default: string | null;
+    extra: string;
+}
+export interface IndexInfo {
+    name: string;
+    column: string;
+    unique: boolean;
+    type: string;
+}
+export interface ForeignKeyInfo {
+    childTable: string;
+    parentTable: string;
+    constraintName: string;
+    columnName: string;
+    referencedColumnName: string;
+}
+export interface DependencyGraph {
+    [childTable: string]: string[];
+}
+export interface QueryMetric {
+    query: string;
+    duration: number;
+    timestamp: number;
+    type: 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'OTHER';
+    params?: any[];
+}
+export interface ConnectionPoolStats {
+    activeConnections: number;
+    idleConnections: number;
+    totalConnections: number;
+    waitingRequests: number;
+}
+export interface PerformanceStats {
+    enabled: boolean;
+    totalQueries: number;
+    averageQueryTime: number;
+    slowestQueries: QueryMetric[];
+    queryCountByType: {
+        SELECT: number;
+        INSERT: number;
+        UPDATE: number;
+        DELETE: number;
+        OTHER: number;
+    };
+    startTime: number;
+    uptime: number;
+}
+export interface BulkInsertOptions {
+    batchSize?: number;
+    ignore?: boolean;
+}
+export interface BulkInsertResult {
+    totalInserted: number;
+    batches: number;
+    firstInsertId?: number;
+    lastInsertId?: number;
+}
+export interface UpsertOptions {
+    conflictKey: string | string[];
+    updateFields?: string[];
+}
+export interface UpsertResult {
+    action: 'inserted' | 'updated';
+    affectedRows: number;
+    insertId?: number;
+}
+export interface BulkUpsertOptions extends BulkInsertOptions {
+    conflictKey: string | string[];
+    updateFields?: string[];
+}
+export interface BulkUpsertResult {
+    totalAffected: number;
+    batches: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "mysql-orm-lite",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "description": "A lightweight ORM for MySQL with connection pooling, query builder, and transaction support",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "private": false,
   "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
@@ -36,6 +39,9 @@
     "mysql2": "^3.0.0"
   },
   "devDependencies": {
-    "mysql2": "^3.11.5"
+    "@types/node": "^25.2.1",
+    "mysql2": "^3.11.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,76 @@
+import connectionManager from './lib/connectionManager';
+import * as crud from './lib/crud';
+import TransactionCRUD from './lib/TransactionCRUD';
+import transactionManager from './lib/transactionManager';
+import schema from './lib/schema';
+import performanceMonitor from './lib/performanceMonitor';
+
+export {
+    connectionManager,
+    transactionManager,
+    TransactionCRUD,
+    schema,
+    performanceMonitor
+};
+
+// CRUD Operations (Non-transactional)
+export const find = crud.find;
+export const findCount = crud.findCount;
+export const insert = crud.insert;
+export const update = crud.update;
+export const _delete = crud.delete;
+export { _delete as delete };
+
+// Bulk Operations
+export const bulkInsert = crud.bulkInsert;
+export const upsert = crud.upsert;
+export const bulkUpsert = crud.bulkUpsert;
+
+// Query Builder - Full names
+export const buildAndExecuteSelectQuery = crud.buildAndExecuteSelectQuery;
+export const buildAndExecuteUpdateQuery = crud.buildAndExecuteUpdateQuery;
+export const buildAndExecuteDeleteQuery = crud.buildAndExecuteDeleteQuery;
+
+// Query Builder - Alternative shorter names
+export const select = crud.select;
+export const findWhere = crud.findWhere;
+export const query = crud.query;
+export const updateWhere = crud.updateWhere;
+export const updateQuery = crud.updateQuery;
+export const deleteWhere = crud.deleteWhere;
+export const remove = crud.remove;
+
+// Utility exports
+export const utils = crud.utils;
+
+// Convenience method to create transaction
+export const createTransaction = () => new TransactionCRUD();
+
+// Default export for CJS compatibility and convenience
+export default {
+    connectionManager,
+    transactionManager,
+    TransactionCRUD,
+    schema,
+    performanceMonitor,
+    find,
+    findCount,
+    insert,
+    update,
+    delete: _delete,
+    buildAndExecuteSelectQuery,
+    buildAndExecuteUpdateQuery,
+    buildAndExecuteDeleteQuery,
+    select,
+    findWhere,
+    query,
+    updateWhere,
+    updateQuery,
+    deleteWhere,
+    remove,
+    utils,
+    createTransaction,
+    bulkInsert,
+    upsert,
+    bulkUpsert
+};

package/{lib/TransactionCRUD.js → src/lib/TransactionCRUD.ts}

@@ -1,8 +1,12 @@
-'use strict';
-const connectionManager = require('./connectionManager');
-const crudUtils = require('./crud').utils;
+import connectionManager from './connectionManager';
+import { utils as crudUtils } from './crud';
+import { DbConfig, SelectOptions, UpdateOptions, DeleteOptions } from '../types';
 
 class TransactionCRUD {
+    private connection: any = null;
+    private transactionActive: boolean = false;
+    public debug: boolean = false;
+
     constructor() {
         this.connection = null;
         this.transactionActive = false;
@@ -11,9 +15,9 @@ class TransactionCRUD {
 
     /**
      * Initialize a transaction
-     * @param {Object} dbConfig - Database configuration (optional)
+     * @param dbConfig - Database configuration (optional)
      */
-    async init(dbConfig) {
+    async init(dbConfig?: DbConfig): Promise<any> {
         const logger = connectionManager.getLogger();
         try {
             const pool = await connectionManager.getPool(dbConfig);
@@ -37,7 +41,7 @@ class TransactionCRUD {
     /**
      * Execute a query within the transaction
      */
-    async executeQuery(query, params = [], operation = 'TRANS_QUERY') {
+    async executeQuery(query: string, params: any[] = [], operation = 'TRANS_QUERY'): Promise<any> {
         if (!this.connection || !this.transactionActive) {
             throw new Error('No active transaction. Call init() first.');
         }
@@ -53,7 +57,7 @@ class TransactionCRUD {
             }
 
             return results;
-        } catch (error) {
+        } catch (error: any) {
             logger.error(`${operation} Failed: ${error.message}`);
             logger.error(`Query: ${query}`);
             throw error;
@@ -63,7 +67,7 @@ class TransactionCRUD {
     /**
      * Commit the transaction
      */
-    async commit() {
+    async commit(): Promise<void> {
         if (!this.connection || !this.transactionActive) {
             throw new Error('No active transaction to commit');
         }
@@ -84,7 +88,7 @@ class TransactionCRUD {
     /**
      * Rollback the transaction
      */
-    async rollback() {
+    async rollback(): Promise<void> {
         if (!this.connection) return;
 
         const logger = connectionManager.getLogger();
@@ -98,7 +102,7 @@ class TransactionCRUD {
         }
     }
 
-    _cleanup() {
+    private _cleanup(): void {
         if (this.connection) {
             this.connection.release();
             this.connection = null;
@@ -108,11 +112,11 @@ class TransactionCRUD {
 
     // CRUD Methods
 
-    async find(query, params = []) {
+    async find(query: string, params: any[] = []): Promise<any[]> {
         return await this.executeQuery(query, params, 'TRANS_FIND');
     }
 
-    async insert(table, data) {
+    async insert(table: string, data: Record<string, any>): Promise<any> {
         if (!table || !data) throw new Error('Invalid table or data');
         const fields = Object.keys(data);
         const values = Object.values(data);
@@ -123,7 +127,7 @@ class TransactionCRUD {
         return result.insertId;
     }
 
-    async update(table, data, query) {
+    async update(table: string, data: Record<string, any>, query: string): Promise<number> {
         if (!query || !query.toLowerCase().includes('where')) throw new Error('Update requires WHERE');
 
         const { setFields, params } = crudUtils.prepareUpdateParams(data);
@@ -133,14 +137,14 @@ class TransactionCRUD {
         return result.affectedRows;
     }
 
-    async delete(query, table) {
+    async delete(query: string, table?: string): Promise<number> {
         if (!query || !query.toLowerCase().includes('where')) throw new Error('Delete requires WHERE');
         const sql = table ? `DELETE FROM ${table} ${query}` : query;
         const result = await this.executeQuery(sql, [], 'TRANS_DELETE');
         return result.affectedRows;
     }
 
-    async buildAndExecuteSelectQuery(options = {}) {
+    async buildAndExecuteSelectQuery(options: SelectOptions): Promise<any[]> {
         const logger = connectionManager.getLogger();
         try {
             const { query, params } = crudUtils._buildSelectQuery(options);
@@ -151,7 +155,7 @@ class TransactionCRUD {
         }
     }
 
-    async buildAndExecuteUpdateQuery(options = {}) {
+    async buildAndExecuteUpdateQuery(options: UpdateOptions): Promise<number> {
         const logger = connectionManager.getLogger();
         try {
             const { query, params } = crudUtils._buildUpdateQuery(options);
@@ -163,7 +167,7 @@ class TransactionCRUD {
         }
     }
 
-    async buildAndExecuteDeleteQuery(options = {}) {
+    async buildAndExecuteDeleteQuery(options: DeleteOptions): Promise<number> {
         const logger = connectionManager.getLogger();
         try {
             const { query, params } = crudUtils._buildDeleteQuery(options);
@@ -176,38 +180,39 @@ class TransactionCRUD {
     }
 
     // Alternative shorter method names (aliases)
-    async select(options) {
+    async select(options: SelectOptions): Promise<any[]> {
         return this.buildAndExecuteSelectQuery(options);
     }
 
-    async findWhere(options) {
+    async findWhere(options: SelectOptions): Promise<any[]> {
         return this.buildAndExecuteSelectQuery(options);
     }
 
-    async findForUpdate(options) {
+    async findForUpdate(options: SelectOptions): Promise<any[]> {
         options.forUpdate = true;
         return this.buildAndExecuteSelectQuery(options);
     }
 
-    async query(options) {
+    async query(options: SelectOptions): Promise<any[]> {
         return this.buildAndExecuteSelectQuery(options);
     }
 
-    async updateWhere(options) {
+    async updateWhere(options: UpdateOptions): Promise<number> {
         return this.buildAndExecuteUpdateQuery(options);
     }
 
-    async updateQuery(options) {
+    async updateQuery(options: UpdateOptions): Promise<number> {
         return this.buildAndExecuteUpdateQuery(options);
     }
 
-    async deleteWhere(options) {
+    async deleteWhere(options: DeleteOptions): Promise<number> {
         return this.buildAndExecuteDeleteQuery(options);
     }
 
-    async remove(options) {
+    async remove(options: DeleteOptions): Promise<number> {
         return this.buildAndExecuteDeleteQuery(options);
     }
 }
 
-module.exports = TransactionCRUD;
+export default TransactionCRUD;
+export { TransactionCRUD };