mdb-engine 0.1.7__py3-none-any.whl → 0.2.1__py3-none-any.whl

mdb_engine/repositories/mongo.py

@@ -0,0 +1,233 @@
+"""
+MongoDB Repository Implementation
+
+Implements the Repository interface using MongoDB through ScopedCollectionWrapper.
+This provides automatic app scoping and security features.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, Generic, List, Optional, Type, TypeVar
+
+from bson import ObjectId
+
+from .base import Entity, Repository
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=Entity)
+
+
+class MongoRepository(Repository[T], Generic[T]):
+    """
+    MongoDB implementation of the Repository interface.
+
+    Uses ScopedCollectionWrapper for automatic app_id scoping
+    and security features.
+
+    Example:
+        # Direct usage
+        users_collection = db.users  # ScopedCollectionWrapper
+        user_repo = MongoRepository(users_collection, User)
+
+        # Find users
+        users = await user_repo.find({"role": "admin"})
+
+        # Add new user
+        user = User(email="john@example.com", name="John")
+        user_id = await user_repo.add(user)
+    """
+
+    def __init__(
+        self,
+        collection: Any,  # ScopedCollectionWrapper - avoid import cycle
+        entity_class: Type[T],
+    ):
+        """
+        Initialize the MongoDB repository.
+
+        Args:
+            collection: ScopedCollectionWrapper for the collection
+            entity_class: Entity subclass for this repository
+        """
+        self._collection = collection
+        self._entity_class = entity_class
+
+    def _to_entity(self, doc: Optional[Dict[str, Any]]) -> Optional[T]:
+        """Convert a MongoDB document to an entity."""
+        if doc is None:
+            return None
+        return self._entity_class.from_dict(doc)
+
+    def _to_document(self, entity: T, include_id: bool = False) -> Dict[str, Any]:
+        """Convert an entity to a MongoDB document."""
+        doc = entity.to_dict()
+        if not include_id and "_id" in doc:
+            del doc["_id"]
+        return doc
+
+    async def get(self, id: str) -> Optional[T]:
+        """Get entity by ID."""
+        try:
+            object_id = ObjectId(id) if ObjectId.is_valid(id) else id
+        except (TypeError, ValueError):
+            return None
+
+        doc = await self._collection.find_one({"_id": object_id})
+        return self._to_entity(doc)
+
+    async def find(
+        self,
+        filter: Optional[Dict[str, Any]] = None,
+        skip: int = 0,
+        limit: int = 100,
+        sort: Optional[List[tuple]] = None,
+    ) -> List[T]:
+        """Find entities matching a filter."""
+        cursor = self._collection.find(filter or {})
+
+        if skip > 0:
+            cursor = cursor.skip(skip)
+        if limit > 0:
+            cursor = cursor.limit(limit)
+        if sort:
+            cursor = cursor.sort(sort)
+
+        docs = await cursor.to_list(length=limit)
+        return [self._to_entity(doc) for doc in docs]
+
+    async def find_one(self, filter: Dict[str, Any]) -> Optional[T]:
+        """Find a single entity matching a filter."""
+        doc = await self._collection.find_one(filter)
+        return self._to_entity(doc)
+
+    async def add(self, entity: T) -> str:
+        """Add a new entity and return its ID."""
+        entity.created_at = datetime.utcnow()
+        doc = self._to_document(entity)
+
+        result = await self._collection.insert_one(doc)
+        entity.id = str(result.inserted_id)
+
+        logger.debug(f"Added {self._entity_class.__name__} with id={entity.id}")
+        return entity.id
+
+    async def add_many(self, entities: List[T]) -> List[str]:
+        """Add multiple entities and return their IDs."""
+        now = datetime.utcnow()
+        docs = []
+
+        for entity in entities:
+            entity.created_at = now
+            docs.append(self._to_document(entity))
+
+        result = await self._collection.insert_many(docs)
+        ids = [str(id) for id in result.inserted_ids]
+
+        for entity, id in zip(entities, ids):
+            entity.id = id
+
+        logger.debug(f"Added {len(ids)} {self._entity_class.__name__} entities")
+        return ids
+
+    async def update(self, id: str, entity: T) -> bool:
+        """Update an entity by ID."""
+        try:
+            object_id = ObjectId(id) if ObjectId.is_valid(id) else id
+        except (TypeError, ValueError):
+            return False
+
+        entity.updated_at = datetime.utcnow()
+        doc = self._to_document(entity)
+
+        result = await self._collection.update_one({"_id": object_id}, {"$set": doc})
+
+        return result.modified_count > 0
+
+    async def update_fields(self, id: str, fields: Dict[str, Any]) -> bool:
+        """Update specific fields of an entity."""
+        try:
+            object_id = ObjectId(id) if ObjectId.is_valid(id) else id
+        except (TypeError, ValueError):
+            return False
+
+        fields["updated_at"] = datetime.utcnow()
+
+        result = await self._collection.update_one({"_id": object_id}, {"$set": fields})
+
+        return result.modified_count > 0
+
+    async def delete(self, id: str) -> bool:
+        """Delete an entity by ID."""
+        try:
+            object_id = ObjectId(id) if ObjectId.is_valid(id) else id
+        except (TypeError, ValueError):
+            return False
+
+        result = await self._collection.delete_one({"_id": object_id})
+        return result.deleted_count > 0
+
+    async def count(self, filter: Optional[Dict[str, Any]] = None) -> int:
+        """Count entities matching a filter."""
+        return await self._collection.count_documents(filter or {})
+
+    async def exists(self, id: str) -> bool:
+        """Check if an entity exists."""
+        try:
+            object_id = ObjectId(id) if ObjectId.is_valid(id) else id
+        except (TypeError, ValueError):
+            return False
+
+        doc = await self._collection.find_one({"_id": object_id}, projection={"_id": 1})
+        return doc is not None
+
+    # Additional MongoDB-specific methods
+
+    async def aggregate(self, pipeline: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Run an aggregation pipeline.
+
+        Args:
+            pipeline: MongoDB aggregation pipeline
+
+        Returns:
+            List of result documents
+        """
+        cursor = self._collection.aggregate(pipeline)
+        return await cursor.to_list(length=None)
+
+    async def update_many(
+        self,
+        filter: Dict[str, Any],
+        update: Dict[str, Any],
+    ) -> int:
+        """
+        Update multiple documents matching a filter.
+
+        Args:
+            filter: MongoDB filter
+            update: Update operations
+
+        Returns:
+            Number of modified documents
+        """
+        if "$set" not in update:
+            update = {"$set": update}
+
+        update["$set"]["updated_at"] = datetime.utcnow()
+
+        result = await self._collection.update_many(filter, update)
+        return result.modified_count
+
+    async def delete_many(self, filter: Dict[str, Any]) -> int:
+        """
+        Delete multiple documents matching a filter.
+
+        Args:
+            filter: MongoDB filter
+
+        Returns:
+            Number of deleted documents
+        """
+        result = await self._collection.delete_many(filter)
+        return result.deleted_count

mdb_engine/repositories/unit_of_work.py

@@ -0,0 +1,166 @@
+"""
+Unit of Work Pattern
+
+Manages repository access and provides a clean interface for data operations.
+The UnitOfWork acts as a factory for repositories and manages their lifecycle.
+"""
+
+import logging
+from typing import Any, Dict, Generic, Optional, Type, TypeVar
+
+from .base import Entity, Repository
+from .mongo import MongoRepository
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=Entity)
+
+
+class UnitOfWork:
+    """
+    Unit of Work for managing repository access.
+
+    Provides a clean interface for accessing repositories through
+    attribute access (e.g., uow.users, uow.orders).
+
+    The UnitOfWork is request-scoped - one instance per HTTP request.
+    Repositories are created lazily and cached for the duration of the request.
+
+    Usage:
+        # In a route handler
+        @app.get("/users/{user_id}")
+        async def get_user(user_id: str, ctx: RequestContext = Depends()):
+            # Access repository through UnitOfWork
+            user = await ctx.uow.users.get(user_id)
+            return user
+
+        # With explicit repository method
+        @app.get("/orders")
+        async def list_orders(ctx: RequestContext = Depends()):
+            repo = ctx.uow.repository("orders", Order)
+            return await repo.find({"status": "pending"})
+
+    Repository Naming Convention:
+        - Attribute access uses collection name: uow.users -> users collection
+        - The entity class defaults to Entity if not registered
+        - Register entity classes for type-safe repositories
+    """
+
+    def __init__(
+        self,
+        db: Any,  # ScopedMongoWrapper - avoid import cycle
+        entity_registry: Optional[Dict[str, Type[Entity]]] = None,
+    ):
+        """
+        Initialize the Unit of Work.
+
+        Args:
+            db: ScopedMongoWrapper for database access
+            entity_registry: Optional mapping of collection names to entity classes
+        """
+        self._db = db
+        self._repositories: Dict[str, Repository] = {}
+        self._entity_registry: Dict[str, Type[Entity]] = entity_registry or {}
+
+    def register_entity(self, collection_name: str, entity_class: Type[Entity]) -> None:
+        """
+        Register an entity class for a collection.
+
+        This enables type-safe repository access.
+
+        Args:
+            collection_name: Name of the collection
+            entity_class: Entity subclass for this collection
+        """
+        self._entity_registry[collection_name] = entity_class
+
+    def repository(
+        self,
+        name: str,
+        entity_class: Optional[Type[T]] = None,
+    ) -> Repository[T]:
+        """
+        Get or create a repository for a collection.
+
+        Args:
+            name: Collection name
+            entity_class: Optional entity class override
+
+        Returns:
+            Repository instance for the collection
+        """
+        if name in self._repositories:
+            return self._repositories[name]
+
+        # Determine entity class
+        if entity_class is None:
+            entity_class = self._entity_registry.get(name, Entity)
+
+        # Get collection from db wrapper
+        collection = getattr(self._db, name)
+
+        # Create repository
+        repo = MongoRepository(collection, entity_class)
+        self._repositories[name] = repo
+
+        logger.debug(f"Created repository for '{name}' with entity {entity_class.__name__}")
+        return repo
+
+    def __getattr__(self, name: str) -> Repository:
+        """
+        Access repositories via attribute syntax.
+
+        Example:
+            uow.users  # Returns Repository for 'users' collection
+            uow.orders  # Returns Repository for 'orders' collection
+        """
+        # Prevent recursion on private attributes
+        if name.startswith("_"):
+            raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")
+
+        return self.repository(name)
+
+    @property
+    def db(self) -> Any:
+        """
+        Direct access to the underlying ScopedMongoWrapper.
+
+        Use this for operations not covered by the Repository interface,
+        like complex aggregations or raw queries.
+
+        Example:
+            # Complex aggregation
+            pipeline = [{"$match": {...}}, {"$group": {...}}]
+            results = await ctx.uow.db.users.aggregate(pipeline).to_list(None)
+        """
+        return self._db
+
+    def dispose(self) -> None:
+        """
+        Dispose of the UnitOfWork and clear cached repositories.
+
+        Called automatically at the end of a request scope.
+        """
+        self._repositories.clear()
+        logger.debug("UnitOfWork disposed")
+
+
+class TypedUnitOfWork(UnitOfWork, Generic[T]):
+    """
+    Generic typed UnitOfWork for better IDE support.
+
+    This is a convenience class that provides type hints for specific
+    repository types.
+
+    Usage:
+        class MyUnitOfWork(TypedUnitOfWork):
+            @property
+            def users(self) -> Repository[User]:
+                return self.repository("users", User)
+
+            @property
+            def orders(self) -> Repository[Order]:
+                return self.repository("orders", Order)
+    """
+
+    pass

{mdb_engine-0.1.7.dist-info → mdb_engine-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdb-engine
-Version: 0.1.7
+Version: 0.2.1
 Summary: MongoDB Engine
 Home-page: https://github.com/ranfysvalle02/mdb-engine
 Author: Your Name
@@ -85,7 +85,9 @@ pip install mdb-engine
 
 ```python
 from pathlib import Path
+from fastapi import Depends
 from mdb_engine import MongoDBEngine
+from mdb_engine.dependencies import get_scoped_db
 
 # 1. Initialize the engine
 engine = MongoDBEngine(
@@ -96,10 +98,9 @@ engine = MongoDBEngine(
 # 2. Create a FastAPI app with automatic lifecycle management
 app = engine.create_app(slug="my_app", manifest=Path("manifest.json"))
 
-# 3. Use the scoped database - all queries automatically isolated
+# 3. Use request-scoped dependencies - all queries automatically isolated
 @app.post("/tasks")
-async def create_task(task: dict):
-    db = engine.get_scoped_db("my_app")
+async def create_task(task: dict, db=Depends(get_scoped_db)):
     result = await db.tasks.insert_one(task)
     return {"id": str(result.inserted_id)}
 ```
@@ -149,22 +150,29 @@ Supported index types: `regular`, `text`, `vector`, `ttl`, `compound`.
 
 ### 2. CRUD Operations (Auto-Scoped)
 
-All database operations are automatically scoped to your app:
+All database operations are automatically scoped to your app. Use `Depends(get_scoped_db)` in route handlers:
 
 ```python
-db = engine.get_scoped_db("my_app")
+from mdb_engine.dependencies import get_scoped_db
 
-# Create
-await db.tasks.insert_one({"title": "Build feature", "status": "pending"})
+@app.post("/tasks")
+async def create_task(task: dict, db=Depends(get_scoped_db)):
+    result = await db.tasks.insert_one(task)
+    return {"id": str(result.inserted_id)}
 
-# Read  
-tasks = await db.tasks.find({"status": "pending"}).to_list(length=10)
+@app.get("/tasks")
+async def list_tasks(db=Depends(get_scoped_db)):
+    return await db.tasks.find({"status": "pending"}).to_list(length=10)
 
-# Update
-await db.tasks.update_one({"_id": task_id}, {"$set": {"status": "done"}})
+@app.put("/tasks/{task_id}")
+async def update_task(task_id: str, db=Depends(get_scoped_db)):
+    await db.tasks.update_one({"_id": task_id}, {"$set": {"status": "done"}})
+    return {"updated": True}
 
-# Delete
-await db.tasks.delete_one({"_id": task_id})
+@app.delete("/tasks/{task_id}")
+async def delete_task(task_id: str, db=Depends(get_scoped_db)):
+    await db.tasks.delete_one({"_id": task_id})
+    return {"deleted": True}
 ```
 
 **What happens under the hood:**
@@ -210,6 +218,26 @@ async def health():
 | **Multi-App** | Secure cross-app data access | [Multi-App Example](https://github.com/ranfysvalle02/mdb-engine/tree/main/examples/advanced/multi_app) |
 | **SSO** | Shared auth across apps | [Shared Auth Example](https://github.com/ranfysvalle02/mdb-engine/tree/main/examples/advanced/multi_app_shared) |
 
+### AppContext — All Services in One Place ✨
+
+```python
+from fastapi import Depends
+from mdb_engine.dependencies import AppContext
+
+@app.post("/ai-chat")
+async def chat(query: str, ctx: AppContext = Depends()):
+    user = ctx.require_user()  # 401 if not logged in
+    ctx.require_role("user")   # 403 if missing role
+    
+    # Everything available: ctx.db, ctx.embedding_service, ctx.memory, ctx.llm
+    if ctx.llm:
+        response = ctx.llm.chat.completions.create(
+            model=ctx.llm_model,
+            messages=[{"role": "user", "content": query}]
+        )
+        return {"response": response.choices[0].message.content}
+```
+
 ---
 
 ## Full Examples

{mdb_engine-0.1.7.dist-info → mdb_engine-0.2.1.dist-info}/RECORD

@@ -1,25 +1,28 @@
 mdb_engine/README.md,sha256=T3EFGcPopY9LslYW3lxgG3hohWkAOmBNbYG0FDMUJiY,3502
-mdb_engine/__init__.py,sha256=d5UN7QnkySDKriO4epSGNS2bBbgl_Bw18qu6Sd4I7xs,1629
+mdb_engine/__init__.py,sha256=-W3Gdj2GAoptKsR_T4xluYnmnelZTdKrTxCthIytZ48,3008
 mdb_engine/config.py,sha256=EsB0PHrRCCt24db6Ly88s6PQ3sm1esSLMa2G4AHpt5k,7315
 mdb_engine/constants.py,sha256=eaotvW57TVOg7rRbLziGrVNoP7adgw_G9iVByHezc_A,7837
+mdb_engine/dependencies.py,sha256=bkKwYz6CnucDNDcXdxTvRCqmQpsWbAXQFf5w-AcKMH8,14107
 mdb_engine/exceptions.py,sha256=N8WYOgh1fOH0yJeR9I3FTXqpACIL_EQX3zcfUgrFvPI,8521
-mdb_engine/auth/README.md,sha256=pOobYo31ENhGA3d_nTUXVK795w2wvvQ_ub10x9wK1pU,33838
-mdb_engine/auth/__init__.py,sha256=0Gc0uFDAcj_BMeACaD0oICAn8YwVcpTf20DJbTzDxr8,5656
+mdb_engine/auth/ARCHITECTURE.md,sha256=JXZsjEIpNz4Szk18KaOiEabhEuz1pmYWXQRN-EJEHDM,4076
+mdb_engine/auth/README.md,sha256=STL4PHyMlYpSNEAqo4RBKTEm4kz1GbWpI9c_lS94nV4,36802
+mdb_engine/auth/__init__.py,sha256=QemWqAVvqlxjF-UbzMTGP5AUOeuaAsUEtK4PMxmozmA,5852
 mdb_engine/auth/audit.py,sha256=LtdG9GdwYTSMI30zMygB0K8w4l179GaGvkNbxWgoQ2I,17461
-mdb_engine/auth/casbin_factory.py,sha256=CjGU7cj_I2OVjsendxpK1ungvHIMHzGJptMDw7LzEtE,5898
+mdb_engine/auth/base.py,sha256=tIcC30_ViVuhmR8PCpY-MYBzu6Y9Ak1DZkAQishQyMg,7434
+mdb_engine/auth/casbin_factory.py,sha256=66unyPRqNPydi0Bln8NNpsPt8gMwl7Hwc_nEsqfJj9U,16633
 mdb_engine/auth/casbin_models.py,sha256=7XtFmRBhhjw1nKprnluvjyJoTj5fzdPeQwVvo6fI-r0,955
 mdb_engine/auth/config_defaults.py,sha256=7JYX8CFI7OP7GHFIDHTf3Jns09LJcQ7f0_GL9yBnyuA,2018
 mdb_engine/auth/config_helpers.py,sha256=DpQ8QZAO2FVVKFmhTJIa4FYPS8Iy8O7vcVh_tg0INLg,6309
 mdb_engine/auth/cookie_utils.py,sha256=F88p6_aMG0aSmGXCn0KYjweSMPHqfce1lrKHU4P5yQk,4913
 mdb_engine/auth/csrf.py,sha256=Rx9qYt8owSJJwwj7Z_w4nzkaLbaqWoVpNv13qnqosIA,12458
 mdb_engine/auth/decorators.py,sha256=47uyOK_6WmK18J6ELRKwwgaIkcp6kHOILXuARj82Ijw,12288
-mdb_engine/auth/dependencies.py,sha256=hAmFhtOFFJWRpCFQyPuALJWcgSMZn_Os16S7Q5N9waQ,27038
+mdb_engine/auth/dependencies.py,sha256=-JooBflCsyndw8oUJ864nX01QOX9Pq09KQhY43oaSJk,27156
 mdb_engine/auth/helpers.py,sha256=BCrid985cYh-3h5ZMUV9TES0q40uJXio4oYKQZta7KA,1970
-mdb_engine/auth/integration.py,sha256=MHb4d8ar1eywXJlo4I1dlvUJ6SP7KO_ql3kbVTs8FAU,21756
+mdb_engine/auth/integration.py,sha256=zaTeo4ZXnxnTbw6iZCawZ6dDXDQQCaX6XYc6cbRw6xs,22759
 mdb_engine/auth/jwt.py,sha256=aRXLfgFjsebIARmPqgfcA5zSgSN44HD7BgSyOEFaQCM,7244
 mdb_engine/auth/middleware.py,sha256=uMx1dOO1NaR4K2nDet3k_ASR7rc7ZbKD0HlEkVYGJvU,10869
-mdb_engine/auth/oso_factory.py,sha256=sJfW9TlrKp6QF_f5kq84axWQJyPsNelDDKuYLmVsduU,11257
-mdb_engine/auth/provider.py,sha256=SNpkws-QO56hOo8CZ6LMenLjLQYO0NK_31zMhYekXx0,21926
+mdb_engine/auth/oso_factory.py,sha256=FPDzL5zYrFWd--amBoqKk_1FHET8QzlmiYTLinZeezU,11289
+mdb_engine/auth/provider.py,sha256=m7G1rMgMezalALcV_74Kb0G77exyAIP-eOGyI2XfApc,26595
 mdb_engine/auth/rate_limiter.py,sha256=kYuYIDlgkmYB2jx_UUmM9VrndUq2iTkdP7DZV-Jfu8o,15825
 mdb_engine/auth/restrictions.py,sha256=TXa2lO3lZQeMtokhyVLP19-XbWwq2R8JMTw2KfaiDMg,8852
 mdb_engine/auth/session_manager.py,sha256=XjYeE4i1998tBIefhp8VH3Oe7reyA_CC_qjw6zZ5EVY,15459
@@ -43,23 +46,27 @@ mdb_engine/core/app_registration.py,sha256=zRK2JTeT0rDW4XdOgFAV-j9Og7xijXdov4u1V
 mdb_engine/core/app_secrets.py,sha256=ipLsC_QdnIFhrCLNQ3nXvBAfndSor4WNRJyqPc0-J8Q,10555
 mdb_engine/core/connection.py,sha256=9WRccQ2Zz8K6PS6yC2XXxhZkppALvAWZJhfLmsJBnbI,8383
 mdb_engine/core/encryption.py,sha256=jblhUuu_L_lht0qlbn5vqDsdj9rN80uL9DCFDCD-zxw,7540
-mdb_engine/core/engine.py,sha256=hW86qxrHvaQdCJgyI93W0GVVxVB7ZUuY66QAiWaGXRA,55486
+mdb_engine/core/engine.py,sha256=YmsoTNqMaLi4kcUFySSpCQZ1O8Fd41YryhwubfMfc0g,69566
 mdb_engine/core/index_management.py,sha256=9-r7MIy3JnjQ35sGqsbj8K_I07vAUWtAVgSWC99lJcE,5555
-mdb_engine/core/manifest.py,sha256=K95aiGvZ2YQ3pUIGJyMeJTvveg9HgGdJUpd6fO7AxmI,132305
+mdb_engine/core/manifest.py,sha256=4Dk7iDOoxOrpZ20BA2onaX6cqMhWVSIA0bryeKPsXDQ,133677
 mdb_engine/core/ray_integration.py,sha256=Qe3jAYQhOKeBBlWFAcqzciDWN2zctJh_6uMTIai1tS0,13617
 mdb_engine/core/seeding.py,sha256=I5g43xdoEdC4rNwc_Ih0L6QOZguPcpAWrS6HvJ2a3fE,6433
 mdb_engine/core/service_initialization.py,sha256=gJNIB0As4vg6UXRgt1EDo5p3zzlHfF8NZqjCAlB75mA,12997
 mdb_engine/core/types.py,sha256=v_lSnBTyl2JHX39cPvPsnOxXhu8xaGC92UektvYPOvg,11239
-mdb_engine/database/README.md,sha256=cWPUce2PmrnIu4JQPF_RzsQ0Ju4pHIjhNhiFT0OdPKs,18481
+mdb_engine/database/README.md,sha256=-31mVxBeVQaYsF3AD1-gQbD2NCYVcPjdFoA6sZ6b02Y,19354
 mdb_engine/database/__init__.py,sha256=rrc3eZFli3K2zrvVdDbMBi8YkmoHYzP6JNT0AUBE5VU,981
 mdb_engine/database/abstraction.py,sha256=FLVhFuS4OTZIRQyDkUBZdIlhqRndqNA89EO0cJvNsN0,23462
 mdb_engine/database/connection.py,sha256=PDmwkjb4wYhLTUjlcYHscorces69rIuSxt5wdYixGQw,13777
 mdb_engine/database/query_validator.py,sha256=AIWkQ-c6HAqJ-ixn-hq_0yfC2vdf1-jbEpzYZNmfEqs,13275
 mdb_engine/database/resource_limiter.py,sha256=n54-I6bjEk5jxNGMXyb6_fArDCiyJ69_h9goFW5GzUs,6936
 mdb_engine/database/scoped_wrapper.py,sha256=S_QIqGVyCteKAYlSUHNIqqc0S80jWhzHV-Lfa-ezNG4,94794
-mdb_engine/embeddings/README.md,sha256=lehHJm7gADRze1Em59Da7DWFuVqDhMKmLz8UaTF12Rc,4997
-mdb_engine/embeddings/__init__.py,sha256=UReBuU_0IOFg2kCpMjmZFV9b88PepL6oNok9Osd8t-4,2024
-mdb_engine/embeddings/dependencies.py,sha256=aQXZnIVLxWU1qnKh-fih0iCcdX3cPd0AdsNEajBLp4w,5915
+mdb_engine/di/__init__.py,sha256=uy9Q153a0QE678TkJ_AEwLuxPY3OyEum2I42_JsuwrI,912
+mdb_engine/di/container.py,sha256=Wf4-O69Kg_hLC3aHmAf847K7p0sHLh4aYKMGOTmvzok,7441
+mdb_engine/di/providers.py,sha256=jCgez_w1NkfAHCa6O3tsoGHiKcZt-fAbmgvn7KXmTCU,5940
+mdb_engine/di/scopes.py,sha256=0pNzm2I5aRr7H_IBCRhcwd4dW4LzwD4uC2PmWyZI1Ps,4187
+mdb_engine/embeddings/README.md,sha256=XjGWUXSdbSpXCAEEVfYmcJoFKBVmXDoM3eTjenrM5Z0,5926
+mdb_engine/embeddings/__init__.py,sha256=BM8tfcekVZv_iPQj3OuZBQ3hHr0eRQetNLEMysRTZkE,2129
+mdb_engine/embeddings/dependencies.py,sha256=BphKvHYF5iYo6k7v4rYkEOYKZCtlGsPfMdrT6v1J430,2195
 mdb_engine/embeddings/service.py,sha256=v5Ch4VMADDUw-tqNs8XbaG9JJktvO7cqniNJ8Mes56k,25991
 mdb_engine/indexes/README.md,sha256=r7duq-1vtqHhBk1cwoBMYYh_dfTzxiaQaPE3mLB_3JQ,15341
 mdb_engine/indexes/__init__.py,sha256=9QFJ6qo_yD26dZcKyKjj-hhesFpaomBt-mWTtYTQvqc,613
@@ -73,13 +80,17 @@ mdb_engine/observability/__init__.py,sha256=jjLsrW6Gy2ayrbfLrgHsDB61NxWWkYLHwv0q
 mdb_engine/observability/health.py,sha256=kZ9LXcJ3_8tKXRWXNNCz3qsj0PkZ0BSTdzisc8ds2vw,9197
 mdb_engine/observability/logging.py,sha256=yo_KnUtqjPx_KvqNrAxW8ud6HQjI7Lk6T7Lj7IMW1uY,4073
 mdb_engine/observability/metrics.py,sha256=EL9-ZFOaxxIdU8PWIqPRyPZHhP3fc4VyUawRSS2GIY4,10726
+mdb_engine/repositories/__init__.py,sha256=048N4QmFLVhJyLdYrWHTTBqujhaF--B8g0z6fUSMuJs,858
+mdb_engine/repositories/base.py,sha256=-Llwhn5NxEh-5S6CJAzZx1nF6J2Sch0WxIpMaaPQhs4,8575
+mdb_engine/repositories/mongo.py,sha256=aR_JFDYtWIZiZA616tDbOPrLN_Gi8diD6Hc9UfeaT-w,7177
+mdb_engine/repositories/unit_of_work.py,sha256=obTsGCcZgsNhQdFOvNGLtvq-guyykmPZzBo-GM_ROAo,5146
 mdb_engine/routing/README.md,sha256=WVvTQXDq0amryrjkCu0wP_piOEwFjLukjmPz2mroWHY,13658
 mdb_engine/routing/__init__.py,sha256=reupjHi_RTc2ZBA4AH5XzobAmqy4EQIsfSUcTkFknUM,2438
 mdb_engine/routing/websockets.py,sha256=X6-MG0mAN8ZEgdmZD8edaiDx8DqMCN-hV3coIOdgZNc,29346
 mdb_engine/utils/__init__.py,sha256=_xjHB5p6WLWBql1DyDqf5zdjj2xpfMlK25Y6BH9-oFk,145
-mdb_engine-0.1.7.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-mdb_engine-0.1.7.dist-info/METADATA,sha256=xhr0VvNWMKVjLgu-fkRbXzFWLf7nb8B5u_4J1LXkXfE,9305
-mdb_engine-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mdb_engine-0.1.7.dist-info/entry_points.txt,sha256=INCbYdFbBzJalwPwxliEzLmPfR57IvQ7RAXG_pn8cL8,48
-mdb_engine-0.1.7.dist-info/top_level.txt,sha256=PH0UEBwTtgkm2vWvC9He_EOMn7hVn_Wg_Jyc0SmeO8k,11
-mdb_engine-0.1.7.dist-info/RECORD,,
+mdb_engine-0.2.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+mdb_engine-0.2.1.dist-info/METADATA,sha256=LaeDnv88ajuRpA0YnOwmMNDSF_4BSRmy-AoxsmFC80U,10470
+mdb_engine-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mdb_engine-0.2.1.dist-info/entry_points.txt,sha256=INCbYdFbBzJalwPwxliEzLmPfR57IvQ7RAXG_pn8cL8,48
+mdb_engine-0.2.1.dist-info/top_level.txt,sha256=PH0UEBwTtgkm2vWvC9He_EOMn7hVn_Wg_Jyc0SmeO8k,11
+mdb_engine-0.2.1.dist-info/RECORD,,