Another ORM? Why?
Immersing to the world of Flutter is a real and captivating adventure. Being a fairly new framework, there are plenty of opportunities to develop new libraries. As a result, I thought it was a good opportunity to set up an ORM to answer more questions. The goal is to have a framework that, besides relational mapping, provides the possibility to generate scaffolds for basic usage cases: user account, user data, data tracking (create, update, delete), soft delete. And that’s how begins the story of f-orm-m8.
The framework adds definitions for a set of types that could be combined to expand ORM capabilities in the annotated code. The current version defines two main annotation types and some helpers associated with each definition:
In order to ease the code emitting, four abstract classes are defined:
- DbOpenEntity: non constrained entity
- DbEntity: an entity with Id as primary key
- DbAccountEntity: a user account template with Id as primary key
- DbAccountRelatedEntity: user related data entities
DataTable describes the required name for the table in conjunction with a bit mask for optional TableMetadata. Table metadata is specified with the parameter
metadataLevel, and is a syntactic sugar to generate the proper fixture without explicitly adding the required fields.
The TableMetadata describes the basic options for the table:
The options may be combined in various ways using | operator
The DataColumn describes how the fields will be transformed into entity attributes. The DataColumn constructor has three parameters:
- purpose: to specify the entity name
- type: String
- purpose: syntactic sugar to specify common use cases
- type: int as combination of ColumnMetadata
- purpose: a fine grain mode to specify composite constraints
- type: List<CompositeConstraint>
Column metadata is specified with the parameter
metadataLevel. Is a syntactic sugar to generate a quick fixture, offering basic options for the following use cases:
The options can be combined in various ways using | operator
indexed constraints can be generated in a targetted way using CompositeConstraint
The composite constraint is able to specify the name and the type of the constraint. If the same name is used on multiple DataColumns, it will signal a composite constraint that will cover all the involved fields. The CompositeConstraint is instantiated with named, required parameters:
- name — the name of the constraint
- constraintType — the type of the constraint as enum with the following values:
A simple approach
DataColumn describes the required name for the column in conjunction with a bit mask for required column metadata.
A fine tuned approach
DataColumn describes the required name for the column in conjunction with a list of composite constraints. For example, if we need a composite, unique constraint defined on the combination of two fields, we define the composite with the same name:
DbOpenEntity is, as it’s name suggests, a template for non restrictive models with composite primary keys. It can also be used for non integer primary key implementation.
It defines a single method getPrimaryKey
Can be used for a general purpose model template with integer primary key named
It implements DbEntity. Can be used for a model template in a generic user account with the following fields:
DbAccountRelatedEntity implements DbEntity
It implements DbEntity. Can be used for a model template in a generic, account dependent, entity with the following fields:
The package can be a start for other projects that aim to develop an ORM scaffolding infrastructure. It is up to developers how they implement the gems of this package. We recommend the annotations to be placed as in the following example:
All set? Let’s go
You’re looking for an implementation, aren’t you? Then, read how to quickly create a CRUD application with f-orm-m8.
The core of M8, a Dart tiny ORM framework with a simple set of annotations - matei-tm/f-orm-m8
May the f-orm-m8 be with you!