Venir de Mongoose

Pour un serveur Node.js qui utilise Mongoose : chaque forme de Mongoose et son équivalent dans IshedDB. Le plus souvent, le plus court chemin est d'écrire comme le pilote MongoDB, que la bibliothèque Node.js suit : client.db('Fann').collection('patients').find({ ville: 'Dakar' }).sort({ âge: -1 }).toArray(), findOne, countDocuments, insertOne, insertMany, updateOne, updateMany, replaceOne, deleteOne, deleteMany, aggregate. Les tableaux ci-dessous donnent aussi l'équivalent dans la syntaxe propre à IshedDB, en chaîne.

Connexion

// Mongoose
await mongoose.connect(process.env.MONGODB_URI);

// IshedDB
import { connect } from '@ished/client';
const db = connect({ url: process.env.ISHED_URL, key: process.env.ISHED_KEY }).db('DB');

Les modèles deviennent des définitions

Une définition se pose une fois, avec une clé « administration », par un script de déploiement. Elle n'est pas redéclarée à chaque démarrage.

Mongoose	IshedDB (`collection.define({...})`)
`{ type: String, required: true }`	`fields: { nom: { type: 'string', required: true } }`
`default: 'Payé'`, `default: 0`, `default: null`	`default: 'Payé'`, `default: 0`, `default: null`
`default: Date.now`	`default: serverTime()`
`trim: true`, `lowercase: true`	`trim: true`, `lowercase: true`
`enum: ['Thoracique', 'Cardiaque']`	`oneOf: ['Thoracique', 'Cardiaque']`
`select: false`	`hidden: true`
`min: 0`, `max: 130`	`min: 0`, `max: 130`
`minlength: 2`, `maxlength: 80`	`minLength: 2`, `maxLength: 80`
`{ timestamps: true }`	`timestamps: true`
`unique: true`	`unique: ['user']`
`schema.index({ patientId: 1 })`	`indexes: ['patientId']`
`index({ expiresAt: 1 }, { expireAfterSeconds: 0 })`	`expireAt: 'expiresAt'`
`ref: 'Patient'` (sans `populate`)	l'identifiant reste un texte ; aucun changement

Les appels

Mongoose	IshedDB
`Model.findById(id)`	`col.doc(id).get()` → `{ id, data }` ou `null`
`Model.findById(id).select('+passwordHash')`	`col.doc(id).get({ reveal: ['passwordHash'] })`
`Model.findOne({ email })`	`col.where('email', '==', email).first()`
`Model.find({ service }).sort({ nom: 1 })`	`col.where('service', '==', service).orderBy('nom').get()`
`.sort({ createdAt: -1 }).limit(20)`	`.orderBy('createdAt', 'desc').limit(20)`
`.select('name role')`	`.select('name', 'role')`
`Model.countDocuments(filtre)`	`col.where(…).count()`
`Model.exists(filtre)`	`col.where(…).exists()`
`Model.create(data)` ou `new Model(data).save()`	`col.add(data)`
`doc.champ = v; await doc.save()`	`col.doc(id).update({ champ: v })`
`Model.findByIdAndUpdate(id, { $set: f }, { new: true })`	`col.doc(id).update(f)` (renvoie le document modifié)
`Model.updateOne({ _id: id }, { $unset: { champ: 1 } })`	`col.doc(id).update({ champ: remove() })`
`findOneAndUpdate(f, u, { upsert: true, new: true })`	`col.where(…).updateFirst(u, { create: true })`
`Model.deleteOne({ user })`	`col.where('user', '==', user).deleteFirst()`
`Model.findByIdAndDelete(id)`	`col.doc(id).delete()`
`aggregate([$match, $group/$sum, $sort, $limit 1])`	`col.where(…).countBy('userId', { order: 'desc', limit: 1 })`

Les opérateurs

Mongoose	IshedDB
`{ champ: valeur }`	`.where('champ', '==', valeur)`
`{ champ: { $ne: null } }`	`.where('champ', '!=', null)` (le champ existe et n'est pas nul)
`{ champ: { $exists: true } }` / `false`	`.where('champ', 'exists')` / `.where('champ', 'missing')`
`{ champ: { $gt: v } }`, `$gte`, `$lt`, `$lte`	`.where('champ', '>', v)`, `>=`, `<`, `<=`
`{ champ: { $in: [...] } }` / `$nin`	`.where('champ', 'in', [...])` / `'not-in'`
`$set: { 'a.b': v }`	`.update({ 'a.b': v })`
`$unset: { champ: 1 }`	`.update({ champ: remove() })`
`$inc: { n: 1 }`	`.update({ n: increment(1) })`

Trois différences à connaître

{ champ: null } : dans MongoDB, cela trouve aussi les documents sans ce champ. Dans IshedDB, == null ne trouve que les valeurs nulles. Pour les absents, écrire .where('champ', 'missing').
Les comparaisons restent dans un type : .where('âge', '>', 40) ne retient que les âges qui sont des nombres, jamais le texte "50".
Le document lu est { id, data, createTime, updateTime } : les champs sont dans data, et _id devient id. Pour l'ancien code, on peut écrire const p = { _id: doc.id, ...doc.data }.