@dqcai/sqlite 1.0.0 → 2.0.2

package/README.md

@@ -1,2637 +1,1799 @@
-# @dqcai/sqlite - Universal SQLite Library
+# @dqcai/sqlite - A Universal SQLite Library (@dqcai/sqlite v2.0.1)
 
 ![Universal SQLite](https://img.shields.io/badge/SQLite-Universal-blue)
 ![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue)
 ![Cross Platform](https://img.shields.io/badge/Platform-Universal-green)
 
-Một thư viện SQLite đa nền tảng hỗ trợ **tất cả** các môi trường JavaScript/TypeScript phổ biến với API thống nhất.
+UniversalSQLite là một thư viện SQLite toàn diện, hỗ trợ đa nền tảng, được thiết kế để hoạt động mượt mà trên các môi trường như Browser, Node.js, Deno, Bun và React Native. Thư viện cung cấp giao diện thống nhất để quản lý cơ sở dữ liệu SQLite, bao gồm tạo schema, CRUD, query nâng cao, migration, import/export dữ liệu, và quản lý transaction. Nó sử dụng mô hình DAO (Data Access Object) để tách biệt logic truy cập dữ liệu, hỗ trợ role-based access control, và tích hợp dễ dàng với các framework.
 
-## 🌟 Tính năng nổi bật
+## Features
 
-- ✅ **Universal**: Hoạt động trên Node.js, Browser, Deno, Bun, React Native
-- ✅ **TypeScript**: Hỗ trợ đầy đủ TypeScript với type safety
-- ✅ **Auto-detection**: Tự động phát hiện môi trường và chọn adapter phù hợp
-- ✅ **Query Builder**: Công cụ xây dựng truy vấn mạnh mẽ
-- ✅ **React Native Windows**: Hỗ trợ đặc biệt cho React Native Windows
-- ✅ **Zero Configuration**: Không cần cấu hình phức tạp
+- **Cross-Platform Support**: Hoạt động trên Browser, Node.js, Deno, Bun, React Native (iOS/Android/Windows).
+- **Schema-Based Management**: Tạo và quản lý database từ JSON schema.
+- **DAO Pattern**: UniversalDAO để thực hiện CRUD, query, transaction.
+- **Query Builder**: Xây dựng query phức tạp với join, where, group by, having, union, CTE.
+- **Migration System**: Quản lý migration với up/down scripts.
+- **Data Import/Export**: Hỗ trợ import từ CSV/JSON với mapping, validation, và export to CSV.
+- **Role-Based Access**: Quản lý kết nối dựa trên role người dùng.
+- **Transaction Management**: Hỗ trợ transaction đơn và cross-schema.
+- **Adapters**: Tự động detect môi trường, hỗ trợ register adapter tùy chỉnh.
+- **Type-Safe**: Đầy đủ types TypeScript cho schema, query, và operations.
+- **Utilities**: CSVImporter, MigrationManager, BaseService cho service layer.
+- **DatabaseManager**: Quản lý kết nối, schema và vai trò người dùng
+- **BaseService**: Lớp cơ sở cho CRUD operations
 
-## 🚀 Cài đặt
+## Installation
+
+Cài đặt qua npm hoặc yarn:
 
 ```bash
-npm install @dqcai/sqlite
+npm install @dqcai/sqlite@2.0.0
+# hoặc
+yarn add @dqcai/sqlite@2.0.0
 ```
 
-### Cài đặt dependencies theo môi trường
+Đối với React Native, đảm bảo cài đặt các dependencies cần thiết cho adapter (nếu sử dụng adapter cụ thể như react-native-sqlite-storage).
+
+## Cài đặt
 
-#### Node.js
 ```bash
-npm install sqlite3
+npm install @dqcai/sqlite
 ```
 
-#### Browser
-Không cần cài đặt thêm - sử dụng sql.js từ CDN
+## 1. Cấu hình Schema Database
+
+Trước tiên, định nghĩa schema cho cơ sở dữ liệu:
+
+```typescript
+import { DatabaseSchema } from '@dqcai/sqlite';
+
+// Schema cho database users
+const userSchema: DatabaseSchema = {
+  version: "1.0.0",
+  database_name: "users",
+  description: "User management database",
+  schemas: {
+    users: {
+      description: "User table",
+      cols: [
+        {
+          name: "id",
+          type: "integer",
+          primary_key: true,
+          auto_increment: true,
+          nullable: false
+        },
+        {
+          name: "username",
+          type: "varchar",
+          nullable: false,
+          unique: true,
+          length: 50
+        },
+        {
+          name: "email",
+          type: "varchar",
+          nullable: false,
+          unique: true,
+          length: 100
+        },
+        {
+          name: "password",
+          type: "varchar",
+          nullable: false,
+          length: 255
+        },
+        {
+          name: "created_at",
+          type: "datetime",
+          nullable: false,
+          default: "CURRENT_TIMESTAMP"
+        },
+        {
+          name: "updated_at",
+          type: "datetime",
+          nullable: true
+        }
+      ],
+      indexes: [
+        {
+          name: "idx_username",
+          columns: ["username"],
+          unique: true
+        },
+        {
+          name: "idx_email", 
+          columns: ["email"],
+          unique: true
+        }
+      ]
+    },
+    profiles: {
+      description: "User profiles table",
+      cols: [
+        {
+          name: "id",
+          type: "integer",
+          primary_key: true,
+          auto_increment: true
+        },
+        {
+          name: "user_id",
+          type: "integer",
+          nullable: false
+        },
+        {
+          name: "first_name",
+          type: "varchar",
+          length: 50
+        },
+        {
+          name: "last_name",
+          type: "varchar", 
+          length: 50
+        },
+        {
+          name: "phone",
+          type: "varchar",
+          length: 20
+        },
+        {
+          name: "address",
+          type: "text"
+        }
+      ],
+      foreign_keys: [
+        {
+          name: "fk_profile_user",
+          column: "user_id",
+          references: {
+            table: "users",
+            column: "id"
+          },
+          on_delete: "CASCADE",
+          on_update: "CASCADE"
+        }
+      ]
+    }
+  }
+};
+
+// Schema core cho hệ thống
+const coreSchema: DatabaseSchema = {
+  version: "1.0.0",
+  database_name: "core",
+  description: "Core system database",
+  schemas: {
+    settings: {
+      description: "System settings",
+      cols: [
+        {
+          name: "key",
+          type: "varchar",
+          primary_key: true,
+          length: 100
+        },
+        {
+          name: "value",
+          type: "text"
+        },
+        {
+          name: "description",
+          type: "text"
+        }
+      ]
+    }
+  }
+};
+```
 
-#### Deno
-Không cần cài đặt - sử dụng Deno SQLite module
+## 2. Setup cho React Native
 
-#### Bun
-Sử dụng built-in SQLite của Bun
+### Cài đặt dependencies
 
-#### React Native
 ```bash
-# Standard React Native
-npm install react-native-sqlite-storage
-# hoặc
-npm install expo-sqlite
-
-# React Native Windows
 npm install react-native-sqlite-2
-# hoặc
-npm install react-native-windows-sqlite
+# Hoặc
+npm install react-native-sqlite-storage
 ```
 
-## 📖 Sử dụng cơ bản
-
-### Import thư viện
+### Tạo Adapter cho React Native
 
 ```typescript
-import UniversalSQLite, { SQLiteManager, QueryBuilder } from '@dqcai/sqlite';
+// adapters/ReactNativeAdapter.ts
+import { BaseAdapter } from '@dqcai/sqlite';
+import SQLite from 'react-native-sqlite-2';
+
+export class ReactNativeAdapter extends BaseAdapter {
+  isSupported(): boolean {
+    return typeof SQLite !== 'undefined';
+  }
+
+  async connect(path: string): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const db = SQLite.openDatabase(
+        path,
+        '1.0',
+        'Database',
+        200000,
+        () => {
+          resolve(new ReactNativeConnection(db));
+        },
+        (error) => {
+          reject(error);
+        }
+      );
+    });
+  }
+}
+
+class ReactNativeConnection {
+  constructor(private db: any) {}
+
+  async execute(sql: string, params: any[] = []): Promise<any> {
+    return new Promise((resolve, reject) => {
+      this.db.transaction((tx: any) => {
+        tx.executeSql(
+          sql,
+          params,
+          (tx: any, results: any) => {
+            const rows: any[] = [];
+            for (let i = 0; i < results.rows.length; i++) {
+              rows.push(results.rows.item(i));
+            }
+            resolve({
+              rows,
+              rowsAffected: results.rowsAffected,
+              lastInsertRowId: results.insertId
+            });
+          },
+          (tx: any, error: any) => {
+            reject(error);
+          }
+        );
+      });
+    });
+  }
+
+  async close(): Promise<void> {
+    // React Native SQLite không cần close thủ công
+    return Promise.resolve();
+  }
+}
 ```
 
-### Kết nối và sử dụng đơn giản
+### Khởi tạo DatabaseManager (React Native)
 
 ```typescript
-const db = new UniversalSQLite();
+// services/DatabaseService.ts
+import { DatabaseManager, DatabaseFactory } from '@dqcai/sqlite';
+import { ReactNativeAdapter } from '../adapters/ReactNativeAdapter';
 
-async function basicExample() {
-  try {
-    // Kết nối đến database
-    await db.connect('myapp.db');
-    
-    // Tạo bảng
-    await db.createTable('users', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      name: 'TEXT NOT NULL',
-      email: 'TEXT UNIQUE',
-      created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-    
-    // Thêm dữ liệu
-    await db.insert('users', {
-      name: 'John Doe',
-      email: 'john@example.com'
+export class DatabaseService {
+  private static isInitialized = false;
+
+  static async initialize() {
+    if (this.isInitialized) return;
+
+    // Đăng ký adapter
+    DatabaseFactory.registerAdapter(new ReactNativeAdapter());
+
+    // Đăng ký schemas
+    DatabaseManager.registerSchemas({
+      core: coreSchema,
+      users: userSchema
     });
-    
-    // Truy vấn dữ liệu
-    const users = await db.select('users');
-    console.log('All users:', users.rows);
-    
-    // Tìm kiếm có điều kiện
-    const john = await db.select('users', 'name = ?', ['John Doe']);
-    console.log('John:', john.rows[0]);
-    
-    // Cập nhật
-    await db.update('users', 
-      { email: 'john.doe@example.com' }, 
-      'name = ?', 
-      ['John Doe']
-    );
-    
-    // Xóa
-    await db.delete('users', 'id = ?', [1]);
-    
-  } catch (error) {
-    console.error('Database error:', error);
-  } finally {
-    await db.close();
+
+    // Đăng ký roles
+    DatabaseManager.registerRoles([
+      {
+        roleName: 'admin',
+        requiredDatabases: ['core', 'users'],
+        priority: 1
+      },
+      {
+        roleName: 'user',
+        requiredDatabases: ['core'],
+        optionalDatabases: ['users'],
+        priority: 2
+      }
+    ]);
+
+    // Khởi tạo core database
+    await DatabaseManager.initializeCoreConnection();
+
+    this.isInitialized = true;
+    console.log('DatabaseService initialized for React Native');
+  }
+
+  static async setUserRole(roles: string[]) {
+    await DatabaseManager.setCurrentUserRoles(roles);
+  }
+
+  static getConnection(dbKey: string) {
+    return DatabaseManager.get(dbKey);
   }
-}
 
-basicExample();
+  static async closeAll() {
+    await DatabaseManager.closeAll();
+    this.isInitialized = false;
+  }
+}
 ```
 
-## 🔧 API Chi tiết
+## 3. Setup cho Node.js
 
-### UniversalSQLite Class
+### Cài đặt dependencies
 
-#### Khởi tạo
-```typescript
-const db = new UniversalSQLite();
+```bash
+npm install sqlite3
+# Hoặc 
+npm install better-sqlite3
 ```
 
-#### Phương thức chính
+### Tạo Adapter cho Node.js
 
-##### `connect(path: string): Promise<void>`
 ```typescript
-// In-memory database
-await db.connect(':memory:');
+// adapters/NodeAdapter.ts
+import { BaseAdapter } from '@dqcai/sqlite';
+import sqlite3 from 'sqlite3';
+import path from 'path';
+import fs from 'fs';
 
-// File database
-await db.connect('database.db');
+export class NodeAdapter extends BaseAdapter {
+  isSupported(): boolean {
+    return typeof process !== 'undefined' && process.versions?.node;
+  }
 
-// Browser (file hoặc in-memory)
-await db.connect('myapp.db');
-```
+  async connect(dbPath: string): Promise<any> {
+    const fullPath = path.resolve(dbPath);
+    
+    // Tạo thư mục nếu chưa tồn tại
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
 
-##### `query(sql: string, params?: any[]): Promise<SQLiteResult>`
-```typescript
-// Truy vấn đơn giản
-const result = await db.query('SELECT * FROM users');
+    return new Promise((resolve, reject) => {
+      const db = new sqlite3.Database(fullPath, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(new NodeConnection(db));
+        }
+      });
+    });
+  }
+}
 
-// Truy vấn với parameters
-const result = await db.query('SELECT * FROM users WHERE age > ?', [18]);
+class NodeConnection {
+  constructor(private db: sqlite3.Database) {}
 
-console.log(result.rows);        // Dữ liệu trả về
-console.log(result.rowsAffected); // Số dòng bị ảnh hưởng
-console.log(result.lastInsertRowId); // ID của dòng mới insert
-```
+  async execute(sql: string, params: any[] = []): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const isSelect = sql.trim().toUpperCase().startsWith('SELECT');
+      
+      if (isSelect) {
+        this.db.all(sql, params, (err, rows) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({
+              rows: rows || [],
+              rowsAffected: 0
+            });
+          }
+        });
+      } else {
+        this.db.run(sql, params, function(err) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({
+              rows: [],
+              rowsAffected: this.changes,
+              lastInsertRowId: this.lastID
+            });
+          }
+        });
+      }
+    });
+  }
 
-##### `createTable(name: string, schema: Record<string, string>): Promise<void>`
-```typescript
-await db.createTable('products', {
-  id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-  name: 'TEXT NOT NULL',
-  price: 'REAL',
-  category_id: 'INTEGER',
-  'FOREIGN KEY (category_id)': 'REFERENCES categories(id)'
-});
+  async close(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.db.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
 ```
 
-##### `insert(table: string, data: Record<string, any>): Promise<SQLiteResult>`
+### Khởi tạo DatabaseManager (Node.js)
+
 ```typescript
-const result = await db.insert('users', {
-  name: 'Alice',
-  email: 'alice@example.com',
-  age: 25
-});
+// services/DatabaseService.ts
+import { DatabaseManager, DatabaseFactory } from '@dqcai/sqlite';
+import { NodeAdapter } from '../adapters/NodeAdapter';
+import path from 'path';
 
-console.log('New user ID:', result.lastInsertRowId);
-```
+export class DatabaseService {
+  private static isInitialized = false;
+  private static dbDirectory = './databases';
 
-##### `select(table: string, where?: string, params?: any[]): Promise<SQLiteResult>`
-```typescript
-// Lấy tất cả
-const allUsers = await db.select('users');
+  static async initialize() {
+    if (this.isInitialized) return;
 
-// Có điều kiện
-const adults = await db.select('users', 'age >= ?', [18]);
+    // Đăng ký adapter
+    DatabaseFactory.registerAdapter(new NodeAdapter());
 
-// Điều kiện phức tạp
-const result = await db.select('users', 'age BETWEEN ? AND ? AND name LIKE ?', [18, 65, 'A%']);
-```
+    // Đăng ký schemas
+    DatabaseManager.registerSchemas({
+      core: coreSchema,
+      users: userSchema
+    });
 
-##### `update(table: string, data: Record<string, any>, where: string, whereParams?: any[]): Promise<SQLiteResult>`
-```typescript
-const result = await db.update('users', 
-  { email: 'newemail@example.com', age: 26 },
-  'id = ?',
-  [1]
-);
+    // Đăng ký roles
+    DatabaseManager.registerRoles([
+      {
+        roleName: 'admin',
+        requiredDatabases: ['core', 'users'],
+        priority: 1
+      },
+      {
+        roleName: 'user', 
+        requiredDatabases: ['core'],
+        optionalDatabases: ['users'],
+        priority: 2
+      }
+    ]);
 
-console.log('Updated rows:', result.rowsAffected);
-```
+    // Khởi tạo core database
+    await DatabaseManager.initializeCoreConnection();
 
-##### `delete(table: string, where: string, params?: any[]): Promise<SQLiteResult>`
-```typescript
-const result = await db.delete('users', 'age < ?', [18]);
-console.log('Deleted rows:', result.rowsAffected);
+    this.isInitialized = true;
+    console.log('DatabaseService initialized for Node.js');
+  }
+
+  static async setUserRole(roles: string[]) {
+    await DatabaseManager.setCurrentUserRoles(roles);
+  }
+
+  static getConnection(dbKey: string) {
+    return DatabaseManager.get(dbKey);
+  }
+
+  static async closeAll() {
+    await DatabaseManager.closeAll();
+    this.isInitialized = false;
+  }
+}
 ```
 
-### QueryBuilder - Xây dựng truy vấn nâng cao
+## 4. Tạo Services với BaseService
+
+### User Service
 
 ```typescript
-import { QueryBuilder } from '@dqcai/sqlite';
-
-// SELECT với QueryBuilder
-const selectSQL = QueryBuilder
-  .table('users')
-  .select(['id', 'name', 'email'])
-  .where('age > 18')
-  .where('status = "active"')
-  .orderBy('name', 'ASC')
-  .limit(10)
-  .offset(0)
-  .toSQL();
-
-console.log(selectSQL);
-// Output: SELECT id, name, email FROM users WHERE age > 18 AND status = "active" ORDER BY name ASC LIMIT 10 OFFSET 0
-
-const result = await db.query(selectSQL);
-
-// INSERT với QueryBuilder
-const insertSQL = QueryBuilder.insert('users', {
-  name: 'Bob',
-  email: 'bob@example.com',
-  age: 30
-});
+// services/UserService.ts
+import { BaseService } from '@dqcai/sqlite';
 
-await db.query(insertSQL, ['Bob', 'bob@example.com', 30]);
+interface User {
+  id?: number;
+  username: string;
+  email: string;
+  password: string;
+  created_at?: string;
+  updated_at?: string;
+}
 
-// UPDATE với QueryBuilder
-const updateSQL = QueryBuilder.update('users', 
-  { email: 'bob.updated@example.com' }, 
-  'id = 1'
-);
+interface Profile {
+  id?: number;
+  user_id: number;
+  first_name?: string;
+  last_name?: string;
+  phone?: string;
+  address?: string;
+}
 
-await db.query(updateSQL, ['bob.updated@example.com']);
+export class UserService extends BaseService<User> {
+  constructor() {
+    super('users', 'users'); // schema name, table name
+    this.setPrimaryKeyFields(['id']);
+  }
 
-// DELETE với QueryBuilder
-const deleteSQL = QueryBuilder.delete('users', 'age < 18');
-await db.query(deleteSQL);
-```
+  // Tạo user mới
+  async createUser(userData: Omit<User, 'id' | 'created_at' | 'updated_at'>): Promise<User | null> {
+    try {
+      // Kiểm tra email đã tồn tại chưa
+      const existingUser = await this.findFirst({ email: userData.email });
+      if (existingUser) {
+        throw new Error('Email already exists');
+      }
 
-### SQLiteManager - Quản lý kết nối thủ công
+      // Kiểm tra username đã tồn tại chưa  
+      const existingUsername = await this.findFirst({ username: userData.username });
+      if (existingUsername) {
+        throw new Error('Username already exists');
+      }
 
-```typescript
-import { SQLiteManager } from '@dqcai/sqlite';
+      const newUser = await this.create({
+        ...userData,
+        created_at: new Date().toISOString()
+      });
 
-const manager = new SQLiteManager();
+      return newUser;
+    } catch (error) {
+      console.error('Error creating user:', error);
+      throw error;
+    }
+  }
 
-// Kiểm tra môi trường
-console.log('Environment:', manager.getEnvironmentInfo());
+  // Cập nhật user
+  async updateUser(id: number, userData: Partial<User>): Promise<User | null> {
+    try {
+      const updatedUser = await this.update(id, {
+        ...userData,
+        updated_at: new Date().toISOString()
+      });
+      return updatedUser;
+    } catch (error) {
+      console.error('Error updating user:', error);
+      throw error;
+    }
+  }
 
-// Kết nối thủ công
-const connection = await manager.connect('database.db');
+  // Tìm user theo email
+  async findByEmail(email: string): Promise<User | null> {
+    return await this.findFirst({ email });
+  }
 
-// Thực thi truy vấn
-const result = await connection.execute('SELECT * FROM users');
+  // Tìm user theo username
+  async findByUsername(username: string): Promise<User | null> {
+    return await this.findFirst({ username });
+  }
 
-// Đóng kết nối
-await connection.close();
-```
+  // Lấy tất cả users với phân trang
+  async getAllUsers(page: number = 1, limit: number = 10): Promise<User[]> {
+    const offset = (page - 1) * limit;
+    return await this.findAll({}, {
+      orderBy: [{ name: 'created_at', direction: 'DESC' }],
+      limit,
+      offset
+    });
+  }
 
-## 🌍 Ví dụ theo môi trường
+  // Xóa user (soft delete bằng cách cập nhật trường deleted_at)
+  async softDeleteUser(id: number): Promise<boolean> {
+    const result = await this.update(id, {
+      updated_at: new Date().toISOString(),
+      // deleted_at: new Date().toISOString() // nếu có field này trong schema
+    });
+    return result !== null;
+  }
 
-### Node.js Application
+  // Đếm tổng số users
+  async getTotalUsers(): Promise<number> {
+    return await this.count();
+  }
 
-```typescript
-// server.js
-import UniversalSQLite from '@dqcai/sqlite';
+  // Tìm kiếm users
+  async searchUsers(searchTerm: string): Promise<User[]> {
+    const dao = await this.init().then(() => this.dao!);
+    const sql = `
+      SELECT * FROM users 
+      WHERE username LIKE ? OR email LIKE ?
+      ORDER BY created_at DESC
+    `;
+    const params = [`%${searchTerm}%`, `%${searchTerm}%`];
+    const result = await dao.execute(sql, params);
+    return result.rows as User[];
+  }
+}
 
-const db = new UniversalSQLite();
+export class ProfileService extends BaseService<Profile> {
+  constructor() {
+    super('users', 'profiles');
+    this.setPrimaryKeyFields(['id']);
+  }
 
-async function setupUserSystem() {
-  await db.connect('./users.db');
-  
-  // Tạo bảng users
-  await db.createTable('users', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    username: 'TEXT UNIQUE NOT NULL',
-    password_hash: 'TEXT NOT NULL',
-    email: 'TEXT UNIQUE',
-    created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP',
-    last_login: 'DATETIME'
-  });
-  
-  // Tạo index cho performance
-  await db.query('CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)');
-  
-  console.log('User system ready!');
-}
+  // Tạo profile cho user
+  async createProfile(profileData: Omit<Profile, 'id'>): Promise<Profile | null> {
+    return await this.create(profileData);
+  }
 
-async function createUser(username: string, email: string, passwordHash: string) {
-  return await db.insert('users', {
-    username,
-    email,
-    password_hash: passwordHash
-  });
+  // Lấy profile theo user_id
+  async getProfileByUserId(userId: number): Promise<Profile | null> {
+    return await this.findFirst({ user_id: userId });
+  }
+
+  // Cập nhật profile
+  async updateProfile(id: number, profileData: Partial<Profile>): Promise<Profile | null> {
+    return await this.update(id, profileData);
+  }
+
+  // Lấy thông tin user và profile
+  async getUserWithProfile(userId: number): Promise<any> {
+    const dao = await this.init().then(() => this.dao!);
+    const sql = `
+      SELECT 
+        u.id, u.username, u.email, u.created_at,
+        p.first_name, p.last_name, p.phone, p.address
+      FROM users u
+      LEFT JOIN profiles p ON u.id = p.user_id
+      WHERE u.id = ?
+    `;
+    const result = await dao.execute(sql, [userId]);
+    return result.rows[0] || null;
+  }
 }
+```
+
+### Core Service
+
+```typescript
+// services/CoreService.ts
+import { BaseService } from '@dqcai/sqlite';
 
-async function getUserByEmail(email: string) {
-  const result = await db.select('users', 'email = ?', [email]);
-  return result.rows[0] || null;
+interface Setting {
+  key: string;
+  value: string;
+  description?: string;
 }
 
-setupUserSystem();
-```
+export class SettingsService extends BaseService<Setting> {
+  constructor() {
+    super('core', 'settings');
+    this.setPrimaryKeyFields(['key']);
+  }
 
-### Browser Application
+  // Lấy giá trị setting
+  async getSetting(key: string): Promise<string | null> {
+    const setting = await this.findById(key);
+    return setting?.value || null;
+  }
 
-```html
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Universal SQLite Browser Demo</title>
-</head>
-<body>
-    <div id="app"></div>
+  // Đặt giá trị setting
+  async setSetting(key: string, value: string, description?: string): Promise<void> {
+    const existing = await this.findById(key);
     
-    <script type="module">
-        import UniversalSQLite from './dist/index.js';
-        
-        const db = new UniversalSQLite();
-        
-        async function browserDemo() {
-            try {
-                // Kết nối in-memory database
-                await db.connect(':memory:');
-                
-                // Tạo bảng todos
-                await db.createTable('todos', {
-                    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-                    title: 'TEXT NOT NULL',
-                    completed: 'BOOLEAN DEFAULT 0',
-                    created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-                });
-                
-                // Thêm một số todos
-                await db.insert('todos', { title: 'Learn SQLite', completed: 0 });
-                await db.insert('todos', { title: 'Build awesome app', completed: 0 });
-                
-                // Hiển thị todos
-                const todos = await db.select('todos');
-                document.getElementById('app').innerHTML = `
-                    <h1>My Todos</h1>
-                    <ul>
-                        ${todos.rows.map(todo => 
-                            `<li>${todo.title} - ${todo.completed ? '✅' : '⏳'}</li>`
-                        ).join('')}
-                    </ul>
-                `;
-                
-            } catch (error) {
-                console.error('Error:', error);
-            }
-        }
-        
-        browserDemo();
-    </script>
-</body>
-</html>
-```
-
-### React Native Application
+    if (existing) {
+      await this.update(key, { value, description });
+    } else {
+      await this.create({ key, value, description });
+    }
+  }
 
-```typescript
-// App.tsx
-import React, { useState, useEffect } from 'react';
-import { View, Text, Button, FlatList } from 'react-native';
-import UniversalSQLite from '@dqcai/sqlite';
+  // Lấy tất cả settings
+  async getAllSettings(): Promise<Setting[]> {
+    return await this.findAll({}, {
+      orderBy: [{ name: 'key', direction: 'ASC' }]
+    });
+  }
 
-const db = new UniversalSQLite();
+  // Xóa setting
+  async deleteSetting(key: string): Promise<boolean> {
+    return await this.delete(key);
+  }
 
-interface User {
-  id: number;
-  name: string;
-  email: string;
+  // Lấy nhiều settings cùng lúc
+  async getMultipleSettings(keys: string[]): Promise<Record<string, string>> {
+    const dao = await this.init().then(() => this.dao!);
+    const placeholders = keys.map(() => '?').join(',');
+    const sql = `SELECT key, value FROM settings WHERE key IN (${placeholders})`;
+    const result = await dao.execute(sql, keys);
+    
+    const settings: Record<string, string> = {};
+    result.rows.forEach(row => {
+      settings[row.key] = row.value;
+    });
+    
+    return settings;
+  }
 }
+```
+
+## 5. Sử dụng trong ứng dụng
 
-export default function App() {
-  const [users, setUsers] = useState<User[]>([]);
-  const [environment, setEnvironment] = useState<string>('');
+### Trong React Native
+
+```typescript
+// App.tsx hoặc index.js
+import React, { useEffect, useState } from 'react';
+import { View, Text, Button, Alert } from 'react-native';
+import { DatabaseService } from './services/DatabaseService';
+import { UserService, ProfileService } from './services/UserService';
+import { SettingsService } from './services/CoreService';
+
+const App = () => {
+  const [isDbReady, setIsDbReady] = useState(false);
+  const [userService] = useState(new UserService());
+  const [profileService] = useState(new ProfileService());
+  const [settingsService] = useState(new SettingsService());
 
   useEffect(() => {
-    initDatabase();
+    initializeDatabase();
+    
+    return () => {
+      // Cleanup khi component unmount
+      DatabaseService.closeAll();
+    };
   }, []);
 
-  const initDatabase = async () => {
+  const initializeDatabase = async () => {
     try {
-      // Kết nối database
-      await db.connect('myapp.db');
+      // Khởi tạo database
+      await DatabaseService.initialize();
       
-      // Hiển thị môi trường
-      setEnvironment(db.getEnvironment());
-      
-      // Tạo bảng
-      await db.createTable('users', {
-        id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-        name: 'TEXT NOT NULL',
-        email: 'TEXT UNIQUE'
-      });
+      // Đặt role cho user hiện tại
+      await DatabaseService.setUserRole(['user']);
       
-      // Load dữ liệu
-      loadUsers();
+      // Khởi tạo services
+      await userService.init();
+      await profileService.init();
+      await settingsService.init();
       
+      setIsDbReady(true);
+      console.log('Database ready!');
+    } catch (error) {
+      console.error('Database initialization failed:', error);
+      Alert.alert('Error', 'Failed to initialize database');
+    }
+  };
+
+  const handleCreateUser = async () => {
+    if (!isDbReady) return;
+
+    try {
+      const newUser = await userService.createUser({
+        username: 'john_doe',
+        email: 'john@example.com',
+        password: 'hashed_password'
+      });
+
+      if (newUser) {
+        // Tạo profile cho user
+        await profileService.createProfile({
+          user_id: newUser.id!,
+          first_name: 'John',
+          last_name: 'Doe',
+          phone: '+1234567890'
+        });
+
+        Alert.alert('Success', 'User created successfully');
+      }
     } catch (error) {
-      console.error('Database init error:', error);
+      console.error('Error creating user:', error);
+      Alert.alert('Error', 'Failed to create user');
     }
   };
 
-  const loadUsers = async () => {
+  const handleGetAllUsers = async () => {
+    if (!isDbReady) return;
+
     try {
-      const result = await db.select('users');
-      setUsers(result.rows);
+      const users = await userService.getAllUsers(1, 10);
+      console.log('Users:', users);
+      Alert.alert('Users', `Found ${users.length} users`);
     } catch (error) {
-      console.error('Load users error:', error);
+      console.error('Error getting users:', error);
     }
   };
 
-  const addUser = async () => {
+  const handleSetSetting = async () => {
+    if (!isDbReady) return;
+
     try {
-      await db.insert('users', {
-        name: `User ${Date.now()}`,
-        email: `user${Date.now()}@example.com`
-      });
-      loadUsers();
+      await settingsService.setSetting(
+        'app_version',
+        '1.0.0',
+        'Current app version'
+      );
+      
+      const version = await settingsService.getSetting('app_version');
+      Alert.alert('Setting', `App version: ${version}`);
     } catch (error) {
-      console.error('Add user error:', error);
+      console.error('Error setting value:', error);
     }
   };
 
   return (
-    <View style={{ flex: 1, padding: 20 }}>
-      <Text>Environment: {environment}</Text>
-      <Button title="Add User" onPress={addUser} />
+    <View style={{ flex: 1, justifyContent: 'center', padding: 20 }}>
+      <Text>Database Status: {isDbReady ? 'Ready' : 'Initializing...'}</Text>
+      
+      <Button
+        title="Create User"
+        onPress={handleCreateUser}
+        disabled={!isDbReady}
+      />
+      
+      <Button
+        title="Get All Users"
+        onPress={handleGetAllUsers}
+        disabled={!isDbReady}
+      />
       
-      <FlatList
-        data={users}
-        keyExtractor={item => item.id.toString()}
-        renderItem={({ item }) => (
-          <View style={{ padding: 10, borderBottomWidth: 1 }}>
-            <Text>{item.name}</Text>
-            <Text>{item.email}</Text>
-          </View>
-        )}
+      <Button
+        title="Set App Setting"
+        onPress={handleSetSetting}
+        disabled={!isDbReady}
       />
     </View>
   );
-}
+};
+
+export default App;
 ```
 
-### Deno Application
+### Trong Node.js
 
 ```typescript
-// main.ts
-import UniversalSQLite from "https://esm.sh/@dqcai/sqlite";
+// app.ts
+import express from 'express';
+import { DatabaseService } from './services/DatabaseService';
+import { UserService, ProfileService } from './services/UserService';
+import { SettingsService } from './services/CoreService';
+
+const app = express();
+app.use(express.json());
 
-const db = new UniversalSQLite();
+// Services
+const userService = new UserService();
+const profileService = new ProfileService();
+const settingsService = new SettingsService();
 
-async function denoExample() {
+// Khởi tạo database khi start server
+async function initializeApp() {
   try {
-    await db.connect('./deno_database.db');
+    console.log('Initializing database...');
     
-    // Tạo bảng logs
-    await db.createTable('logs', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      level: 'TEXT NOT NULL',
-      message: 'TEXT NOT NULL',
-      timestamp: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-    
-    // Thêm log entries
-    await db.insert('logs', { level: 'INFO', message: 'Application started' });
-    await db.insert('logs', { level: 'DEBUG', message: 'Database connected' });
-    await db.insert('logs', { level: 'ERROR', message: 'Something went wrong' });
+    // Khởi tạo DatabaseService
+    await DatabaseService.initialize();
     
-    // Truy vấn logs theo level
-    const errorLogs = await db.select('logs', 'level = ?', ['ERROR']);
-    console.log('Error logs:', errorLogs.rows);
+    // Set role admin cho server
+    await DatabaseService.setUserRole(['admin']);
     
-    // Sử dụng QueryBuilder
-    const recentLogs = QueryBuilder
-      .table('logs')
-      .select(['level', 'message', 'timestamp'])
-      .where('timestamp > datetime("now", "-1 hour")')
-      .orderBy('timestamp', 'DESC')
-      .limit(10)
-      .toSQL();
+    // Khởi tạo services
+    await userService.init();
+    await profileService.init();
+    await settingsService.init();
     
-    const result = await db.query(recentLogs);
-    console.log('Recent logs:', result.rows);
-    
-  } finally {
-    await db.close();
+    console.log('Database initialized successfully');
+  } catch (error) {
+    console.error('Database initialization failed:', error);
+    process.exit(1);
   }
 }
 
-// Chạy với: deno run --allow-read --allow-write main.ts
-denoExample();
-```
-
-### Bun Application
+// API Routes
 
-```typescript
-// app.ts
-import UniversalSQLite from '@dqcai/sqlite';
+// POST /users - Tạo user mới
+app.post('/users', async (req, res) => {
+  try {
+    const { username, email, password } = req.body;
+    
+    if (!username || !email || !password) {
+      return res.status(400).json({ error: 'Missing required fields' });
+    }
 
-const db = new UniversalSQLite();
+    const user = await userService.createUser({
+      username,
+      email,
+      password // Nên hash password trước khi lưu
+    });
 
-async function bunExample() {
-  console.log('Environment:', db.getEnvironment()); // "Bun"
-  
-  await db.connect('./bun_database.db');
-  
-  // Tạo bảng products
-  await db.createTable('products', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    name: 'TEXT NOT NULL',
-    price: 'REAL NOT NULL',
-    category: 'TEXT',
-    in_stock: 'BOOLEAN DEFAULT 1'
-  });
-  
-  // Bulk insert
-  const products = [
-    { name: 'Laptop', price: 999.99, category: 'Electronics' },
-    { name: 'Mouse', price: 29.99, category: 'Electronics' },
-    { name: 'Desk', price: 199.99, category: 'Furniture' }
-  ];
-  
-  for (const product of products) {
-    await db.insert('products', product);
+    res.status(201).json({ success: true, user });
+  } catch (error: any) {
+    console.error('Error creating user:', error);
+    res.status(400).json({ error: error.message });
   }
-  
-  // Truy vấn phức tạp
-  const expensiveProducts = await db.query(`
-    SELECT name, price, category 
-    FROM products 
-    WHERE price > ? AND in_stock = 1 
-    ORDER BY price DESC
-  `, [100]);
-  
-  console.log('Expensive products:', expensiveProducts.rows);
-  
-  await db.close();
-}
+});
 
-// Chạy với: bun run app.ts
-bunExample();
-```
+// GET /users - Lấy danh sách users
+app.get('/users', async (req, res) => {
+  try {
+    const page = parseInt(req.query.page as string) || 1;
+    const limit = parseInt(req.query.limit as string) || 10;
+    
+    const users = await userService.getAllUsers(page, limit);
+    const total = await userService.getTotalUsers();
+    
+    res.json({
+      success: true,
+      users,
+      pagination: {
+        page,
+        limit,
+        total,
+        pages: Math.ceil(total / limit)
+      }
+    });
+  } catch (error: any) {
+    console.error('Error getting users:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
 
-## 🏗️ Ví dụ nâng cao
-
-### 1. Transaction Management
-
-```typescript
-import { SQLiteManager } from '@dqcai/sqlite';
-
-async function transactionExample() {
-  const manager = new SQLiteManager();
-  const connection = await manager.connect('transactions.db');
-  
+// GET /users/:id - Lấy user theo ID
+app.get('/users/:id', async (req, res) => {
   try {
-    // Bắt đầu transaction
-    await connection.execute('BEGIN TRANSACTION');
-    
-    // Tạo bảng accounts
-    await connection.execute(`
-      CREATE TABLE IF NOT EXISTS accounts (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        balance REAL DEFAULT 0.00
-      )
-    `);
-    
-    // Thêm accounts
-    await connection.execute('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Alice', 1000]);
-    await connection.execute('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Bob', 500]);
-    
-    // Chuyển tiền từ Alice sang Bob
-    const transferAmount = 200;
-    
-    // Trừ tiền Alice
-    await connection.execute(
-      'UPDATE accounts SET balance = balance - ? WHERE name = ?', 
-      [transferAmount, 'Alice']
-    );
-    
-    // Cộng tiền Bob
-    await connection.execute(
-      'UPDATE accounts SET balance = balance + ? WHERE name = ?', 
-      [transferAmount, 'Bob']
-    );
+    const id = parseInt(req.params.id);
+    const user = await userService.findById(id);
     
-    // Kiểm tra balance không âm
-    const aliceBalance = await connection.execute('SELECT balance FROM accounts WHERE name = ?', ['Alice']);
-    if (aliceBalance.rows[0].balance < 0) {
-      throw new Error('Insufficient funds');
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
     }
     
-    // Commit transaction
-    await connection.execute('COMMIT');
-    console.log('Transfer successful!');
-    
-    // Hiển thị kết quả
-    const allAccounts = await connection.execute('SELECT * FROM accounts');
-    console.log('Final balances:', allAccounts.rows);
-    
-  } catch (error) {
-    // Rollback nếu có lỗi
-    await connection.execute('ROLLBACK');
-    console.error('Transaction failed:', error);
-  } finally {
-    await connection.close();
-  }
-}
-
-transactionExample();
-```
-
-### 2. Complex Queries với JOIN
-
-```typescript
-async function complexQueryExample() {
-  const db = new UniversalSQLite();
-  await db.connect('ecommerce.db');
-  
-  // Tạo schema phức tạp
-  await db.createTable('categories', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    name: 'TEXT NOT NULL UNIQUE',
-    description: 'TEXT'
-  });
-  
-  await db.createTable('products', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    name: 'TEXT NOT NULL',
-    price: 'REAL NOT NULL',
-    category_id: 'INTEGER NOT NULL',
-    'FOREIGN KEY (category_id)': 'REFERENCES categories(id)'
-  });
-  
-  await db.createTable('orders', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    product_id: 'INTEGER NOT NULL',
-    quantity: 'INTEGER NOT NULL',
-    order_date: 'DATETIME DEFAULT CURRENT_TIMESTAMP',
-    'FOREIGN KEY (product_id)': 'REFERENCES products(id)'
-  });
-  
-  // Thêm dữ liệu mẫu
-  await db.insert('categories', { name: 'Electronics', description: 'Electronic devices' });
-  await db.insert('categories', { name: 'Books', description: 'Books and literature' });
-  
-  await db.insert('products', { name: 'iPhone 15', price: 999, category_id: 1 });
-  await db.insert('products', { name: 'MacBook Pro', price: 2499, category_id: 1 });
-  await db.insert('products', { name: 'JavaScript Guide', price: 29.99, category_id: 2 });
-  
-  await db.insert('orders', { product_id: 1, quantity: 2 });
-  await db.insert('orders', { product_id: 2, quantity: 1 });
-  await db.insert('orders', { product_id: 1, quantity: 1 });
-  
-  // Query phức tạp với JOIN
-  const salesReport = await db.query(`
-    SELECT 
-      c.name as category,
-      p.name as product,
-      SUM(o.quantity) as total_sold,
-      SUM(o.quantity * p.price) as total_revenue,
-      AVG(p.price) as avg_price
-    FROM orders o
-    JOIN products p ON o.product_id = p.id
-    JOIN categories c ON p.category_id = c.id
-    GROUP BY c.id, p.id
-    ORDER BY total_revenue DESC
-  `);
-  
-  console.log('Sales Report:', salesReport.rows);
-  
-  // Subquery example
-  const topSellingCategory = await db.query(`
-    SELECT 
-      c.name,
-      (SELECT SUM(quantity) FROM orders o 
-       JOIN products p ON o.product_id = p.id 
-       WHERE p.category_id = c.id) as total_quantity
-    FROM categories c
-    ORDER BY total_quantity DESC
-    LIMIT 1
-  `);
-  
-  console.log('Top selling category:', topSellingCategory.rows[0]);
-  
-  await db.close();
-}
-
-complexQueryExample();
-```
-
-### 3. Real-time Data Synchronization
-
-```typescript
-async function realtimeExample() {
-  const db = new UniversalSQLite();
-  await db.connect('realtime.db');
-  
-  // Tạo bảng cho sync
-  await db.createTable('sync_queue', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    table_name: 'TEXT NOT NULL',
-    operation: 'TEXT NOT NULL', // INSERT, UPDATE, DELETE
-    data: 'TEXT', // JSON data
-    synced: 'BOOLEAN DEFAULT 0',
-    created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-  });
-  
-  await db.createTable('users', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    name: 'TEXT NOT NULL',
-    email: 'TEXT UNIQUE',
-    last_modified: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-  });
-  
-  // Helper function để track changes
-  async function trackChange(table: string, operation: string, data: any) {
-    await db.insert('sync_queue', {
-      table_name: table,
-      operation: operation,
-      data: JSON.stringify(data)
-    });
-  }
-  
-  // Wrapper functions với tracking
-  async function insertUser(userData: any) {
-    const result = await db.insert('users', userData);
-    await trackChange('users', 'INSERT', { ...userData, id: result.lastInsertRowId });
-    return result;
-  }
-  
-  async function updateUser(id: number, userData: any) {
-    const result = await db.update('users', 
-      { ...userData, last_modified: new Date().toISOString() }, 
-      'id = ?', 
-      [id]
-    );
-    await trackChange('users', 'UPDATE', { id, ...userData });
-    return result;
-  }
-  
-  async function deleteUser(id: number) {
-    const result = await db.delete('users', 'id = ?', [id]);
-    await trackChange('users', 'DELETE', { id });
-    return result;
-  }
-  
-  // Sync function
-  async function syncToServer() {
-    const unsyncedChanges = await db.select('sync_queue', 'synced = 0');
-    
-    for (const change of unsyncedChanges.rows) {
-      try {
-        // Giả lập API call
-        console.log(`Syncing ${change.operation} on ${change.table_name}:`, 
-                   JSON.parse(change.data));
-        
-        // Đánh dấu đã sync
-        await db.update('sync_queue', 
-          { synced: 1 }, 
-          'id = ?', 
-          [change.id]
-        );
-        
-      } catch (error) {
-        console.error('Sync failed for change:', change.id, error);
-      }
-    }
+    res.json({ success: true, user });
+  } catch (error: any) {
+    console.error('Error getting user:', error);
+    res.status(500).json({ error: error.message });
   }
-  
-  // Demo usage
-  await insertUser({ name: 'Alice', email: 'alice@example.com' });
-  await insertUser({ name: 'Bob', email: 'bob@example.com' });
-  await updateUser(1, { email: 'alice.updated@example.com' });
-  
-  // Sync changes
-  await syncToServer();
-  
-  await db.close();
-}
-
-realtimeExample();
-```
-
-### 4. Database Migration System
+});
 
-```typescript
-class DatabaseMigration {
-  private db: UniversalSQLite;
-  private currentVersion: number = 0;
-  
-  constructor(db: UniversalSQLite) {
-    this.db = db;
-  }
-  
-  async getCurrentVersion(): Promise<number> {
-    try {
-      const result = await this.db.query('PRAGMA user_version');
-      return result.rows[0].user_version || 0;
-    } catch {
-      return 0;
-    }
-  }
-  
-  async setVersion(version: number): Promise<void> {
-    await this.db.query(`PRAGMA user_version = ${version}`);
-  }
-  
-  async migrate() {
-    this.currentVersion = await this.getCurrentVersion();
-    console.log(`Current database version: ${this.currentVersion}`);
+// PUT /users/:id - Cập nhật user
+app.put('/users/:id', async (req, res) => {
+  try {
+    const id = parseInt(req.params.id);
+    const updates = req.body;
     
-    const migrations = [
-      this.migration1_initial,
-      this.migration2_addUserProfiles,
-      this.migration3_addIndexes,
-      this.migration4_addAuditLog
-    ];
+    const user = await userService.updateUser(id, updates);
     
-    for (let i = this.currentVersion; i < migrations.length; i++) {
-      console.log(`Running migration ${i + 1}...`);
-      await migrations[i].call(this);
-      await this.setVersion(i + 1);
-      console.log(`Migration ${i + 1} completed`);
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
     }
     
-    console.log('All migrations completed!');
-  }
-  
-  // Migration 1: Initial schema
-  private async migration1_initial() {
-    await this.db.createTable('users', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      username: 'TEXT UNIQUE NOT NULL',
-      email: 'TEXT UNIQUE NOT NULL',
-      created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-  }
-  
-  // Migration 2: Add user profiles
-  private async migration2_addUserProfiles() {
-    await this.db.query('ALTER TABLE users ADD COLUMN first_name TEXT');
-    await this.db.query('ALTER TABLE users ADD COLUMN last_name TEXT');
-    await this.db.query('ALTER TABLE users ADD COLUMN avatar_url TEXT');
-  }
-  
-  // Migration 3: Add performance indexes
-  private async migration3_addIndexes() {
-    await this.db.query('CREATE INDEX idx_users_email ON users(email)');
-    await this.db.query('CREATE INDEX idx_users_username ON users(username)');
-    await this.db.query('CREATE INDEX idx_users_created_at ON users(created_at)');
-  }
-  
-  // Migration 4: Add audit log
-  private async migration4_addAuditLog() {
-    await this.db.createTable('audit_logs', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      table_name: 'TEXT NOT NULL',
-      record_id: 'INTEGER NOT NULL',
-      action: 'TEXT NOT NULL',
-      old_values: 'TEXT',
-      new_values: 'TEXT',
-      user_id: 'INTEGER',
-      timestamp: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-    
-    // Tạo trigger cho audit
-    await this.db.query(`
-      CREATE TRIGGER audit_users_update 
-      AFTER UPDATE ON users 
-      FOR EACH ROW 
-      BEGIN
-        INSERT INTO audit_logs (table_name, record_id, action, old_values, new_values)
-        VALUES ('users', NEW.id, 'UPDATE', 
-                json_object('username', OLD.username, 'email', OLD.email),
-                json_object('username', NEW.username, 'email', NEW.email));
-      END
-    `);
+    res.json({ success: true, user });
+  } catch (error: any) {
+    console.error('Error updating user:', error);
+    res.status(400).json({ error: error.message });
   }
-}
-
-// Sử dụng migration
-async function migrationExample() {
-  const db = new UniversalSQLite();
-  await db.connect('app_with_migrations.db');
-  
-  const migration = new DatabaseMigration(db);
-  await migration.migrate();
-  
-  // Test data sau migration
-  await db.insert('users', {
-    username: 'testuser',
-    email: 'test@example.com',
-    first_name: 'Test',
-    last_name: 'User'
-  });
-  
-  // Update để trigger audit
-  await db.update('users', 
-    { email: 'test.updated@example.com' },
-    'username = ?',
-    ['testuser']
-  );
-  
-  // Kiểm tra audit log
-  const auditLogs = await db.select('audit_logs');
-  console.log('Audit logs:', auditLogs.rows);
-  
-  await db.close();
-}
-
-migrationExample();
-```
-
-### 5. Full-Text Search
-
-```typescript
-async function fullTextSearchExample() {
-  const db = new UniversalSQLite();
-  await db.connect('search.db');
-  
-  // Tạo FTS table
-  await db.query(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS articles_fts 
-    USING fts5(id, title, content, author)
-  `);
-  
-  // Tạo bảng articles thường
-  await db.createTable('articles', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    title: 'TEXT NOT NULL',
-    content: 'TEXT NOT NULL',
-    author: 'TEXT NOT NULL',
-    published_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-  });
-  
-  // Thêm dữ liệu mẫu
-  const articles = [
-    {
-      title: 'Introduction to SQLite',
-      content: 'SQLite is a lightweight database engine that is perfect for mobile and web applications. It provides ACID compliance and supports most of the SQL standard.',
-      author: 'John Doe'
-    },
-    {
-      title: 'Advanced TypeScript Patterns',
-      content: 'TypeScript provides powerful type system features including generics, conditional types, and mapped types that enable building robust applications.',
-      author: 'Jane Smith'
-    },
-    {
-      title: 'React Native Performance Tips',
-      content: 'Optimizing React Native apps requires understanding of the bridge, native modules, and proper state management patterns.',
-      author: 'Bob Johnson'
-    }
-  ];
-  
-  for (const article of articles) {
-    const result = await db.insert('articles', article);
-    // Thêm vào FTS index
-    await db.query(`
-      INSERT INTO articles_fts (id, title, content, author) 
-      VALUES (?, ?, ?, ?)
-    `, [result.lastInsertRowId, article.title, article.content, article.author]);
-  }
-  
-  // Full-text search
-  const searchResults = await db.query(`
-    SELECT 
-      a.id, a.title, a.author, a.published_at,
-      snippet(articles_fts, 1, '<b>', '</b>', '...', 50) as title_snippet,
-      snippet(articles_fts, 2, '<b>', '</b>', '...', 100) as content_snippet
-    FROM articles_fts
-    JOIN articles a ON articles_fts.id = a.id
-    WHERE articles_fts MATCH ?
-    ORDER BY rank
-  `, ['SQLite OR TypeScript']);
-  
-  console.log('Search results:', searchResults.rows);
-  
-  // Advanced search với bxm25 ranking
-  const advancedSearch = await db.query(`
-    SELECT 
-      a.*,
-      bm25(articles_fts) as relevance_score
-    FROM articles_fts
-    JOIN articles a ON articles_fts.id = a.id
-    WHERE articles_fts MATCH ?
-    ORDER BY relevance_score
-  `, ['application AND (mobile OR web)']);
-  
-  console.log('Advanced search:', advancedSearch.rows);
-  
-  await db.close();
-}
-
-fullTextSearchExample();
-```
-
-### 6. Data Analytics và Reporting
-
-```typescript
-async function analyticsExample() {
-  const db = new UniversalSQLite();
-  await db.connect('analytics.db');
-  
-  // Tạo schema cho analytics
-  await db.createTable('events', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    user_id: 'INTEGER NOT NULL',
-    event_type: 'TEXT NOT NULL',
-    event_data: 'TEXT', // JSON
-    timestamp: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-  });
-  
-  await db.createTable('users_analytics', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    user_id: 'INTEGER UNIQUE NOT NULL',
-    total_events: 'INTEGER DEFAULT 0',
-    first_seen: 'DATETIME',
-    last_seen: 'DATETIME',
-    session_count: 'INTEGER DEFAULT 0'
-  });
-  
-  // Thêm dữ liệu events mẫu
-  const sampleEvents = [
-    { user_id: 1, event_type: 'page_view', event_data: '{"page": "/home"}' },
-    { user_id: 1, event_type: 'click', event_data: '{"element": "signup_button"}' },
-    { user_id: 2, event_type: 'page_view', event_data: '{"page": "/products"}' },
-    { user_id: 1, event_type: 'purchase', event_data: '{"product_id": 123, "amount": 99.99}' },
-    { user_id: 3, event_type: 'page_view', event_data: '{"page": "/home"}' },
-    { user_id: 2, event_type: 'purchase', event_data: '{"product_id": 456, "amount": 149.99}' }
-  ];
-  
-  for (const event of sampleEvents) {
-    await db.insert('events', event);
-  }
-  
-  // Analytics queries
-  
-  // 1. User engagement report
-  const userEngagement = await db.query(`
-    SELECT 
-      user_id,
-      COUNT(*) as total_events,
-      COUNT(CASE WHEN event_type = 'purchase' THEN 1 END) as purchases,
-      MIN(timestamp) as first_seen,
-      MAX(timestamp) as last_seen,
-      ROUND(
-        JULIANDAY(MAX(timestamp)) - JULIANDAY(MIN(timestamp))
-      ) as days_active
-    FROM events
-    GROUP BY user_id
-    ORDER BY total_events DESC
-  `);
-  
-  console.log('User Engagement Report:', userEngagement.rows);
-  
-  // 2. Revenue analytics
-  const revenueReport = await db.query(`
-    SELECT 
-      DATE(timestamp) as date,
-      COUNT(*) as purchase_count,
-      SUM(CAST(json_extract(event_data, '$.amount') AS REAL)) as total_revenue,
-      AVG(CAST(json_extract(event_data, '$.amount') AS REAL)) as avg_order_value
-    FROM events
-    WHERE event_type = 'purchase'
-    GROUP BY DATE(timestamp)
-    ORDER BY date DESC
-  `);
-  
-  console.log('Revenue Report:', revenueReport.rows);
-  
-  // 3. Funnel analysis
-  const funnelAnalysis = await db.query(`
-    WITH user_funnel AS (
-      SELECT 
-        user_id,
-        MAX(CASE WHEN event_type = 'page_view' THEN 1 ELSE 0 END) as viewed,
-        MAX(CASE WHEN event_type = 'click' THEN 1 ELSE 0 END) as clicked,
-        MAX(CASE WHEN event_type = 'purchase' THEN 1 ELSE 0 END) as purchased
-      FROM events
-      GROUP BY user_id
-    )
-    SELECT 
-      SUM(viewed) as total_users,
-      SUM(clicked) as users_clicked,
-      SUM(purchased) as users_purchased,
-      ROUND(SUM(clicked) * 100.0 / SUM(viewed), 2) as click_rate_percent,
-      ROUND(SUM(purchased) * 100.0 / SUM(clicked), 2) as conversion_rate_percent
-    FROM user_funnel
-  `);
-  
-  console.log('Funnel Analysis:', funnelAnalysis.rows[0]);
-  
-  await db.close();
-}
-
-analyticsExample();
-```
-
-## 🔍 Debugging và Monitoring
-
-### 1. Query Performance Monitoring
+});
 
-```typescript
-class PerformanceMonitor {
-  private db: UniversalSQLite;
-  
-  constructor(db: UniversalSQLite) {
-    this.db = db;
-  }
-  
-  async queryWithTiming(sql: string, params?: any[]): Promise<{result: any, duration: number}> {
-    const startTime = performance.now();
-    const result = await this.db.query(sql, params);
-    const endTime = performance.now();
-    const duration = endTime - startTime;
+// DELETE /users/:id - Xóa user
+app.delete('/users/:id', async (req, res) => {
+  try {
+    const id = parseInt(req.params.id);
+    const success = await userService.delete(id);
     
-    console.log(`Query executed in ${duration.toFixed(2)}ms: ${sql.substring(0, 100)}...`);
+    if (!success) {
+      return res.status(404).json({ error: 'User not found' });
+    }
     
-    return { result, duration };
-  }
-  
-  async explainQuery(sql: string): Promise<void> {
-    const explanation = await this.db.query(`EXPLAIN QUERY PLAN ${sql}`);
-    console.log('Query Plan:');
-    explanation.rows.forEach(row => {
-      console.log(`  ${row.detail}`);
-    });
+    res.json({ success: true, message: 'User deleted' });
+  } catch (error: any) {
+    console.error('Error deleting user:', error);
+    res.status(500).json({ error: error.message });
   }
-}
+});
 
-async function performanceExample() {
-  const db = new UniversalSQLite();
-  await db.connect('performance_test.db');
-  const monitor = new PerformanceMonitor(db);
-  
-  // Tạo bảng với nhiều dữ liệu
-  await db.createTable('large_table', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    name: 'TEXT',
-    value: 'INTEGER',
-    category: 'TEXT'
-  });
-  
-  // Insert bulk data
-  console.log('Inserting test data...');
-  for (let i = 0; i < 1000; i++) {
-    await db.insert('large_table', {
-      name: `Item ${i}`,
-      value: Math.floor(Math.random() * 1000),
-      category: `Category ${i % 10}`
-    });
+// POST /users/:id/profile - Tạo profile cho user
+app.post('/users/:id/profile', async (req, res) => {
+  try {
+    const user_id = parseInt(req.params.id);
+    const profileData = { ...req.body, user_id };
+    
+    const profile = await profileService.createProfile(profileData);
+    res.status(201).json({ success: true, profile });
+  } catch (error: any) {
+    console.error('Error creating profile:', error);
+    res.status(400).json({ error: error.message });
   }
-  
-  // Test query performance
-  const { result, duration } = await monitor.queryWithTiming(`
-    SELECT category, COUNT(*) as count, AVG(value) as avg_value
-    FROM large_table 
-    GROUP BY category 
-    ORDER BY count DESC
-  `);
-  
-  console.log('Aggregation result:', result.rows);
-  
-  // Explain query
-  await monitor.explainQuery('SELECT * FROM large_table WHERE value > 500');
-  
-  await db.close();
-}
-
-performanceExample();
-```
-
-### 2. Connection Pool (Advanced)
+});
 
-```typescript
-class ConnectionPool {
-  private connections: Map<string, UniversalSQLite> = new Map();
-  private maxConnections: number = 5;
-  
-  async getConnection(dbPath: string): Promise<UniversalSQLite> {
-    if (this.connections.has(dbPath)) {
-      return this.connections.get(dbPath)!;
-    }
+// GET /users/:id/full - Lấy user với profile
+app.get('/users/:id/full', async (req, res) => {
+  try {
+    const user_id = parseInt(req.params.id);
+    const userWithProfile = await profileService.getUserWithProfile(user_id);
     
-    if (this.connections.size >= this.maxConnections) {
-      throw new Error('Connection pool exhausted');
+    if (!userWithProfile) {
+      return res.status(404).json({ error: 'User not found' });
     }
     
-    const db = new UniversalSQLite();
-    await db.connect(dbPath);
-    this.connections.set(dbPath, db);
-    
-    return db;
+    res.json({ success: true, user: userWithProfile });
+  } catch (error: any) {
+    console.error('Error getting user with profile:', error);
+    res.status(500).json({ error: error.message });
   }
-  
-  async closeAll(): Promise<void> {
-    for (const [path, db] of this.connections) {
-      await db.close();
-    }
-    this.connections.clear();
-  }
-}
+});
 
-async function connectionPoolExample() {
-  const pool = new ConnectionPool();
-  
+// Settings API
+app.get('/settings/:key', async (req, res) => {
   try {
-    // Sử dụng multiple databases
-    const mainDb = await pool.getConnection('main.db');
-    const cacheDb = await pool.getConnection('cache.db');
-    const logsDb = await pool.getConnection('logs.db');
-    
-    // Setup schemas
-    await mainDb.createTable('users', {
-      id: 'INTEGER PRIMARY KEY',
-      name: 'TEXT',
-      email: 'TEXT'
-    });
-    
-    await cacheDb.createTable('cache_entries', {
-      key: 'TEXT PRIMARY KEY',
-      value: 'TEXT',
-      expires_at: 'DATETIME'
-    });
-    
-    await logsDb.createTable('access_logs', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      ip: 'TEXT',
-      path: 'TEXT',
-      timestamp: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-    
-    // Concurrent operations
-    await Promise.all([
-      mainDb.insert('users', { name: 'Alice', email: 'alice@test.com' }),
-      cacheDb.insert('cache_entries', { key: 'user:1', value: '{"name":"Alice"}', expires_at: '2024-12-31 23:59:59' }),
-      logsDb.insert('access_logs', { ip: '192.168.1.1', path: '/api/users' })
-    ]);
-    
-    console.log('All operations completed successfully');
-    
-  } finally {
-    await pool.closeAll();
+    const value = await settingsService.getSetting(req.params.key);
+    res.json({ success: true, value });
+  } catch (error: any) {
+    console.error('Error getting setting:', error);
+    res.status(500).json({ error: error.message });
   }
-}
-
-connectionPoolExample();
-```
-
-## 🛠️ Configuration và Customization
+});
 
-### Environment Detection
+app.post('/settings', async (req, res) => {
+  try {
+    const { key, value, description } = req.body;
+    await settingsService.setSetting(key, value, description);
+    res.json({ success: true, message: 'Setting saved' });
+  } catch (error: any) {
+    console.error('Error setting value:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
 
-```typescript
-import { SQLiteManager } from '@dqcai/sqlite';
-
-const manager = new SQLiteManager();
-
-// Kiểm tra môi trường hiện tại
-const env = manager.getEnvironmentInfo();
-console.log('Running on:', env);
-
-// Conditional logic based on environment
-switch (env) {
-  case 'Node.js':
-    console.log('Server-side database with file system access');
-    break;
-  case 'Browser':
-    console.log('Client-side database with local storage');
-    break;
-  case 'React Native':
-    console.log('Mobile database with native SQLite');
-    break;
-  case 'React Native Windows':
-    console.log('Windows mobile database');
-    break;
-  case 'Deno':
-    console.log('Deno runtime with modern SQLite');
-    break;
-  case 'Bun':
-    console.log('Bun runtime with built-in SQLite');
-    break;
-}
-```
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('Shutting down server...');
+  await DatabaseService.closeAll();
+  process.exit(0);
+});
 
-### Custom Error Handling
+process.on('SIGTERM', async () => {
+  console.log('Shutting down server...');
+  await DatabaseService.closeAll();
+  process.exit(0);
+});
 
-```typescript
-class DatabaseErrorHandler {
-  static async safeExecute<T>(
-    operation: () => Promise<T>, 
-    fallback?: T
-  ): Promise<T | null> {
-    try {
-      return await operation();
-    } catch (error) {
-      console.error('Database operation failed:', error);
-      
-      if (error.message.includes('UNIQUE constraint failed')) {
-        console.log('Duplicate entry detected');
-      } else if (error.message.includes('no such table')) {
-        console.log('Table does not exist');
-      } else if (error.message.includes('database is locked')) {
-        console.log('Database is busy, retrying...');
-        // Implement retry logic
-        await new Promise(resolve => setTimeout(resolve, 100));
-        return await operation();
-      }
-      
-      return fallback || null;
-    }
-  }
-}
+// Start server
+const PORT = process.env.PORT || 3000;
 
-async function errorHandlingExample() {
-  const db = new UniversalSQLite();
-  await db.connect('error_test.db');
-  
-  await db.createTable('users', {
-    id: 'INTEGER PRIMARY KEY',
-    email: 'TEXT UNIQUE NOT NULL'
-  });
-  
-  // Safe insert với error handling
-  const user1 = await DatabaseErrorHandler.safeExecute(async () => {
-    return await db.insert('users', { email: 'test@example.com' });
-  });
-  
-  // Duplicate insert sẽ fail gracefully
-  const user2 = await DatabaseErrorHandler.safeExecute(async () => {
-    return await db.insert('users', { email: 'test@example.com' });
+initializeApp().then(() => {
+  app.listen(PORT, () => {
+    console.log(`Server running on port ${PORT}`);
   });
-  
-  console.log('User1 result:', user1);
-  console.log('User2 result:', user2); // null due to unique constraint
-  
-  await db.close();
-}
-
-errorHandlingExample();
+});
 ```
 
-## 📱 Platform-Specific Examples
+## 6. Quản lý Database với DatabaseManager
 
-### React Native với Expo
+### Mở/Đóng Connections
 
 ```typescript
-// expo-sqlite-example.ts
-import { StatusBar } from 'expo-status-bar';
-import { StyleSheet, Text, View, Button, FlatList } from 'react-native';
-import { useState, useEffect } from 'react';
-import UniversalSQLite from '@dqcai/sqlite';
-
-const db = new UniversalSQLite();
-
-export default function App() {
-  const [todos, setTodos] = useState([]);
-  const [isLoading, setIsLoading] = useState(true);
+// DatabaseHelper.ts
+import { DatabaseManager } from '@dqcai/sqlite';
 
-  useEffect(() => {
-    initDatabase();
-  }, []);
+export class DatabaseHelper {
+  
+  // Kiểm tra trạng thái kết nối
+  static checkConnectionStatus(): void {
+    const connections = DatabaseManager.getConnections();
+    const count = DatabaseManager.getConnectionCount();
+    const activeList = DatabaseManager.listConnections();
+    
+    console.log('Active connections:', count);
+    console.log('Connection list:', activeList);
+    console.log('Connection details:', connections);
+  }
 
-  const initDatabase = async () => {
+  // Đóng kết nối cụ thể
+  static async closeSpecificConnection(dbKey: string): Promise<void> {
     try {
-      await db.connect('todos.db');
-      
-      await db.createTable('todos', {
-        id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-        title: 'TEXT NOT NULL',
-        completed: 'BOOLEAN DEFAULT 0',
-        priority: 'INTEGER DEFAULT 1',
-        created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-      });
-      
-      loadTodos();
+      await DatabaseManager.closeConnection(dbKey);
+      console.log(`Connection ${dbKey} closed`);
     } catch (error) {
-      console.error('Database setup error:', error);
-    } finally {
-      setIsLoading(false);
+      console.error(`Error closing connection ${dbKey}:`, error);
     }
-  };
+  }
 
-  const loadTodos = async () => {
+  // Mở lại kết nối
+  static async reopenConnection(dbKey: string): Promise<void> {
     try {
-      const result = await db.select('todos', null, []);
-      setTodos(result.rows);
+      const dao = await DatabaseManager.getLazyLoading(dbKey);
+      console.log(`Connection ${dbKey} reopened`);
+      return dao;
     } catch (error) {
-      console.error('Load todos error:', error);
+      console.error(`Error reopening connection ${dbKey}:`, error);
+      throw error;
     }
-  };
+  }
 
-  const addTodo = async () => {
+  // Đảm bảo kết nối tồn tại
+  static async ensureConnection(dbKey: string): Promise<void> {
     try {
-      await db.insert('todos', {
-        title: `Todo ${Date.now()}`,
-        priority: Math.floor(Math.random() * 3) + 1
-      });
-      loadTodos();
+      const dao = await DatabaseManager.ensureDatabaseConnection(dbKey);
+      console.log(`Connection ${dbKey} ensured`);
+      return dao;
     } catch (error) {
-      console.error('Add todo error:', error);
+      console.error(`Error ensuring connection ${dbKey}:`, error);
+      throw error;
     }
-  };
+  }
 
-  const toggleTodo = async (id: number, completed: boolean) => {
+  // Thực hiện transaction cross-schema
+  static async executeTransactionAcrossSchemas(
+    schemas: string[],
+    operations: (daos: Record<string, any>) => Promise<void>
+  ): Promise<void> {
     try {
-      await db.update('todos', 
-        { completed: completed ? 0 : 1 },
-        'id = ?',
-        [id]
-      );
-      loadTodos();
+      await DatabaseManager.executeCrossSchemaTransaction(schemas, operations);
+      console.log('Cross-schema transaction completed successfully');
     } catch (error) {
-      console.error('Toggle todo error:', error);
+      console.error('Cross-schema transaction failed:', error);
+      throw error;
     }
-  };
-
-  if (isLoading) {
-    return (
-      <View style={styles.container}>
-        <Text>Loading database...</Text>
-      </View>
-    );
   }
 
-  return (
-    <View style={styles.container}>
-      <Text style={styles.title}>Universal SQLite Todos</Text>
-      <Text>Environment: {db.getEnvironment()}</Text>
-      
-      <Button title="Add Todo" onPress={addTodo} />
-      
-      <FlatList
-        data={todos}
-        keyExtractor={item => item.id.toString()}
-        renderItem={({ item }) => (
-          <View style={styles.todoItem}>
-            <Text style={[styles.todoText, item.completed && styles.completed]}>
-              {item.title}
-            </Text>
-            <Button 
-              title={item.completed ? "Undo" : "Done"}
-              onPress={() => toggleTodo(item.id, item.completed)}
-            />
-          </View>
-        )}
-      />
-      
-      <StatusBar style="auto" />
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    backgroundColor: '#fff',
-    alignItems: 'center',
-    justifyContent: 'center',
-    padding: 20,
-  },
-  title: {
-    fontSize: 24,
-    fontWeight: 'bold',
-    marginBottom: 20,
-  },
-  todoItem: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    padding: 10,
-    borderBottomWidth: 1,
-    borderBottomColor: '#ccc',
-  },
-  todoText: {
-    flex: 1,
-    fontSize: 16,
-  },
-  completed: {
-    textDecorationLine: 'line-through',
-    color: '#888',
-  },
-});
-```
-
-### Next.js API Routes
-
-```typescript
-// pages/api/users/[id].ts
-import { NextApiRequest, NextApiResponse } from 'next';
-import UniversalSQLite from '@dqcai/sqlite';
-
-const db = new UniversalSQLite();
-let isConnected = false;
+  // Event listeners cho reconnection
+  static setupReconnectionHandlers(): void {
+    DatabaseManager.onDatabaseReconnect('users', (dao) => {
+      console.log('Users database reconnected');
+      // Re-initialize services nếu cần
+    });
 
-async function ensureConnection() {
-  if (!isConnected) {
-    await db.connect(process.env.DATABASE_PATH || './api_database.db');
-    
-    await db.createTable('users', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      name: 'TEXT NOT NULL',
-      email: 'TEXT UNIQUE NOT NULL',
-      avatar: 'TEXT',
-      created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP',
-      updated_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
+    DatabaseManager.onDatabaseReconnect('core', (dao) => {
+      console.log('Core database reconnected');
+      // Re-initialize settings
     });
-    
-    isConnected = true;
   }
-}
 
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-  const { id } = req.query;
-  
-  try {
-    await ensureConnection();
+  // Health check tất cả connections
+  static async performHealthCheck(): Promise<void> {
+    const connections = DatabaseManager.getConnections();
     
-    switch (req.method) {
-      case 'GET':
-        if (id === 'all') {
-          const users = await db.select('users');
-          res.status(200).json(users.rows);
-        } else {
-          const user = await db.select('users', 'id = ?', [Number(id)]);
-          if (user.rows.length === 0) {
-            res.status(404).json({ error: 'User not found' });
-          } else {
-            res.status(200).json(user.rows[0]);
-          }
-        }
-        break;
-        
-      case 'POST':
-        const { name, email, avatar } = req.body;
-        const newUser = await db.insert('users', { name, email, avatar });
-        res.status(201).json({ 
-          id: newUser.lastInsertRowId, 
-          message: 'User created successfully' 
-        });
-        break;
-        
-      case 'PUT':
-        const updateData = { ...req.body, updated_at: new Date().toISOString() };
-        const updateResult = await db.update('users', updateData, 'id = ?', [Number(id)]);
-        
-        if (updateResult.rowsAffected === 0) {
-          res.status(404).json({ error: 'User not found' });
-        } else {
-          res.status(200).json({ message: 'User updated successfully' });
-        }
-        break;
-        
-      case 'DELETE':
-        const deleteResult = await db.delete('users', 'id = ?', [Number(id)]);
+    for (const [dbKey, dao] of Object.entries(connections)) {
+      try {
+        await dao.execute('SELECT 1');
+        console.log(`${dbKey}: Healthy`);
+      } catch (error) {
+        console.error(`${dbKey}: Unhealthy -`, error);
         
-        if (deleteResult.rowsAffected === 0) {
-          res.status(404).json({ error: 'User not found' });
-        } else {
-          res.status(200).json({ message: 'User deleted successfully' });
+        // Thử reconnect nếu cần
+        try {
+          await DatabaseManager.ensureDatabaseConnection(dbKey);
+          console.log(`${dbKey}: Reconnected successfully`);
+        } catch (reconnectError) {
+          console.error(`${dbKey}: Failed to reconnect -`, reconnectError);
         }
-        break;
-        
-      default:
-        res.setHeader('Allow', ['GET', 'POST', 'PUT', 'DELETE']);
-        res.status(405).end(`Method ${req.method} Not Allowed`);
+      }
     }
-    
-  } catch (error) {
-    console.error('API Error:', error);
-    res.status(500).json({ error: 'Internal server error' });
   }
 }
 ```
 
-## 🧪 Testing
+## 7. Import/Export Dữ liệu
 
-### Unit Tests với Jest
+### Import từ CSV
 
 ```typescript
-// __tests__/universal-sqlite.test.ts
-import UniversalSQLite from '../src/index';
+// services/DataImportService.ts
+import { DatabaseManager, ImportResult, ColumnMapping } from '@dqcai/sqlite';
 
-describe('UniversalSQLite', () => {
-  let db: UniversalSQLite;
-  
-  beforeEach(async () => {
-    db = new UniversalSQLite();
-    await db.connect(':memory:');
-  });
-  
-  afterEach(async () => {
-    await db.close();
-  });
-  
-  test('should create and query table', async () => {
-    await db.createTable('test_table', {
-      id: 'INTEGER PRIMARY KEY',
-      name: 'TEXT'
-    });
-    
-    await db.insert('test_table', { name: 'Test Item' });
-    
-    const result = await db.select('test_table');
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].name).toBe('Test Item');
-  });
-  
-  test('should handle parameters correctly', async () => {
-    await db.createTable('users', {
-      id: 'INTEGER PRIMARY KEY',
-      email: 'TEXT UNIQUE'
-    });
-    
-    await db.insert('users', { email: 'test@example.com' });
-    
-    const user = await db.select('users', 'email = ?', ['test@example.com']);
-    expect(user.rows).toHaveLength(1);
-    
-    const noUser = await db.select('users', 'email = ?', ['nonexistent@example.com']);
-    expect(noUser.rows).toHaveLength(0);
-  });
+export class DataImportService {
   
-  test('should handle SQL injection attempts', async () => {
-    await db.createTable('users', {
-      id: 'INTEGER PRIMARY KEY',
-      name: 'TEXT'
-    });
-    
-    await db.insert('users', { name: 'Regular User' });
-    
-    // Attempt SQL injection
-    const maliciousInput = "'; DROP TABLE users; --";
-    await db.insert('users', { name: maliciousInput });
-    
-    const users = await db.select('users');
-    expect(users.rows).toHaveLength(2); // Table should still exist
-  });
-});
-```
-
-## 🔐 Best Practices
+  // Import users từ CSV
+  static async importUsersFromCSV(csvData: string): Promise<ImportResult> {
+    try {
+      const result = await DatabaseManager.importFromCSV(
+        'users', // database key
+        'users', // table name
+        csvData,
+        {
+          hasHeader: true,
+          delimiter: ',',
+          skipErrors: false,
+          validateData: true,
+          batchSize: 500,
+          onProgress: (processed, total) => {
+            console.log(`Import progress: ${processed}/${total}`);
+          },
+          onError: (error, rowIndex, rowData) => {
+            console.error(`Row ${rowIndex} error:`, error, rowData);
+          }
+        }
+      );
 
-### 1. Security
+      console.log('Import completed:', {
+        total: result.totalRows,
+        success: result.successRows,
+        errors: result.errorRows,
+        time: result.executionTime
+      });
 
-```typescript
-class SecureDatabase {
-  private db: UniversalSQLite;
-  
-  constructor() {
-    this.db = new UniversalSQLite();
-  }
-  
-  async connect(path: string) {
-    await this.db.connect(path);
-    
-    // Enable foreign key constraints
-    await this.db.query('PRAGMA foreign_keys = ON');
-    
-    // Set secure defaults
-    await this.db.query('PRAGMA journal_mode = WAL'); // Write-Ahead Logging
-    await this.db.query('PRAGMA synchronous = NORMAL');
-  }
-  
-  // Validate input before queries
-  validateEmail(email: string): boolean {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(email);
-  }
-  
-  validateUsername(username: string): boolean {
-    return /^[a-zA-Z0-9_]{3,20}$/.test(username);
-  }
-  
-  async createUser(userData: {name: string, email: string, username: string}) {
-    // Validate input
-    if (!this.validateEmail(userData.email)) {
-      throw new Error('Invalid email format');
-    }
-    
-    if (!this.validateUsername(userData.username)) {
-      throw new Error('Invalid username format');
+      return result;
+    } catch (error) {
+      console.error('Import failed:', error);
+      throw error;
     }
-    
-    // Sanitize input
-    const sanitizedData = {
-      name: userData.name.trim(),
-      email: userData.email.toLowerCase().trim(),
-      username: userData.username.trim()
-    };
-    
-    return await this.db.insert('users', sanitizedData);
   }
-}
-```
-
-### 2. Performance Optimization
 
-```typescript
-class OptimizedDatabase {
-  private db: UniversalSQLite;
-  
-  constructor() {
-    this.db = new UniversalSQLite();
-  }
-  
-  async connect(path: string) {
-    await this.db.connect(path);
-    
-    // Performance tuning
-    await this.db.query('PRAGMA cache_size = 10000');
-    await this.db.query('PRAGMA temp_store = memory');
-    await this.db.query('PRAGMA mmap_size = 268435456'); // 256MB
-    await this.db.query('PRAGMA optimize');
-  }
-  
-  async bulkInsert(table: string, records: Record<string, any>[]) {
-    await this.db.query('BEGIN TRANSACTION');
-    
+  // Import với column mapping
+  static async importUsersWithMapping(
+    data: Record<string, any>[],
+    columnMappings: ColumnMapping[]
+  ): Promise<ImportResult> {
     try {
-      for (const record of records) {
-        await this.db.insert(table, record);
-      }
-      await this.db.query('COMMIT');
+      const result = await DatabaseManager.importDataWithMapping(
+        'users',
+        'users', 
+        data,
+        columnMappings,
+        {
+          batchSize: 1000,
+          skipErrors: true,
+          updateOnConflict: true,
+          conflictColumns: ['email']
+        }
+      );
+
+      return result;
     } catch (error) {
-      await this.db.query('ROLLBACK');
+      console.error('Import with mapping failed:', error);
       throw error;
     }
   }
-  
-  async createOptimizedIndexes(table: string, columns: string[]) {
-    for (const column of columns) {
-      await this.db.query(`
-        CREATE INDEX IF NOT EXISTS idx_${table}_${column} 
-        ON ${table}(${column})
-      `);
-    }
-  }
-}
-```
-
-## 🚨 Troubleshooting
-
-### Common Issues
 
-#### 1. "No supported SQLite adapter found"
-```typescript
-// Kiểm tra adapter availability
-const manager = new SQLiteManager();
-const adapters = [
-  'NodeAdapter',
-  'BrowserAdapter', 
-  'DenoAdapter',
-  'BunAdapter',
-  'ReactNativeAdapter'
-];
-
-for (const adapterName of adapters) {
-  try {
-    const adapter = new (require(`./adapters/${adapterName.toLowerCase()}`))();
-    console.log(`${adapterName}: ${adapter.isSupported() ? '✅' : '❌'}`);
-  } catch {
-    console.log(`${adapterName}: ❌ (not available)`);
-  }
-}
-```
-
-#### 2. React Native Windows Setup
-
-```typescript
-// Kiểm tra Windows environment
-async function checkReactNativeWindows() {
-  const db = new UniversalSQLite();
-  
-  console.log('Environment:', db.getEnvironment());
-  
-  if (db.getEnvironment() === 'React Native Windows') {
-    console.log('✅ React Native Windows detected');
-    
+  // Bulk import nhiều bảng cùng lúc
+  static async bulkImportData(importConfigs: Array<{
+    databaseKey: string;
+    tableName: string;
+    data: Record<string, any>[];
+  }>): Promise<void> {
     try {
-      await db.connect('windows_test.db');
-      console.log('✅ Database connection successful');
+      const result = await DatabaseManager.bulkImport(importConfigs);
       
-      await db.createTable('test', { id: 'INTEGER', name: 'TEXT' });
-      console.log('✅ Table creation successful');
-      
-    } catch (error) {
-      console.error('❌ Windows SQLite error:', error);
-      console.log('💡 Try installing: npm install react-native-sqlite-2');
-    }
-  }
-}
-```
-
-#### 3. Browser CORS Issues
-
-```typescript
-// browser-cors-fix.js
-async function setupBrowserDatabase() {
-  const db = new UniversalSQLite();
-  
-  try {
-    // In-memory database (không cần file access)
-    await db.connect(':memory:');
-    console.log('✅ Browser in-memory database ready');
-    
-  } catch (error) {
-    console.error('❌ Browser setup failed:', error);
-    console.log('💡 Fallback: Using in-memory database');
-    
-    // Fallback strategy
-    await db.connect(':memory:');
-  }
-}
-```
-
-## 📊 Performance Benchmarks
-
-```typescript
-async function benchmarkExample() {
-  const db = new UniversalSQLite();
-  await db.connect('benchmark.db');
-  
-  await db.createTable('benchmark_table', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    data: 'TEXT',
-    timestamp: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-  });
-  
-  // Benchmark bulk insert
-  console.log('Starting bulk insert benchmark...');
-  const insertStart = performance.now();
-  
-  await db.query('BEGIN TRANSACTION');
-  for (let i = 0; i < 10000; i++) {
-    await db.insert('benchmark_table', { 
-      data: `Sample data ${i}` 
-    });
-  }
-  await db.query('COMMIT');
-  
-  const insertEnd = performance.now();
-  console.log(`Bulk insert (10k records): ${(insertEnd - insertStart).toFixed(2)}ms`);
-  
-  // Benchmark select
-  const selectStart = performance.now();
-  const allRecords = await db.select('benchmark_table');
-  const selectEnd = performance.now();
-  
-  console.log(`Select all (${allRecords.rows.length} records): ${(selectEnd - selectStart).toFixed(2)}ms`);
-  
-  // Benchmark with index
-  await db.query('CREATE INDEX idx_data ON benchmark_table(data)');
-  
-  const indexedSelectStart = performance.now();
-  const searchResult = await db.select('benchmark_table', 'data LIKE ?', ['Sample data 50%']);
-  const indexedSelectEnd = performance.now();
-  
-  console.log(`Indexed search (${searchResult.rows.length} results): ${(indexedSelectEnd - indexedSelectStart).toFixed(2)}ms`);
-  
-  await db.close();
-}
-
-benchmarkExample();
-```
-
-## 📚 Advanced Use Cases
-
-### 1. Multi-Database Application
-
-```typescript
-class MultiDatabaseApp {
-  private userDb: UniversalSQLite;
-  private logDb: UniversalSQLite;
-  private cacheDb: UniversalSQLite;
-  
-  constructor() {
-    this.userDb = new UniversalSQLite();
-    this.logDb = new UniversalSQLite();
-    this.cacheDb = new UniversalSQLite();
-  }
-  
-  async initialize() {
-    // Separate databases for different concerns
-    await this.userDb.connect('users.db');
-    await this.logDb.connect('logs.db');
-    await this.cacheDb.connect(':memory:'); // Cache in memory
-    
-    // Setup schemas
-    await this.setupUserDatabase();
-    await this.setupLogDatabase();
-    await this.setupCacheDatabase();
-  }
-  
-  private async setupUserDatabase() {
-    await this.userDb.createTable('users', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      username: 'TEXT UNIQUE NOT NULL',
-      email: 'TEXT UNIQUE NOT NULL',
-      profile_data: 'TEXT', // JSON
-      created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-    
-    await this.userDb.createTable('user_sessions', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      user_id: 'INTEGER NOT NULL',
-      session_token: 'TEXT UNIQUE NOT NULL',
-      expires_at: 'DATETIME NOT NULL',
-      'FOREIGN KEY (user_id)': 'REFERENCES users(id) ON DELETE CASCADE'
-    });
-  }
-  
-  private async setupLogDatabase() {
-    await this.logDb.createTable('access_logs', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      user_id: 'INTEGER',
-      action: 'TEXT NOT NULL',
-      ip_address: 'TEXT',
-      user_agent: 'TEXT',
-      timestamp: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-    
-    await this.logDb.createTable('error_logs', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      error_type: 'TEXT NOT NULL',
-      error_message: 'TEXT NOT NULL',
-      stack_trace: 'TEXT',
-      context: 'TEXT', // JSON
-      timestamp: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-  }
-  
-  private async setupCacheDatabase() {
-    await this.cacheDb.createTable('cache_entries', {
-      key: 'TEXT PRIMARY KEY',
-      value: 'TEXT NOT NULL',
-      expires_at: 'DATETIME NOT NULL'
-    });
-  }
-  
-  // User operations
-  async createUser(userData: any) {
-    const result = await this.userDb.insert('users', userData);
-    
-    // Log the action
-    await this.logAction(result.lastInsertRowId!, 'USER_CREATED', 'User registration');
-    
-    return result;
-  }
-  
-  async getUserById(id: number) {
-    // Check cache first
-    const cached = await this.getFromCache(`user:${id}`);
-    if (cached) {
-      return JSON.parse(cached);
-    }
-    
-    // Query from database
-    const result = await this.userDb.select('users', 'id = ?', [id]);
-    if (result.rows.length > 0) {
-      const user = result.rows[0];
-      // Cache for 1 hour
-      await this.setCache(`user:${id}`, JSON.stringify(user), 3600);
-      return user;
-    }
-    
-    return null;
-  }
-  
-  // Logging operations
-  async logAction(userId: number, action: string, details: string) {
-    await this.logDb.insert('access_logs', {
-      user_id: userId,
-      action: action,
-      ip_address: '127.0.0.1', // Would get from request
-      user_agent: 'Universal SQLite App'
-    });
-  }
-  
-  async logError(error: Error, context?: any) {
-    await this.logDb.insert('error_logs', {
-      error_type: error.name,
-      error_message: error.message,
-      stack_trace: error.stack,
-      context: context ? JSON.stringify(context) : null
-    });
-  }
-  
-  // Cache operations
-  async setCache(key: string, value: string, ttlSeconds: number) {
-    const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
-    
-    await this.cacheDb.query(`
-      INSERT OR REPLACE INTO cache_entries (key, value, expires_at) 
-      VALUES (?, ?, ?)
-    `, [key, value, expiresAt]);
-  }
-  
-  async getFromCache(key: string): Promise<string | null> {
-    // Clean expired entries
-    await this.cacheDb.delete('cache_entries', 'expires_at < ?', [new Date().toISOString()]);
-    
-    const result = await this.cacheDb.select('cache_entries', 'key = ?', [key]);
-    return result.rows.length > 0 ? result.rows[0].value : null;
-  }
-  
-  // Analytics across databases
-  async getUserAnalytics(userId: number) {
-    const user = await this.getUserById(userId);
-    if (!user) return null;
-    
-    const logs = await this.logDb.query(`
-      SELECT 
-        action,
-        COUNT(*) as count,
-        MAX(timestamp) as last_action
-      FROM access_logs 
-      WHERE user_id = ? 
-      GROUP BY action
-      ORDER BY count DESC
-    `, [userId]);
-    
-    return {
-      user: user,
-      activity: logs.rows,
-      total_actions: logs.rows.reduce((sum, row) => sum + row.count, 0)
-    };
-  }
-  
-  async cleanup() {
-    await this.userDb.close();
-    await this.logDb.close();
-    await this.cacheDb.close();
+      console.log('Bulk import completed:', {
+        totalDatabases: result.totalDatabases,
+        successDatabases: result.successDatabases,
+        executionTime: result.executionTime
+      });
+
+      // Log chi tiết từng bảng
+      Object.entries(result.results).forEach(([key, importResult]) => {
+        console.log(`${key}: ${importResult.successRows}/${importResult.totalRows} rows imported`);
+      });
+
+      // Log lỗi nếu có
+      if (Object.keys(result.errors).length > 0) {
+        console.error('Import errors:', result.errors);
+      }
+
+    } catch (error) {
+      console.error('Bulk import failed:', error);
+      throw error;
+    }
   }
 }
 
-// Usage
-async function multiDbExample() {
-  const app = new MultiDatabaseApp();
-  
+// Ví dụ sử dụng import service
+async function exampleImportUsage() {
+  // CSV data mẫu
+  const csvData = `username,email,password,first_name,last_name
+john_doe,john@example.com,password123,John,Doe
+jane_smith,jane@example.com,password456,Jane,Smith
+bob_wilson,bob@example.com,password789,Bob,Wilson`;
+
   try {
-    await app.initialize();
-    
-    // Create user
-    const newUser = await app.createUser({
-      username: 'johndoe',
-      email: 'john@example.com',
-      profile_data: JSON.stringify({ bio: 'Software developer' })
-    });
-    
-    const userId = newUser.lastInsertRowId!;
-    
-    // Simulate user activity
-    await app.logAction(userId, 'LOGIN', 'User logged in');
-    await app.logAction(userId, 'VIEW_PROFILE', 'Viewed profile page');
-    await app.logAction(userId, 'UPDATE_PROFILE', 'Updated profile');
-    
-    // Get analytics
-    const analytics = await app.getUserAnalytics(userId);
-    console.log('User Analytics:', analytics);
-    
+    // Import từ CSV
+    const importResult = await DataImportService.importUsersFromCSV(csvData);
+    console.log('CSV Import result:', importResult);
+
+    // Import với column mapping
+    const mappedData = [
+      { user_name: 'alice', user_email: 'alice@test.com', pwd: 'pass123' },
+      { user_name: 'charlie', user_email: 'charlie@test.com', pwd: 'pass456' }
+    ];
+
+    const columnMappings: ColumnMapping[] = [
+      { sourceColumn: 'user_name', targetColumn: 'username' },
+      { sourceColumn: 'user_email', targetColumn: 'email' },
+      { 
+        sourceColumn: 'pwd', 
+        targetColumn: 'password',
+        transform: (value) => `hashed_${value}` // Hash password
+      }
+    ];
+
+    const mappingResult = await DataImportService.importUsersWithMapping(
+      mappedData, 
+      columnMappings
+    );
+    console.log('Mapping Import result:', mappingResult);
+
   } catch (error) {
-    console.error('Multi-db error:', error);
-  } finally {
-    await app.cleanup();
+    console.error('Import example failed:', error);
   }
 }
-
-multiDbExample();
 ```
 
-### 2. Real-time Sync với WebSocket
+### Export dữ liệu
 
 ```typescript
-// realtime-sync.ts
-import UniversalSQLite, { QueryBuilder } from '@dqcai/sqlite';
-import { WebSocket } from 'ws'; // Node.js example
-
-class RealtimeSync {
-  private db: UniversalSQLite;
-  private ws: WebSocket | null = null;
-  private syncQueue: any[] = [];
+// services/DataExportService.ts
+import { DatabaseManager } from '@dqcai/sqlite';
+
+export class DataExportService {
   
-  constructor() {
-    this.db = new UniversalSQLite();
+  // Export users ra CSV
+  static async exportUsersToCSV(): Promise<string> {
+    try {
+      const dao = DatabaseManager.get('users');
+      const sql = `
+        SELECT u.username, u.email, u.created_at,
+               p.first_name, p.last_name, p.phone
+        FROM users u
+        LEFT JOIN profiles p ON u.id = p.user_id
+        ORDER BY u.created_at DESC
+      `;
+      
+      const result = await dao.execute(sql);
+      
+      if (result.rows.length === 0) {
+        return 'No data to export';
+      }
+
+      // Tạo CSV header
+      const headers = Object.keys(result.rows[0]);
+      let csvContent = headers.join(',') + '\n';
+
+      // Thêm data rows
+      result.rows.forEach(row => {
+        const values = headers.map(header => {
+          const value = row[header];
+          // Escape quotes và wrap trong quotes nếu chứa comma
+          if (value === null || value === undefined) {
+            return '';
+          }
+          const stringValue = String(value);
+          if (stringValue.includes(',') || stringValue.includes('"') || stringValue.includes('\n')) {
+            return `"${stringValue.replace(/"/g, '""')}"`;
+          }
+          return stringValue;
+        });
+        csvContent += values.join(',') + '\n';
+      });
+
+      return csvContent;
+    } catch (error) {
+      console.error('Export to CSV failed:', error);
+      throw error;
+    }
   }
-  
-  async initialize() {
-    await this.db.connect('realtime.db');
-    
-    // Setup sync tables
-    await this.db.createTable('messages', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      content: 'TEXT NOT NULL',
-      sender_id: 'INTEGER NOT NULL',
-      room_id: 'INTEGER NOT NULL',
-      created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP',
-      synced: 'BOOLEAN DEFAULT 0'
-    });
-    
-    await this.db.createTable('sync_log', {
-      id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-      operation: 'TEXT NOT NULL',
-      table_name: 'TEXT NOT NULL',
-      record_id: 'INTEGER',
-      data: 'TEXT',
-      sync_status: 'TEXT DEFAULT "pending"',
-      created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP'
-    });
-    
-    this.startSyncProcess();
+
+  // Export với điều kiện tùy chỉnh
+  static async exportUsersWithConditions(
+    whereClause?: string,
+    params?: any[]
+  ): Promise<Record<string, any>[]> {
+    try {
+      const dao = DatabaseManager.get('users');
+      let sql = `
+        SELECT u.*, p.first_name, p.last_name, p.phone, p.address
+        FROM users u
+        LEFT JOIN profiles p ON u.id = p.user_id
+      `;
+      
+      if (whereClause) {
+        sql += ` WHERE ${whereClause}`;
+      }
+      
+      sql += ` ORDER BY u.created_at DESC`;
+
+      const result = await dao.execute(sql, params || []);
+      return result.rows;
+    } catch (error) {
+      console.error('Export with conditions failed:', error);
+      throw error;
+    }
   }
-  
-  async addMessage(content: string, senderId: number, roomId: number) {
-    const result = await this.db.insert('messages', {
-      content,
-      sender_id: senderId,
-      room_id: roomId
-    });
-    
-    // Queue for sync
-    await this.queueSync('INSERT', 'messages', result.lastInsertRowId!, {
-      id: result.lastInsertRowId,
-      content,
-      sender_id: senderId,
-      room_id: roomId
-    });
-    
-    return result;
+
+  // Export dữ liệu backup toàn bộ database
+  static async createDatabaseBackup(dbKey: string): Promise<{
+    tables: Record<string, any[]>;
+    metadata: any;
+  }> {
+    try {
+      const dao = DatabaseManager.get(dbKey);
+      
+      // Lấy danh sách tables
+      const tablesResult = await dao.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+      );
+      
+      const backup: Record<string, any[]> = {};
+      
+      // Export từng table
+      for (const tableRow of tablesResult.rows) {
+        const tableName = tableRow.name;
+        const dataResult = await dao.execute(`SELECT * FROM ${tableName}`);
+        backup[tableName] = dataResult.rows;
+      }
+
+      // Thêm metadata
+      const dbInfo = await dao.getDatabaseInfo();
+      
+      return {
+        tables: backup,
+        metadata: {
+          ...dbInfo,
+          exportDate: new Date().toISOString(),
+          version: await dao.getSchemaVersion()
+        }
+      };
+    } catch (error) {
+      console.error('Database backup failed:', error);
+      throw error;
+    }
   }
-  
-  async getMessages(roomId: number, limit: number = 50) {
-    return await this.db.query(`
-      SELECT m.*, u.username 
-      FROM messages m
-      LEFT JOIN users u ON m.sender_id = u.id
-      WHERE m.room_id = ? 
-      ORDER BY m.created_at DESC 
-      LIMIT ?
-    `, [roomId, limit]);
+}
+
+// Ví dụ sử dụng export
+async function exampleExportUsage() {
+  try {
+    // Export users ra CSV
+    const csvContent = await DataExportService.exportUsersToCSV();
+    console.log('CSV Export:', csvContent);
+
+    // Export users với điều kiện
+    const recentUsers = await DataExportService.exportUsersWithConditions(
+      "u.created_at > ?",
+      [new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString()] // 30 ngày gần đây
+    );
+    console.log('Recent users:', recentUsers);
+
+    // Backup toàn bộ database users
+    const backup = await DataExportService.createDatabaseBackup('users');
+    console.log('Database backup:', backup);
+
+  } catch (error) {
+    console.error('Export example failed:', error);
   }
-  
-  private async queueSync(operation: string, tableName: string, recordId: number, data: any) {
-    await this.db.insert('sync_log', {
-      operation,
-      table_name: tableName,
-      record_id: recordId,
-      data: JSON.stringify(data)
+}
+```
+
+## 8. Best Practices & Tips
+
+### Error Handling
+
+```typescript
+// utils/ErrorHandler.ts
+export class DatabaseErrorHandler {
+  
+  static handleServiceError(error: any, context: string): void {
+    console.error(`Database Error in ${context}:`, {
+      message: error.message,
+      stack: error.stack,
+      code: error.code,
+      timestamp: new Date().toISOString()
     });
+
+    // Specific error handling
+    if (error.message?.includes('UNIQUE constraint failed')) {
+      throw new Error('Duplicate entry detected');
+    } else if (error.message?.includes('database is locked')) {
+      throw new Error('Database is busy, please try again');
+    } else if (error.message?.includes('no such table')) {
+      throw new Error('Database table not found');
+    } else {
+      throw new Error(`Database operation failed: ${error.message}`);
+    }
   }
-  
-  private async startSyncProcess() {
-    setInterval(async () => {
-      await this.processSyncQueue();
-    }, 5000); // Sync every 5 seconds
-  }
-  
-  private async processSyncQueue() {
-    const pendingSyncs = await this.db.select('sync_log', 'sync_status = ?', ['pending']);
+
+  static async withRetry<T>(
+    operation: () => Promise<T>,
+    maxRetries: number = 3,
+    delay: number = 1000
+  ): Promise<T> {
+    let lastError: any;
     
-    for (const sync of pendingSyncs.rows) {
+    for (let i = 0; i < maxRetries; i++) {
       try {
-        // Simulate API call
-        const response = await this.syncToServer(sync);
+        return await operation();
+      } catch (error) {
+        lastError = error;
         
-        if (response.success) {
-          await this.db.update('sync_log',
-            { sync_status: 'completed' },
-            'id = ?',
-            [sync.id]
-          );
-          
-          // Mark original record as synced
-          if (sync.table_name === 'messages') {
-            await this.db.update('messages',
-              { synced: 1 },
-              'id = ?',
-              [sync.record_id]
-            );
-          }
+        if (i < maxRetries - 1) {
+          console.log(`Operation failed, retrying in ${delay}ms... (${i + 1}/${maxRetries})`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+          delay *= 2; // Exponential backoff
         }
-      } catch (error) {
-        await this.db.update('sync_log',
-          { sync_status: 'failed' },
-          'id = ?',
-          [sync.id]
-        );
-        console.error('Sync failed:', error);
       }
     }
-  }
-  
-  private async syncToServer(syncData: any): Promise<{success: boolean}> {
-    // Simulate server sync
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve({ success: Math.random() > 0.1 }); // 90% success rate
-      }, 100);
-    });
+    
+    throw lastError;
   }
 }
 
-// Usage
-async function realtimeSyncExample() {
-  const sync = new RealtimeSync();
-  await sync.initialize();
-  
-  // Simulate adding messages
-  await sync.addMessage('Hello World!', 1, 1);
-  await sync.addMessage('How are you?', 2, 1);
-  
-  // Get messages
-  const messages = await sync.getMessages(1);
-  console.log('Room messages:', messages.rows);
-  
-  // Let sync process run
-  await new Promise(resolve => setTimeout(resolve, 6000));
+// Sử dụng error handler
+class SafeUserService extends UserService {
+  async createUser(userData: Omit<User, 'id' | 'created_at' | 'updated_at'>): Promise<User | null> {
+    return DatabaseErrorHandler.withRetry(async () => {
+      try {
+        return await super.createUser(userData);
+      } catch (error) {
+        DatabaseErrorHandler.handleServiceError(error, 'createUser');
+        throw error; // Re-throw sau khi handle
+      }
+    });
+  }
 }
-
-realtimeSyncExample();
 ```
 
-### 3. Database Backup và Restore
+### Performance Optimization
 
 ```typescript
-class DatabaseBackup {
-  private db: UniversalSQLite;
-  
-  constructor() {
-    this.db = new UniversalSQLite();
-  }
-  
-  async connect(path: string) {
-    await this.db.connect(path);
-  }
-  
-  async createBackup(): Promise<string> {
-    // Get all table schemas
-    const tables = await this.db.query(`
-      SELECT name, sql FROM sqlite_master 
-      WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
-    `);
-    
-    let backupSQL = '';
-    backupSQL += '-- Database Backup\n';
-    backupSQL += `-- Generated: ${new Date().toISOString()}\n\n`;
-    
-    // Add schema
-    for (const table of tables.rows) {
-      backupSQL += `${table.sql};\n\n`;
-    }
-    
-    // Add data
-    for (const table of tables.rows) {
-      const data = await this.db.select(table.name);
+// utils/PerformanceOptimizer.ts
+export class PerformanceOptimizer {
+  
+  // Batch operations để giảm số lần gọi database
+  static async batchCreateUsers(
+    userService: UserService,
+    users: Array<Omit<User, 'id' | 'created_at' | 'updated_at'>>
+  ): Promise<void> {
+    const batchSize = 100;
+    
+    for (let i = 0; i < users.length; i += batchSize) {
+      const batch = users.slice(i, i + batchSize);
       
-      if (data.rows.length > 0) {
-        // Get column names
-        const columns = Object.keys(data.rows[0]);
-        
-        backupSQL += `-- Data for ${table.name}\n`;
-        for (const row of data.rows) {
-          const values = columns.map(col => {
-            const value = row[col];
-            if (value === null) return 'NULL';
-            if (typeof value === 'string') return `'${value.replace(/'/g, "''")}'`;
-            return String(value);
+      await userService.executeTransaction(async () => {
+        for (const userData of batch) {
+          await userService.create({
+            ...userData,
+            created_at: new Date().toISOString()
           });
-          
-          backupSQL += `INSERT INTO ${table.name} (${columns.join(', ')}) VALUES (${values.join(', ')});\n`;
         }
-        backupSQL += '\n';
-      }
+      });
+      
+      console.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)}`);
     }
-    
-    return backupSQL;
   }
-  
-  async restoreFromBackup(backupSQL: string): Promise<void> {
-    const statements = backupSQL
-      .split(';')
-      .map(stmt => stmt.trim())
-      .filter(stmt => stmt && !stmt.startsWith('--'));
+
+  // Index optimization
+  static async optimizeQueries(dao: any): Promise<void> {
+    // Enable query optimization
+    await dao.execute('PRAGMA optimize');
     
-    await this.db.query('BEGIN TRANSACTION');
+    // Analyze tables for better query planning
+    await dao.execute('ANALYZE');
     
-    try {
-      for (const statement of statements) {
-        if (statement) {
-          await this.db.query(statement);
-        }
-      }
-      await this.db.query('COMMIT');
-      console.log('Backup restored successfully');
-    } catch (error) {
-      await this.db.query('ROLLBACK');
-      throw new Error(`Restore failed: ${error}`);
-    }
+    // Set optimal cache size
+    await dao.execute('PRAGMA cache_size = 10000');
+    
+    console.log('Database optimization completed');
   }
-  
-  async scheduleBackups(intervalMinutes: number = 60) {
-    setInterval(async () => {
-      try {
-        const backup = await this.createBackup();
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const filename = `backup_${timestamp}.sql`;
-        
-        // In Node.js environment, save to file
-        if (typeof require !== 'undefined' && this.db.getEnvironment() === 'Node.js') {
-          const fs = require('fs').promises;
-          await fs.writeFile(filename, backup);
-          console.log(`Backup saved: ${filename}`);
-        } else {
-          // In browser/other environments, log or send to server
-          console.log('Backup created (implement save logic for your environment)');
-        }
-        
-      } catch (error) {
-        console.error('Backup failed:', error);
+
+  // Connection pooling check
+  static monitorConnections(): void {
+    setInterval(() => {
+      const count = DatabaseManager.getConnectionCount();
+      const connections = DatabaseManager.listConnections();
+      
+      console.log(`Active connections: ${count}`, connections);
+      
+      if (count > 5) {
+        console.warn('High number of database connections detected');
       }
-    }, intervalMinutes * 60 * 1000);
-  }
-  
-  async close() {
-    await this.db.close();
+    }, 30000); // Check every 30 seconds
   }
 }
-
-// Usage
-async function backupExample() {
-  const backup = new DatabaseBackup();
-  await backup.connect('main_app.db');
-  
-  // Create some test data
-  const db = new UniversalSQLite();
-  await db.connect('main_app.db');
-  
-  await db.createTable('posts', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    title: 'TEXT NOT NULL',
-    content: 'TEXT',
-    author_id: 'INTEGER'
-  });
-  
-  await db.insert('posts', { title: 'First Post', content: 'Hello World!', author_id: 1 });
-  await db.insert('posts', { title: 'Second Post', content: 'More content', author_id: 2 });
-  
-  // Create backup
-  const backupSQL = await backup.createBackup();
-  console.log('Backup created, size:', backupSQL.length, 'characters');
-  
-  // Test restore (to new database)
-  const restoreDb = new UniversalSQLite();
-  await restoreDb.connect(':memory:');
-  
-  const restoreBackup = new DatabaseBackup();
-  await restoreBackup.connect(':memory:');
-  await restoreBackup.restoreFromBackup(backupSQL);
-  
-  // Verify restore
-  const restoredData = await restoreDb.select('posts');
-  console.log('Restored data:', restoredData.rows);
-  
-  await db.close();
-  await restoreDb.close();
-  await backup.close();
-  await restoreBackup.close();
-}
-
-backupExample();
 ```
 
-## 🌐 Production Deployment
-
-### Environment Variables
+### Testing Utilities
 
 ```typescript
-// config.ts
-interface DatabaseConfig {
-  path: string;
-  backupInterval?: number;
-  maxConnections?: number;
-  enableWAL?: boolean;
-}
-
-function getDatabaseConfig(): DatabaseConfig {
-  const env = process.env.NODE_ENV || 'development';
-  
-  const configs: Record<string, DatabaseConfig> = {
-    development: {
-      path: './dev_database.db',
-      backupInterval: 60, // 1 hour
-      enableWAL: true
-    },
-    test: {
-      path: ':memory:',
-      enableWAL: false
-    },
-    production: {
-      path: process.env.DATABASE_PATH || './prod_database.db',
-      backupInterval: 15, // 15 minutes
-      maxConnections: 10,
-      enableWAL: true
-    }
-  };
-  
-  return configs[env] || configs.development;
-}
+// utils/TestHelpers.ts
+import { DatabaseManager } from '@dqcai/sqlite';
 
-// app.ts
-async function productionSetup() {
-  const config = getDatabaseConfig();
-  const db = new UniversalSQLite();
+export class DatabaseTestHelpers {
   
-  await db.connect(config.path);
-  
-  if (config.enableWAL) {
-    await db.query('PRAGMA journal_mode = WAL');
-    await db.query('PRAGMA synchronous = NORMAL');
-    await db.query('PRAGMA cache_size = 10000');
-    await db.query('PRAGMA temp_store = memory');
+  static async setupTestDatabase(): Promise<void> {
+    // Use in-memory database for testing
+    const testSchema = {
+      ...userSchema,
+      database_name: ':memory:'
+    };
+    
+    DatabaseManager.registerSchema('test_users', testSchema);
+    await DatabaseManager.initLazySchema(['test_users']);
   }
-  
-  // Setup production tables
-  await setupProductionSchema(db);
-  
-  // Setup monitoring
-  if (process.env.NODE_ENV === 'production') {
-    setupProductionMonitoring(db);
+
+  static async cleanupTestData(service: any): Promise<void> {
+    await service.truncate();
   }
-  
-  return db;
-}
 
-async function setupProductionSchema(db: UniversalSQLite) {
-  // Users table với full audit trail
-  await db.createTable('users', {
-    id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-    email: 'TEXT UNIQUE NOT NULL',
-    password_hash: 'TEXT NOT NULL',
-    status: 'TEXT DEFAULT "active" CHECK(status IN ("active", "inactive", "suspended"))',
-    created_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP',
-    updated_at: 'DATETIME DEFAULT CURRENT_TIMESTAMP',
-    last_login: 'DATETIME'
-  });
-  
-  // Indexes for performance
-  await db.query('CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)');
-  await db.query('CREATE INDEX IF NOT EXISTS idx_users_status ON users(status)');
-  await db.query('CREATE INDEX IF NOT EXISTS idx_users_last_login ON users(last_login)');
-  
-  // Trigger for updated_at
-  await db.query(`
-    CREATE TRIGGER IF NOT EXISTS update_users_timestamp 
-    AFTER UPDATE ON users 
-    FOR EACH ROW 
-    BEGIN
-      UPDATE users SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
-    END
-  `);
-}
+  static async seedTestData(userService: UserService): Promise<User[]> {
+    const testUsers = [
+      { username: 'test1', email: 'test1@example.com', password: 'pass1' },
+      { username: 'test2', email: 'test2@example.com', password: 'pass2' },
+      { username: 'test3', email: 'test3@example.com', password: 'pass3' }
+    ];
 
-function setupProductionMonitoring(db: UniversalSQLite) {
-  // Monitor database size
-  setInterval(async () => {
-    const sizeInfo = await db.query('PRAGMA page_count; PRAGMA page_size;');
-    const pages = sizeInfo.rows[0].page_count;
-    const pageSize = sizeInfo.rows[1].page_size;
-    const sizeBytes = pages * pageSize;
-    const sizeMB = (sizeBytes / 1024 / 1024).toFixed(2);
-    
-    console.log(`Database size: ${sizeMB} MB`);
-    
-    if (sizeBytes > 500 * 1024 * 1024) { // 500MB warning
-      console.warn('Database size exceeds 500MB, consider archiving old data');
+    const createdUsers: User[] = [];
+    for (const userData of testUsers) {
+      const user = await userService.createUser(userData);
+      if (user) createdUsers.push(user);
     }
-  }, 300000); // Check every 5 minutes
-  
-  // Monitor query performance
-  setInterval(async () => {
-    const longQueries = await db.query(`
-      SELECT * FROM pragma_stats 
-      WHERE name LIKE '%time%'
-    `);
-    
-    // Log slow queries for optimization
-    console.log('Database stats:', longQueries.rows);
-  }, 600000); // Check every 10 minutes
-}
-
-productionSetup();
-```
-
-## 📖 API Reference
 
-### Core Types
-
-```typescript
-interface SQLiteRow {
-  [key: string]: any;
-}
-
-interface SQLiteResult {
-  rows: SQLiteRow[];           // Dữ liệu trả về
-  rowsAffected: number;        // Số dòng bị ảnh hưởng
-  lastInsertRowId?: number;    // ID của record mới insert
+    return createdUsers;
+  }
 }
 
-interface SQLiteConnection {
-  execute(sql: string, params?: any[]): Promise<SQLiteResult>;
-  close(): Promise<void>;
-}
+// Example test
+describe('UserService Tests', () => {
+  let userService: UserService;
 
-interface SQLiteConfig {
-  path: string;              // Đường dẫn database
-  timeout?: number;          // Timeout kết nối
-  busyTimeout?: number;      // Timeout khi database busy
-}
-```
+  beforeAll(async () => {
+    await DatabaseTestHelpers.setupTestDatabase();
+    userService = new UserService();
+    await userService.init();
+  });
 
-### Error Codes
+  beforeEach(async () => {
+    await DatabaseTestHelpers.cleanupTestData(userService);
+  });
 
-| Error | Description | Solution |
-|-------|-------------|----------|
-| `No supported SQLite adapter found` | Không tìm thấy adapter phù hợp | Cài đặt SQLite dependencies cho môi trường |
-| `Database connection not available` | Chưa kết nối database | Gọi `connect()` trước khi query |
-| `SQLite error: no such table` | Bảng không tồn tại | Tạo bảng bằng `createTable()` hoặc SQL |
-| `UNIQUE constraint failed` | Vi phạm ràng buộc unique | Kiểm tra dữ liệu trước khi insert |
-| `database is locked` | Database đang bị khóa | Retry sau một khoảng thời gian |
+  afterAll(async () => {
+    await DatabaseManager.closeAll();
+  });
 
-## 🤝 Contributing
+  test('should create user successfully', async () => {
+    const userData = {
+      username: 'testuser',
+      email: 'test@example.com',
+      password: 'password123'
+    };
 
-### Development Setup
+    const user = await userService.createUser(userData);
+    expect(user).toBeTruthy();
+    expect(user?.username).toBe(userData.username);
+    expect(user?.email).toBe(userData.email);
+  });
+});
+```
 
-```bash
-# Clone repository
-git clone https://github.com/dqcai/sqlite
-cd sqlite
+## 9. Troubleshooting Common Issues
 
-# Install dependencies
-npm install
+### Database Locked
 
-# Run tests
-npm test
+```typescript
+// Giải quyết database locked
+const handleDatabaseLocked = async () => {
+  try {
+    // Enable WAL mode để tránh lock
+    const dao = DatabaseManager.get('users');
+    await dao.execute('PRAGMA journal_mode = WAL');
+    await dao.execute('PRAGMA busy_timeout = 30000'); // 30 giây timeout
+  } catch (error) {
+    console.error('Error setting WAL mode:', error);
+  }
+};
+```
 
-# Build
-npm run build
+### Connection Issues
 
-# Test in different environments
-npm run test:node
-npm run test:browser
-npm run test:deno
-npm run test:bun
+```typescript
+// Kiểm tra và khôi phục kết nối
+const ensureConnectionHealth = async (dbKey: string) => {
+  try {
+    const dao = DatabaseManager.get(dbKey);
+    await dao.execute('SELECT 1');
+  } catch (error) {
+    console.log(`Connection ${dbKey} unhealthy, reconnecting...`);
+    await DatabaseManager.closeConnection(dbKey);
+    await DatabaseManager.getLazyLoading(dbKey);
+    console.log(`Connection ${dbKey} restored`);
+  }
+};
 ```
 
-### Testing New Adapters
+## 10. Migration & Schema Updates
 
 ```typescript
-// tests/adapter-test.ts
-import { SQLiteAdapter } from '../src/types';
+// migrations/001_add_user_status.ts
+import { UniversalDAO } from '@dqcai/sqlite';
 
-export async function testAdapter(adapter: SQLiteAdapter, testDbPath: string) {
-  console.log(`Testing adapter: ${adapter.constructor.name}`);
-  
-  // Test 1: Support detection
-  console.log(`✓ isSupported(): ${adapter.isSupported()}`);
-  
-  if (!adapter.isSupported()) {
-    console.log('❌ Adapter not supported in current environment');
-    return;
-  }
+export const migration_001 = {
+  version: '1.0.1',
+  description: 'Add status column to users table',
   
-  try {
-    // Test 2: Connection
-    const connection = await adapter.connect(testDbPath);
-    console.log('✓ Connection established');
-    
-    // Test 3: Table creation
-    await connection.execute(`
-      CREATE TABLE IF NOT EXISTS test_table (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        value INTEGER
-      )
+  async up(dao: UniversalDAO): Promise<void> {
+    await dao.execute(`
+      ALTER TABLE users 
+      ADD COLUMN status VARCHAR(20) DEFAULT 'active'
     `);
-    console.log('✓ Table created');
-    
-    // Test 4: Insert
-    const insertResult = await connection.execute(
-      'INSERT INTO test_table (name, value) VALUES (?, ?)',
-      ['Test Item', 42]
-    );
-    console.log('✓ Insert successful, ID:', insertResult.lastInsertRowId);
     
-    // Test 5: Select
-    const selectResult = await connection.execute('SELECT * FROM test_table');
-    console.log('✓ Select successful, rows:', selectResult.rows.length);
+    await dao.execute(`
+      CREATE INDEX idx_user_status ON users(status)
+    `);
+  },
+  
+  async down(dao: UniversalDAO): Promise<void> {
+    await dao.execute(`
+      DROP INDEX IF EXISTS idx_user_status
+    `);
     
-    // Test 6: Update
-    const updateResult = await connection.execute(
-      'UPDATE test_table SET value = ? WHERE id = ?',
-      [100, insertResult.lastInsertRowId]
-    );
-    console.log('✓ Update successful, affected:', updateResult.rowsAffected);
+    // SQLite không hỗ trợ DROP COLUMN, cần recreate table
+    await dao.execute(`
+      CREATE TABLE users_backup AS 
+      SELECT id, username, email, password, created_at, updated_at 
+      FROM users
+    `);
     
-    // Test 7: Delete
-    const deleteResult = await connection.execute(
-      'DELETE FROM test_table WHERE id = ?',
-      [insertResult.lastInsertRowId]
-    );
-    console.log('✓ Delete successful, affected:', deleteResult.rowsAffected);
+    await dao.execute(`DROP TABLE users`);
     
-    // Test 8: Close
-    await connection.close();
-    console.log('✓ Connection closed');
+    await dao.execute(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        username VARCHAR(50) UNIQUE NOT NULL,
+        email VARCHAR(100) UNIQUE NOT NULL,
+        password VARCHAR(255) NOT NULL,
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME
+      )
+    `);
     
-    console.log(`🎉 All tests passed for ${adapter.constructor.name}`);
+    await dao.execute(`
+      INSERT INTO users SELECT * FROM users_backup
+    `);
     
-  } catch (error) {
-    console.error(`❌ Test failed:`, error);
+    await dao.execute(`DROP TABLE users_backup`);
   }
-}
+};
+
+// Chạy migration
+const runMigration = async () => {
+  const dao = DatabaseManager.get('users');
+  const currentVersion = await dao.getSchemaVersion();
+  
+  if (currentVersion < '1.0.1') {
+    await migration_001.up(dao);
+    await dao.setSchemaVersion('1.0.1');
+    console.log('Migration 001 completed');
+  }
+};
 ```
 
+## Kết luận
+
+Universal SQLite cung cấp một giải pháp mạnh mẽ và linh hoạt để quản lý cơ sở dữ liệu SQLite across platforms. Với DatabaseManager và BaseService, bạn có thể:
+
+- Dễ dàng quản lý nhiều database connections
+- Thực hiện CRUD operations một cách type-safe
+- Import/Export dữ liệu hiệu quả
+- Quản lý schema và migrations
+- Handle errors và performance optimization
+
+Thư viện hỗ trợ tốt cho cả React Native và Node.js, giúp bạn xây dựng ứng dụng database-driven một cách nhất quán và maintainable.
+
+## API Reference
+
+- **UniversalSQLite**: Singleton chính, methods: initialize, connect, getDAO, query, execute, importData, etc.
+- **UniversalDAO**: Core DAO cho CRUD, execute, importData.
+- **QueryBuilder**: Xây dựng query với fluent API.
+- **MigrationManager**: Quản lý migration.
+- **CSVImporter**: Import/export CSV.
+- **BaseService**: Base cho service layer.
+- **DatabaseFactory**: Factory để tạo DAO.
+- **DatabaseManager**: Quản lý connections, roles.
+
+Xem source code để biết chi tiết types và methods.
+
+
+## Best Practices
+
+1. **Always use transactions for multi-step operations**
+2. **Define schemas for type safety and validation**
+3. **Use parameterized queries to prevent SQL injection**
+4. **Implement proper error handling**
+5. **Close connections when done**
+6. **Use migrations for schema changes**
+7. **Batch large operations for better performance**
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests
+5. Submit a pull request
+
+
 ## 📄 License
 
-MIT License - see LICENSE file for details.
+MIT © [Cuong Doan](https://github.com/cuongdqpayment)
 
 ## 🙏 Acknowledgments
 
@@ -2646,8 +1808,9 @@ MIT License - see LICENSE file for details.
 - [Documentation](https://github.com/cuongdqpayment/dqcai-sqlite/docs)
 - [Examples Repository](https://github.com/cuongdqpayment/dqcai-sqlite)
 - [Issue Tracker](https://github.com/cuongdqpayment/dqcai-sqlite/issues)
+- [Issue Facebook](https://www.facebook.com/share/p/19esHGbaGj/)
 - [NPM Package](https://www.npmjs.com/package/@dqcai/sqlite)
 
 ---
 
-**Universal SQLite** - One library, all platforms! 🚀
+🔥 **@dqcai/sqlite** — One library, all platforms! 🚀