@medyll/idae-db 0.0.1 → 0.2.0

package/dist/adapters/ChromaDBAdapter.d.ts

@@ -0,0 +1,29 @@
+import { type Document } from 'chromadb';
+import type { IdaeDbParams, IdaeDbAdapterInterface } from '../types.js';
+import { IdaeDbConnection } from '../IdaeDbConnection.js';
+export declare class ChromaDBAdapter<T extends Document = Document> implements IdaeDbAdapterInterface<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[]>;
+    deleteWhere(params: IdaeDbParams<T>): Promise<{
+        deletedCount?: number;
+    }>;
+    addItem(id: string, vector: number[], metadata?: object): Promise<{
+        error: string;
+    }>;
+    similaritySearch(vector: number[], k?: number): Promise<import("chromadb").QueryResponse>;
+}

package/dist/adapters/ChromaDBAdapter.js

@@ -0,0 +1,61 @@
+// packages/idae-db/lib/adapters/ChromaDBAdapter.ts
+import { Collection } from 'chromadb';
+import { IdaeDbConnection } from '../IdaeDbConnection.js';
+export class ChromaDBAdapter {
+    collectionName;
+    connection;
+    collection;
+    client;
+    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;
+    }
+    async create(data) {
+        const { id, vector, metadata } = data;
+        return this.collection.add(id, vector, metadata);
+    }
+    async findById(id) {
+        return this.collection.get([id]);
+    }
+    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);
+    }
+    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);
+    }
+    async updateWhere(params, updateData) {
+        throw new Error('updateWhere not supported in ChromaDB');
+    }
+    async deleteById(id) {
+        return this.collection.delete([id]);
+    }
+    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);
+    }
+    async similaritySearch(vector, k = 10) {
+        return this.collection.query(vector, k);
+    }
+}

package/dist/adapters/MongoDBAdapter.d.ts

@@ -1,20 +1,25 @@
-import type { IdaeDbParams, IdaeDbAdapter } from "../types.js";
-import { Document, type IndexSpecification, type CreateIndexesOptions } from "mongodb";
-import { IdaeDbConnection } from "../IdaeDbConnection.js";
-export declare class MongoDBAdapter<T extends Document> implements IdaeDbAdapter<T> {
+import type { IdaeDbParams, IdaeDbAdapterInterface } from '../types.js';
+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>;
-    update(id: string, updateData: Partial<T>): Promise<import("mongodb").UpdateResult<T>>;
-    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<import("mongodb").UpdateResult<T>>;
-    deleteById(id: string): Promise<import("mongodb").DeleteResult>;
+    create(data: Partial<T>): Promise<import("mongodb").UpdateResult<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>>;
+    deleteById(id: string | number): Promise<import("mongodb").DeleteResult>;
     deleteWhere(params: IdaeDbParams<T>): Promise<{
         deletedCount?: number;
     }>;
+    transaction<TResult>(callback: (session: ClientSession) => Promise<TResult>): Promise<TResult>;
     private parseSortOptions;
 }

package/dist/adapters/MongoDBAdapter.js

@@ -1,8 +1,8 @@
 // packages\idae-db\src\lib\adapters\MongoDBAdapter.ts
-import dotenv from "dotenv";
-import { Document, } from "mongodb";
-import { IdaeDbConnection } from "../IdaeDbConnection.js";
-import { IdaeDBModel } from "../IdaeDBModel.js";
+import dotenv from 'dotenv';
+import { ClientSession, MongoClient, Db } from 'mongodb';
+import { IdaeDbConnection } from '../IdaeDbConnection.js';
+import { IdaeDBModel } from '../IdaeDBModel.js';
 // Load environment variables
 dotenv.config();
 // MongoDB Adapter
@@ -12,16 +12,29 @@ export class MongoDBAdapter {
     fieldId;
     constructor(collection, connection) {
         // just in case
-        collection = collection.split(".")[1] ?? collection.split(".")[0];
+        collection = collection.split('.')[1] ?? collection.split('.')[0];
         this.connection = connection;
-        this.model = this.connection.model(collection);
+        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,35 +43,56 @@ export class MongoDBAdapter {
             .find(query)
             .sort(sortOptions)
             .limit(Number(limit) || 0)
-            .skip(Number(skip) || 0);
+            .skip(Number(skip) || 0)
+            .toArray();
     }
-    findOne(params) {
+    async findOne(params) {
         return this.model.collection.findOne(params.query);
     }
-    async update(id, updateData) {
-        return this.model.collection.updateMany({ [this.fieldId]: id }, updateData, {
-            upsert: true,
+    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
         });
     }
-    async updateWhere(params, updateData) {
-        return this.model.collection.updateMany(params.query, updateData, {
-            upsert: true,
-        });
+    async update(id, updateData, options) {
+        return this.model.collection.updateMany({ [this.fieldId]: id }, { $set: { ...updateData } }, options);
+    }
+    async updateWhere(params, updateData, options = {}) {
+        return this.model.collection.updateMany(params.query, updateData, options);
     }
     async deleteById(id) {
-        return this.model.collection.deleteMany({ _id: { $eq: id } });
+        return this.model.collection.deleteMany({ [this.fieldId]: id });
     }
     async deleteWhere(params) {
         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) {
-            const sortFields = sortBy.split(",");
+            const sortFields = sortBy.split(',');
             sortFields.forEach((field) => {
-                const [key, order] = field.split(":");
-                sortOptions[key] = order === "desc" ? -1 : 1;
+                const [key, order] = field.split(':');
+                sortOptions[key] = order === 'desc' ? -1 : 1;
             });
         }
         return sortOptions;

package/dist/adapters/MySQLAdapter.d.ts

@@ -1,21 +1,21 @@
-import type { ApiServerRequestParams } from "../server/engine/types";
-import { Model } from "sequelize";
-import type { DatabaseAdapter } from "../types";
+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 DatabaseAdapter<T> {
+export declare class MySQLAdapter<T extends MySQLDocument> implements IdaeDbAdapterInterface<T> {
     private sequelize;
     private model;
     constructor(tableName: string);
     create(document: Partial<T>): Promise<T>;
-    where(params: ApiServerRequestParams): Promise<T[]>;
+    find(params: IdaeDbParams): Promise<T[]>;
     findById(id: string): Promise<T | null>;
-    findOne(params: ApiServerRequestParams): 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: ApiServerRequestParams): Promise<{
+    deleteManyByQuery(params: IdaeDbParams): Promise<{
         deletedCount?: number;
     }>;
     private parseSortOptions;

package/dist/adapters/MySQLAdapter.js

@@ -1,41 +1,42 @@
-import { Sequelize, Model, DataTypes } from "sequelize";
-import dotenv from "dotenv";
+// packages\idae-api\src\lib\adapters\MySQLAdapter.ts
+import { Sequelize, Model, DataTypes } from 'sequelize';
+import dotenv from 'dotenv';
 dotenv.config();
 export class MySQLAdapter {
     sequelize;
     model;
     constructor(tableName) {
         this.sequelize = new Sequelize({
-            dialect: "mysql",
-            host: process.env.MYSQL_HOST || "localhost",
+            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",
+            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,
-            },
+                primaryKey: true
+            }
             // Define other fields here as needed
         }, {
             timestamps: false,
-            tableName,
+            tableName
         });
     }
     async create(document) {
         const newDocument = await this.model.create(document);
         return newDocument;
     }
-    async where(params) {
+    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,
+            offset: skip ? Number(skip) : undefined
         };
         const results = await this.model.findAll(options);
         return results;
@@ -44,7 +45,7 @@ export class MySQLAdapter {
         const result = await this.model.findByPk(id);
         return result ? result : null;
     }
-    async findOne(params) {
+    async findOne() {
         const { query = {} } = params;
         const result = await this.model.findOne({ where: query });
         return result ? result : null;
@@ -52,7 +53,14 @@ export class MySQLAdapter {
     async update(id, updateData) {
         const [affectedCount, affectedRows] = await this.model.update(updateData, {
             where: { id },
-            returning: true,
+            returning: true
+        });
+        return affectedCount > 0 ? affectedRows[0] : null;
+    }
+    async updateWhere(params, updateData) {
+        const [affectedCount, affectedRows] = await this.model.update(updateData, {
+            where: { id },
+            returning: true
         });
         return affectedCount > 0 ? affectedRows[0] : null;
     }
@@ -72,9 +80,9 @@ export class MySQLAdapter {
     parseSortOptions(sortBy) {
         if (!sortBy)
             return [];
-        return sortBy.split(",").map((field) => {
-            const [key, order] = field.split(":");
-            return [key, order === "desc" ? "DESC" : "ASC"];
+        return sortBy.split(',').map((field) => {
+            const [key, order] = field.split(':');
+            return [key, order === 'desc' ? 'DESC' : 'ASC'];
         });
     }
 }

package/dist/idaeDb.d.ts

@@ -0,0 +1,55 @@
+import { DbType } from './types.js';
+import { IdaeDbConnection } from './IdaeDbConnection.js';
+import type { IdaeModelOptions } from './IdaeDBModel.js';
+import type { Document } from 'mongodb';
+import { IdaeDbAdapter } from './IdaeDbAdapter.js';
+import type { EventListeners } from './IdaeEventEmitter.js';
+type Uri = string;
+type IdaeDbInstanceKey = `${DbType}:${Uri}`;
+type Options = {
+    dbType: DbType;
+    dbScope: string | undefined;
+    dbScopeSeparator?: string;
+    idaeModelOptions?: IdaeModelOptions;
+};
+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.
+     * @returns An IdaeDb instance.
+     */
+    static init(uri: Uri, options?: Partial<Options>): 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;
+    /**
+     * Creates a new database connection.
+     * @param dbName The name of the database.
+     * @returns A Promise resolving to an IdaeDbConnection.
+     * @throws Error if the connection already exists.
+     */
+    db(dbName: string): Promise<IdaeDbConnection>;
+    /**
+     * Gets an adapter for the current database type.
+     * @param collectionName The name of the collection or table.
+     * @returns An appropriate adapter for the database type.
+     * @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 connectionKey(): IdaeDbInstanceKey;
+    get uri(): string;
+    get options(): Options;
+}
+export {};

package/dist/idaeDb.js

@@ -0,0 +1,111 @@
+// packages\idae-db\lib\idaeDb.ts
+import { DbType } from './types.js';
+import { IdaeDbConnection } from './IdaeDbConnection.js';
+import { IdaeDbAdapter } from './IdaeDbAdapter.js';
+export class IdaeDb {
+    _uri;
+    globalEvents;
+    static instances = new Map();
+    #adapterClass;
+    #connections = new Map();
+    #connection = undefined;
+    #options = {
+        dbType: DbType.MONGODB,
+        dbScope: undefined,
+        idaeModelOptions: {}
+    };
+    constructor(_uri, options = {}) {
+        this._uri = _uri;
+        this.#options = { ...this.#options, ...options };
+        this.#adapterClass = IdaeDbAdapter.getAdapterForDbType(this.options.dbType);
+    }
+    /**
+     * Initializes or retrieves an IdaeDb instance.
+     * @param dbType The type of database.
+     * @param uri The URI of the database.
+     * @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));
+        }
+        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;
+    }
+    /**
+     * Creates a new database connection.
+     * @param dbName The name of the database.
+     * @returns A Promise resolving to an IdaeDbConnection.
+     * @throws Error if the connection already exists.
+     */
+    async db(dbName) {
+        if (this.#connections.has(this.connectionKey)) {
+            return this.#connections.get(this.connectionKey);
+        }
+        this.#connection = await new IdaeDbConnection(this, dbName).connect();
+        this.#connections.set(this.connectionKey, this.#connection);
+        return this.#connection;
+    }
+    /**
+     * Gets an adapter for the current database type.
+     * @param collectionName The name of the collection or table.
+     * @returns An appropriate adapter for the database type.
+     * @throws Error if the connection is not found or the database type is unsupported.
+     */
+    // renamed from getAdapter to collection
+    collection(collectionName) {
+        if (!this.#connection) {
+            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);
+        }
+        return adapter;
+    }
+    applyEvents(adapter, events) {
+        for (const [method, listeners] of Object.entries(events)) {
+            if (listeners.pre) {
+                adapter.on(`pre:${String(method)}`, listeners.pre);
+            }
+            if (listeners.post) {
+                adapter.on(`post:${String(method)}`, listeners.post);
+            }
+            if (listeners.error) {
+                adapter.on(`error:${String(method)}`, listeners.error);
+            }
+        }
+    }
+    async closeConnection() {
+        if (this.#connection) {
+            await this.#connection.close();
+            this.#connections.delete(this.connectionKey);
+        }
+    }
+    async closeAllConnections() {
+        for (const [connectionName, connection] of this.#connections) {
+            await connection.close();
+        }
+        this.#connections.clear();
+    }
+    get adapterClass() {
+        return this.#adapterClass;
+    }
+    get connectionKey() {
+        return `${this.options.dbType}:${this._uri}`;
+    }
+    get uri() {
+        return this._uri;
+    }
+    get options() {
+        return this.#options;
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,9 @@
 export * from './types.js';
-export * from './idaDb.js';
+export * from './idaeDb.js';
+export * from './IdaeEventEmitter.js';
 export * from './IdaeDbConnection.js';
+export * from './IdaeDbAdapter.js';
 export * from './IdaeDBModel.js';
 export * from './adapters/MySQLAdapter.js';
 export * from './adapters/MongoDBAdapter.js';
+export * from './adapters/ChromaDBAdapter.js';

package/dist/index.js

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

package/dist/types.d.ts

@@ -1,17 +1,22 @@
-import { Document, type UpdateResult, type Filter, type WithId, type FindCursor, type IndexSpecification, type CreateIndexesOptions, type DeleteResult } from "mongodb";
-export interface IdaeDbAdapter<T extends Document> {
+import { type Document, type Filter, type IndexSpecification, type CreateIndexesOptions } from 'mongodb';
+export interface IdaeDbAdapterInterface<T extends Document> {
     createIndex(fieldOrSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
-    findById(id: string): Promise<FindCursor<WithId<T>>>;
-    find(params: IdaeDbParams<T>): Promise<FindCursor<WithId<T>>>;
-    findOne(params: IdaeDbParams<T>): Promise<WithId<T> | null>;
-    update(id: string, updateData: Partial<T>): Promise<UpdateResult<T>>;
-    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<UpdateResult<T>>;
-    deleteById(id: string): Promise<DeleteResult>;
+    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> {
+export interface IdaeDbParams<T extends object = Record<string, unknown>> {
     id?: string;
     query: Filter<T>;
     sortBy?: string;
@@ -23,5 +28,6 @@ export interface IdaeDbParamsSortOptions {
 }
 export declare enum DbType {
     MONGODB = "mongodb",
-    MYSQL = "mysql"
+    MYSQL = "mysql",
+    CHROMADB = "chromaDb"
 }

package/dist/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medyll/idae-db",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "scripts": {
     "dev": "vite dev",
     "build": "vite build && npm run package",
@@ -52,5 +52,8 @@
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
-  "scope": "@medyll"
-}
+  "scope": "@medyll",
+  "dependencies": {
+    "chromadb": "^1.8.1"
+  }
+}

package/dist/idaDb.d.ts

@@ -1,17 +0,0 @@
-import { DbType } from "./types.js";
-import { IdaeDbConnection } from "./IdaeDbConnection";
-import { MongoDBAdapter } from "./adapters/MongoDBAdapter";
-import { MySQLAdapter } from "./adapters/MysqlAdapter";
-import type { Document } from "mongodb";
-export declare class IdaeDb {
-    private static instances;
-    private connections;
-    private dbType;
-    private constructor();
-    static getOrCreateInstance(dbType: DbType): IdaeDb;
-    createConnection(connectionName: string, uri: string, dbName: string): Promise<IdaeDbConnection>;
-    getConnection(connectionName: string): IdaeDbConnection;
-    getAdapter<T extends Document>(connectionName: string, collectionName: string): MongoDBAdapter<T> | MySQLAdapter<T>;
-    closeConnection(connectionName: string): Promise<void>;
-    closeAllConnections(): Promise<void>;
-}