@medyll/idae-db 0.0.1 → 0.2.0

package/README.md

@@ -1,58 +1,102 @@
-# create-svelte
 
-Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+# @medyll/idae-db
 
-Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).
+@medyll/idae-db is a flexible and powerful library for interacting with various databases, with a particular focus on MongoDB support.
 
-## Creating a project
-
-If you're seeing this, you've probably already done this step. Congrats!
+## Installation
 
 ```bash
-# create a new project in the current directory
-npm create svelte@latest
-
-# create a new project in my-app
-npm create svelte@latest my-app
+npm install @medyll/idae-db
 ```
 
-## Developing
+## Key Features
 
-Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+- Robust support for MongoDB
+- Unified interface for different types of databases
+- Efficient connection management
+- Intuitive and flexible API
 
-```bash
-npm run dev
+## Quick Start with MongoDB
 
-# or start the server and open the app in a new browser tab
-npm run dev -- --open
-```
+```typescript
+import { IdaeDb, DbType } from '@medyll/idae-db';
 
-Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+async function main() {
+  // Initialize MongoDB connection
+  const mongoDb = IdaeDb.init('mongodb://localhost:27017', {
+    dbType: DbType.MONGODB,
+    dbScope: 'myapp_'
+  });
 
-## Building
+  // Create a connection
+  await mongoDb.db('example_db');
 
-To build your library:
+  // Use the 'users' collection
+  const usersCollection = mongoDb.collection('users');
 
-```bash
-npm run package
-```
+  // Insert a document
+  await usersCollection.update('user1', {
+    name: 'John Doe',
+    email: 'john@example.com',
+    age: 30
+  });
 
-To create a production version of your showcase app:
+  // Find a document
+  const user = await usersCollection.findOne({ query: { email: 'john@example.com' } });
+  console.log('Found user:', user);
 
-```bash
-npm run build
+  // Close the connection
+  await mongoDb.closeConnection();
+}
+
+main().catch(console.error);
 ```
 
-You can preview the production build with `npm run preview`.
+## MongoDB Features
+
+- Easy creation and management of connections
+- Simplified CRUD operations
+- Support for complex queries
+- Index management
+- Transactions (coming soon)
+
+## Advanced Configuration
+
+```typescript
+const mongoDb = IdaeDb.init('mongodb://localhost:27017', {
+  dbType: DbType.MONGODB,
+  dbScope: 'myapp_',
+  dbScopeSeparator: '_',
+  idaeModelOptions: {
+    // Model-specific options
+  }
+});
+```
 
-> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
+## MongoDB API
 
-## Publishing
+- `collection(name: string)`: Access a MongoDB collection
+- `find(params)`: Search for documents
+- `findOne(params)`: Find a single document
+- `update(id, data)`: Update a document
+- `deleteById(id)`: Delete a document by ID
+- `createIndex(fieldOrSpec, options)`: Create an index on the collection
 
-Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+## Connection Management
 
-To publish your library to [npm](https://www.npmjs.com):
+- Efficiently managed multiple connections
+- Automatic closure of connections
 
-```bash
-npm publish
-```
+## Roadmap
+
+- Enhanced support for other databases (MySQL, ChromaDB)
+- Advanced features for MongoDB (aggregations, watch)
+- Performance optimizations
+
+## Contribution
+
+Contributions are welcome! Feel free to open issues or submit pull requests.
+
+## License
+
+MIT

package/dist/IdaeDBModel.d.ts

@@ -1,12 +1,19 @@
-import { Collection, Document } from "mongodb";
-import { IdaeDbConnection } from "./IdaeDbConnection";
+import type { Collection, Document } from 'mongodb';
+import { IdaeDbConnection } from './IdaeDbConnection.js';
+export interface IdaeModelOptions {
+    autoIncrementFormat?: (collection: string) => string;
+    autoIncrementDbCollection?: string;
+}
 export declare class IdaeDBModel<T extends Document> {
+    private connection;
+    private _collectionName;
     private _collection;
     private _autoIncrementField;
+    private _autoIncrementDbCollection;
     private _fieldId;
-    constructor(connection: IdaeDbConnection, collectionName: string, options?: {
-        autoIncrementFormat?: (collection: string) => string;
-    });
+    constructor(connection: IdaeDbConnection, _collectionName: string, options?: Partial<IdaeModelOptions>);
     get collection(): Collection<T>;
-    get fieldId(): string | undefined;
+    get collectionName(): string;
+    get fieldId(): string;
+    getNextIncrement(): Promise<any>;
 }

package/dist/IdaeDBModel.js

@@ -1,19 +1,38 @@
-// packages\idae-db\lib\IdaeDBModel.ts
-import { Collection, Document } from "mongodb";
-import { IdaeDbConnection } from "./IdaeDbConnection";
+import { IdaeDbConnection } from './IdaeDbConnection.js';
+import { IdaeDb } from './idaeDb.js';
+// models are attached to a connection
 export class IdaeDBModel {
+    connection;
+    _collectionName;
     _collection;
     _autoIncrementField = undefined;
-    _fieldId = "_id";
-    constructor(connection, collectionName, options) {
-        this._collection = connection.getDb().collection(collectionName);
-        this._autoIncrementField = options?.autoIncrementFormat?.(collectionName);
-        this._fieldId = this._autoIncrementField ?? "_id";
+    _autoIncrementDbCollection = undefined;
+    _fieldId = '_id';
+    constructor(connection, _collectionName, options) {
+        this.connection = connection;
+        this._collectionName = _collectionName;
+        this._collection = this.connection.getDb().collection(_collectionName);
+        this._autoIncrementField = options?.autoIncrementFormat?.(_collectionName);
+        this._autoIncrementDbCollection = options?.autoIncrementDbCollection ?? 'auto_increment';
+        this._fieldId = this._autoIncrementField ?? '_id';
     }
     get collection() {
         return this._collection;
     }
+    get collectionName() {
+        return this._collectionName;
+    }
     get fieldId() {
         return this._fieldId;
     }
+    async getNextIncrement() {
+        const idaeAuto = IdaeDb.init(this.connection.idaeDb.uri, this.connection.idaeDb.options);
+        const increment_name = 'increment';
+        await idaeAuto.db(increment_name);
+        const incrementCollection = idaeAuto.collection(this._autoIncrementDbCollection);
+        // await incrementCollection.createIndex({ _id: 1 }, { unique: true });
+        await incrementCollection.updateWhere({ query: { _id: this.fieldId } }, { $inc: { value: 1 } }, { upsert: true });
+        const next = await incrementCollection.findOne({ query: { _id: this.fieldId } });
+        return next?.value;
+    }
 }

package/dist/IdaeDbAdapter.d.ts

@@ -0,0 +1,36 @@
+import { DbType, type IdaeDbAdapterInterface, type IdaeDbParams } from './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 {
+    private dbType;
+    private adapter;
+    private static adapters;
+    /**
+     * Adds a new adapter for a specific database type.
+     * @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;
+    constructor(collection: string, connection: IdaeDbConnection, dbType: DbType);
+    private applyAdapter;
+    /**
+     * Registers event listeners specific to this collection.
+     * @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>;
+}

package/dist/IdaeDbAdapter.js

@@ -0,0 +1,148 @@
+// lib/IdaeDbAdapter.ts
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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';
+import { IdaeDbConnection } from './IdaeDbConnection.js';
+import { MongoDBAdapter } from './adapters/MongoDBAdapter.js';
+import { MySQLAdapter } from './adapters/MySQLAdapter.js';
+import { ChromaDBAdapter } from './adapters/ChromaDBAdapter.js';
+import { IdaeEventEmitter, withEmitter } from './IdaeEventEmitter.js';
+export class IdaeDbAdapter extends IdaeEventEmitter {
+    dbType;
+    adapter;
+    static adapters = new Map();
+    static {
+        IdaeDbAdapter.addAdapter(DbType.MONGODB, MongoDBAdapter);
+        IdaeDbAdapter.addAdapter(DbType.MYSQL, MySQLAdapter);
+        IdaeDbAdapter.addAdapter(DbType.CHROMADB, ChromaDBAdapter);
+    }
+    /**
+     * Adds a new adapter for a specific database type.
+     * @param dbType The type of database for this adapter.
+     * @param adapterConstructor The constructor function for the adapter.
+     */
+    static addAdapter(dbType, adapterConstructor) {
+        IdaeDbAdapter.adapters.set(dbType, adapterConstructor);
+    }
+    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.
+     * @param events An object containing event listeners for different operations.
+     */
+    registerEvents(events) {
+        for (const [method, listeners] of Object.entries(events)) {
+            if (listeners.pre) {
+                this.on(`pre:${String(method)}`, listeners.pre);
+            }
+            if (listeners.post) {
+                this.on(`post:${String(method)}`, listeners.post);
+            }
+            if (listeners.error) {
+                this.on(`error:${String(method)}`, listeners.error);
+            }
+        }
+    }
+    static getAdapterForDbType(dbType) {
+        return IdaeDbAdapter.adapters.get(dbType);
+    }
+    async create(data) {
+        return this.adapter.create(data);
+    }
+    async findById(id) {
+        return this.adapter.findById(id);
+    }
+    async find(params) {
+        return this.adapter.find(params);
+    }
+    async findOne(params) {
+        return this.adapter.findOne(params);
+    }
+    async update(id, updateData) {
+        return this.adapter.update(id, updateData);
+    }
+    async updateWhere(params, updateData) {
+        return this.adapter.updateWhere(params, updateData);
+    }
+    async deleteById(id) {
+        return this.adapter.deleteById(id);
+    }
+    async deleteWhere(params) {
+        return this.adapter.deleteWhere(params);
+    }
+    async transaction(callback) {
+        return this.adapter.transaction(callback);
+    }
+}
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_a = typeof Partial !== "undefined" && Partial) === "function" ? _a : Object]),
+    __metadata("design:returntype", Promise)
+], IdaeDbAdapter.prototype, "create", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], IdaeDbAdapter.prototype, "findById", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], IdaeDbAdapter.prototype, "find", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], IdaeDbAdapter.prototype, "findOne", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, typeof (_b = typeof Partial !== "undefined" && Partial) === "function" ? _b : 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:returntype", Promise)
+], IdaeDbAdapter.prototype, "updateWhere", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], IdaeDbAdapter.prototype, "deleteById", null);
+__decorate([
+    withEmitter(),
+    __metadata("design:type", Function),
+    __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,16 +1,17 @@
-import { Db } from "mongodb";
-import { Connection as MysqlConnection } from "mysql2/promise";
-import { DbType } from "./types";
+import { IdaeDBModel } from './IdaeDBModel.js';
+import { IdaeDb } from './idaeDb.js';
 export declare class IdaeDbConnection {
-    private uri;
-    private dbName;
-    private dbType;
-    private mongoClient;
-    private mongoDb;
-    private mysqlConnection;
-    constructor(uri: string, dbName: string, dbType: DbType);
-    connect(): Promise<void>;
-    getDb(): Db | MysqlConnection;
+    #private;
+    private _idaeDb;
+    private _dbName;
+    constructor(_idaeDb: IdaeDb, _dbName: string);
+    connect(): Promise<IdaeDbConnection>;
+    getDb(): any;
+    getModel: <T extends Document>(collectionName: string) => IdaeDBModel<T>;
+    getClient<T>(): T;
     close(): Promise<void>;
-    getDbType(): DbType;
+    get dbName(): string;
+    get connected(): boolean;
+    get idaeDb(): IdaeDb;
+    private getFullDbName;
 }

package/dist/IdaeDbConnection.js

@@ -1,74 +1,73 @@
 // packages\idae-db\lib\IdaeDbConnection.ts
-import { MongoClient, Db } from "mongodb";
-import { Connection as MysqlConnection } from "mysql2/promise";
-import { DbType } from "./types";
+import { DbType } from './types.js';
+import { IdaeDBModel } from './IdaeDBModel.js';
+import { IdaeDb } from './idaeDb.js';
 export class IdaeDbConnection {
-    uri;
-    dbName;
-    dbType;
-    mongoClient = null;
-    mongoDb = null;
-    mysqlConnection = null;
-    constructor(uri, dbName, dbType) {
-        this.uri = uri;
-        this.dbName = dbName;
-        this.dbType = dbType;
+    _idaeDb;
+    _dbName;
+    #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.#adapterClass = _idaeDb.adapterClass;
+        // add prefix if requested
+        this._dbName = this.getFullDbName();
     }
     async connect() {
+        if (!this.#adapterClass?.connect)
+            throw new Error('Adapter does not have a connect method');
         try {
-            switch (this.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");
-                    break;
-                case DbType.MYSQL:
-                    // this.mysqlConnection = await mysql.createConnection(...);
-                    console.log("Connected to MySQL");
-                    break;
-                default:
-                    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;
-            default:
-                throw new Error(`Unsupported database type: ${this.dbType}`);
+        if (!this.#Db) {
+            throw new Error('Db not connected. Call connect() first.');
         }
+        return this.#Db;
     }
-    async close() {
-        switch (this.dbType) {
-            case DbType.MONGODB:
-                if (this.mongoClient) {
-                    await this.mongoClient.close();
-                    console.log("Disconnected from MongoDB");
-                }
-                break;
-            case DbType.MYSQL:
-                if (this.mysqlConnection) {
-                    await this.mysqlConnection.end();
-                    console.log("Disconnected from MySQL");
-                }
-                break;
+    getModel = (collectionName) => {
+        if (!this.#models.has(collectionName)) {
+            const model = new IdaeDBModel(this, collectionName, this._idaeDb?.options?.idaeModelOptions);
+            this.#models.set(collectionName, model);
+        }
+        return this.#models.get(collectionName);
+    };
+    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;
+    }
+    get connected() {
+        return this.#connected;
     }
-    getDbType() {
-        return this.dbType;
+    get idaeDb() {
+        return this._idaeDb;
     }
+    getFullDbName = () => [this.idaeDb.options.dbScope, this._dbName].join('_');
 }

package/dist/IdaeEventEmitter.d.ts

@@ -0,0 +1,52 @@
+import { EventEmitter } from 'events';
+import { IdaeDbAdapter } from './IdaeDbAdapter.js';
+/**
+ * IdaeEventEmitter extends Node's EventEmitter to provide pre/post method hooks.
+ */
+export declare class IdaeEventEmitter extends EventEmitter {
+    /**
+     * Overrides the emit method to ensure type safety.
+     * @param event The name of the event to emit.
+     * @param args The arguments to pass to the event listeners.
+     * @returns Whether the event had listeners.
+     */
+    emit(event: string | symbol, ...args: any[]): boolean;
+}
+/**
+ * Decorator factory to add pre/post hooks to a method.
+ * @returns A method decorator that adds event emission for pre/post hooks.
+ */
+export declare function withEmitter(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any> | void;
+/**
+ * Type for pre-execution event listeners.
+ */
+export type PreEventListener<T extends any[]> = (...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>;
+/**
+ * Type for error event listeners.
+ */
+export type ErrorEventListener = (error: Error) => void | Promise<void>;
+/**
+ * Interface to extend IdaeEventEmitter with strongly typed event listeners.
+ */
+export interface TypedIdaeEventEmitter<T> {
+    on<K extends keyof T>(event: `pre:${K & string}`, listener: PreEventListener<Parameters<T[K]>>): this;
+    on<K extends keyof T>(event: `post:${K & string}`, listener: PostEventListener<Parameters<T[K]>, ReturnType<T[K]>>): this;
+    on<K extends keyof T>(event: `error:${K & string}`, listener: ErrorEventListener): this;
+    once<K extends keyof T>(event: `pre:${K & string}`, listener: PreEventListener<Parameters<T[K]>>): this;
+    once<K extends keyof T>(event: `post:${K & string}`, listener: PostEventListener<Parameters<T[K]>, ReturnType<T[K]>>): this;
+    once<K extends keyof T>(event: `error:${K & string}`, listener: ErrorEventListener): this;
+    emit<K extends keyof T>(event: `pre:${K & string}`, ...args: Parameters<T[K]>): boolean;
+    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

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'events';
+import { IdaeDbAdapter } from './IdaeDbAdapter.js';
+/**
+ * IdaeEventEmitter extends Node's EventEmitter to provide pre/post method hooks.
+ */
+export class IdaeEventEmitter extends EventEmitter {
+    /**
+     * Overrides the emit method to ensure type safety.
+     * @param event The name of the event to emit.
+     * @param args The arguments to pass to the event listeners.
+     * @returns Whether the event had listeners.
+     */
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+}
+/**
+ * Decorator factory to add pre/post hooks to a method.
+ * @returns A method decorator that adds event emission for pre/post hooks.
+ */
+export function withEmitter() {
+    return function (target, propertyKey, descriptor) {
+        if (descriptor === undefined) {
+            descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            // Emit the pre-execution event
+            this.emit(`pre:${String(propertyKey)}`, ...args);
+            let result;
+            try {
+                // Execute the original method
+                result = await originalMethod.apply(this, args);
+            }
+            catch (error) {
+                // Emit the error event if an exception occurs
+                this.emit(`error:${String(propertyKey)}`, error);
+                throw error;
+            }
+            // Emit the post-execution event
+            this.emit(`post:${String(propertyKey)}`, result, ...args);
+            return result;
+        };
+        return descriptor;
+    };
+}