@medyll/idae-db 0.149.0 → 0.155.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 medyll
-
-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.
+MIT License
+
+Copyright (c) 2024 medyll
+
+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

@@ -1,178 +1,337 @@
-# Idae Database Library
-
-The Idae Database Library provides a flexible and extensible way to interact with various databases such as MongoDB, MySQL. It includes features like event emitters for pre/post hooks, auto-increment fields, and more.
-
-## Installation
-
-To install the library, run:
-
-```bash
-npm install idae-db
-```
-
-## Scripts
-
-```bash
-npm run test            # Run all tests
-npm run test:coverage   # Run tests with coverage (v8)
-npm run test:mongodb    # Run only the MongoDB adapter suite (in-memory mongo)
-```
-
-## Usage
-
-### Initialization
-
-First, initialize the database connection:
-
-#### MongoDB
-
-```typescript
-import { IdaeDb } from './lib/idaeDb.js';
-import { DbType } from './lib/@types/types.js';
-
-const mongoDb = IdaeDb.init('mongodb://localhost:27017', {
-    dbType: DbType.MONGODB,
-    dbScope: 'a_idae_db_sitebase',
-    dbScopeSeparator: '_',
-    idaeModelOptions: {
-        autoIncrementFormat: (collection: string) => `id${collection}`,
-        autoIncrementDbCollection: 'auto_increment'
-    }
-});
-```
-
-#### MySQL
-
-```typescript
-import { IdaeDb } from './lib/idaeDb.js';
-import { DbType } from './lib/@types/types.js';
-
-const mysqlDb = IdaeDb.init('mysql://user:password@localhost:3306', {
-    dbType: DbType.MYSQL,
-    dbScope: 'a_idae_db_sitebase',
-    dbScopeSeparator: '_',
-    idaeModelOptions: {
-        autoIncrementFormat: (collection: string) => `id${collection}`,
-        autoIncrementDbCollection: 'auto_increment'
-    }
-});
-```
-
-### Create a Connection
-
-Create a connection to the database:
-
-```typescript
-await mongoDb.db('app');
-await mysqlDb.db('app');
-```
-
-### Define a Model
-
-Define a model interface:
-
-```typescript
-interface User {
-    iduser: number;
-    name: string;
-    email: string;
-    age: number;
-}
-```
-
-### Register Event Listeners
-
-Register event listeners for various operations:
-
-```typescript
-const usersCollection = mongoDb.collection<User>('user');
-
-usersCollection.registerEvents<any>({
-    findById: {
-        pre: (id) => console.log(`About to find document with id: ${id}`),
-        post: (result, id) => console.log(`Found document for id ${id}:`, result),
-        error: (error) => console.error('Error in findById:', error)
-    },
-    update: {
-        pre: (id, data) => console.log(`About to update document ${id} with:`, data),
-        post: (result, id, data) => console.log(`Updated document ${id}:`, result)
-    },
-    create: {
-        pre: (data) => console.log(`About to create document with:`, data),
-        post: (data, result) => console.log(`Created document `, data, result)
-    }
-});
-```
-
-### CRUD Operations
-
-Perform CRUD operations:
-
-#### MongoDB
-
-```typescript
-// Create a new user
-const newUser = await usersCollection.create({
-    name: 'John Doe',
-    email: 'john@example.com',
-    age: 30
-});
-
-// Find a user by email
-const user = await usersCollection.findOne({ query: { email: 'john@example.com' } });
-
-// Update a user's age
-const updateResult = await usersCollection.update(user.iduser, { age: 31 });
-
-// Find users with age greater than 25
-const users = await usersCollection.find({
-    query: { age: { $gt: 25 } },
-    sortBy: 'name:asc',
-    limit: 10
-});
-
-// Delete a user by ID
-const deleteResult = await usersCollection.deleteById(5);
-```
-
-#### MySQL
-
-```typescript
-const usersCollection = mysqlDb.collection<User>('user');
-
-// Create a new user
-const newUser = await usersCollection.create({
-    name: 'John Doe',
-    email: 'john@example.com',
-    age: 30
-});
-
-// Find a user by email
-const user = await usersCollection.findOne({ query: { email: 'john@example.com' } });
-
-// Update a user's age
-const updateResult = await usersCollection.update(user.iduser, { age: 31 });
-
-// Find users with age greater than 25
-const users = await usersCollection.find({
-    query: { age: { $gt: 25 } },
-    sortBy: 'name:asc',
-    limit: 10
-});
-
-// Delete a user by ID
-const deleteResult = await usersCollection.deleteById(5);
-```
-
-### Close Connections
-
-Close all connections when done:
-
-```typescript
-await mongoDb.closeAllConnections();
-await mysqlDb.closeAllConnections();
-```
-
-## License
-
+# Idae Database Library
+
+**Idae Database Library** is a flexible, type-safe, event-driven database abstraction for Node.js and TypeScript. It supports MongoDB, MySQL, ChromaDB, PouchDB, SQLite, and PostgreSQL with a unified API, event hooks, and singleton connection management.
+
+## Features
+
+- **Multi-Database Support:** MongoDB, MySQL, ChromaDB, PouchDB, SQLite, PostgreSQL
+- **Event-driven CRUD:** Pre/post/error hooks on all operations
+- **Type Safety:** Full TypeScript generics, strict mode
+- **Singleton Pattern:** One connection per URI+DbType
+- **Adapter Pattern:** Easily extend to new databases
+- **Auto-increment:** Native for MongoDB, extensible for others
+- **Transaction Support:** Native in MongoDB/MySQL
+
+## Supported Adapters
+
+| DbType        | Adapter Class         | Peer Dependency |
+|-------------- |----------------------|-----------------|
+| MONGODB       | MongoDBAdapter        | mongodb         |
+| MYSQL         | MySQLAdapter          | mysql2          |
+| CHROMADB      | ChromaDBAdapter       | chromadb        |
+| POUCHDB       | PouchDBAdapter        | pouchdb         |
+| SQLITE        | SQLiteAdapter         | sqlite3         |
+| POSTGRESQL    | PostgreSQLAdapter     | pg              |
+
+## Installation
+
+Install the core library and the peer dependencies for your database(s):
+
+```bash
+pnpm add @medyll/idae-db
+# For MongoDB:
+pnpm add mongodb
+# For MySQL:
+pnpm add mysql2
+# For ChromaDB:
+pnpm add chromadb
+# For PouchDB:
+pnpm add pouchdb
+# For SQLite:
+pnpm add sqlite3
+# For PostgreSQL:
+pnpm add pg
+```
+
+## Quick Start
+
+### 1. Initialize a Database
+
+```typescript
+import { IdaeDb } from '@medyll/idae-db';
+import { DbType } from '@medyll/idae-db/lib/@types/types';
+
+const db = IdaeDb.init('mongodb://localhost:27017', {
+    dbType: DbType.MONGODB,
+    dbScope: 'app',
+});
+await db.db('app');
+```
+
+### 2. Define a Model
+
+```typescript
+interface User {
+    iduser: number;
+    name: string;
+    email: string;
+    age: number;
+}
+```
+
+### 3. CRUD Operations
+
+```typescript
+const users = db.collection<User>('user');
+const newUser = await users.create({ name: 'Alice', email: 'alice@example.com', age: 25 });
+const found = await users.findOne({ query: { email: 'alice@example.com' } });
+await users.update(found.iduser, { age: 26 });
+await users.deleteById(found.iduser);
+```
+
+### 4. Event Hooks
+
+```typescript
+users.registerEvents({
+    create: {
+        pre: (data) => console.log('Creating:', data),
+        post: (result, data) => console.log('Created:', result),
+        error: (err) => console.error(err)
+    }
+});
+```
+
+## Adapter Usage Examples
+
+### MongoDB
+
+```typescript
+const mongoDb = IdaeDb.init('mongodb://localhost:27017', { dbType: DbType.MONGODB });
+await mongoDb.db('app');
+const users = mongoDb.collection<User>('user');
+```
+
+### MySQL
+
+```typescript
+const mysqlDb = IdaeDb.init('mysql://user:password@localhost:3306', { dbType: DbType.MYSQL });
+await mysqlDb.db('app');
+const users = mysqlDb.collection<User>('user');
+```
+
+### ChromaDB
+
+```typescript
+const chromaDb = IdaeDb.init('chromadb://localhost:8000', { dbType: DbType.CHROMADB });
+await chromaDb.db('app');
+const items = chromaDb.collection<any>('item');
+```
+
+### PouchDB
+
+```typescript
+const pouchDb = IdaeDb.init('pouchdb://./my-pouchdb-folder', { dbType: DbType.POUCHDB });
+await pouchDb.db('app');
+const docs = pouchDb.collection<any>('doc');
+```
+
+### SQLite
+
+```typescript
+const sqliteDb = IdaeDb.init('sqlite://./mydb.sqlite', { dbType: DbType.SQLITE });
+await sqliteDb.db('app');
+const users = sqliteDb.collection<User>('user');
+```
+
+### PostgreSQL
+
+```typescript
+const pgDb = IdaeDb.init('postgresql://user:password@localhost:5432/mydb', { dbType: DbType.POSTGRESQL });
+await pgDb.db('app');
+const users = pgDb.collection<User>('user');
+```
+
+## Event System
+
+All CRUD methods emit `pre:method`, `post:method`, and `error:method` events. Register listeners with `registerEvents`:
+
+```typescript
+users.registerEvents({
+    create: {
+        pre: (data) => console.log('Creating:', data),
+        post: (result, data) => console.log('Created:', result),
+        error: (err) => console.error(err)
+    },
+    update: {
+        pre: (id, data) => console.log('Updating:', id, data),
+        post: (result, id, data) => console.log('Updated:', result),
+        error: (err) => console.error(err)
+    }
+});
+```
+
+## Type Safety
+
+- All models are fully typed (`T extends object`)
+- Query params: `IdaeDbParams<T>`
+- MongoDB filters: use `Filter<T>`
+- ID field: MongoDB uses `_id` or custom via `autoIncrementFormat`
+
+## Singleton & Connection Management
+
+- One instance per URI+DbType
+- Use `.closeAllConnections()` to gracefully close all DBs:
+
+```typescript
+await db.closeAllConnections();
+```
+
+## Scripts
+
+```bash
+pnpm run test            # Run all tests
+pnpm run build           # Build the package
+pnpm run lint            # Lint code
+pnpm run format          # Format code
+```
+
+## License
+
+MIT License
+import { DbType } from './lib/@types/types.js';
+
+const pouchDb = IdaeDb.init('pouchdb://./my-pouchdb-folder', {
+    dbType: DbType.POUCHDB
+});
+```
+
+#### SQLite
+
+```typescript
+import { IdaeDb } from './lib/idaeDb.js';
+import { DbType } from './lib/@types/types.js';
+
+const sqliteDb = IdaeDb.init('sqlite://./mydb.sqlite', {
+    dbType: DbType.SQLITE
+});
+```
+
+#### PostgreSQL
+
+```typescript
+import { IdaeDb } from './lib/idaeDb.js';
+import { DbType } from './lib/@types/types.js';
+
+const pgDb = IdaeDb.init('postgresql://user:password@localhost:5432/mydb', {
+    dbType: DbType.POSTGRESQL
+});
+```
+
+### Create a Connection
+
+Create a connection to the database:
+
+```typescript
+await mongoDb.db('app');
+await mysqlDb.db('app');
+```
+
+### Define a Model
+
+Define a model interface:
+
+```typescript
+interface User {
+    iduser: number;
+    name: string;
+    email: string;
+    age: number;
+}
+```
+
+### Register Event Listeners
+
+Register event listeners for various operations:
+
+```typescript
+const usersCollection = mongoDb.collection<User>('user');
+
+usersCollection.registerEvents<any>({
+    findById: {
+        pre: (id) => console.log(`About to find document with id: ${id}`),
+        post: (result, id) => console.log(`Found document for id ${id}:`, result),
+        error: (error) => console.error('Error in findById:', error)
+    },
+    update: {
+        pre: (id, data) => console.log(`About to update document ${id} with:`, data),
+        post: (result, id, data) => console.log(`Updated document ${id}:`, result)
+    },
+    create: {
+        pre: (data) => console.log(`About to create document with:`, data),
+        post: (data, result) => console.log(`Created document `, data, result)
+    }
+});
+```
+
+### CRUD Operations
+
+Perform CRUD operations:
+
+#### MongoDB
+
+```typescript
+// Create a new user
+const newUser = await usersCollection.create({
+    name: 'John Doe',
+    email: 'john@example.com',
+    age: 30
+});
+
+// Find a user by email
+const user = await usersCollection.findOne({ query: { email: 'john@example.com' } });
+
+// Update a user's age
+const updateResult = await usersCollection.update(user.iduser, { age: 31 });
+
+// Find users with age greater than 25
+const users = await usersCollection.find({
+    query: { age: { $gt: 25 } },
+    sortBy: 'name:asc',
+    limit: 10
+});
+
+// Delete a user by ID
+const deleteResult = await usersCollection.deleteById(5);
+```
+
+#### MySQL
+
+```typescript
+const usersCollection = mysqlDb.collection<User>('user');
+
+// Create a new user
+const newUser = await usersCollection.create({
+    name: 'John Doe',
+    email: 'john@example.com',
+    age: 30
+});
+
+// Find a user by email
+const user = await usersCollection.findOne({ query: { email: 'john@example.com' } });
+
+// Update a user's age
+const updateResult = await usersCollection.update(user.iduser, { age: 31 });
+
+// Find users with age greater than 25
+const users = await usersCollection.find({
+    query: { age: { $gt: 25 } },
+    sortBy: 'name:asc',
+    limit: 10
+});
+
+// Delete a user by ID
+const deleteResult = await usersCollection.deleteById(5);
+```
+
+### Close Connections
+
+Close all connections when done:
+
+```typescript
+await mongoDb.closeAllConnections();
+await mysqlDb.closeAllConnections();
+```
+
+## License
+
 This project is licensed under the MIT License.

package/cli.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+
+const pkgJson = require(path.join(__dirname, 'package.json'));
+const packageName = pkgJson.name.replace(/^@[^/]+\//, '');
+const cmd = process.argv[2];
+
+
+if (cmd === 'get-readme') {
+  const readmePath = path.join(__dirname, 'README.md');
+  if (fs.existsSync(readmePath)) {
+    const content = fs.readFileSync(readmePath, 'utf8');
+    console.log(content);
+  } else {
+    console.error('README.md not found in this package.');
+    process.exit(1);
+  }
+} else if (cmd === 'install-skill') {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const skillSrc = path.join(__dirname, 'SKILL.md');
+  const skillDest = path.resolve(__dirname, `../../../.github/skills/${packageName}/SKILL.md`);
+  if (!fs.existsSync(skillSrc)) {
+    console.error('SKILL.md not found in this package.');
+    process.exit(1);
+  }
+  rl.question(`This will copy SKILL.md to .github/skills/${packageName}/SKILL.md. Continue? (y/n): `, (answer) => {
+    if (answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes') {
+      fs.mkdirSync(path.dirname(skillDest), { recursive: true });
+      fs.copyFileSync(skillSrc, skillDest);
+      console.log(`SKILL.md installed to .github/skills/${packageName}/SKILL.md`);
+    } else {
+      console.log('Operation cancelled.');
+    }
+    rl.close();
+  });
+} else {
+  console.log('Usage: <cli> get-readme | install-skill');
+  process.exit(1);
+}

package/dist/@types/pg.d.ts

@@ -0,0 +1 @@
+declare module 'pg';

package/dist/@types/types.d.ts

@@ -33,7 +33,10 @@ export interface IdaeDbParamsSortOptions {
 export declare enum DbType {
     MONGODB = "mongodb",
     MYSQL = "mysql",
-    CHROMADB = "chromaDb"
+    CHROMADB = "chromaDb",
+    POUCHDB = "pouchdb",
+    SQLITE = "sqlite",
+    POSTGRESQL = "postgresql"
 }
 export declare abstract class AbstractIdaeDbAdapter<T extends object> implements IdaeDbAdapterInterface<T> {
     abstract createIndex(fieldOrSpec: unknown, options?: unknown): Promise<string>;

package/dist/@types/types.js

@@ -5,6 +5,9 @@ export var DbType;
     DbType["MONGODB"] = "mongodb";
     DbType["MYSQL"] = "mysql";
     DbType["CHROMADB"] = "chromaDb";
+    DbType["POUCHDB"] = "pouchdb";
+    DbType["SQLITE"] = "sqlite";
+    DbType["POSTGRESQL"] = "postgresql";
 })(DbType || (DbType = {}));
 export class AbstractIdaeDbAdapter {
     static connect(uri) {

package/dist/IdaeDbAdapter.js

@@ -14,6 +14,9 @@ import { IdaeDbConnection } from './IdaeDbConnection.js';
 import { MongoDBAdapter } from './adapters/MongoDBAdapter.js';
 import { MySQLAdapter } from './adapters/MySQLAdapter.js';
 import { ChromaDBAdapter } from './adapters/ChromaDBAdapter.js';
+import { PouchDBAdapter } from './adapters/PouchDBAdapter.js';
+import { SQLiteAdapter } from './adapters/SQLiteAdapter.js';
+import { PostgreSQLAdapter } from './adapters/PostgreSQLAdapter.js';
 import { IdaeEventEmitter, withEmitter } from './IdaeEventEmitter.js';
 /**
  * IdaeDbAdapter class that extends IdaeEventEmitter and implements AbstractIdaeDbAdapter.
@@ -26,6 +29,9 @@ export class IdaeDbAdapter extends IdaeEventEmitter {
         IdaeDbAdapter.addAdapter(DbType.MONGODB, MongoDBAdapter);
         IdaeDbAdapter.addAdapter(DbType.MYSQL, MySQLAdapter);
         IdaeDbAdapter.addAdapter(DbType.CHROMADB, ChromaDBAdapter);
+        IdaeDbAdapter.addAdapter(DbType.POUCHDB, PouchDBAdapter);
+        IdaeDbAdapter.addAdapter(DbType.SQLITE, SQLiteAdapter);
+        IdaeDbAdapter.addAdapter(DbType.POSTGRESQL, PostgreSQLAdapter);
     }
     /**
      * Adds a new adapter for a specific database type.

package/dist/adapters/MongoDBAdapter.d.ts

@@ -14,9 +14,9 @@ export declare class MongoDBAdapter<T extends Document> implements AbstractIdaeD
     find(params: IdaeDbParams<T>): Promise<T[]>;
     findOne(params: IdaeDbParams<T>): Promise<T | null>;
     create(data: Partial<T>): Promise<T>;
-    update(id: string, updateData: Partial<T>, options?: UpdateOptions): Promise<any>;
-    updateWhere<OPT = never>(params: IdaeDbParams<T>, updateData: Partial<T>, options?: OPT): Promise<any>;
-    deleteById(id: string | number): Promise<any>;
+    update(id: string, updateData: Partial<T>, options?: UpdateOptions): Promise<import("mongodb").UpdateResult<T>>;
+    updateWhere<OPT = never>(params: IdaeDbParams<T>, updateData: Partial<T>, options?: OPT): Promise<import("mongodb").UpdateResult<T>>;
+    deleteById(id: string | number): Promise<import("mongodb").DeleteResult>;
     deleteWhere(params: IdaeDbParams<T>): Promise<{
         deletedCount?: number;
     }>;

package/dist/adapters/PostgreSQLAdapter.d.ts

@@ -0,0 +1,22 @@
+import type { IdaeDbAdapterInterface, IdaeDbParams } from '../@types/types';
+export declare class PostgreSQLAdapter<T extends object> implements IdaeDbAdapterInterface<T> {
+    private client;
+    private table;
+    private idField;
+    constructor(collection: string, connection: any);
+    static connect(uri: string, options?: any): Promise<any>;
+    static getDb(connection: any, dbName: string): Promise<any>;
+    static close(connection: any): Promise<void>;
+    create(data: Partial<T>): Promise<T>;
+    find(params?: IdaeDbParams<T>): Promise<T[]>;
+    findOne(params: IdaeDbParams<T>): Promise<T | null>;
+    update(id: string, data: Partial<T>): Promise<T | null>;
+    deleteById(id: string): Promise<boolean>;
+    transaction<TResult>(callback: (session: unknown) => Promise<TResult>): Promise<TResult>;
+    createIndex<F, O>(fieldOrSpec: F, options?: O): Promise<unknown>;
+    findById(id: string): Promise<T[]>;
+    updateWhere<OPT = never>(params: IdaeDbParams<T>, updateData: Partial<T>, options?: OPT): Promise<unknown>;
+    deleteWhere(params: IdaeDbParams<T>): Promise<{
+        deletedCount?: number;
+    }>;
+}

package/dist/adapters/PostgreSQLAdapter.js

@@ -0,0 +1,127 @@
+import { Client } from 'pg';
+export class PostgreSQLAdapter {
+    client;
+    table;
+    idField;
+    constructor(collection, connection) {
+        // connection est un IdaeDbConnection, on récupère la vraie connexion
+        this.client = connection.getDb();
+        this.table = collection;
+        this.idField = 'id';
+    }
+    static async connect(uri, options) {
+        const client = new Client({ connectionString: uri, ...options });
+        await client.connect();
+        return client;
+    }
+    static async getDb(connection, dbName) {
+        // PostgreSQL: pas de notion de dbName, retourne la connexion
+        return connection;
+    }
+    static async close(connection) {
+        await connection.end();
+    }
+    async create(data) {
+        const keys = Object.keys(data);
+        const values = keys.map((k) => data[k]);
+        const placeholders = keys.map((_, i) => `$${i + 1}`).join(',');
+        const sql = `INSERT INTO ${this.table} (${keys.join(',')}) VALUES (${placeholders}) RETURNING *`;
+        const result = await this.client.query(sql, values);
+        return result.rows[0];
+    }
+    async find(params) {
+        const { query = {}, limit, sortBy } = params || {};
+        let sql = `SELECT * FROM ${this.table}`;
+        const where = [];
+        const values = [];
+        let idx = 1;
+        for (const k in query) {
+            where.push(`${k} = $${idx}`);
+            values.push(query[k]);
+            idx++;
+        }
+        if (where.length)
+            sql += ' WHERE ' + where.join(' AND ');
+        if (sortBy)
+            sql += ` ORDER BY ${sortBy}`;
+        if (limit)
+            sql += ` LIMIT ${limit}`;
+        const result = await this.client.query(sql, values);
+        return result.rows;
+    }
+    async findOne(params) {
+        const results = await this.find({ ...params, limit: 1 });
+        return results[0] || null;
+    }
+    async update(id, data) {
+        const keys = Object.keys(data);
+        const values = keys.map((k) => data[k]);
+        const set = keys.map((k, i) => `${k} = $${i + 1}`).join(', ');
+        const sql = `UPDATE ${this.table} SET ${set} WHERE ${this.idField} = $${keys.length + 1} RETURNING *`;
+        const result = await this.client.query(sql, [...values, id]);
+        return result.rows[0];
+    }
+    async deleteById(id) {
+        const sql = `DELETE FROM ${this.table} WHERE ${this.idField} = $1`;
+        const result = await this.client.query(sql, [id]);
+        return result.rowCount > 0;
+    }
+    async transaction(callback) {
+        await this.client.query('BEGIN');
+        try {
+            // PostgreSQL n'expose pas de session explicite, on passe undefined
+            const result = await callback(undefined);
+            await this.client.query('COMMIT');
+            return result;
+        }
+        catch (e) {
+            await this.client.query('ROLLBACK');
+            throw e;
+        }
+    }
+    async createIndex(fieldOrSpec, options) {
+        // Not implemented for PostgreSQL (no-op)
+        return Promise.resolve();
+    }
+    async findById(id) {
+        const sql = `SELECT * FROM ${this.table} WHERE ${this.idField} = $1`;
+        const result = await this.client.query(sql, [id]);
+        return result.rows;
+    }
+    async updateWhere(params, updateData, options) {
+        // Simple implementation: update all matching rows
+        const { query = {} } = params;
+        const keys = Object.keys(updateData);
+        const values = keys.map((k) => updateData[k]);
+        const set = keys.map((k, i) => `${k} = $${i + 1}`).join(', ');
+        const where = [];
+        const whereValues = [];
+        let idx = keys.length + 1;
+        for (const k in query) {
+            where.push(`${k} = $${idx}`);
+            whereValues.push(query[k]);
+            idx++;
+        }
+        let sql = `UPDATE ${this.table} SET ${set}`;
+        if (where.length)
+            sql += ' WHERE ' + where.join(' AND ');
+        const result = await this.client.query(sql, [...values, ...whereValues]);
+        return { rowCount: result.rowCount };
+    }
+    async deleteWhere(params) {
+        const { query = {} } = params;
+        const where = [];
+        const values = [];
+        let idx = 1;
+        for (const k in query) {
+            where.push(`${k} = $${idx}`);
+            values.push(query[k]);
+            idx++;
+        }
+        let sql = `DELETE FROM ${this.table}`;
+        if (where.length)
+            sql += ' WHERE ' + where.join(' AND ');
+        const result = await this.client.query(sql, values);
+        return { deletedCount: result.rowCount };
+    }
+}

package/dist/adapters/PouchDBAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { IdaiDbAdapterInterface, IdaeDbParams } from '../@types/types';
+export declare class PouchDBAdapter<T extends object> implements IdaiDbAdapterInterface<T> {
+    private db;
+    constructor(collection: string, connection: any);
+    static connect(uri: string, options?: any): Promise<any>;
+    static getDb(connection: any, dbName: string): Promise<any>;
+    static close(connection: any): Promise<void>;
+    create(data: Partial<T>): Promise<T>;
+    find(params?: IdaeDbParams<T>): Promise<T[]>;
+    findOne(params: IdaeDbParams<T>): Promise<T | null>;
+    update(id: string, data: Partial<T>): Promise<T | null>;
+    deleteById(id: string): Promise<boolean>;
+    transaction(fn: () => Promise<any>): Promise<any>;
+}

package/dist/adapters/PouchDBAdapter.js

@@ -0,0 +1,62 @@
+import PouchDB from 'pouchdb';
+export class PouchDBAdapter {
+    db;
+    constructor(collection, connection) {
+        // connection est un IdaeDbConnection, on récupère la vraie connexion
+        this.db = connection.getDb();
+    }
+    static async connect(uri, options) {
+        // uri: pouchdb://./folder or pouchdb://memory
+        let dbPath = uri.replace(/^pouchdb:\/\//, '');
+        if (!dbPath)
+            dbPath = 'idae-pouchdb';
+        return new PouchDB(dbPath, options);
+    }
+    static async getDb(connection, dbName) {
+        // PouchDB does not use dbName, just return the connection
+        return connection;
+    }
+    static async close(connection) {
+        await connection.close();
+    }
+    async create(data) {
+        const doc = { ...data };
+        const result = await this.db.post(doc);
+        return { ...doc, _id: result.id, _rev: result.rev };
+    }
+    async find(params) {
+        // Only supports simple query for now
+        const { query = {}, limit, sortBy } = params || {};
+        const result = await this.db.find({ selector: query, limit });
+        return result.docs;
+    }
+    async findOne(params) {
+        const docs = await this.find({ ...params, limit: 1 });
+        return docs[0] || null;
+    }
+    async update(id, data) {
+        try {
+            const doc = await this.db.get(id);
+            const updated = { ...doc, ...data };
+            const result = await this.db.put(updated);
+            return { ...updated, _rev: result.rev };
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async deleteById(id) {
+        try {
+            const doc = await this.db.get(id);
+            await this.db.remove(doc);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async transaction(fn) {
+        // PouchDB natively does not support transactions
+        return fn();
+    }
+}

package/dist/adapters/SQLiteAdapter.d.ts

@@ -0,0 +1,17 @@
+import type { IdaiDbAdapterInterface, IdaeDbParams } from '../@types/types';
+import sqlite3 from 'sqlite3';
+export declare class SQLiteAdapter<T extends object> implements IdaiDbAdapterInterface<T> {
+    private db;
+    private table;
+    private idField;
+    constructor(collection: string, connection: any);
+    static connect(uri: string, options?: any): Promise<sqlite3.Database>;
+    static getDb(connection: sqlite3.Database, dbName: string): Promise<sqlite3.Database>;
+    static close(connection: sqlite3.Database): Promise<void>;
+    create(data: Partial<T>): Promise<T>;
+    find(params?: IdaeDbParams<T>): Promise<T[]>;
+    findOne(params: IdaeDbParams<T>): Promise<T | null>;
+    update(id: string, data: Partial<T>): Promise<T | null>;
+    deleteById(id: string): Promise<boolean>;
+    transaction(fn: () => Promise<any>): Promise<any>;
+}

package/dist/adapters/SQLiteAdapter.js

@@ -0,0 +1,113 @@
+import sqlite3 from 'sqlite3';
+export class SQLiteAdapter {
+    db;
+    table;
+    idField;
+    constructor(collection, connection) {
+        // connection est un IdaeDbConnection, on récupère la vraie connexion
+        this.db = connection.getDb();
+        this.table = collection;
+        this.idField = 'id';
+    }
+    static async connect(uri, options) {
+        // uri: sqlite://./mydb.sqlite
+        const dbPath = uri.replace(/^sqlite:\/\//, '');
+        return new Promise((resolve, reject) => {
+            const db = new sqlite3.Database(dbPath, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(db);
+            });
+        });
+    }
+    static async getDb(connection, dbName) {
+        // SQLite: pas de notion de dbName, retourne la connexion
+        return connection;
+    }
+    static async close(connection) {
+        return new Promise((resolve, reject) => {
+            connection.close((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    async create(data) {
+        const keys = Object.keys(data);
+        const values = keys.map((k) => data[k]);
+        const placeholders = keys.map(() => '?').join(',');
+        const sql = `INSERT INTO ${this.table} (${keys.join(',')}) VALUES (${placeholders})`;
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, values, function (err) {
+                if (err)
+                    return reject(err);
+                resolve({ ...data, id: this.lastID });
+            });
+        });
+    }
+    async find(params) {
+        const { query = {}, limit, sortBy } = params || {};
+        let sql = `SELECT * FROM ${this.table}`;
+        const where = [];
+        const values = [];
+        for (const k in query) {
+            where.push(`${k} = ?`);
+            values.push(query[k]);
+        }
+        if (where.length)
+            sql += ' WHERE ' + where.join(' AND ');
+        if (sortBy)
+            sql += ` ORDER BY ${sortBy}`;
+        if (limit)
+            sql += ` LIMIT ${limit}`;
+        return new Promise((resolve, reject) => {
+            this.db.all(sql, values, (err, rows) => {
+                if (err)
+                    return reject(err);
+                resolve(rows);
+            });
+        });
+    }
+    async findOne(params) {
+        const results = await this.find({ ...params, limit: 1 });
+        return results[0] || null;
+    }
+    async update(id, data) {
+        const keys = Object.keys(data);
+        const values = keys.map((k) => data[k]);
+        const sql = `UPDATE ${this.table} SET ${keys.map((k) => `${k} = ?`).join(',')} WHERE ${this.idField} = ?`;
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, [...values, id], function (err) {
+                if (err)
+                    return reject(err);
+                resolve({ ...data, id });
+            });
+        });
+    }
+    async deleteById(id) {
+        const sql = `DELETE FROM ${this.table} WHERE ${this.idField} = ?`;
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, [id], function (err) {
+                if (err)
+                    return reject(err);
+                resolve(this.changes > 0);
+            });
+        });
+    }
+    async transaction(fn) {
+        await new Promise((resolve, reject) => {
+            this.db.run('BEGIN TRANSACTION', (err) => (err ? reject(err) : resolve(null)));
+        });
+        try {
+            const result = await fn();
+            await new Promise((resolve, reject) => {
+                this.db.run('COMMIT', (err) => (err ? reject(err) : resolve(null)));
+            });
+            return result;
+        }
+        catch (e) {
+            await new Promise((resolve, reject) => {
+                this.db.run('ROLLBACK', (err) => (err ? reject(err) : resolve(null)));
+            });
+            throw e;
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,8 +1,11 @@
-export * from './idaeDb.js';
 export * from './IdaeEventEmitter.js';
+export * from './IdaeDBModel.js';
 export * from './IdaeDbConnection.js';
 export * from './IdaeDbAdapter.js';
-export * from './IdaeDBModel.js';
+export * from './idaeDb.js';
+export * from './adapters/SQLiteAdapter.js';
+export * from './adapters/PouchDBAdapter.js';
+export * from './adapters/PostgreSQLAdapter.js';
 export * from './adapters/MySQLAdapter.js';
 export * from './adapters/MongoDBAdapter.js';
 export * from './adapters/ChromaDBAdapter.js';

package/dist/index.js

@@ -1,9 +1,12 @@
 // auto exports of entry components
-export * from './idaeDb.js';
 export * from './IdaeEventEmitter.js';
+export * from './IdaeDBModel.js';
 export * from './IdaeDbConnection.js';
 export * from './IdaeDbAdapter.js';
-export * from './IdaeDBModel.js';
+export * from './idaeDb.js';
+export * from './adapters/SQLiteAdapter.js';
+export * from './adapters/PouchDBAdapter.js';
+export * from './adapters/PostgreSQLAdapter.js';
 export * from './adapters/MySQLAdapter.js';
 export * from './adapters/MongoDBAdapter.js';
 export * from './adapters/ChromaDBAdapter.js';

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "@medyll/idae-db",
-  "version": "0.149.0",
+  "bin": {
+    "idae-db": "./cli.js"
+  },
+  "version": "0.155.2",
+  "author": "Lebrun Meddy",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/medyll/idae.git"
+  },
   "description": "@medyll/idae-db is a flexible and powerful library for interacting with various databases, with a particular focus on MongoDB support. It offers robust connection management, an intuitive API, and simplified CRUD operations.",
   "exports": {
     ".": {
@@ -15,38 +23,53 @@
     "!dist/**/*.spec.*"
   ],
   "peerDependencies": {
+    "pg": ">=8.0.0",
+    "pouchdb": ">=8.0.0",
+    "sqlite3": ">=5.1.0",
     "svelte": "^5.0.0-next"
   },
+  "publishConfig": {
+    "access": "public",
+    "directory": "."
+  },
   "devDependencies": {
+    "@semantic-release/github": "^10.3.5",
     "@sveltejs/adapter-auto": "^6.0.0",
     "@sveltejs/kit": "^2.20.7",
     "@sveltejs/package": "^2.3.11",
     "@sveltejs/vite-plugin-svelte": "^5.0.3",
     "@types/eslint": "^9.6.1",
+    "@types/pouchdb": "^6.4.2",
     "@vitest/coverage-v8": "^3.1.1",
     "eslint": "^9.25.0",
     "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-svelte": "^3.5.1",
     "globals": "^16.0.0",
     "mongodb-memory-server": "^10.1.4",
+    "pg": "^8.17.2",
+    "pouchdb-adapter-memory": "^9.0.0",
+    "pouchdb-find": "^9.0.0",
     "prettier": "^3.5.3",
     "prettier-plugin-svelte": "^3.3.3",
     "publint": "^0.3.12",
+    "sqlite3": "^5.1.7",
     "svelte": "^5.28.1",
     "svelte-check": "^4.1.6",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.30.1",
     "vite": "^6.3.2",
     "vitest": "^3.1.1",
-    "@medyll/idae-prettier-config": "1.2.1",
-    "@medyll/idae-query": "0.180.0"
+    "@medyll/idae-query": "0.186.2",
+    "@medyll/idae-eslint-config": "0.1.5"
   },
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "scope": "@medyll",
   "dependencies": {
-    "chromadb": "^2.2.1"
+    "chromadb": "^2.2.1",
+    "mongodb": "^7.0.0",
+    "mysql2": "^3.16.0"
   },
   "scripts": {
     "dev": "vite dev",
@@ -61,6 +84,6 @@
     "test:watch": "vitest --watch",
     "lint": "prettier --check . && eslint .",
     "format": "prettier --write .",
-    "package:pre": "node scripts/package-pre.js"
+    "prepackage": "node scripts/package-pre.js"
   }
 }