@medyll/idae-db 0.2.0 → 0.4.0

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

@@ -0,0 +1,56 @@
+import { type Filter } from 'mongodb';
+export type IdaeDbQueryFilter<T> = Filter<T>;
+export type AdapterConstructor<CON> = new <T extends object>(collection: string, connection: CON, _constructor: () => IdaeDbAdapterInterface<T>) => Omit<IdaeDbAdapterInterface<T>, 'connect' | 'getDb' | 'close' | 'registerEvents'>;
+export interface IdaeDbAdapterInterface<T extends object> {
+    createIndex<F, O>(fieldOrSpec: F, options?: O): Promise<any>;
+    create(data: Partial<T>): Promise<T>;
+    findById(id: string): Promise<T[]>;
+    find(params: IdaeDbParams<T>): Promise<T[]>;
+    findOne(params: IdaeDbParams<T>): Promise<T | null>;
+    update(id: string, updateData: Partial<T>): Promise<any>;
+    updateWhere<OPT = any>(params: IdaeDbParams<T>, updateData: Partial<T>, options?: OPT): Promise<any>;
+    deleteById(id: string): Promise<any>;
+    deleteWhere(params: IdaeDbParams<T>): Promise<{
+        deletedCount?: number;
+    }>;
+    transaction<TResult>(callback: (session: any) => Promise<TResult>): Promise<TResult>;
+}
+export interface IdaeDbAdapterStaticMethods {
+    connect(uri: string): Promise<any>;
+    getDb(client: any, dbName: string): any;
+    close(client: any): Promise<void>;
+}
+export interface IdaeDbParams<T extends object = Record<string, unknown>> {
+    id?: string;
+    query: IdaeDbQueryFilter<T>;
+    sortBy?: string;
+    limit?: number;
+    skip?: number;
+}
+export interface IdaeDbParamsSortOptions {
+    [key: string]: 1 | -1;
+}
+export declare enum DbType {
+    MONGODB = "mongodb",
+    MYSQL = "mysql",
+    CHROMADB = "chromaDb"
+}
+export declare abstract class AbstractIdaeDbAdapter<T extends object> implements IdaeDbAdapterInterface<T> {
+    abstract createIndex(fieldOrSpec: any, options?: any): Promise<string>;
+    abstract create(data: Partial<T>): Promise<T>;
+    abstract findById(id: string): Promise<T[]>;
+    abstract find(params: IdaeDbParams<T>): Promise<T[]>;
+    abstract findOne(params: IdaeDbParams<T>): Promise<T | null>;
+    abstract update(id: string, updateData: Partial<T>): Promise<any>;
+    abstract updateWhere<OPT = any>(params: IdaeDbParams<T>, updateData: Partial<T>, options?: OPT): Promise<any>;
+    abstract deleteById(id: string): Promise<any>;
+    abstract deleteWhere(params: IdaeDbParams<T>): Promise<{
+        deletedCount?: number;
+    }>;
+    abstract transaction<TResult>(callback: (session: any) => Promise<TResult>): Promise<TResult>;
+    static connect(uri: string): Promise<any>;
+    static getDb(client: any, dbName: string): any;
+    static close(client: any): Promise<void>;
+}
+export interface IdaeDbApiMethods<T extends object> extends AbstractIdaeDbAdapter<T> {
+}

package/dist/@types/types.js

@@ -0,0 +1,19 @@
+// packages\idae-db\src\lib\adapters\types.ts
+import {} from 'mongodb';
+export var DbType;
+(function (DbType) {
+    DbType["MONGODB"] = "mongodb";
+    DbType["MYSQL"] = "mysql";
+    DbType["CHROMADB"] = "chromaDb";
+})(DbType || (DbType = {}));
+export class AbstractIdaeDbAdapter {
+    static connect(uri) {
+        throw new Error('Method not implemented.');
+    }
+    static getDb(client, dbName) {
+        throw new Error('Method not implemented.');
+    }
+    static close(client) {
+        throw new Error('Method not implemented.');
+    }
+}

package/dist/IdaeDBModel.d.ts

@@ -1,10 +1,10 @@
-import type { Collection, Document } from 'mongodb';
+import type { Collection } from 'mongodb';
 import { IdaeDbConnection } from './IdaeDbConnection.js';
 export interface IdaeModelOptions {
     autoIncrementFormat?: (collection: string) => string;
     autoIncrementDbCollection?: string;
 }
-export declare class IdaeDBModel<T extends Document> {
+export declare class IdaeDBModel<T extends object> {
     private connection;
     private _collectionName;
     private _collection;

package/dist/IdaeDbAdapter.d.ts

@@ -1,8 +1,14 @@
-import { DbType, type IdaeDbAdapterInterface, type IdaeDbParams } from './types.js';
+import { AbstractIdaeDbAdapter, DbType, type AdapterConstructor, type IdaeDbParams } from './@types/types.js';
 import { IdaeDbConnection } from './IdaeDbConnection.js';
-import { IdaeEventEmitter, type EventListeners } from './IdaeEventEmitter.js';
-export type AdapterConstructor = new <T extends Document = Document>(collection: string, connection: IdaeDbConnection) => IdaeDbAdapterInterface<T>;
-export declare class IdaeDbAdapter<T extends Document> extends IdaeEventEmitter {
+import { IdaeEventEmitter, type ErrorEventListener, type PostEventListener, type PreEventListener } from './IdaeEventEmitter.js';
+export type EventListeners<T extends object> = {
+    [K in keyof IdaeDbAdapter<T> as IdaeDbAdapter<T>[K] extends (...args: unknown[]) => unknown ? K : never]?: {
+        pre?: PreEventListener<IdaeDbAdapter<T>[K] extends (...args: infer P) => unknown ? P : never>;
+        post?: PostEventListener<IdaeDbAdapter<T>[K] extends (...args: infer P) => unknown ? P : never, IdaeDbAdapter<T>[K] extends (...args: unknown[]) => infer R ? R : never>;
+        error?: ErrorEventListener;
+    };
+};
+export declare class IdaeDbAdapter<T extends object> extends IdaeEventEmitter implements AbstractIdaeDbAdapter<T> {
     private dbType;
     private adapter;
     private static adapters;
@@ -11,26 +17,37 @@ export declare class IdaeDbAdapter<T extends Document> extends IdaeEventEmitter
      * @param dbType The type of database for this adapter.
      * @param adapterConstructor The constructor function for the adapter.
      */
-    static addAdapter<A>(dbType: DbType, adapterConstructor: AdapterConstructor): void;
+    static addAdapter<A>(dbType: DbType, adapterConstructor: new (collection: string, connection: IdaeDbConnection) => A): void;
+    /**
+     * Retrieves the adapter constructor for a specific database type.
+     * @param dbType The type of database for which to retrieve the adapter.
+     * @returns The adapter constructor for the specified database type, or undefined if not found.
+     */
+    static getAdapterForDbType(dbType: DbType): AdapterConstructor<IdaeDbConnection> | undefined;
+    /**
+     * Creates a new instance of IdaeDbAdapter.
+     * @param collection The name of the collection or table to operate on.
+     * @param connection The database connection object.
+     * @param dbType The type of database being used (e.g., MongoDB, MySQL, ChromaDB).
+     * @throws {Error} If no adapter is found for the specified database type.
+     */
     constructor(collection: string, connection: IdaeDbConnection, dbType: DbType);
-    private applyAdapter;
     /**
-     * Registers event listeners specific to this collection.
+     * Register event listeners for different operations.
      * @param events An object containing event listeners for different operations.
      */
     registerEvents(events: EventListeners<T>): void;
-    static getAdapterForDbType(dbType: DbType): AdapterConstructor | undefined;
-    create(data: Partial<T>): Promise<T | {
-        error: string;
-    } | import("mongodb").UpdateResult<T>>;
-    findById(id: string): Promise<T | import("chromadb").GetResponse | T[] | null>;
-    find(params: IdaeDbParams<T>): Promise<import("chromadb").QueryResponse | import("mongodb").WithId<T>[] | T[]>;
-    findOne(params: IdaeDbParams<T>): Promise<any>;
-    update(id: string, updateData: Partial<T>): Promise<T | {
-        error: string;
-    } | import("mongodb").UpdateResult<T> | null>;
-    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<void | T | import("mongodb").UpdateResult<T> | null>;
-    deleteById(id: string): Promise<string[] | T | import("mongodb").DeleteResult | null>;
-    deleteWhere(params: IdaeDbParams<T>): Promise<any>;
-    transaction<TResult>(callback: (session: any) => Promise<TResult>): Promise<TResult>;
+    createIndex<F, O>(fieldOrSpec: F, options?: O): Promise<any>;
+    create(data: Partial<T>): Promise<T>;
+    findById(id: string): Promise<T[]>;
+    find(params: IdaeDbParams<T>): Promise<T[]>;
+    findOne(params: IdaeDbParams<T>): Promise<T | null>;
+    update(id: string, updateData: Partial<T>): Promise<any>;
+    updateWhere<OPT = any>(params: IdaeDbParams<T>, updateData: Partial<T>, options: OPT): Promise<any>;
+    deleteById(id: string): Promise<any>;
+    deleteWhere(params: IdaeDbParams<T>): Promise<{
+        deletedCount?: number;
+    }>;
+    transaction<TResult>(callback: (session: unknown) => Promise<TResult>): Promise<TResult>;
+    private applyAdapter;
 }

package/dist/IdaeDbAdapter.js

@@ -8,8 +8,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var _a, _b, _c, _d;
-import { DbType } from './types.js';
+var _a, _b, _c, _d, _e, _f, _g;
+import { AbstractIdaeDbAdapter, DbType } from './@types/types.js';
 import { IdaeDbConnection } from './IdaeDbConnection.js';
 import { MongoDBAdapter } from './adapters/MongoDBAdapter.js';
 import { MySQLAdapter } from './adapters/MySQLAdapter.js';
@@ -32,20 +32,28 @@ export class IdaeDbAdapter extends IdaeEventEmitter {
     static addAdapter(dbType, adapterConstructor) {
         IdaeDbAdapter.adapters.set(dbType, adapterConstructor);
     }
+    /**
+     * Retrieves the adapter constructor for a specific database type.
+     * @param dbType The type of database for which to retrieve the adapter.
+     * @returns The adapter constructor for the specified database type, or undefined if not found.
+     */
+    static getAdapterForDbType(dbType) {
+        return IdaeDbAdapter.adapters.get(dbType);
+    }
+    /**
+     * Creates a new instance of IdaeDbAdapter.
+     * @param collection The name of the collection or table to operate on.
+     * @param connection The database connection object.
+     * @param dbType The type of database being used (e.g., MongoDB, MySQL, ChromaDB).
+     * @throws {Error} If no adapter is found for the specified database type.
+     */
     constructor(collection, connection, dbType) {
         super();
         this.dbType = dbType;
         this.applyAdapter(collection, connection, this.dbType);
     }
-    applyAdapter(collection, connection, dbType) {
-        const AdapterConstructor = IdaeDbAdapter.adapters.get(dbType);
-        if (!AdapterConstructor) {
-            throw new Error(`No adapter found for database type: ${dbType}`);
-        }
-        this.adapter = new AdapterConstructor(collection, connection);
-    }
     /**
-     * Registers event listeners specific to this collection.
+     * Register event listeners for different operations.
      * @param events An object containing event listeners for different operations.
      */
     registerEvents(events) {
@@ -61,8 +69,8 @@ export class IdaeDbAdapter extends IdaeEventEmitter {
             }
         }
     }
-    static getAdapterForDbType(dbType) {
-        return IdaeDbAdapter.adapters.get(dbType);
+    async createIndex(fieldOrSpec, options) {
+        return this.adapter.createIndex(fieldOrSpec, options);
     }
     async create(data) {
         return this.adapter.create(data);
@@ -79,8 +87,8 @@ export class IdaeDbAdapter extends IdaeEventEmitter {
     async update(id, updateData) {
         return this.adapter.update(id, updateData);
     }
-    async updateWhere(params, updateData) {
-        return this.adapter.updateWhere(params, updateData);
+    async updateWhere(params, updateData, options) {
+        return this.adapter.updateWhere(params, updateData, options);
     }
     async deleteById(id) {
         return this.adapter.deleteById(id);
@@ -91,11 +99,25 @@ export class IdaeDbAdapter extends IdaeEventEmitter {
     async transaction(callback) {
         return this.adapter.transaction(callback);
     }
+    applyAdapter(collection, connection, dbType) {
+        const adapterConstructor = IdaeDbAdapter.adapters.get(dbType);
+        if (!adapterConstructor) {
+            throw new Error(`No adapter found for database type : ${dbType}`);
+        }
+        /** @ts-expect-error  ---  */
+        this.adapter = new adapterConstructor(collection, connection);
+    }
 }
 __decorate([
     withEmitter(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [typeof (_a = typeof Partial !== "undefined" && Partial) === "function" ? _a : Object]),
+    __metadata("design:paramtypes", [typeof (_a = typeof F !== "undefined" && F) === "function" ? _a : Object, typeof (_b = typeof O !== "undefined" && O) === "function" ? _b : Object]),
+    __metadata("design:returntype", Promise)
+], IdaeDbAdapter.prototype, "createIndex", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_c = typeof Partial !== "undefined" && Partial) === "function" ? _c : Object]),
     __metadata("design:returntype", Promise)
 ], IdaeDbAdapter.prototype, "create", null);
 __decorate([
@@ -119,13 +141,13 @@ __decorate([
 __decorate([
     withEmitter(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, typeof (_b = typeof Partial !== "undefined" && Partial) === "function" ? _b : Object]),
+    __metadata("design:paramtypes", [String, typeof (_d = typeof Partial !== "undefined" && Partial) === "function" ? _d : Object]),
     __metadata("design:returntype", Promise)
 ], IdaeDbAdapter.prototype, "update", null);
 __decorate([
     withEmitter(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, typeof (_c = typeof Partial !== "undefined" && Partial) === "function" ? _c : Object]),
+    __metadata("design:paramtypes", [Object, typeof (_e = typeof Partial !== "undefined" && Partial) === "function" ? _e : Object, typeof (_f = typeof OPT !== "undefined" && OPT) === "function" ? _f : Object]),
     __metadata("design:returntype", Promise)
 ], IdaeDbAdapter.prototype, "updateWhere", null);
 __decorate([
@@ -144,5 +166,5 @@ __decorate([
     withEmitter(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Function]),
-    __metadata("design:returntype", typeof (_d = typeof Promise !== "undefined" && Promise) === "function" ? _d : Object)
+    __metadata("design:returntype", typeof (_g = typeof Promise !== "undefined" && Promise) === "function" ? _g : Object)
 ], IdaeDbAdapter.prototype, "transaction", null);

package/dist/IdaeDbConnection.js

@@ -1,5 +1,5 @@
 // packages\idae-db\lib\IdaeDbConnection.ts
-import { DbType } from './types.js';
+import { DbType } from './@types/types.js';
 import { IdaeDBModel } from './IdaeDBModel.js';
 import { IdaeDb } from './idaeDb.js';
 export class IdaeDbConnection {

package/dist/IdaeEventEmitter.d.ts

@@ -1,5 +1,4 @@
 import { EventEmitter } from 'events';
-import { IdaeDbAdapter } from './IdaeDbAdapter.js';
 /**
  * IdaeEventEmitter extends Node's EventEmitter to provide pre/post method hooks.
  */
@@ -20,11 +19,12 @@ export declare function withEmitter(): (target: object, propertyKey: string | sy
 /**
  * Type for pre-execution event listeners.
  */
-export type PreEventListener<T extends any[]> = (...args: T) => void | Promise<void>;
+export type PreEventListener<T extends unknown[]> = (...args: T) => void | Promise<void>;
 /**
  * Type for post-execution event listeners.
  */
-export type PostEventListener<T extends any[], R> = (result: R, ...args: T) => void | Promise<void>;
+export type PostEventListener<T extends unknown[], R> = (result: R, ...args: T) => void | Promise<void>;
+export type EventListeners<T, R> = PreEventListener<T> & PostEventListener<T, R> & ErrorEventListener;
 /**
  * Type for error event listeners.
  */
@@ -43,10 +43,3 @@ export interface TypedIdaeEventEmitter<T> {
     emit<K extends keyof T>(event: `post:${K & string}`, result: ReturnType<T[K]>, ...args: Parameters<T[K]>): boolean;
     emit<K extends keyof T>(event: `error:${K & string}`, error: Error): boolean;
 }
-export type EventListeners<T> = {
-    [K in keyof IdaeDbAdapter<T>]?: {
-        pre?: PreEventListener<Parameters<IdaeDbAdapter<T>[K]>>;
-        post?: PostEventListener<Parameters<IdaeDbAdapter<T>[K]>, ReturnType<IdaeDbAdapter<T>[K]>>;
-        error?: ErrorEventListener;
-    };
-};

package/dist/IdaeEventEmitter.js

@@ -1,5 +1,4 @@
 import { EventEmitter } from 'events';
-import { IdaeDbAdapter } from './IdaeDbAdapter.js';
 /**
  * IdaeEventEmitter extends Node's EventEmitter to provide pre/post method hooks.
  */

package/dist/adapters/ChromaDBAdapter.d.ts

@@ -1,29 +1,30 @@
-import { type Document } from 'chromadb';
-import type { IdaeDbParams, IdaeDbAdapterInterface } from '../types.js';
+import { type AddParams, type Metadata, type UpdateParams, type Documents, type Embeddings, type ID } from 'chromadb';
+import type { IdaeDbParams, AbstractIdaeDbAdapter } from '../@types/types.js';
 import { IdaeDbConnection } from '../IdaeDbConnection.js';
-export declare class ChromaDBAdapter<T extends Document = Document> implements IdaeDbAdapterInterface<T> {
+type ChromaDBAdapterContent = {
+    id: ID;
+    embeddings: Embeddings;
+    metadatas: Metadata;
+    documents: Documents;
+};
+export declare class ChromaDBAdapter<T extends ChromaDBAdapterContent> implements AbstractIdaeDbAdapter<T> {
     private collectionName;
     private connection;
     private collection;
     private client;
     constructor(collectionName: string, connection: IdaeDbConnection);
     private _init;
-    create(data: Partial<T>): Promise<{
-        error: string;
-    }>;
-    findById(id: string): Promise<import("chromadb").GetResponse>;
-    find(params: IdaeDbParams<T>): Promise<import("chromadb").QueryResponse>;
-    findOne(params: IdaeDbParams<T>): Promise<any>;
-    update(id: string, updateData: Partial<T>): Promise<{
-        error: string;
-    }>;
-    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<void>;
-    deleteById(id: string): Promise<string[]>;
+    create(data: AddParams): Promise<T>;
+    findById(id: string): Promise<T[]>;
+    find(params: IdaeDbParams<T>): Promise<T[]>;
+    findOne(params: IdaeDbParams<T>): Promise<T | null>;
+    update(id: string, updateData: UpdateParams): Promise<T>;
+    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<T[]>;
+    createIndex(field: unknown, opt: unknown): Promise<T[]>;
+    deleteById(id: string | string[]): Promise<boolean>;
     deleteWhere(params: IdaeDbParams<T>): Promise<{
-        deletedCount?: number;
-    }>;
-    addItem(id: string, vector: number[], metadata?: object): Promise<{
-        error: string;
+        deletedCount: number;
     }>;
-    similaritySearch(vector: number[], k?: number): Promise<import("chromadb").QueryResponse>;
+    similaritySearch(vector: number[], k?: number): Promise<T[]>;
 }
+export {};

package/dist/adapters/ChromaDBAdapter.js

@@ -1,4 +1,3 @@
-// packages/idae-db/lib/adapters/ChromaDBAdapter.ts
 import { Collection } from 'chromadb';
 import { IdaeDbConnection } from '../IdaeDbConnection.js';
 export class ChromaDBAdapter {
@@ -9,53 +8,64 @@ export class ChromaDBAdapter {
     constructor(collectionName, connection) {
         this.collectionName = collectionName;
         this.connection = connection;
-        this.client = this.connection.getDb(); // Assuming getDb() returns ChromaClient
-        return this._init();
-    }
-    _init() {
-        this.collection = this.client
-            .getOrCreateCollection({ name: this.collectionName })
-            .then((collection) => {
-            return collection;
-        });
-        return this;
+        this.client = this.connection.getDb();
+        this._init();
+    }
+    async _init() {
+        this.collection = await this.client.getOrCreateCollection({ name: this.collectionName });
     }
     async create(data) {
-        const { id, vector, metadata } = data;
-        return this.collection.add(id, vector, metadata);
+        const { embeddings, metadatas, documents } = data;
+        const itemId = data.ids || crypto.randomUUID();
+        await this.collection.add({
+            ids: [itemId],
+            embeddings: [embeddings],
+            metadatas: [metadatas],
+            documents: [documents]
+        });
+        return { ...data, id: itemId };
     }
     async findById(id) {
-        return this.collection.get([id]);
+        const result = await this.collection.get([id]);
+        return result;
     }
     async find(params) {
         const { query = {}, limit } = params;
-        // ChromaDB uses vector similarity search, so we need to adapt the query
-        // This is a simplified example and may need to be adjusted based on your specific use case
-        return this.collection.query(query.vector || [], limit);
+        const results = await this.collection.query(query.vector || [], limit);
+        return results;
     }
     async findOne(params) {
         const results = await this.find({ ...params, limit: 1 });
         return results.length > 0 ? results[0] : null;
     }
     async update(id, updateData) {
-        // ChromaDB doesn't have a direct update method, so we need to delete and re-add
-        await this.deleteById(id);
-        return this.collection.add(id, updateData.vector, updateData.metadata);
+        await this.collection.update(updateData);
+        return updateData;
     }
     async updateWhere(params, updateData) {
         throw new Error('updateWhere not supported in ChromaDB');
     }
+    async createIndex(field, opt) {
+        throw new Error(`updateWhere not supported in ChromaDB ${field} ${opt}`);
+    }
     async deleteById(id) {
-        return this.collection.delete([id]);
+        if (typeof id === 'string') {
+            await this.collection.delete({ ids: [id] });
+        }
+        else {
+            await this.collection.delete({ ids: id });
+        }
+        return true;
     }
     async deleteWhere(params) {
         throw new Error('deleteWhere not supported in ChromaDB');
     }
-    // Additional ChromaDB specific methods
-    async addItem(id, vector, metadata) {
-        return this.collection.add(id, vector, metadata);
-    }
+    // Specific methods for ChromaDB
+    /* 	async addItem(ids: string, vector: number[], metadata?: object): Promise<void> {
+        await this.collection.add({ ids, vector, metadata });
+    } */
     async similaritySearch(vector, k = 10) {
-        return this.collection.query(vector, k);
+        const results = await this.collection.query(vector, k);
+        return results;
     }
 }

package/dist/adapters/MongoDBAdapter.d.ts

@@ -1,7 +1,7 @@
-import type { IdaeDbParams, IdaeDbAdapterInterface } from '../types.js';
-import { type Document, type UpdateOptions, type IndexSpecification, type CreateIndexesOptions, ClientSession, MongoClient, Db } from 'mongodb';
+import { type IdaeDbParams, AbstractIdaeDbAdapter } from '../@types/types.js';
+import { type UpdateOptions, type IndexSpecification, type CreateIndexesOptions, type Document, ClientSession, MongoClient, Db } from 'mongodb';
 import { IdaeDbConnection } from '../IdaeDbConnection.js';
-export declare class MongoDBAdapter<T extends Document = Document> implements IdaeDbAdapterInterface<T> {
+export declare class MongoDBAdapter<T extends Document> implements AbstractIdaeDbAdapter<T> {
     private model;
     private connection;
     private fieldId;
@@ -11,11 +11,11 @@ export declare class MongoDBAdapter<T extends Document = Document> implements Id
     static close(client: MongoClient): Promise<void>;
     createIndex(fieldOrSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
     findById(id: string): Promise<T[]>;
-    find(params: IdaeDbParams<T>): Promise<import("mongodb").WithId<T>[]>;
-    findOne(params: IdaeDbParams<T>): Promise<import("mongodb").WithId<T> | null>;
-    create(data: Partial<T>): Promise<import("mongodb").UpdateResult<T>>;
+    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<import("mongodb").UpdateResult<T>>;
-    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>, options?: UpdateOptions): Promise<import("mongodb").UpdateResult<T>>;
+    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>, options?: any): Promise<import("mongodb").UpdateResult<T>>;
     deleteById(id: string | number): Promise<import("mongodb").DeleteResult>;
     deleteWhere(params: IdaeDbParams<T>): Promise<{
         deletedCount?: number;

package/dist/adapters/MongoDBAdapter.js

@@ -1,5 +1,6 @@
 // packages\idae-db\src\lib\adapters\MongoDBAdapter.ts
 import dotenv from 'dotenv';
+import { AbstractIdaeDbAdapter } from '../@types/types.js';
 import { ClientSession, MongoClient, Db } from 'mongodb';
 import { IdaeDbConnection } from '../IdaeDbConnection.js';
 import { IdaeDBModel } from '../IdaeDBModel.js';
@@ -16,13 +17,16 @@ export class MongoDBAdapter {
         this.connection = connection;
         this.model = this.connection.getModel(collection);
         this.fieldId = this.model.fieldId;
+        console.log('MongoDBAdapter constructor', collection);
     }
     static async connect(uri) {
+        console.log('MongoDBAdapter connect', uri);
         const client = new MongoClient(uri);
         await client.connect();
         return client;
     }
     static getDb(client, dbName) {
+        console.log('MongoDBAdapter getDb', dbName);
         return client.db(dbName);
     }
     static async close(client) {
@@ -39,23 +43,21 @@ export class MongoDBAdapter {
     async find(params) {
         const { query = {}, sortBy, limit, skip } = params;
         const sortOptions = this.parseSortOptions(sortBy);
-        return await this.model.collection
+        return (await this.model.collection
             .find(query)
             .sort(sortOptions)
             .limit(Number(limit) || 0)
             .skip(Number(skip) || 0)
-            .toArray();
+            .toArray());
     }
     async findOne(params) {
-        return this.model.collection.findOne(params.query);
+        const result = await this.model.collection.findOne(params.query);
+        return result;
     }
     async create(data) {
-        // create auto_increment
         const id = await this.model.getNextIncrement();
-        // ensure Index i set
-        return this.model.collection.updateOne({ [this.fieldId]: id }, { $set: { ...data } }, {
-            upsert: true
-        });
+        const result = await this.model.collection.findOneAndUpdate({ [this.fieldId]: id }, { $set: { ...data, [this.fieldId]: id } }, { upsert: true, returnDocument: 'after' });
+        return result.value;
     }
     async update(id, updateData, options) {
         return this.model.collection.updateMany({ [this.fieldId]: id }, { $set: { ...updateData } }, options);

package/dist/adapters/MySQLAdapter.d.ts

@@ -1,23 +1,22 @@
-import { Model } from 'sequelize';
-import type { IdaeDbAdapterInterface, IdaeDbParams } from '../types.js';
-interface MySQLDocument extends Model {
-    id: number;
-    [key: string]: any;
-}
-export declare class MySQLAdapter<T extends MySQLDocument> implements IdaeDbAdapterInterface<T> {
-    private sequelize;
+import { AbstractIdaeDbAdapter, type IdaeDbParams } from '../@types/types.js';
+import { IdaeDbConnection } from '../IdaeDbConnection.js';
+import mysql from 'mysql2/promise';
+export declare class MySQLAdapter<T extends Record<string, any>> implements AbstractIdaeDbAdapter<T> {
     private model;
-    constructor(tableName: string);
-    create(document: Partial<T>): Promise<T>;
-    find(params: IdaeDbParams): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    findOne(): Promise<T | null>;
-    update(id: string, updateData: Partial<T>): Promise<T | null>;
-    updateWhere(params: IdaeDbParams, updateData: Partial<T>): Promise<T | null>;
-    deleteById(id: string): Promise<T | null>;
-    deleteManyByQuery(params: IdaeDbParams): Promise<{
+    private connection;
+    private fieldId;
+    private tableName;
+    constructor(collection: string, connection: IdaeDbConnection);
+    findById(id: string): Promise<T[]>;
+    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?: any): Promise<any>;
+    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>, options?: any): Promise<any>;
+    deleteById(id: string | number): Promise<any>;
+    deleteWhere(params: IdaeDbParams<T>): Promise<{
         deletedCount?: number;
     }>;
+    transaction<TResult>(callback: (session: mysql.Connection) => Promise<TResult>): Promise<TResult>;
     private parseSortOptions;
 }
-export {};

package/dist/adapters/MySQLAdapter.js

@@ -1,88 +1,125 @@
-// packages\idae-api\src\lib\adapters\MySQLAdapter.ts
-import { Sequelize, Model, DataTypes } from 'sequelize';
-import dotenv from 'dotenv';
-dotenv.config();
+import { AbstractIdaeDbAdapter } from '../@types/types.js';
+import { IdaeDbConnection } from '../IdaeDbConnection.js';
+import { IdaeDBModel } from '../IdaeDBModel.js';
+import mysql from 'mysql2/promise';
 export class MySQLAdapter {
-    sequelize;
     model;
-    constructor(tableName) {
-        this.sequelize = new Sequelize({
-            dialect: 'mysql',
-            host: process.env.MYSQL_HOST || 'localhost',
-            port: Number(process.env.MYSQL_PORT) || 3306,
-            database: process.env.MYSQL_DATABASE || 'database',
-            username: process.env.MYSQL_USER || 'root',
-            password: process.env.MYSQL_PASSWORD || 'password'
-        });
-        this.model = this.sequelize.define(tableName, {
-            id: {
-                type: DataTypes.INTEGER.UNSIGNED,
-                autoIncrement: true,
-                primaryKey: true
-            }
-            // Define other fields here as needed
-        }, {
-            timestamps: false,
-            tableName
-        });
+    connection;
+    fieldId;
+    tableName;
+    constructor(collection, connection) {
+        this.connection = connection;
+        this.model = this.connection.getModel(collection);
+        this.fieldId = this.model.fieldId;
+        this.tableName = collection;
     }
-    async create(document) {
-        const newDocument = await this.model.create(document);
-        return newDocument;
+    async findById(id) {
+        const [rows] = await this.connection
+            .getClient()
+            .execute(`SELECT * FROM ${this.tableName} WHERE ${this.fieldId} = ?`, [id]);
+        return rows;
     }
     async find(params) {
         const { query = {}, sortBy, limit, skip } = params;
-        const options = {
-            where: query,
-            order: this.parseSortOptions(sortBy),
-            limit: limit ? Number(limit) : undefined,
-            offset: skip ? Number(skip) : undefined
-        };
-        const results = await this.model.findAll(options);
-        return results;
+        let sql = `SELECT * FROM ${this.tableName}`;
+        const values = [];
+        if (Object.keys(query).length > 0) {
+            sql +=
+                ' WHERE ' +
+                    Object.keys(query)
+                        .map((key) => `${key} = ?`)
+                        .join(' AND ');
+            values.push(...Object.values(query));
+        }
+        if (sortBy) {
+            sql += ' ORDER BY ' + this.parseSortOptions(sortBy);
+        }
+        if (limit) {
+            sql += ' LIMIT ?';
+            values.push(Number(limit));
+        }
+        if (skip) {
+            sql += ' OFFSET ?';
+            values.push(Number(skip));
+        }
+        const [rows] = await this.connection.getClient().execute(sql, values);
+        return rows;
     }
-    async findById(id) {
-        const result = await this.model.findByPk(id);
-        return result ? result : null;
+    async findOne(params) {
+        const results = await this.find({ ...params, limit: 1 });
+        return results[0] || null;
     }
-    async findOne() {
-        const { query = {} } = params;
-        const result = await this.model.findOne({ where: query });
-        return result ? result : null;
+    async create(data) {
+        const columns = Object.keys(data);
+        const values = Object.values(data);
+        const placeholders = columns.map(() => '?').join(', ');
+        const [result] = await this.connection
+            .getClient()
+            .execute(`INSERT INTO ${this.tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
+        const insertId = result.insertId;
+        return { ...data, [this.fieldId]: insertId };
     }
-    async update(id, updateData) {
-        const [affectedCount, affectedRows] = await this.model.update(updateData, {
-            where: { id },
-            returning: true
-        });
-        return affectedCount > 0 ? affectedRows[0] : null;
+    async update(id, updateData, options) {
+        const setClause = Object.keys(updateData)
+            .map((key) => `${key} = ?`)
+            .join(', ');
+        const values = [...Object.values(updateData), id];
+        const [result] = await this.connection
+            .getClient()
+            .execute(`UPDATE ${this.tableName} SET ${setClause} WHERE ${this.fieldId} = ?`, values);
+        return result;
     }
-    async updateWhere(params, updateData) {
-        const [affectedCount, affectedRows] = await this.model.update(updateData, {
-            where: { id },
-            returning: true
-        });
-        return affectedCount > 0 ? affectedRows[0] : null;
+    async updateWhere(params, updateData, options = {}) {
+        const { query = {} } = params;
+        const setClause = Object.keys(updateData)
+            .map((key) => `${key} = ?`)
+            .join(', ');
+        const whereClause = Object.keys(query)
+            .map((key) => `${key} = ?`)
+            .join(' AND ');
+        const values = [...Object.values(updateData), ...Object.values(query)];
+        const [result] = await this.connection
+            .getClient()
+            .execute(`UPDATE ${this.tableName} SET ${setClause} WHERE ${whereClause}`, values);
+        return result;
     }
     async deleteById(id) {
-        const result = await this.model.findByPk(id);
-        if (result) {
-            await result.destroy();
-            return result;
-        }
-        return null;
+        const [result] = await this.connection
+            .getClient()
+            .execute(`DELETE FROM ${this.tableName} WHERE ${this.fieldId} = ?`, [id]);
+        return result;
     }
-    async deleteManyByQuery(params) {
+    async deleteWhere(params) {
         const { query = {} } = params;
-        const deletedCount = await this.model.destroy({ where: query });
-        return { deletedCount };
+        const whereClause = Object.keys(query)
+            .map((key) => `${key} = ?`)
+            .join(' AND ');
+        const values = Object.values(query);
+        const [result] = await this.connection
+            .getClient()
+            .execute(`DELETE FROM ${this.tableName} WHERE ${whereClause}`, values);
+        return { deletedCount: result.affectedRows };
+    }
+    async transaction(callback) {
+        const connection = await this.connection.getClient();
+        await connection.beginTransaction();
+        try {
+            const result = await callback(connection);
+            await connection.commit();
+            return result;
+        }
+        catch (error) {
+            await connection.rollback();
+            throw error;
+        }
     }
     parseSortOptions(sortBy) {
-        if (!sortBy)
-            return [];
-        return sortBy.split(',').map((field) => {
+        return sortBy
+            .split(',')
+            .map((field) => {
             const [key, order] = field.split(':');
-            return [key, order === 'desc' ? 'DESC' : 'ASC'];
-        });
+            return `${key} ${order === 'desc' ? 'DESC' : 'ASC'}`;
+        })
+            .join(', ');
     }
 }

package/dist/idaeDb.d.ts

@@ -1,4 +1,4 @@
-import { DbType } from './types.js';
+import { DbType } from './@types/types.js';
 import { IdaeDbConnection } from './IdaeDbConnection.js';
 import type { IdaeModelOptions } from './IdaeDBModel.js';
 import type { Document } from 'mongodb';
@@ -6,7 +6,7 @@ import { IdaeDbAdapter } from './IdaeDbAdapter.js';
 import type { EventListeners } from './IdaeEventEmitter.js';
 type Uri = string;
 type IdaeDbInstanceKey = `${DbType}:${Uri}`;
-type Options = {
+export type IdaeDbOptions = {
     dbType: DbType;
     dbScope: string | undefined;
     dbScopeSeparator?: string;
@@ -15,21 +15,23 @@ type Options = {
 export declare class IdaeDb {
     #private;
     private _uri;
-    private globalEvents?;
-    private static instances;
     private constructor();
     /**
      * Initializes or retrieves an IdaeDb instance.
-     * @param dbType The type of database.
      * @param uri The URI of the database.
+     * @param options options.
+     * @param options.dbType The type of database.
+     * @param options.dbScope The scope of the database.
+     * @param options.dbScopeSeparator The separator of the database scope.
+     * @param options.idaeModelOptions The options of the IdaeDBModel.
      * @returns An IdaeDb instance.
      */
-    static init(uri: Uri, options?: Partial<Options>): IdaeDb;
+    static init(uri: Uri, options?: Partial<IdaeDbOptions>): IdaeDb;
     /**
      * Registers event listeners for all collections.
      * @param events An object containing event listeners for different operations.
      */
-    registerEvents<T extends Document>(events: EventListeners<T>): void;
+    registerEvents<T extends object, R extends object>(events: EventListeners<T, R>): void;
     /**
      * Creates a new database connection.
      * @param dbName The name of the database.
@@ -44,12 +46,11 @@ export declare class IdaeDb {
      * @throws Error if the connection is not found or the database type is unsupported.
      */
     collection<T extends Document>(collectionName: string): IdaeDbAdapter<T>;
-    private applyEvents;
     closeConnection(): Promise<void>;
     closeAllConnections(): Promise<void>;
-    get adapterClass(): import("./IdaeDbAdapter.js").AdapterConstructor | undefined;
+    get adapterClass(): import("./@types/types.js").AdapterConstructor<IdaeDbConnection> | undefined;
     get connectionKey(): IdaeDbInstanceKey;
     get uri(): string;
-    get options(): Options;
+    get options(): IdaeDbOptions;
 }
 export {};

package/dist/idaeDb.js

@@ -1,11 +1,11 @@
 // packages\idae-db\lib\idaeDb.ts
-import { DbType } from './types.js';
+import { DbType } from './@types/types.js';
 import { IdaeDbConnection } from './IdaeDbConnection.js';
 import { IdaeDbAdapter } from './IdaeDbAdapter.js';
 export class IdaeDb {
     _uri;
-    globalEvents;
-    static instances = new Map();
+    #globalEvents;
+    static #instances = new Map();
     #adapterClass;
     #connections = new Map();
     #connection = undefined;
@@ -21,24 +21,28 @@ export class IdaeDb {
     }
     /**
      * Initializes or retrieves an IdaeDb instance.
-     * @param dbType The type of database.
      * @param uri The URI of the database.
+     * @param options options.
+     * @param options.dbType The type of database.
+     * @param options.dbScope The scope of the database.
+     * @param options.dbScopeSeparator The separator of the database scope.
+     * @param options.idaeModelOptions The options of the IdaeDBModel.
      * @returns An IdaeDb instance.
      */
     static init(uri, options) {
         const dbType = options?.dbType ?? DbType.MONGODB;
         const instanceKey = `${dbType}:${uri}`;
-        if (!IdaeDb.instances.has(instanceKey)) {
-            IdaeDb.instances.set(instanceKey, new IdaeDb(uri, options));
+        if (!IdaeDb.#instances.has(instanceKey)) {
+            IdaeDb.#instances.set(instanceKey, new IdaeDb(uri, options));
         }
-        return IdaeDb.instances.get(instanceKey);
+        return IdaeDb.#instances.get(instanceKey);
     }
     /**
      * Registers event listeners for all collections.
      * @param events An object containing event listeners for different operations.
      */
     registerEvents(events) {
-        this.globalEvents = events;
+        this.#globalEvents = events;
     }
     /**
      * Creates a new database connection.
@@ -66,12 +70,12 @@ export class IdaeDb {
             throw new Error(`Connection for '${this.options.dbType}:${this._uri}' not found.`);
         }
         const adapter = new IdaeDbAdapter(collectionName, this.#connection, this.options.dbType);
-        if (this.globalEvents) {
-            this.applyEvents(adapter, this.globalEvents);
+        if (this.#globalEvents) {
+            this.#applyEvents(adapter, this.#globalEvents);
         }
         return adapter;
     }
-    applyEvents(adapter, events) {
+    #applyEvents(adapter, events) {
         for (const [method, listeners] of Object.entries(events)) {
             if (listeners.pre) {
                 adapter.on(`pre:${String(method)}`, listeners.pre);

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export * from './types.js';
 export * from './idaeDb.js';
 export * from './IdaeEventEmitter.js';
 export * from './IdaeDbConnection.js';
@@ -7,3 +6,4 @@ export * from './IdaeDBModel.js';
 export * from './adapters/MySQLAdapter.js';
 export * from './adapters/MongoDBAdapter.js';
 export * from './adapters/ChromaDBAdapter.js';
+export * from './@types/types.js';

package/dist/index.js

@@ -1,5 +1,4 @@
 // auto exports of entry components
-export * from './types.js';
 export * from './idaeDb.js';
 export * from './IdaeEventEmitter.js';
 export * from './IdaeDbConnection.js';
@@ -8,3 +7,4 @@ export * from './IdaeDBModel.js';
 export * from './adapters/MySQLAdapter.js';
 export * from './adapters/MongoDBAdapter.js';
 export * from './adapters/ChromaDBAdapter.js';
+export * from './@types/types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medyll/idae-db",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "scripts": {
     "dev": "vite dev",
     "build": "vite build && npm run package",

package/dist/types.d.ts

@@ -1,33 +0,0 @@
-import { type Document, type Filter, type IndexSpecification, type CreateIndexesOptions } from 'mongodb';
-export interface IdaeDbAdapterInterface<T extends Document> {
-    createIndex(fieldOrSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
-    create(data: Partial<T>): Promise<T>;
-    findById(id: string): Promise<T[]>;
-    find(params: IdaeDbParams<T>): Promise<T[]>;
-    findOne(params: IdaeDbParams<T>): Promise<T | null>;
-    update(id: string, updateData: Partial<T>): Promise<any>;
-    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<any>;
-    deleteById(id: string): Promise<any>;
-    deleteWhere(params: IdaeDbParams<T>): Promise<{
-        deletedCount?: number;
-    }>;
-    transaction<TResult>(callback: (session: any) => Promise<TResult>): Promise<TResult>;
-    connect(uri: string): Promise<any>;
-    getDb(client: any, dbName: string): any;
-    close(client: any): Promise<void>;
-}
-export interface IdaeDbParams<T extends object = Record<string, unknown>> {
-    id?: string;
-    query: Filter<T>;
-    sortBy?: string;
-    limit?: number;
-    skip?: number;
-}
-export interface IdaeDbParamsSortOptions {
-    [key: string]: 1 | -1;
-}
-export declare enum DbType {
-    MONGODB = "mongodb",
-    MYSQL = "mysql",
-    CHROMADB = "chromaDb"
-}

package/dist/types.js

@@ -1,8 +0,0 @@
-// packages\idae-db\src\lib\adapters\types.ts
-import {} from 'mongodb';
-export var DbType;
-(function (DbType) {
-    DbType["MONGODB"] = "mongodb";
-    DbType["MYSQL"] = "mysql";
-    DbType["CHROMADB"] = "chromaDb";
-})(DbType || (DbType = {}));