flutter_orm_m8 0.7.1

Flutter package for ORM annotations. It defines ColumnMetadata, TableMetadata, DataTable, DataColumn annotations. Targeted audience is code generators

Flutter ORM Mate - flutter_orm_m8

Flutter package for ORM annotations.

• Flutter ORM Mate - flutter_orm_m8
  • Introduction
  • Annotations
    • DataTable
      • TableMetadata
    • DataColumn
      • ColumnMetadata
      • CompositeConstraint
      • A simple approach
      • A fine tuned approach
  • Interfaces
    • DbOpenEntity
    • DbEntity
    • DbAccountEntity
    • DbAccountRelatedEntity implements DbEntity
  • Usage

Introduction

The package 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:

• DataTable
  • TableMetadata
• DataColumn
  • ColumnMetadata
  • CompositeConstraint

In order to ease the code emitting, four abstract classes are defined:

• DbOpenEntity
• DbEntity
• DbAccountEntity implements DbEntity
• DbAccountRelatedEntity implements DbEntity

Annotations

DataTable

DataTable describes the required name for the table in conjuction 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 add the required fields.

@DataTable(
  "a01_tests",
  metadataLevel: TableMetadata.softDeletable | TableMetadata.trackCreate | TableMetadata.trackUpdate)
class A01Test implements DbAccountRelatedEntity {

TableMetadata

The TableMetadata describes the basic options for the table:

• softDeletable
• trackCreate
• trackUpdate

The options may be combined in various ways using | operator

@DataTable(
    "health_issues",
    metadataLevel: 
      TableMetadata.softDeletable | 
      TableMetadata.trackCreate | 
      TableMetadata.trackUpdate)

DataColumn

The DataColumn describes how the fields will be transformed into entity attributes. The DataColumn constructor has three parameters:

• name
  • purpose: to specify the entity name
  • type: String
  • positional
  • mandatory
• metadataLevel
  • purpose: syntactic sugar to specify common use cases
  • type: int as combination of ColumnMetadata
  • named
  • optional
• compositeConstraints
  • purpose: a fine grain mode to specify composite constraints
  • type: List<CompositeConstraint>
  • named
  • optional

 const DataColumn(this.name, {this.metadataLevel, this.compositeConstraints});

ColumnMetadata

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:

• ignore
• primaryKey
• unique
• notNull
• autoIncrement
• indexed

The options can be combined in various ways using | operator

@DataColumn(
  "id", 
  metadataLevel: ColumnMetadata.primaryKey | ColumnMetadata.unique | ColumnMetadata.autoIncrement)

The primaryKey, unique, indexed constraints can be generated in a targetted way using CompositeConstraint

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:
  • unique,
  • primaryKey,
  • foreignKey,
  • indexed

A simple approach

DataColumn describes the required name for the column in conjunction with a bit mask for required column metadata.

  @DataColumn(
    "id", 
    metadataLevel: 
      ColumnMetadata.primaryKey | 
      ColumnMetadata.unique | 
      ColumnMetadata.autoIncrement)
  int id;

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:

  @DataColumn("account_id", compositeConstraints: [
    CompositeConstraint(
        name: "uq_account_entry",
        constraintType: CompositeConstraintType.unique)
  ])
  int accountId;

  @DataColumn("description", compositeConstraints: [
    CompositeConstraint(
        name: "uq_account_entry",
        constraintType: CompositeConstraintType.unique)
  ])
  String description;

Interfaces

DbOpenEntity

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

DbEntity

Can be used for a general purpose model template with integer primary key named id

DbAccountEntity

It implements DbEntity. Can be used for a model template in a generic user account with the following fields:

• userName
• email
• abbreviation
• isCurrent

DbAccountRelatedEntity implements DbEntity

It implements DbEntity. Can be used for a model template in a generic, account dependent, entity with the following fields:

• accountId

Usage

The package can be a start for other projects that aim to develop an ORM. Such a project is https://github.com/matei-tm/flutter-sqlite-m8-generator

@DataTable("a01_tests", TableMetadata.softDeletable)
class A01Test implements DbAccountRelatedEntity {
  @DataColumn(
    "id", 
    metadataLevel: ColumnMetadata.primaryKey | ColumnMetadata.unique | ColumnMetadata.autoIncrement)
  int id;

  @DataColumn("account_id", compositeConstraints: [
    CompositeConstraint(
        name: "uq_account_entry",
        constraintType: CompositeConstraintType.unique)
  ])
  int accountId;

  @DataColumn("description", compositeConstraints: [
    CompositeConstraint(
        name: "uq_account_entry",
        constraintType: CompositeConstraintType.unique)
  ])
  String description;

  @DataColumn("record_date")
  int recordDate;
}