# Database trong NodeJS ## 1. Giới thiệu Trong `NodeJS`, có thể sử dụng nhiều loại Database khác nhau như: - Kiểu `database` quan hệ: `MySQL`, `PostgreSQL`, `SQLite`, `MariaDB`, `Oracle`, `MS SQL Server`. - Kiểu `database` không quan hệ: `MongoDB`, `Cassandra`, `CouchDB`, `Redis`, `RethinkDB`, `LevelDB`. ## 2. Sử dụng MySQL trong NodeJS ### 2.1. Cài đặt package `mysql` Sử dụng `mysql2` để kết nối với `MySQL` trong `NodeJS`. ```bash $ npm install mysql2 ``` ### 2.2. Kết nối với `MySQL` Kết nối với `MySQL` ta được một `pool` connection trả về 1 `Promise` để thực hiện các câu lệnh `SQL`. ```javascript const mysql = require("mysql2"); // Nhâp thư viện mysql2 // Tạo 1 pool để kết nối tới database (pool là 1 tập hợp các kết nối) const pool = mysql.createPool({ host: "localhost", // Địa chỉ host user: "root", // Tên user database: "node-shop", // Tên database password: "17052002", // Mật khẩu }); module.exports = pool.promise(); // Xuất pool để sử dụng ở các file khác là 1 promise, trả về then(), catch() để xử lý tránh bị callback hell ``` Từ khi `export` `pool` dưới dạng `promise`, ta có thể sử dụng `then()`, `catch()` để xử lý dễ dàng hơn với hàm `execute(, <[mảng tham số]>)`. Dữ liệu trả về của hàm `execute` là một mảng gồm 2 phần tử: - `rows`: Mảng các dòng dữ liệu trả về từ truy vấn. - `fieldData`: Thông tin về các trường dữ liệu. > VD ```javascript const db = require("../util/database"); // Import pool đã tạo ở trên const result = db.execute("SELECT * FROM `products` WHERE `id` = ?", [1]) .then(([rows, fieldData]) => { console.log(rows); // In ra mảng các dòng dữ liệu }).catch(err => { console.log(err); // In ra lỗi nếu có }); ``` ### 2.3. Ví dụ về sử dụng `MySQL` trong `NodeJS` (Thực hiện ở `model` và `controller`) > model/products.js ```javascript const Cart = require("./carts") const db = require("../util/database"); class Product { constructor(data, idUpdate) { this.product = data; this.product.id = idUpdate } // {ADD TO DATABASE} // save(isDelete=null) { return db.execute('INSERT INTO `node-shop`.`product-test` (name, price, description) VALUES (?, ?, ?)', [this.product.name, this.product.price, this.product.description] ) // Các dấu "?" là 1 tham số lần được truyền vào thông qua các phần tử mảng [id] ở bên ngoài } // {GET ALL PRODUCTS FROM MYSQL} // static fetchAll() { return db.execute('SELECT * FROM `node-shop`.`product-test`') } // {GET PRODUCT BY ID FROM MYSQL} // static findByID(id) { return db.execute('SELECT * FROM `node-shop`.`product-test` WHERE products.id = ?', [id]) // Các dấu "?" là 1 tham số lần được truyền vào thông qua các phần tử mảng [id] ở bên ngoài } } module.exports = Product; ``` > controller/products.js ```javascript ... // {ADD TO DATABASE} // const postProduct = (req, res) => { const data = JSON.parse(JSON.stringify(req.body)); const product = new Product(data, null); product.save().then(() => { res.redirect("/"); }) .catch(err => console.log(err)); }; // {GET ALL PRODUCTS FROM MYSQL} // const getProduct = (req, res) => { Product.fetchAll() .then(([value, field]) => { // Kết quả trả về của promise là 1 array chứa 2 phần tử là [data] và field [[data], field] => dùng destructuring để lấy ra trong hàm callback của then res.render("./admin/products", { title: "Admin Product", items: value, path: "/admin/product", }); }) .catch((err) => console.log(err)); }; // {ADD EDIT PRODUCT} // const getEditProduct = (req, res) => { const isEdit = req.query.edit; // lấy giá trị của query 'edit' từ url (vd url = "http://.../edit-poduct?id=1&edit=true" => isEdit = "true") if (!isEdit) { // nếu không có query 'edit' thì chuyển hướng về trang chủ res.redirect("/"); } else { // nếu có query 'edit' const ID = req.params.productID; // Lấy productID của url có routes động (http://.../:productID) Product.findByID(ID, (product) => { // Nếu ko tìm được product có id = ID if (!product) { res.redirect("/"); } // Nếu tìm được render ra editProduct else { res.render("./admin/editProduct", { title: "Edit Product", path: "/admin/add-product", editing: isEdit, // truyền giá trị của query 'edit' vào biến editing để kiểm tra xem có phải đang ở trạng thái edit hay không item: product, // gán product vừa tìm được vào biến item để đưa vào file ejs }); } }); } }; // {UPDATE PRODUCT} // const postEditProduct = (req, res) => { const idUpdate = req.body.id; // Lấy id của product từ thẻ input đã được hidden trong editProduct.ejs (mục đích dùng input là để lấy ra id của product đã có sẵn trong database, không cần phải thông qua việc kiểm tra id đó có tồn tại hay không) const data = JSON.parse(JSON.stringify(req.body)); const updateProduct = new Product(data, idUpdate); updateProduct.save(); res.redirect("/admin/product"); }; // {DELETE PRODUCT} // const deleteProduct = (req, res) => { const idDelete = req.body.id; Product.findByID(idDelete, (item) => { const delProduct = new Product(item, idDelete); delProduct.save("isDelete"); res.redirect("/admin/product"); }); }; ... ``` ## 3. Sử dụng `Sequlize` trong `NodeJS` `Sequelize` là một thư viện ORM (Object-Relational Mapping) cho `NodeJS` giúp tương tác với `MySQL`, `PostgreSQL`, `SQLite`, `MariaDB`, `MS SQL Server` một cách dễ dàng hơn. ### 3.1. Cài đặt package `sequelize` Trước hết, cần phải có `package` để kêt nối với Database, ở đây sử dụng `mysql2` và `sequelize` để tương tác với `MySQL`. Sau đó, cài đặt `sequelize` bằng lệnh: ```bash $ npm install sequelize ``` ### 3.2. Sử dụng `Sequelize` trong `NodeJS` #### 3.2.1. Kết nối với `MySQL` bằng `Sequelize` Thay vì sử dụng cách cũ với `pool` như ở trên, ta sử dụng `Sequelize` để kết nối với `MySQL`. ```javascript const {Sequelize} = require("sequelize"); // Thêm module sequelize vào biến Sequelize (object) // Tạo 1 connect đến database: new Sequelize(database, user, password, {host: địa chỉ, dialect: tên db}) const sequelize = new Sequelize("node-shop", "root", "17052002", { host: "localhost", dialect: "mysql", }); module.exports = sequelize; ``` #### 3.2.2. Tạo model trong `Sequelize` bằng `Sequelize.define()` Chúng ta thực hiện mapping các bảng trong `MySQL` với các `model` trong `NodeJS` bằng cách sử dụng `Sequelize.define()`. > model/products.js ```javascript const { DataTypes } = require("sequelize"); // Thêm module DataTypes có chức năng tạo các kiểu dữ liệu cho database từ sequelize const sequelize = require("../util/database"); // Thêm module sequelize đã tạo ở file database.js // Tạo 1 model có tên là products (khi chạy, MySQL tự chuyển tên thành in thường và thêm 's') // có các thuộc tính là id, name, price, description đã tạo sẵn và tự thêm 2 thuộc tính createdAt và updatedAt const Product = sequelize.define("products", { id: { type: DataTypes.INTEGER, autoIncrement: true, allowNull: false, unique: true, primaryKey: true, }, name: { type: DataTypes.CHAR(50), allowNull: false, }, price: { type: DataTypes.DOUBLE, allowNull: false, }, description: { type: DataTypes.TEXT, allowNull: false, }, }); module.exports = Product; ``` #### 3.2.3. Tiến hành chạy `Sequlize` trong `NodeJS` Sau khi đão tạo các `model entity` trong `Sequelize`, ta cần tạo ra các `relationship` giữa các `model` đó. Thông thường có 3 loại `relationship`: - `One-to-One`: Một sản phẩm chỉ thuộc về một danh mục. Đi kèm với nó là `belongsTo({foreignKey: 'tên trường chính'})`. - `One-to-Many`: Một danh mục có thể chứa nhiều sản phẩm. Đi kèm với nó là `hasMany({foreignKey: 'tên trường chính'})`. - `Many-to-Many`: Một sản phẩm có thể thuộc nhiều danh mục và một danh mục có thể chứa nhiều sản phẩm. Đi kèm với nó là `belongsToMany({through: 'tên bảng trung gian'})`. Ngoia ra, còn có thể thêm các thuộc tính sau ở bên trong các hàm `belongsTo()`, `hasMany()`, `belongsToMany()`: - `foreignKey`: Tên trường chính của bảng. - `as`: Tên alias của bảng. - `constraints`: Ràng buộc dữ liệu. Nếu `false` thì không ràng buộc. Nếu `true` thì ràng buộc (khi xóa bảng cha thì bảng con cũng bị xóa). - `onDelete`: Hành động khi xóa bảng cha. Có thể là `CASCADE`, `SET NULL`, `NO ACTION`, `RESTRICT`. - `onUpdate`: Hành động khi cập nhật bảng cha. Có thể là `CASCADE`, `SET NULL`, `NO ACTION`, `RESTRICT`. - `through`: Tên bảng trung gian. (Chỉ dùng cho `belongsToMany()`). > app.js ```javascript // IMPORT TẤT CẢ MODEL ĐÃ TẠO ... // {Relationship} // const Product = require("./models/products"); const User = require("./models/users"); const Cart = require("./models/carts"); const CartItem = require("./models/cartItems"); const Order = require("./models/orders"); const OrderItem = require("./models/orderItems"); // Tạo quan hệ 1-1 giữa Product và User (1 product chỉ có 1 user tạo ra) Product.belongsTo(User, { constraints: true, // Tạo ràng buộc giữa 2 bảng để khi xóa 1 bảng thì bảng còn lại cũng bị xóa theo onDelete: "CASCADE", // Nếu user bị xóa thì product cũng bị xóa theo }); User.hasMany(Product); // Tạo quan hệ 1-n giữa User và Product (1 user có thể tạo nhiều product) Cart.belongsTo(User); // Tạo quan hệ 1-1 giữa Cart và User (1 cart chỉ thuộc về 1 user) User.hasOne(Cart); // Tạo quan hệ 1-1 giữa User và Cart (1 user chỉ có 1 cart) Cart.belongsToMany(Product, { through: CartItem }); // Tạo quan hệ n-n giữa Cart và Product (1 cart có thể có nhiều product), thông qua bảng trung gian CartItem Product.belongsToMany(Cart, { through: CartItem }); // Tạo quan hệ n-n giữa Product và Cart (1 product có thể thuộc về nhiều cart), thông qua bảng trung gian CartItem Order.belongsTo(User); // Tạo quan hệ 1-1 giữa Order và User (1 order chỉ thuộc về 1 user) User.hasMany(Order); // Tạo quan hệ 1-n giữa User và Order (1 user có thể tạo nhiều order) Order.belongsToMany(Product, { through: OrderItem }); // Tạo quan hệ n-n giữa Order và Product (1 order có thể có nhiều product), thông qua bảng trung gian OrderItem Product.belongsToMany(Order, { through: OrderItem }); // Tạo quan hệ n-n giữa Product và Order (1 product có thể thuộc về nhiều order), thông qua bảng trung gian OrderItem ... ``` Ngoài ra, sử dụng `sync()` để đồng bộ `model` với `MySQL`. Nếu chưa có `table` nào trong `database` thì `sequelize` sẽ tự tạo ra `table` đó. ```javascript ... import sequelize from "./util/database"; // Import sequelize đã tạo ở file database.js // Đồng bộ model với database, đồng thời chạy server sequelize .sync() .then(() => { return User.findByPk(1); // Tìm user có id = 1 }) .then((user) => { if (!user) { // Nếu không tìm thấy user thì tạo 1 user mới return User.create({ username: "Dan", email: "dan@gmail.com", }); } return user; }) .then((user) => { return user.createCart(); // Tạo cart cho user, sau khi khởi tạo 1 user mới thì tạo cart cho user đó }) .then(() => { // Vì promise là 1 bất đồng bộ, nên phải đưa việc khởi động server vào trong hàm promise đê đợi kết quả trả về, chỉ khi thực hiện listen() thì các phương thức ở trên mới hoạt động => kiểm tra xong user rồi mới đến middleware const IP = "192.168.1.15"; app.listen(3000, "localhost" || IP); }) .catch((err) => { console.log(err); }); ``` #### 3.2.4. Sử dụng các hàm có săn trong `Sequelize` phục vụ cho việc tương tác với `MySQL` Sử dụng các thuộc tính của model để tạo dữ liệu, thuộc tính sẽ trả về 1 promise. - `create()` để tạo dữ liệu mới, VD: create({name: 'name', price: 1000}) - `findAll()` để lấy tất cả dữ liệu, VD: findAll({where: {id: 1}}) để lấy dữ liệu có id = 1 - `findByPk()` để lấy dữ liệu theo khóa chính, VD: findByPk(1) - `findOne()` để lấy ra một dữ liệu theo điều kiện, VD: findOne({where: {id: 1}}) - `update()` để cập nhật dữ liệu, VD: update({name: 'new name'}, {where: {id: 1}}) (Sau khi tìm được đối tượng cụ thể trong database) - `destroy()` để xóa dữ liệu, VD: destroy({where: {id: 1}}) (Sau khi tìm được đối tượng cụ thể trong database) ## 4. NoSQL Database trong NodeJS (Sư dụng `MongoDB`) ### 4.1. Cài đặt package kết nối với `MongoDB` Để kết nối với `MongoDB`, ta sử dụng package chính trên trang chủ của `MongoDB` là `mongodb`. ```bash $ npm install mongodb ``` ### 4.2. Kết nối với `MongoDB` Đầu tiên, ta cấu hình kết nối với `MongoDB` bằng cách sử dụng `MongoClient` để kết nối với `MongoDB`. ```javascript const { MongoClient, ServerApiVersion } = require("mongodb"); // Nhập vào object lấy từ module mongodb const URL = "mongodb+srv://nodejsshop:12345@shop.zjodmkn.mongodb.net/?retryWrites=true&w=majority"; // URL của database let _db; // Biến lưu trữ database const client = new MongoClient(URL, { serverApi: { version: ServerApiVersion.v1, // Sử dụng phiên bản API 1 strict: true, // Chỉ cho phép sử dụng những tính năng mới nhất của API deprecationErrors: true, // Hiển thị lỗi khi sử dụng những tính năng cũ }, }); // Tạo client kết nối với database const mongoConnect = (callback) => { client .connect() // Kết nối với database .then((result) => { console.log("Connected!"); _db = result.db(); callback() // Thực hiện hàm callback sau khi kết nối thành công // console.log(_db) }) // Lưu trữ database vào biến _db .catch((err) => { console.log(err); throw err; }); }; // Kết nối với database và lưu trữ database vào biến _db const getDB = () => { if (_db) { return _db; } throw "No database found"; }; // Trả về database module.exports = { mongoConnect, getDB, }; ``` Sau đó, tiến hành chạy server cùng với `MongoDB` bằng cách sử dụng hàm `mongoConnect()` để kết nối với `MongoDB`. ```javascript ... const mongoConnect = require("./util/database").mongoConnect; // Import hàm kết nối với MongoDB mongoConnect(() => { app.listen(3000); }); ``` ### 4.3. Tạo `model` để tương tác với `MongoDB` Tương tác với `MongoDB` bằng cách sử dụng getDB() để lấy ra database của MongoDB (Đã lưu ở biến _db) sau đó kết hợp với `collection()` cùng với các hàm có sẵn trong `MongoDB` như: - `insertOne()` : thêm 1 document vào collection (Trả về Promise) - `insertMany()` : thêm nhiều document vào collection (Trả về Promise) - `find()` : tìm kiếm document trong collection (Trả về Cursor) - `findOne()` : tìm kiếm 1 document trong collection (Trả về Promise) - `updateOne()` : cập nhật 1 document trong collection (Trả về Promise) - `updateMany()` : cập nhật nhiều document trong collection (Trả về Promise) - `deleteOne()` : xóa 1 document trong collection (Trả về Promise) - `deleteMany()` : xóa nhiều document trong collection (Trả về Promise) - `aggregate()` : thực hiện các phép toán trên collection (Trả về Promise) - `countDocuments()` : đếm số document trong collection (Trả về Promise) - `estimatedDocumentCount()` : đếm số document trong collection (Trả về Promise) - `distinct()` : trả về các giá trị duy nhất của 1 field trong collection (Trả về Promise) - `findOneAndDelete()` : tìm kiếm và xóa 1 document trong collection (Trả về Promise) - `findOneAndReplace()` : tìm kiếm và thay thế 1 document trong collection (Trả về Promise) - `findOneAndUpdate()` : tìm kiếm và cập nhật 1 document trong collection (Trả về Promise) - `findOneAndUpsert()` : tìm kiếm và cập nhật 1 document trong collection, nếu không tìm thấy thì thêm mới (Trả về Promise) - `replaceOne()` : thay thế 1 document trong collection (Trả về Promise) - `watch()` : theo dõi các thay đổi trên collection (Trả về ChangeStream) - `createIndex()` : tạo index cho collection (Trả về Promise) - `createIndexes()` : tạo nhiều index cho collection (Trả về Promise) - `dropIndex()` : xóa index của collection (Trả về Promise) - `dropIndexes()` : xóa nhiều index của collection (Trả về Promise) - `listIndexes()` : liệt kê các index của collection (Trả về Cursor) - `indexExists()` : kiểm tra index có tồn tại trong collection không (Trả về Promise) - `indexInformation()` : trả về thông tin index của collection (Trả về Promise) - `stats()` : trả về thông tin thống kê của collection (Trả về Promise) > Tất cả các hàm trên đều trả về `Promise` nên cần phải sử dụng `then()`, `catch()` hoặc `async/await` để xử lý. > `id` của các đối tượng trong `MongoDB` được tự động tạo ra khi thêm vào `collection` và có kiểu dữ liệu là `ObjectId`. Khi truyền vào 1 String thì `MongoDB` thì cần phải chuyển từ `String` sang `ObjectId` bằng cách sử dụng `new ObjectId()`. > Ví dụ về tạo `model` trong `MongoDB` ```javascript const getDB = require("../util/database").getDB; // Nhập vào object getDB lấy từ file database.js const { ObjectId } = require("mongodb"); // Tạo class Product class Product { constructor(name, price, url, description, userID) { (this.name = name), (this.price = price), (this.url = url), (this.description = description), (this.userID = userID); // Lưu id của user tạo product } // Lưu product vào database save(productID = null) { // Tham số productID có giá trị mặc định là null const db = getDB(); // Lấy database từ server MongoDB (xử lý trong file database.js) let dbOP; // Biến lưu trữ database operation // Nếu có tham số productID truyền vào => update if (productID) { const ID = new ObjectId(productID) // Tạo object ID từ string productID (vì productID là string, còn ID là object) dbOP = db.collection("products").updateOne({ _id: ID }, { $set: this }) // Lấy collection products trong database, tìm kiếm product có id là ID, và update product đó bằng object this (this ở đây chính là object product được tạo ra từ class Product) } // Nếu không có tham số productID truyền vào => tạo mới else { dbOP = db.collection("products").insertOne(this); // Lấy collection products trong database (nếu chưa có sẽ tự động tạo mới) và Thêm product vào collection products (this ở đây chính là object product được tạo ra từ class Product) } return dbOP.then((result) => console.log(result)).catch((err) => console.log(err)); // Trả về kết quả thực hiện database operation } // Lấy tất cả product từ database static fetchAll() { const db = getDB(); // Lấy database từ server MongoDB (xử lý trong file database.js) return db .collection("products") // Lấy collection products trong database (nếu chưa có sẽ tự động tạo mới) .find() // Tìm kiếm tất cả product trong collection products .toArray() // Sau khi tìm kiếm xong, chuyển kết quả thành array (vì kết quả trả về là 1 cursor object, không phải là array) .then((result) => { console.log(result); return result; }) .catch((err) => console.log(err)); } // Tìm kiếm product theo id static findById(productID) { const db = getDB(); // Lấy database từ server MongoDB (xử lý trong file database.js) const ID = new ObjectId(productID); // Tạo object ID từ string productID (vì productID là string, còn ID là object) return ( db .collection("products") // Lấy collection products trong database (nếu chưa có sẽ tự động tạo mới) .findOne({ _id: ID }) // Tìm kiếm product trong collection products có id là ID (Nếu muốn trả về object không cần next() thì dùng findOne()) // .next() // Sau khi tìm kiếm xong, chuyển kết quả thành object (vì kết quả trả về là 1 cursor object, không phải là object) .then((result) => { console.log(result); return result; }) .catch((err) => console.log(err)) ); } // Xóa product theo id static deleteById(productID) { const db = getDB() // Lấy database từ server MongoDB (xử lý trong file database.js) const ID = new ObjectId(productID) // Tạo object ID từ string productID (vì productID là string, còn ID là object) return db.collection("products").deleteOne({ _id: ID }) // Tìm kiếm product trong collection, có id là ID rồi xoá product đó .then(result => console.log(result)) .catch(err => console.log(err)) } } module.exports = Product; ``` ## 5. Sử dụng `Mongoose` trong `NodeJS` (ORM cho `MongoDB`) Chúng ta có thể sử dụng `Mongoose` để tương tác với `MongoDB` một cách dễ dàng hơn. `Mongoose` giúp chúng ta tạo `model` và tự tạo `schema` cho `MongoDB` một cách dễ dàng hơn. Ưu điểm của `Mongoose` so với dùng `MongoDB` truyền thống: - Giúp tạo schema, model, validate, query, populate, aggregate, ... dễ dàng hơn - Lược bỏ nhiều bước phức tạp so với dùng trực tiếp với MongoDB như: + Khi query các dữ liệu, không cần phải chuyển id từ string sang ObjectId, ... + Khi tạo schema, không cần phải tạo các collection, các method để query, validate, ... ### 5.1. Cài đặt package `mongoose` Trước đó, cũng cần cài package `mongodb`. Để sử dụng `Mongoose`, ta cần cài đặt `mongoose` bằng lệnh: ```bash $ npm install mongoose ``` ### 5.2. Kết nối với `MongoDB` bằng `Mongoose` Chúng ta import `mongoose` vào file `app.js` và sử dụng `mongoose.connect()` để kết nối với `MongoDB` và đồng thời chạy server. ```javascript import mongoose from "mongoose"; // Import mongoose vào biến mongoose import URL from "./util/database"; // Import URL của database từ file database.js (URL của MongoDB) mongoose .connect(URL, { useNewUrlParser: true, useUnifiedTopology: true }) // Kết nối với MongoDB .then(() => { console.log("Connected!"); app.listen(3000); // Chạy server }) .catch((err) => console.log(err)); ``` ### 5.3. Tạo `model` trong `Mongoose` Chúng ta sử dụng: - `mongoose.Schema` để tạo `schema` cho `MongoDB`. - `mongoose.SchemaTypes` để tạo các kiểu dữ liệu cho `schema`. - `new Schema().methods.` để tạo ra các phương thức cho `model`. - `new Schema().statics.` để tạo ra các phương thức `static` cho `model`. - Ngoài ra sử dụng các thuộc tính phụ sau: + `ref: `: Tạo quan hệ giữa các `collection`. + `required: true`: Bắt buộc phải có. + `unique: true`: Giá trị phải là duy nhất. + `default: `: Giá trị mặc định. + `min: `: Giá trị nhỏ nhất. + `max: `: Giá trị lớn nhất. + `enum: [, , ...]`: Giá trị phải thuộc 1 trong các giá trị trong mảng. + `validate: `: Hàm validate dữ liệu. > Ví dụ về tạo `model` trong `Mongoose` ```javascript const mongoose = require("mongoose"); // Nhập mongoose lấy từ module mongoose const Schema = mongoose.Schema; // Nhập Schema lấy từ mongoose const SchemaTypes = mongoose.SchemaTypes; // Nhập SchemaTypes lấy từ mongoose // Tạo Schema cho product const Product = new Schema({ name: { type: SchemaTypes.String, // Kiểu dữ liệu required: true, // Bắt buộc phải có }, price: { type: SchemaTypes.Number, // Kiểu dữ liệu required: true, // Bắt buộc phải có }, url: { type: SchemaTypes.String, // Kiểu dữ liệu required: true, // Bắt buộc phải có }, description: { type: SchemaTypes.String, // Kiểu dữ liệu require: true, // Bắt buộc phải có }, // {Realation} // Tạo quan hệ giữa product và user userId: { type: SchemaTypes.ObjectId, // Kiểu dữ liệu ObjectId (id của user) required: true, // Bắt buộc phải có ref: "users", // Tên collection mà userId tham chiếu đến }, }, { timestamps: true }); // Tạo thêm 2 trường createdAt và updatedAt Product.methods.saveAll = function () { return this.save(); // Lưu product vào database (this ở đây chính là object product được tạo ra từ Schema Product) }; // Tạo phương thức tùy chỉnh cho model Product module.exports = mongoose.model("products", Product); // Tạo model products vào collection từ Schema Product và export ra ngoài để sử dụng ``` ### 5.4. Sử dụng `model` trong `Mongoose` để tương tác với `MongoDB` Chúng ta sử dụng các phương thức có sẵn trong `model` để tương tác với `MongoDB`: - `save()`: Lưu dữ liệu vào collection trong NoSQL - `find()`: Tìm tất cả `item` trong collection trong NoSQL - `findById()`: Tìm product có id trong collection trong NoSQL - `findByIdAndRemove()`: Xóa product có id trong collection trong NoSQL - `findByIdAndUpdate()`: Cập nhật product có id trong collection trong NoSQL - `findOne()`: Tìm 1 product trong collection trong NoSQL, nếu không truyền gì vào nó sẽ trả về phần tử đầu tiên - `.find().populate("userId", "...")`: Tìm tất cả `item` trong collection trong NoSQL, lấy được `userId` của rồi tìm các collection có id == .userId trong NoSQL rồi trả về kết quả đã tìm kiếm, có thể trả về hết hoặc chỉ trả về các field được chọn trong dấu 3 chấm - `.find().select("title price -_id").exec()`: Tìm tất cả `item` trong collection trong NoSQL, chỉ lấy title và price, không lấy _id (dấu - trước _id để bỏ qua _id) - `.find().sort({price: -1}).exec`: Tìm tất cả `item` trong collection trong NoSQL, sắp xếp theo giá giảm dần - `.find().skip(1).limit(1).exec()`: Tìm tất cả `item` trong collection trong NoSQL, bỏ qua 1 phần tử đầu tiên, chỉ lấy 1 phần tử - `.find().countDocuments()`: Tìm tất cả `item` trong collection trong NoSQL sau đó đếm số lượng phần tử > LƯU Ý: `select()`, `sort()`, `skip()`, `limit()`, `countDocuments()` phải thêm `exec()` nếu đằng sau nó không có `then` hoặc `catch` để thực thi vì nó không phải là bất đồng bộ nên không trả về promise, thêm `exec()` mục đích để trả về 1 promise, có thể thêm callback vào `exec()` để xử lý kết quả trả về > `._doc`: Cho phép quyên truy cập vào schema khác, trả về object chứa các thuộc tính của schema, không trả về các method của schema (Nên sử dụng khi dùng populate() để lấy các thuộc tính của schema khác) > VD: `product._doc.userId._doc.name` -> truy cập vào thuộc tính name của schema user trong schema product

NodeJS: Sử dụng Database với NodeJS