@ooneex/database 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ooneex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,607 @@
+# @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.
+
+![Bun](https://img.shields.io/badge/Bun-Compatible-orange?style=flat-square&logo=bun)
+![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
+
+✅ **Bun Native** - Built specifically for Bun runtime with Bun.SQL
+
+✅ **TypeORM Integration** - Dedicated adapters for PostgreSQL and SQLite
+
+✅ **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
+
+✅ **Error Handling** - Comprehensive error handling with custom exceptions
+
+✅ **Environment Support** - Automatic environment variable detection
+
+✅ **Zero Configuration** - Works out of the box with sensible defaults
+
+## Installation
+
+### Bun
+```bash
+bun add @ooneex/database
+```
+
+## Usage
+
+### TypeORM PostgreSQL Adapter
+
+```typescript
+import { TypeormPgDatabaseAdapter } from '@ooneex/database';
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+@Entity()
+class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @Column()
+  email: string;
+}
+
+const adapter = new TypeormPgDatabaseAdapter({
+  url: 'postgresql://user:pass@localhost:5432/mydb',
+  synchronize: true,
+  entities: [User]
+});
+
+// Open and get repository
+const userRepository = await adapter.open(User);
+
+// Create user
+const user = userRepository.create({
+  name: 'John Doe',
+  email: 'john@example.com'
+});
+await userRepository.save(user);
+
+// Find users
+const users = await userRepository.find();
+
+// Close connection
+await adapter.close();
+```
+
+### TypeORM SQLite Adapter
+
+```typescript
+import { TypeormSqliteDatabaseAdapter } from '@ooneex/database';
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+@Entity()
+class Product {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @Column('decimal')
+  price: number;
+}
+
+const adapter = new TypeormSqliteDatabaseAdapter({
+  database: './products.db',
+  synchronize: true,
+  entities: [Product]
+});
+
+// Open and get repository
+const productRepository = await adapter.open(Product);
+
+// Create product
+const product = productRepository.create({
+  name: 'Laptop',
+  price: 999.99
+});
+await productRepository.save(product);
+
+// Close connection
+await adapter.close();
+```
+
+### Error Handling
+
+```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);
+  }
+}
+```
+
+### Environment Configuration
+
+```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
+```
+
+## API Reference
+
+### `Database` Class
+
+The main database class providing connection management and basic operations.
+
+#### Constructor
+
+```typescript
+constructor(connectionString?: string | URL, options?: Bun.SQL.Options)
+```
+
+**Parameters:**
+- `connectionString` - Database connection string or URL object
+- `options` - Bun.SQL connection options
+
+**Example:**
+```typescript
+const db = new Database('sqlite://./app.db', { timeout: 5000 });
+```
+
+#### Methods
+
+##### `getClient(): Bun.SQL`
+Returns the underlying Bun.SQL client instance.
+
+**Returns:** The Bun.SQL client
+
+**Example:**
+```typescript
+const client = db.getClient();
+const result = await client`SELECT * FROM users`;
+```
+
+##### `open(): Promise<void>`
+Opens the database connection.
+
+**Example:**
+```typescript
+await db.open();
+```
+
+##### `close(): Promise<void>`
+Closes the database connection.
+
+**Example:**
+```typescript
+await db.close();
+```
+
+##### `drop(): Promise<void>`
+Drops the database. **Caution: This is destructive and cannot be undone.**
+
+**Example:**
+```typescript
+await db.drop(); // Permanently deletes the database
+```
+
+### `TypeormPgDatabaseAdapter` Class
+
+TypeORM adapter for PostgreSQL databases.
+
+#### Constructor
+
+```typescript
+constructor(options: Omit<PostgresConnectionOptions, "type">)
+```
+
+**Parameters:**
+- `options` - PostgreSQL connection options (without type field)
+
+#### Methods
+
+##### `getSource(): DataSource`
+Returns the TypeORM DataSource instance.
+
+##### `open<Entity>(entity: EntityTarget<Entity>): Promise<Repository<Entity>>`
+Opens connection and returns repository for the specified entity.
+
+##### `close(): Promise<void>`
+Closes the database connection.
+
+##### `drop(): Promise<void>`
+Drops the database schema.
+
+##### `getEntityManager(): EntityManager`
+Returns the TypeORM EntityManager.
+
+### `TypeormSqliteDatabaseAdapter` Class
+
+TypeORM adapter for SQLite databases.
+
+#### Constructor
+
+```typescript
+constructor(options: Omit<SqliteConnectionOptions, "type">)
+```
+
+**Parameters:**
+- `options` - SQLite connection options (without type field)
+
+#### Methods
+
+Same methods as `TypeormPgDatabaseAdapter` but optimized for SQLite.
+
+### `RedisDatabaseAdapter` Class
+
+Redis adapter using Bun's native Redis client.
+
+#### Constructor
+
+```typescript
+constructor(options: RedisConnectionOptions = {})
+```
+
+**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
+
+### Interfaces
+
+#### `IDatabase`
+
+```typescript
+interface IDatabase {
+  open(): Promise<void>;
+  close(): Promise<void>;
+  drop(): Promise<void>;
+}
+```
+
+#### `ITypeormDatabaseAdapter`
+
+```typescript
+interface ITypeormDatabaseAdapter {
+  open(entity: any): Promise<any>;
+  close(): Promise<void>;
+  drop(): Promise<void>;
+}
+```
+
+## Supported Database URLs
+
+### SQLite
+```typescript
+// File-based database
+'sqlite://./database.db'
+'sqlite:database.db'
+'./database.db'
+
+// In-memory database
+'sqlite://:memory:'
+':memory:'
+```
+
+### PostgreSQL
+```typescript
+'postgresql://user:password@localhost:5432/database'
+'postgres://user:password@localhost:5432/database'
+```
+
+### MySQL
+```typescript
+'mysql://user:password@localhost:3306/database'
+'mysql2://user:password@localhost:3306/database'
+```
+
+### Redis
+```typescript
+// Standard Redis URL
+'redis://localhost:6379'
+
+// With authentication
+'redis://username:password@localhost:6379'
+
+// With database number
+'redis://localhost:6379/0'
+
+// TLS connections
+'rediss://localhost:6379'
+'redis+tls://localhost:6379'
+
+// Unix socket connections
+'redis+unix:///path/to/socket'
+'redis+tls+unix:///path/to/socket'
+```
+
+## 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
+
+### Redis Adapter
+
+```typescript
+import { RedisDatabaseAdapter } from '@ooneex/database';
+
+const adapter = new RedisDatabaseAdapter({
+  url: 'redis://localhost:6379',
+  connectionTimeout: 10000,
+  autoReconnect: true,
+  maxRetries: 10
+});
+
+// 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');
+
+// Close connection
+await adapter.close();
+```
+
+### 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
+
+```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
+  }
+});
+```
+
+### SQLite with TypeORM
+
+```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
+
+This package provides a native Redis adapter built specifically for Bun's Redis client, offering high-performance Redis operations with full TypeScript support.
+
+### Basic Redis Usage
+
+```typescript
+import { RedisDatabaseAdapter } from '@ooneex/database';
+
+const adapter = new RedisDatabaseAdapter({
+  url: process.env.REDIS_URL,
+  connectionTimeout: 5000,
+  autoReconnect: true
+});
+
+await adapter.open();
+const client = adapter.getClient();
+
+// String operations
+await client.set('key', 'value');
+const value = await client.get('key');
+
+// Numeric operations
+await client.incr('counter');
+await client.decr('counter');
+
+// Hash operations
+await client.hmset('user:1', ['name', 'Alice', 'email', 'alice@example.com']);
+const userData = await client.hmget('user:1', ['name', 'email']);
+
+// Set operations
+await client.sadd('tags', 'redis', 'cache');
+const allTags = await client.smembers('tags');
+
+await adapter.close();
+```
+
+### Redis Pub/Sub
+
+```typescript
+const publisher = new RedisDatabaseAdapter();
+const subscriber = new RedisDatabaseAdapter();
+
+await publisher.open();
+await subscriber.open();
+
+// Set up subscription
+const subClient = subscriber.getClient();
+await subClient.subscribe('notifications', (message, channel) => {
+  console.log(`Received: ${message} on ${channel}`);
+});
+
+// Publish message
+const pubClient = publisher.getClient();
+await pubClient.publish('notifications', 'Hello subscribers!');
+```
+
+### 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);
+  }
+  
+  // 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
+
+```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);
+  }
+  
+  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.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+### Development Setup
+
+1. Clone the repository
+2. Install dependencies: `bun install`
+3. Run tests: `bun run test`
+4. Build the project: `bun run build`
+
+### Guidelines
+
+- Write tests for new features
+- 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)
+
+---
+
+Made with ❤️ by the Ooneex team

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+import { Exception } from "@ooneex/exception";
+declare class DatabaseException extends Exception {
+	constructor(message: string, data?: Record<string, unknown>);
+}
+import { RedisClient as RedisClient2 } from "bun";
+import { RedisClient } from "bun";
+import { EntityTarget, ObjectLiteral, Repository } from "typeorm";
+type DatabaseClassType = new (...args: any[]) => IDatabase | IRedisDatabaseAdapter | ITypeormDatabaseAdapter;
+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;
+	};
+};
+interface IDatabase {
+	open: () => Promise<void>;
+	close: () => Promise<void>;
+	drop: () => Promise<void>;
+}
+interface IRedisDatabaseAdapter {
+	open: () => Promise<RedisClient>;
+	close: () => Promise<void>;
+	drop: () => Promise<void>;
+}
+interface ITypeormDatabaseAdapter {
+	open: <Entity extends ObjectLiteral>(entity: EntityTarget<Entity>) => Promise<Repository<Entity>>;
+	close: () => Promise<void>;
+	drop: () => Promise<void>;
+}
+declare class RedisDatabaseAdapter implements IRedisDatabaseAdapter {
+	private readonly options;
+	private client;
+	private connectionUrl;
+	constructor(options?: RedisConnectionOptionsType);
+	getClient(): RedisClient2;
+	open(): Promise<RedisClient2>;
+	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 {
+	private source;
+	constructor(options: Omit<SqliteConnectionOptions, "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 };

package/dist/index.js

@@ -0,0 +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};
+
+//# debugId=6EB87EF735D078EC64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["src/DatabaseException.ts", "src/RedisDatabaseAdapter.ts", "src/TypeormPgDatabaseAdapter.ts", "src/TypeormSqliteDatabaseAdapter.ts"],
+  "sourcesContent": [
+    "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"
+  ],
+  "mappings": ";AAAA,oBAAS,0BACT,qBAAS,4BAEF,MAAM,UAA0B,CAAU,CAC/C,WAAW,CAAC,EAAiB,EAAgC,CAAC,EAAG,CAC/D,MAAM,EAAS,CACb,OAAQ,EAAW,KAAK,oBACxB,MACF,CAAC,EACD,KAAK,KAAO,oBAEhB,CCXA,kCAIO,MAAM,CAAsD,CAIpC,QAHrB,OACA,cAER,WAAW,CAAkB,EAAsC,CAAC,EAAG,CAA1C,eAG3B,GAFA,KAAK,cAAgB,EAAQ,KAAO,IAAI,IAAI,oBAAsB,GAE9D,CAAC,KAAK,cACR,MAAM,IAAI,EACR,sIACA,IACK,EACH,cAAe,KAAK,aACtB,CACF,EAIF,KAAK,OAAS,IAAI,EAAY,KAAK,cAAe,CAChD,kBAAmB,EAAQ,mBAAqB,IAChD,YAAa,EAAQ,aAAe,EACpC,cAAe,EAAQ,eAAiB,GACxC,WAAY,EAAQ,YAAc,GAClC,mBAAoB,EAAQ,oBAAsB,GAClD,qBAAsB,EAAQ,sBAAwB,MAClD,EAAQ,MAAQ,QAAa,CAAE,IAAK,EAAQ,GAAI,CACtD,CAAC,EAGI,SAAS,EAAgB,CAC9B,OAAO,KAAK,YAGD,KAAI,EAAyB,CACxC,GAAI,CACF,GAAI,CAAC,KAAK,OAAO,UACf,MAAM,KAAK,OAAO,QAAQ,EAG5B,OAAO,KAAK,OACZ,MAAO,EAAO,CACd,MAAM,IAAI,EACR,oCAAoC,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,IACzF,CACE,cAAe,KAAK,cACpB,QAAS,KAAK,QACd,OACF,CACF,QAIS,MAAK,EAAkB,CAClC,GAAI,CACF,GAAI,KAAK,OAAO,UACd,KAAK,OAAO,MAAM,EAEpB,MAAO,EAAO,CACd,MAAM,IAAI,EACR,qCAAqC,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,IAC1F,CACE,cAAe,KAAK,cACpB,OACF,CACF,QAIS,KAAI,EAAkB,CACjC,GAAI,CACF,GAAI,CAAC,KAAK,OAAO,UACf,MAAM,KAAK,KAAK,EAIlB,MAAM,KAAK,OAAO,KAAK,UAAW,CAAC,CAAC,EACpC,MAAO,EAAO,CACd,MAAM,IAAI,EACR,kCAAkC,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,IACvF,CACE,cAAe,KAAK,cACpB,OACF,CACF,GAGN,CC1FA,qBAAS,gBAKF,MAAM,CAA4D,CAC/D,OAER,WAAW,CAAC,EAAkD,CAC5D,IAAM,GAAO,EAAQ,KAAO,IAAI,IAAI,cAAgB,IAAI,KAAK,EAE7D,GAAI,CAAC,EACH,MAAM,IAAI,EACR,0GACA,IACK,EACH,KACF,CACF,EAGF,KAAK,OAAS,IAAI,EAAW,CAC3B,YAAa,GACb,SAAU,CAAC,EACX,MAAO,CACL,IAAK,EAEP,KACG,EACH,MACA,KAAM,UACR,CAAC,EAGI,SAAS,EAAe,CAC7B,OAAO,KAAK,YAGD,KAAkC,CAAC,EAA2D,CACzG,IAAM,EAAS,KAAK,UAAU,EAE9B,GAAI,CAAC,EAAO,cACV,MAAM,EAAO,WAAW,EAG1B,OAAO,EAAO,cAAc,CAAM,OAGvB,MAAK,EAAkB,CAClC,IAAM,EAAS,KAAK,UAAU,EAC9B,GAAI,EAAO,cACT,MAAM,EAAO,QAAQ,OAIZ,KAAI,EAAkB,CACjC,IAAM,EAAS,KAAK,UAAU,EAC9B,GAAI,EAAO,cACT,MAAM,EAAO,aAAa,EAIvB,gBAAgB,EAAkB,CACvC,OAAO,KAAK,UAAU,EAAE,QAE5B,CCjEA,qBAAS,gBAKF,MAAM,CAAgE,CACnE,OAER,WAAW,CAAC,EAAgD,CAC1D,IAAM,EAAW,EAAQ,UAAY,IAAI,IAAI,sBAAwB,GAErE,GAAI,CAAC,EACH,MAAM,IAAI,EACR,oMACA,IACK,EACH,UACF,CACF,EAGF,KAAK,OAAS,IAAI,EAAW,CAC3B,YAAa,GACb,SAAU,CAAC,EACX,UAAW,GACX,eAAgB,KAChB,YAAa,SACV,EACH,WACA,KAAM,QACR,CAAC,EAGI,SAAS,EAAe,CAC7B,OAAO,KAAK,YAGD,KAAkC,CAAC,EAA2D,CACzG,IAAM,EAAS,KAAK,UAAU,EAE9B,GAAI,CAAC,EAAO,cACV,MAAM,EAAO,WAAW,EAG1B,OAAO,EAAO,cAAc,CAAM,OAGvB,MAAK,EAAkB,CAClC,IAAM,EAAS,KAAK,UAAU,EAC9B,GAAI,EAAO,cACT,MAAM,EAAO,QAAQ,OAIZ,KAAI,EAAkB,CACjC,IAAM,EAAS,KAAK,UAAU,EAC9B,GAAI,EAAO,cACT,MAAM,EAAO,aAAa,EAIvB,gBAAgB,EAAkB,CACvC,OAAO,KAAK,UAAU,EAAE,QAE5B",
+  "debugId": "6EB87EF735D078EC64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@ooneex/database",
+  "description": "",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "scripts": {
+    "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"
+  },
+  "dependencies": {
+    "@ooneex/exception": "0.0.1",
+    "@ooneex/http-status": "0.0.1",
+    "typeorm": "^0.3.27"
+  },
+  "peerDependencies": {},
+  "devDependencies": {}
+}