apibean-engine 0.1.0a1

A schema-driven application engine for building multi-tenant REST APIs with dynamic data models, storage abstraction, and pluggable backend integrations.

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

                   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

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