@dqcai/sqlite 1.0.0 → 2.0.0

package/README.md

@@ -1,2637 +1,548 @@
-# @dqcai/sqlite - Universal SQLite Library
+# @dqcai/sqlite - A Universal SQLite Library (@dqcai/sqlite v2.0.0)
 
 ![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.
 
-## 🚀 Cài đặt
+## Installation
 
-```bash
-npm install @dqcai/sqlite
-```
-
-### Cài đặt dependencies theo môi trường
-
-#### Node.js
-```bash
-npm install sqlite3
-```
-
-#### Browser
-Không cần cài đặt thêm - sử dụng sql.js từ CDN
-
-#### Deno
-Không cần cài đặt - sử dụng Deno SQLite module
+Cài đặt qua npm hoặc yarn:
 
-#### Bun
-Sử dụng built-in SQLite của Bun
-
-#### 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
+npm install @dqcai/sqlite@2.0.0
 # hoặc
-npm install react-native-windows-sqlite
-```
-
-## 📖 Sử dụng cơ bản
-
-### Import thư viện
-
-```typescript
-import UniversalSQLite, { SQLiteManager, QueryBuilder } from '@dqcai/sqlite';
-```
-
-### Kết nối và sử dụng đơn giản
-
-```typescript
-const db = new UniversalSQLite();
-
-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'
-    });
-    
-    // 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();
-  }
-}
-
-basicExample();
-```
-
-## 🔧 API Chi tiết
-
-### UniversalSQLite Class
-
-#### Khởi tạo
-```typescript
-const db = new UniversalSQLite();
-```
-
-#### Phương thức chính
-
-##### `connect(path: string): Promise<void>`
-```typescript
-// In-memory database
-await db.connect(':memory:');
-
-// File database
-await db.connect('database.db');
-
-// Browser (file hoặc in-memory)
-await db.connect('myapp.db');
-```
-
-##### `query(sql: string, params?: any[]): Promise<SQLiteResult>`
-```typescript
-// Truy vấn đơn giản
-const result = await db.query('SELECT * FROM users');
-
-// Truy vấn với parameters
-const result = await db.query('SELECT * FROM users WHERE age > ?', [18]);
-
-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
-```
-
-##### `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)'
-});
-```
-
-##### `insert(table: string, data: Record<string, any>): Promise<SQLiteResult>`
-```typescript
-const result = await db.insert('users', {
-  name: 'Alice',
-  email: 'alice@example.com',
-  age: 25
-});
-
-console.log('New user ID:', result.lastInsertRowId);
+yarn add @dqcai/sqlite@2.0.0
 ```
 
-##### `select(table: string, where?: string, params?: any[]): Promise<SQLiteResult>`
-```typescript
-// Lấy tất cả
-const allUsers = await db.select('users');
-
-// Có điều kiện
-const adults = await db.select('users', 'age >= ?', [18]);
-
-// Điều kiện phức tạp
-const result = await db.select('users', 'age BETWEEN ? AND ? AND name LIKE ?', [18, 65, 'A%']);
-```
+Đố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).
 
-##### `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]
-);
+## Quick Start
 
-console.log('Updated rows:', result.rowsAffected);
-```
+### Bước 1: Định nghĩa Schema
+Schema là một object JSON mô tả cấu trúc database.
 
-##### `delete(table: string, where: string, params?: any[]): Promise<SQLiteResult>`
 ```typescript
-const result = await db.delete('users', 'age < ?', [18]);
-console.log('Deleted rows:', result.rowsAffected);
-```
-
-### QueryBuilder - Xây dựng truy vấn nâng cao
+import { DatabaseSchema } from '@dqcai/sqlite';
 
-```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
-});
-
-await db.query(insertSQL, ['Bob', 'bob@example.com', 30]);
-
-// UPDATE với QueryBuilder
-const updateSQL = QueryBuilder.update('users', 
-  { email: 'bob.updated@example.com' }, 
-  'id = 1'
-);
-
-await db.query(updateSQL, ['bob.updated@example.com']);
-
-// DELETE với QueryBuilder
-const deleteSQL = QueryBuilder.delete('users', 'age < 18');
-await db.query(deleteSQL);
-```
-
-### SQLiteManager - Quản lý kết nối thủ công
-
-```typescript
-import { SQLiteManager } from '@dqcai/sqlite';
-
-const manager = new SQLiteManager();
-
-// Kiểm tra môi trường
-console.log('Environment:', manager.getEnvironmentInfo());
-
-// Kết nối thủ công
-const connection = await manager.connect('database.db');
-
-// Thực thi truy vấn
-const result = await connection.execute('SELECT * FROM users');
-
-// Đóng kết nối
-await connection.close();
-```
-
-## 🌍 Ví dụ theo môi trường
-
-### Node.js Application
-
-```typescript
-// server.js
-import UniversalSQLite from '@dqcai/sqlite';
-
-const db = new UniversalSQLite();
-
-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!');
-}
-
-async function createUser(username: string, email: string, passwordHash: string) {
-  return await db.insert('users', {
-    username,
-    email,
-    password_hash: passwordHash
-  });
-}
-
-async function getUserByEmail(email: string) {
-  const result = await db.select('users', 'email = ?', [email]);
-  return result.rows[0] || null;
-}
-
-setupUserSystem();
-```
-
-### Browser Application
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Universal SQLite Browser Demo</title>
-</head>
-<body>
-    <div id="app"></div>
-    
-    <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);
-            }
+const exampleSchema: DatabaseSchema = {
+  version: '1.0.0',
+  database_name: 'example_db',
+  description: 'Example database',
+  schemas: {
+    users: {
+      description: 'Users table',
+      cols: [
+        { name: 'id', type: 'integer', primary_key: true, auto_increment: true },
+        { name: 'name', type: 'string', nullable: false },
+        { name: 'email', type: 'string', unique: true },
+      ],
+      indexes: [{ name: 'idx_email', columns: ['email'], unique: true }],
+      foreign_keys: [],
+    },
+  },
+};
+```
+
+```json
+// schema.json ví dụ kiểu json
+{
+  "version": "1.0.0",
+  "database_name": "example.db",
+  "description": "Schema for example application.",
+  "schemas": {
+    "users": {
+      "description": "User accounts table.",
+      "cols": [
+        {
+          "name": "id",
+          "type": "integer",
+          "constraints": "PRIMARY KEY AUTOINCREMENT"
+        },
+        {
+          "name": "name",
+          "type": "text",
+          "constraints": "NOT NULL"
+        },
+        {
+          "name": "email",
+          "type": "text",
+          "constraints": "UNIQUE NOT NULL"
+        },
+        {
+          "name": "created_at",
+          "type": "timestamp",
+          "constraints": "DEFAULT CURRENT_TIMESTAMP"
         }
-        
-        browserDemo();
-    </script>
-</body>
-</html>
-```
-
-### React Native Application
-
-```typescript
-// App.tsx
-import React, { useState, useEffect } from 'react';
-import { View, Text, Button, FlatList } from 'react-native';
-import UniversalSQLite from '@dqcai/sqlite';
-
-const db = new UniversalSQLite();
-
-interface User {
-  id: number;
-  name: string;
-  email: string;
-}
-
-export default function App() {
-  const [users, setUsers] = useState<User[]>([]);
-  const [environment, setEnvironment] = useState<string>('');
-
-  useEffect(() => {
-    initDatabase();
-  }, []);
-
-  const initDatabase = async () => {
-    try {
-      // Kết nối database
-      await db.connect('myapp.db');
-      
-      // 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'
-      });
-      
-      // Load dữ liệu
-      loadUsers();
-      
-    } catch (error) {
-      console.error('Database init error:', error);
-    }
-  };
-
-  const loadUsers = async () => {
-    try {
-      const result = await db.select('users');
-      setUsers(result.rows);
-    } catch (error) {
-      console.error('Load users error:', error);
-    }
-  };
-
-  const addUser = async () => {
-    try {
-      await db.insert('users', {
-        name: `User ${Date.now()}`,
-        email: `user${Date.now()}@example.com`
-      });
-      loadUsers();
-    } catch (error) {
-      console.error('Add user error:', error);
+      ]
+    },
+    "posts": {
+      "description": "Posts created by users.",
+      "cols": [
+        {
+          "name": "id",
+          "type": "integer",
+          "constraints": "PRIMARY KEY AUTOINCREMENT"
+        },
+        {
+          "name": "title",
+          "type": "text",
+          "constraints": "NOT NULL"
+        },
+        {
+          "name": "content",
+          "type": "text"
+        },
+        {
+          "name": "user_id",
+          "type": "integer",
+          "constraints": "NOT NULL"
+        }
+      ],
+      "foreign_keys": [
+        {
+          "name": "fk_posts_user_id",
+          "column": "user_id",
+          "references": {
+            "table": "users",
+            "column": "id"
+          },
+          "on_delete": "CASCADE"
+        }
+      ]
     }
-  };
-
-  return (
-    <View style={{ flex: 1, padding: 20 }}>
-      <Text>Environment: {environment}</Text>
-      <Button title="Add User" onPress={addUser} />
-      
-      <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>
-        )}
-      />
-    </View>
-  );
-}
-```
-
-### Deno Application
-
-```typescript
-// main.ts
-import UniversalSQLite from "https://esm.sh/@dqcai/sqlite";
-
-const db = new UniversalSQLite();
-
-async function denoExample() {
-  try {
-    await db.connect('./deno_database.db');
-    
-    // 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' });
-    
-    // Truy vấn logs theo level
-    const errorLogs = await db.select('logs', 'level = ?', ['ERROR']);
-    console.log('Error logs:', errorLogs.rows);
-    
-    // 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();
-    
-    const result = await db.query(recentLogs);
-    console.log('Recent logs:', result.rows);
-    
-  } finally {
-    await db.close();
   }
 }
-
-// Chạy với: deno run --allow-read --allow-write main.ts
-denoExample();
 ```
 
-### Bun Application
+### Bước 2: Khởi tạo và Sử dụng
+Sử dụng singleton UniversalSQLite.
 
 ```typescript
-// app.ts
 import UniversalSQLite from '@dqcai/sqlite';
 
-const db = new UniversalSQLite();
-
-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);
-  }
-  
-  // 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();
-```
+const sqlite = UniversalSQLite.getInstance();
 
-## 🏗️ Ví dụ nâng cao
+async function init() {
+  await sqlite.initializeFromSchema(exampleSchema);
+  const dao = await sqlite.connect('example_db');
 
-### 1. Transaction Management
-
-```typescript
-import { SQLiteManager } from '@dqcai/sqlite';
-
-async function transactionExample() {
-  const manager = new SQLiteManager();
-  const connection = await manager.connect('transactions.db');
-  
-  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']
-    );
-    
-    // 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');
-    }
-    
-    // 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();
-  }
+  // CRUD example
+  await dao.insert({ name: 'users', cols: [{ name: 'name', value: 'John' }, { name: 'email', value: 'john@example.com' }] });
+  const users = await dao.selectAll({ name: 'users' });
+  console.log(users);
 }
 
-transactionExample();
+init();
 ```
 
-### 2. Complex Queries với JOIN
+## Adapters and Environment Setup
 
-```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();
-}
+UniversalSQLite tự động detect môi trường và chọn adapter phù hợp. Tuy nhiên, bạn có thể register adapter tùy chỉnh nếu cần.
 
-complexQueryExample();
-```
+### Common Adapters
+- **Browser**: Sử dụng sql.js (cần import sql.js library).
+- **Node.js**: Sử dụng better-sqlite3 hoặc sqlite3 (cần cài đặt package tương ứng).
+- **React Native**: Sử dụng react-native-sqlite-storage (cần cài đặt package).
+- **Deno/Bun**: Sử dụng native SQLite support.
 
-### 3. Real-time Data Synchronization
+### Register Adapter
+Khai báo adapter tùy chỉnh bằng cách extend BaseAdapter và register với DatabaseFactory.
 
 ```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);
-      }
-    }
-  }
-  
-  // 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();
-}
+import { BaseAdapter, SQLiteAdapter } from '@dqcai/sqlite';
+import DatabaseFactory from '@dqcai/sqlite';
 
-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}`);
-    
-    const migrations = [
-      this.migration1_initial,
-      this.migration2_addUserProfiles,
-      this.migration3_addIndexes,
-      this.migration4_addAuditLog
-    ];
-    
-    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`);
-    }
-    
-    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
-    `);
-  }
+class CustomNodeAdapter extends BaseAdapter implements SQLiteAdapter {
+  // Implement connect and isSupported
+  async connect(path: string) { /* ... */ }
+  isSupported() { return true; }
 }
 
-// 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();
+DatabaseFactory.registerAdapter(new CustomNodeAdapter());
 ```
 
-### 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();
-```
+## Usage Guide
 
-### 6. Data Analytics và Reporting
+### 1. Khởi tạo Database
+Sử dụng DatabaseFactory để tạo hoặc mở database.
 
-```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();
-}
+- **Tạo từ Schema**:
+  ```typescript
+  const dao = await DatabaseFactory.createFromConfig(exampleSchema);
+  ```
 
-analyticsExample();
-```
+- **Mở Existing Database**:
+  ```typescript
+  const dao = await DatabaseFactory.openExisting('example_db.db');
+  ```
 
-## 🔍 Debugging và Monitoring
+- **Create DAO Directly**:
+  ```typescript
+  const dao = DatabaseFactory.createDAO('example_db.db', { createIfNotExists: true });
+  await dao.connect();
+  ```
 
-### 1. Query Performance Monitoring
+### 2. CRUD Operations với UniversalDAO
+UniversalDAO cung cấp các method CRUD cơ bản.
 
 ```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;
-    
-    console.log(`Query executed in ${duration.toFixed(2)}ms: ${sql.substring(0, 100)}...`);
-    
-    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}`);
-    });
-  }
-}
+// Insert
+await dao.insert({ name: 'users', cols: [{ name: 'name', value: 'Alice' }] });
 
-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}`
-    });
-  }
-  
-  // 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();
-```
+// Update
+await dao.update({ name: 'users', cols: [{ name: 'name', value: 'Bob' }], wheres: [{ name: 'id', value: 1 }] });
 
-### 2. Connection Pool (Advanced)
+// Delete
+await dao.delete({ name: 'users', wheres: [{ name: 'id', value: 1 }] });
 
-```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)!;
-    }
-    
-    if (this.connections.size >= this.maxConnections) {
-      throw new Error('Connection pool exhausted');
-    }
-    
-    const db = new UniversalSQLite();
-    await db.connect(dbPath);
-    this.connections.set(dbPath, db);
-    
-    return db;
-  }
-  
-  async closeAll(): Promise<void> {
-    for (const [path, db] of this.connections) {
-      await db.close();
-    }
-    this.connections.clear();
-  }
-}
-
-async function connectionPoolExample() {
-  const pool = new ConnectionPool();
-  
-  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();
-  }
-}
-
-connectionPoolExample();
+// Select
+const row = await dao.select({ name: 'users', wheres: [{ name: 'id', value: 1 }] });
+const allRows = await dao.selectAll({ name: 'users' });
 ```
 
-## 🛠️ Configuration và Customization
-
-### Environment Detection
+### 3. Query Builder
+Xây dựng query phức tạp.
 
 ```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;
-}
-```
-
-### Custom Error Handling
-
-```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;
-    }
-  }
-}
+import { QueryBuilder } from '@dqcai/sqlite';
 
-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' });
-  });
-  
-  console.log('User1 result:', user1);
-  console.log('User2 result:', user2); // null due to unique constraint
-  
-  await db.close();
-}
+const qb = new QueryBuilder(dao).table('users')
+  .select('id', 'name')
+  .where('age', '>', 18)
+  .orderBy('name', 'ASC')
+  .limit(10);
 
-errorHandlingExample();
+const results = await qb.get();
 ```
 
-## 📱 Platform-Specific Examples
-
-### React Native với Expo
+### 4. Migration
+Sử dụng MigrationManager.
 
 ```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);
-
-  useEffect(() => {
-    initDatabase();
-  }, []);
-
-  const initDatabase = async () => {
-    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();
-    } catch (error) {
-      console.error('Database setup error:', error);
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  const loadTodos = async () => {
-    try {
-      const result = await db.select('todos', null, []);
-      setTodos(result.rows);
-    } catch (error) {
-      console.error('Load todos error:', error);
-    }
-  };
-
-  const addTodo = async () => {
-    try {
-      await db.insert('todos', {
-        title: `Todo ${Date.now()}`,
-        priority: Math.floor(Math.random() * 3) + 1
-      });
-      loadTodos();
-    } catch (error) {
-      console.error('Add todo error:', error);
-    }
-  };
-
-  const toggleTodo = async (id: number, completed: boolean) => {
-    try {
-      await db.update('todos', 
-        { completed: completed ? 0 : 1 },
-        'id = ?',
-        [id]
-      );
-      loadTodos();
-    } catch (error) {
-      console.error('Toggle todo error:', 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',
-  },
+const migrationManager = new MigrationManager(dao);
+migrationManager.addMigration({
+  version: '1.1.0',
+  description: 'Add column',
+  up: async (dao) => { await dao.execute('ALTER TABLE users ADD COLUMN age INTEGER'); },
+  down: async (dao) => { /* rollback */ },
 });
+await migrationManager.migrate();
 ```
 
-### Next.js API Routes
+### 5. Import/Export Data
+Sử dụng CSVImporter hoặc importData.
 
 ```typescript
-// pages/api/users/[id].ts
-import { NextApiRequest, NextApiResponse } from 'next';
-import UniversalSQLite from '@dqcai/sqlite';
-
-const db = new UniversalSQLite();
-let isConnected = false;
-
-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'
-    });
-    
-    isConnected = true;
-  }
-}
+const importer = new CSVImporter(dao);
+await importer.importFromCSV('users', csvString, { hasHeader: true });
 
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-  const { id } = req.query;
-  
-  try {
-    await ensureConnection();
-    
-    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)]);
-        
-        if (deleteResult.rowsAffected === 0) {
-          res.status(404).json({ error: 'User not found' });
-        } else {
-          res.status(200).json({ message: 'User deleted successfully' });
-        }
-        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
-
-### Unit Tests với Jest
-
-```typescript
-// __tests__/universal-sqlite.test.ts
-import UniversalSQLite from '../src/index';
-
-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);
-  });
-  
-  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
-  });
-});
+// Hoặc import JSON
+await dao.importData({ tableName: 'users', data: [{ name: 'John' }] });
 ```
 
-## 🔐 Best Practices
-
-### 1. Security
-
+### 6. Transaction
 ```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');
-    }
-    
-    // Sanitize input
-    const sanitizedData = {
-      name: userData.name.trim(),
-      email: userData.email.toLowerCase().trim(),
-      username: userData.username.trim()
-    };
-    
-    return await this.db.insert('users', sanitizedData);
-  }
+await dao.beginTransaction();
+try {
+  // operations
+  await dao.commitTransaction();
+} catch {
+  await dao.rollbackTransaction();
 }
 ```
 
-### 2. Performance Optimization
+### 7. BaseService
+Tạo service layer.
 
 ```typescript
-class OptimizedDatabase {
-  private db: UniversalSQLite;
-  
+class UserService extends BaseService<{ id: number; name: string }> {
   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');
-    
-    try {
-      for (const record of records) {
-        await this.db.insert(table, record);
-      }
-      await this.db.query('COMMIT');
-    } catch (error) {
-      await this.db.query('ROLLBACK');
-      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})
-      `);
-    }
+    super('example_db', 'users');
   }
 }
-```
 
-## 🚨 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)`);
-  }
-}
+const userService = new UserService();
+await userService.create({ name: 'John' });
 ```
 
-#### 2. React Native Windows Setup
+### 8. Role-Based Management
+Sử dụng DatabaseManager để quản lý role.
 
 ```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');
-    
-    try {
-      await db.connect('windows_test.db');
-      console.log('✅ Database connection successful');
-      
-      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');
-    }
-  }
-}
+DatabaseManager.registerRole({ roleName: 'admin', requiredDatabases: ['example_db'] });
+await DatabaseManager.setCurrentUserRoles(['admin']);
+const dao = DatabaseManager.get('example_db');
 ```
 
-#### 3. Browser CORS Issues
+## Examples
 
-```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();
-```
+### Example for React Native
 
-## 📚 Advanced Use Cases
+1. Cài đặt dependencies:
+   ```bash
+   npm install react-native-sqlite-storage
+   ```
 
-### 1. Multi-Database Application
+2. Khai báo Adapter (nếu cần tùy chỉnh, nhưng thư viện tự detect):
+   ```typescript
+    import { enablePromise, openDatabase} from 'react-native-sqlite-storage';
+    import { BaseAdapter } from '@dqcai/sqlite';
+    enablePromise(true);
+    class ReactNativeAdapter extends BaseAdapter {
+        isSupported() {
+            return typeof Platform !== 'undefined' && Platform.OS !== 'web';
+        }
 
-```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;
+        connect(path) {
+            return new Promise((resolve, reject) => {
+            const db = openDatabase(
+                { name: path, location: 'default' },
+                () => {
+                resolve({
+                    execute: (sql, params) => {
+                    return new Promise((execResolve, execReject) => {
+                        db.transaction(tx => {
+                        tx.executeSql(
+                            sql,
+                            params,
+                            (tx, results) => {
+                            const rowsAffected = results.rowsAffected;
+                            let rows = [];
+                            for (let i = 0; i < results.rows.length; i++) {
+                                rows.push(results.rows.item(i));
+                            }
+                            execResolve({ rows, rowsAffected, lastInsertRowId: results.insertId });
+                            },
+                            (tx, error) => {
+                            execReject(error);
+                            }
+                        );
+                        });
+                    });
+                    },
+                    close: () => {
+                    return new Promise((closeResolve, closeReject) => {
+                        db.close((err) => {
+                        if (err) return closeReject(err);
+                        closeResolve();
+                        });
+                    });
+                    }
+                });
+                },
+                (error) => reject(error)
+            );
+            });
+        }
     }
+    export default ReactNativeAdapter;
     
-    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();
-  }
-}
+   ```
 
-// Usage
-async function multiDbExample() {
-  const app = new MultiDatabaseApp();
-  
-  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);
-    
-  } catch (error) {
-    console.error('Multi-db error:', error);
-  } finally {
-    await app.cleanup();
-  }
-}
+3. Tạo và Mở Database, CRUD:
+   ```typescript
+    import { DatabaseFactory } from '@dqcai/sqlite';
+    import ReactNativeAdapter from './adapters/react-native-adapter'; // Hoặc NodejsAdapter
+    import schema from './schema.json';
 
-multiDbExample();
-```
+    async function setupDatabase() {
+    // Đăng ký adapter để thư viện biết cách kết nối
+    DatabaseFactory.registerAdapter(new ReactNativeAdapter()); // Đăng ký adapter cho môi trường
 
-### 2. Real-time Sync với WebSocket
+    // Tạo hoặc mở database. Nếu file chưa tồn tại, nó sẽ được tạo mới và init schema.
+    // Nếu đã tồn tại, nó sẽ được mở.
+    const dao = await DatabaseFactory.createOrOpen({ config: schema });
 
-```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[] = [];
-  
-  constructor() {
-    this.db = new UniversalSQLite();
-  }
-  
-  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();
-  }
-  
-  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;
-  }
-  
-  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]);
-  }
-  
-  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)
-    });
-  }
-  
-  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']);
-    
-    for (const sync of pendingSyncs.rows) {
-      try {
-        // Simulate API call
-        const response = await this.syncToServer(sync);
-        
-        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]
-            );
-          }
-        }
-      } catch (error) {
-        await this.db.update('sync_log',
-          { sync_status: 'failed' },
-          'id = ?',
-          [sync.id]
-        );
-        console.error('Sync failed:', error);
-      }
+    console.log(`Kết nối thành công tới database: ${dao.getDatabaseInfo().name}`);
+    return dao;
     }
-  }
-  
-  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);
-    });
-  }
-}
-
-// 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));
-}
 
-realtimeSyncExample();
-```
+    async function crudOperations(dao) {
+        // 1. CREATE (Insert)
+        console.log('Inserting a new user...');
+        const userToInsert = {
+            name: 'John Doe',
+            email: 'john.doe@example.com',
+        };
+        const insertResult = await dao.insert({
+            name: 'users',
+            cols: Object.entries(userToInsert).map(([name, value]) => ({ name, value })),
+        });
+        const newUserId = insertResult.lastInsertRowId;
+        console.log(`User inserted with ID: ${newUserId}`);
+
+        // 2. READ (Select)
+        console.log('Selecting user by email...');
+        const selectedUser = await dao.select({
+            name: 'users',
+            cols: [], // Chọn tất cả các cột
+            wheres: [{ name: 'email', value: 'john.doe@example.com' }],
+        });
+        console.log('Selected user:', selectedUser);
+
+        // 3. UPDATE
+        console.log('Updating user name...');
+        await dao.update({
+            name: 'users',
+            cols: [{ name: 'name', value: 'John Smith' }],
+            wheres: [{ name: 'id', value: newUserId }],
+        });
+        const updatedUser = await dao.select({
+            name: 'users',
+            cols: ['id', 'name'],
+            wheres: [{ name: 'id', value: newUserId }],
+        });
+        console.log('Updated user:', updatedUser);
 
-### 3. Database Backup và Restore
+        // 4. DELETE
+        console.log('Deleting the user...');
+        const deleteResult = await dao.delete({
+            name: 'users',
+            wheres: [{ name: 'id', value: newUserId }],
+        });
+        console.log(`Rows deleted: ${deleteResult.rowsAffected}`);
 
-```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);
-      
-      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);
-          });
-          
-          backupSQL += `INSERT INTO ${table.name} (${columns.join(', ')}) VALUES (${values.join(', ')});\n`;
+        const checkUser = await dao.select({
+            name: 'users',
+            wheres: [{ name: 'id', value: newUserId }],
+        });
+        console.log('User exists after delete?', Object.keys(checkUser).length > 0);
         }
-        backupSQL += '\n';
-      }
-    }
-    
-    return backupSQL;
-  }
-  
-  async restoreFromBackup(backupSQL: string): Promise<void> {
-    const statements = backupSQL
-      .split(';')
-      .map(stmt => stmt.trim())
-      .filter(stmt => stmt && !stmt.startsWith('--'));
-    
-    await this.db.query('BEGIN TRANSACTION');
-    
+
+    // Chạy ví dụ
+    async function main() {
     try {
-      for (const statement of statements) {
-        if (statement) {
-          await this.db.query(statement);
-        }
-      }
-      await this.db.query('COMMIT');
-      console.log('Backup restored successfully');
+        const dao = await setupDatabase();
+        await crudOperations(dao);
+        await dao.close();
+        console.log('Đã đóng kết nối database.');
     } catch (error) {
-      await this.db.query('ROLLBACK');
-      throw new Error(`Restore failed: ${error}`);
+        console.error('Đã xảy ra lỗi:', error);
     }
-  }
-  
-  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);
-      }
-    }, intervalMinutes * 60 * 1000);
-  }
-  
-  async close() {
-    await this.db.close();
-  }
-}
-
-// 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
-
-```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;
-}
-
-// app.ts
-async function productionSetup() {
-  const config = getDatabaseConfig();
-  const db = new UniversalSQLite();
-  
-  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');
-  }
-  
-  // Setup production tables
-  await setupProductionSchema(db);
-  
-  // Setup monitoring
-  if (process.env.NODE_ENV === 'production') {
-    setupProductionMonitoring(db);
-  }
-  
-  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
-  `);
-}
-
-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');
     }
-  }, 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
+    main();
+   ```
+
+### Example for Node.js
+
+1. Cài đặt dependencies:
+   ```bash
+   npm install better-sqlite3
+   ```
+
+2. Khai báo Adapter (tự detect, nhưng có thể tùy chỉnh):
+   ```typescript
+   class NodeAdapter extends BaseAdapter {
+     async connect(path: string) {
+       const SQLite3 = require('better-sqlite3');
+       const db = new SQLite3(path);
+       return {
+         execute: (sql: string, params = []) => {
+           const stmt = db.prepare(sql);
+           const result = stmt.run(params);
+           return { rows: stmt.all(params), rowsAffected: result.changes };
+         },
+         close: () => db.close(),
+       };
+     }
+     isSupported() { return true; }
+   }
+
+   DatabaseFactory.registerAdapter(new NodeAdapter());
+   ```
+
+3. Tạo và Mở Database, CRUD:
+   ```typescript
+   import UniversalSQLite from '@dqcai/sqlite';
+
+   const sqlite = UniversalSQLite.getInstance();
+
+   async function nodeExample() {
+     await sqlite.initializeFromSchema(exampleSchema);
+     const dao = await sqlite.connect('example_db');
+
+     // CRUD
+     await dao.insert({ name: 'users', cols: [{ name: 'name', value: 'NodeUser' }, { name: 'email', value: 'node@example.com' }] });
+     const users = await dao.selectAll({ name: 'users' });
+     console.log('Users:', users);
+
+     // Query Builder
+     const qb = sqlite.query('users');
+     const results = await qb.select('*').where('name', 'LIKE', '%User%').get();
+
+     // Migration
+     const migrationManager = sqlite.createMigrationManager();
+     migrationManager.addMigration({
+       version: '1.0.1',
+       description: 'Add age',
+       up: async (dao) => await dao.execute('ALTER TABLE users ADD COLUMN age INTEGER'),
+       down: async (dao) => await dao.execute('ALTER TABLE users DROP COLUMN age'),
+     });
+     await migrationManager.migrate();
+
+     // Import from File
+     const importer = sqlite.createCSVImporter();
+     await importer.importFromFile('users', './data.csv', { hasHeader: true });
+
+     await sqlite.closeAll();
+   }
+
+   nodeExample();
+   ```
+
+## 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
 
-```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
-}
-
-interface SQLiteConnection {
-  execute(sql: string, params?: any[]): Promise<SQLiteResult>;
-  close(): Promise<void>;
-}
-
-interface SQLiteConfig {
-  path: string;              // Đường dẫn database
-  timeout?: number;          // Timeout kết nối
-  busyTimeout?: number;      // Timeout khi database busy
-}
-```
-
-### Error Codes
-
-| 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 |
-
-## 🤝 Contributing
-
-### Development Setup
-
-```bash
-# Clone repository
-git clone https://github.com/dqcai/sqlite
-cd sqlite
-
-# Install dependencies
-npm install
-
-# Run tests
-npm test
-
-# Build
-npm run build
-
-# Test in different environments
-npm run test:node
-npm run test:browser
-npm run test:deno
-npm run test:bun
-```
-
-### Testing New Adapters
-
-```typescript
-// tests/adapter-test.ts
-import { SQLiteAdapter } from '../src/types';
-
-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;
-  }
-  
-  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
-      )
-    `);
-    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);
-    
-    // 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);
-    
-    // Test 7: Delete
-    const deleteResult = await connection.execute(
-      'DELETE FROM test_table WHERE id = ?',
-      [insertResult.lastInsertRowId]
-    );
-    console.log('✓ Delete successful, affected:', deleteResult.rowsAffected);
-    
-    // Test 8: Close
-    await connection.close();
-    console.log('✓ Connection closed');
-    
-    console.log(`🎉 All tests passed for ${adapter.constructor.name}`);
-    
-  } catch (error) {
-    console.error(`❌ Test failed:`, error);
-  }
-}
-```
 
 ## 📄 License
 
-MIT License - see LICENSE file for details.
+MIT © [Cuong Doan](https://github.com/cuongdqpayment)
 
 ## 🙏 Acknowledgments
 
@@ -2646,8 +557,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! 🚀