@ooneex/database 0.0.1 → 0.0.5

package/README.md

@@ -1,30 +1,28 @@
 # @ooneex/database
 
-A comprehensive TypeScript/JavaScript database library designed for Bun runtime. This package provides a unified interface for database operations with support for SQLite, PostgreSQL, MySQL, and Redis, along with TypeORM adapters for advanced ORM functionality.
+A database connection and management library for TypeScript applications with TypeORM integration. This package provides unified interfaces for Redis, PostgreSQL, and SQLite databases with automatic connection handling, repository management, and seamless integration with the Ooneex framework.
 
 ![Bun](https://img.shields.io/badge/Bun-Compatible-orange?style=flat-square&logo=bun)
+![Deno](https://img.shields.io/badge/Deno-Compatible-blue?style=flat-square&logo=deno)
+![Node.js](https://img.shields.io/badge/Node.js-Compatible-green?style=flat-square&logo=node.js)
 ![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue?style=flat-square&logo=typescript)
 ![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)
 
 ## Features
 
-✅ **Multi-Database Support** - SQLite, PostgreSQL, MySQL, and Redis support
+✅ **Multiple Databases** - Support for PostgreSQL, SQLite, and Redis
 
-✅ **Bun Native** - Built specifically for Bun runtime with Bun.SQL
+✅ **TypeORM Integration** - Full TypeORM support for relational databases
 
-✅ **TypeORM Integration** - Dedicated adapters for PostgreSQL and SQLite
+✅ **Repository Pattern** - Easy access to TypeORM repositories
 
-✅ **Type-Safe** - Full TypeScript support with proper type definitions
-
-✅ **Connection Management** - Robust connection opening, closing, and lifecycle management
-
-✅ **Database Operations** - Create, drop, and manage database instances
+✅ **Connection Management** - Automatic connection handling and reconnection
 
-✅ **Error Handling** - Comprehensive error handling with custom exceptions
+✅ **Container Integration** - Works seamlessly with dependency injection
 
-✅ **Environment Support** - Automatic environment variable detection
+✅ **Type-Safe** - Full TypeScript support with proper type definitions
 
-✅ **Zero Configuration** - Works out of the box with sensible defaults
+✅ **Decorators** - Register database services with decorators
 
 ## Installation
 
@@ -33,289 +31,227 @@ A comprehensive TypeScript/JavaScript database library designed for Bun runtime.
 bun add @ooneex/database
 ```
 
-## Usage
-
-### TypeORM PostgreSQL Adapter
+### pnpm
+```bash
+pnpm add @ooneex/database
+```
 
-```typescript
-import { TypeormPgDatabaseAdapter } from '@ooneex/database';
-import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+### Yarn
+```bash
+yarn add @ooneex/database
+```
 
-@Entity()
-class User {
-  @PrimaryGeneratedColumn()
-  id: number;
+### npm
+```bash
+npm install @ooneex/database
+```
 
-  @Column()
-  name: string;
+## Usage
 
-  @Column()
-  email: string;
-}
+### PostgreSQL with TypeORM
 
-const adapter = new TypeormPgDatabaseAdapter({
-  url: 'postgresql://user:pass@localhost:5432/mydb',
-  synchronize: true,
-  entities: [User]
+```typescript
+import { TypeormPgDatabase } from '@ooneex/database';
+import { UserEntity } from './entities/UserEntity';
+
+const database = new TypeormPgDatabase({
+  host: 'localhost',
+  port: 5432,
+  username: 'postgres',
+  password: 'password',
+  database: 'myapp'
 });
 
-// Open and get repository
-const userRepository = await adapter.open(User);
+// Get repository for an entity
+const userRepository = await database.open(UserEntity);
 
-// Create user
-const user = userRepository.create({
-  name: 'John Doe',
-  email: 'john@example.com'
-});
-await userRepository.save(user);
-
-// Find users
+// Use TypeORM repository methods
 const users = await userRepository.find();
+const user = await userRepository.findOneBy({ id: '123' });
 
-// Close connection
-await adapter.close();
+// Close connection when done
+await database.close();
 ```
 
-### TypeORM SQLite Adapter
+### SQLite with TypeORM
 
 ```typescript
-import { TypeormSqliteDatabaseAdapter } from '@ooneex/database';
-import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+import { TypeormSqliteDatabase } from '@ooneex/database';
+import { ProductEntity } from './entities/ProductEntity';
 
-@Entity()
-class Product {
-  @PrimaryGeneratedColumn()
-  id: number;
+const database = new TypeormSqliteDatabase({
+  database: './data/app.db'
+});
 
-  @Column()
-  name: string;
+// Get repository
+const productRepository = await database.open(ProductEntity);
 
-  @Column('decimal')
-  price: number;
-}
-
-const adapter = new TypeormSqliteDatabaseAdapter({
-  database: './products.db',
-  synchronize: true,
-  entities: [Product]
+// Query products
+const products = await productRepository.find({
+  where: { category: 'electronics' },
+  take: 10
 });
 
-// Open and get repository
-const productRepository = await adapter.open(Product);
+await database.close();
+```
+
+### Redis Database
+
+```typescript
+import { RedisDatabase } from '@ooneex/database';
 
-// Create product
-const product = productRepository.create({
-  name: 'Laptop',
-  price: 999.99
+const redis = new RedisDatabase({
+  url: 'redis://localhost:6379'
 });
-await productRepository.save(product);
+
+// Open connection and get client
+const client = await redis.open();
+
+// Use Redis commands
+await client.set('key', 'value');
+const value = await client.get('key');
 
 // Close connection
-await adapter.close();
+await redis.close();
 ```
 
-### Error Handling
+### Using Environment Variables
 
 ```typescript
-import { Database, DatabaseException } from '@ooneex/database';
-
-try {
-  const db = new Database('invalid://connection');
-  await db.open();
-} catch (error) {
-  if (error instanceof DatabaseException) {
-    console.error('Database error:', error.message);
-    console.error('Error data:', error.data);
-  }
-}
-```
+import { TypeormPgDatabase } from '@ooneex/database';
 
-### Environment Configuration
+// Automatically uses environment variables
+const database = new TypeormPgDatabase();
 
-```bash
-# Set in your .env file
-DATABASE_URL=sqlite://./myapp.db
-# or
-DATABASE_URL=postgresql://user:password@localhost:5432/mydb
-# or
-DATABASE_URL=mysql://user:password@localhost:3306/mydb
-
-# For SQLite adapter
-SQLITE_DATABASE_PATH=./myapp.db
-
-# For Redis adapter
-REDIS_URL=redis://localhost:6379
-# or
-VALKEY_URL=redis://localhost:6379
+// Environment variables:
+// DATABASE_HOST
+// DATABASE_PORT
+// DATABASE_USERNAME
+// DATABASE_PASSWORD
+// DATABASE_NAME
 ```
 
 ## API Reference
 
-### `Database` Class
+### Classes
 
-The main database class providing connection management and basic operations.
+#### `TypeormPgDatabase`
 
-#### Constructor
+PostgreSQL database adapter using TypeORM.
 
+**Constructor:**
 ```typescript
-constructor(connectionString?: string | URL, options?: Bun.SQL.Options)
+new TypeormPgDatabase(options?: PostgresConnectionOptions)
 ```
 
 **Parameters:**
-- `connectionString` - Database connection string or URL object
-- `options` - Bun.SQL connection options
-
-**Example:**
-```typescript
-const db = new Database('sqlite://./app.db', { timeout: 5000 });
-```
+- `options.host` - Database host (default: `DATABASE_HOST` env var)
+- `options.port` - Database port (default: `DATABASE_PORT` env var)
+- `options.username` - Database username (default: `DATABASE_USERNAME` env var)
+- `options.password` - Database password (default: `DATABASE_PASSWORD` env var)
+- `options.database` - Database name (default: `DATABASE_NAME` env var)
+- `options.synchronize` - Auto-sync schema (default: false)
+- `options.logging` - Enable query logging (default: false)
 
-#### Methods
+**Methods:**
 
-##### `getClient(): Bun.SQL`
-Returns the underlying Bun.SQL client instance.
+##### `open<Entity>(entity: EntityTarget<Entity>, database?: string): Promise<Repository<Entity>>`
 
-**Returns:** The Bun.SQL client
+Opens connection and returns a TypeORM repository for the specified entity.
 
-**Example:**
-```typescript
-const client = db.getClient();
-const result = await client`SELECT * FROM users`;
-```
+**Parameters:**
+- `entity` - TypeORM entity class
+- `database` - Optional database name override
 
-##### `open(): Promise<void>`
-Opens the database connection.
+**Returns:** TypeORM Repository instance
 
 **Example:**
 ```typescript
-await db.open();
+const userRepo = await database.open(UserEntity);
+const users = await userRepo.find();
 ```
 
 ##### `close(): Promise<void>`
-Closes the database connection.
 
-**Example:**
-```typescript
-await db.close();
-```
+Closes the database connection.
 
 ##### `drop(): Promise<void>`
-Drops the database. **Caution: This is destructive and cannot be undone.**
 
-**Example:**
-```typescript
-await db.drop(); // Permanently deletes the database
-```
+Drops the database (use with caution!).
 
-### `TypeormPgDatabaseAdapter` Class
+---
 
-TypeORM adapter for PostgreSQL databases.
+#### `TypeormSqliteDatabase`
 
-#### Constructor
+SQLite database adapter using TypeORM.
 
+**Constructor:**
 ```typescript
-constructor(options: Omit<PostgresConnectionOptions, "type">)
+new TypeormSqliteDatabase(options?: SqliteConnectionOptions)
 ```
 
 **Parameters:**
-- `options` - PostgreSQL connection options (without type field)
+- `options.database` - Path to SQLite database file
 
-#### Methods
+**Methods:**
 
-##### `getSource(): DataSource`
-Returns the TypeORM DataSource instance.
+Same interface as `TypeormPgDatabase`.
 
-##### `open<Entity>(entity: EntityTarget<Entity>): Promise<Repository<Entity>>`
-Opens connection and returns repository for the specified entity.
+---
 
-##### `close(): Promise<void>`
-Closes the database connection.
+#### `AbstractTypeormSqliteDatabase`
 
-##### `drop(): Promise<void>`
-Drops the database schema.
+Abstract base class for creating custom SQLite database adapters.
 
-##### `getEntityManager(): EntityManager`
-Returns the TypeORM EntityManager.
+**Example:**
+```typescript
+class MyDatabase extends AbstractTypeormSqliteDatabase {
+  protected getEntities() {
+    return [UserEntity, ProductEntity];
+  }
+}
+```
 
-### `TypeormSqliteDatabaseAdapter` Class
+---
 
-TypeORM adapter for SQLite databases.
+#### `RedisDatabase`
 
-#### Constructor
+Redis database adapter using Bun's built-in Redis client.
 
+**Constructor:**
 ```typescript
-constructor(options: Omit<SqliteConnectionOptions, "type">)
+new RedisDatabase(options?: RedisConnectionOptionsType)
 ```
 
 **Parameters:**
-- `options` - SQLite connection options (without type field)
+- `options.url` - Redis connection URL (default: `REDIS_URL` env var)
+- `options.connectionTimeout` - Connection timeout in ms (default: 10000)
+- `options.idleTimeout` - Idle timeout in ms (default: 30000)
+- `options.autoReconnect` - Enable auto reconnection (default: true)
+- `options.maxRetries` - Maximum retry attempts (default: 3)
+- `options.tls` - TLS configuration (optional)
 
-#### Methods
+**Methods:**
 
-Same methods as `TypeormPgDatabaseAdapter` but optimized for SQLite.
+##### `open(): Promise<RedisClient>`
 
-### `RedisDatabaseAdapter` Class
+Opens connection and returns the Redis client.
 
-Redis adapter using Bun's native Redis client.
-
-#### Constructor
+**Returns:** Bun RedisClient instance
 
+**Example:**
 ```typescript
-constructor(options: RedisConnectionOptions = {})
+const client = await redis.open();
+await client.set('session:123', JSON.stringify(sessionData));
 ```
 
-**Parameters:**
-- `options` - Redis connection configuration
-
-**Options:**
-- `url` - Redis connection URL (defaults to environment variables or localhost)
-- `connectionTimeout` - Connection timeout in milliseconds (default: 10000)
-- `idleTimeout` - Idle timeout in milliseconds (default: 0)
-- `autoReconnect` - Whether to automatically reconnect (default: true)
-- `maxRetries` - Maximum reconnection attempts (default: 10)
-- `enableOfflineQueue` - Queue commands when disconnected (default: true)
-- `enableAutoPipelining` - Automatically pipeline commands (default: true)
-- `tls` - TLS configuration (default: false)
-
-#### Methods
-
-##### `getClient(): RedisClient`
-Returns the underlying Bun Redis client instance.
-
-##### `open(): Promise<void>`
-Opens the Redis connection.
-
 ##### `close(): Promise<void>`
+
 Closes the Redis connection.
 
 ##### `drop(): Promise<void>`
-Flushes the current Redis database (FLUSHDB).
-
-##### `ping(): Promise<string>`
-Pings the Redis server.
-
-##### `info(section?: string): Promise<string>`
-Gets Redis server information.
 
-##### `isConnected(): boolean`
-Returns connection status.
-
-##### `getBufferedAmount(): number`
-Returns buffered data amount in bytes.
-
-### `DatabaseException` Class
-
-Custom exception class for database-related errors.
-
-#### Constructor
-
-```typescript
-constructor(message: string, data?: T)
-```
-
-**Parameters:**
-- `message` - Error message
-- `data` - Additional error data
+Flushes all data from Redis (use with caution!).
 
 ### Interfaces
 
@@ -323,265 +259,240 @@ constructor(message: string, data?: T)
 
 ```typescript
 interface IDatabase {
-  open(): Promise<void>;
-  close(): Promise<void>;
-  drop(): Promise<void>;
+  open: () => Promise<void>;
+  close: () => Promise<void>;
+  drop: () => Promise<void>;
 }
 ```
 
-#### `ITypeormDatabaseAdapter`
+#### `ITypeormDatabase`
 
 ```typescript
-interface ITypeormDatabaseAdapter {
-  open(entity: any): Promise<any>;
-  close(): Promise<void>;
-  drop(): Promise<void>;
+interface ITypeormDatabase {
+  open: <Entity extends ObjectLiteral>(
+    entity: EntityTarget<Entity>,
+    database?: string
+  ) => Promise<Repository<Entity>>;
+  close: () => Promise<void>;
+  drop: () => Promise<void>;
 }
 ```
 
-## Supported Database URLs
+#### `IRedisDatabase`
 
-### SQLite
 ```typescript
-// File-based database
-'sqlite://./database.db'
-'sqlite:database.db'
-'./database.db'
-
-// In-memory database
-'sqlite://:memory:'
-':memory:'
+interface IRedisDatabase {
+  open: () => Promise<RedisClient>;
+  close: () => Promise<void>;
+  drop: () => Promise<void>;
+}
 ```
 
-### PostgreSQL
-```typescript
-'postgresql://user:password@localhost:5432/database'
-'postgres://user:password@localhost:5432/database'
-```
+### Types
 
-### MySQL
-```typescript
-'mysql://user:password@localhost:3306/database'
-'mysql2://user:password@localhost:3306/database'
-```
+#### `DatabaseClassType`
 
-### Redis
 ```typescript
-// Standard Redis URL
-'redis://localhost:6379'
-
-// With authentication
-'redis://username:password@localhost:6379'
-
-// With database number
-'redis://localhost:6379/0'
+type DatabaseClassType = new (...args: any[]) => IDatabase | IRedisDatabase | ITypeormDatabase;
+```
 
-// TLS connections
-'rediss://localhost:6379'
-'redis+tls://localhost:6379'
+#### `RedisConnectionOptionsType`
 
-// Unix socket connections
-'redis+unix:///path/to/socket'
-'redis+tls+unix:///path/to/socket'
+```typescript
+type RedisConnectionOptionsType = {
+  url?: string;
+  connectionTimeout?: number;
+  idleTimeout?: number;
+  autoReconnect?: boolean;
+  maxRetries?: number;
+  enableOfflineQueue?: boolean;
+  enableAutoPipelining?: boolean;
+  tls?: boolean | {
+    rejectUnauthorized?: boolean;
+    ca?: string;
+    cert?: string;
+    key?: string;
+  };
+};
 ```
 
-## Best Practices
-
-### Connection Management
-- Always call `close()` when done with database operations
-- Use try-catch blocks for proper error handling
-- Consider connection pooling for high-traffic applications
+## Advanced Usage
 
-### Redis Adapter
+### Integration with Ooneex App
 
 ```typescript
-import { RedisDatabaseAdapter } from '@ooneex/database';
-
-const adapter = new RedisDatabaseAdapter({
-  url: 'redis://localhost:6379',
-  connectionTimeout: 10000,
-  autoReconnect: true,
-  maxRetries: 10
+import { App } from '@ooneex/app';
+import { TypeormPgDatabase } from '@ooneex/database';
+
+const database = new TypeormPgDatabase({
+  host: 'localhost',
+  port: 5432,
+  username: 'postgres',
+  password: 'password',
+  database: 'myapp'
 });
 
-// Open connection
-await adapter.open();
-
-// Get Redis client for operations
-const client = adapter.getClient();
-
-// Basic operations
-await client.set('user:1', 'Alice');
-const user = await client.get('user:1');
-
-// Hash operations
-await client.hmset('user:2', ['name', 'Bob', 'email', 'bob@example.com']);
-const userFields = await client.hmget('user:2', ['name', 'email']);
-
-// Set operations
-await client.sadd('tags', 'redis', 'database', 'cache');
-const tags = await client.smembers('tags');
-
-// Utility methods
-const pingResult = await adapter.ping();
-const serverInfo = await adapter.info('server');
+const app = new App({
+  database,
+  // ... other config
+});
 
-// Close connection
-await adapter.close();
+await app.run();
 ```
 
-### Error Handling
-- Catch `DatabaseException` specifically for database errors
-- Log error details for debugging
-- Implement retry logic for transient failures
-
-### Security
-- Never hardcode database credentials
-- Use environment variables for sensitive information
-- Validate input data before database operations
-
-### Performance
-- Use prepared statements when possible
-- Implement proper indexing strategies
-- Monitor query performance in production
-
-## TypeORM Integration
-
-This package provides specialized adapters for TypeORM, allowing you to leverage the full power of TypeORM while maintaining the simplicity of the Ooneex database interface.
-
-### PostgreSQL with TypeORM
+### Using in Controllers
 
 ```typescript
-import { TypeormPgDatabaseAdapter } from '@ooneex/database';
-
-const adapter = new TypeormPgDatabaseAdapter({
-  url: process.env.DATABASE_URL,
-  synchronize: false, // Set to true only in development
-  entities: [User, Product, Order],
-  migrations: ['./migrations/**/*.ts'],
-  extra: {
-    max: 20, // Maximum number of connections
-    idleTimeoutMillis: 30000
+import { Route } from '@ooneex/routing';
+import type { IController, ContextType } from '@ooneex/controller';
+import { UserEntity } from '../entities/UserEntity';
+
+@Route.http({
+  name: 'api.users.list',
+  path: '/api/users',
+  method: 'GET',
+  description: 'List all users'
+})
+class UserListController implements IController {
+  public async index(context: ContextType): Promise<IResponse> {
+    const { database } = context;
+    
+    const userRepository = await database?.open(UserEntity);
+    const users = await userRepository?.find({
+      take: 100,
+      order: { createdAt: 'DESC' }
+    });
+    
+    return context.response.json({ users });
   }
-});
+}
 ```
 
-### SQLite with TypeORM
+### Container Integration with Decorators
 
 ```typescript
-import { TypeormSqliteDatabaseAdapter } from '@ooneex/database';
-
-const adapter = new TypeormSqliteDatabaseAdapter({
-  database: './myapp.db',
-  synchronize: true,
-  entities: [User, Product],
-  enableWAL: true, // Write-Ahead Logging for better performance
-  busyTimeout: 30000
-});
-```
-
-## Redis Integration
+import { container, EContainerScope } from '@ooneex/container';
+import { TypeormPgDatabase, decorator } from '@ooneex/database';
+
+// Register with decorator
+@decorator.database()
+class AppDatabase extends TypeormPgDatabase {
+  constructor() {
+    super({
+      host: 'localhost',
+      port: 5432,
+      database: 'myapp'
+    });
+  }
+}
 
-This package provides a native Redis adapter built specifically for Bun's Redis client, offering high-performance Redis operations with full TypeScript support.
+// Resolve from container
+const database = container.get(AppDatabase);
+```
 
-### Basic Redis Usage
+### Error Handling
 
 ```typescript
-import { RedisDatabaseAdapter } from '@ooneex/database';
+import { TypeormPgDatabase, DatabaseException } from '@ooneex/database';
 
-const adapter = new RedisDatabaseAdapter({
-  url: process.env.REDIS_URL,
-  connectionTimeout: 5000,
-  autoReconnect: true
-});
-
-await adapter.open();
-const client = adapter.getClient();
+try {
+  const database = new TypeormPgDatabase();
+  const userRepo = await database.open(UserEntity);
+  const users = await userRepo.find();
+} catch (error) {
+  if (error instanceof DatabaseException) {
+    console.error('Database Error:', error.message);
+    console.error('Status:', error.status);
+  }
+}
+```
 
-// String operations
-await client.set('key', 'value');
-const value = await client.get('key');
+### Transaction Support
 
-// Numeric operations
-await client.incr('counter');
-await client.decr('counter');
+```typescript
+import { TypeormPgDatabase } from '@ooneex/database';
+import { UserEntity, OrderEntity } from './entities';
 
-// Hash operations
-await client.hmset('user:1', ['name', 'Alice', 'email', 'alice@example.com']);
-const userData = await client.hmget('user:1', ['name', 'email']);
+const database = new TypeormPgDatabase();
+const userRepo = await database.open(UserEntity);
 
-// Set operations
-await client.sadd('tags', 'redis', 'cache');
-const allTags = await client.smembers('tags');
+// Access the entity manager for transactions
+const entityManager = userRepo.manager;
 
-await adapter.close();
+await entityManager.transaction(async (transactionalManager) => {
+  const user = await transactionalManager.findOneBy(UserEntity, { id: '123' });
+  
+  const order = transactionalManager.create(OrderEntity, {
+    userId: user.id,
+    total: 99.99
+  });
+  
+  await transactionalManager.save(order);
+  
+  user.ordersCount += 1;
+  await transactionalManager.save(user);
+});
 ```
 
-### Redis Pub/Sub
+### Multiple Database Connections
 
 ```typescript
-const publisher = new RedisDatabaseAdapter();
-const subscriber = new RedisDatabaseAdapter();
+import { TypeormPgDatabase, TypeormSqliteDatabase } from '@ooneex/database';
 
-await publisher.open();
-await subscriber.open();
+// Main PostgreSQL database
+const mainDb = new TypeormPgDatabase({
+  host: 'localhost',
+  database: 'main_app'
+});
 
-// Set up subscription
-const subClient = subscriber.getClient();
-await subClient.subscribe('notifications', (message, channel) => {
-  console.log(`Received: ${message} on ${channel}`);
+// Analytics SQLite database
+const analyticsDb = new TypeormSqliteDatabase({
+  database: './analytics.db'
 });
 
-// Publish message
-const pubClient = publisher.getClient();
-await pubClient.publish('notifications', 'Hello subscribers!');
+// Use both databases
+const userRepo = await mainDb.open(UserEntity);
+const analyticsRepo = await analyticsDb.open(AnalyticsEntity);
 ```
 
 ### Redis Caching Pattern
 
 ```typescript
-async function getUserWithCache(userId: number) {
-  const cacheKey = `user:${userId}`;
-  
-  // Try cache first
-  const cached = await client.get(cacheKey);
-  if (cached) {
-    return JSON.parse(cached);
+import { RedisDatabase } from '@ooneex/database';
+
+class CacheService {
+  private readonly redis: RedisDatabase;
+  private client: Bun.RedisClient | null = null;
+
+  constructor() {
+    this.redis = new RedisDatabase();
   }
-  
-  // Fetch from database
-  const user = await database.getUser(userId);
-  
-  // Cache with expiration
-  await client.set(cacheKey, JSON.stringify(user));
-  await client.expire(cacheKey, 3600); // 1 hour
-  
-  return user;
-}
-```
 
-### Redis Rate Limiting
+  public async init(): Promise<void> {
+    this.client = await this.redis.open();
+  }
 
-```typescript
-async function rateLimit(ip: string, limit: number = 100, windowSecs: number = 3600) {
-  const key = `ratelimit:${ip}`;
-  
-  const count = await client.incr(key);
-  
-  if (count === 1) {
-    await client.expire(key, windowSecs);
+  public async get<T>(key: string): Promise<T | null> {
+    const value = await this.client?.get(key);
+    return value ? JSON.parse(value) : null;
+  }
+
+  public async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+    await this.client?.set(key, JSON.stringify(value));
+    if (ttl) {
+      await this.client?.expire(key, ttl);
+    }
+  }
+
+  public async delete(key: string): Promise<void> {
+    await this.client?.del(key);
   }
-  
-  return {
-    allowed: count <= limit,
-    remaining: Math.max(0, limit - count)
-  };
 }
 ```
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
 
 ## Contributing
 
@@ -600,7 +511,6 @@ Contributions are welcome! Please feel free to submit a Pull Request. For major
 - Follow the existing code style
 - Update documentation for API changes
 - Ensure all tests pass before submitting PR
-- Test with different database types (SQLite, PostgreSQL, MySQL)
 
 ---
 

package/dist/index.d.ts

@@ -1,11 +1,7 @@
-import { Exception } from "@ooneex/exception";
-declare class DatabaseException extends Exception {
-	constructor(message: string, data?: Record<string, unknown>);
-}
-import { RedisClient as RedisClient2 } from "bun";
+import { DataSource, EntityManager, EntityTarget as EntityTarget2, ObjectLiteral as ObjectLiteral2, Repository as Repository2 } from "typeorm";
 import { RedisClient } from "bun";
 import { EntityTarget, ObjectLiteral, Repository } from "typeorm";
-type DatabaseClassType = new (...args: any[]) => IDatabase | IRedisDatabaseAdapter | ITypeormDatabaseAdapter;
+type DatabaseClassType = new (...args: any[]) => IDatabase | IRedisDatabase | ITypeormDatabase;
 type RedisConnectionOptionsType = {
 	url?: string;
 	connectionTimeout?: number;
@@ -26,17 +22,34 @@ interface IDatabase {
 	close: () => Promise<void>;
 	drop: () => Promise<void>;
 }
-interface IRedisDatabaseAdapter {
+interface IRedisDatabase {
 	open: () => Promise<RedisClient>;
 	close: () => Promise<void>;
 	drop: () => Promise<void>;
 }
-interface ITypeormDatabaseAdapter {
-	open: <Entity extends ObjectLiteral>(entity: EntityTarget<Entity>) => Promise<Repository<Entity>>;
+interface ITypeormDatabase {
+	open: <Entity extends ObjectLiteral>(entity: EntityTarget<Entity>, database?: string) => Promise<Repository<Entity>>;
 	close: () => Promise<void>;
 	drop: () => Promise<void>;
 }
-declare class RedisDatabaseAdapter implements IRedisDatabaseAdapter {
+declare abstract class AbstractTypeormSqliteDatabase implements ITypeormDatabase {
+	protected source: DataSource;
+	abstract getSource(database?: string): DataSource;
+	open<Entity extends ObjectLiteral2>(entity: EntityTarget2<Entity>, database?: string): Promise<Repository2<Entity>>;
+	close(database?: string): Promise<void>;
+	drop(database?: string): Promise<void>;
+	getEntityManager(database?: string): EntityManager;
+}
+import { Exception } from "@ooneex/exception";
+declare class DatabaseException extends Exception {
+	constructor(message: string, data?: Record<string, unknown>);
+}
+import { EContainerScope } from "@ooneex/container";
+declare const decorator: {
+	database: (scope?: EContainerScope) => (target: DatabaseClassType) => void;
+};
+import { RedisClient as RedisClient2 } from "bun";
+declare class RedisDatabase implements IRedisDatabase {
 	private readonly options;
 	private client;
 	private connectionUrl;
@@ -46,26 +59,22 @@ declare class RedisDatabaseAdapter implements IRedisDatabaseAdapter {
 	close(): Promise<void>;
 	drop(): Promise<void>;
 }
-import { DataSource, EntityManager, EntityTarget as EntityTarget2, ObjectLiteral as ObjectLiteral2, Repository as Repository2 } from "typeorm";
-import { PostgresConnectionOptions } from "typeorm/driver/postgres/PostgresConnectionOptions";
-declare class TypeormPgDatabaseAdapter implements ITypeormDatabaseAdapter {
-	private source;
-	constructor(options: Omit<PostgresConnectionOptions, "type">);
-	getSource(): DataSource;
-	open<Entity extends ObjectLiteral2>(entity: EntityTarget2<Entity>): Promise<Repository2<Entity>>;
-	close(): Promise<void>;
-	drop(): Promise<void>;
-	getEntityManager(): EntityManager;
-}
 import { DataSource as DataSource2, EntityManager as EntityManager2, EntityTarget as EntityTarget3, ObjectLiteral as ObjectLiteral3, Repository as Repository3 } from "typeorm";
-import { SqliteConnectionOptions } from "typeorm/driver/sqlite/SqliteConnectionOptions";
-declare class TypeormSqliteDatabaseAdapter implements ITypeormDatabaseAdapter {
+import { PostgresConnectionOptions } from "typeorm/driver/postgres/PostgresConnectionOptions";
+declare class TypeormPgDatabase implements ITypeormDatabase {
 	private source;
-	constructor(options: Omit<SqliteConnectionOptions, "type">);
+	constructor(options?: Omit<PostgresConnectionOptions, "type">);
 	getSource(): DataSource2;
 	open<Entity extends ObjectLiteral3>(entity: EntityTarget3<Entity>): Promise<Repository3<Entity>>;
 	close(): Promise<void>;
 	drop(): Promise<void>;
 	getEntityManager(): EntityManager2;
 }
-export { TypeormSqliteDatabaseAdapter, TypeormPgDatabaseAdapter, RedisDatabaseAdapter, RedisConnectionOptionsType, ITypeormDatabaseAdapter, IRedisDatabaseAdapter, IDatabase, DatabaseException, DatabaseClassType };
+import { DataSource as DataSource3 } from "typeorm";
+import { SqliteConnectionOptions } from "typeorm/driver/sqlite/SqliteConnectionOptions";
+declare class TypeormSqliteDatabase extends AbstractTypeormSqliteDatabase {
+	private readonly options;
+	constructor(options?: Omit<SqliteConnectionOptions, "type"> | undefined);
+	getSource(database?: string): DataSource3;
+}
+export { decorator, TypeormSqliteDatabase, TypeormPgDatabase, RedisDatabase, RedisConnectionOptionsType, ITypeormDatabase, IRedisDatabase, IDatabase, DatabaseException, DatabaseClassType, AbstractTypeormSqliteDatabase };

package/dist/index.js

@@ -1,4 +1,4 @@
 // @bun
-import{Exception as r}from"@ooneex/exception";import{HttpStatus as a}from"@ooneex/http-status";class i extends r{constructor(t,e={}){super(t,{status:a.Code.InternalServerError,data:e});this.name="DatabaseException"}}var{RedisClient:o}=globalThis.Bun;class s{options;client;connectionUrl;constructor(t={}){this.options=t;if(this.connectionUrl=t.url||Bun.env.DATABASE_REDIS_URL||"",!this.connectionUrl)throw new i("No Redis connection URL provided. The 'url' option must be specified or set the following environment variable: DATABASE_REDIS_URL.",{...t,connectionUrl:this.connectionUrl});this.client=new o(this.connectionUrl,{connectionTimeout:t.connectionTimeout||1e4,idleTimeout:t.idleTimeout||0,autoReconnect:t.autoReconnect??!0,maxRetries:t.maxRetries||10,enableOfflineQueue:t.enableOfflineQueue??!0,enableAutoPipelining:t.enableAutoPipelining??!0,...t.tls!==void 0&&{tls:t.tls}})}getClient(){return this.client}async open(){try{if(!this.client.connected)await this.client.connect();return this.client}catch(t){throw new i(`Failed to open Redis connection: ${t instanceof Error?t.message:String(t)}`,{connectionUrl:this.connectionUrl,options:this.options,error:t})}}async close(){try{if(this.client.connected)this.client.close()}catch(t){throw new i(`Failed to close Redis connection: ${t instanceof Error?t.message:String(t)}`,{connectionUrl:this.connectionUrl,error:t})}}async drop(){try{if(!this.client.connected)await this.open();await this.client.send("FLUSHDB",[])}catch(t){throw new i(`Failed to drop Redis database: ${t instanceof Error?t.message:String(t)}`,{connectionUrl:this.connectionUrl,error:t})}}}import{DataSource as n}from"typeorm";class c{source;constructor(t){let e=(t.url||Bun.env.DATABASE_URL||"").trim();if(!e)throw new i("No database URL provided. Please set DATABASE_URL environment variable or provide a url in the options.",{...t,url:e});this.source=new n({synchronize:!1,entities:[],extra:{max:10},...t,url:e,type:"postgres"})}getSource(){return this.source}async open(t){let e=this.getSource();if(!e.isInitialized)await e.initialize();return e.getRepository(t)}async close(){let t=this.getSource();if(t.isInitialized)await t.destroy()}async drop(){let t=this.getSource();if(t.isInitialized)await t.dropDatabase()}getEntityManager(){return this.getSource().manager}}import{DataSource as p}from"typeorm";class y{source;constructor(t){let e=t.database||Bun.env.SQLITE_DATABASE_PATH||"";if(!e)throw new i("No database path provided. The 'database' option must be specified with a valid file path or ':memory:' for in-memory database. Alternatively, set the SQLITE_DATABASE_PATH environment variable.",{...t,database:e});this.source=new p({synchronize:!1,entities:[],enableWAL:!0,busyErrorRetry:2000,busyTimeout:30000,...t,database:e,type:"sqlite"})}getSource(){return this.source}async open(t){let e=this.getSource();if(!e.isInitialized)await e.initialize();return e.getRepository(t)}async close(){let t=this.getSource();if(t.isInitialized)await t.destroy()}async drop(){let t=this.getSource();if(t.isInitialized)await t.dropDatabase()}getEntityManager(){return this.getSource().manager}}export{y as TypeormSqliteDatabaseAdapter,c as TypeormPgDatabaseAdapter,s as RedisDatabaseAdapter,i as DatabaseException};
+class i{source;async open(t,e){let a=this.getSource(e);if(!a.isInitialized)await a.initialize();return a.getRepository(t)}async close(t){let e=this.getSource(t);if(e.isInitialized)await e.destroy()}async drop(t){let e=this.getSource(t);if(e.isInitialized)await e.dropDatabase()}getEntityManager(t){return this.getSource(t).manager}}import{Exception as c}from"@ooneex/exception";import{HttpStatus as p}from"@ooneex/http-status";class r extends c{constructor(t,e={}){super(t,{status:p.Code.InternalServerError,data:e});this.name="DatabaseException"}}import{container as m,EContainerScope as y}from"@ooneex/container";var D={database:(t=y.Singleton)=>{return(e)=>{m.add(e,t)}}};var{RedisClient:u}=globalThis.Bun;class o{options;client;connectionUrl;constructor(t={}){this.options=t;if(this.connectionUrl=t.url||Bun.env.DATABASE_REDIS_URL||"",!this.connectionUrl)throw new r("No Redis connection URL provided. The 'url' option must be specified or set the following environment variable: DATABASE_REDIS_URL.",{...t,connectionUrl:this.connectionUrl});this.client=new u(this.connectionUrl,{connectionTimeout:t.connectionTimeout||1e4,idleTimeout:t.idleTimeout||0,autoReconnect:t.autoReconnect??!0,maxRetries:t.maxRetries||10,enableOfflineQueue:t.enableOfflineQueue??!0,enableAutoPipelining:t.enableAutoPipelining??!0,...t.tls!==void 0&&{tls:t.tls}})}getClient(){return this.client}async open(){try{if(!this.client.connected)await this.client.connect();return this.client}catch(t){throw new r(`Failed to open Redis connection: ${t instanceof Error?t.message:String(t)}`,{connectionUrl:this.connectionUrl,options:this.options,error:t})}}async close(){try{if(this.client.connected)this.client.close()}catch(t){throw new r(`Failed to close Redis connection: ${t instanceof Error?t.message:String(t)}`,{connectionUrl:this.connectionUrl,error:t})}}async drop(){try{if(!this.client.connected)await this.open();await this.client.send("FLUSHDB",[])}catch(t){throw new r(`Failed to drop Redis database: ${t instanceof Error?t.message:String(t)}`,{connectionUrl:this.connectionUrl,error:t})}}}import{DataSource as l}from"typeorm";class s{source;constructor(t={}){let e=(t.url||Bun.env.DATABASE_URL||"").trim();if(!e)throw new r("No database URL provided. Please set DATABASE_URL environment variable or provide a url in the options.",{...t,url:e});this.source=new l({synchronize:!1,entities:[],extra:{max:10},...t,url:e,type:"postgres"})}getSource(){return this.source}async open(t){let e=this.getSource();if(!e.isInitialized)await e.initialize();return e.getRepository(t)}async close(){let t=this.getSource();if(t.isInitialized)await t.destroy()}async drop(){let t=this.getSource();if(t.isInitialized)await t.dropDatabase()}getEntityManager(){return this.getSource().manager}}import{DataSource as d}from"typeorm";class n extends i{options;constructor(t=void 0){super();this.options=t}getSource(t){if(!t&&this.source)return this.source;if(t=t||this.options?.database||Bun.env.SQLITE_DATABASE_PATH||"",!t)throw new r("No database path provided. The 'database' option must be specified with a valid file path or ':memory:' for in-memory database. Alternatively, set the SQLITE_DATABASE_PATH environment variable.",{...this.options||{},database:t});return this.source=new d({synchronize:!1,entities:[],enableWAL:!0,busyErrorRetry:2000,busyTimeout:30000,...this.options||{},database:t,type:"sqlite"}),this.source}}export{D as decorator,n as TypeormSqliteDatabase,s as TypeormPgDatabase,o as RedisDatabase,r as DatabaseException,i as AbstractTypeormSqliteDatabase};
 
-//# debugId=6EB87EF735D078EC64756E2164756E21
+//# debugId=99403C65D68784B064756E2164756E21

package/dist/index.js.map

@@ -1,13 +1,15 @@
 {
   "version": 3,
-  "sources": ["src/DatabaseException.ts", "src/RedisDatabaseAdapter.ts", "src/TypeormPgDatabaseAdapter.ts", "src/TypeormSqliteDatabaseAdapter.ts"],
+  "sources": ["src/AbstractTypeormSqliteDatabase.ts", "src/DatabaseException.ts", "src/decorators.ts", "src/RedisDatabase.ts", "src/TypeormPgDatabase.ts", "src/TypeormSqliteDatabase.ts"],
   "sourcesContent": [
+    "import type { DataSource, EntityManager, EntityTarget, ObjectLiteral, Repository } from \"typeorm\";\nimport type { ITypeormDatabase } from \"./types\";\n\nexport abstract class AbstractTypeormSqliteDatabase implements ITypeormDatabase {\n  protected source: DataSource;\n  public abstract getSource(database?: string): DataSource;\n\n  public async open<Entity extends ObjectLiteral>(\n    entity: EntityTarget<Entity>,\n    database?: string,\n  ): Promise<Repository<Entity>> {\n    const source = this.getSource(database);\n\n    if (!source.isInitialized) {\n      await source.initialize();\n    }\n\n    return source.getRepository(entity);\n  }\n\n  public async close(database?: string): Promise<void> {\n    const source = this.getSource(database);\n    if (source.isInitialized) {\n      await source.destroy();\n    }\n  }\n\n  public async drop(database?: string): Promise<void> {\n    const source = this.getSource(database);\n    if (source.isInitialized) {\n      await source.dropDatabase();\n    }\n  }\n\n  public getEntityManager(database?: string): EntityManager {\n    return this.getSource(database).manager;\n  }\n}\n",
     "import { Exception } from \"@ooneex/exception\";\nimport { HttpStatus } from \"@ooneex/http-status\";\n\nexport class DatabaseException extends Exception {\n  constructor(message: string, data: Record<string, unknown> = {}) {\n    super(message, {\n      status: HttpStatus.Code.InternalServerError,\n      data,\n    });\n    this.name = \"DatabaseException\";\n  }\n}\n",
-    "import { RedisClient } from \"bun\";\nimport { DatabaseException } from \"./DatabaseException\";\nimport type { IRedisDatabaseAdapter, RedisConnectionOptionsType } from \"./types\";\n\nexport class RedisDatabaseAdapter implements IRedisDatabaseAdapter {\n  private client: RedisClient;\n  private connectionUrl: string;\n\n  constructor(private readonly options: RedisConnectionOptionsType = {}) {\n    this.connectionUrl = options.url || Bun.env.DATABASE_REDIS_URL || \"\";\n\n    if (!this.connectionUrl) {\n      throw new DatabaseException(\n        \"No Redis connection URL provided. The 'url' option must be specified or set the following environment variable: DATABASE_REDIS_URL.\",\n        {\n          ...options,\n          connectionUrl: this.connectionUrl,\n        },\n      );\n    }\n\n    // Create Redis client with options\n    this.client = new RedisClient(this.connectionUrl, {\n      connectionTimeout: options.connectionTimeout || 10_000,\n      idleTimeout: options.idleTimeout || 0,\n      autoReconnect: options.autoReconnect ?? true,\n      maxRetries: options.maxRetries || 10,\n      enableOfflineQueue: options.enableOfflineQueue ?? true,\n      enableAutoPipelining: options.enableAutoPipelining ?? true,\n      ...(options.tls !== undefined && { tls: options.tls }),\n    });\n  }\n\n  public getClient(): RedisClient {\n    return this.client;\n  }\n\n  public async open(): Promise<RedisClient> {\n    try {\n      if (!this.client.connected) {\n        await this.client.connect();\n      }\n\n      return this.client;\n    } catch (error) {\n      throw new DatabaseException(\n        `Failed to open Redis connection: ${error instanceof Error ? error.message : String(error)}`,\n        {\n          connectionUrl: this.connectionUrl,\n          options: this.options,\n          error,\n        },\n      );\n    }\n  }\n\n  public async close(): Promise<void> {\n    try {\n      if (this.client.connected) {\n        this.client.close();\n      }\n    } catch (error) {\n      throw new DatabaseException(\n        `Failed to close Redis connection: ${error instanceof Error ? error.message : String(error)}`,\n        {\n          connectionUrl: this.connectionUrl,\n          error,\n        },\n      );\n    }\n  }\n\n  public async drop(): Promise<void> {\n    try {\n      if (!this.client.connected) {\n        await this.open();\n      }\n\n      // Use FLUSHDB to clear the current database\n      await this.client.send(\"FLUSHDB\", []);\n    } catch (error) {\n      throw new DatabaseException(\n        `Failed to drop Redis database: ${error instanceof Error ? error.message : String(error)}`,\n        {\n          connectionUrl: this.connectionUrl,\n          error,\n        },\n      );\n    }\n  }\n}\n",
-    "import { DataSource, type EntityManager, type EntityTarget, type ObjectLiteral, type Repository } from \"typeorm\";\nimport type { PostgresConnectionOptions } from \"typeorm/driver/postgres/PostgresConnectionOptions.js\";\nimport { DatabaseException } from \"./DatabaseException\";\nimport type { ITypeormDatabaseAdapter } from \"./types\";\n\nexport class TypeormPgDatabaseAdapter implements ITypeormDatabaseAdapter {\n  private source: DataSource;\n\n  constructor(options: Omit<PostgresConnectionOptions, \"type\">) {\n    const url = (options.url || Bun.env.DATABASE_URL || \"\").trim();\n\n    if (!url) {\n      throw new DatabaseException(\n        \"No database URL provided. Please set DATABASE_URL environment variable or provide a url in the options.\",\n        {\n          ...options,\n          url,\n        },\n      );\n    }\n\n    this.source = new DataSource({\n      synchronize: false,\n      entities: [],\n      extra: {\n        max: 10,\n        // idleTimeoutMillis: 30000,\n      },\n      ...options,\n      url,\n      type: \"postgres\",\n    });\n  }\n\n  public getSource(): DataSource {\n    return this.source;\n  }\n\n  public async open<Entity extends ObjectLiteral>(entity: EntityTarget<Entity>): Promise<Repository<Entity>> {\n    const source = this.getSource();\n\n    if (!source.isInitialized) {\n      await source.initialize();\n    }\n\n    return source.getRepository(entity);\n  }\n\n  public async close(): Promise<void> {\n    const source = this.getSource();\n    if (source.isInitialized) {\n      await source.destroy();\n    }\n  }\n\n  public async drop(): Promise<void> {\n    const source = this.getSource();\n    if (source.isInitialized) {\n      await source.dropDatabase();\n    }\n  }\n\n  public getEntityManager(): EntityManager {\n    return this.getSource().manager;\n  }\n}\n",
-    "import { DataSource, type EntityManager, type EntityTarget, type ObjectLiteral, type Repository } from \"typeorm\";\nimport type { SqliteConnectionOptions } from \"typeorm/driver/sqlite/SqliteConnectionOptions.js\";\nimport { DatabaseException } from \"./DatabaseException\";\nimport type { ITypeormDatabaseAdapter } from \"./types\";\n\nexport class TypeormSqliteDatabaseAdapter implements ITypeormDatabaseAdapter {\n  private source: DataSource;\n\n  constructor(options: Omit<SqliteConnectionOptions, \"type\">) {\n    const database = options.database || Bun.env.SQLITE_DATABASE_PATH || \"\";\n\n    if (!database) {\n      throw new DatabaseException(\n        \"No database path provided. The 'database' option must be specified with a valid file path or ':memory:' for in-memory database. Alternatively, set the SQLITE_DATABASE_PATH environment variable.\",\n        {\n          ...options,\n          database,\n        },\n      );\n    }\n\n    this.source = new DataSource({\n      synchronize: false,\n      entities: [],\n      enableWAL: true,\n      busyErrorRetry: 2000,\n      busyTimeout: 30_000,\n      ...options,\n      database,\n      type: \"sqlite\",\n    });\n  }\n\n  public getSource(): DataSource {\n    return this.source;\n  }\n\n  public async open<Entity extends ObjectLiteral>(entity: EntityTarget<Entity>): Promise<Repository<Entity>> {\n    const source = this.getSource();\n\n    if (!source.isInitialized) {\n      await source.initialize();\n    }\n\n    return source.getRepository(entity);\n  }\n\n  public async close(): Promise<void> {\n    const source = this.getSource();\n    if (source.isInitialized) {\n      await source.destroy();\n    }\n  }\n\n  public async drop(): Promise<void> {\n    const source = this.getSource();\n    if (source.isInitialized) {\n      await source.dropDatabase();\n    }\n  }\n\n  public getEntityManager(): EntityManager {\n    return this.getSource().manager;\n  }\n}\n"
+    "import { container, EContainerScope } from \"@ooneex/container\";\nimport type { DatabaseClassType } from \"./types\";\n\nexport const decorator = {\n  database: (scope: EContainerScope = EContainerScope.Singleton) => {\n    return (target: DatabaseClassType): void => {\n      container.add(target, scope);\n    };\n  },\n};\n",
+    "import { RedisClient } from \"bun\";\nimport { DatabaseException } from \"./DatabaseException\";\nimport type { IRedisDatabase, RedisConnectionOptionsType } from \"./types\";\n\nexport class RedisDatabase implements IRedisDatabase {\n  private client: RedisClient;\n  private connectionUrl: string;\n\n  constructor(private readonly options: RedisConnectionOptionsType = {}) {\n    this.connectionUrl = options.url || Bun.env.DATABASE_REDIS_URL || \"\";\n\n    if (!this.connectionUrl) {\n      throw new DatabaseException(\n        \"No Redis connection URL provided. The 'url' option must be specified or set the following environment variable: DATABASE_REDIS_URL.\",\n        {\n          ...options,\n          connectionUrl: this.connectionUrl,\n        },\n      );\n    }\n\n    // Create Redis client with options\n    this.client = new RedisClient(this.connectionUrl, {\n      connectionTimeout: options.connectionTimeout || 10_000,\n      idleTimeout: options.idleTimeout || 0,\n      autoReconnect: options.autoReconnect ?? true,\n      maxRetries: options.maxRetries || 10,\n      enableOfflineQueue: options.enableOfflineQueue ?? true,\n      enableAutoPipelining: options.enableAutoPipelining ?? true,\n      ...(options.tls !== undefined && { tls: options.tls }),\n    });\n  }\n\n  public getClient(): RedisClient {\n    return this.client;\n  }\n\n  public async open(): Promise<RedisClient> {\n    try {\n      if (!this.client.connected) {\n        await this.client.connect();\n      }\n\n      return this.client;\n    } catch (error) {\n      throw new DatabaseException(\n        `Failed to open Redis connection: ${error instanceof Error ? error.message : String(error)}`,\n        {\n          connectionUrl: this.connectionUrl,\n          options: this.options,\n          error,\n        },\n      );\n    }\n  }\n\n  public async close(): Promise<void> {\n    try {\n      if (this.client.connected) {\n        this.client.close();\n      }\n    } catch (error) {\n      throw new DatabaseException(\n        `Failed to close Redis connection: ${error instanceof Error ? error.message : String(error)}`,\n        {\n          connectionUrl: this.connectionUrl,\n          error,\n        },\n      );\n    }\n  }\n\n  public async drop(): Promise<void> {\n    try {\n      if (!this.client.connected) {\n        await this.open();\n      }\n\n      // Use FLUSHDB to clear the current database\n      await this.client.send(\"FLUSHDB\", []);\n    } catch (error) {\n      throw new DatabaseException(\n        `Failed to drop Redis database: ${error instanceof Error ? error.message : String(error)}`,\n        {\n          connectionUrl: this.connectionUrl,\n          error,\n        },\n      );\n    }\n  }\n}\n",
+    "import { DataSource, type EntityManager, type EntityTarget, type ObjectLiteral, type Repository } from \"typeorm\";\nimport type { PostgresConnectionOptions } from \"typeorm/driver/postgres/PostgresConnectionOptions.js\";\nimport { DatabaseException } from \"./DatabaseException\";\nimport type { ITypeormDatabase } from \"./types\";\n\nexport class TypeormPgDatabase implements ITypeormDatabase {\n  private source: DataSource;\n\n  constructor(options: Omit<PostgresConnectionOptions, \"type\"> = {}) {\n    const url = (options.url || Bun.env.DATABASE_URL || \"\").trim();\n\n    if (!url) {\n      throw new DatabaseException(\n        \"No database URL provided. Please set DATABASE_URL environment variable or provide a url in the options.\",\n        {\n          ...options,\n          url,\n        },\n      );\n    }\n\n    this.source = new DataSource({\n      synchronize: false,\n      entities: [],\n      extra: {\n        max: 10,\n        // idleTimeoutMillis: 30000,\n      },\n      ...options,\n      url,\n      type: \"postgres\",\n    });\n  }\n\n  public getSource(): DataSource {\n    return this.source;\n  }\n\n  public async open<Entity extends ObjectLiteral>(entity: EntityTarget<Entity>): Promise<Repository<Entity>> {\n    const source = this.getSource();\n\n    if (!source.isInitialized) {\n      await source.initialize();\n    }\n\n    return source.getRepository(entity);\n  }\n\n  public async close(): Promise<void> {\n    const source = this.getSource();\n    if (source.isInitialized) {\n      await source.destroy();\n    }\n  }\n\n  public async drop(): Promise<void> {\n    const source = this.getSource();\n    if (source.isInitialized) {\n      await source.dropDatabase();\n    }\n  }\n\n  public getEntityManager(): EntityManager {\n    return this.getSource().manager;\n  }\n}\n",
+    "import { DataSource } from \"typeorm\";\nimport type { SqliteConnectionOptions } from \"typeorm/driver/sqlite/SqliteConnectionOptions.js\";\nimport { AbstractTypeormSqliteDatabase } from \"./AbstractTypeormSqliteDatabase\";\nimport { DatabaseException } from \"./DatabaseException\";\n\nexport class TypeormSqliteDatabase extends AbstractTypeormSqliteDatabase {\n  constructor(private readonly options: Omit<SqliteConnectionOptions, \"type\"> | undefined = undefined) {\n    super();\n  }\n\n  public getSource(database?: string): DataSource {\n    if (!database && this.source) {\n      return this.source;\n    }\n\n    database = database || this.options?.database || Bun.env.SQLITE_DATABASE_PATH || \"\";\n\n    if (!database) {\n      throw new DatabaseException(\n        \"No database path provided. The 'database' option must be specified with a valid file path or ':memory:' for in-memory database. Alternatively, set the SQLITE_DATABASE_PATH environment variable.\",\n        {\n          ...(this.options || {}),\n          database,\n        },\n      );\n    }\n\n    this.source = new DataSource({\n      synchronize: false,\n      entities: [],\n      enableWAL: true,\n      busyErrorRetry: 2000,\n      busyTimeout: 30_000,\n      ...(this.options || {}),\n      database,\n      type: \"sqlite\",\n    });\n\n    return this.source;\n  }\n}\n"
   ],
-  "mappings": "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",
-  "debugId": "6EB87EF735D078EC64756E2164756E21",
+  "mappings": "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",
+  "debugId": "99403C65D68784B064756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ooneex/database",
-  "description": "",
-  "version": "0.0.1",
+  "description": "Database connection and management utilities with TypeORM integration for Ooneex applications",
+  "version": "0.0.5",
   "type": "module",
   "files": [
     "dist",
@@ -25,15 +25,23 @@
     "test": "bun test tests",
     "build": "bunup",
     "lint": "tsgo --noEmit && bunx biome lint",
-    "publish:prod": "bun publish --tolerate-republish --access public",
-    "publish:pack": "bun pm pack --destination ./dist",
-    "publish:dry": "bun publish --dry-run"
+    "npm:publish": "bun publish --tolerate-republish --access public"
   },
   "dependencies": {
+    "@ooneex/container": "0.0.2",
     "@ooneex/exception": "0.0.1",
     "@ooneex/http-status": "0.0.1",
     "typeorm": "^0.3.27"
   },
-  "peerDependencies": {},
-  "devDependencies": {}
+  "devDependencies": {},
+  "keywords": [
+    "bun",
+    "database",
+    "db",
+    "ooneex",
+    "query",
+    "sql",
+    "typeorm",
+    "typescript"
+  ]
 }