duxt_orm library

DuxtOrm - ActiveRecord-style ORM for Duxt framework.

Supports PostgreSQL, MySQL, and SQLite with GORM-like auto-migrations.

Quick Start

import 'package:duxt_orm/duxt_orm.dart';

// 1. Define your model (extend Entity)
class User extends Entity {
  int? _id;
  String? email;
  String? name;

  User({int? id, this.email, this.name}) : _id = id;

  @override dynamic get id => _id;
  @override set id(dynamic value) => _id = value as int?;

  @override
  Map<String, dynamic> toMap() => {'email': email, 'name': name};

  factory User.fromRow(Map<String, dynamic> row) => User(
    id: row['id'] as int?,
    email: row['email'] as String?,
    name: row['name'] as String?,
  );

  static void register() => Entity.registerModel[User](User.fromRow, schema: {
    'id': Column.integer().primaryKey().autoIncrement(),
    'email': Column.string(255).unique().notNull(),
    'name': Column.string(100).notNull(),
  });
}

// 2. Initialize
User.register();
await DuxtOrm.init(DuxtConfig.database);
await DuxtOrm.migrate();

// 3. Use Model[T] for queries - Rails-like syntax!
final users = Model[User]();

final all = await users.all();
final user = await users.find(1);
final admins = await users.where('role', 'admin').get();
await users.create({'email': '[e-mail]', 'name': 'Test'});

ModelT Query API

final posts = Model[Post]();

// CRUD
await posts.all();
await posts.find(1);
await posts.create({'title': 'Hello'});

// Query Builder
await posts.where('published', true).get();
await posts.where('views', 100, '>').orderByDesc('created_at').limit(10).get();

// Aggregates
await posts.count();
await posts.where('published', true).count();

Relations

class Post extends Entity {
  int? categoryId;
  Category? get category => getRelation[Category]('category');

  static void register() {
    Entity.registerModel[Post](Post.fromRow, schema: {...});
    Entity.registerRelation[Post]('category', BelongsTo[Category](foreignKey: 'category_id'));
  }
}

// Eager load relations
final posts = await Model[Post]().include(['category']).get();
print(posts.first.category?.name);

Classes

BelongsTo<T extends Entity>

Defines a "belongs to" relationship.

BelongsToMany<T extends Entity>

Defines a "belongs to many" (many-to-many) relationship.

Column

Column definition for schema.

DatabaseAdapter

Database adapter interface.

DuxtOrm

DuxtOrm - ActiveRecord-style ORM for Duxt framework.

Entity

Base class for all ORM models.

HasMany<T extends Entity>

Defines a "has many" relationship.

HasOne<T extends Entity>

Defines a "has one" relationship.

Migrator

Database migration helper.

Model<T extends Entity>

Query interface for models - provides clean Rails-like syntax.

MySqlAdapter

MySQL database adapter.

PostgresAdapter

PostgreSQL database adapter.

QueryBuilder<T extends Entity>

Fluent query builder for constructing SQL queries.

QueryResult

Database adapter interface and related classes for DuxtOrm. Result from a database query.

Relation<T extends Entity>

Base class for all relation definitions.

Schema

Schema definition for a model.

SqliteAdapter

SQLite database adapter.

Transaction

Transaction interface.

Enums

ColumnType

Column type definitions for schema.

Typedefs

DatabaseConfig = ({String database, String driver, String host, String password, String path, int port, bool ssl, String username})

Database configuration record.

Exceptions / Errors

RecordNotFoundException

Exception thrown when a record is not found.