Sqlpp11 Adapter

Sqlpp11 Adapter is a sqlpp11 adapter for Casbin. With this library, Casbin can load policy from MySQL database or save policy to it.

Features

Load policy from MySQL database
Save policy to MySQL database
Full support for Casbin policy management
Built on top of the powerful sqlpp11 library

Installation

Requirements

C++17 or higher
CMake 3.19 or higher
Casbin-CPP
sqlpp11
MySQL client library

Building from source

git clone https://github.com/casbin-cpp/sqlpp11-adapter
cd sqlpp11-adapter
mkdir build && cd build
cmake ..
cmake --build .

Usage

Basic Example

#include "include/sqlpp11_adapter.h"
#include <casbin/casbin.h>

int main() {
    // Create adapter with MySQL connection parameters
    auto adapter = std::make_shared<casbin::Sqlpp11Adapter>(
        "localhost",  // host
        "root",       // user
        "password",   // password
        "casbin",     // database
        3306          // port (default: 3306)
    );
    
    // Create the table (if it doesn't exist)
    adapter->CreateTable();
    
    // Create enforcer with model file and adapter
    auto enforcer = std::make_shared<casbin::Enforcer>(
        "path/to/model.conf", 
        adapter
    );
    
    // Load policy from database
    enforcer->LoadPolicy();
    
    // Add policies
    enforcer->AddPolicy("alice", "data1", "read");
    enforcer->AddPolicy("bob", "data2", "write");
    
    // Save policy to database
    enforcer->SavePolicy();
    
    // Check permissions
    if (enforcer->Enforce("alice", "data1", "read")) {
        // alice can read data1
    }
    
    return 0;
}

Model Configuration

Create a model configuration file (e.g., rbac_model.conf):

[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[role_definition]
g = _, _

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

API Reference

Constructor

Sqlpp11Adapter(const std::string& host, 
               const std::string& user,
               const std::string& password, 
               const std::string& database,
               unsigned int port = 3306);

Creates a new adapter instance with the specified MySQL connection parameters.

Methods

LoadPolicy

void LoadPolicy(const std::shared_ptr<Model>& model) override;

Loads all policy rules from the database.

SavePolicy

void SavePolicy(Model& model) override;

Saves all policy rules to the database (replaces existing policies).

CreateTable

void CreateTable();

Creates the casbin_rule table if it doesn't exist.

DropTable

void DropTable();

Drops the casbin_rule table if it exists.

Database Schema

The adapter uses a table named casbin_rule with the following schema:

CREATE TABLE casbin_rule (
    id INT AUTO_INCREMENT PRIMARY KEY,
    ptype VARCHAR(100) NOT NULL,
    v0 VARCHAR(100),
    v1 VARCHAR(100),
    v2 VARCHAR(100),
    v3 VARCHAR(100),
    v4 VARCHAR(100),
    v5 VARCHAR(100)
);

Testing

To run the tests:

cd build
./test

Make sure you have a MySQL server running and accessible with the connection parameters used in the test.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

Acknowledgments

Casbin - An authorization library that supports access control models
sqlpp11 - A type safe SQL template library for C++