Metadata-Version: 2.4
Name: pholguinc-multitenant-core
Version: 0.1.0
Summary: A framework-agnostic multi-tenancy core for Python with support for multiple database drivers and schema isolation.
Author: pholguinc
Project-URL: Homepage, https://github.com/pholguinc/multitenant-core
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.9
Description-Content-Type: text/markdown
Requires-Dist: sqlalchemy>=2.0.0
Requires-Dist: psycopg2-binary
Requires-Dist: mysql-connector-python
Requires-Dist: alembic
Requires-Dist: pydantic>=2.0.0
Requires-Dist: rich

# Multitenant Core 

**Multitenant Core** es un motor de infraestructura potente y flexible diseñado para simplificar la gestión de múltiples clientes (tenants) en aplicaciones Python. Automatiza el aislamiento de datos mediante esquemas o bases de datos independientes, permitiéndote escalar tu SaaS sin complicaciones técnicas.

## Instalación

Puedes instalar el paquete y su CLI directamente desde el repositorio o mediante pip (próximamente en PyPI):

```bash
pip install pholguinc-multitenant-core
```

O si estás en desarrollo:

```bash
git clone https://github.com/pholguinc/multitenant-core.git
cd multitenant-core
pip install -e .
```

---

## Uso del CLI

El CLI te permite generar proyectos completos con arquitecturas profesionales y el soporte multitenant ya configurado.

### Inicializar un nuevo proyecto
```bash
mt-core init mi_gran_proyecto
```

Durante la inicialización, podrás elegir:
- **Framework**: FastAPI, Django o Flask.
- **Arquitectura**: Capas (Layered) o Hexagonal (Enterprise).
- **Estrategia**: Single DB (Esquemas) o Multi DB (Múltiples bases de datos).
- **Motor**: PostgreSQL, MySQL, MariaDB o SQLite.

---

## Core Library: Cómo Aplicar el Paquete

Si no usas el CLI o quieres profundizar en la librería, estos son los dos pilares fundamentales:

### 1. Aprovisionamiento (Provisioning)
Crea físicamente la infraestructura (Esquema o DB) para un nuevo cliente.

```python
from multitenant_core import TenantDatabaseManager

manager = TenantDatabaseManager("postgresql://user:pass@localhost:5432/main_db")

# Crea el esquema y ejecuta migraciones iniciales
manager.provision_tenant("empresa_alfonso")
```

### 2. Conmutación de Contexto (Session Switching)
Accede a los datos de un cliente específico de forma aislada.

```python
# Dentro de tu lógica de negocio
with manager.get_tenant_session("empresa_alfonso") as session:
    # Todas las consultas aquí se ejecutan SOLAMENTE en el esquema de 'empresa_alfonso'
    productos = session.execute("SELECT * FROM productos").fetchall()
```

---

## Integración en Frameworks

### FastAPI (Inyección de Dependencias)
En FastAPI, puedes resolver el tenant desde un Header y usarlo en tus rutas:

```python
from fastapi import FastAPI, Header
from app.core.database import manager

app = FastAPI()

@app.get("/items")
def read_items(x_tenant_id: str = Header(...)):
    with manager.get_tenant_session(x_tenant_id) as session:
        return session.execute("SELECT * FROM items").fetchall()
```

### Django (Servicios)
En Django, puedes usar el manager dentro de tus vistas o servicios:

```python
from django.http import JsonResponse
from app.core.database import manager

def list_items(request):
    tenant_id = request.headers.get('X-Tenant-Id')
    with manager.get_tenant_session(tenant_id) as session:
        data = session.execute("SELECT * FROM items").fetchall()
        return JsonResponse(list(data), safe=False)
```

---

## Arquitecturas Soportadas por el CLI

- **Layered (Capas)**: Estructura tradicional ideal para proyectos medianos, con separación clara entre API, Servicios y Repositorios.
- **Hexagonal**: Estructura de nivel empresarial (DDD) que separa el Dominio (negocio) de la Infraestructura (base de datos, frameworks), garantizando máxima mantenibilidad.

---


---
Autor: **pholguinc** 
Versión: **0.1.0**
