Create `PoolFactory`

[garciparedes]

classDiagram

    class DeltaRepository {
        <<abstract>>
        submit(delta: Delta)*
        get(*args, **kwargs)* Delta
    }

    DeltaRepository <|-- InMemoryDeltaRepository
    class InMemoryDeltaRepository {
        submit(delta: Delta)
        get(*args, **kwargs) Delta
    }
    

    DeltaRepository <|-- SqlDeltaRepository
    class SqlDeltaRepository { 
        submit(delta: Delta)
        get(*args, **kwargs) Delta
    }

    SqlDeltaRepository o-- SqlDeltaQueryFactory: query_factory

    class SqlDeltaQueryFactory {
        build_create_table() str
        build_add_row() str
        build_get_offset() str
    }

    SqlDeltaQueryFactory <|-- PostgresDeltaQueryFactory
    class PostgresDeltaQueryFactory {
        build_create_table() str
    }

    SqlDeltaQueryFactory <|-- MySqlDeltaQueryFactory
    class MySqlDeltaQueryFactory {
        build_create_table() str
    }

    DeltaRepository <|-- MongoDeltaRepository
    class MongoDeltaRepository {
        submit(delta: Delta)
        get(*args, **kwargs) Delta
    }

    class PoolFactory {
        from_config(config: Config) PoolFactory
        setup()
        destroy()
    }

    SqlDeltaRepository o-- PoolFactory : get_pool(type_="database", name="default") -> DatabaseClientPool[SqlDatabaseClient]  
    MongoDeltaRepository o-- PoolFactory : get_pool(type_="database", name="default") -> DatabaseClientPool[MonoDatabaseClient]    


    PoolFactory o-- Pool : pools dict[str, Pool]

    class Pool {
        acquire()*
    }


    Pool <|-- DatabaseClientPool
    class DatabaseClientPool { 
        client_type: type[DatabaseClient]
        max_size: int
        recycle: timedelta
        setup()
        destroy()
    }

    DatabaseClientPool o-- DatabaseClient : acquire()

    class DatabaseClient { 
        <<abstract>>
        execute(query: str)*
        fetch_all()* Iterable~Any~
        fetch_one() Any
        setup()
        destroy()
    }
    
    DatabaseClient <|-- SqlDatabaseClient
    class SqlDatabaseClient {
        <<abstract>>
        execute(query: str)*
        fetch_all() Iterable~Any~
    }

    SqlDatabaseClient <|-- AiopgDatabaseClient
    class AiopgDatabaseClient {
        execute(query: str)
        fetch_all() Iterable~Any~
    }
    AiopgDatabaseClient o-- aiopg_Connection : connection

    class aiopg_Connection { }


    SqlDatabaseClient <|-- SqlAlchemyDatabaseClient
    class SqlAlchemyDatabaseClient {
        execute(query: str)
        fetch_all() Iterable~Any~
    }
    SqlAlchemyDatabaseClient o-- sqlalchemy_SqlAlchemyClient : connection

    class sqlalchemy_SqlAlchemyClient { }


    DatabaseClient <|-- LmdbDatabaseClient
    class LmdbDatabaseClient {
        execute(query: str)
        fetch_all() Iterable~Any~
    }

    DatabaseClient <|-- RedisDatabaseClient
    class RedisDatabaseClient {
        execute(query: str)
        fetch_all() Iterable~Any~
    }

    DatabaseClient <|-- MongoDatabaseClient
    class MongoDatabaseClient {
        execute(query: str)
        fetch_all() Iterable~Any~
    }


    Pool <|-- LockPool
    Pool <|-- BrokerClientPool
    Pool <|-- HttpClientPool

Loading