Metadata-Version: 2.4
Name: apibean-engine
Version: 0.1.0a1
Summary: A schema-driven application engine for building multi-tenant REST APIs with dynamic data models, storage abstraction, and pluggable backend integrations.
License-Expression: MIT
Requires-Python: <4.0,>=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: alembic>=1.16.5
Requires-Dist: apibean-base>=0.1.0a1
Requires-Dist: bcrypt==4.0.1
Requires-Dist: dependency-injector>=4.49.1
Requires-Dist: fastapi-mail>=1.5.2
Requires-Dist: fastapi[standard]>=0.128.8
Requires-Dist: passlib[bcrypt]>=1.7.4
Requires-Dist: psycopg[binary]>=3.2.13
Requires-Dist: pydantic>=2.13.4
Requires-Dist: pydantic-settings>=2.11.0
Requires-Dist: pyjwt>=2.13.0
Requires-Dist: python-baseconv>=1.2.2
Requires-Dist: python-dotenv>=1.2.1
Requires-Dist: python-slugify>=8.0.4
Requires-Dist: sqlalchemy>=2.0.51
Requires-Dist: sqlmodel>=0.0.34
Dynamic: license-file

# apibean-engine

**apibean-engine** is a schema-driven application framework for building modern, multi-tenant business applications.

It combines dynamic schema management, database abstraction, authentication, authorization, and REST API generation into a single, integrated package, allowing developers to rapidly build metadata-driven applications without assembling multiple frameworks.

The project is designed with a modular architecture. While the current release provides an all-in-one developer experience, major components such as the REST API layer and notebook integration are intended to evolve into standalone packages within the apibean ecosystem.

## Features

### Schema-Driven Applications

Define application models using JSON Schema instead of handwritten ORM models.

* Dynamic schema definition
* Runtime schema evolution
* Metadata-driven application design
* JSON object storage

### Database Abstraction

Access multiple storage technologies through a unified programming model.

Supported and planned backends include:

* PostgreSQL
* MySQL
* Redis
* MinIO
* OpenSearch
* TimescaleDB

The storage layer is designed to be extensible through backend adapters.

### Automatic REST APIs

Build RESTful APIs with minimal boilerplate.

Current integration is based on **FastAPI**, providing:

* CRUD endpoints
* Authentication
* Authorization
* Request validation
* OpenAPI documentation
* Dependency Injection

The REST layer is currently included in **apibean-engine** for simplicity and is planned to become a dedicated package in the future.

### Authentication & Authorization

Built-in security components include:

* User authentication
* Role-Based Access Control (RBAC)
* Permission management
* Resource-level authorization
* Extensible authentication providers

### Multi-Tenant Ready

The framework is designed for SaaS and enterprise applications.

Capabilities include:

* Organization management
* Tenant-aware data access
* Configurable isolation strategies
* Tenant-specific schemas and resources

Advanced multi-tenant features will be provided by the future **apibean-tenants** package.

### Extensible Plugin Architecture

Most framework capabilities are implemented through pluggable components.

Examples include:

* Database adapters
* Storage providers
* Search engines
* Time-series backends
* Authentication providers
* API extensions

## Architecture

```text
                   apibean-engine
    ┌─────────────────────────────────────────────┐
    │                                             │
    │  Schema Management                          │
    │  Metadata Runtime                           │
    │  Storage Adapters                           │
    │  Authentication                             │
    │  Authorization                              │
    │  REST API (FastAPI)                         │
    │  Dependency Injection                       │
    │                                             │
    └─────────────────────────────────────────────┘
                   │
        ┌──────────┼──────────┐
        ▼          ▼          ▼
   PostgreSQL   Redis      MinIO
        │
        ▼
   OpenSearch
        │
        ▼
   TimescaleDB
```

The internal architecture is modular, enabling individual components to be extracted into dedicated packages as the ecosystem grows.

## Design Principles

* Schema-first development
* Metadata-driven applications
* Convention with explicit customization
* Pluggable backend architecture
* Multi-tenant by design
* Framework-independent domain logic
* Production-ready defaults

## Future Ecosystem

As the project evolves, the framework will be organized into dedicated packages:

* **apibean-engine** — Core runtime and application framework
* **apibean-rest** — REST API integration
* **apibean-client** — Python API client
* **apibean-tenants** — Advanced multi-tenant management
* **apibean-jupyter** — Jupyter Server integration
* **apibean-notebook** — Interactive notebook utilities
* **apibean-base** — Shared utilities and common abstractions

Applications built today on **apibean-engine** will remain compatible as these components are gradually separated.

## Installation

```bash
pip install apibean-engine
```

## Vision

apibean-engine aims to provide a productive foundation for building metadata-driven applications. By combining schema management, storage abstraction, authentication, and REST APIs into a cohesive framework, it enables developers to focus on business logic rather than infrastructure.

The long-term vision is to grow into a modular ecosystem where individual capabilities can be adopted independently while maintaining a consistent developer experience.

## License

MIT License
