Node | Kevin Chisholm - Blog

Dec92013 by dcm1 Comment

Creating a Simple JSONP API with Node.js and MongoDB

By leveraging the Node.js middleware “express”, we can create functionality for viewing, adding or deleting JSON data.

In a previous article: “Using Mongoose ODM to Connect to MongoDB In Your Node.js Application,” we learned the basics about connecting to a MongoDB database in a Node.js application. Because that article barely skimmed the surface of what is possible, we’ll take a few more baby steps here with our data. And for the sake of brevity, I’ll skim over the Mongoose.js details. If needed, you can refer to the article mentioned above for more details on that.

The goals for this article are:

Allow the user to view all data in the database
Allow the user to make a JSONP call to get all data
Allow the user to add a new name to the Sales database
Allow the user to delete all data in the database

When completed, this will be far from a robust or production-ready application, but we will, at minimum, learn how to view / add / delete data in our MongoDB database, using clean URLs in the browser.

Dependencies

In order to use the code in this article, you’ll need the following installed on your computer:

Node.js
MongoDB

Installation of these components is beyond the scope of this article, but if you follow the provided links, you will be pointed in the right direction.

File Structure

app.js
package.json

For this article, we will need two files: app.js and package.json. So, in your project folder, create these two empty files. The following sections will explain what to put in them.

Example # 1A

In Example # 1A, we have the contents of package.json. Note that for a more detailed discussion about package.json files you can search this blog for helpful articles. The two dependencies declared are “mongoose” and “express”. When you use node package manager to install dependencies, npm will download and install mongoose and express for us.

Example # 1B

In Example # 1B we see the command needed to install the dependencies for our application. Once you run this command, you will have everything needed to start writing code.

Getting Started

Open app.js in your text editor. From this point on, you can copy / paste the code in each example into the app.js (or you can scroll to the bottom of this page and paste the entire code listing in one step).

Example #2

In Example #2, we declare all of the top-level variables we’ll need in our script. Take note of “app”, which will be used to leverage the express middleware that we listed as a dependency. Also, “initApp”, which is called from the very end of this script. It is used to start the HTTP server.

Example #3

In Example #3, we have our database implementation. The details are identical to those in the previously mentioned article, so we’ll skip over that.

Example #4

In Example #4, we get into something new. If you remember from Example #2, the variable: “app” is an instance of the Express middleware object. We use the .get() method of that object to define what will happen when certain requests are made. When users navigate to the root of our web application, they are presented with a simple message. We accomplish this by passing two arguments to the .get() method: a string representing the requests we want to respond to (i.e. “/”), and an anonymous function. That anonymous function takes two arguments: “req” and “res”, which represent the request that was made, and the response object that we will send back. We use the .end() method of the response object, and pass in the string we want to send to the browser.

The second call to the app.get() method responds to “/json/delete”. It, in turn, calls a function named: utils.deleteAllData(), which will be explained a bit later.

Example #5

In Example #5, we use the app.get() method to respond to the request: “/json”. For this request, we want to show all of the data in the database. We start off by requesting all of the data in the database: salesMember.find({}).exec(). The anonymous function that is passed to the exec() method provides access to an error object (if there is one), and the results of our search. In this case, the result object is JSON, which contains all the data in the database, which we then stringify.

We then use the utils.isJsonCallback() method to determine if the user added a callback function name to the query string. If so, we wrap our database JSON with the named callback. We then deliver the JSON by passing it to the res.end() method.

Example #6

In Example #6, we respond to a request to add a new user to the database (i.e. “/addUser”). If you remember from the top of the script, the variable “url” allows us to leverage the same-named Node.js module, which provides programmatic access to the URL. We then use the “url” object to access the query string for the new user parameters. Once we have that information, we can leverage code that is nearly identical to the previous article, to create a new document in the collection. So just think of this as adding a row to a database table).

Once the new data has been saved, we then end the response with some HTML, informing the user of the successful data addition, and add a link that allows them to view all data or go to the home page.

Example #7

Example #7 contains all of the utility functions used throughout our code:

utils.isJsonCallback : Returns true if a callback name was provided in the query string
utils.getJsonCallbackName : Returns the name of the callback provided in the query string
utils.wrapDataInCallback : Returns the JSON data, wrapped in the callback function
utils.deleteAllData : Deletes all of the data in the database

Note: At the end of Example #7 you will also see a call to initApp(). This simply starts the HTTP server.

Example #8

So finally, in Example #8 we have the complete code for our working example. You can start the application by navigating to the root of the folder that contains app.js and entering the following command in the terminal: node app.js.

NOTE: On line # 97 of Example #8, I escape the double quotes that are part of HTML element attributes. I did this only because the color-coding of the plugin used to make code more readable was being particularly difficult for some reason. You will likely need to surround that entire string in single quotes, and remove the escape characters: “\”.

Summary

In this article we leverage MongoDB, mongoose and express middleware to create a very basic JSONP API. By using the .get() method of the express object instance, we created functions that respond to specific requests. As a result, we were able to provide the user with functionality to view all data, retrieve all data as a JSONP call, add a user to the database, or delete all data.

Dec22013 by dcm1 Comment

Using Mongoose ODM to Connect to MongoDB In Your Node.js Application

Node.js

Mongoose ODM simplifies the process of connecting to your MongoDB database in your Node.js application and working with the data.

If you are a JavaScript developer, using MongoDB as your backend database is a joy. If for no other reason, you get to think of and interact with data as JSON objects. This serves to solidify the case for Node.js: those of us who live and breathe JavaScript on the client side, can now extend our skill set to include server-side development using the language we love.

The quickest way to get up and running with MongoDB in your Node.js application is to leverage Mongoose ODM. The Mongoose website defines it as a : “…straightforward, schema-based solution to modeling your application data…”. That’s a little deep for me. Suffice it to say, it makes interacting with MongoDB incredibly simple.

In this article, our goal is extremely simple: connect to MongoDB, create a record and then show that record in a web page. While we will barely scratch the surface of what is possible, we will, at minimum, accomplish our modest goal. I’m sure that, as a programmer, you’ll get halfway through this code and realize how much more is possible. You can then take this very basic code, copy and paste it into your own application and then build a more robust solution.

Dependencies

In order to use the code in this article, you’ll need the following installed on your computer:

Installation of these components is beyond the scope of this article, but if you follow the provided links, they will point you in the right direction.

File Structure

app.js
package.json

For this article, we will need two files: app.js and package.json. In your project folder, create these two blank files. The following sections will explain what to put into them.

Example # 1A

{
  "name": "My-First-MongoDB-App",
  "version": "0.1.0",
  "description": "Simple MongoDB example with Mongoose on Node.js",
  "main": "app.js",
  "engines" : { 
      "node" : "0.8",
      "npm" : "&gt;=1.1"
  },
  "author": "Kevin Chisholm",
  "license": "MIT",
  "dependencies": {
    "mongoose": "3.5.7"
  }
}

{

"name": "My-First-MongoDB-App",

"version": "0.1.0",

"description": "Simple MongoDB example with Mongoose on Node.js",

"main": "app.js",

"engines" : {

"node" : "0.8",

"npm" : ">=1.1"

"author": "Kevin Chisholm",

"license": "MIT",

"dependencies": {

"mongoose": "3.5.7"

}

In Example # 1A, we have the contents of package.json. I won’t spend too much time on this file. For a more detailed discussion about package.json files you can search this blog for helpful articles. I will point out that the single dependency declared is “mongoose”. When you use node package manager to install dependencies, npm will download version 3.5.7 of mongoose for us.

Example # 1B

sudo npm install

1	sudo npm install

In Example # 1B we see the command needed to install the dependencies for our application. In this case, the single dependency declared is “mongoose” version 3.5.7. Once you run this command, you will have everything needed to start writing code.

Getting Started

Open up app.js in your text editor. From this point on, you can copy / paste the code in each example into the app.js (or you can scroll to the bottom of this page and paste the entire code listing in one step).

Example # 2

//variables we'll need
var
http = require ("http"),
mongoose = require ("mongoose"),
dbConnString = "mongodb://localhost/myMongooseDb",
dbport = 5000,
salesSchema = null,//just a placeholder, we'll overwrite this a bit later
salesMember = null,//just a placeholder, we'll overwrite this a bit later
salesMemberDocument = null;//just a placeholder, we'll overwrite this a bit later

//variables we'll need

var

http = require ("http"),

mongoose = require ("mongoose"),

dbConnString = "mongodb://localhost/myMongooseDb",

dbport = 5000,

salesSchema = null,//just a placeholder, we'll overwrite this a bit later

salesMember = null,//just a placeholder, we'll overwrite this a bit later

salesMemberDocument = null;//just a placeholder, we'll overwrite this a bit later

In Example # 2 we have the variables that we need for our application. Here are the details:

http : a module built into node.js that provides http server methods
mongoose : will be an instance of mongoose, which we listed as a dependency
dbConnString : tells mongoose where the database is running
dbport : tells mongoose which port to use
salesSchema : will be explained a bit later
salesMember : will be explained a bit later

NOTE: I define salesSchema, salesMember and salesMemberDocument at the top of the script because it is a best practice to define all of your variables at the top of your script or function, even if you are not ready to initialize them.

Example # 3

//connect to the database
mongoose.connect(dbConnString,function(err, res){
  if (err){
    console.log ('ERROR connecting to: ' + dbConnString + '! ' + err);
  } else {
    console.log ('Successfully connected to: ' + dbConnString);
  }
});

//define the schema to use
salesSchema = new mongoose.Schema({
  name: {
    first: String,
    last: String
  },
  phone: String
});

//define the data model, using the schema that we just created
salesMember = mongoose.model('Sales', salesSchema);

// Clear out old data
salesMember.remove({}, function(err) {
  if (err) {
    console.log ('There was an error deleting the old data.');
  } else  {
    console.log ('Successfully deleted the old data.');
  } 
});

//connect to the database

mongoose.connect(dbConnString,function(err, res){

if (err){

console.log ('ERROR connecting to: ' + dbConnString + '! ' + err);

} else {

console.log ('Successfully connected to: ' + dbConnString);

}

});

//define the schema to use

salesSchema = new mongoose.Schema({

first: String,

last: String

phone: String

});

//define the data model, using the schema that we just created

salesMember = mongoose.model('Sales', salesSchema);

// Clear out old data

salesMember.remove({}, function(err) {

if (err) {

console.log ('There was an error deleting the old data.');

} else {

console.log ('Successfully deleted the old data.');

}

});

Connecting to the MongoDB Database

In Example # 3, we start out by connecting to the database. The first argument is the connection string, which tells mongoose to find the database. The second argument is a function. Because this connection is an asynchronous event, the anonymous function that we pass as the second argument allows us to safely act upon the completed connection event. Like many Node.js callbacks, this anonymous function takes two arguments: “err” and “res” (which you can of course name anything you want). In the callback, we are interested in the error argument. If the error argument is “falsy”, then we can assume it’s safe to proceed. In this case, we simply log the appropriate console messages.

Defining a Schema

Next up, we define our database schema. Again, just to keep things simple, I won’t go into this in detail. Suffice it to say that we are telling mongoose how the data we will work with will be structured.

Defining a Data Model

Now that we have defined our schema, we call the “model” method of the mongoose object, assigning the resulting value to our variable “salesMember”. When calling mongoose.model, we pass the name of the collection as the first argument (i.e. “Sales”). If the collection does not exist, then it will be created. Simple, simple, simple. The second argument is the schema that will be used, which in this case is the variable “salesSchema”.

Finally, we call the “remove” method of our “salesMember” model, which empties out the collection. This will of course delete the data that we are about to create each time you reload the page. You can safely skip this code block so that each time you run the script and create a new entry in the collection, it persists.

Example # 4

//create a new sales member
salesMemberDocument = new salesMember ({
  name: { first: Alfred E., last: 'Newman' },
  phone: "212-555-1212"
});

//save the new user to the database.  
salesMemberDocument.save(function (err) {
  if (err) console.log ('Error on save!');
});

//create a new sales member

salesMemberDocument = new salesMember ({

phone: "212-555-1212"

});

//save the new user to the database.

salesMemberDocument.save(function (err) {

if (err) console.log ('Error on save!');

});

Creating a Document in the MongoDB Collection

In Example # 4, we finally get down to business. Here we overwrite the “salesMemberDocument” variable with a new instance of the “salesMember” model. We pass it an object which represents the data for MongoDB document (you can think of this as a record in a database table and our “Sales” collection as the database table). We then call the “save” method of the salesMemberDocument object. This persists the data.

Example # 5

//create a server instance, and start it
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'application/json'});

    salesMember.find({}).exec(function(err, result) {
    if (!err) { 
      res.end(JSON.stringify(result, undefined, 2));
    } else {
      res.end('Error in query. ' + err)
    };
  });

}).listen(dbport);

//create a server instance, and start it

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'application/json'});

salesMember.find({}).exec(function(err, result) {

if (!err) {

res.end(JSON.stringify(result, undefined, 2));

} else {

res.end('Error in query. ' + err)

};

});

}).listen(dbport);

Starting the Server and Presenting the MongoDB Data

In Example # 5, we create an HTTP server and start it, and then immediately write a “200 ok” header, with the Content-Type of ‘application/json’ (we will present our data as JSON in the browser). Next, we call the find method of the “salesMember” model, passing it an empty object. This tells the “salesMember” model to return everything (i.e. all records in the database table). That method call takes an anonymous function as an argument. We check to see that there were no errors, and if not, we send the result of our find method call to the browser, courtesy of JSON.stringify().

Example # 6

//variables we'll need
var http = require ("http"),
mongoose = require ("mongoose"),
dbConnString = 'mongodb://localhost/myMongooseDb',
dbport = 5000,
salesSchema = null,//just a placeholder, we'll overwrite this a bit later
salesMember = null;//just a placeholder, we'll overwrite this a bit later

//connect to the database
mongoose.connect(dbConnString,function(err, res){
  if (err){
    console.log ("ERROR connecting to: " + dbConnString + "! " + err);
  } else {
    console.log ("Successfully connected to: " + dbConnString);
  }
});

//define the schema to use
salesSchema = new mongoose.Schema({
  name: {
    first: String,
    last: String
  },
  phone: String
});

//define the data model, using the schema that we just created
salesMember = mongoose.model("Sales", salesSchema);

// Clear out old data
salesMember.remove({}, function(err) {
  if (err) {
    console.log ("There was an error deleting the old data.");
  } else  {
    console.log ("Successfully deleted the old data.");
  } 
});

//create a new sales member
var salesMemberDocument = new salesMember ({
  name: { first: "Gary", last: "Newman" },
  phone: "212-555-1212"
});

//save the new user to the database.  
salesMemberDocument.save(function (err) {
  if (err) console.log ("Error on save!");
});

//create a server instance, and start it
http.createServer(function (req, res) {
  res.writeHead(200, {"Content-Type": "application/json"});

    salesMember.find({}).exec(function(err, result) {
    if (!err) { 
      res.end(JSON.stringify(result, undefined, 2));
    } else {
      res.end("Error in query. " + err)
    };
  });

}).listen(dbport);

//variables we'll need

var http = require ("http"),

mongoose = require ("mongoose"),

dbConnString = 'mongodb://localhost/myMongooseDb',

dbport = 5000,

salesSchema = null,//just a placeholder, we'll overwrite this a bit later

salesMember = null;//just a placeholder, we'll overwrite this a bit later

//connect to the database

mongoose.connect(dbConnString,function(err, res){

if (err){

console.log ("ERROR connecting to: " + dbConnString + "! " + err);

} else {

console.log ("Successfully connected to: " + dbConnString);

}

});

//define the schema to use

salesSchema = new mongoose.Schema({

first: String,

last: String

phone: String

});

//define the data model, using the schema that we just created

salesMember = mongoose.model("Sales", salesSchema);

// Clear out old data

salesMember.remove({}, function(err) {

if (err) {

console.log ("There was an error deleting the old data.");

} else {

console.log ("Successfully deleted the old data.");

}

});

//create a new sales member

var salesMemberDocument = new salesMember ({

phone: "212-555-1212"

});

//save the new user to the database.

salesMemberDocument.save(function (err) {

if (err) console.log ("Error on save!");

});

//create a server instance, and start it

http.createServer(function (req, res) {

res.writeHead(200, {"Content-Type": "application/json"});

salesMember.find({}).exec(function(err, result) {

if (!err) {

res.end(JSON.stringify(result, undefined, 2));

} else {

res.end("Error in query. " + err)

};

});

}).listen(dbport);

In Example # 6, we have the complete code for our Node.js application. If you paste all of this code into app.js, and be sure that you have successfully executed that file in Node.js, open a browser, and then enter “localhost:5000” in the address bar, you will see the application in action.

Running the Application

In your terminal, navigate to the application folder, and then run the following command:

node app.js

1	node app.js

Example # 7

[
  {
    "phone": "212-555-1212",
    "_id": "5234e505674f223908000001",
    "__v": 0,
    "name": {
      "first": "Alfred E.",
      "last": "Newman"
    }
  }
]

[

{

"phone": "212-555-1212",

"_id": "5234e505674f223908000001",

"__v": 0,

"name": {

"first": "Alfred E.",

"last": "Newman"

}

]

In Example # 7, we have the JSON data returned in the browser. If you followed the instructions in each step of this article, this is what you should see (although the value of “_id” will differ).

Summary

In this article we learned how to use Mongoose ODM to make a connection to a MongoDB database in a Node.js application. We learned how to define mongoose as a dependency and install it with npm (node package manager). We also covered how to connect to the database, instantiate the schema class, and define a model. In addition, we discussed how to create a new document, save it, and then retrieve it. While this article presented the most bare-bones information on the topic, I hope that it has provided the background you need to get started with MongoDB.

Helpful Links for Mongoose ODM and MogoDB

Jun242013 by dcmNo Comments

Making a Simple HTTP Server with Node.js – Part IV

Node.js

Setting the right value for the “Content-Type” header is a critical task for any web server

In Part III of this series, we built out our Node.js server to serve up any file that is requested, or gracefully return a 404 / “Not Found” header, as well as a custom HTML page informing the user that the requested file was not found. But the only problem is that we are not setting headers for each request. So, it’s important that HTML, CSS, JavaScript and image file, have the appropriate “Content-Type” header set.

In order to demonstrate all of this, we will include a CSS file and a JavaScript file in our web page. I won’t bother including the CSS file in an example; it’s just some silly CSS… nothing too interesting. But I will include the source of our JavaScript file in Example # 1, just so we can see that the second blue box in the web page is created via JavaScript.

TO SAVE TIME, THE FULL WORKING VERSION OF THE CODE EXAMPLES CAN BE CLONED HERE: HTTPS://GITHUB.COM/KEVINCHISHOLM/SIMPLE-HTTP-SERVER-WITH-NODE-PART-IV

Example # 1

var div = document.createElement('div'),
text = document.createTextNode('This box was added by my JavaScript file');

div.className="colorBox blueBack";
div.appendChild(text);
document.getElementsByTagName('body')[0].appendChild(div);

var div = document.createElement('div'),

text = document.createTextNode('This box was added by my JavaScript file');

div.className="colorBox blueBack";

div.appendChild(text);

document.getElementsByTagName('body')[0].appendChild(div);

Example # 1 simply shows the contents of the JavaScript file: “script.js” that we will request in our pages.

Example # 2

<!DOCTYPE html> 
<html> 
    <head> 
        <meta charset="utf-8"> 
        <title>My First Node.js Page</title>
        <link href="style.css" rel="stylesheet" type="text/css" />
    </head> 
    <body>
        <img src="node-js-logo.png"/>
		<div class="colorBox redBack">
			My awesome content goes here....
		</div>
        <script src="script.js"></script>
    </body> 
</html>

<!DOCTYPE html>

<html>

<head>

<title>My First Node.js Page</title>

</head>

<body>

My awesome content goes here....

</div>

</body>

</html>

Example # 2 is the source code for index.html.

Example # 3

<!DOCTYPE html> 
<html> 
    <head> 
        <meta charset="utf-8"> 
        <title>About</title>
        <link href="style.css" rel="stylesheet" type="text/css" />
    </head> 
    <body> 
		<div class="colorBox redBack">
			About our company....
		</div>
        <script src="script.js"></script>
    </body> 
</html>

<!DOCTYPE html>

<html>

<head>

<title>About</title>

</head>

<body>

About our company....

</div>

</body>

</html>

Example # 3 is the source code for about.html, a second web page that we can request from our Node.js web server.

Before we go any further, let’s take a moment to discuss the folder structure. Just as in Part III of this series, the folder that our server.js file sits in has a sub-folder named “public”. This is where our assets will go. It is this “public” folder that the world will have access to and all requested files will be in there. See Figure # 1.

Example # 4

extensions = {
  ".html" : "text/html",
  ".css" : "text/css",
  ".js" : "application/javascript",
  ".png" : "image/png",
  ".gif" : "image/gif",
  ".jpg" : "image/jpeg"
};

extensions = {

".html" : "text/html",

".css" : "text/css",

".js" : "application/javascript",

".png" : "image/png",

".gif" : "image/gif",

".jpg" : "image/jpeg"

};

In Example # 4, we have a JavaScript object that contains a list of mime-types that we will support. Each of the object’s properties represents a file extension that we plan to support, and the corresponding value is the mime-type string that will be used for the “Content-Type” header.

Example # 5

var
fileName = path.basename(req.url) || 'index.html',
ext = path.extname(fileName),
localFolder = __dirname + '/public/',
page404 = localFolder + '404.html';

var

fileName = path.basename(req.url) || 'index.html',

ext = path.extname(fileName),

localFolder = __dirname + '/public/',

page404 = localFolder + '404.html';

In Example # 5, we have added a new line to the variable declarations for the requestHandler() function. The variable “ext” contains a string copy of the requested file’s extension (e.g. “.html” for a web page, “.js” for a JavaScript file, and so on). So we will use that string to check all properties of the “extensions” object from Example # 4. Don’t worry if you feel like you are getting lost; we’ll piece everything together nicely at the end. For now, just know that we have so far provided a hard-coded list of file extensions that we will allow, and the mime-type string values for each one, and we have the variable: “ext” that tells us what the file type is.

Example # 6

//do we support the requested file type?
if(!extensions[ext]){
	//for now just send a 404 and a short message
	res.writeHead(404, {'Content-Type': 'text/html'});
	res.end("&lt;html&gt;&lt;head&gt;&lt;/head&gt;&lt;body&gt;The requested file type is not supported&lt;/body&gt;&lt;/html&gt;");
};

//do we support the requested file type?

if(!extensions[ext]){

//for now just send a 404 and a short message

res.writeHead(404, {'Content-Type': 'text/html'});

res.end("<html><head></head><body>The requested file type is not supported</body></html>");

};

In Example # 6, we see if the extensions object has a property that matches the value of the “ext” variable. If not, we write a 404 header, and return a simple HTML page, informing the user that the requested file type is not supported.

Example # 7

getFile((localFolder + fileName),res,page404,extensions[ext]);

1	getFile((localFolder + fileName),res,page404,extensions[ext]);

In Example # 7, we add a new argument to the getFile() function call. We pass-in the value of the property in the extensions object that matches the file extension of the user’s request. In a nutshell, we are telling the getFile() function what type of mime-type to set in the response header.

Example # 8

function getFile(filePath,res,page404,mimeType)

In Example # 8, you can see that the getFile() function takes a new fourth argument, which is the <strong>mime-type</strong> for the requested file.

<strong>Example # 9

</strong>res.writeHead(200,{
	"Content-type" : mimeType,
	"Content-Length" : contents.length
});

function getFile(filePath,res,page404,mimeType)

In Example # 8, you can see that the getFile() function takes a new fourth argument, which is the <strong>mime-type</strong> for the requested file.

<strong>Example # 9

</strong>res.writeHead(200,{

"Content-type" : mimeType,

"Content-Length" : contents.length

});

In Example # 8, we have expanded the res.writeHead() function call. Where previously we only set the 200 / “OK” response code, we now set the “Content-Type” and “Content-Length” headers. The “Content-Type” property is mapped to the value of the mimeType variable, which was passed-in as an argument to the function. So the fruits of our labor in this article all become apparent in this example. The value of the mimeType variable will be set accordingly, for the file type.

Example # 9

//step 1) require the modules we need
var
http = require('http'),
path = require('path'),
fs = require('fs'),

//these are the only file types we will support for now
extensions = {
	".html" : "text/html",
	".css" : "text/css",
	".js" : "application/javascript",
	".png" : "image/png",
	".gif" : "image/gif",
	".jpg" : "image/jpeg"
};

//helper function handles file verification
function getFile(filePath,res,page404,mimeType){
	//does the requested file exist?
	fs.exists(filePath,function(exists){
		//if it does...
		if(exists){
			//read the fiule, run the anonymous function
			fs.readFile(filePath,function(err,contents){
				if(!err){
					//if there was no error
					//send the contents with the default 200/ok header
					res.writeHead(200,{
						"Content-type" : mimeType,
						"Content-Length" : contents.length
					});
					res.end(contents);
				} else {
					//for our own troubleshooting
					console.dir(err);
				};
			});
		} else {
			//if the requested file was not found
			//serve-up our custom 404 page
			fs.readFile(page404,function(err,contents){
				//if there was no error
				if(!err){
					//send the contents with a 404/not found header 
					res.writeHead(404, {'Content-Type': 'text/html'});
					res.end(contents);
				} else {
					//for our own troubleshooting
					console.dir(err);
				};
			});
		};
	});
};

//a helper function to handle HTTP requests
function requestHandler(req, res) {
	var
	fileName = path.basename(req.url) || 'index.html',
	ext = path.extname(fileName),
	localFolder = __dirname + '/public/',
	page404 = localFolder + '404.html';

	//do we support the requested file type?
	if(!extensions[ext]){
		//for now just send a 404 and a short message
		res.writeHead(404, {'Content-Type': 'text/html'});
		res.end("&lt;html&gt;&lt;head&gt;&lt;/head&gt;&lt;body&gt;The requested file type is not supported&lt;/body&gt;&lt;/html&gt;");
	};

	//call our helper function
	//pass in the path to the file we want,
	//the response object, and the 404 page path
	//in case the requestd file is not found
	getFile((localFolder + fileName),res,page404,extensions[ext]);
};

//step 2) create the server
http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000
.listen(3000);

//step 1) require the modules we need

var

http = require('http'),

path = require('path'),

fs = require('fs'),

//these are the only file types we will support for now

extensions = {

".html" : "text/html",

".css" : "text/css",

".js" : "application/javascript",

".png" : "image/png",

".gif" : "image/gif",

".jpg" : "image/jpeg"

};

//helper function handles file verification

function getFile(filePath,res,page404,mimeType){

//does the requested file exist?

fs.exists(filePath,function(exists){

//if it does...

if(exists){

//read the fiule, run the anonymous function

fs.readFile(filePath,function(err,contents){

if(!err){

//if there was no error

//send the contents with the default 200/ok header

res.writeHead(200,{

"Content-type" : mimeType,

"Content-Length" : contents.length

});

res.end(contents);

} else {

//for our own troubleshooting

console.dir(err);

};

});

} else {

//if the requested file was not found

//serve-up our custom 404 page

fs.readFile(page404,function(err,contents){

//if there was no error

if(!err){

//send the contents with a 404/not found header

res.writeHead(404, {'Content-Type': 'text/html'});

res.end(contents);

} else {

//for our own troubleshooting

console.dir(err);

};

});

};

});

};

//a helper function to handle HTTP requests

function requestHandler(req, res) {

var

fileName = path.basename(req.url) || 'index.html',

ext = path.extname(fileName),

localFolder = __dirname + '/public/',

page404 = localFolder + '404.html';

//do we support the requested file type?

if(!extensions[ext]){

//for now just send a 404 and a short message

res.writeHead(404, {'Content-Type': 'text/html'});

res.end("<html><head></head><body>The requested file type is not supported</body></html>");

};

//call our helper function

//pass in the path to the file we want,

//the response object, and the 404 page path

//in case the requestd file is not found

getFile((localFolder + fileName),res,page404,extensions[ext]);

};

//step 2) create the server

http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000

.listen(3000);

Example # 9 is a complete code-listing for this article. In Figure # 2, we see the results of http://localhost:3000/index.html. So, as you can see, we are serving not only HTML, but also an image file, a CSS file and a JavaScript file. The JavaScript file dynamically creates the blue box you see on page load (simply to demonstrate that our JavaScript file is served correctly from our Node.js web server, and works).

In Figure # 3, we see that our “about.html” page works, and also pulls in the CSS and JavaScript files with no problems.

In Figure # 4, we inspect the JavaScript file call in the “net” tab of FireBug and can see that the “Content-Type” header is set accordingly.

The FireBug — Figure # 4: Inspecting the call to script.js in FireBug’s “net” panel

Summary

In this article we learned how to set the appropriate “Content-Type” header for each request, based on the file extension of the requested file. We demonstrated how to use the extname() method of the path module, to return the extension of the requested file. We also applied some logic, to handle scenarios in which the requested file-type is not supported.

Helpful Links for the Node.js path module

http://nodejs.org/api/path.html

http://docs.nodejitsu.com/articles/file-system/how-to-use-the-path-module

Helpful Links for HTTP header fields

http://en.wikipedia.org/wiki/List_of_HTTP_header_fields

http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html

Helpful Links for mime-types

http://en.wikipedia.org/wiki/MIME_type

http://en.wikipedia.org/wiki/MIME

Jun172013 by dcm5 Comments

Making a Simple HTTP Server with Node.js – Part III

Node.js

In Part II of this series: Making a Simple HTTP Server with Node.js – Part II we learned how to use the “path” and “file system” modules. By leveraging these Node.js modules, we were able to read the path of the HTTP request that our server received, and read from the file system of the web server. We also learned about the “__dirname” keyword, which provides an abstract reference to the folder in which the currently executing JavaScript file exists.

That version of our HTTP server simply checked to see if the request was for the file “index.html”, and if so, served it up. That was progress over Part I, but still not robust enough.

In this article, we will expand our Node.js HTTP server so that the following services are provided:

If an asset is requested, and it exists, it will be returned
If an asset is not specified, then “index.html” will be returned
If an asset is requested, and it does not exist, our custom 404.html page will be returned

We will make every effort to keep our three-step paradigm, which will, we hope, continue to illustrate that creating an HTTP web server with Node.js is at its core, quite simple. What we have to take a closer look at, is the fact that, as we ask more of our little web server, we have to roll up our sleeves and write the code that provides that very functionality.

So the good news is: It’s just more JavaScript. Yay!

Example # 1

//step 1) require the modules we need
var
http = require('http'),
path = require('path'),
fs = require('fs');

//step 2) create the server
http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000
.listen(3000);

//step 1) require the modules we need

var

http = require('http'),

path = require('path'),

fs = require('fs');

//step 2) create the server

http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000

.listen(3000);

In Example #1, we have the three-step core of our HTTP web server. We have already discussed each step in detail, so let’s just quickly re-cap:

Step # 1: Use the require() method to gain access to the Node.js modules that we need
Step # 2: Use the createServer() method of the HTTP module, and pass it a reference to our “requestHandler” function
Step # 3: Listen for a request on port # 3000

Simple, simple, simple.

Next, let’s look at two functions: our updated requestHandler() function, and then our new getFile() function.

Example # 2

//a helper function to handle HTTP requests
function requestHandler(req, res) {
	var
	fileName = path.basename(req.url) || 'index.html',
	localFolder = __dirname + '/public/',
	page404 = localFolder + '404.html';

	//call our helper function
	//pass in the path to the file we want,
	//the response object, and the 404 page path
	//in case the requestd file is not found
	getFile((localFolder + fileName),res,page404);
};

//a helper function to handle HTTP requests

function requestHandler(req, res) {

var

fileName = path.basename(req.url) || 'index.html',

localFolder = __dirname + '/public/',

page404 = localFolder + '404.html';

//call our helper function

//pass in the path to the file we want,

//the response object, and the 404 page path

//in case the requestd file is not found

getFile((localFolder + fileName),res,page404);

};

In Example # 2, we first look at the request, and if no file was requested (i.e. the user simply typed http://somedomain.com into their browser), then we prepare to serve up “index.html”.

As we learned in Part II, the __dirname keyword provides an abstract reference to the folder in which the currently executing JavaScript file resides. We then create a variable named “page404”, which will provide a reference to our custom “404 / Not Found” page, should we need it.

Now we have everything we need, so we call the getFile() function, passing it the path and name of the asset we want (i.d. index.html), the response object, and then the reference to our custom 404 page.

Example # 3

//helper function handles file verification
function getFile(filePath,res,page404){
	//does the requested file exist?
	fs.exists(filePath,function(exists){
		//if it does...
		if(exists){
			//read the file, run the anonymous function
			fs.readFile(filePath,function(err,contents){
				if(!err){
					//if there was no error
					//send the contents with the default 200/ok header
					res.end(contents);
				} else {
					//for our own troubleshooting
					console.dir(err);
				};
			});
		} else {
			//if the requested file was not found
			//serve-up our custom 404 page
			fs.readFile(page404,function(err,contents){
				//if there was no error
				if(!err){
					//send the contents with a 404/not found header 
					res.writeHead(404, {'Content-Type': 'text/html'});
					res.end(contents);
				} else {
					//for our own troubleshooting
					console.dir(err);
				};
			});
		};
	});
};

//helper function handles file verification

function getFile(filePath,res,page404){

//does the requested file exist?

fs.exists(filePath,function(exists){

//if it does...

if(exists){

//read the file, run the anonymous function

fs.readFile(filePath,function(err,contents){

if(!err){

//if there was no error

//send the contents with the default 200/ok header

res.end(contents);

} else {

//for our own troubleshooting

console.dir(err);

};

});

} else {

//if the requested file was not found

//serve-up our custom 404 page

fs.readFile(page404,function(err,contents){

//if there was no error

if(!err){

//send the contents with a 404/not found header

res.writeHead(404, {'Content-Type': 'text/html'});

res.end(contents);

} else {

//for our own troubleshooting

console.dir(err);

};

});

};

});

};

In Example # 3, there are some new things happening. First, we use the exists() method of the file system object that was returned by the “fs” module, and assigned to our variable: “fs”. This method takes two arguments: a path to the file, and an anonymous function. That anonymous function takes one argument: “exists” (call it whatever you like). That single argument provides a helpful “truthy/falsy” flag against which we can test.

So if you take a moment to think about this, you’ll find that it’s quite cool: baked into the Node.js “fs” module is a method that simply tells us whether or not a named file exists. This is a perfect example of the brilliance of Node.js modules. Imagine how much heavy lifting you’d have to do if you needed to provide this kind of implementation yourself. Fortunately, someone did it for you. And that module can be used over and over again… a zillion more times if you like.

So moving along, if the “exists” argument returns a “truthy” value, we use the fs.readFile() method to literally read the physical file from the local file system. We have a little error checking to make sure that the file read operation did not fail, and if it did not fail, we send the contents of that file back to the user.

If the requested file was not found (i.e. the “exists()” method told us that the named file does not exist), then we serve up the custom 404.html file that we still have a reference to.

Example # 4

//step 1) require the modules we need
var
http = require('http'),
path = require('path'),
fs = require('fs');

//helper function handles file verification
function getFile(filePath,res,page404){
	//does the requested file exist?
	fs.exists(filePath,function(exists){
		//if it does...
		if(exists){
			//read the fiule, run the anonymous function
			fs.readFile(filePath,function(err,contents){
				if(!err){
					//if there was no error
					//send the contents with the default 200/ok header
					res.end(contents);
				} else {
					//for our own troubleshooting
					console.dir(err);
				};
			});
		} else {
			//if the requested file was not found
			//serve-up our custom 404 page
			fs.readFile(page404,function(err,contents){
				//if there was no error
				if(!err){
					//send the contents with a 404/not found header 
					res.writeHead(404, {'Content-Type': 'text/html'});
					res.end(contents);
				} else {
					//for our own troubleshooting
					console.dir(err);
				};
			});
		};
	});
};

//a helper function to handle HTTP requests
function requestHandler(req, res) {
	var
	fileName = path.basename(req.url) || 'index.html',
	localFolder = __dirname + '/public/',
	page404 = localFolder + '404.html';

	//call our helper function
	//pass in the path to the file we want,
	//the response object, and the 404 page path
	//in case the requestd file is not found
	getFile((localFolder + fileName),res,page404);
};

//step 2) create the server
http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000
.listen(3000);

//step 1) require the modules we need

var

http = require('http'),

path = require('path'),

fs = require('fs');

//helper function handles file verification

function getFile(filePath,res,page404){

//does the requested file exist?

fs.exists(filePath,function(exists){

//if it does...

if(exists){

//read the fiule, run the anonymous function

fs.readFile(filePath,function(err,contents){

if(!err){

//if there was no error

//send the contents with the default 200/ok header

res.end(contents);

} else {

//for our own troubleshooting

console.dir(err);

};

});

} else {

//if the requested file was not found

//serve-up our custom 404 page

fs.readFile(page404,function(err,contents){

//if there was no error

if(!err){

//send the contents with a 404/not found header

res.writeHead(404, {'Content-Type': 'text/html'});

res.end(contents);

} else {

//for our own troubleshooting

console.dir(err);

};

});

};

});

};

//a helper function to handle HTTP requests

function requestHandler(req, res) {

var

fileName = path.basename(req.url) || 'index.html',

localFolder = __dirname + '/public/',

page404 = localFolder + '404.html';

//call our helper function

//pass in the path to the file we want,

//the response object, and the 404 page path

//in case the requestd file is not found

getFile((localFolder + fileName),res,page404);

};

//step 2) create the server

http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000

.listen(3000);

Example # 4 simply puts all our code examples together, to provide some context.

Summary

In this article we expanded our simple Node.js HTTP web server. We leveraged the exists() method of the “fs” (file system) object, to determine if the requested file actually exists, and provided logic that handles cases in which the requested file does not exist.

Helpful Links for the Node.js path and fs Modules

http://nodejs.org/api/fs.html

https://github.com/jprichardson/node-fs-extra

http://docs.nodejitsu.com/articles/file-system/how-to-write-files-in-nodejs

Jun32013 by dcm2 Comments

Making a Simple HTTP Server with Node.js – Part II

Node.js

OK, enough “Hello World!” Let’s serve up an HTML file, dagnabbit.

In Part I of this series: “Making a Simple HTTP Server with Node.js – Part I“, we learned the bare-bones steps needed to create an HTTP server with Node.js. While it was fun to see our text message make its way from our server-side JavaScript file, at the end of the day we sent a hard-coded text message. Not too sexy.

In this article, we will invite the user to type “index.html” into their browser window and prepare to be amazed. Ok, the user has to be on your local DEV machine, and type “http://localhost:3000/index.html”, but we have to start somewhere, right?

Example # 1

//step 1) require the modules we need
var
http = require('http'),//helps with http methods
path = require('path'),//helps with file paths
fs = require('fs');//helps with file system tasks
 
//a helper function to handle HTTP requests
function requestHandler(req, res) {
	var
	content = '',
	fileName = path.basename(req.url),//the file that was requested
	localFolder = __dirname + '/public/';//where our public files are located
 
	//NOTE: __dirname returns the root folder that
	//this javascript file is in.
 
	if(fileName === 'index.html'){//if index.html was requested...
		content = localFolder + fileName;//setup the file name to be returned
 
		//reads the file referenced by 'content'
		//and then calls the anonymous function we pass in
		fs.readFile(content,function(err,contents){
			//if the fileRead was successful...
			if(!err){
				//send the contents of index.html
				//and then close the request
				res.end(contents);
			} else {
				//otherwise, let us inspect the eror
				//in the console
				console.dir(err);
			};
		});
	} else {
		//if the file was not found, set a 404 header...
		res.writeHead(404, {'Content-Type': 'text/html'});
		//send a custom 'file not found' message
		//and then close the request
		res.end('<h1>Sorry, the page you are looking for cannot be found.</h1>');
	};
};
 
//step 2) create the server
http.createServer(requestHandler)
 
//step 3) listen for an HTTP request on port 3000
.listen(3000);

//step 1) require the modules we need

var

http = require('http'),//helps with http methods

path = require('path'),//helps with file paths

fs = require('fs');//helps with file system tasks

//a helper function to handle HTTP requests

function requestHandler(req, res) {

var

content = '',

fileName = path.basename(req.url),//the file that was requested

localFolder = __dirname + '/public/';//where our public files are located

//NOTE: __dirname returns the root folder that

//this javascript file is in.

if(fileName === 'index.html'){//if index.html was requested...

content = localFolder + fileName;//setup the file name to be returned

//reads the file referenced by 'content'

//and then calls the anonymous function we pass in

fs.readFile(content,function(err,contents){

//if the fileRead was successful...

if(!err){

//send the contents of index.html

//and then close the request

res.end(contents);

} else {

//otherwise, let us inspect the eror

//in the console

console.dir(err);

};

});

} else {

//if the file was not found, set a 404 header...

res.writeHead(404, {'Content-Type': 'text/html'});

//send a custom 'file not found' message

//and then close the request

res.end('<h1>Sorry, the page you are looking for cannot be found.</h1>');

};

//step 2) create the server

http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000

.listen(3000);

There are a few new things happening in Example # 1, when compared to the examples from Part I of this series. The biggest change is that we’ve expanded “Step # 1” and are requiring two new Node.js modules: “path” and “fs”.

The “path” module provides a number of methods that help you to examine and parse file paths. The “fs” module is short for “File System”. This module provides access to the file system. So here is where the fun stuff starts: Writing JavaScript that has access to the local file system? Yep. You bet. We have not even begun to scratch the surface of what is possible.

Next, our helper function has grown a bit as well. We use the basename() method of the path module to return the name of the file that was requested by the user (i.e. index.html). We then leverage the “__dirname” keyword, which provides a quick and easy handle to the folder that your server-side JavaScript file resides in.

After that, we check to see if the user has requested “index.html”, and if so we will return it. The fs.fileRead() method takes two arguments: a path to the physical file that we want to return to the user, and an anonymous function. That anonymous function takes two arguments: an error object, and the content of the file that is to be returned. So just to play it safe, we check to see if there is an error: if ( !err ). If there is none, then we use the res.end() method to return the contents of index.html and then close the request. If there was an error, for now we are piping it to the console for our own troubleshooting.

If none of that worked out, then we set a “404 / Not Found” header, and send some markup back, letting the user know. Step # 2 and Step # 3 haven’t changed since our last article: Create the server, and then listen for a request.

Phew!

That was a lot, but our Node.js HTTP server has grown up quite a bit. Instead of just sending back a plain text message or some hard-coded HTML, we are now serving up an actual HTML file. We could change that file any time, which would change what the user sees in the browser. It’s not exactly Facebook, but hey, we are creating an HTTP web server using nothing but JavaScript!

For Part III, we will smarten things up and enhance our server so that it will serve up any static content that is requested.

Summary

In this article we learned how to use the “path” and “file system” Node.js modules. By leveraging the modules, we were able to read the path of the HTTP request, and read from the file system. We also learned about the “__dirname” keyword.

Helpful Links for the Node.js path and fs Modules

http://nodejs.org/api/path.html

http://docs.nodejitsu.com/articles/file-system/how-to-use-the-path-module

http://nodejs.org/api/fs.html

http://jspro.com/nodejs/accessing-the-file-system-in-node-js/

http://docs.nodejitsu.com/articles/file-system/how-to-read-files-in-nodejs

May282013 by dcm1 Comment

Making a Simple HTTP Server with Node.js – Part I

Node.js

The beauty of creating an HTTP server with Node.js is that you are doing so using a language that you already know: JavaScript.

If you work with JavaScript, then you’ve probably heard about Node.js. What makes Node.js such an amazing technology is that it turns web-development on its head: a historically client-side language is now being used as a server-side language. I’m sure I don’t have to tell you how insanely cool this is.

When I first started looking at Node.js, my first question was: “Ok, server-side JavaScript. Got it. So what the heck can I do with it?”

Short answer: A lot.

Probably the most obvious and easiest to comprehend application for Node.js is to make a web server. Node handles all the low-level ugliness and let’s you just write code. The code you write is not too much different than the client-side JavaScript that you are used to. The biggest differences come in when you start to realize that you have access to the file system. You can do things with Node that are completely off-limits on the client side. When it comes to creating a simple HTTP server, the amount of code you need to write for proof of concept is amazingly minimal. The examples that follow are very basic. They don’t offer any real-world usefulness, but they do illustrate the small amount of effort needed to get up and running. In Part II of this series, we will look at more realistic HTTP server code for Node.js.

Example # 1 A

//step 1) specify that we need the ‘http’ module
var http = require('http');

  //step 2) start the server
  http.createServer(function (req, res) {

  //set an HTTP header of 200 and the meta type
  res.writeHead(200, {'Content-Type': 'text/plain'});

  //write something to the request and end it
  res.end('Your node.js server is running on localhost:3000');

}).listen(3000);//step 3) listen for a request on port 3000

//step 1) specify that we need the ‘http’ module

var http = require('http');

//step 2) start the server

http.createServer(function (req, res) {

//set an HTTP header of 200 and the meta type

res.writeHead(200, {'Content-Type': 'text/plain'});

//write something to the request and end it

res.end('Your node.js server is running on localhost:3000');

}).listen(3000);//step 3) listen for a request on port 3000

In Example # 1, we have the absolute bare minimum needed to set up an HTTP web server using Node.js. The very first line tells Node.js that we need to use the “http” module. Using Node’s “require” method, we assign the return value of the “HTTP” module to the variable “http”. This was Step # 1.

(A detailed discussion of the require() method is beyond the scope of this article, but a topic that plays an important role in Node.js. If you are not familiar with the Modules/AsynchronousDefinition proposal from Common.js, I highly recommend reading up on that topic. For any client or server-side JavaScript developer, it’s a biggie.)

The only part that might seem a bit confusing to some is the callback that is passed into the createServer() method. This callback is executed each time the server receives an HTTP request.

For Step # 2, we call the createServer() method of the http object. We pass that method an anonymous function which takes two arguments: the request object and the response object. Inside of that anonymous function, we use the writeHead() method of the response object, to set the server’s response of “200 ok” to the client’s browser, and set the header of “Content-type” to “text/plain”. Next, we call the end() method of the response object. The end() method closes the response to the client. It can also send output to the client. We pass in a string as an argument in this example, and that string is sent to the client’s browser.

For Step # 3, we call the listen() method on the return value of the createServer() method. We pass in “3000”, which tells Node.js to listen on port # 3000.

If you run this code in Node.js, and then in your browser, “type localhost:3000”, you will see the following in your browser: “Your node.js server is running on localhost:3000.”

Whew! The explanation for Example # 1A took much longer to write than the actual code!

As you can see, it’s pretty easy to create an HTTP server with Node.js. In my opinion, the only part that might seem a bit confusing to some is the callback that is passed into the createServer() method. This callback is executed each time the server receives an HTTP request. It might make things easier to understand if we move the guts of that callback to its own function, and then pass that function declaration as the callback to the createServer() method.

Example # 1 B

var http = require('http');

function requestHandler(req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('This request was handled by the requestHandler() function');
}

http.createServer(requestHandler).listen(3000);

var http = require('http');

function requestHandler(req, res) {

res.writeHead(200, {'Content-Type': 'text/plain'});

res.end('This request was handled by the requestHandler() function');

}

http.createServer(requestHandler).listen(3000);

In Example # 1B, we create a function declaration named requestHandler. Then we pass that function as the sole argument to the createServer() method. I believe that if you are new to Node.js, you’ll find it is easier to see what is going on, because the createServer() method is all on one line.

Example # 1 C

//a helper function to handle HTTP requests
function requestHandler(req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('This request was handled by the requestHandler() function');
}

//step 1) require the http module
var http = require('http');

//step 2) create the server
http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000
.listen(3000);

//a helper function to handle HTTP requests

function requestHandler(req, res) {

res.writeHead(200, {'Content-Type': 'text/plain'});

res.end('This request was handled by the requestHandler() function');

}

//step 1) require the http module

var http = require('http');

//step 2) create the server

http.createServer(requestHandler)

//step 3) listen for an HTTP request on port 3000

.listen(3000);

In Example # 1C, we’ve refactored our code to make things even simpler. First, our helper function processes the HTTP request, then Step 1, Step 2 and Step 3. Bing, Bang, Boom. Simple stuff.

Example # 2 A

var http = require('http');

function requestHandler(req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('<h1>My First Node.js Web Server</h1><p>Lorem ipsum dolor sit amet.</p>');
}

http.createServer(requestHandler).listen(3000);

var http = require('http');

function requestHandler(req, res) {

res.writeHead(200, {'Content-Type': 'text/plain'});

res.end('<h1>My First Node.js Web Server</h1><p>Lorem ipsum dolor sit amet.</p>');

}

http.createServer(requestHandler).listen(3000);

In Example # 2A, we’ve upgraded our message to the client’s browser to include some HTML. After all, HTML is what we will really want to serve, right? The only problem is that Node is not parsing the HTML. When you run this example in your browser, you see the HTML tags in the response. That is not what we want. What is happening?

The problem is in the header that we are setting with the res.writeHead() method call. The value of the “Content-Type” header is “text/plain”. So, Node just passes all the text along as… well, plain old text.

Example # 2 B

var http = require('http');

function requestHandler(req, res) {
 res.writeHead(200, {'Content-Type': 'text/html'});
 res.end('<h1>My First Node.js Web Server</h1><p>Lorem ipsum dolor sit amet.</p>');
}

http.createServer(requestHandler).listen(3000);

var http = require('http');

function requestHandler(req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});

res.end('<h1>My First Node.js Web Server</h1><p>Lorem ipsum dolor sit amet.</p>');

}

http.createServer(requestHandler).listen(3000);

In Example # 2B, we have changed the value of the “Content-Type” header to “text/html”. If you run this example in your browser, you will see that Node sends the string as HTML, so our H1 and UL elements are rendering as they should in the browser.

Example # 3

var http = require('http');

function requestHandler(req, res) {
  //write the HTTP header
  res.writeHead(200, {'Content-Type': 'text/html'});

  //here is our page header
  res.write('<h1>My First Node.js Web Server</h1>');

  //open the unordered list
  res.write('<ul>');

  //print ten <li> elements to the page
  for(var i = 0; i <= 10; i++){
    res.write('<li>' + i + '</li>');
  };

  //close the unordered list
  res.write('</ul>');

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

http.createServer(requestHandler).listen(3000);

var http = require('http');

function requestHandler(req, res) {

//write the HTTP header

res.writeHead(200, {'Content-Type': 'text/html'});

//here is our page header

res.write('<h1>My First Node.js Web Server</h1>');

//open the unordered list

res.write('<ul>');

//print ten <li> elements to the page

for(var i = 0; i <= 10; i++){

res.write('<li>' + i + '</li>');

};

//close the unordered list

res.write('</ul>');

//close the response

res.end();

}

http.createServer(requestHandler).listen(3000);

In Example # 3, we take things a bit further. Up until now, we have been using the res.end() method to do two things: send some text or HTML to the client’s browser, and then close the response. In this example, we use the res.write() method to send our HTML to the client’s browser, and the end() method is used only to close the request.

We’ve also introduced some logic into our code. While what this example accomplishes is very little, and has virtually no real-world value, it demonstrates that while we have created an HTTP server, we have done so with JavaScript, and we already know the JavaScript language. So, we can do something like create a for/loop block, and use that loop to provide some dynamic HTML output. Again, this “dynamic” aspect of our code is not very impressive, but I think you get the point: it’s just JavaScript, so the sky’s the limit.

Summary

In this article, we learned how to create a simple HTTP server using Node.JS. We covered the three most basic steps needed, which include requiring the HTTP module, calling the createServer() method, and then telling the server to listen for an HTTP request. Finally, we learned how the server executes a callback function for each HTTP request it receives, and the most basic things that need to happen inside of that callback.

Helpful Links for creating a simple Node.js HTTP Server

http://nodejs.org/

http://docs.nodejitsu.com/articles/HTTP/servers/how-to-create-a-HTTP-server

http://www.youtube.com/watch?v=jo_B4LTHi3I

http://stackoverflow.com/questions/6084360/node-js-as-a-simple-web-server

http://www.nodebeginner.org/

By leveraging the Node.js middleware “express”, we can create functionality for viewing, adding or deleting JSON data.

Dependencies

File Structure

Example # 1A

Example # 1B

Getting Started

Example #2

Example #3

Example #4

Example #5

Example #6

Example #7

Example #8

Summary

Mongoose ODM simplifies the process of connecting to your MongoDB database in your Node.js application and working with the data.

Dependencies

File Structure

Getting Started

Connecting to the MongoDB Database

Defining a Schema

Defining a Data Model

Creating a Document in the MongoDB Collection

Starting the Server and Presenting the MongoDB Data

Running the Application

Summary

Helpful Links for Mongoose ODM and MogoDB

General

Mongoose ODM

MogoDB

Setting the right value for the “Content-Type” header is a critical task for any web server

TO SAVE TIME, THE FULL WORKING VERSION OF THE CODE EXAMPLES CAN BE CLONED HERE: HTTPS://GITHUB.COM/KEVINCHISHOLM/SIMPLE-HTTP-SERVER-WITH-NODE-PART-IV

Summary

Helpful Links for the Node.js path module

Helpful Links for HTTP header fields

Helpful Links for mime-types

Summary

Helpful Links for the Node.js path and fs Modules

OK, enough “Hello World!” Let’s serve up an HTML file, dagnabbit.

Example # 1

Summary

Helpful Links for the Node.js path and fs Modules

The beauty of creating an HTTP server with Node.js is that you are doing so using a language that you already know: JavaScript.

Summary

Helpful Links for creating a simple Node.js HTTP Server