sequelize vs objection vs bookshelf vs waterline | Comparaison des packages npm "ORM (Object-Relational Mapping)"

Package	Téléchargements	Stars	Taille	Issues	Publication	Licence

sequelize	1,750,972	29,910	2.91 MB	958	il y a 11 jours	MIT
objection	142,323	7,317	645 kB	120	il y a 6 mois	MIT
bookshelf	54,725	6,368	-	237	il y a 5 ans	MIT
waterline	28,830	5,410	1.3 MB	32	-	MIT

Package

Téléchargements

Stars

Taille

Issues

Publication

Licence

sequelize

1,750,972

29,910

2.91 MB

958

il y a 11 jours

MIT

objection

142,323

7,317

645 kB

120

il y a 6 mois

MIT

bookshelf

54,725

6,368

237

il y a 5 ans

MIT

waterline

28,830

5,410

1.3 MB

MIT

Taille et Performance

sequelize:
Sequelize est un ORM complet avec de nombreuses fonctionnalités, ce qui peut entraîner une certaine surcharge. Cependant, il est optimisé pour les performances et convient aux applications de taille moyenne à grande.
objection:
Objection.js est conçu pour être performant et léger, tirant parti de Knex.js pour les requêtes SQL. Il offre un bon équilibre entre fonctionnalité et performance, ce qui le rend adapté aux applications de toutes tailles.
bookshelf:
Bookshelf est plus léger que Sequelize, mais sa performance dépend de la manière dont il est utilisé. Il est idéal pour les applications qui n'ont pas besoin de toutes les fonctionnalités avancées d'un ORM complet.
waterline:
Waterline peut être moins performant que les autres ORM en raison de son abstraction agnostique par rapport à la base de données. Cependant, il est suffisamment rapide pour la plupart des applications, en particulier celles construites avec Sails.js.

Conception de l'API

sequelize:
Sequelize propose une API riche et bien documentée, avec un support complet pour les modèles, les relations et les transactions. Son API est intuitive, mais la richesse des fonctionnalités peut rendre la courbe d'apprentissage un peu raide.
objection:
Objection.js se concentre sur la simplicité et la clarté dans la conception de son API. Il permet aux développeurs de créer des modèles et des relations rapidement, tout en offrant des fonctionnalités avancées lorsque cela est nécessaire.
bookshelf:
Bookshelf fournit une API simple et élégante pour travailler avec des modèles et des relations. Il est facile à utiliser, surtout si vous êtes déjà familier avec Knex.js, ce qui le rend accessible aux développeurs de tous niveaux.
waterline:
Waterline offre une API unifiée pour interagir avec différentes bases de données, ce qui facilite le travail avec plusieurs dialectes. Cependant, son abstraction peut rendre certaines opérations plus complexes.

Gestion des Relations

sequelize:
Sequelize gère les relations entre les modèles de manière robuste, prenant en charge les relations un à un, un à plusieurs et plusieurs à plusieurs. Il fournit des méthodes intégrées pour gérer les relations, y compris le chargement paresseux et le chargement anticipé.
objection:
Objection.js fournit une gestion des relations puissante et flexible, permettant aux développeurs de définir des relations de manière déclarative. Il prend en charge le chargement paresseux et anticipé, ainsi que les relations imbriquées.
bookshelf:
Bookshelf excelle dans la gestion des relations, offrant une approche simple et intuitive pour définir et travailler avec les relations entre les modèles. Il prend en charge les relations complexes et permet une personnalisation facile.
waterline:
Waterline prend en charge les relations entre les modèles, mais sa gestion des relations peut être moins intuitive que celle des autres ORM. Il prend en charge les relations un à un, un à plusieurs et plusieurs à plusieurs, mais la documentation peut être limitée.

Migration et Validation

sequelize:
Sequelize dispose d'un système de migration intégré et prend en charge la validation des données au niveau du modèle. Il fournit des outils pour créer et gérer des migrations, ce qui facilite la gestion des schémas de base de données au fil du temps.
objection:
Objection.js n'inclut pas de système de migration, mais il s'appuie sur Knex.js, qui offre des fonctionnalités de migration robustes. La validation peut être effectuée à l'aide de bibliothèques tierces ou en définissant des méthodes de validation personnalisées dans les modèles.
bookshelf:
Bookshelf ne dispose pas de système de migration intégré, mais il peut être facilement intégré à Knex.js pour gérer les migrations. La validation doit être implémentée manuellement ou à l'aide de bibliothèques tierces.
waterline:
Waterline prend en charge les migrations et la validation, mais ces fonctionnalités peuvent ne pas être aussi robustes que celles des autres ORM. La validation peut être effectuée au niveau du modèle, mais le système de migration peut nécessiter des ajustements.

Exemple de Code

sequelize:

Exemple de modèle Sequelize avec relations et migrations

const { Sequelize, DataTypes } = require('sequelize');
const sequelize = new Sequelize('sqlite::memory:');

// Définir un modèle
const User = sequelize.define('User', {
  username: {
    type: DataTypes.STRING,
    allowNull: false,
  },
});

const Post = sequelize.define('Post', {
  title: {
    type: DataTypes.STRING,
    allowNull: false,
  },
});

// Définir les relations
User.hasMany(Post);
Post.belongsTo(User);

// Synchroniser les modèles avec la base de données
(async () => {
  await sequelize.sync({ force: true });
  console.log('Base de données synchronisée');
})();

objection:

Exemple de modèle Objection.js avec relations

const { Model } = require('objection');
const Knex = require('knex');

const knex = Knex({
  client: 'sqlite3',
  connection: { filename: './data.db' },
});
Model.knex(knex);

class User extends Model {
  static get tableName() {
    return 'users';
  }

  static get relationMappings() {
    return {
      posts: {
        relation: Model.HasManyRelation,
        modelClass: Post,
        join: {
          from: 'users.id',
          to: 'posts.userId',
        },
      },
    };
  }
}

class Post extends Model {
  static get tableName() {
    return 'posts';
  }
}

// Créer les tables et insérer des données
(async () => {
  await knex.schema.createTable('users', (table) => {
    table.increments();
    table.string('name');
  });
  await knex.schema.createTable('posts', (table) => {
    table.increments();
    table.string('title');
    table.integer('userId').references('id').inTable('users');
  });

  const user = await User.query().insert({ name: 'Alice' });
  const post = await Post.query().insert({ title: 'Hello World', userId: user.id });
  console.log('Utilisateur et post créés');
})();

bookshelf:

Exemple de modèle Bookshelf avec relations

const knex = require('knex')({
  client: 'sqlite3',
  connection: { filename: './data.db' },
});
const bookshelf = require('bookshelf')(knex);

// Définir un modèle
const User = bookshelf.model('User', {
  tableName: 'users',
});

const Post = bookshelf.model('Post', {
  tableName: 'posts',
  user() {
    return this.belongsTo(User);
  },
});

// Créer une instance de modèle
(async () => {
  await knex.schema.createTable('users', (table) => {
    table.increments();
    table.string('username');
  });
  await knex.schema.createTable('posts', (table) => {
    table.increments();
    table.string('title');
    table.integer('user_id').references('id').inTable('users');
  });

  const user = await User.forge({ username: 'Alice' }).save();
  const post = await Post.forge({ title: 'Hello World', user_id: user.id }).save();
  console.log('Utilisateur et post créés');
})();

waterline:

Exemple de modèle Waterline avec relations

const Waterline = require('waterline');
const MongoAdapter = require('sails-mongo'); // Exemple d'adaptateur

const orm = new Waterline();
const config = {
  adapters: {
    mongo: MongoAdapter,
  },
  connections: {
    myMongoDB: {
      adapter: 'mongo',
      url: 'mongodb://localhost:27017/mydb',
    },
  },
};

const userModel = Waterline.Collection.extend({
  identity: 'user',
  connection: 'myMongoDB',
  attributes: {
    name: { type: 'string' },
    posts: { collection: 'post', via: 'user' },
  },
});

const postModel = Waterline.Collection.extend({
  identity: 'post',
  connection: 'myMongoDB',
  attributes: {
    title: { type: 'string' },
    user: { model: 'user' },
  },
});

orm.loadCollection(userModel);
orm.loadCollection(postModel);

orm.initialize(config, (err, models) => {
  if (err) throw err;
  console.log('Waterline ORM initialisé');
});