Làm cách nào để kết nối với la bàn MongoDB bằng cầy mangut?

Trong bài viết trước, chúng ta đã biết cách đặt xác thực và ủy quyền trên MongoDB và chúng ta đã tương tác thông qua CLI, nhưng chúng ta sẽ làm gì nếu muốn Node của mình. js để nói chuyện với cơ sở dữ liệu của chúng tôi? . js và sau đó tương tác với MongoDB

Đối với dự án này, giả sử chúng ta có một blog nơi người dùng có thể tạo bài đăng, xem số lượt xem cho bài đăng và thêm nhận xét;

Tạo dự án

Chúng ta sẽ bắt đầu với trình khởi động nút với Bản in mà tôi đã thực hiện trong hướng dẫn này, vì vậy hãy sao chép nó và cài đặt các phần phụ thuộc

git clone https://github.com/tericcabrel/node-ts-starter.git

cd node typescript-starter

yarn install

Bây giờ dự án đã sẵn sàng, hãy tạo cơ sở dữ liệu của chúng tôi

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

Bây giờ chúng ta có mọi thứ để bắt đầu

Kết nối với cơ sở dữ liệu

Để tạo nút. js giao tiếp với MongoDB, chúng ta cần trình điều khiển Mongo DB cho Node. js. Chúng tôi sẽ sử dụng một ORM có tên là cầy mangut để ánh xạ một lớp tới bộ sưu tập MongoDB và cũng giúp dễ dàng thực hiện các truy vấn CRUD trong cơ sở dữ liệu. Mongoose đã nhúng trình điều khiển nên không cần cài đặt riêng

yarn add mongoose
yarn add -D @types/mongoose

Sau khi cài đặt, hãy tạo một tệp

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

3 trong thư mục

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

4 và thêm mã này

import mongoose, { ConnectionOptions } from 'mongoose';

mongoose.Promise = global.Promise;

const connectToDatabase = async (): Promise => {
  const options: ConnectionOptions = { useNewUrlParser: true, useFindAndModify: false, useCreateIndex: true, useUnifiedTopology: true };

  await mongoose.connect(`mongodb://blogUser:blogUserPwd@localhost:27017/blog`, options);
};

export { connectToDatabase };

Thay thế nội dung của chỉ mục. ts với

import { connectToDatabase } from './db-connection';

(async () => {
  await connectToDatabase();

  console.log('Connected to the database successfully!');
})();

Lưu và chạy

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

5 bạn nên kết nối thành công với cơ sở dữ liệu nếu thông tin đăng nhập của bạn hợp lệ

Ghi chú. Trong một ứng dụng thực, không bao giờ dữ liệu nhạy cảm với mã cứng như thông tin đăng nhập cơ sở dữ liệu. Bạn nên tải chúng từ biến môi trường. Chúng ta sẽ xem cách thực hiện trong phần hướng dẫn sắp tới

Tạo các lược đồ

Chúng tôi sẽ tạo các lược đồ và Mongoose sẽ chịu trách nhiệm tạo chúng trong cơ sở dữ liệu. Hãy bắt đầu với lược đồ người dùng bằng cách tạo một thư mục có tên models sau đó, một tệp user. mô hình. ts

import mongoose, { Document, Schema, Model } from 'mongoose';

type UserDocument = Document & {
  name: string;
  dateOfBirth: Date;
  location: {
    country: string;
    city: string;
  };
  email: string;
};

type UserInput = {
  name: UserDocument['name'];
  dateOfBirth: UserDocument['dateOfBirth'];
  location: UserDocument['location'];
  email: UserDocument['email'];
};

const userSchema = new Schema(
  {
    email: {
      type: String,
      required: true,
      unique: true,
      index: true, // We can search an user by his email, index the field will make the search faster
    },
    name: {
      type: String,
      required: true,
    },
    dateOfBirth: {
      type: Date,
      required: true,
    },
    location: {
      country: String,
      city: String,
    },
  },
  {
    timestamps: true, // Automatically field createdAt and updatedAt
    collection: 'users', // Create the collection with name 'users'
  },
);

const User: Model = mongoose.model('User', userSchema);

export { User, UserDocument, UserInput };

mô hình/người dùng. mô hình. ts

Chúng tôi cũng tạo một tệp

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

6 cho lược đồ Đăng

import mongoose, { Document, Schema, Model } from 'mongoose';
import { UserDocument } from './user.model';

type CommentInput = {
  text: string;
  voteCount: number;
};

enum TagEnum {
  Node = 'Node.js',
  Java = 'Java',
  React = 'React',
  GraphQL = 'GraphQL',
  Spring = 'Spring',
  Typescript = 'Typescript',
  Express = 'Express',
  Docker = 'Docker',
  Jest = 'Jest',
  Jenkins = 'Jenkins',
  AWS = 'AWS',
}

type PostDocument = Document & {
  title: string;
  content: string;
  viewCount: number;
  author: UserDocument['_id'];
  tags: TagEnum[];
  isPublished: boolean;
  comments: CommentInput[];
};

type PostInput = {
  title: PostDocument['title'];
  content: PostDocument['content'];
  viewCount: PostDocument['viewCount'];
  author: PostDocument['author'];
  tags: PostDocument['tags'];
  isPublished: PostDocument['isPublished'];
  comments: PostDocument['comments'];
};

const commentSchema = new Schema(
  {
    text: {
      type: String,
      required: true,
    },
    voteCount: {
      type: Number,
      default: 0,
    },
  },
  {
    timestamps: true,
  },
);

const postSchema = new Schema(
  {
    title: {
      type: String,
      required: true,
    },
    content: {
      type: String,
      required: true,
    },
    viewCount: {
      type: Number,
      default: 0,
    },
    tags: {
      type: [String],
      enum: TagEnum,
    },
    isPublished: {
      type: Boolean,
      required: true,
      default: false,
    },
    author: {
      type: mongoose.Schema.Types.ObjectId,
      ref: 'User',
      required: true,
      index: true,
    },
    comments: [commentSchema],
  },
  {
    collection: 'posts',
    timestamps: true,
  },
);

const Post: Model = mongoose.model('Post', postSchema);

export { Post, PostInput, CommentInput, TagEnum };

mô hình/bài đăng. mô hình. ts

Chèn dữ liệu

Các lược đồ của chúng tôi được tạo để chúng tôi có thể chèn dữ liệu vào cơ sở dữ liệu của mình. Trước tiên, chúng tôi sẽ tạo một người dùng và sau đó tạo một bài đăng với tác giả là người dùng đã tạo trước đó
Tạo một tệp

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

7 sau đó thêm mã bên dưới

import { User, UserInput } from '../models/user.model';
import { CommentInput, Post, PostInput, TagEnum } from '../models/post.model';

export const insertUserAndPost = async () => {
  const userInput: UserInput = {
    email: '[email protected]',
    name: 'Jon Snow',
    dateOfBirth: new Date(1995, 1, 23),
    location: {
      city: 'Paris',
      country: 'FRA',
    },
  };

  const createdUser = await User.create(userInput);

  const postInput: PostInput = {
    author: createdUser._id,
    comments: [
      {
        text: 'My first comment',
        voteCount: 14,
      },
    ],
    content: 'My first post text content',
    isPublished: false,
    tags: [TagEnum.Node, TagEnum.Docker, TagEnum.GraphQL],
    title: 'My first post title',
    viewCount: 23,
  };

  const createdPost = await Post.create(postInput);

  console.log(createdUser);
  console.log(createdPost);
};

Gọi tập tin trên bên trong.

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

8

import { connectToDatabase } from './db-connection';
import { insertUserAndPost } from './queries/insertUserAndPost';

(async () => {
  await connectToDatabase();

  console.log('Connected to the database successfully!');

  await insertUserAndPost();
})();

Chạy mã của bạn với

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

5 và đây là kết quả chúng tôi nhận được

Bạn có thể sử dụng các công cụ GUI cho cơ sở dữ liệu để xem dữ liệu bên trong cơ sở dữ liệu. Một công cụ tuyệt vời cho MongoDB là MongoDB Compass. Việc cài đặt và sử dụng rất đơn giản. Bạn có thể tải về tại đây

Chèn vào trẻ em

Bên trong bài đăng, chúng tôi có một loạt các bình luận liên quan đến bài đăng. Giả sử chúng ta muốn thêm nhận xét vào một bài đăng hiện có, bên trong

yarn add mongoose
yarn add -D @types/mongoose

0, chúng ta sẽ làm điều gì đó như thế này

// ....code to create user and post
const newComment: CommentInput = {
    text: 'A new comment in the post created above',
    voteCount: 32,
};

createdPost.comments.push(newComment);
const updatedPost = await createdPost.save();
console.log(updatedPost);

Lưu ý rằng bạn sẽ cần dọn dẹp DB của mình trước khi chạy cái này; . Chạy ứng dụng của bạn và bạn sẽ có đầu ra này

Khôi phục dữ liệu

Trong đoạn mã bên dưới, chúng tôi thấy cách chúng tôi có thể thực hiện một số truy vấn bằng cầy mangut

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

0

Cập nhật dữ liệu

Bây giờ hãy xem cách chúng tôi có thể cập nhật dữ liệu nhưng trước đó, hãy tạo lại một tệp "updateData. ts" bên trong thư mục "truy vấn. "

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

1

Xóa dữ liệu

Mongoose cung cấp 4 phương thức xóa dữ liệu. Tạo một tệp "deleteData. ts" bên trong thư mục "truy vấn. "

mongo --port 27017 -u "root" -p "rootPassword" --authenticationDatabase "admin"

use blog

db.createUser({ user: "blogUser", pwd: "blogUserPwd@2k21", roles: [{ role: "dbAdmin", db: "blog" }, { role: "readWrite", db: "blog" } ]})

2

Một trong những khác biệt chính giữa NoSQL và SQL là không hỗ trợ các ràng buộc toàn vẹn. Trong đoạn mã trên, khi chúng tôi xóa một người dùng, sẽ không có kiểm tra xem id có được sử dụng làm khóa ngoại ở đâu đó hay không và đồng thời, các bài đăng do người dùng này tạo vẫn còn

Hãy ghi nhớ điều này khi bạn chọn cơ sở dữ liệu để sử dụng cho dự án tiếp theo của mình

Có một gói có thể giúp bạn mạnh mẽ loại lược đồ cầy mangut của bạn được gọi là ts-mongoose

Bạn có thể tìm mã nguồn trên kho lưu trữ GitHub

Theo dõi tôi trên Twitter hoặc đăng ký nhận bản tin của tôi để tránh bỏ lỡ các bài đăng sắp tới cũng như các mẹo và thủ thuật mà tôi thỉnh thoảng chia sẻ

Làm cách nào để kết nối MongoDB với MongoDB Compass?

Làm cách nào để kết nối MongoDB cục bộ với La bàn?

Làm cách nào để kết nối với La bàn MongoDB cục bộ trong nút js?

Làm cách nào để kết nối MongoDB Compass với máy chủ từ xa?