@medyll/idae-db 0.1.0 → 0.3.0

package/dist/IdaeDbAdapter.d.ts

@@ -1,7 +1,7 @@
 import { DbType, type IdaeDbAdapterInterface, type IdaeDbParams } from './types.js';
 import { IdaeDbConnection } from './IdaeDbConnection.js';
 import { IdaeEventEmitter, type EventListeners } from './IdaeEventEmitter.js';
-type AdapterConstructor<T> = new (collection: string, connection: IdaeDbConnection) => IdaeDbAdapterInterface<T>;
+export type AdapterConstructor = new <T extends Document = Document>(collection: string, connection: IdaeDbConnection) => Omit<IdaeDbAdapterInterface<T>, 'connect' | 'getDb' | 'close'>;
 export declare class IdaeDbAdapter<T extends Document> extends IdaeEventEmitter {
     private dbType;
     private adapter;
@@ -11,7 +11,7 @@ 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<A>): void;
+    static addAdapter<A>(dbType: DbType, adapterConstructor: AdapterConstructor): void;
     constructor(collection: string, connection: IdaeDbConnection, dbType: DbType);
     private applyAdapter;
     /**
@@ -19,17 +19,16 @@ export declare class IdaeDbAdapter<T extends Document> extends IdaeEventEmitter
      * @param events An object containing event listeners for different operations.
      */
     registerEvents(events: EventListeners<T>): void;
-    create(data: Partial<T>): Promise<T | {
-        error: string;
-    } | import("mongodb").UpdateResult<T>>;
-    findById(id: string): Promise<T | import("chromadb").GetResponse | import("mongodb").FindCursor<import("mongodb").WithId<T>> | null>;
-    find(params: IdaeDbParams<T>): Promise<import("chromadb").QueryResponse | import("mongodb").FindCursor<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<T | string[] | import("mongodb").DeleteResult | null>;
-    deleteWhere(params: IdaeDbParams<T>): Promise<any>;
+    static getAdapterForDbType(dbType: DbType): IdaeDbAdapterInterface<T> | undefined;
+    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>;
 }
-export {};

package/dist/IdaeDbAdapter.js

@@ -8,7 +8,7 @@ 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;
+var _a, _b, _c, _d;
 import { DbType } from './types.js';
 import { IdaeDbConnection } from './IdaeDbConnection.js';
 import { MongoDBAdapter } from './adapters/MongoDBAdapter.js';
@@ -61,6 +61,9 @@ export class IdaeDbAdapter extends IdaeEventEmitter {
             }
         }
     }
+    static getAdapterForDbType(dbType) {
+        return IdaeDbAdapter.adapters.get(dbType);
+    }
     async create(data) {
         return this.adapter.create(data);
     }
@@ -85,6 +88,9 @@ export class IdaeDbAdapter extends IdaeEventEmitter {
     async deleteWhere(params) {
         return this.adapter.deleteWhere(params);
     }
+    async transaction(callback) {
+        return this.adapter.transaction(callback);
+    }
 }
 __decorate([
     withEmitter(),
@@ -134,3 +140,9 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], IdaeDbAdapter.prototype, "deleteWhere", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", typeof (_d = typeof Promise !== "undefined" && Promise) === "function" ? _d : Object)
+], IdaeDbAdapter.prototype, "transaction", null);

package/dist/IdaeDbConnection.d.ts

@@ -1,25 +1,17 @@
-import { Db } from 'mongodb';
-import type { Connection as MysqlConnection } from 'mysql2/promise';
 import { IdaeDBModel } from './IdaeDBModel.js';
 import { IdaeDb } from './idaeDb.js';
 export declare class IdaeDbConnection {
     #private;
     private _idaeDb;
     private _dbName;
-    private mongoClient;
-    private mongoDb;
-    private mysqlConnection;
-    private chromaDbConnection;
-    private models;
-    private _uri;
-    private _dbType;
     constructor(_idaeDb: IdaeDb, _dbName: string);
     connect(): Promise<IdaeDbConnection>;
-    getDb(): Db | MysqlConnection | ChromaClient;
+    getDb(): any;
     getModel: <T extends Document>(collectionName: string) => IdaeDBModel<T>;
-    private getFullDbName;
+    getClient<T>(): T;
     close(): Promise<void>;
     get dbName(): string;
     get connected(): boolean;
     get idaeDb(): IdaeDb;
+    private getFullDbName;
 }

package/dist/IdaeDbConnection.js

@@ -1,110 +1,64 @@
 // packages\idae-db\lib\IdaeDbConnection.ts
-import { MongoClient, Db } from 'mongodb';
 import { DbType } from './types.js';
 import { IdaeDBModel } from './IdaeDBModel.js';
 import { IdaeDb } from './idaeDb.js';
 export class IdaeDbConnection {
     _idaeDb;
     _dbName;
-    mongoClient = null;
-    mongoDb = null;
-    mysqlConnection = null;
-    chromaDbConnection = null;
-    models = [];
-    _uri;
-    _dbType;
+    #models = new Map();
+    #uri;
+    #dbType;
+    #Db;
+    #client;
+    #adapterClass;
     #connected = false;
     constructor(_idaeDb, _dbName) {
         this._idaeDb = _idaeDb;
         this._dbName = _dbName;
-        this._uri = _idaeDb.uri;
-        this._dbType = _idaeDb.options.dbType;
+        this.#uri = _idaeDb.uri;
+        this.#dbType = _idaeDb.options.dbType;
+        this.#adapterClass = _idaeDb.adapterClass;
         // add prefix if requested
         this._dbName = this.getFullDbName();
-        console.log('dbName', this._dbName);
     }
     async connect() {
+        if (!this.#adapterClass?.connect)
+            throw new Error('Adapter does not have a connect method');
         try {
-            switch (this._idaeDb.options.dbType) {
-                case DbType.MONGODB:
-                    this.mongoClient = new MongoClient(this._uri);
-                    await this.mongoClient.connect();
-                    this.mongoDb = this.mongoClient.db(this._dbName);
-                    console.log('Connected to MongoDB');
-                    this.#connected = true;
-                    break;
-                case DbType.MYSQL:
-                    // this.mysqlConnection = await mysql.createConnection(...);
-                    console.log('Connected to MySQL');
-                    this.#connected = false;
-                    break;
-                case DbType.CHROMADB:
-                    // this.mysqlConnection = await mysql.createConnection(...);
-                    console.log('Connected to CHROMADB');
-                    this.#connected = false;
-                    break;
-                default:
-                    this.#connected = false;
-                    throw new Error(`Unsupported database type: ${this._dbType}`);
-            }
+            this.#client = await this.#adapterClass.connect(this.#uri);
+            this.#Db = this.#adapterClass.getDb(this.#client, this._dbName);
+            this.#connected = true;
             return this;
         }
         catch (error) {
-            console.error(`Error connecting to ${this._dbType}:`, error);
+            console.error(`Error connecting to ${this.#dbType}:`, error);
             this.#connected = false;
             throw error;
         }
     }
     getDb() {
-        switch (this._dbType) {
-            case DbType.MONGODB:
-                if (!this.mongoDb) {
-                    throw new Error('MongoDB not connected. Call connect() first.');
-                }
-                return this.mongoDb;
-            case DbType.MYSQL:
-                if (!this.mysqlConnection) {
-                    throw new Error('MySQL not connected. Call connect() first.');
-                }
-                return this.mysqlConnection;
-            case DbType.CHROMADB:
-                if (!this.chromaDbConnection) {
-                    throw new Error('ChromaDb not connected. Call connect() first.');
-                }
-                return this.chromaDbConnection;
-            default:
-                throw new Error(`Unsupported database type: ${this._dbType}`);
+        if (!this.#Db) {
+            throw new Error('Db not connected. Call connect() first.');
         }
+        return this.#Db;
     }
     getModel = (collectionName) => {
-        if (this.models[collectionName]) {
-            return this.models[collectionName];
-        }
-        else {
+        if (!this.#models.has(collectionName)) {
             const model = new IdaeDBModel(this, collectionName, this._idaeDb?.options?.idaeModelOptions);
-            this.models[collectionName] = model;
-            return model;
+            this.#models.set(collectionName, model);
         }
+        return this.#models.get(collectionName);
     };
-    getFullDbName = () => [this.idaeDb.options.dbScope, this._dbName].join('_');
-    async close() {
-        switch (this._dbType) {
-            case DbType.MONGODB:
-                if (this.mongoClient) {
-                    await this.mongoClient.close(true);
-                    this.mongoClient = null;
-                    this.mongoDb = null;
-                    console.log('Disconnected from MongoDB');
-                    this.#connected = false;
-                }
-                break;
-            case DbType.MYSQL:
-                if (this.mysqlConnection) {
-                    await this.mysqlConnection.end();
-                    console.log('Disconnected from MySQL');
-                }
-                break;
+    getClient() {
+        if (!this.#client) {
+            throw new Error('Client not initialized. Call connect() first.');
         }
+        return this.#client;
+    }
+    async close() {
+        if (!this.#adapterClass?.close)
+            throw new Error('Adapter does not have a close method');
+        await this.#adapterClass?.close(this.#client);
     }
     get dbName() {
         return this._dbName;
@@ -115,4 +69,5 @@ export class IdaeDbConnection {
     get idaeDb() {
         return this._idaeDb;
     }
+    getFullDbName = () => [this.idaeDb.options.dbScope, this._dbName].join('_');
 }

package/dist/adapters/MongoDBAdapter.d.ts

@@ -1,14 +1,17 @@
 import type { IdaeDbParams, IdaeDbAdapterInterface } from '../types.js';
-import { type Document, type UpdateOptions, type IndexSpecification, type CreateIndexesOptions } from 'mongodb';
+import { type Document, type UpdateOptions, type IndexSpecification, type CreateIndexesOptions, ClientSession, MongoClient, Db } from 'mongodb';
 import { IdaeDbConnection } from '../IdaeDbConnection.js';
 export declare class MongoDBAdapter<T extends Document = Document> implements IdaeDbAdapterInterface<T> {
     private model;
     private connection;
     private fieldId;
     constructor(collection: string, connection: IdaeDbConnection);
+    static connect(uri: string): Promise<MongoClient>;
+    static getDb(client: MongoClient, dbName: string): Db;
+    static close(client: MongoClient): Promise<void>;
     createIndex(fieldOrSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
-    findById(id: string): Promise<import("mongodb").FindCursor<import("mongodb").WithId<T>>>;
-    find(params: IdaeDbParams<T>): Promise<import("mongodb").FindCursor<import("mongodb").WithId<T>>>;
+    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>>;
     update(id: string, updateData: Partial<T>, options?: UpdateOptions): Promise<import("mongodb").UpdateResult<T>>;
@@ -17,5 +20,6 @@ export declare class MongoDBAdapter<T extends Document = Document> implements Id
     deleteWhere(params: IdaeDbParams<T>): Promise<{
         deletedCount?: number;
     }>;
+    transaction<TResult>(callback: (session: ClientSession) => Promise<TResult>): Promise<TResult>;
     private parseSortOptions;
 }

package/dist/adapters/MongoDBAdapter.js

@@ -1,6 +1,6 @@
 // packages\idae-db\src\lib\adapters\MongoDBAdapter.ts
 import dotenv from 'dotenv';
-import {} from 'mongodb';
+import { ClientSession, MongoClient, Db } from 'mongodb';
 import { IdaeDbConnection } from '../IdaeDbConnection.js';
 import { IdaeDBModel } from '../IdaeDBModel.js';
 // Load environment variables
@@ -17,11 +17,24 @@ export class MongoDBAdapter {
         this.model = this.connection.getModel(collection);
         this.fieldId = this.model.fieldId;
     }
+    static async connect(uri) {
+        const client = new MongoClient(uri);
+        await client.connect();
+        return client;
+    }
+    static getDb(client, dbName) {
+        return client.db(dbName);
+    }
+    static async close(client) {
+        return client.close();
+    }
     async createIndex(fieldOrSpec, options) {
         return this.model.collection.createIndex(fieldOrSpec, options);
     }
     async findById(id) {
-        return this.model.collection.find({ [this.fieldId]: id }, { hint: this.fieldId });
+        return this.model.collection
+            .find({ [this.fieldId]: id }, { hint: this.fieldId })
+            .toArray();
     }
     async find(params) {
         const { query = {}, sortBy, limit, skip } = params;
@@ -30,7 +43,8 @@ export class MongoDBAdapter {
             .find(query)
             .sort(sortOptions)
             .limit(Number(limit) || 0)
-            .skip(Number(skip) || 0);
+            .skip(Number(skip) || 0)
+            .toArray();
     }
     async findOne(params) {
         return this.model.collection.findOne(params.query);
@@ -56,6 +70,22 @@ export class MongoDBAdapter {
         const result = await this.model.collection.deleteMany(params.query);
         return { deletedCount: result.deletedCount };
     }
+    async transaction(callback) {
+        const session = this.connection.getClient().startSession();
+        try {
+            session.startTransaction();
+            const result = await callback(session);
+            await session.commitTransaction();
+            return result;
+        }
+        catch (error) {
+            await session.abortTransaction();
+            throw error;
+        }
+        finally {
+            await session.endSession();
+        }
+    }
     parseSortOptions(sortBy) {
         const sortOptions = {};
         if (sortBy) {

package/dist/idaeDb.d.ts

@@ -47,6 +47,7 @@ export declare class IdaeDb {
     private applyEvents;
     closeConnection(): Promise<void>;
     closeAllConnections(): Promise<void>;
+    get adapterClass(): import("./types.js").IdaeDbAdapterInterface<T> | undefined;
     get connectionKey(): IdaeDbInstanceKey;
     get uri(): string;
     get options(): Options;

package/dist/idaeDb.js

@@ -6,6 +6,7 @@ export class IdaeDb {
     _uri;
     globalEvents;
     static instances = new Map();
+    #adapterClass;
     #connections = new Map();
     #connection = undefined;
     #options = {
@@ -16,6 +17,7 @@ export class IdaeDb {
     constructor(_uri, options = {}) {
         this._uri = _uri;
         this.#options = { ...this.#options, ...options };
+        this.#adapterClass = IdaeDbAdapter.getAdapterForDbType(this.options.dbType);
     }
     /**
      * Initializes or retrieves an IdaeDb instance.
@@ -94,6 +96,9 @@ export class IdaeDb {
         }
         this.#connections.clear();
     }
+    get adapterClass() {
+        return this.#adapterClass;
+    }
     get connectionKey() {
         return `${this.options.dbType}:${this._uri}`;
     }

package/dist/types.d.ts

@@ -2,7 +2,7 @@ import { type Document, type Filter, type IndexSpecification, type CreateIndexes
 export interface IdaeDbAdapterInterface<T extends Document> {
     createIndex(fieldOrSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
     create(data: Partial<T>): Promise<T>;
-    findById(id: string): 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>;
@@ -11,6 +11,10 @@ export interface IdaeDbAdapterInterface<T extends Document> {
     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;

package/package.json

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