SchemaTypes trong Mongoose

Trong bài này chúng ta sẽ tìm hiểu về SchemaTypes trong Mongoose, một module của NodeJS.

SchemaTypes có liên quan mật thiết đến hầu hết các phần trong Mongoose như Schema, Model, validation, lấy dữ liệu, thêm dữ liệu hay truy vấn dữ liệu và các thuộc tính của các document. Trong bài này chúng ta sẽ tìm hiểu về SchemaType trong Mongooose.

1. SchemaTypes là gì ?

Bạn có thể hiểu rằng Mongoose Schema là một đối tượng giúp tạo ra khung cho một Model, một Schema Type sẽ làm nhiệm vụ chỉnh là chỉnh sửa các phần của khung đó theo ý mà bạn muốn.

SchemaTypes giúp bạn định dạng kiểu dữ liệu mà bạn mong muốn. Mỗi khi có bất kì tác động nào thì Schema sẽ dựa vào SchemaTypes để kiểm tra kiểu dữ liệu đó có đúng với kiểu đã đặt trước đó không?

Bài viết này được đăng tại [free tuts .net]

Ví dụ, mình muốn thuộc tính name trong document của mình phải là kiểu string thì mình sẽ tạo ra một Schema có key là name và SchemaTypes là String

const schema = new Schema({ name: String });
schema.path('name') instanceof mongoose.SchemaType; // true
schema.path('name') instanceof mongoose.Schema.Types.String; // true
schema.path('name').instance; // 'String'

Chúng ta có môt vài SchemaTypes trong Mongoose như sau:

• String
• Number
• Date
• Buffer
• Boolean
• Mixed
• ObjectId
• Array
• Decimal128
• Map

Dưới đây mình sẽ khởi tạo một Schema trong đó bao gồm nhiều các SchemaTypes khác nhau:

var schema = new Schema({
  name:    String,
  binary:  Buffer,
  living:  Boolean,
  updated: { type: Date, default: Date.now },
  age:     { type: Number, min: 18, max: 65 },
  mixed:   Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  decimal: Schema.Types.Decimal128,
  array: [],
  ofString: [String],
  ofNumber: [Number],
  ofDates: [Date],
  ofBuffer: [Buffer],
  ofBoolean: [Boolean],
  ofMixed: [Schema.Types.Mixed],
  ofObjectId: [Schema.Types.ObjectId],
  ofArrays: [[]],
  ofArrayOfNumbers: [[Number]],
  nested: {
    stuff: { type: String, lowercase: true, trim: true }
  },
  map: Map,
  mapOfString: {
    type: Map,
    of: String
  }
})

2. Từ khóa 'type' trong Schema Types

Type là một thuộc tính của Schema trong Mongoose, khi Mongoose tìm thấy một thuộc tính type trong schema của bạn, nó sẽ ngay lập tức chỉ định giá trị của thuộc tính đó là một SchemaTypes.

Chúng ta có ví dụ bên dưới:

//Khai báo SchemaTypes với thuộc tính type
const schema = new Schema({
  name: { type: String },
  nested: {
    firstName: { type: String },
    lastName: { type: String }
  }
});
//Khai báo SchemaTypes thông thường
const schema = new Schema({
  name: String,
  nested: {
    firstName: String,
    lastName: String
  }
});

Trong trường hợp bạn cần chỉ định một thuộc tính có tên là type, ví dụ bạn muốn tạo một Schema chứa thông tin của quần áo chẳng hạn bao gồm có các thuộc tính như (type, color,...) thì khi bạn khai báo trong Schema như thế này :

const clothes = new Schema({
  //Trong trường hợp này Schema sẽ hiểu lầm là details là kiểu String
  details: {
    type: String,
    ticker: String
  }
});

Để giải quyến vấn đề này bạn chỉ cần thử sử dụng 2 cách khai báo Schema như sau:

const clothes = new Schema({
  //Trong trường hợp này Schema sẽ hiểu lầm là details là kiểu String
  details: {
    type: {type: String},
    ticker: String
  }
});

3. Thêm các options vào SchemaType

Bạn có thể khai báo một SchemaType bằng cách truyền trực tiếp kiểu dữ liệu mà bạn mong muốn hoặc đưa nó vào một object và gán trị cho thuộc tính type như 2 cách mà mình đề cập ở trên :

var schema1 = new Schema({
  test: String // test có kiểu là string
});

var schema2 = new Schema({
  // thuộc tính test chứa một object có chứa SchemaTypes
  test: { type: String } // test có kiểu là string
});

Ngoài thuộc tính type được thêm trong object, bạn còn có các thuộc tính khác có thể thêm vào. Giả sữ mình muốn giá trị của test luôn luôn được viết thường :

var schema2 = new Schema({
  // thuộc tính test chứa một object có chứa SchemaTypes
  test: { 
    type: String, // test có kiểu là string
    lowercase: true  //test luôn luôn được chuyển sang viết thường
  } 
});

Ngoài ra bạn có thêm nhiều plugin hỗ trợ việc thêm các options cho một Schema, ví dụ như mongoose-autopopulate,...Mongoose hỗ trợ một số tùy chọn SchemaType tích hợp, như lowercase trong ví dụ trên.

Schema Types Options

Dưới đây là các options được sử dụng trong các SchemaTypes, mình sẽ phân chia theo từng loại bên dưới:

Options Type (Dùng trong tất cả các SchemaTypes)

• required : (Boolean hoặc function), thuộc tính này có bắt buộc phải có giá trị không ?
• default: Giá trị mặc định của thuộc tính
• select: (Boolean) Chỉ định cách trường được trả về khi truy vấn
• validate: (function) kiểm tra gía trị của thuộc tính.
• get: (function) chỉ định các giá trị lấy vào của thuộc tính sử dụng Object.defineProperty()
• set: (function) chỉ định các giá trị được đặt vào của thuộc tính sử dụng Object.defineProperty()
• alias : (function) xác định virtual được chỉ định.

var numberSchema = new Schema({
  integerOnly: {
    type: Number,
    get: v => Math.round(v),
    set: v => Math.round(v),
    alias: 'i'
  }
});

var Number = mongoose.model('Number', numberSchema);

var doc = new Number();
doc.integerOnly = 2.001;
doc.integerOnly; // 2
doc.i; // 2
doc.i = 3.001;
doc.integerOnly; // 3
doc.i; // 3

Indexes

Bạn có thể chỉ định các MongoDB Index sử dụng Schema Types Options :

• index : (boolean) chỉ định index trong thuộc tính.
• unique: (boolean) chỉ định unique index trong thuộc tính.
• sparse: (boolean) chỉ định sparse index trong thuộc tính.

var schema2 = new Schema({
  test: {
    type: String,
    index: true,
    unique: true 
  }
});

String

Về String chúng ta có một vài Schema Types Options như: lowercase, uppercase, trim, match, enum, minlength, maxlength,..

var schema2 = new Schema({
    test: {
      type: String,
      enum: ['large', 'small'],
  ​    uppercase: true,
      minlength: 2
    }
  });   

Number

Bao gồm các Schema Types Optiosn như: min, max, enum

var PeopleSchema = new Schema({
    age: {
      type: Number,
      min: 1,
      max: 120
    }
  });   

Date

Bao gồm các SchemaTypes options như: min, max

var PeopleSchema = new Schema({
    joinDay: {
        type: Date,
        min: '2002-12-09',
        max: '2019-19-02'
    }
  });   

Trong bài viết này chúng ta đã tìm hiểu về SchemaTypes trong Mongoose DB, rất mong bài viết này sẽ giúp ích cho bạn. Cảm ơn bạn đã ghé thăm bài viết.