DEV Community: Rittwick Bhabak

Introduction to MongoDB

Rittwick Bhabak — Mon, 22 Nov 2021 08:17:05 +0000

1 Introduction to MongoDB

MongoDB is a NoSQL Database.
Instead of storing data in the form of table and rows, in mongoDB data in stored in the form of objects.
Mongoose is ODM, which makes it easier to communicate with MongoDB.

In this series we will learn about
MongoDB and Mongoose
CRUD application
and a testing framework called Mocha.

2 Installing MongoDB Locally & connecting to MongoDB

npm init -- to track the dependencies.
Install mongoose npm install mongoose --save
Connecting to database: Mongoose do not automatically knows about database. we've to tell it explicitly.

//connection.js
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/testaroo');

mongoose.connection.once('open', function(){
    console.log('Connection is made');
}).on('error', function(error){
    console.log('Connection error', error);
})

3 Models and Collection

File: models/marioChar.js

const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const MarioCharSchema = new Schema({
    name: String,
    weight: Number
})

const MarioChar = mongoose.model('mariochar', MarioCharSchema)

module.exports = MarioChar;

// Now we can do the following
// var myChar = new MarioChar({ name: "Rayan", weight: 100 });

4 Introduction to Mocha testing

Mocha is a testing framework.
We use it to perform within our application
To make sure everything works correctly
First install Mocha npm install mocha --save
Keep the test script demo_test.js to a folder /test.
demo_test.js

const mocha = require('mocha');
const assert = require('assert');

describe('Some demo tests', function(){
    //Create tests
    it('adds two numbers together', function(){
        assert(2+3===5)
    })
})

Set the test property to mocha in package.json
and run npm run test

5 Saving data to MongoDB

const mocha = require('mocha');
const assert = require('assert');
const MarioChar = require('../models/mariochar');

describe('Some demo tests', function(){

    //Create tests
    it('Saves a record to the database', function(done){
        var character = new MarioChar({
            name: "Mario",
        })
        character.save().then(function(){
            assert(character.isNew === false)
            done();
        })
    })
})

character.save().then(function(){
        assert(character.isNew === false)
        done();
})

The above function saves the character in the database.
character.isNew returns true when the object is created but not present in the database.
and returns false when the object is found in the database.
As save is an asynchronous function, to perform next tests we have to explicitly tell when it is finished through done method.

Using ES6 promise instead using mogoose's own promise

const mongoose = require('mongoose');

// Using ES6 promise instead mogoose's promise
mongoose.Promise = global.Promise 

// Connect to mongodb
mongoose.connect('mongodb://localhost/testaroo');
mongoose.connection.once('open', function(){
    ...
}).on('error', function(error){
  ...  
})

At this point our test is being ran even before the connection is established.
To do that we have to put our connection code inside before

before(function(done){
     mongoose.connect('mongodb://localhost/testaroo');
    mongoose.connection.once('open', function(){
        console.log('Conneciton is made');
        done();
    }).on('error', function(error){
        console.log('Connection error', error);
    })
})

Note that we've also used done to explicitly tell when the connection is established.

6 Dropping a Collection

To drop a collection:
mongoose.connection.collections.mariochars.drop()
note that we're writing mariochars (pluralized) and not mariochar but we've declared the collection as mariochar. This is the way mongodb works.

To drop the collection before every test so that the result of one test do not affect the other test by using beforeEach

const mongoose = require('mongoose');mongoose.Promise = global.Promise 
before(function(done){
    // Connect to mongodb
    ...
})
beforeEach(function(done){
    mongoose.connection.collections.mariochars.drop()
    done()
})

7 Finding Records

To search we can use find or findOne method to the model.

MarioChar.findOne({ name: "Mario"}).then(result => {
    ...
})

This code, finds the first match where name==="Mario"
Our finding_test.js file is

const assert = require('assert');
const MarioChar = require('../models/mariochar');

describe('Some demo tests', function(){

    beforeEach(function(done){
        var character = new MarioChar({
            name: "Mario",
        })
        character.save().then(function(){
            assert(character.isNew === false)
            done();
        })
    })

    //Create tests
    it('Finding a record form the database', function(done){
        MarioChar.findOne({ name: "Mario"}).then(result => {
            assert(result.name === "Mario")
            done();
        })
    })
})

8 ObjectId

To retrieve data by ID from the collection:

MarioChar.findOne({ _id: character._id }).then(result => {
    assert(result._id === character._id)
    done();
})

But the above code is not going to work as
result._id===character._id is going to return false as
result._id is of type ObjectID and character._id is of type String. So we've to convert both of them to String and then compare.
result._id.toString()===character._id.toString()
will return true

9 Deleting Record

Mongoose has 3 records to delete records

char.remove()
MarioChar.remove() Inside the bracket we are going to pass the options
MarioChar.findOneAndRemove() Inside the bracket we're going to pass the options

Use of findOneAndRemove()

MarioChar.findOneAndRemove({ name:"Mario" }).then(function(){
            MarioChar.findOne({ name:"Mario" })
        })

10 Updating Record

Various mongoose methods

char.update()
MarioChar.update()
MarioChar.findOneAndUpdate()

// Saving the data
character = new MarioChar({
    name: "Mario",
    weight: 60
})
character.save().then(function(){
    ...
})

// Updating the data
MarioChar.findOneAndUpdate({ name:"Mario"}, { name:"new_name"}).then(function(){
    MarioChar.findOne({ name:"Mario" }).then(result => {
        ...
    })
})

The the new changes will be injected and this will not overwrite the complete objects. This update results to the object:
{ name: "new_name", weight: 100 } and not just { name: "new_name" }

11 Relational Data

Suppose, Author(name, age, books) and Book(title, pages) are two relations.
In the following way we construct it in MongoDB

const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const BookSchema = new Schema({
    title: String,
    pages: Number 
});

const AuthorSchema = new Schema({
    name: String,
    age: Number, 
    books: [BookSchema] 
})

const Author = mongoose.model('author', AuthorSchema);

module.exports = Author;

books: [BookSchema] tells us that books property is an array where the array elements will be of the form BookSchema

12 Nesting Documents

const mongoose = require('mongoose');
const assert = require('assert')
const Author = require('../models/author');

describe('Nesting Documents', function(){

    //Create tests
    it('Create an author with sub-documents', function(done){

        var pat = new Author({
            name: 'Patrick Ruffus',
            books:[{title:'Name of the wind', pages: 400}]
        });
        pat.save().then(function(){
            Author.findOne({name:'Patrick Ruffus'}).then(function(record){
                assert(record.books.length === 1);
                done();
            })
        })
    })

    it('Add a book to an existing author', function(done){

        var rus = new Author({
            name: 'Ruskin Bond',
            books:[{title:'The eyes have it', pages: 400}]
        });
        rus.save().then(function(){
            Author.findOne({name:'Ruskin Bond'}).then(function(record){
                record.books.push({title:"7 husband", pages:200});
                record.save().then(function(){
                    Author.findOne({ name: 'Ruskin Bond' }).then(function(record){
                        assert(record.books.length===2);
                        done();
                    })
                })
            })
        })
    })
})

Introduction to Node.js

Rittwick Bhabak — Mon, 22 Nov 2021 07:49:45 +0000

1. Introduction, Set up and Basics

To check node version in my computer: node -v
To start node console: node

Running a javascript file 'test.js'

//filename test.js
const name = 'rittwick'
console.log(name)

Command to run this file: node test

2. Basics

1. The global object

There is an object called global in node. The same object in browser console is called window.
Checkout console.log(global); in node console.
This object contains functions like setInterval, setTimeout etc.
File globaltut.js:

const interval = setInterval(() => {
    console.log('In the interval');
}, 1000);

setTimeout(() => {
    console.log("In the timeout")
    clearInterval(interval);
}, 5000);

The output will be:

In the interval
In the interval
In the interval
In the interval
In the timeout

Finding the filename and directory name in node

console.log(__dirname);
console.log(__filename);

Some attributes are present in node and not in window and some are present in window and not in node global object.For example 'document' is present in window object and not in node.

2. Modules and Require

We've two files: people.js and data.js
people.js contains:

const persons = ['arun', 'shankar', 'vinod', 'irfan'];
console.log(`From people.js: ${persons}`);

data.js contains:

const xyz = require('./people');
console.log(`From data.js: `, xyz);

From people.js: arun,shankar,vinod,irfan
From data.js:  {}

This way persons array is not available in data.js. We have to manually send from person.js to data.js.

people.js have to contain a line:

module.export = persons;

Then only person is accessible to data.js.
Note: In require statement the path should be a relative path not an absolute path

Exporting multiple things from person.js to data.js

people.js

const persons = ['arun', 'shankar', 'vinod', 'irfan'];
const ages = [12, 22, 44, 9];

module.exports = {
    personsList: persons,
    agesList: ages
}

data.js

const xyz = require('./people');
console.log(xyz.personsList);
console.log(xyz.agesList);

Output on running node data:

[ 'arun', 'shankar', 'vinod', 'irfan' ]
[ 12, 22, 44, 9 ]

persons array of people.js --> personsList array of data.js

To call persons array of people.js as persons in data.js:
people.js:

module.export = {
    persons: persons,
    ages: ages
}

There is a shortcut of these method:

module.export = {
    persons, ages
}

Now there are different types of accessing tricks:
Trick 1

//people.js
const persons = ['arun', 'shankar', 'vinod', 'irfan'];
const ages = [12, 22, 44, 9];

module.exports = {
    persons, ages
}


// data.js
const xyz = require('./path_of_people')
console.log(xyz.persons);
console.log(xyz.ages);

Trick 2

//people.js
const persons = ['arun', 'shankar', 'vinod', 'irfan'];
const ages = [12, 22, 44, 9];

module.exports = {
    persons, ages
}


// data.js
const { persons, ages } = require('./path_of_people')

Trick 3

//people.js
const persons = ['arun', 'shankar', 'vinod', 'irfan'];
const ages = [12, 22, 44, 9];

module.exports = {
    personsList: persons,
    agesList: ages
}


// data.js
const { personsList } = require('./path_of_people')
//agesList is not accessible now. Only personsList is imported here.

node also has some built in modules: For example:

// OS MODULE
const os = require('os');
const os = require('os');
console.log(os.platform());
console.log(os.homedir());

Another important built in module is filesystem module

3. The filesystem

Reading the file

const fs = require('fs');
fs.readFile('./textfile.txt', (err, data) => {
    if(err){
        console.log('Some error happened');
    }else{
        console.log(data);
    }
})

Output:

<Buffer 6c 6f 72 65 6d 20 69  ... 94 more bytes>

data is a package of objects. To read it we have to convert it into string.

console.log(data);
//Output: <Buffer 6c 6f 72 65 6d 20 94 more bytes>

console.log(data.toString());
// Output: This is a nice tutorial

Note: readFile is asynchronous function. Following code reveals that:

const fs = require('fs');
fs.readFile('./textfile.txt', (err, data) => {
        console.log(data.toString());
})
console.log('last line of the code')

The output will be:

last line of the code
This is a nice tutorial

Wirting the file

fs.writeFile('./new.txt', 'hello rittwick', () => {
    console.log('File was written');
}

writeFile is also a asynchronous function. This function overwrites the file if the file already exists and creates, writes the file if the file already not exists.

4. Creating and Removing Directories

fs.mkdir('./assets', (err)=>{
        if(err){
            console.log('Some error happened 1');
        }else{
            console.log('Folder created');
        }
    })

mkdir creates the folder if does not exists. If exists then returns error.

Creating the folder if not exists and deleting otherwise:

if(!fs.existsSync('./assets')){
    fs.mkdir('./assets', (err)=>{
        if(err){
            console.log('Some error happened 1');
        }else{
            console.log('Folder created');
        }
    })
}else{
    fs.rmdir('./assets', (err) => {
        if(err){
            console.log('Some error happened 2');
        }else{
            console.log('Folder Deleted');
        }
    })
}

5. Deleting Files

if(fs.existsSync('./deleteme.txt')){
    fs.unlink('./deleteme.txt', err => {
        if(err){
            console.log('Some error occurred ');
        }else{
            console.log('File deleted successful');
        }
    })
}

unlink deletes the file if exists otherwise returns an error.

4. Streams and Buffers

Starts using data before it has finished loading completely. For example loading a chunk of data and watching the video before the video fully loads.

Reading a stream

const readStream = fs.createReadStream('./docs/huge.txt');
readStream.on('data', (chunk)=>{
    console.log('-------NEW CHUNK---------');
    console.log(chunk);
})

This will output some buffers. To get a readable text:
console.log(chunk.toString())
OR there we can directly encode it to a readable string:

const readStream = fs.createReadStream('./docs/huge.txt', { encoding:'utf8' });

Writing a Stream

const readStream = fs.createReadStream('./docs/huge.txt', { encoding:'utf8' });
const writeStream = fs.createWriteStream('./docs/newhuge.txt');

readStream.on('data', (chunk)=>{
    writeStream.write('\nNEW CHUNK\n');
    writeStream.write(chunk);
})

Piping

Reading streams and writing it into a writestream.

const readStream = fs.createReadStream('./docs/huge.txt', { encoding:'utf8' });
const writeStream = fs.createWriteStream('./docs/newhuge.txt');

readStream.pipe(writeStream);

3. Client and Servers

Creating a server in node

const http = require('http');

const server = http.createServer((req, res)=>{
    console.log('Everytime a request is made, I pops up.');
})

The callback function in the above code block runs every time a request is made.
The arguments of the callback function are req and res. In req, the information about incoming request is present and through req the response is sent back.

This alone is not doing anything. The server have to actively listen to the requests.
server.listen()

server.listen(3000, 'localhost', ()=>{
    console.log('Listening to port number 3000')
});

4. Requests & Responses

1.The Request Object

Getting the request url and request method: req.url & req.method

const server = http.createServer((req, res)=>{
    console.log(req.url, req.method);
})

2. The Response Object

Sending response is a three step process:

setting the response header
writing the response
sending the response

const server = http.createServer((req, res)=>{
    //Setting response header
    res.setHeader('Content-type', 'text/plain');

    //Writing the response
    res.write(`Hello, Rittwick!`);

    //Sending the response
    res.end();
})

In the above code we're just sending plain text. We can also send html.

const server = http.createServer((req, res)=>{
    console.log(req.url, req.method);
    //Setting response header to 'text/html'
    res.setHeader('Content-type', 'text/html');

    res.write('<h1>Hello! Rittwick</h1>');

    res.end();
})

The browse automatically adds the other tags body, html and head. We can overwrite them.

const server = http.createServer((req, res)=>{
    res.setHeader('Content-type', 'text/html');

    res.write('<head><title>Hello page </title></head>');
    res.write('<h1>Hello! Rittwick</h1>');

    res.end();
})

3. Sending html files

const server = http.createServer((req, res)=>{
    res.setHeader('Content-type', 'text/html');

    fs.readFile('./views/index.html', (err, data) => {
        if(err){
            res.end();
        }else{
            res.write(data);
            res.end();
        }
    })
})

Instead of doing the following in two lines, we can do it in one line res.end(data)

res.write(data)
res.end()

Instead the shortcut
res.end(data)

When we are sending the only one data, like the above then only this shortcut can be applied.

4. Basic Routing

const server = http.createServer((req, res)=>{
    res.setHeader('Content-type', 'text/html');
    let path = './views/';
    switch(req.url){
        case '/':
            path += 'index.html';
            break;
        case '/about':
            path += 'about.html';
            break;
        default:
            path += '404.html';
            break;
    }
    fs.readFile(path, (err, data) => {
        res.end(data);
    })
})

5. Status Codes

Setting status codes is very easy.
res.statusCode=<your_status_code> for example res.statusCode=200

In the following code block example, status code is set according to need.

const server = http.createServer((req, res)=>{
    res.setHeader('Content-type', 'text/html');
    let path = './views/';
    switch(req.url){
        case '/':
            path += 'index.html';
            res.statusCode = 200;
            break;
        case '/about':
            path += 'about.html';
            res.statusCode = 200;
            break;
        default:
            path += '404.html';
            res.statusCode = 404;
            break;
    }
    fs.readFile(path, (err, data) => {
            res.end(data);
    })
})

Some more important points:

100 range - Informative codes for browser
200 range - Success codes
300 range - redirection codes
400 range - User side errors
500 range - Server errors

Example:

200 - OK
301 - Resource moved
404 - Page not found
500 - Internal server error

6. Redirects

Suppose my website has an established route '/about'. I wish someone who also visits to '/about-me' get redirected to '/about'. The below code does that:

First set the statuscode to 301 res.statusCode=301;
Then do res.setHeader('Location', '/about');
Send the request res.end()

        case '/about':
            path += 'about.html';
            res.statusCode = 200;
            break;
        case '/about-me':
            res.statusCode = 301;
            res.setHeader('Location', '/about');
            res.end();
            break;
        default:
            path += '404.html';
            res.statusCode = 404;
            break;

6. Expressions, Statements, if-then-else , Methods, Method Overloading

Rittwick Bhabak — Thu, 10 Dec 2020 05:48:30 +0000

1. Expressions

Example:

int score = 100;
if (score > 99){
    System.out.println("You got the high score!");
    score = 0;
}

In the above code score = 100, You got the high score! and score = 0 are expressions only.

2. Keywords

Java has 52 reserved key words

3. if-then-else

Example:

if(score>100) {
    return "Grade A";
} else if(score > 50) {
    return "Grade B";
} else {
    return "Grade C";
}

4. Method

Example:

public static String greetUser(String username) {
        return "Welcome" + username;
}

5. Method Overloading

Example 1:

    public static int loggedIn(int a, int b) {
        return 0;
    }
    public static int loggedIn(int a) {
        return a + 5;
    }
    public static boolean loggedIn(int a) {
        return true;
    }
    public static String loggedIn(String name) {
        return name + " is dancing";
    }

All of the above are valid method overloading, but the example below is not valid:

    public static int loggedIn(int a, int b) {
        return 0;
    }
    public static boolean loggedIn(int a, int b) {
        return true;
    }

This is an error.

Another example of method overloading:

    public static int sum (int a, int b, int c, int d) {
        return sum(a,b,c) + d;
    }
    public  static int sum (int a, int b, int c) {
        return sum(a,b) + c;
    }
    public static int sum (int a, int b) {
        return a + b;
    }

Method overloading is a feature that allows us to have more than one method with the same name, so long as we use different parameters.
It is the ability to create multiple methods of the same name with different implementations.
Calls to an overloaded method will run a specific implementation of that method.

public static void main(String[] args) {
    System.out.println("Hello!");
    System.out.println(5);
    System.out.println(10.75);
}

println method is a great example of method overloading in the Java language. There are actually 10 methods with name println. We can print an integer, double, string, and so on...

5. If-then block in JAVA

Rittwick Bhabak — Thu, 03 Dec 2020 06:11:31 +0000

Example:

        boolean isAlien = false;
        if(isAlien == false)
            System.out.println("It is not an alien!");

Example 2:

            if(isAlien == false){
            System.out.println("It is not an alien!");
            System.out.println("and I'm scared of aliens");
        }

Example 3:

        int a = 60;
        int b = 70;
        if(a < b && a < 100){
            System.out.println("I am happy");
        }
        if(a>50 || b<30) {
            System.out.println("Logical OR operator");
        }

Assignment vs Equal to Operator

        boolean isCar = false;
        if( isCar = true ) {
            System.out.println("This is not supposed to happen");
        }

if( isCar = true ) in this line, isCar = true returns true, similarly isValue=50 returns 50
So, the following code is not a valid code but the above code is valid as if statement accepts true or false

        int newValue = 50;
        if(newValue = 50) {
            System.out.println("This is true");
        }

4. Operators, Operands, Expression, Operator Precedence

Rittwick Bhabak — Thu, 03 Dec 2020 06:04:04 +0000

Example of operators

        int result = 1 + 2; // addition
        result = result - 1; // subtraction
        result = result * 10; // multiplication
        result = result / 5; // division
        result = result % 3; // modulus

Abbreviating of operators

        // result = result + 1;
        result++;

        // result = result - 1;
        result--;

        // result = result + 2;
        result += 2;

        // result = result * 10;
        result *= 10;

        // result = result / 3;
        result /= 3;

        // result = result % 2;
        result %= 2;

Arithmetic operators

+, -, *, /, %, ++, --

Assignment operators

=, +=, -=, *=, /=, %=, &=, |=, ^=, >>=, <<=

Comparison operators

==, !=, >, <, >=, <=

Logical operators

&&, ||, !

Bitwise operators

&, |, ~, ^, <<, >>, >>>

Another operator is Ternary Operator

boolean loggedIn = false;
String userStatus = loggedIn ? "User is loggedIn" : "User is not logged in";
System.out.println(userStatus);

More details can be found in
w3schools.com
oracle.com

Java Operator Precedence

Link

3. String in JAVA

Rittwick Bhabak — Wed, 02 Dec 2020 07:19:27 +0000

A string is a sequences of characters. In the case of the char, char contains a single character only.
A String can contain a sequence of characters.
Exmaple:
String name = "Rittwick Bhabak"

3 Strings in Java are Immutable

String name = "Rittwick";
String name = name + "Bhabak";

In the above code, name doesn't get appended the value "Bhabak" instead a new String is created which consists of the previous value of name plus "Bhabak".
The net result is same, name has the right values, however, a new String got created and the old one got discarded.
So, String is immutable in Java.
There are a class in Java called StringBuffer which can be changed.

2. Variables, Datatypes, Operators in JAVA

Rittwick Bhabak — Wed, 02 Dec 2020 07:10:04 +0000

1. Integer

public static void main(String[] args) {
        int myFirstNumber = 5;
        System.out.println(myFirstNumber);
}

Left of the = sign have to be an expression.
Expression is construct that evaluates to a single value.

int myMinIntValue = Integer.MIN_VALUE;
Here Integer is a wrapper class. Java uses the concept of a Wrapper class for all eight primitive types - In the case of an int, we can use Integer, and by doing that it gives us ways to perform operations on an int.
In this case we're using the MIN_VALUE to get Java to tell us the minimum int that can be stored.

int myInt = 2147483648; this is not human readable. It's human readable version is int myInt = 2_147_483_648;

2. Byte

byte myMinByteValue = Byte.MIN_VALUE;
byte myMabyteValueByteValue = Byte.MAX_VALUE;
System.out.println("Byte Minimum Value " + myMinByteValue);
System.out.println("Byte MabyteValueimum Value " + myMabyteValueByteValue);

3. Short

short myMinShortValue = Short.MIN_VALUE;
short myMabyteValueShortValue = Short.MAX_VALUE;
System.out.println("Short Minimum Value " + myMinShortValue);
System.out.println("Short MabyteValueimum Value " + myMabyteValueShortValue);

4. Long

long myLongValue = 100L;
long myMinLongValue = Long.MIN_VALUE;
long myMabyteValueLongValue = Long.MAX_VALUE;
System.out.println("Long Minimum Value " + myMinLongValue);
System.out.println("Long MabyteValueimum Value " + myMabyteValueLongValue);
long bigLongLiteralValue = 2_147_483_647_234L;
System.out.println("Big Long Literal Value " + bigLongLiteralValue);

5. Float

float myMinFloat = Float.MIN_VALUE;
float myMaxFloat = Float.MAX_VALUE;
System.out.println("Float Minimum Value: " + myMinFloat);
System.out.println("Float Maximum Value: " + myMaxFloat);

6. Double

Java by default takes a floating point number as double and whole number as int.
double is faster than float

double myMinDouble = Double.MIN_VALUE;
double myMaxDouble = Double.MAX_VALUE;
System.out.println("Double Minimum Value: " + myMinDouble);
System.out.println("Double Maximum Value: " + myMaxDouble);

int myIntValue = 5;
// float myFloatValue = (float) 5.25;
// float myFloatValue = 5.25f;
float myFloatValue = 5f / 3f;
double myDoubleValue = 5.00 / 3.00;
System.out.println("MyIntValue= " + myIntValue);
System.out.println("MyFloatValue= " + myFloatValue);
System.out.println("MyDoubleValue= " + myDoubleValue);

In case of double we can use the underscore notation also for example : double number = 2_000_000.4_567_891d;

In general float and double are great for general floating point operations. But both are not great where precise calculations are required - this is due to a limitation with how floating point numbers are stored and not a Java problem such. Java has a class called BigDecimal that overcomes this.

7. Char

char myChar = 'D';
char myUnicodeChar = '\u0044';
System.out.println(myChar);
System.out.println(myUnicodeChar);

8. Boolean

boolean myTureBooleanValue = true;
boolean myFalseBooleanValue = false;
boolean isCustomerAdult = true;

#13 Nesting Documents

Rittwick Bhabak — Sat, 28 Nov 2020 07:22:23 +0000

const mongoose = require('mongoose');
const assert = require('assert')
const Author = require('../models/author');

describe('Nesting Documents', function(){

    //Create tests
    it('Create an author with sub-documents', function(done){

        var pat = new Author({
            name: 'Patrick Ruffus',
            books:[{title:'Name of the wind', pages: 400}]
        });
        pat.save().then(function(){
            Author.findOne({name:'Patrick Ruffus'}).then(function(record){
                assert(record.books.length === 1);
                done();
            })
        })
    })

    it('Add a book to an existing author', function(done){

        var rus = new Author({
            name: 'Ruskin Bond',
            books:[{title:'The eyes have it', pages: 400}]
        });
        rus.save().then(function(){
            Author.findOne({name:'Ruskin Bond'}).then(function(record){
                record.books.push({title:"7 husband", pages:200});
                record.save().then(function(){
                    Author.findOne({ name: 'Ruskin Bond' }).then(function(record){
                        assert(record.books.length===2);
                        done();
                    })
                })
            })
        })
    })
})

#12 Relational Data

Rittwick Bhabak — Sat, 28 Nov 2020 06:27:32 +0000

Suppose, Author(name, age, books) and Book(title, pages) are two relations.
In the following way we construct it in MongoDB

const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const BookSchema = new Schema({
    title: String,
    pages: Number 
});

const AuthorSchema = new Schema({
    name: String,
    age: Number, 
    books: [BookSchema] 
})

const Author = mongoose.model('author', AuthorSchema);

module.exports = Author;

books: [BookSchema] tells us that books property is an array where the array elements will be of the form BookSchema

#11 Updating Record

Rittwick Bhabak — Sat, 28 Nov 2020 04:34:09 +0000

Various mongoose methods

char.update()
MarioChar.update()
MarioChar.findOneAndUpdate()

// Saving the data
character = new MarioChar({
    name: "Mario",
    weight: 60
})
character.save().then(function(){
    ...
})

// Updating the data
MarioChar.findOneAndUpdate({ name:"Mario"}, { name:"new_name"}).then(function(){
    MarioChar.findOne({ name:"Mario" }).then(result => {
        ...
    })
})

The the new changes will be injected and this will not overwrite the complete objects. This update results to the object:
{ name: "new_name", weight: 100 } and not just { name: "new_name" }

#10 Deleting Record

Rittwick Bhabak — Sat, 28 Nov 2020 04:09:58 +0000

Mongoose has 3 records to delete records

char.remove()
MarioChar.remove() Inside the bracket we are going to pass the options
MarioChar.findOneAndRemove() Inside the bracket we're going to pass the options

Use of findOneAndRemove()

MarioChar.findOneAndRemove({ name:"Mario" }).then(function(){
            MarioChar.findOne({ name:"Mario" })
        })

#9 ObjectId

Rittwick Bhabak — Sat, 28 Nov 2020 03:38:57 +0000

To retrieve data by ID from the collection:

MarioChar.findOne({ _id: character._id }).then(result => {
    assert(result._id === character._id)
    done();
})