Node.js - MongoDB Create Collection

Hello there, aspiring programmers! Today, we're going to embark on an exciting journey into the world of Node.js and MongoDB. As your friendly neighborhood computer teacher, I'm here to guide you through the process of creating collections in MongoDB using Node.js. Don't worry if you're new to programming – we'll take it step by step, and before you know it, you'll be creating collections like a pro!

What is MongoDB?

Before we dive into the nitty-gritty, let's start with the basics. MongoDB is a popular NoSQL database that stores data in flexible, JSON-like documents. Think of it as a giant digital filing cabinet where you can store all sorts of information without worrying too much about structure.

What is a Collection?

In MongoDB, a collection is like a folder in that filing cabinet. It's where we group similar documents together. For example, if you're building a library database, you might have a collection for books, another for authors, and another for borrowers.

Setting Up Our Environment

First things first, we need to make sure we have Node.js and MongoDB installed on our computer. If you haven't done this yet, take a quick detour to the official websites and follow their installation guides.

Once you're all set up, let's create a new project folder and initialize it:

mkdir mongodb-collection-tutorial
cd mongodb-collection-tutorial
npm init -y

Now, let's install the MongoDB driver for Node.js:

npm install mongodb

Connecting to MongoDB

Alright, now the fun begins! Let's create a new file called app.js and start by connecting to our MongoDB database:

const { MongoClient } = require('mongodb');

// Connection URL
const url = 'mongodb://localhost:27017';

// Database Name
const dbName = 'myLibrary';

// Create a new MongoClient
const client = new MongoClient(url);

// Connect to the server
async function connect() {
  try {
    await client.connect();
    console.log('Connected successfully to the database');
    const db = client.db(dbName);
    return db;
  } catch (error) {
    console.error('Error connecting to the database:', error);
  }
}

In this code, we're setting up a connection to our local MongoDB server. We're using localhost:27017, which is the default address for MongoDB. We're also specifying a database name, myLibrary. Don't worry if the database doesn't exist yet – MongoDB will create it for us when we first use it.

Creating a Collection

Now that we're connected, let's create our first collection! We'll create a collection for books in our library:

async function createCollection() {
  const db = await connect();
  try {
    const result = await db.createCollection('books');
    console.log('Collection created successfully:', result.namespace);
  } catch (error) {
    if (error.code === 48) {
      console.log('Collection already exists');
    } else {
      console.error('Error creating collection:', error);
    }
  } finally {
    await client.close();
  }
}

createCollection();

Let's break this down:

We use the createCollection method to create a new collection called 'books'.
If the collection is created successfully, we log a success message.
If there's an error, we check if it's because the collection already exists (error code 48). If so, we log a message saying the collection already exists. For any other error, we log the error details.
Finally, we close the database connection.

Adding Options to Our Collection

MongoDB allows us to specify options when creating a collection. Let's create another collection with some options:

async function createCollectionWithOptions() {
  const db = await connect();
  try {
    const options = {
      capped: true,
      size: 1000000,
      max: 5000
    };
    const result = await db.createCollection('logs', options);
    console.log('Collection created with options:', result.namespace);
  } catch (error) {
    console.error('Error creating collection with options:', error);
  } finally {
    await client.close();
  }
}

createCollectionWithOptions();

In this example, we're creating a 'logs' collection with the following options:

capped: true - This creates a capped collection, which has a fixed size.
size: 1000000 - This sets the maximum size of the collection to 1 million bytes.
max: 5000 - This sets the maximum number of documents the collection can hold to 5000.

These options are useful for collections that have a "rolling" nature, like log files, where you want to keep only the most recent entries.

Checking If a Collection Exists

Sometimes, you might want to check if a collection already exists before trying to create it. Here's how you can do that:

async function checkCollectionExists(collectionName) {
  const db = await connect();
  try {
    const collections = await db.listCollections({name: collectionName}).toArray();
    if (collections.length > 0) {
      console.log(`Collection ${collectionName} exists`);
    } else {
      console.log(`Collection ${collectionName} does not exist`);
    }
  } catch (error) {
    console.error('Error checking collection:', error);
  } finally {
    await client.close();
  }
}

checkCollectionExists('books');

This function uses the listCollections method to check if a collection with the given name exists. If the returned array has a length greater than 0, it means the collection exists.

Putting It All Together

Now that we've learned about creating collections, let's put it all together in a single script:

const { MongoClient } = require('mongodb');

const url = 'mongodb://localhost:27017';
const dbName = 'myLibrary';
const client = new MongoClient(url);

async function connect() {
  try {
    await client.connect();
    console.log('Connected successfully to the database');
    return client.db(dbName);
  } catch (error) {
    console.error('Error connecting to the database:', error);
  }
}

async function createCollections() {
  const db = await connect();
  try {
    // Create 'books' collection
    await db.createCollection('books');
    console.log('Books collection created successfully');

    // Create 'logs' collection with options
    const logOptions = { capped: true, size: 1000000, max: 5000 };
    await db.createCollection('logs', logOptions);
    console.log('Logs collection created successfully with options');

    // Check if 'authors' collection exists
    const collections = await db.listCollections({name: 'authors'}).toArray();
    if (collections.length > 0) {
      console.log('Authors collection already exists');
    } else {
      await db.createCollection('authors');
      console.log('Authors collection created successfully');
    }
  } catch (error) {
    console.error('Error in createCollections:', error);
  } finally {
    await client.close();
  }
}

createCollections();

This script combines all the concepts we've learned:

Connecting to the database
Creating a simple collection ('books')
Creating a collection with options ('logs')
Checking if a collection exists before creating it ('authors')

Conclusion

Congratulations! You've just taken your first steps into the world of MongoDB and Node.js. We've learned how to connect to a MongoDB database, create collections, add options to collections, and check if collections exist. These are fundamental skills that will serve you well as you continue your journey in database management with MongoDB.

Remember, practice makes perfect. Try creating different types of collections, experiment with various options, and don't be afraid to make mistakes – that's how we learn!

Here's a table summarizing the main methods we've used:

Method	Description
`MongoClient.connect()`	Connects to the MongoDB server
`db.createCollection()`	Creates a new collection
`db.listCollections()`	Lists existing collections

Keep coding, keep learning, and most importantly, have fun! Until next time, happy databasing!

Credits: Image by storyset

Previous Tutorial:

Node.js - MongoDB Create Database

Next Tutorial:

Node.js - MongoDB Insert