@onurege3467/zerohelper 5.0.3 → 6.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onurege3467/zerohelper",
-  "version": "5.0.3",
+  "version": "6.0.1",
   "main": "index.js",
   "scripts": {
     "test": "node test.js"
@@ -26,7 +26,7 @@
   "description": "ZeroHelper is a versatile JavaScript library offering helper functions and database utilities for developers. It supports MongoDB, MySQL, SQLite, Redis, and PostgreSQL.",
   "dependencies": {
     "bcrypt": "^5.1.1",
-    "better-sqlite3": "^11.10.0",
+    
     "crypto": "^1.0.1",
     "csv": "^6.3.11",
     "dotenv": "^16.4.7",
@@ -40,6 +40,7 @@
     "pg": "^8.14.1",
     "promise-mysql": "^5.2.0",
     "redis": "^4.7.0",
-    "sqlite3": "^5.1.7"
+    "sqlite3": "^5.1.7",
+    "lru-cache": "^10.0.0"
   }
 }

package/readme.md

@@ -15,14 +15,8 @@ ZeroHelper is a versatile JavaScript package providing helper functions and data
    - [🔒 Crypto Functions](#crypto-functions-)
    - [➗ Math Functions](#math-functions-)
 3. [💾 Database Utilities](#-database-utilities)
-   - [🗃️ JsonDatabase](#jsondatabase-️)
-   - [♦️ YamlDatabase](#yamldatabase-️)
-   - [🎋 CSV Database](#csv-database-)
-   - [🗄️ MongoDB](#mongodb-️)
-   - [🐬 MySQL](#mysql-)
-   - [📱 SQLiteDB](#sqlitedb-)
-   - [🍇 PostgreSQL](#postgresql-)
-   - [⚡ Redis](#redis-)
+   - [🏭 Using the Database Factory](#-using-the-database-factory)
+   - [📚 API Reference](#-api-reference)
 4. [🔄 Database Migration](#database-migration)
 
 ---
@@ -166,240 +160,149 @@ console.log(prime); // true
 
 ZeroHelper provides multiple database utilities for seamless integration with various databases.
 
-# JsonDatabase 🗃️
+## 💾 Using ZeroHelper as Database
 
-```js
-(async function () {
-  const JsonDatabase = require("@onurege3467/zerohelper/database/jsondatabase");
-  const db = new JsonDatabase();
+ZeroHelper provides a flexible database factory for seamless integration with various databases.
 
-  await db.set("foo", "bar");
-  await db.push("array", "x");
-  await db.delete("foo");
+### 🏭 Using the Database Factory
 
-  await db.add("number", 1);
-  await db.sub("number", 1);
+ZeroHelper's database factory allows you to create database instances with various adapters. You can also enable and configure an LRU (Least Recently Used) cache for read operations to improve performance.
 
-  await console.log(db.get("foo"));
-  await console.log(db.has("foo"));
-})();
-```
-# YamlDatabase 🗃️
-```js
-(async function () {
-  const YamlDatabase = require("@onurege3467/zerohelper/database/yamldatabase");
-  const db = new YamlDatabase();
+#### Enabling and Configuring Cache
 
-  await db.set("foo", "bar");
-  await db.push("array", "x");
-  await db.delete("foo");
+To enable caching, pass a `cache` object within the `config` object when creating a database instance. The `cache` object can have the following properties:
 
-  await db.add("number", 1);
-  await db.sub("number", 1);
+- `max`: (Number, optional) The maximum number of items to store in the cache. Defaults to `500`.
+- `ttl`: (Number, optional) The time to live for cache entries in milliseconds. Defaults to `300000` (5 minutes).
+- `updateAgeOnGet`: (Boolean, optional) If `true`, accessing an item refreshes its `ttl`. Defaults to `false`.
 
-  await console.log(db.get("foo"));
-  await console.log(db.has("foo"));
-})();
-```
-# CSV Database 🎋
-```js
-(async function () {
-  const csvdb = require("@onurege3467/zerohelper/database/csvdb");
-  const db = new csvdb();
+**Example with Cache Enabled:**
 
-  await db.set("foo", "bar");
-  await db.push("array", "x");
-  await db.delete("foo");
-
-  await db.add("number", 1);
-  await db.sub("number", 1);
+```javascript
+const path = require('path');
+const createDatabase = require('@onurege3467/zerohelper/database');
 
-  await console.log(db.get("foo"));
-  await console.log(db.has("foo"));
-})();
-```
-# MongoDB 🗄️
+const cachedSqliteDb = createDatabase({
+  adapter: 'sqlite',
+  config: {
+    filePath: path.join(__dirname, 'data', 'cached_development.sqlite'),
+    cache: {
+      max: 1000, // Cache up to 1000 items
+      ttl: 1000 * 60 * 10, // Cache items for 10 minutes
+      updateAgeOnGet: true // Refresh TTL on access
+    }
+  }
+});
 
-```js
-(async function () {
-  const MongoDB = require("@onurege3467/zerohelper/database/mongodb");
-  const db = await MongoDB.createData(
-    "database",
-    "collection",
-    "data",
-    undefined,
-    "mongourl"
-  );
-
-  await db.set("foo", "bar");
-  await db.push("array", "x");
-  await db.delete("foo");
-
-  await db.add("number", 1);
-  await db.sub("number", 1);
-
-  console.log(await db.get("foo"));
-  console.log(await db.has("foo"));
-
-  console.log(await db.ping());
-})();
+// Subsequent `select` or `selectOne` calls for the same query will hit the cache
+// Write operations (insert, update, delete, set, bulkInsert) will automatically invalidate the cache for the affected table.
 ```
 
-# MySQL 🐬
-
-```js
-(async function () {
-  const MySQL = require("@onurege3467/zerohelper/database/mysql");
-
-  const db = new MySQL();
-  await db.connect({
-    host: "localhost",
-    port: "3306",
-    user: "root",
-    password: "",
-    database: "database",
-    charset: "utf8mb4",
-  });
-
-  db.on("connected", async () => {
-    console.log("Database Connected");
-  });
-
-  await db.set("key", "value"); // Uses the default table
-  await db.set("key", "value", "custom_table"); // Uses the specified table
-
-  const value = await db.get("key"); // Uses the default table
-  const valueInCustomTable = await db.get("key", "custom_table"); // Uses the specified table
-
-  await db.add("count", 10); // Uses the default table
-  await db.add("count", 10, "custom_table"); // Uses the specified table
-
-  await db.sub("count", 5); // Uses the default table
-  await db.sub("count", 5, "custom_table"); // Uses the specified table
-
-  await db.push("array", "value"); // Uses the default table
-  await db.push("array", "value", "custom_table"); // Uses the specified table
-
-  await db.pull("array", "value"); // Uses the default table
-  await db.pull("array", "value", "custom_table"); // Uses the specified table
+**Basic Usage (without cache configuration shown):**
 
-  await db.delete("key"); // Uses the default table
-  await db.delete("key", "custom_table"); // Uses the specified table
-
-  const exists = await db.exists("key"); // Uses the default table
-  const existsInCustomTable = await db.exists("key", "custom_table"); // Uses the specified table
-
-  const includes = await db.includes("array", "value"); // Uses the default table
-  const includesInCustomTable = await db.includes(
-    "array",
-    "value",
-    "custom_table"
-  ); // Uses the specified table
-
-  const allData = await db.all(); // Uses the default table
-  const allDataInCustomTable = await db.all("custom_table"); // Uses the specified table
-
-  await db.clear(); // Clears the default table
-  await db.clear("custom_table"); // Clears the specified table
+```javascript
+const path = require('path');
+const createDatabase = require('@onurege3467/zerohelper/database'); // Adjust the path to your project structure
 
-  await db.drop(); // Drops the default table
-  await db.drop("custom_table"); // Drops the specified table
+// --- 1. Using SQLite (Fast and Lightweight) ---
+const sqliteDb = createDatabase({
+  adapter: 'sqlite',
+  config: {
+    filePath: path.join(__dirname, 'data', 'development.sqlite')
+  }
+});
 
-  await db.rename("old_table", "new_table");
+// --- 2. Using MySQL (For Production) ---
+const mysqlDb = createDatabase({
+  adapter: 'mysql',
+  config: {
+    host: 'localhost',
+    user: 'root',
+    password: 'your_password',
+    database: 'my_app_prod'
+  }
+});
 
-  const ping = await db.ping();
-  console.log(`Ping: ${ping}ms`);
+// --- 3. Using a JSON File (For Simple Prototyping) ---
+const jsonDb = createDatabase({
+  adapter: 'json',
+  config: {
+    filePath: path.join(__dirname, 'data', 'db.json')
+  }
+});
 
-  // Sets MySQL global variables
-  await db.variables({
-    max_connections: 100000,
-    wait_timeout: 60,
-  });
-})();
+// --- 4. Using MongoDB ---
+const mongoDb = createDatabase({
+    adapter: 'mongodb',
+    config: {
+        url: 'mongodb://localhost:27017',
+        database: 'my_app_mongo'
+    }
+});
 ```
 
-# SQLiteDB 📱
-
-```js
-(async function () {
-  const SQLiteDB = require("@onurege3467/zerohelper/database/sqldb");
-
-  const db = new SQLiteDB();
-
-  await db.set("foo", "bar");
-  await db.push("array", "x");
-  await db.delete("foo");
-
-  await db.add("number", 1);
-  await db.sub("number", 1);
-
-  console.log(await db.get("foo"));
-  console.log(await db.has("foo"));
-})();
-```
+### Basic Operations (CRUD)
 
-# PostgreSQL 🍇
+No matter which adapter you choose, you can use the following methods in exactly the same way.
 
-```js
-(async function () {
-  const PostgreSQL = require("@onurege3467/zerohelper/database/postgresql");
-
-  const db = new PostgreSQL({
-    user: "your_username",
-    host: "localhost",
-    database: "your_database",
-    password: "your_password",
-    port: 5432,
+```javascript
+async function main() {
+  // Let's use sqliteDb for this example
+  const db = createDatabase({
+    adapter: 'sqlite',
+    config: { filePath: 'app.db' }
   });
 
-  await db.set("foo", "bar");
-  console.log(await db.get("foo"));
-  console.log(await db.has("foo"));
-  await db.delete("foo");
-
-  await db.add("number", 10);
-  await db.sub("number", 5);
-
-  await db.set("array", []);
-  await db.push("array", "value");
-  console.log(await db.get("array"));
+  try {
+    // Insert Data
+    const newUserId = await db.insert('users', { name: 'John Doe', email: 'john@example.com', age: 30 });
+    console.log(`New user added with ID: ${newUserId}`);
 
-  console.log(await db.ping());
+    // Select Data
+    const user = await db.selectOne('users', { name: 'John Doe' });
+    console.log('Found user:', user);
 
-  await db.close();
-})();
-```
+    // Update Data
+    await db.update('users', { age: 31 }, { email: 'john@example.com' });
+    console.log('User updated.');
 
-# Redis ⚡
+    // Update if exists, or insert if not (Upsert)
+    await db.set('users', { city: 'New York' }, { name: 'John Doe' }); // Updates existing
+    await db.set('users', { name: 'Jane Doe', email: 'jane@example.com' }, { name: 'Jane Doe' }); // Inserts new
 
-```js
-(async function () {
-  const RedisDatabase = require("@onurege3467/zerohelper/database/redis");
+    // Select All Data
+    const allUsers = await db.select('users');
+    console.log('All users:', allUsers);
 
-  const db = new RedisDatabase({
-    url: "redis://localhost:6379",
-  });
+    // Delete Data
+    await db.delete('users', { name: 'John Doe' });
+    console.log('User deleted.');
 
-  await db.connect();
+  } catch (error) {
+    console.error('An error occurred:', error);
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+}
 
-  await db.set("user.name", "John Doe");
-  console.log(await db.get("user.name"));
-  console.log(await db.has("user.name"));
-  await db.delete("user.name");
+main();
+```
 
-  await db.add("stats.score", 10);
-  await db.sub("stats.score", 5);
+### 📚 API Reference
 
-  await db.set("items", []);
-  await db.push("items", "item1");
-  console.log(await db.get("items"));
+All adapters implement the following common methods (the `IDatabase` interface):
 
-  console.log(await db.ping());
+- `select(table, where)`: Returns an array of all rows matching the query.
+- `selectOne(table, where)`: Returns the first row matching the query as an object, or `null`.
+- `insert(table, data)`: Inserts a new row and returns its ID.
+- `update(table, data, where)`: Updates rows matching the query and returns the number of affected rows.
+- `delete(table, where)`: Deletes rows matching the query and returns the number of affected rows.
+- `set(table, data, where)`: Updates a record if it exists, otherwise inserts it as a new record.
+- `bulkInsert(table, dataArray)`: Inserts an array of objects in a single, optimized operation.
+- `close()`: Safely closes the database connection or file handle.
 
-  await db.close();
-})();
-```
-## Schema DB
+## Database Migration
 
 ```javascript
 const path = require('path');
@@ -502,119 +405,3 @@ All adapters implement the following common methods (the `IDatabase` interface):
 - `set(table, data, where)`: Updates a record if it exists, otherwise inserts it as a new record.
 - `bulkInsert(table, dataArray)`: Inserts an array of objects in a single, optimized operation.
 - `close()`: Safely closes the database connection or file handle.
-
-## Database Migration
-
-The `migrateData` function allows you to migrate data between different types of databases. It supports JSON, MongoDB, MySQL, SQLite, Redis, and PostgreSQL.
-
-# Example: Migrate Data from JSON to MongoDB
-
-```js
-const migrateData = require("@onurege3467/zerohelper/database/migrate");
-
-const sourceConfig = {
-  type: "json",
-  options: {
-    filePath: "databases/source.json", // Path to the JSON file
-  },
-};
-
-const targetConfig = {
-  type: "mongodb",
-  options: {
-    url: "mongodb://localhost:27017", // MongoDB connection URL
-    database: "targetDatabase", // Target database name
-    collection: "targetCollection", // Target collection name
-  },
-};
-
-(async () => {
-  try {
-    await migrateData(sourceConfig, targetConfig);
-    console.log("Data migration completed successfully!");
-  } catch (error) {
-    console.error("Error during migration:", error);
-  }
-})();
-```
-
-# Supported Database Types and Options
-
-```json
-{
-  "type": "json",
-  "options": {
-    "filePath": "path/to/json/file.json"
-  }
-}
-```
-```json
-{
-  "type": "yaml",
-  "options": {
-    "filePath": "data.yaml"
-  }
-}
-```
-```json
-{
-  "type": "csv",
-  "options": {
-    "filePath": "data.csv"
-  }
-}
-```
-```json
-{
-  "type": "mongodb",
-  "options": {
-    "url": "mongodb://localhost:27017",
-    "database": "databaseName",
-    "collection": "collectionName"
-  }
-}
-```
-
-```json
-{
-  "type": "mysql",
-  "options": {
-    "host": "localhost:port",
-    "user": "username",
-    "password": "password",
-    "database": "databaseName"
-  }
-}
-```
-
-```json
-{
-  "type": "sqlite",
-  "options": {
-    "filePath": "path/to/sqlite/file.db"
-  }
-}
-```
-
-```json
-{
-  "type": "redis",
-  "options": {
-    "host": "127.0.0.1",
-    "port": 6379
-  }
-}
-```
-
-```json
-{
-  "type": "postgresql",
-  "options": {
-    "host": "localhost",
-    "user": "username",
-    "password": "password",
-    "database": "databaseName",
-    "port": 5432
-  }
-}
-```