ilorm (I Love ORM)

New way to manipulate data with NodeJS.

You can found example and documentation on the Official Ilorm website

Why a new ORM ?

• Elegant way to separate database from business logic.
• Easy way to create powerful plugins using the "class" inheritance.
• Universal database / data source connector (MongoDB, SQL, Redis, REST, CSV...).
• Use newest feature of ECMAScript (modern javascript).

Features

• Universal connector to bind every kind of database or data source.
• Powerful plugin ecosystem
• Query builder
• Data validation

# Contributing Please, refer to our code of conduct before starting and to our contributing guide.

Initialize

Schema

With a Schema you define the way your data are represented.

const ilorm = require('ilorm');
const schema = ilorm.schema;

const userSchema = schema.new({
  firstName: schema.String().required(),
  lastName: schema.String().required(),
  children: schema.Array(schema.reference('User')),
  birthday: schema.Date(),
  weight: schema.Number().min(5).max(500)
});

ilorm.schema

| Function | Description | |:--------:|-------------| | static new( schema ) | Create a new ilorm schema. | | static string() | Instantiate a Field/String | | static number() | Instantiate a Field/Number | | static boolean() | Instantiate a Field/Boolean | | static date() | Instantiate a Field/Date | | static reference() | Instantiate a Field/Reference |

All Fields

All Fields are children of the class BaseField. This class contains this method :

| Function | Description | |:--------:|-------------| | required() | The field is required for create an object (per default not required). | | default(value) |  Set a precise value for default (if you do not set a value at creation). |

Field/Number

Represent a javascript number.

Field/String

Represent a javascript string.

Field/Boolean

Represent a javascript boolean.

Field/Date

Represent a javascript date.

Field/Reference

Represent a javascript reference to another instance.

Models

const ilorm = require('ilorm');
const ilormMongo = require('ilorm-connector-mongo');

const userSchema = require('./schema');
const userModel = ilorm.newModel({
  name:'User',
  connector: ilormMongo({ db }),
  schema: userSchema,
});

userModel.query()
  .firstName.is('Smith')
  .findOne()
  .then(user => {
    user.weight = 30;
    return user.save();
  });

ilorm.model

| Function | Description | |:--------:|-------------| | query()  | Instantiate a Query targeting the current Model |

Query

Fields

In a query, every field present in the schema could be use to build the query. The [field] part in further documentation are every field declared in your specific schema.

Exemple of query

// if your schema is something like this ;
const schema = ilorm.schema({
  firstName: ilorm.String().required(),
});

// You could write query like this :
const user = await User.query()
    .firstName.is('Smith')
    .findOne();

Filters

| Function | Description | |:--------:|-------------| | [field].is(value) | Check if the field is equal value | | [field].isNot(value) | Check if the field is not equal with value | | [field].isIn(arrayOfValue) | Check if the field value is one of the array value | | [field].isNotIn(arrayOfValue) | Check if the field value is none of array value | | [field].between(min, max) | Check if the value is between min and max (include)| | [field].min(value) | Check if the value is equal or superior than the value | | [field].max(value) | Check if the value is equal or inferior than the value | | [field].linkedWith(value) | Check if the field (reference) is linked with another model, id, ... |

Update

Used for update or updateOne query only :

| Function | Description | |:--------:|-------------| | [field].set(value) | Set the value of the field | | [field].inc(value) | Incremente the value of the field by the given value |

Operations

| Function | Description | |:--------:|-------------| | find() | Run the query and return a promise with the result (array of instance). | | findOne() | Run the query and return a promise the result (instance). | | count() | Count the number of instance and return it. | | stream() | Run the query with a stream context could be the best solution for big query. | | remove() | Remove the instance which match the query. | | removeOne() | Remove only one instance which math the query. | | update() | Used to update many instance. | | updateOne() | Used to update one instance. |

Query.update

userModel.query()
  .firstName.is('Smith')
  .weight.set(30)
  .update();

Query.stream

userModel.query()
  .stream() //Return a standard stream
  .pipe(otherStream);

Instances

Instances are returned after a loading (find, or stream). It's a specific item loaded from the database. You can create a new instance from the model :

const instance = new userModel();
instance.firstName = 'Thibauld';
instance.lastName = 'Smith';
instance.save();

| Function | Description | |:--------:|-------------| | save() | Save the instance in the database (auto insert or update) | | remove() | Delete the instance from the database |