drizzle-adapter

Drizzle Adapter

Drizzle Adapter is the Drizzle ORM adapter for Node-Casbin. With this library, Node-Casbin can load policy from Drizzle ORM supported database or save policy to it.

Based on Officially Supported Databases, the current supported databases are:

• PostgreSQL
• MySQL
• SQLite
• Turso
• Neon
• PlanetScale
• Vercel Postgres
• Xata
• And more...

Installation

npm install drizzle-adapter
# or
yarn add drizzle-adapter

Simple Example

import { newEnforcer } from 'casbin';
import { drizzle } from 'drizzle-orm/better-sqlite3';
import Database from 'better-sqlite3';
import DrizzleAdapter, { casbinRuleSqlite } from 'drizzle-adapter';

async function myFunction() {
    // Initialize a SQLite database
    const sqlite = new Database('casbin.db');
    const db = drizzle(sqlite);
    
    // Create the casbin_rule table if it doesn't exist
    db.run(`
        CREATE TABLE IF NOT EXISTS casbin_rule (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            ptype TEXT,
            v0 TEXT,
            v1 TEXT,
            v2 TEXT,
            v3 TEXT,
            v4 TEXT,
            v5 TEXT
        )
    `);

    // Initialize a Drizzle adapter and use it in a Node-Casbin enforcer
    const a = await DrizzleAdapter.newAdapter({
        db: db,
        table: casbinRuleSqlite,
    });

    const e = await newEnforcer('examples/rbac_model.conf', a);

    // Load the policy from DB.
    await e.loadPolicy();

    // Check the permission.
    await e.enforce('alice', 'data1', 'read');

    // Modify the policy.
    // await e.addPolicy(...);
    // await e.removePolicy(...);

    // Save the policy back to DB.
    await e.savePolicy();
}

PostgreSQL Example

import { newEnforcer } from 'casbin';
import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import DrizzleAdapter, { casbinRulePostgres } from 'drizzle-adapter';

async function myFunction() {
    // Initialize a PostgreSQL connection
    const pool = new Pool({
        host: 'localhost',
        port: 5432,
        user: 'postgres',
        password: 'password',
        database: 'casbin',
    });
    const db = drizzle(pool);

    // Initialize a Drizzle adapter
    const a = await DrizzleAdapter.newAdapter({
        db: db,
        table: casbinRulePostgres,
    });

    const e = await newEnforcer('examples/rbac_model.conf', a);

    // Load the policy from DB.
    await e.loadPolicy();

    // Check the permission.
    await e.enforce('alice', 'data1', 'read');
}

MySQL Example

import { newEnforcer } from 'casbin';
import { drizzle } from 'drizzle-orm/mysql2';
import mysql from 'mysql2/promise';
import DrizzleAdapter, { casbinRuleMysql } from 'drizzle-adapter';

async function myFunction() {
    // Initialize a MySQL connection
    const connection = await mysql.createConnection({
        host: 'localhost',
        port: 3306,
        user: 'root',
        password: 'password',
        database: 'casbin',
    });
    const db = drizzle(connection);

    // Initialize a Drizzle adapter
    const a = await DrizzleAdapter.newAdapter({
        db: db,
        table: casbinRuleMysql,
    });

    const e = await newEnforcer('examples/rbac_model.conf', a);

    // Load the policy from DB.
    await e.loadPolicy();

    // Check the permission.
    await e.enforce('alice', 'data1', 'read');
}

Filtered Policy Example

import { newEnforcer } from 'casbin';
import { drizzle } from 'drizzle-orm/better-sqlite3';
import Database from 'better-sqlite3';
import DrizzleAdapter, { casbinRuleSqlite } from 'drizzle-adapter';

async function myFunction() {
    const sqlite = new Database('casbin.db');
    const db = drizzle(sqlite);

    const a = await DrizzleAdapter.newAdapter({
        db: db,
        table: casbinRuleSqlite,
    });

    const e = await newEnforcer('examples/rbac_model.conf', a);

    // Load the filtered policy from DB.
    await e.loadFilteredPolicy({
        'ptype': 'p',
        'v0': 'alice'
    });

    // Check the permission.
    await e.enforce('alice', 'data1', 'read');
}

Custom Table Schema

You can create a custom table schema if you need additional fields or different column names:

import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
import DrizzleAdapter from 'drizzle-adapter';

// Define a custom table schema
const customCasbinRule = sqliteTable('my_casbin_rules', {
    id: integer('id').primaryKey({ autoIncrement: true }),
    ptype: text('ptype'),
    v0: text('v0'),
    v1: text('v1'),
    v2: text('v2'),
    v3: text('v3'),
    v4: text('v4'),
    v5: text('v5'),
});

async function myFunction() {
    const sqlite = new Database('casbin.db');
    const db = drizzle(sqlite);

    const a = await DrizzleAdapter.newAdapter({
        db: db,
        table: customCasbinRule,
    });

    const e = await newEnforcer('examples/rbac_model.conf', a);
    await e.loadPolicy();
}

API Reference

DrizzleAdapter

newAdapter(options: DrizzleAdapterOptions): Promise<DrizzleAdapter>

Creates a new Drizzle adapter instance.

Options:

• db: Drizzle database instance
• table: (Optional) Drizzle table schema. Defaults to casbinRuleSqlite

loadPolicy(model: Model): Promise<void>

Loads all policy rules from the database.

loadFilteredPolicy(model: Model, filter: FilterOptions): Promise<void>

Loads policy rules that match the filter from the database.

FilterOptions:

• ptype: Policy type (e.g., 'p', 'g')
• v0 to v5: Policy values

savePolicy(model: Model): Promise<boolean>

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

addPolicy(sec: string, ptype: string, rule: string[]): Promise<void>

Adds a policy rule to the database.

addPolicies(sec: string, ptype: string, rules: string[][]): Promise<void>

Adds multiple policy rules to the database.

removePolicy(sec: string, ptype: string, rule: string[]): Promise<void>

Removes a policy rule from the database.

removePolicies(sec: string, ptype: string, rules: string[][]): Promise<void>

Removes multiple policy rules from the database.

removeFilteredPolicy(sec: string, ptype: string, fieldIndex: number, ...fieldValues: string[]): Promise<void>

Removes policy rules that match the filter from the database.

updatePolicy(sec: string, ptype: string, oldRule: string[], newRule: string[]): Promise<void>

Updates a policy rule in the database.

isFiltered(): boolean

Returns whether the loaded policy has been filtered.

Getting Help

• Node-Casbin
• Drizzle ORM

License

This project is under Apache 2.0 License. See the LICENSE file for the full license text.