@dqcai/sqlite 3.1.0 → 3.2.0

package/README.md

@@ -30,575 +30,717 @@ yarn add @dqcai/sqlite @dqcai/logger
 pnpm add @dqcai/sqlite @dqcai/logger
 ```
 
-## ⚡ Quick Start
+### Cài đặt dependencies theo môi trường
 
-```typescript
-import { DatabaseManager, ServiceManager, BaseService } from '@dqcai/sqlite';
-
-// 1. Define your schema
-const userSchema = {
-  version: "1.0.0",
-  database_name: "users",
-  schemas: {
-    users: {
-      cols: [
-        { name: "id", type: "integer", primary_key: true, auto_increment: true },
-        { name: "username", type: "varchar", length: 50, unique: true },
-        { name: "email", type: "varchar", length: 100, unique: true },
-        { name: "created_at", type: "datetime", default: "CURRENT_TIMESTAMP" }
-      ]
-    }
-  }
-};
-
-// 2. Initialize database
-await DatabaseManager.registerSchema('users', userSchema);
-await DatabaseManager.initializeCoreConnection();
-
-// 3. Create service
-class UserService extends BaseService {
-  async createUser(data) {
-    return await this.create(data);
-  }
-  
-  async getAllUsers() {
-    return await this.findAll();
-  }
-}
+**React Native:**
 
-// 4. Use it!
-const service = new UserService('users', 'users');
-const user = await service.createUser({ 
-  username: 'john', 
-  email: 'john@example.com' 
-});
+```bash
+npm install react-native-sqlite-storage
 ```
 
-## 📝 Logger Integration (v3.1.0+)
+**Node.js:**
 
-@dqcai/sqlite integrates seamlessly with [@dqcai/logger](https://www.npmjs.com/package/@dqcai/logger) for comprehensive logging capabilities across your entire application.
+```bash
+npm install better-sqlite3
+```
 
-### Step 1: Configure Logger
+## 2. Lựa chọn Adapter theo môi trường
 
-Create a centralized logger configuration file:
+### React Native Adapter
 
 ```typescript
-// ./src/configs/logger.ts
-import {
-  LogLevel,
-  LoggerConfigBuilder,
-  createModuleLogger,
-  CommonLoggerConfig,
-} from "@dqcai/logger";
-
-import { SQLiteModules } from "@dqcai/sqlite"; // version 3.1.0+
-
-// Define your application modules
-const AppModules = {
-  ...SQLiteModules, // Includes: UNIVERSAL_SQLITE, UNIVERSAL_DAO, etc.
-  MIDDLEWARE: "middleware",
-  API: "api",
-  AUTH: "auth",
-  // Add your custom modules here
-};
-
-// Configure logger settings
-const config = new LoggerConfigBuilder()
-  .setEnabled(true) // Enable logging globally
-  .setDefaultLevel('trace') // Set default log level: trace, debug, info, warn, error
-  // Optional: Configure specific modules
-  .addModule(SQLiteModules.UNIVERSAL_SQLITE, true, ['info', 'warn', 'error'], ['console'])
-  .addModule(SQLiteModules.UNIVERSAL_DAO, true, ['debug', 'info', 'warn', 'error'], ['console'])
-  .addModule(AppModules.MIDDLEWARE, true, ['trace', 'debug', 'info', 'warn', 'error'], ['console'])
-  .build();
-
-// Apply configuration
-CommonLoggerConfig.updateConfiguration(config);
+import { ReactNativeAdapter, DatabaseFactory } from "@dqcai/sqlite";
 
-export { createModuleLogger, AppModules };
+// Đăng ký adapter
+DatabaseFactory.registerAdapter(new ReactNativeAdapter());
 ```
 
-### Step 2: Use Logger in Your Modules
-
-Replace `console.log/debug/warn/error` with the module logger:
+### Node.js Adapter
 
 ```typescript
-// ./src/middleware/auth.ts
-import { createModuleLogger, AppModules } from "@/configs/logger";
-
-const logger = createModuleLogger(AppModules.MIDDLEWARE);
-
-export function authMiddleware(req, res, next) {
-  logger.trace("Middleware importing...");
-  logger.debug("Processing authentication", { userId: req.userId });
-  logger.info("User authenticated successfully");
-  logger.warn("Token expires soon", { expiresIn: 300 });
-  logger.error("Authentication failed", { reason: "Invalid token" });
-  
-  next();
-}
+import { NodeJSAdapter, DatabaseFactory } from "@dqcai/sqlite";
+
+// Đăng ký adapter
+DatabaseFactory.registerAdapter(new NodeJSAdapter());
 ```
 
-### Step 3: Use Logger in Services
+### Adapter tự động phát hiện
 
 ```typescript
-// ./src/services/UserService.ts
-import { BaseService } from '@dqcai/sqlite';
-import { createModuleLogger, AppModules } from "@/configs/logger";
-
-const logger = createModuleLogger(AppModules.API);
-
-interface User {
-  id?: number;
-  username: string;
-  email: string;
-}
-
-class UserService extends BaseService<User> {
-  constructor() {
-    super('users', 'users');
-    logger.info("UserService initialized");
-  }
+import { DatabaseFactory } from "@dqcai/sqlite";
+import { ReactNativeAdapter } from "@dqcai/sqlite";
+import { NodeJSAdapter } from "@dqcai/sqlite";
 
-  async createUser(data: Omit<User, 'id'>): Promise<User | null> {
-    logger.debug("Creating user", { username: data.username });
-    
-    try {
-      const user = await this.create(data);
-      logger.info("User created successfully", { userId: user?.id });
-      return user;
-    } catch (error) {
-      logger.error("Failed to create user", { error, data });
-      throw error;
-    }
-  }
+// Đăng ký cả hai adapter - thư viện sẽ tự chọn adapter phù hợp
+DatabaseFactory.registerAdapter(new ReactNativeAdapter());
+DatabaseFactory.registerAdapter(new NodeJSAdapter());
 
-  async findByEmail(email: string): Promise<User | null> {
-    logger.trace("Searching user by email", { email });
-    return await this.findFirst({ email });
-  }
-}
+// Kiểm tra môi trường hiện tại
+console.log("Environment:", DatabaseFactory.getEnvironmentInfo());
 ```
 
-### Advanced Logger Configuration
+## 3. Quản lý Database với DatabaseManager
 
-#### Environment-based Configuration
+### Khai báo Schema
 
 ```typescript
-// ./src/configs/logger.ts
-const isDevelopment = process.env.NODE_ENV === 'development';
-const logLevel = process.env.LOG_LEVEL || (isDevelopment ? 'trace' : 'info');
-const logEnabled = process.env.LOG_ENABLED !== 'false';
-
-const config = new LoggerConfigBuilder()
-  .setEnabled(logEnabled)
-  .setDefaultLevel(logLevel as LogLevel)
-  .build();
-```
-
-#### File Transport
+import { DatabaseSchema, SQLITE_TYPE_MAPPING } from "@dqcai/sqlite";
 
-```typescript
-import { FileTransport } from "@dqcai/logger";
-
-const config = new LoggerConfigBuilder()
-  .setEnabled(true)
-  .setDefaultLevel('debug')
-  .addModule(
-    AppModules.API,
-    true,
-    ['info', 'warn', 'error'],
-    ['console', 'file'] // Log to both console and file
-  )
-  .addTransport(new FileTransport({
-    filename: './logs/app.log',
-    maxSize: 10 * 1024 * 1024, // 10MB
-    maxFiles: 5
-  }))
-  .build();
+const coreSchema: DatabaseSchema = {
+  version: "v1",
+  database_name: "core.db",
+  description: "Core database schema",
+  type_mapping: SQLITE_TYPE_MAPPING,
+  schemas: {
+    users: {
+      description: "User management table",
+      cols: [
+        {
+          name: "id",
+          type: "uuid",
+          constraints: "NOT NULL UNIQUE PRIMARY KEY",
+        },
+        {
+          name: "username",
+          type: "varchar",
+          length: 50,
+          constraints: "NOT NULL UNIQUE",
+        },
+        {
+          name: "email",
+          type: "email",
+          constraints: "UNIQUE",
+        },
+        {
+          name: "created_at",
+          type: "timestamp",
+          constraints: "DEFAULT CURRENT_TIMESTAMP",
+        },
+      ],
+      indexes: [
+        {
+          name: "idx_users_username",
+          columns: ["username"],
+          unique: true,
+        },
+      ],
+    },
+  },
+};
 ```
 
-#### API Transport (Remote Logging)
+### Đăng ký Schema và khởi tạo Database
 
 ```typescript
-import { APITransport } from "@dqcai/logger";
-
-const config = new LoggerConfigBuilder()
-  .setEnabled(true)
-  .setDefaultLevel('info')
-  .addTransport(new APITransport({
-    url: 'https://your-logging-service.com/logs',
-    method: 'POST',
-    headers: {
-      'Authorization': 'Bearer YOUR_TOKEN'
-    }
-  }))
-  .build();
-```
+import { DatabaseManager } from "@dqcai/sqlite";
 
-### Logger Best Practices
+// Đăng ký schema
+DatabaseManager.registerSchema("core", coreSchema);
 
-1. **Use appropriate log levels**:
-   - `trace`: Very detailed information for debugging
-   - `debug`: Diagnostic information
-   - `info`: General informational messages
-   - `warn`: Warning messages for potentially harmful situations
-   - `error`: Error messages for serious problems
+// Khởi tạo kết nối core database
+await DatabaseManager.initializeCoreConnection();
 
-2. **Include contextual data**:
-```typescript
-logger.info("User action completed", {
-  userId: user.id,
-  action: 'profile_update',
-  timestamp: Date.now()
-});
+// Lazy loading cho database khác
+const dao = await DatabaseManager.getLazyLoading("core");
 ```
 
-3. **Don't log sensitive information**:
+### Quản lý kết nối theo Role
+
 ```typescript
-// ❌ Bad
-logger.debug("User login", { password: user.password });
+// Đăng ký role configuration
+DatabaseManager.registerRole({
+  roleName: "admin",
+  requiredDatabases: ["core", "inventory"],
+  optionalDatabases: ["reports"],
+  priority: 1,
+});
 
-// ✅ Good
-logger.debug("User login", { username: user.username });
-```
+// Set user roles - tự động khởi tạo databases cần thiết
+await DatabaseManager.setCurrentUserRoles(["admin"]);
 
-4. **Use module-specific loggers**:
-```typescript
-// Create separate loggers for different parts of your app
-const authLogger = createModuleLogger(AppModules.AUTH);
-const apiLogger = createModuleLogger(AppModules.API);
-const dbLogger = createModuleLogger(AppModules.UNIVERSAL_SQLITE);
+// Lấy database đã được khởi tạo
+const coreDao = DatabaseManager.get("core");
 ```
 
-## 🗃️ Core Components
+## 4. Định nghĩa Service từ BaseService
 
-### DatabaseManager
-Central database connection and schema management.
+### Service đơn giản (sử dụng DefaultService)
 
 ```typescript
-import { DatabaseManager } from '@dqcai/sqlite';
-
-// Register schemas
-DatabaseManager.registerSchemas({
-  users: userSchema,
-  products: productSchema
-});
-
-// Initialize connections
-await DatabaseManager.initializeCoreConnection();
+import { BaseService } from "@dqcai/sqlite";
 
-// Get connection
-const dao = DatabaseManager.get('users');
+// Sử dụng BaseService trực tiếp cho CRUD cơ bản
+const userService = new BaseService("core", "users");
+await userService.init();
 ```
 
-### ServiceManager
-Centralized service lifecycle management with automatic optimization.
+### Service mở rộng với logic nghiệp vụ
 
 ```typescript
-import { ServiceManager } from '@dqcai/sqlite';
+import { BaseService } from "@dqcai/sqlite";
 
-const serviceManager = ServiceManager.getInstance();
+export class UserService extends BaseService<User> {
+  constructor() {
+    super("core", "users");
+    this.setPrimaryKeyFields(["id"]);
+  }
 
-// Register services
-serviceManager.registerService({
-  schemaName: 'users',
-  tableName: 'users',
-  serviceClass: UserService
-});
+  // Business logic method
+  async findByStoreId(storeId: string): Promise<User[]> {
+    await this._ensureInitialized();
+    return await this.findAll({ store_id: storeId });
+  }
+
+  async findActiveUsers(): Promise<User[]> {
+    await this._ensureInitialized();
+    return await this.findAll({ is_active: true });
+  }
 
-// Get service instance
-const userService = await serviceManager.getService('users', 'users');
+  async updateLastLogin(userId: string): Promise<void> {
+    await this._ensureInitialized();
+    await this.update(userId, {
+      last_login: new Date().toISOString(),
+    });
+  }
 
-// Health monitoring
-const healthReport = await serviceManager.healthCheck();
+  async lockUser(userId: string, duration: number): Promise<void> {
+    await this._ensureInitialized();
+    const lockedUntil = new Date(Date.now() + duration);
+    await this.update(userId, {
+      is_active: false,
+      locked_until: lockedUntil.toISOString(),
+    });
+  }
+}
 ```
 
-### BaseService
-Type-safe CRUD operations with built-in optimization.
+### Service với validation và events
 
 ```typescript
-import { BaseService } from '@dqcai/sqlite';
-
-interface User {
-  id?: number;
-  username: string;
-  email: string;
-}
-
-class UserService extends BaseService<User> {
+export class StoreService extends BaseService<Store> {
   constructor() {
-    super('users', 'users');
+    super("core", "stores");
+    this.setupEventHandlers();
   }
 
-  async createUser(data: Omit<User, 'id'>): Promise<User | null> {
-    return await this.create(data);
+  private setupEventHandlers() {
+    // Lắng nghe events
+    this.on("dataCreated", (event) => {
+      console.log("Store created:", event.data);
+    });
+
+    this.on("dataUpdated", (event) => {
+      console.log("Store updated:", event.id);
+    });
+
+    // Custom error handler
+    this.setErrorHandler("CREATE_ERROR", (error) => {
+      console.error("Failed to create store:", error.message);
+    });
   }
 
-  async findByEmail(email: string): Promise<User | null> {
-    return await this.findFirst({ email });
+  // Override create để thêm validation
+  async create(data: Partial<Store>): Promise<Store | null> {
+    // Validate
+    if (!data.enterprise_id) {
+      throw new Error("Enterprise ID is required");
+    }
+    if (!data.name?.trim()) {
+      throw new Error("Store name is required");
+    }
+
+    // Set defaults
+    data.currency = data.currency || "VND";
+    data.timezone = data.timezone || "Asia/Ho_Chi_Minh";
+    data.status = data.status || "active";
+
+    return await super.create(data);
   }
 
-  async updateUser(id: number, data: Partial<User>): Promise<User | null> {
-    return await this.update(id, data);
+  async findByEnterpriseId(enterpriseId: string): Promise<Store[]> {
+    return await this.findAll({ enterprise_id: enterpriseId });
   }
 
-  async deleteUser(id: number): Promise<boolean> {
-    return await this.delete(id);
+  async getActiveStores(enterpriseId: string): Promise<Store[]> {
+    return await this.findAll(
+      { enterprise_id: enterpriseId, status: "active" },
+      { orderBy: [{ name: "name", direction: "ASC" }] }
+    );
   }
 }
 ```
 
-## 🌐 Platform Support
+## 5. Quản lý Service với ServiceManager
+
+### Đăng ký Services
 
-### Browser
 ```typescript
-import { DatabaseFactory, BrowserAdapter } from '@dqcai/sqlite';
+import { ServiceManager } from "@dqcai/sqlite";
+import { UserService } from "./services/UserService";
+import { StoreService } from "./services/StoreService";
 
-DatabaseFactory.registerAdapter(new BrowserAdapter());
-```
+const serviceManager = ServiceManager.getInstance();
 
-### Node.js
-```typescript
-import { DatabaseFactory, NodeAdapter } from '@dqcai/sqlite';
+// Đăng ký service với custom class
+serviceManager.registerService({
+  schemaName: "core",
+  tableName: "users",
+  primaryKeyFields: ["id"],
+  serviceClass: UserService,
+});
+
+serviceManager.registerService({
+  schemaName: "core",
+  tableName: "stores",
+  serviceClass: StoreService,
+});
 
-DatabaseFactory.registerAdapter(new NodeAdapter());
+// Đăng ký nhiều services cùng lúc
+serviceManager.registerServices([
+  {
+    schemaName: "core",
+    tableName: "enterprises",
+    primaryKeyFields: ["id"],
+  },
+  {
+    schemaName: "core",
+    tableName: "settings",
+    primaryKeyFields: ["id"],
+  },
+]);
 ```
 
-### React Native
+### Lấy và sử dụng Service
+
 ```typescript
-import { DatabaseFactory } from '@dqcai/sqlite';
-import { ReactNativeAdapter } from './adapters/ReactNativeAdapter';
+// Lấy service - tự động khởi tạo nếu chưa tồn tại
+const userService = (await serviceManager.getService(
+  "core",
+  "users"
+)) as UserService;
 
-DatabaseFactory.registerAdapter(new ReactNativeAdapter());
+// Khởi tạo service ngay lập tức
+const storeService = await serviceManager.initializeService("core", "stores");
+
+// Lấy service đã tồn tại (không tự động tạo)
+const existingService = serviceManager.getExistingService("core", "users");
 ```
 
-### Deno
-```typescript
-import { DatabaseFactory, DenoAdapter } from '@dqcai/sqlite';
+### Quản lý lifecycle
 
-DatabaseFactory.registerAdapter(new DenoAdapter());
-```
+```typescript
+// Kiểm tra sức khỏe tất cả services
+const healthReport = await serviceManager.healthCheck();
+console.log("Overall health:", healthReport.overallHealth);
+console.log("Healthy services:", healthReport.healthyServices);
 
-## 🔧 Schema Definition
+// Lấy thông tin services
+const allServices = serviceManager.getAllServiceInfo();
+console.log("Total services:", allServices.length);
 
-Define your database structure with JSON schemas:
+// Destroy service
+await serviceManager.destroyService("core", "users");
 
-```typescript
-const schema = {
-  version: "1.0.0",
-  database_name: "myapp",
-  description: "Application database",
-  schemas: {
-    users: {
-      description: "User accounts",
-      cols: [
-        {
-          name: "id",
-          type: "integer",
-          primary_key: true,
-          auto_increment: true
-        },
-        {
-          name: "username",
-          type: "varchar",
-          length: 50,
-          nullable: false,
-          unique: true
-        },
-        {
-          name: "email",
-          type: "varchar", 
-          length: 100,
-          nullable: false,
-          unique: true
-        },
-        {
-          name: "password",
-          type: "varchar",
-          length: 255,
-          nullable: false
-        },
-        {
-          name: "created_at",
-          type: "datetime",
-          nullable: false,
-          default: "CURRENT_TIMESTAMP"
-        }
-      ],
-      indexes: [
-        {
-          name: "idx_username",
-          columns: ["username"],
-          unique: true
-        }
-      ]
-    },
-    posts: {
-      description: "User posts",
-      cols: [
-        { name: "id", type: "integer", primary_key: true, auto_increment: true },
-        { name: "user_id", type: "integer", nullable: false },
-        { name: "title", type: "varchar", length: 200 },
-        { name: "content", type: "text" },
-        { name: "created_at", type: "datetime", default: "CURRENT_TIMESTAMP" }
-      ],
-      foreign_keys: [
-        {
-          name: "fk_post_user",
-          column: "user_id",
-          references: { table: "users", column: "id" },
-          on_delete: "CASCADE"
-        }
-      ]
-    }
-  }
-};
+// Destroy tất cả services trong một schema
+await serviceManager.destroyServicesBySchema("core");
 ```
 
-## ⚡ Advanced Features
+## 6. Thực thi CRUD và Logic nghiệp vụ
+
+### CRUD cơ bản
 
-### Transaction Management
 ```typescript
-// Single table transaction
-await userService.executeTransaction(async () => {
-  const user = await userService.create({ username: 'john', email: 'john@test.com' });
-  await userService.update(user.id, { username: 'johnny' });
+// Create
+const newUser = await userService.create({
+  id: crypto.randomUUID(),
+  username: "john_doe",
+  email: "john@example.com",
+  full_name: "John Doe",
+  store_id: storeId,
+  role: "staff",
 });
 
-// Cross-schema transaction
-await DatabaseManager.executeCrossSchemaTransaction(['users', 'posts'], async (daos) => {
-  const user = await daos.users.execute('INSERT INTO users ...');
-  await daos.posts.execute('INSERT INTO posts ...');
+// Read
+const user = await userService.findById(userId);
+const allUsers = await userService.findAll();
+const activeUsers = await userService.findAll({ is_active: true });
+
+// Update
+await userService.update(userId, {
+  email: "newemail@example.com",
+  updated_at: new Date().toISOString(),
 });
+
+// Delete
+await userService.delete(userId);
+
+// Count
+const userCount = await userService.count({ is_active: true });
+
+// Exists
+const exists = await userService.exists(userId);
 ```
 
-### Query Builder
+### Query nâng cao
+
 ```typescript
-const users = await userService.queryBuilder()
-  .select(['id', 'username', 'email'])
-  .where('created_at', '>', '2024-01-01')
-  .orderBy('username', 'ASC')
-  .limit(10)
-  .execute();
+// Tìm kiếm với options
+const users = await userService.findAll(
+  { role: "staff", is_active: true },
+  {
+    orderBy: [{ name: "created_at", direction: "DESC" }],
+    limit: 10,
+    offset: 0,
+    columns: ["id", "username", "email", "full_name"],
+  }
+);
+
+// Pagination
+const page = 1;
+const perPage = 20;
+const offset = (page - 1) * perPage;
+
+const paginatedUsers = await userService.findAll(
+  {},
+  { limit: perPage, offset }
+);
 ```
 
-### Batch Operations
+### Bulk operations
+
 ```typescript
+// Bulk insert
 const users = [
-  { username: 'user1', email: 'user1@test.com' },
-  { username: 'user2', email: 'user2@test.com' }
+  {
+    id: uuid(),
+    username: "user1",
+    email: "user1@example.com",
+    store_id: storeId,
+  },
+  {
+    id: uuid(),
+    username: "user2",
+    email: "user2@example.com",
+    store_id: storeId,
+  },
 ];
 
-await userService.batchCreate(users);
+const importResult = await userService.bulkInsert(users);
+console.log(`Imported ${importResult.successRows} users`);
+
+// Bulk create with transaction
+const createdUsers = await userService.bulkCreate(users);
 ```
 
-### Real-time Monitoring
+### Transaction
+
 ```typescript
-import { ServiceHealthMonitor } from '@dqcai/sqlite';
+// Single service transaction
+await userService.executeTransaction(async () => {
+  await userService.create(user1);
+  await userService.create(user2);
+  await userService.update(userId, { status: "active" });
+});
 
-const monitor = new ServiceHealthMonitor();
-monitor.startMonitoring(30000); // Check every 30 seconds
+// Cross-service transaction (same schema)
+await serviceManager.executeSchemaTransaction("core", async (services) => {
+  const [userSvc, storeSvc] = services;
 
-// Get health status
-const healthReport = await serviceManager.healthCheck();
-console.log(`System health: ${healthReport.overallHealth ? 'Healthy' : 'Unhealthy'}`);
+  const store = await storeSvc.create(storeData);
+  await userSvc.create({
+    ...userData,
+    store_id: store.id,
+  });
+});
 ```
 
-## 🎯 Use Cases
+### Import/Export
 
-- **Mobile Apps**: React Native applications with offline-first data storage
-- **Desktop Apps**: Electron applications with embedded database
-- **Web Applications**: Browser-based apps with client-side data storage
-- **Server Applications**: Node.js backends with SQLite database
-- **Edge Computing**: Lightweight applications for edge deployment
-- **Microservices**: Small, focused services with embedded databases
+```typescript
+// Import from CSV
+const csvData = `username,email,role
+john,john@example.com,staff
+jane,jane@example.com,manager`;
+
+const result = await userService.importFromCSV(csvData, {
+  hasHeader: true,
+  delimiter: ",",
+  skipErrors: false,
+});
 
-## 🔍 SEO Keywords
+// Import with column mapping
+const columnMappings = [
+  { sourceColumn: "user_name", targetColumn: "username" },
+  { sourceColumn: "mail", targetColumn: "email" },
+  {
+    sourceColumn: "created",
+    targetColumn: "created_at",
+    transform: (value) => new Date(value).toISOString(),
+  },
+];
 
-**SQLite JavaScript**, **TypeScript SQLite**, **React Native SQLite**, **Node.js SQLite**, **Universal SQLite**, **Cross-platform database**, **SQLite ORM**, **Database service management**, **TypeScript database library**, **JavaScript database**, **Mobile database**, **Offline database**, **SQLite migrations**, **Database transactions**, **SQLite schema management**, **Logger integration**, **Debug SQLite**, **Database logging**
+await userService.importDataWithMapping(data, columnMappings);
+```
 
-## 📊 Performance Benchmarks
+## 7. Ví dụ hoàn chỉnh với Core Schema
 
-- **Connection pooling** reduces connection overhead by 80%
-- **Batch operations** improve write performance by 10x
-- **Query optimization** reduces query time by 60%
-- **Service caching** eliminates repeated initialization costs
+```typescript
+import {
+  DatabaseFactory,
+  DatabaseManager,
+  ServiceManager,
+  BaseService,
+} from "@dqcai/sqlite";
+import { NodeJSAdapter } from "@dqcai/sqlite";
+import { coreSchema } from "./schemas/core";
 
-## 🛡️ Production Ready
+// ========== BƯỚC 1: Setup Adapters ==========
+DatabaseFactory.registerAdapter(new NodeJSAdapter());
 
-- **Error handling**: Comprehensive error management with retry mechanisms
-- **Health monitoring**: Real-time service health checks and auto-recovery
-- **Performance optimization**: Built-in query optimization and connection pooling
-- **Memory management**: Automatic cleanup of unused services
-- **Graceful shutdown**: Proper resource cleanup on application termination
-- **Comprehensive logging**: Integrated logger for debugging and monitoring
+// ========== BƯỚC 2: Đăng ký Schemas ==========
+DatabaseManager.registerSchema("core", coreSchema);
 
-## 🔄 Migration Support
+// ========== BƯỚC 3: Định nghĩa Services ==========
+class UserService extends BaseService {
+  constructor() {
+    super("core", "users");
+  }
 
-```typescript
-// Define migration
-const migration = {
-  version: '1.0.1',
-  description: 'Add user status column',
-  
-  async up(dao) {
-    await dao.execute('ALTER TABLE users ADD COLUMN status VARCHAR(20) DEFAULT "active"');
-  },
-  
-  async down(dao) {
-    // Rollback logic
+  async findByStoreId(storeId: string) {
+    return await this.findAll({ store_id: storeId });
   }
-};
 
-// Run migration
-await migrationManager.runMigration(migration);
-```
+  async authenticate(username: string, password: string) {
+    const user = await this.findFirst({ username });
+    if (!user) return null;
 
-## 📱 React Native Example
+    // Verify password (simplified)
+    if (user.password_hash === password) {
+      await this.update(user.id, {
+        last_login: new Date().toISOString(),
+        failed_login_attempts: 0,
+      });
+      return user;
+    }
 
-```typescript
-// App.tsx
-import React, { useEffect, useState } from 'react';
-import { DatabaseService } from './services/DatabaseService';
+    // Increment failed attempts
+    await this.update(user.id, {
+      failed_login_attempts: (user.failed_login_attempts || 0) + 1,
+    });
 
-export default function App() {
-  const [users, setUsers] = useState([]);
+    return null;
+  }
+}
 
-  useEffect(() => {
-    initDatabase();
-  }, []);
+class StoreService extends BaseService {
+  constructor() {
+    super("core", "stores");
+  }
 
-  const initDatabase = async () => {
-    await DatabaseService.initialize();
-    const userService = await ServiceManager.getService('users', 'users');
-    const allUsers = await userService.getAllUsers();
-    setUsers(allUsers);
-  };
+  async findByEnterpriseId(enterpriseId: string) {
+    return await this.findAll({ enterprise_id: enterpriseId });
+  }
 
-  // Your UI here
+  async getActiveStores(enterpriseId: string) {
+    return await this.findAll(
+      { enterprise_id: enterpriseId, status: "active" },
+      { orderBy: [{ name: "name", direction: "ASC" }] }
+    );
+  }
 }
-```
 
-## 🖥️ Node.js Example
+// ========== BƯỚC 4: Đăng ký Services ==========
+const serviceManager = ServiceManager.getInstance();
 
-```typescript
-// server.js
-import express from 'express';
-import { DatabaseService } from './services/DatabaseService';
+serviceManager.registerServices([
+  {
+    schemaName: "core",
+    tableName: "enterprises",
+  },
+  {
+    schemaName: "core",
+    tableName: "stores",
+    serviceClass: StoreService,
+  },
+  {
+    schemaName: "core",
+    tableName: "users",
+    serviceClass: UserService,
+  },
+]);
+
+// ========== BƯỚC 5: Khởi tạo và sử dụng ==========
+async function main() {
+  try {
+    // Khởi tạo core database
+    await DatabaseManager.initializeCoreConnection();
+
+    // Lấy services
+    const enterpriseService = await serviceManager.getService(
+      "core",
+      "enterprises"
+    );
+    const storeService = (await serviceManager.getService(
+      "core",
+      "stores"
+    )) as StoreService;
+    const userService = (await serviceManager.getService(
+      "core",
+      "users"
+    )) as UserService;
+
+    // ========== TEST CRUD Operations ==========
+
+    // 1. Create Enterprise
+    const enterprise = await enterpriseService.create({
+      id: crypto.randomUUID(),
+      name: "My Company",
+      business_type: "ltd",
+      email: "contact@mycompany.com",
+      status: "active",
+      subscription_plan: "premium",
+    });
+    console.log("✅ Enterprise created:", enterprise?.name);
+
+    // 2. Create Store
+    const store = await storeService.create({
+      id: crypto.randomUUID(),
+      enterprise_id: enterprise!.id,
+      name: "Main Store",
+      store_type: "retail",
+      address: "123 Main St",
+      status: "active",
+    });
+    console.log("✅ Store created:", store?.name);
+
+    // 3. Create Users
+    const users = [
+      {
+        id: crypto.randomUUID(),
+        store_id: store!.id,
+        username: "admin",
+        password_hash: "hashed_password",
+        full_name: "Admin User",
+        email: "admin@mycompany.com",
+        role: "admin",
+        is_active: true,
+      },
+      {
+        id: crypto.randomUUID(),
+        store_id: store!.id,
+        username: "staff1",
+        password_hash: "hashed_password",
+        full_name: "Staff One",
+        email: "staff1@mycompany.com",
+        role: "staff",
+        is_active: true,
+      },
+    ];
+
+    const importResult = await userService.bulkInsert(users);
+    console.log(`✅ Users imported: ${importResult.successRows} successful`);
+
+    // 4. Query data
+    const allUsers = await userService.findByStoreId(store!.id);
+    console.log(`✅ Users in store: ${allUsers.length}`);
+
+    const activeStores = await storeService.getActiveStores(enterprise!.id);
+    console.log(`✅ Active stores: ${activeStores.length}`);
+
+    // 5. Update
+    await userService.update(users[0].id, {
+      last_login: new Date().toISOString(),
+    });
+    console.log("✅ User login updated");
+
+    // 6. Transaction example
+    await serviceManager.executeSchemaTransaction("core", async (services) => {
+      const [entSvc, storeSvc, userSvc] = services;
+
+      // Create another store and user in transaction
+      const newStore = await storeSvc.create({
+        id: crypto.randomUUID(),
+        enterprise_id: enterprise!.id,
+        name: "Branch Store",
+        status: "active",
+      });
+
+      await userSvc.create({
+        id: crypto.randomUUID(),
+        store_id: newStore.id,
+        username: "branch_manager",
+        password_hash: "hashed_password",
+        full_name: "Branch Manager",
+        email: "manager@branch.com",
+        role: "manager",
+        is_active: true,
+      });
+    });
+    console.log("✅ Transaction completed");
+
+    // 7. Health check
+    const health = await serviceManager.healthCheck();
+    console.log("✅ System health:", health.overallHealth);
+    console.log(
+      `   Healthy services: ${health.healthyServices}/${health.totalServices}`
+    );
+
+    // 8. Statistics
+    const enterpriseCount = await enterpriseService.count();
+    const storeCount = await storeService.count();
+    const userCount = await userService.count();
+
+    console.log("\n📊 Statistics:");
+    console.log(`   Enterprises: ${enterpriseCount}`);
+    console.log(`   Stores: ${storeCount}`);
+    console.log(`   Users: ${userCount}`);
+  } catch (error) {
+    console.error("❌ Error:", error);
+  } finally {
+    // Cleanup
+    await DatabaseManager.closeAll();
+    console.log("\n✅ Database connections closed");
+  }
+}
 
-const app = express();
+// Run test
+main().catch(console.error);
+```
 
-app.get('/users', async (req, res) => {
-  const userService = await ServiceManager.getService('users', 'users');
-  const users = await userService.getAllUsers();
-  res.json(users);
-});
+### Kết quả mong đợi:
 
-// Initialize database before starting server
-await DatabaseService.initialize();
-app.listen(3000);
 ```
+✅ Enterprise created: My Company
+✅ Store created: Main Store
+✅ Users imported: 2 successful
+✅ Users in store: 2
+✅ Active stores: 1
+✅ User login updated
+✅ Transaction completed
+✅ System health: true
+   Healthy services: 3/3
+
+📊 Statistics:
+   Enterprises: 1
+   Stores: 2
+   Users: 3
+
+✅ Database connections closed
+```
+
+## Tổng kết
+
+Thư viện @dqcai/sqlite cung cấp:
+
+- ✅ **Cross-platform**: Hỗ trợ React Native và Node.js
+- ✅ **Type-safe**: TypeScript support đầy đủ
+- ✅ **Schema-driven**: Quản lý database qua JSON schema
+- ✅ **Service-based**: Architecture rõ ràng, dễ mở rộng
+- ✅ **Lazy loading**: Tối ưu performance trên mobile
+- ✅ **Transaction support**: ACID compliance
+- ✅ **Event system**: Lắng nghe và xử lý events
+- ✅ **Import/Export**: CSV, JSON, bulk operations
+- ✅ **Logging**: Tích hợp @dqcai/logger để trace/debug
 
 ## 🤝 Community & Support
 
@@ -622,4 +764,4 @@ Transform your data management with the most powerful universal SQLite library f
 
 ---
 
-**@dqcai/sqlite** - One library, all platforms! 🌟
+**@dqcai/sqlite** - One library, all platforms! 🌟