![\"Connect\"](\"/0c2e07fb212a4ae2213d88764997036c/connect.webp\")
In this blog, I will show you how to create a NodeJS server using core http module. We will create a simple server that will serve static assets and a simple API to return some JSON data.
\nIn the process, you will also learn about the request and response objects provided by NodeJS, which are used by every other framework built on top of NodeJS like ExpressJS etc.
\nWith that in mind, let's begin.
\nCreate a folder by any name and initialize a node project in it using npm init -y
package.json file in your directory.server.js in your directory.public at the root of your project.Add a file named index.html with the following content\nindex.html
<!DOCTYPE html>\n<html lang="en">\n<head>\n <meta charset="UTF-8">\n <meta name="viewport" content="width=device-width, initial-scale=1.0">\n <title>Demo</title>\n</head>\n<body>\n <h1>Coming from the Root </h1>\n</body>\n</html>Now we will create a node server that will serve our index.html file when a request is sent to /.
server.js
const http = require('http');\n const path = require('path');\n const fs = require('fs');\n const PORT = 3000;\n const hostname = 'localhost';\n\n // createServer is the http method used to create a web server that takes a callback.\n const server = http.createServer(serverHandler);\n\n // callback function definition\n function serverHandler(req, res) => {\n if(req.method === 'GET' && req.url === '/') {\n let filePath = path.resolve(__dirname, 'public/index.html')\n let fileExists = fs.existsSync(filePath);\n if (!fileExists) {\n res.statusCode = 404;\n res.setHeader('Content-Type', 'text/html');\n res.end(`\n <html>\n <body>\n <h3>Page not found</h3>\n </body>\n </html>`)\n } else {\n res.statusCode = 200;\n res.setHeader('Content-Type', 'text/html');\n fs.createReadStream(filePath).pipe(res);\n }\n }\n }\n\n server.listen(PORT, hostname, () => {\n console.log(`Server running at ${hostname}:${PORT}`); \n })Let's understand what just happened in the above code snippet:
\ncreateServer method provided by node http module. createServer takes a callback which will be called when there is an incoming request with req and res parameters.serverHandler, we have used an if block to check if the incoming request is a GET request and the request url is / then code inside if statement will be executed.index.html which we want to serve exists or not in our public directory using existsSync, which synchronously checks for the file at the given path and returns true if the file exists.createReadStream method from fs module and pipe it into res object which sends it to the browser.server.listen to start our server on the PORT 3000.Now it's time to test our server. Run node server.js at the root of the project, and you will see the server running on PORT 3000.\nOpen your browser and enter localhost:3000 in the address bar, and you will get the HTML response.
Now we will expand our callback, which we passed to createServer to handle one more GET request at /notes, which will return an array of notes to the browser.
Update the serverHandler function with the following code snippet in your server.js file
server.js
...\n function serverHandler(req, res) {\n if(req.method === 'GET' && req.url === '/') {\n let filePath = path.resolve(__dirname, 'public/index.html')\n let fileExists = fs.existsSync(filePath);\n if (!fileExists) {\n res.statusCode = 404;\n res.setHeader('Content-Type', 'text/html');\n res.end(`\n <html>\n <body>\n <h3>Page not found</h3>\n </body>\n </html>`)\n } else {\n res.statusCode = 200;\n res.setHeader('Content-Type', 'text/html');\n fs.createReadStream(filePath).pipe(res);\n }\n }\n // Newly added code \n if (req.method === 'GET' && req.url === "/notes") {\n const notes = [\n {\n id: 1,\n title: "Demo Note"\n },\n {\n id: 2,\n title: "Another Note"\n }\n ]\n\n res.statusCode = 200;\n res.setHeader('Content-Type', 'application/json');\n res.end(JSON.stringify(notes));\n } else {\n res.setHeader('Content-Type', 'application/json')\n res.end(JSON.stringify({message: `${req.method} is not supported for ${req.url}`}))\n } \n }\n ...if statement to handle the request coming at /notes .application/json for the browser to process it accordingly.With that, we have created a simple node server to serve static content as well a simple API to return JSON data.
\nWe saw how we had to handle each request with its method and the URL. With an increasing number of routes, such things become hard to manage as we will have to add multiple if statements. And that's why frameworks like ExpressJS, HapiJS exist, which makes creating servers in NodeJS very easy. But it's important to know what happens under the hood as there is no magic happening in those frameworks.
\nThe complete code for this blog can be found at Github Repo.
\n","frontmatter":{"date":"November 27, 2020","updated_date":null,"title":"NodeJS Server using Core HTTP Module","tags":["NodeJs","JavaScript"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/8d8c41d9ba7fce1f1b5c6d72e0982463/58556/coverImage.webp","srcSet":"/static/8d8c41d9ba7fce1f1b5c6d72e0982463/61e93/coverImage.webp 200w,\n/static/8d8c41d9ba7fce1f1b5c6d72e0982463/1f5c5/coverImage.webp 400w,\n/static/8d8c41d9ba7fce1f1b5c6d72e0982463/58556/coverImage.webp 800w,\n/static/8d8c41d9ba7fce1f1b5c6d72e0982463/99238/coverImage.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Hridayesh Sharma","github":"vyasriday","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/using-pgp-encryption-with-nodejs/"},"html":"PGP (Pretty Good Privacy) is a cryptographic process used to encrypt and decrypt information. It combines concepts from symmetric and asymmetric key encryption, maintaining some of the best security and usability aspects of both.
\nOne way PGP can be used is to protect the confidentiality of information. Once the information is encrypted, nobody will be able to decrypt it unless they have the right key. In practice, PGP is commonly used in sending and receiving emails, sharing information on the Dark Web, and others. This is because both on and off the Internet, there are ways to intercept information being sent, making encryption using PGP or similar critical.
\nOn a high-level the process between a sender and receiver looks like this:
\nNow, let's go over some examples in Node.js using the openpgp library.
\nWe'll go over some basic examples and show how to encrypt & decrypt large files using Node.js streams.
\nFirst, set up your Node.js project and install openpgp.js:
\nmkdir pgp-tutorial && cd pgp-tutorial && npm init\nnpm i openpgp --saveNote: examples use openpgp v4.10.8
\nWhen generating private and public PGP keys with OpenPGP, you can define which curve to use in Elliptic-curve cryptography. In this example, we use Ed25519 for its performance and small key size. For the full list of curves, you can choose from, refer to OpenPGP.js docs.
\nYou also need to define a passphrase used to decrypt files and the private key. In practice, this should be a strong, randomized secret generated for a single-use.
\n// generate-keys.js\nconst openpgp = require("openpgp");\n\ngenerate();\nasync function generate() {\n const { privateKeyArmored, publicKeyArmored } = await openpgp.generateKey({\n userIds: [{ name: "person", email: "person@somebody.com" }],\n curve: "ed25519",\n passphrase: "qwerty",\n });\n console.log(privateKeyArmored);\n console.log(publicKeyArmored);\n}Running the above gives us our private key:
\n-----BEGIN PGP PRIVATE KEY BLOCK-----\nVersion: OpenPGP.js v4.10.8\nComment: https://openpgpjs.org\n\nxYYEX6iKVxYJKwYBBAHaRw8BAQdANJ6JIXuMMZV3NIlwq0POS7xsF2N7+kAE\n7KQjAtfIuqj+CQMI4CUgW9jPsGPgJvQnnCWFf1s7lO/5+D5ZQ9JK25fUtmQo\nWyHX0Ja1ryOoFnvq7u+7fUC0+RAzt8S1xv3eDzazfgNuLtEmufwMyR6wMi78\nKc0ccGVyc29uIDxwZXJzb25Ac29tZWJvZHkuY29tPsKPBBAWCgAgBQJfqIpX\nBgsJBwgDAgQVCAoCBBYCAQACGQECGwMCHgEAIQkQVrbGpNEnCPUWIQQb8YRJ\nhw7DjekU68lWtsak0ScI9UM7AQDv4YRbIdU2ErPf8MobreeLiXXjYZ6fas8E\nzW0KoTZWEQD+NHDY2YYByMF1mWusPkdPDpyBzqMJrlMeihMzZ+PE8AfHiwRf\nqIpXEgorBgEEAZdVAQUBAQdARY37/Vys4Sj6DvwN6TRjxrIqiMIngxQgvOb6\nwi+tQzEDAQgH/gkDCJ2xNZ1OXxv94E8fTLQ3gYHFQuebn/PSijD8CqlvHNB/\n/Z9sIxSFt7rzorW+9v6Awfe+pQwXW5iEyJkdiGu3BM91GMwMvMmZ+rBNlBvq\niX7CeAQYFggACQUCX6iKVwIbDAAhCRBWtsak0ScI9RYhBBvxhEmHDsON6RTr\nyVa2xqTRJwj17W0BAI5MuCWHrqjSRcdjLTwxa++jYv+Yxq4tODj8oh27T86v\nAQCfb3lij9JGlIMNDQgceeougl+Lw4Gb0kQCnsNQRggTDw==\n=yzT4\n-----END PGP PRIVATE KEY BLOCK-----And the public key:
\n-----BEGIN PGP PUBLIC KEY BLOCK-----\nVersion: OpenPGP.js v4.10.8\nComment: https://openpgpjs.org\n\nxjMEX6iKVxYJKwYBBAHaRw8BAQdANJ6JIXuMMZV3NIlwq0POS7xsF2N7+kAE\n7KQjAtfIuqjNHHBlcnNvbiA8cGVyc29uQHNvbWVib2R5LmNvbT7CjwQQFgoA\nIAUCX6iKVwYLCQcIAwIEFQgKAgQWAgEAAhkBAhsDAh4BACEJEFa2xqTRJwj1\nFiEEG/GESYcOw43pFOvJVrbGpNEnCPVDOwEA7+GEWyHVNhKz3/DKG63ni4l1\n42Gen2rPBM1tCqE2VhEA/jRw2NmGAcjBdZlrrD5HTw6cgc6jCa5THooTM2fj\nxPAHzjgEX6iKVxIKKwYBBAGXVQEFAQEHQEWN+/1crOEo+g78Dek0Y8ayKojC\nJ4MUILzm+sIvrUMxAwEIB8J4BBgWCAAJBQJfqIpXAhsMACEJEFa2xqTRJwj1\nFiEEG/GESYcOw43pFOvJVrbGpNEnCPXtbQEAjky4JYeuqNJFx2MtPDFr76Ni\n/5jGri04OPyiHbtPzq8BAJ9veWKP0kaUgw0NCBx56i6CX4vDgZvSRAKew1BG\nCBMP\n=C6S6\n-----END PGP PUBLIC KEY BLOCK-----Now we can start encrypting information.
\nCreate a text file:
\necho 'This file contains secret information' > secrets.txtHere, we act as the sender who received a public key from the intended recipient. We use their public key to encrypt the confidential information:
\n// encrypt-file.js\nconst openpgp = require("openpgp");\nconst fs = require("fs");\n\nconst publicKeyArmored = <PUBLIC KEY GIVEN BY RECIPIENT>\n\nencrypt();\nasync function encrypt() {\n const plainData = fs.readFileSync("secrets.txt");\n const encrypted = await openpgp.encrypt({\n message: openpgp.message.fromText(plainData),\n publicKeys: (await openpgp.key.readArmored(publicKeyArmored)).keys,\n });\n\n fs.writeFileSync("encrypted-secrets.txt", encrypted.data);\n}In the newly created encrypted-secrets.txt file, we have the contents encrypted like so:
-----BEGIN PGP MESSAGE-----\nVersion: OpenPGP.js v4.10.8\nComment: https://openpgpjs.org\n\nwV4DUsPKVnc3UHMSAQdAey4TJiEOrZQIrx6q2zBLgmPkbnhPMt1WR+jCWX5x\nGn8wEim8W4OhDVMwfhtgVIClBCGPhvdeZ1zvVUAJGDdl8+S+DUynKhPNcN8m\nKb9TRGYs0sAlAaXcTChBHSS5kDHV/8Hgjcn0OIs6v2mbCkz/bHs/shwf8WMI\nov711iEkgcXnXIX+ZDGyDFnAKftoygzAf0aZy82g7ejAD9SX13wNmO6TK8Gw\nwr9Xj8F6XBV0yHvdsm2uzRY9W03tTSqAf0anEs+ZWyVR/ha9ddnZJPFKtUbC\nBEF4AMavsIN0CcqpA4q69I3E6GEtkAzgBWfJOOO8mQsNQ1vJWcJocinryBE6\nKbhznoe+R69qmUaJXPpe5scF6tfCYuQtPz4uhOljT+OUP6qss5Nz4zBs4JLq\nnUlyynLLSSgdVr4Hvg==\n=5tyF\n-----END PGP MESSAGE-----Now, as the sender, we can send the encrypted file to the recipient.
\nHere, we act as the reciever. To decrypt the encrypted-secrets.txt file, we use our private key and passphrase:
// decrypt-file.js\nconst openpgp = require("openpgp");\nconst fs = require("fs");\n\nconst privateKeyArmored = <PRIVATE KEY>\nconst passphrase = <PASS PHRASE>;\n\ndecrypt();\nasync function decrypt() {\n const privateKey = (await openpgp.key.readArmored([privateKeyArmored])).keys[0];\n await privateKey.decrypt(passphrase);\n\n const encryptedData = fs.readFileSync("encrypted-secrets.txt");\n const decrypted = await openpgp.decrypt({\n message: await openpgp.message.readArmored(encryptedData),\n privateKeys: [privateKey],\n });\n\n console.log(decrypted.data);\n}Which logs the decrypted file contents:
\nThis file contains secret information.If you plan on encrypting or decrypting large files, you won't be able to fit the entire file contents in memory. In this case, you can use Node.js streams.
\nHere, we encrypt a large file called dataset-1mill.json using streams:
encrypt();\nasync function encrypt() {\n const encrypted = await openpgp.encrypt({\n message: openpgp.message.fromText(fs.createReadStream("dataset-1mill.json")),\n publicKeys: (await openpgp.key.readArmored(publicKeyArmored)).keys,\n });\n\n let readStream = encrypted.data;\n let writeStream = fs.createWriteStream("encrypted-dataset.txt", { flags: "a" });\n readStream.pipe(writeStream);\n readStream.on("end", () => console.log("done!"));\n}And then, we decrypt the newly created encrypted-dataset.txt using streams:
openpgp.config.allow_unauthenticated_stream = true;\n\ndecrypt();\nasync function decrypt() {\n const privateKey = (await openpgp.key.readArmored([privateKeyArmored])).keys[0];\n await privateKey.decrypt(passphrase);\n\n const decrypted = await openpgp.decrypt({\n message: await openpgp.message.readArmored(fs.createReadStream("encrypted-dataset.txt")),\n privateKeys: [privateKey],\n });\n\n let readStream = decrypted.data;\n let writeStream = fs.createWriteStream("decrypted-dataset.json", { flags: "a" });\n readStream.pipe(writeStream);\n readStream.on("end", () => console.log("done!"));\n}Now, decrypted-dataset.json will have the same contents as our original dataset-1mill.json file.
Redis's usage as both a temporary data store and even as a permanent data store is increasing today, as memory has started becoming much cheaper. Redis' quick memory-based CRUD operations allow database interactions to happen significantly faster than interactions with other databases that use drive-based storage. This blog is about three different methods to interact with your Redis data.
\nThis blog will require having access to a Redis instance. Guides can be found to set up a local Redis instance for Windows here and for UNIX based machines like Mac or other Linux distros, it can be found here. Alternatively, you can use a remote instance, but be aware that some of the commands in this blog may delete or modify the data.
\nFor users that do not like working with command-line interfaces, the first tool introduced in this blog is a GUI interface called RedisInsight. This can be found here. After filling in their download form and installing, running the application will start a server on the localhost, which you can access with a browser.
\nAfter installing and running the application, you will add the connection information for your Redis instance. If running a local instance of Redis, the connection information in the image will typically suffice. If connecting to a remote instance, you might need to fill in some additional details for TLS, such as connection certificates.
\n
When connected to your Redis instance, the dashboard UI appears. Clicking the Browser sidebar tab will display all existing keys in your database.
\n![\"Browser\"](\"/5ebe56aa78be3e13e90b5f98095f979b/browser.webp\")
From here, CRUD operations are relatively straightforward. Key-value pair creation can be done by using the ADD KEY button. This will prompt for the type of key-value pair to be added (Hash, String, JSON, etc.) and the data that will be stored with the key.
\nIf a specific key is required to be queried, fill in the field next to the blue filter icon with search criteria, then click the icon. It will prompt the type of data stored with the key, and the results will be displayed.
\n![\"Filter\"](\"/3e991606bcc88dd356cd677f4c5b3919/filter.webp\")
Finally, keys can be deleted by clicking the trash can icon on the right side.
\nThe Redis command-line interface is a more common approach for developers to interact with data from a Redis store. If you followed the steps at the beginning of the blog, the CLI should already be installed. To do a ping test to the server, type the following command in the terminal:
\nchris@LR-ENG-17:~$ redis-cli -h localhost -p 6379 ping\nPONGAnd to connect, run the previous command without pinging:
\nchris@LR-ENG-17:~$ redis-cli -h localhost -p 6379\nlocalhost:6379>The basic command to get a key-value pair is to call get with the key:
\nlocalhost:6379> get key:1\n"value1"Setting a value can be done with the set command:
\nlocalhost:6379> set key:1 value1new\nOK\nlocalhost:6379> get key:1\n"value1new"Creating a value can also be done in the same way:
\nlocalhost:6379> get key:3\n(nil)\nlocalhost:6379> set key:3 value3new\nOK\nlocalhost:6379> get key:3\n"value3new"And deletion can be done with the del command:
\nlocalhost:6379> del key:3\n(integer) 1\nlocalhost:6379> get key:3\n(nil)\nlocalhost:6379>This is only the simple basics of the Redis CLI. You can do more advanced operations through the CLI, such as the flushall command, which wipes your database. It’s a powerful tool, so be careful when experimenting with it. An extensive list of commands can be found here.
\nWith Redis’ widespread usage, almost all major industry programming languages have either community or official supported releases of libraries that can be used to interact with your database. In this section, I will be using Node.JS, and one of the support Redis libraries called node-redis.
\nInitialization of the package in the code can be done by calling the following command after initializing Node in your directory:
\nnpm install redisWhen the process is finished, the redis module should be imported within your code, where you can set up the Redis connection and any options that need to be included:
const redis = require("redis")\n\nconst redisOption = {\n host: "127.0.0.1",\n port: "6379",\n}\n\nconst client = redis.createClient()For an extensive list of options supported by the library for connection, check this link.
\nAfter connecting, calling the on method on the client will allow the connection to open and run commands.
The commands used by the library are a 1 to 1 mapping of the commands used by the Redis CLI, so they follow the same method calls. To update or create an entry in Redis, the most basic method is to use the set command:
\nclient.set("key:3", "value3new")Getting a value can be done with the get method:
\nclient.get("key:3")Deleting a value can be done with the del method:
\nclient.del("key:3")The methods used by the client also support callbacks. For example, if the operations should be console logged, we can include a callback to redis.print after each method:
client.set("key:3", "value3new", redis.print)\nclient.get("key:3", redis.print)\nclient.del("key:3", redis.print)The output of this in the console would be:
\nReply: OK\nReply: value3new\nReply: 1This blog has only touched the surface of the different operations Redis can do. There are many more resources online that can help you go further into your understanding of Redis. Whether using Redis as a temporary store, like a cache, or using it as a primary, permanent store, the operations' speed is something to be acknowledged and considered when building your next big app.
\n","frontmatter":{"date":"October 21, 2020","updated_date":null,"title":"Three Ways to do CRUD Operations On Redis","tags":["Redis","NodeJs","CLI","GUI"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/6597d1ce622532f445baf8ba0ef6e846/58556/index.webp","srcSet":"/static/6597d1ce622532f445baf8ba0ef6e846/61e93/index.webp 200w,\n/static/6597d1ce622532f445baf8ba0ef6e846/1f5c5/index.webp 400w,\n/static/6597d1ce622532f445baf8ba0ef6e846/58556/index.webp 800w,\n/static/6597d1ce622532f445baf8ba0ef6e846/99238/index.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Chris Yee","github":null,"avatar":null}}}},{"node":{"fields":{"slug":"/engineering/build-a-twitter-bot-using-nodejs/"},"html":"Hey there! In this blog post, we will build a twitter bot that let us tweet using the command line directly.
\n\n\n\n
We will use twitter - a client library for the Twitter REST and Streaming APIs. This npm package will make the whole process of building the bot a whole lot easier and faster.
\nTo be able to access Twitter API, you need a Twitter Developer Account. Apply for it here. Click on Apply for a Developer Account.
\n![\"Twitter](\"/5d738c8f8819770413d37f829cde3598/twitter.webp\")
It will ask you to log in. Select appropriate settings after logging in. It will also generate keys and secret tokens like Consumer Key, Consumer Secret, Access Token Key, Access Token Secret. Copy and save them somewhere for future use.
\nMake a project folder with any name of your choice. Run npm init to initialize the project. This will generate a package.json file in your directory. Alternatively, you can run npm init -y to setup your project with default settings.
\n\n\n
package.jsonholds all the dependencies of a project.
Since our project will be dependent on twitter client library, it's time we install this dependency in our project. Run npm install twitter to include this in your package.json .
Now we will start with the actual coding part. At the moment, your project folder will have a node_modules folder, a package.json file, and a package-lock.json file. If you have gone with the default options while running npm init, then index.js is the file we will be working upon.
Open index.js. To be able to use the twitter library, which we have installed, you need to include it in index.js.
var Twitter = require('twitter');
Also, remember the keys and tokens you got from Twitter Developer Portal? It's time we use them.
\nvar client = new Twitter({\n\tconsumer_key: process.env.CONSUMER_KEY,\n\tconsumer_secret: process.env.CONSUMER_SECRET,\n\taccess_token_key: process.env.ACCESS_TOKEN_KEY,\n\taccess_token_secret: process.env.ACCESS_TOKEN_SECRET\n});Do not add your Consumer or Access Token keys or secrets directly in the index.js. These should be managed accordingly using environment variables.
\n\nWe will use
\ndotenvlibrary to manage our environment variables in NodeJS. Runnpm install dotenvand follow these instructions. Your.envwill look something like this.
CONSUMER_KEY=........................................\nCONSUMER_SECRET=.....................................\nACCESS_TOKEN_KEY=....................................\nACCESS_TOKEN_SECRET=.................................I will use Official Joke API to automatically fetch content for my tweet. You can visit the repository and learn more about the endpoints. But the only endpoint we will work with is random_joke. Click on this, and you will receive a JSON response with fields id, type, setup, and punchline. The fields we are concerned with are setup and punchline.
\nWe will use axios for calling the API endpoint. Run npm install axios and add var axios = require('axios'); in index.js.
Now everything has been laid out. We need to connect the dots. The Official Joke API will return a JSON response. We will grab the required data, i.e., the setup and the punchline from it. And then make use of client.post functionality of twitter package.
\naxios("https://official-joke-api.appspot.com/random_joke").then(Response => {\n\treturn [Response.data.setup, Response.data.punchline];\n}).then(([setup, punch]) => {\n\tclient.post('statuses/update', {status: `${setup}\\n${punch}`}, function(error, tweet, response){\n\t\tif(!error){\n\t\t\tconsole.log(tweet);\n\t\t}\n\t})\n});Now run node index.js on the terminal and see the output.\nIf everything went well, you would see a tweet response, otherwise an error message. The successful message would look something like this.
At this point, your index.js should look like this.
\n![\"index.js\"](\"/4081a47a94b07d7916221d3f11de5121/code.webp\")
That's it! You have created your first Twitter Bot, which tweets content after directly calling it from an API. You might take a look at the repository if you encountered any errors. Here, I have used different APIs to fetch content and tweet. Moreover, I have added a script that will search posts with a particular hashtag and like them.
\n\n\nWhile pushing your code to GitHub, make sure to add
\n.gitignorefile and includenode_modulesand.envin it.
\n\nThe world is yours to explore.
\n
And the dev world is based entirely on exploring technologies and frameworks. Play with this twitter library and see what interesting stuff can be built with it. Maybe, search tweets with a particular hashtag and like them? Or maybe, retweet tweets of any particular user? You are free to use your imagination and coding skills to explore more and more. If axios and dotenv are new to you, then go ahead and read their documentation. Get hold of the concepts of environment variables. And come up with your own cool Twitter Bot.
\n\n","frontmatter":{"date":"October 14, 2020","updated_date":null,"title":"Build A Twitter Bot Using NodeJS","tags":["NodeJs","Twitter","Bot"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/820019d481163bc17d6c095404abb359/58556/cover.webp","srcSet":"/static/820019d481163bc17d6c095404abb359/61e93/cover.webp 200w,\n/static/820019d481163bc17d6c095404abb359/1f5c5/cover.webp 400w,\n/static/820019d481163bc17d6c095404abb359/58556/cover.webp 800w,\n/static/820019d481163bc17d6c095404abb359/99238/cover.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Vineeta Jain","github":"Ninjavin","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/upload-files-with-node-and-multer/"},"html":"Keep in mind Twitter's Developer Policy & Terms and Twitter Terms & Conditions. These should not be violated in whatever project you are building.
\n
When building APIs, the need to upload files is expected, which can be images, text documents, scripts, pdfs, among others. In the development of this functionality, some problems can be found, such as the number of files, valid file types, sizes of these files, and several others. And to save us from these problems we have the Multer library. Multer is a node.js middleware for handling multipart/form-data that is used to send files in forms.
The first step is to create a NodeJS project on your computer.
\nIn your terminal, type the following command:
\nyarn add express* You can also use NPM for installation
\nCreate a file named app.js inside the src/ folder. The next step is to start our Express server in our app.js
const express = require("express")\nconst app = express()\n\napp.listen(3000 || process.env.PORT, () => {\n console.log("Server on...")\n})With the project created, configured and with Express installed, we will add the multer to our project.
\nyarn add multerThe next step is to import the multer into our app.js file.
const multer = require("multer")We are almost there. Now create a folder called uploads where we will store the uploaded files.
Now we are at a very important stage which is the configuration of diskStorage. DiskStorage is a method made available by multer where we configure the destination of the file, the name of the file and we can also add validations regarding the type of the file. These settings are according to the needs of your project. Below I will leave an elementary example of the configuration.
const storage = multer.diskStorage({\n destination: (req, file, cb) => {\n cb(null, "uploads/")\n },\n filename: (req, file, cb) => {\n cb(null, Date.now() + "-" + file.originalname)\n },\n})In the configuration above, we mentioned the destination for the uploaded files and also change the name of the file .
\nconst uploadStorage = multer({ storage: storage })\n\n// Single file\napp.post("/upload/single", uploadStorage.single("file"), (req, res) => {\n console.log(req.file)\n return res.send("Single file")\n})\n\n//Multiple files\napp.post("/upload/multiple", uploadStorage.array("file", 10), (req, res) => {\n console.log(req.files)\n return res.send("Multiple files")\n})In the code snippet above, we created 2 POST routes for sending files. The first /upload/single route receives only a single file, note that the uploadStorage variable receives our diskStorage settings. As a middleware in the route, it calls the single method for uploading a single file. The /upload/multiple route receives several files, but with a maximum limit of 10 files, note that the uploadStorage variable now calls the ʻarray` method for uploading multiple files.
With all the settings done, our little API is already able to store the files sent.
\nconst express = require("express")\nconst multer = require("multer")\n\nconst app = express()\n\nconst storage = multer.diskStorage({\n destination: (req, file, cb) => {\n cb(null, "uploads/")\n },\n filename: (req, file, cb) => {\n cb(null, Date.now() + "-" + file.originalname)\n },\n})\n\nconst uploadStorage = multer({ storage: storage })\n\n// Single file\napp.post("/upload/single", uploadStorage.single("file"), (req, res) => {\n console.log(req.file)\n return res.send("Single file")\n})\n//Multiple files\napp.post("/upload/multiple", uploadStorage.array("file", 10), (req, res) => {\n console.log(req.files)\n return res.send("Multiple files")\n})\n\napp.listen(3000 || process.env.PORT, () => {\n console.log("Server on...")\n})Now it's up to you!
\n","frontmatter":{"date":"October 12, 2020","updated_date":null,"title":"Upload files using NodeJS + Multer","tags":["NodeJs","Express","Multer"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/7abf157b1bfeb7c65d7e338a620ac875/58556/node-multer-upload.webp","srcSet":"/static/7abf157b1bfeb7c65d7e338a620ac875/61e93/node-multer-upload.webp 200w,\n/static/7abf157b1bfeb7c65d7e338a620ac875/1f5c5/node-multer-upload.webp 400w,\n/static/7abf157b1bfeb7c65d7e338a620ac875/58556/node-multer-upload.webp 800w,\n/static/7abf157b1bfeb7c65d7e338a620ac875/99238/node-multer-upload.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Gabriel Rabelo","github":"gabrielrab","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/write-a-javascript-library-using-webpack-and-babel/"},"html":"In this blog we will learn how to create our own webpack configuration to bundle a small JavaScript utility library using webpack and babel.
\nLet's create the source code for our library. For that we will be create two utility functions into two separate files in our source folder.
\ndemo and run following command in it. $ npm init -yThe above command will create a package.json in your project root. I am using a --y to initialize it with default options.
Directory Structure
\ndemo\n |-- src/\n |-- package.jsonLet's add our source code into src directory:
src\n |--index.js\n |--capital.js\n |--addDOMContent.jsOur utility library contains two functions capital, to capitalize a string and addDOMContent, to add content to a web page, each in it's own module.
capital.js
function capital(string) {\n const capitalizedString =\n string.substring(0, 1).toUpperCase() + string.substring(1)\n return capitalizedString\n}\n\nexport default capitaladdDOMContent.js
function addDOMContent(content) {\n const node = document.createElement("h1")\n node.innerText = content\n document.body.appendChild(node)\n}\n\nexport default addDOMContentInside our index.js, we will import these two functions.
index.js
import capital from "./capital"\nimport addDOMContent from "./addDOMContent"\n\nexport { capital, addDOMContent }So far we got the source code ready but we still need to bundle it so that the browsers can understand and oh boy!, we need to support some older browsers too 🙄. Anyway, being responsible developers we are going to do that 😎.
\n $ npm i --save-dev webpack webpack-cli @babel/core @babel/preset-env babel-loaderWe need webpack to bundle our code and webpack-cli is a command-line tool that uses webpack to do the same. Also webpack requires babel-loader to transpile our ES6 code to ES5 before bundling (Remember, what I said about being responsible developers 😃).
4.1. Create a webpack.config.js at the root of the project.
webpack.config.js
const path = require("path")\n\nmodule.exports = {\n entry: path.resolve(__dirname, "src/index.js"),\n output: {\n path: path.resolve(__dirname, "dist"),\n filename: "index_bundle.js",\n library: "$",\n libraryTarget: "umd",\n },\n module: {\n rules: [\n {\n test: /\\.(js)$/,\n exclude: /node_modules/,\n use: "babel-loader",\n },\n ],\n },\n mode: "development",\n}There are a couple of things we need to understand about webpack configuration. Stay with me for a couple more minutes.
\nentry: In order for webpack to know where to start with, it needs to know the entry point to our app.module.rules: Each file in Node is treated like a module. Webpack itself understands only Javascript and JSON modules. Since we want to transpile ES6, we need babel-loader and webpack needs to know the rules on how to process the Javascript using the given loader.output: After creating the bundle, webpack needs to know what name to give it and where to put it.library and libraryTarget are used to expose our library where library being the name,$ here and libraryTarget is the property to configure, how the library will be exposed. Here we will be using UMD. UMD is a module system capable of working everywhere, be it in the client, on the server or elsewhere.mode: Webpack bundles code into either development mode (unminified) or in production(minified) mode. I am using a hard coded value here for the demo. You can set it using environment variables too.
\n4.2. Create a .babelrc file at the root of the project.
.babelrc
{\n presets: ["@babel/preset-env"]\n}@babel/preset-env let's us use the latest Javascript without any polyfills and syntax transforms.babel-loader uses babel under the hood.
By Now our Project Structure should look like this:
\ndemo\n|-- src\n| |-- index.js\n| |-- capital.js\n| |-- addDOMContent.js\n|-- webpack.config.js\n|-- .babelrc\n|-- package.json\n|-- node_modulesWe have added our source files, now let's add an npm script to build final code using webpack and modify the main property inside our package.json to point it to our bundled code.
package.json
{\n "name": "demo",\n "version": "1.0.0",\n "description": "",\n+ "main": "dist/index_bundle.js",\n+ "scripts": {\n+ "build": "webpack"\n+ },\n "keywords": [],\n "author": "Hridayesh Sharma",\n "license": "ISC",\n "dependencies": {},\n "devDependencies": {\n "@babel/core": "^7.10.4",\n "@babel/preset-env": "^7.11.0",\n "babel-loader": "^8.1.0",\n "webpack": "^4.44.1",\n "webpack-cli": "^3.3.12",\n }\n}In package.json the main property is a direction to the entry point of the module that the package.json is describing.
Run $npm run build to generate the bundled code and use it in the next step.
index.html
<!DOCTYPE html>\n<html lang="en">\n <head>\n <meta charset="UTF-8" />\n <meta name="viewport" content="width=device-width, initial-scale=1.0" />\n <title>Demo</title>\n </head>\n <body>\n <script src="dist/index_bundle.js"></script>\n <script>\n console.log($)\n alert($.capital("hridayesh"))\n $.addDOMContent("Well It Works Fine!!!")\n </script>\n </body>\n</html>Save it and run it in your browser. You will see the name capitalized.
\nThe complete code is available at LoginRadius Engineering Blog Sample Repo
\nThanks for reading the blog. For detailed information and execution example of this blog, please refer to the video below:
\n\n","frontmatter":{"date":"August 18, 2020","updated_date":null,"title":"Let's Write a JavaScript Library in ES6 using Webpack and Babel","tags":["JavaScript","Webpack","NodeJs"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/b9b74a766ec8c0c06733b438fefae5ae/58556/cover.webp","srcSet":"/static/b9b74a766ec8c0c06733b438fefae5ae/61e93/cover.webp 200w,\n/static/b9b74a766ec8c0c06733b438fefae5ae/1f5c5/cover.webp 400w,\n/static/b9b74a766ec8c0c06733b438fefae5ae/58556/cover.webp 800w,\n/static/b9b74a766ec8c0c06733b438fefae5ae/cc834/cover.webp 1024w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Hridayesh Sharma","github":"vyasriday","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/a-journey-from-node-to-golang/"},"html":"Migrating your existing code to a new programming language is a very tedious task. We need to have a proper set of requirements and some obvious benchmarking between the new and existing technology.
\nSo here our journey started to transform (not convert) our existing code to a new language. You might be thinking why I have used the word transformation instead of conversion, so -
\nConversion: Conversion is just about writing your existing code in different languages as it is.
\nTransformation: Transformation is about leveraging all possible benefits of a new language and convert accordingly.
\nThe idea of migrating code to a new programming language started with a simple requirement: we wanted to take our cloud solution to on-premise as well. Till now, our services were written in NodeJS for a cloud solution and it was doing pretty well. The performance was also good but there is nothing that cannot be improved upon. So, along with performance improvement, we started to find out that can we make a GUI or CLI using existing NodeJS code that can take our solution on-premise?
\nAnswer for that was practically YES. but, technically NO. If we’re writing apps with a GUI, Node can’t do it on its own. We had to use some other projects which provide GUI creation capabilities (eg: ElectronJS, NW.js, etc). Making CLI seemed doable but there were also problems like the inablility to have single file distribution for our code. And the ability to download a single file and execute commands - without an installer, or even a setup process - does wonders for a user. This also makes the product easily backward-compatible.
\nAlso, another factor came in that it was better to switch to a technology that works closely with gRPC.
\nSo, we drew out a few goals for our new solution
\nAfter research with our requirement, we were able to figure out that we can achieve these with GoLang, developed by Google.\nOn the basis of our research, we also did some benchmarking on different node js frameworks and GoLang.
\nBenchmarking sever we’ve used with below configurations
\n![\"server\"](\"/a9b12b02c985072861152d1de65032b9/server.webp\")
The benchmarking result was pretty much similor to what we are thinking. Here are the benchmarking results -
\n![\"sheet1\"](\"/bc71c0c2ed131f0b4ba9ac1fe9bdb155/sheet1.webp\")
![\"sheet2\"](\"/0d6023167db0ad99d3fe1d8dfb1f1870/sheet2.webp\")
There was a big difference. For better clarity let’s see the below graphs.
\nIn the below chart, we can clearly see that Golang won the competition and Hapi has taken the maximum time to finish the test.
\n![\"total-time-taken-for-test\"](\"/13b747de9eb5e9d9ed52d041de7a483a/total-time-taken-for-test.webp\")
In the below chart, we can see that Golang served maximum requests per second.
\n![\"request-per-second-and-transfer-rate-kb-s\"](\"/4129f7fdfaf409d18266224a68e8d07e/request-per-second-and-transfer-rate-kb-s.webp\")
The below chart is showing that the Number of requests is very high compared to other node js frameworks.
\n![\"request-per-second-and-time-per-request\"](\"/9dd0dd6c131fe4efbd1b3fd543283d81/request-per-second-and-time-per-request.webp\")
![\"chart\"](\"/844246f974c34aef12770c0a7458a864/chart.webp\")
All the data clearly shows the direction so we decided to move to GoLang.
\n","frontmatter":{"date":"August 11, 2020","updated_date":null,"title":"A journey from Node to GoLang","tags":["NodeJs","Golang","Performance"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/7495b241d8dd853cf8580344cc9332f2/ad85c/node-go.webp","srcSet":"/static/7495b241d8dd853cf8580344cc9332f2/61e93/node-go.webp 200w,\n/static/7495b241d8dd853cf8580344cc9332f2/1f5c5/node-go.webp 400w,\n/static/7495b241d8dd853cf8580344cc9332f2/ad85c/node-go.webp 600w","sizes":"(max-width: 600px) 100vw, 600px"}}},"author":{"id":"Narendra Pareek","github":"pareek-narendra","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/password-hashing-with-nodejs/"},"html":"In this blog, we’ll be implementing authentication with password hashing in a Node.js web application. For this, we’ll be using crypto, a package password hashing for Node.js.
\nThe Crypto module for Node JS helps developers to hash user passwords.
\nPre-requisites:
\nStep 1. First, create a directory structure as below :
\nhashApp
--model\n----user.js\n--route\n----user.js\n--server.jsStep 2. Create model/user.js file and add the following code :
\n// Importing modules \nconst mongoose = require('mongoose'); \nvar crypto = require('crypto'); \n \n// Creating user schema \nconst UserSchema = mongoose.Schema({ \n name : { \n type : String, \n required : true\n }, \n email : { \n type : String, \n required : true\n }, \n hash : String, \n salt : String \n}); \n \n// Method to set salt and hash the password for a user \nUserSchema.methods.setPassword = function(password) { \n \n // Creating a unique salt for a particular user \n this.salt = crypto.randomBytes(16).toString('hex'); \n \n // Hashing user's salt and password with 1000 iterations, \n \n this.hash = crypto.pbkdf2Sync(password, this.salt, \n 1000, 64, `sha512`).toString(`hex`); \n}; \n \n// Method to check the entered password is correct or not \nUserSchema.methods.validPassword = function(password) { \n var hash = crypto.pbkdf2Sync(password, \n this.salt, 1000, 64, `sha512`).toString(`hex`); \n return this.hash === hash; \n}; \n \n// Exporting module to allow it to be imported in other files \nconst User = module.exports = mongoose.model('User', UserSchema); Step 3. Create route/user.js file and add the following code:
\n// Importing modules \nconst express = require('express'); \nconst router = express.Router(); \n\n// Importing User Schema \nconst User = require('../model/user'); \n\n// User login api \nrouter.post('/login', (req, res) => { \n\n // Find user with requested email \n User.findOne({ email : req.body.email }, function(err, user) { \n if (user === null) { \n return res.status(400).send({ \n message : "User not found."\n }); \n } \n else { \n if (user.validPassword(req.body.password)) { \n return res.status(201).send({ \n message : "User Logged In", \n }) \n } \n else { \n return res.status(400).send({ \n message : "Wrong Password"\n }); \n } \n } \n }); \n}); \n\n// User signup api \nrouter.post('/signup', (req, res, next) => { \n\n\n// Creating empty user object \n let newUser = new User(); \n\n // Initialize newUser object with request data \n newUser.name = req.body.name, \n\n newUser.email = req.body.email,\n\n\n newUser.password=req.body.password\n\n // Call setPassword function to hash password \n newUser.setPassword(req.body.password); \n\n // Save newUser object to database \n newUser.save((err, User) => { \n if (err) { \n return res.status(400).send({ \n message : "Failed to add user."\n }); \n } \n else { \n return res.status(201).send({ \n message : "User added successfully."\n }); \n } \n }); \n}); \n// Export module to allow it to be imported in other files \nmodule.exports = router; Step 4. Create server.js file :
\n// Importing modules\nvar express = require('express');\nvar mongoose = require('mongoose');\nvar bodyparser = require('body-parser');\n \n// Initialize express app\nvar app = express();\n \n// Mongodb connection url\nvar MONGODB_URI = "mongodb://localhost:27017/hashAppDb";\n \n// Connect to MongoDB\nmongoose.connect(MONGODB_URI);\nmongoose.connection.on('connected', () => {\n console.log('Connected to MongoDB @ 27017');\n});\n \n// Using bodyparser to parse json data\napp.use(bodyparser.json());\n \n// Importing routes\nconst user = require('./route/user');\n \n// Use user route when url matches /api/user/\napp.use('/api/user', user);\n \n// Creating server\nconst port = 3000;\napp.listen(port, () => {\n console.log("Server ru\nnning at port: " + port);\n});Step 5. Run server.js file using command
\nnode server.jsStep 6. Open Postman and create a post request to localhost:3000/api/user/signup with following body parameter:
\n{\n"name" : "test".\n"email" : "test@test.com",\n"password" : "test1234"\n}Run the request and you will get a success response:
\n{\n"message" : "user added sucessfully"\n}User data is stored in the database as below:
\n "_id": {\n "$oid": "5ab71ef2afb6db0148052f6f"\n },\n "name": "test",\n "email": "test@test.com",\n "salt": "ddee18ef6a6804fbb919b25f790005e3",\n "hash": "bbf13ae4db87d475ca0ee5f97e397248a23509fc10c82f1e3cf110\n b352c3ca6cc057955ace9d541573929cd7a74a280a02e8cb549136b43df7704caaa555b38a",\n "__v": 0\n}If we have sensitive data or information that you need to be protected, ensuring it is secured correctly is important. With the above process, we can now successfully store our hashed password into our database with a bit of additional security.
\nYou can check the code on Github.
\n","frontmatter":{"date":"June 25, 2020","updated_date":null,"title":"Password hashing with NodeJS","tags":["Security","NodeJs"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.4598540145985401,"src":"/static/7c5686f355f37377e26ec91cbaa6cbed/58556/cover.webp","srcSet":"/static/7c5686f355f37377e26ec91cbaa6cbed/61e93/cover.webp 200w,\n/static/7c5686f355f37377e26ec91cbaa6cbed/1f5c5/cover.webp 400w,\n/static/7c5686f355f37377e26ec91cbaa6cbed/58556/cover.webp 800w,\n/static/7c5686f355f37377e26ec91cbaa6cbed/99238/cover.webp 1200w,\n/static/7c5686f355f37377e26ec91cbaa6cbed/ba24a/cover.webp 1440w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Ashish Sharma","github":"ashish8947","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/linkedin-login-using-node-passport/"},"html":"This blog article will guide you to add \"log in with LinkedIn\"\nfunctionality in your application. Here we will be implementing Linkedin Login using NodeJS and Passport.
\nPassport is an authentication middleware for Node, which authenticates requests and delegates all other functionality to the application. Considering the unique application requirements, Passport has stuck to authentication mechanisms known as strategies. In the blog, we will be implementing a similar strategy for Login with Linkedin.
\nAPP_ID and APP_SECRETcreate app link and add the required details to create an app![\"Create](\"/75132ca3ed5b7cd02270d0e280055008/create-app.webp\" "\\"Create")
Provide basic details about your app:
\nApp logo
\nauth tab in the navigation bar as shown below. You can now copy your secret and ID from here ![\"App](\"/a78c4aa6cfc27a4af94c9233d52f3538/app-credentials.webp\" "\\"App")
Now enough, let's move to code, First of all, create a directory named Linkedin-node-authentication
mkdir Linkedin-node-authenticationLinkedin-node-authentication/ cd Linkedin-node-authenticationpackage.json and copy the following code The dependencies, we are going to use in the projects are
\nexpress : Node web frameworkexpress-session Session managment of expresspassport Authentication middleware for Node.js passport-linkedin-oauth2 A simple passport strategy for LinkedIn OAuth2 passport linkedin oauth2ejs - Templating engine{\n "name": "linkedin-login-node",\n "version": "1.0.0",\n "description": "Basic application for setting up Linkedin login using node and passport",\n "main": "index.js",\n "scripts": {\n "test": "echo \\"Error: no test specified\\" && exit 1",\n "start": "node server.js"\n },\n "author": "LoginRadius",\n "license": "ISC",\n "dependencies": {\n "ejs": "^3.1.2",\n "express": "^4.17.1",\n "express-session": "^1.17.1",\n "passport": "^0.4.1",\n "passport-linkedin-oauth2": "^2.0.0"\n }\n}After this run the following command in the terminal
\nnpm installserver.js and paste the following code const express = require('express');\nconst app = express();\nconst session = require('express-session');\nconst passport = require('passport');\nconst LinkedInStrategy = require('passport-linkedin-oauth2').Strategy;\nconst routes = require('./routes.js');\nconst config = require('./config')\n\napp.set('view engine', 'ejs');\n\napp.use(session({\n resave: false,\n saveUninitialized: true,\n secret: 'SECRET'\n}));\n\napp.use(passport.initialize());\napp.use(passport.session());\n\npassport.serializeUser(function (user, cb) {\n cb(null, user);\n});\n\npassport.deserializeUser(function (obj, cb) {\n cb(null, obj);\n});\n\npassport.use(new LinkedInStrategy({\n clientID: config.linkedinAuth.clientID,\n clientSecret: config.linkedinAuth.clientSecret,\n callbackURL: config.linkedinAuth.callbackURL,\n scope: ['r_emailaddress', 'r_liteprofile'],\n}, function (token, tokenSecret, profile, done) {\n return done(null, profile);\n}\n));\n\napp.use('/', routes);\n\nconst port = 3000;\n\napp.listen(port, () => {\n console.log('App listening on port ' + port);\n});routes.js in the root directory and paste the following code const passport = require('passport');\nconst express = require('express');\nvar router = express.Router();\n\nrouter.get('/', function (req, res) {\n res.render('pages/index.ejs'); // load the index.ejs file\n});\n\nrouter.get('/profile', isLoggedIn, function (req, res) {\n res.render('pages/profile.ejs', {\n user: req.user // get the user out of session and pass to template\n });\n});\n\nrouter.get('/auth/linkedin', passport.authenticate('linkedin', {\n scope: ['r_emailaddress', 'r_liteprofile'],\n}));\n\nrouter.get('/auth/linkedin/callback',\n passport.authenticate('linkedin', {\n successRedirect: '/profile',\n failureRedirect: '/login'\n }));\n\nrouter.get('/logout', function (req, res) {\n req.logout();\n res.redirect('/');\n});\n\n\nfunction isLoggedIn(req, res, next) {\n if (req.isAuthenticated())\n return next();\n res.redirect('/');\n}\n\nmodule.exports = router;views and under this create a directory named pages. Under this folder create two pages named profile.ejs and index.ejs// index.ejs\n<!doctype html>\n<html>\n\n<head>\n <title>Linkedin Node Authentication</title>\n <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">\n <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">\n <link rel="stylesheet" type="text/css"\n href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.5/css/materialize.min.css">\n <style>\n .linkedin {\n background-color: #0073b1 !important;\n color: #fff !important;\n }\n .fa-linkedin-f:before,\n .fa-linkedin:before {\n content: "\\f0e1";\n }\n </style>\n</head>\n\n<body>\n <nav class="light-blue lighten-1" role="navigation">\n <div class="nav-wrapper container">\n <a id="logo-container" href="#" class="brand-logo">Node Authentication</a>\n </div>\n </nav>\n <div class="section no-pad-bot" id="index-banner">\n <div class="container">\n <br><br>\n <div class="row center">\n <div class="col s6 offset-s3">\n <div class="card">\n <div class="card-content">\n <span class="card-title">Linkedin Login using Node and passport</span>\n </div>\n <div class="card-action">\n <a href="/auth/linkedin" class="waves-effect waves-light btn social linkedin">\n <i class="fa fa-linkedin"></i> Sign in with Linkedin\n </a>\n </div>\n </div>\n </div>\n </div>\n </div>\n </div>\n</body>\n\n</html><!- profile.ejs->\n<!doctype html>\n<html>\n\n<head> \n <title>LinkedIn Node Authentication</title>\n <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">\n <link rel="stylesheet" type="text/css"\n href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.5/css/materialize.min.css">\n <style>\n .card:hover {\n box-shadow: 0 10px 20px rgba(0, 0, 0, 0.19), 0 6px 6px rgba(0, 0, 0, 0.23);\n margin-bottom: 54px;\n }\n </style>\n</head>\n\n<body>\n <nav class="light-blue lighten-1" role="navigation">\n <div class="nav-wrapper container">\n <a id="logo-container" href="#" class="brand-logo">Node Authentication</a>\n <a href="/logout" class="right">Logout</a>\n </div>\n </nav>\n <div class="section no-pad-bot" id="index-banner">\n <div class="container">\n <br><br>\n <div class="row center">\n <div class="col s12">\n <div class="card">\n <div class="card-content blue lighten-3">\n <span class="card-title white-text"><strong><i class="large material-icons">person</i>\n </strong></span>\n </div>\n <div class="card-action">\n <h5><b><%= user.displayName %></b></h5>\n <p><strong>Linkedin id</strong>: <%= user.id %></p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </div>\n</body>\n\n</html>config.js file created in the root directory module.exports = {\n 'linkedinAuth': {\n 'clientID': '<CLIENT_ID>', // your App ID\n 'clientSecret': '<CLIENT_SECRET>', // your App Secret\n 'callbackURL': 'http://127.0.0.1:3000/auth/linkedin/callback'\n }\n}// Final directory structure\nLinkedin-node-authentication/\n --|node_modules\n --|views/\n |--|pages/\n |----|error.ejs\n |----|profile.ejs\n |----|index.ejs\n --|config.js\n --|package.json\n --|package-lock.json\n --|routes.js\n --|server.jsLinkedin-node-authentication/npm starthttp://localhost:3000 ![\"Linkedin](\"/bfd29e4b03283c3a5cfe67a43e18f3f5/linkedin-login-page.webp\" "\\"Linkedin")
Click on the sign in button, and you will be asked to login through Linkedin. Once logged in you will be redirected to profile page as below:
\n ![\"Linkedin](\"/2c95500cf554892bb994a1e8d7cc90f8/linkedin-profile-page.webp\" "\\"Linkedin")
The complete sample code for the above tutorial can be found here
\n","frontmatter":{"date":"June 10, 2020","updated_date":null,"title":"LinkedIn Login using Node JS and passport","tags":["LinkedIn","Login","NodeJs","PassportJS"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/717d9ce34aacf1736c240b0fa8d67551/58556/linkedin_login_node.webp","srcSet":"/static/717d9ce34aacf1736c240b0fa8d67551/61e93/linkedin_login_node.webp 200w,\n/static/717d9ce34aacf1736c240b0fa8d67551/1f5c5/linkedin_login_node.webp 400w,\n/static/717d9ce34aacf1736c240b0fa8d67551/58556/linkedin_login_node.webp 800w,\n/static/717d9ce34aacf1736c240b0fa8d67551/99238/linkedin_login_node.webp 1200w,\n/static/717d9ce34aacf1736c240b0fa8d67551/135cd/linkedin_login_node.webp 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Aman Agrawal","github":"aman-agrwl","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/hello-world-deno/"},"html":"Deno is a new platform for writing applications using JavaScript and TypeScript. It is based on the V8 JavaScript engine and the Rust.
\nDeno’s lowest level binding layer to the system is tied to promises (called ops). Deno is secure by default, provides first-class TypeScript support, has built-in utilities like a dependency inspector, and supports third-party modules such as lodash .
\nBtw, this is the best damn geeky one-liner code to explain what is Deno. Totally cool.
\n![\"alt_text\"](\"/3dccb354c5a6bfd002b925289a8fb026/twitter.webp\" "\\"Twitter\\"")
Deno works on macOS, Linux, and Windows. Deno is a single binary executable and it has no external dependencies.
\nSee all installation.
\nLaunch Windows PowerShell and run the following command to install Deno on Windows 10/8/7
\niwr https://deno.land/x/install/install.ps1 -useb | iexLaunch terminal and run the following command to install Deno on Linux and Mac
\ncurl -fsSL https://deno.land/x/install/install.sh | shOpen a new terminal and run deno. You should get a > prompt. Type exit.
After installing deno on your system we just need to create a simple Hello World program by using the following steps :
\nStep 1. Create a Folder as per your project name by using command prompt
\nmkdir HelloWorldDenoStep 2. Create a typeScript file and name it index.ts.
\nStep 3. Add the following code in index.ts.
\nconst helloWorld = (name: string = "world") => {\n console.log(`Hello ${name}!!`);\n}\n\nhelloWorld();\n\nhelloWorld("Friend");Step 4. Run the following project by using the following command
\ndeno run index.tsYou can check the result here
\n![\"alt_text\"](\"/c9187b83647bac95a00b0dc259f75826/cmd.webp\" "\\"Result\\"")
Yupppp it works this is your first Deno program !!
\n","frontmatter":{"date":"June 02, 2020","updated_date":null,"title":"Hello world with Deno","tags":["Deno","HelloWorld","NodeJs"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/70351d960fd94ea6641dc19419a97bbc/58556/deno.webp","srcSet":"/static/70351d960fd94ea6641dc19419a97bbc/61e93/deno.webp 200w,\n/static/70351d960fd94ea6641dc19419a97bbc/1f5c5/deno.webp 400w,\n/static/70351d960fd94ea6641dc19419a97bbc/58556/deno.webp 800w,\n/static/70351d960fd94ea6641dc19419a97bbc/99238/deno.webp 1200w,\n/static/70351d960fd94ea6641dc19419a97bbc/135cd/deno.webp 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Ashish Sharma","github":"ashish8947","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/facebook-authentication-using-node-and-passport/"},"html":"Social login is the need for simplifying your registration process and increasing the conversion rates. Here we will be implementing Facebook Login using NodeJS and Passport.
\nPassport is authentication middleware for Node, which authenticates requests and delegates all other functionality to the application. Considering the unique application requirements, passport has stuck to authentication mechanisms known as strategies. In the blog, we will be implementing a similar strategy for Login with Facebook.
\nAPP_ID and APP_SECRETcreate app link and you will need to enter the details in the following pop-up![\"Create](\"/41ad5abd8263297d343e6408d2c90ebc/create-facebook-app.webp\" "\\"Create")
![\"Add](\"/4ca38e0f8bb5f195c3de332002ac5f63/add-product.webp\" "\\"Add")
http://localhost:3000 ![\"App](\"/a2c7d54fb8d728ccf59c4d5823234555/app-id-secret.webp\" "\\"App")
Now enough, let's move to code, First of all, create a directory named facebook-node-authentication
mkdir facebook-node-authenticationfacebook-node-authentication/ cd facebook-node-authenticationpackage.json and copy the following code The dependencies, we are going to use in the projects are
\nexpress : Node web frameworkexpress-session Session managment of expresspassport Authentication middleware for NodeJS passport-facebook Facebook Plugin for passportejs - Templating engine{\n "name": "facebook_login_node",\n "version": "1.0.0",\n "description": "\\"Basic application for setting up Facebook logij using node and passport\\"",\n "main": "index.js",\n "scripts": {\n "test": "echo \\"Error: no test specified\\" && exit 1",\n "start": "node server.js"\n },\n "author": "",\n "license": "ISC",\n "dependencies": {\n "ejs": "^3.1.2",\n "express": "^4.17.1",\n "express-session": "^1.17.1",\n "passport": "^0.4.1",\n "passport-facebook": "^3.0.0"\n }\n}After this run the following command in the terminal
\nnpm installserver.js and paste the following code const express = require('express');\nconst app = express();\nconst session = require('express-session');\nconst passport = require('passport');\nconst FacebookStrategy = require('passport-facebook').Strategy;\nconst routes = require('./routes.js');\nconst config = require('./config')\n\napp.set('view engine', 'ejs');\n\napp.use(session({\n resave: false,\n saveUninitialized: true,\n secret: 'SECRET'\n}));\n\napp.use(passport.initialize());\napp.use(passport.session());\n\npassport.serializeUser(function (user, cb) {\n cb(null, user);\n});\n\npassport.deserializeUser(function (obj, cb) {\n cb(null, obj);\n});\n\npassport.use(new FacebookStrategy({\n clientID: config.facebookAuth.clientID,\n clientSecret: config.facebookAuth.clientSecret,\n callbackURL: config.facebookAuth.callbackURL\n }, function (accessToken, refreshToken, profile, done) {\n return done(null, profile);\n }\n));\n\napp.use('/', routes);\n\nconst port = 3000;\n\napp.listen(port, () => {\n console.log('App listening on port ' + port);\n});route.js in the root directory and paste the following code const passport = require('passport');\nconst express = require('express');\nvar router = express.Router();\n\nrouter.get('/', function (req, res) {\n res.render('pages/index.ejs'); // load the index.ejs file\n});\n\nrouter.get('/profile', isLoggedIn, function (req, res) {\n res.render('pages/profile.ejs', {\n user: req.user // get the user out of session and pass to template\n });\n});\n\nrouter.get('/error', isLoggedIn, function (req, res) {\n res.render('pages/error.ejs');\n});\n\nrouter.get('/auth/facebook', passport.authenticate('facebook', {\n scope: ['public_profile', 'email']\n}));\n\nrouter.get('/auth/facebook/callback',\n passport.authenticate('facebook', {\n successRedirect: '/profile',\n failureRedirect: '/error'\n }));\n\nrouter.get('/logout', function (req, res) {\n req.logout();\n res.redirect('/');\n});\n\nfunction isLoggedIn(req, res, next) {\n if (req.isAuthenticated())\n return next();\n res.redirect('/');\n}\n\nmodule.exports = router;views and under this create a directory named pages. Under this folder create two pages named profile.ejs and index.ejs// index.ejs\n<!doctype html>\n<html>\n\n<head>\n <title>Facebook Node Authentication</title>\n <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">\n <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">\n <link rel="stylesheet" type="text/css"\n href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.5/css/materialize.min.css">\n <style>\n .facebook {\n background-color: #3b5998 !important;\n color: #fff !important;\n }\n .fa-facebook-f:before,\n .fa-facebook:before {\n content: "\\f09a";\n }\n </style>\n</head>\n\n<body>\n <nav class="light-blue lighten-1" role="navigation">\n <div class="nav-wrapper container">\n <a id="logo-container" href="#" class="brand-logo">Node Authentication</a>\n </div>\n </nav>\n <div class="section no-pad-bot" id="index-banner">\n <div class="container">\n <br><br>\n <div class="row center">\n <div class="col s6 offset-s3">\n <div class="card">\n <div class="card-content">\n <span class="card-title">Facebook Login using Node and passport</span>\n </div>\n <div class="card-action">\n <a href="/auth/facebook" class="waves-effect waves-light btn social facebook">\n <i class="fa fa-facebook"></i> Sign in with facebook\n </a>\n </div>\n </div>\n </div>\n </div>\n </div>\n </div>\n</body>\n\n</html><!- profile.ejs->\n<!doctype html>\n<html>\n\n<head> \n <title>Facebook Node Authentication</title>\n <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">\n <link rel="stylesheet" type="text/css"\n href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.5/css/materialize.min.css">\n <style>\n .card:hover {\n box-shadow: 0 10px 20px rgba(0, 0, 0, 0.19), 0 6px 6px rgba(0, 0, 0, 0.23);\n margin-bottom: 54px;\n }\n </style>\n</head>\n\n<body>\n <nav class="light-blue lighten-1" role="navigation">\n <div class="nav-wrapper container">\n <a id="logo-container" href="#" class="brand-logo">Node Authentication</a>\n <a href="/logout" class="right">Logout</a>\n </div>\n </nav>\n <div class="section no-pad-bot" id="index-banner">\n <div class="container">\n <br><br>\n <div class="row center">\n <div class="col s12">\n <div class="card">\n <div class="card-content blue lighten-3">\n <span class="card-title white-text"><strong><i class="large material-icons">person</i>\n </strong></span>\n </div>\n <div class="card-action">\n <h5><b><%= user.displayName %></b></h5>\n <p><strong>Facebook id</strong>: <%= user.id %></p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </div>\n</body>\n\n</html>config.js file created in the root directorymodule.exports = {\n\t'facebookAuth': {\n\t\t'clientID': '<APP_ID>', // your App ID\n\t\t'clientSecret': '<APP_SECRET>', // your App Secret\n\t\t'callbackURL': 'http://localhost:3000/auth/facebook/callback'\n\t}\n}// Final directory structure\nfacebook-node-authentication/\n --|node_modules\n --|views/\n |--|pages/\n |----|error.ejs\n |----|profile.ejs\n |----|index.ejs\n --|config.js\n --|package.json\n --|package-lock.json\n --|routes.js\n --|server.jsfacebook-node-authentication/npm starthttp://localhost:3000 ![\"Facebook](\"/d141c6d362dba8db785c2ac77ed5e09d/facebook-login-home-page.webp\" "\\"Facebook")
![\"Facebook](\"/213fc3c7c63044e2a4e1b21859ea828a/Profile-page-facebook-login.webp\" "\\"Facebook")
You can found the complete code used in this tutorial on our Github Repo
\n","frontmatter":{"date":"June 01, 2020","updated_date":null,"title":"Facebook authentication using NodeJS and PassportJS","tags":["Facebook","NodeJs","Authentication","PassportJS"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/adba71048e93f4d775b486dff18c1ca8/58556/facebook_node_passport.webp","srcSet":"/static/adba71048e93f4d775b486dff18c1ca8/61e93/facebook_node_passport.webp 200w,\n/static/adba71048e93f4d775b486dff18c1ca8/1f5c5/facebook_node_passport.webp 400w,\n/static/adba71048e93f4d775b486dff18c1ca8/58556/facebook_node_passport.webp 800w,\n/static/adba71048e93f4d775b486dff18c1ca8/99238/facebook_node_passport.webp 1200w,\n/static/adba71048e93f4d775b486dff18c1ca8/135cd/facebook_node_passport.webp 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Aman Agrawal","github":"aman-agrwl","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/oauth-implemenation-using-node/"},"html":"In this blog, we’ll be implementing OAuth by Github in a Node.js Application
\nThis tutorial assumes you have:
\nTo implement Github Auth we need to register a new application in Github OAuth Apps.
\nOnce you start the process you will get a form like this.
\n![\"Github](\"/70fc6824dc4df23803ee7172457b4ce8/git_new_app.webp\" "\\"Github")
You need to fill all the required details and put the Authorization callback URL as http://localhost:2400/github/callback (This will be the URL on which Github will send the authorization code once authorization is finished)
Once you register the application you will get the App's Client Id and Secret which we will use in our code.
\n![\"Github](\"/a3d3f92a563b5f7c94fed2e39892c54f/github_cred.webp\" "\\"Github")
First in an empty folder run the below command
\nnpm initIt essentially just creates the package.json file with all the basic information you will provide. after that, we will install all the dependencies needed in our project
\nnpm install express ejs axios --saveCreate a file index.js in the root folder of your app and add the following code:
\n// index.js\n\n/* EXPRESS */\nconst express = require('express');\nconst app = express();\n\napp.set('view engine', 'ejs');\nvar access_token = "";\n\napp.get('/', function(req, res) {\n res.render('pages/index',{client_id: clientID});\n});\n\nconst port = process.env.PORT || 2400;\napp.listen(port , () => console.log('App listening on port ' + port));Our web server has been set up, now we will add the code related to sending the OAuth request to GitHub using Axios package, at the bottom of the index.js file:
\n// index.js\n\n// Import the axios library, to make HTTP requests\nconst axios = require('axios')\n// This is the client ID and client secret that you obtained\n// while registering on github app\nconst clientID = 'xxxxxxxxxxxx'\nconst clientSecret = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxx'\n\n// Declare the callback route\napp.get('/github/callback', (req, res) => {\n\n // The req.query object has the query params that were sent to this route.\n const requestToken = req.query.code\n \n axios({\n method: 'post',\n url: `https://github.com/login/oauth/access_token?client_id=${clientID}&client_secret=${clientSecret}&code=${requestToken}`,\n // Set the content type header, so that we get the response in JSON\n headers: {\n accept: 'application/json'\n }\n }).then((response) => {\n access_token = response.data.access_token\n res.redirect('/success');\n })\n})\n\napp.get('/success', function(req, res) {\n\n axios({\n method: 'get',\n url: `https://api.github.com/user`,\n headers: {\n Authorization: 'token ' + access_token\n }\n }).then((response) => {\n res.render('pages/success',{ userData: response.data });\n })\n});Note: The callback URL should be the same as used in the GitHub app configuration.
\nCreate an ejs file under path views/pages/index.js, it will render into a nice looking Github authorization page:
\n<!-- views/index.ejs -->\n<!doctype html>\n<html>\n<head>\n <title>Github OAuth</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n <style>\n body { padding-top:70px; }\n </style>\n</head>\n<body>\n<div class="container">\n <div class="jumbotron text-center text-primary">\n <h1><span class="fa fa-github"></span> Github OAuth</h1>\n <p>Authorize your app with:</p>\n <a href="https://github.com/login/oauth/authorize?client_id=<%= client_id %>" class="btn btn-danger"><span class="fa fa-github"></span> Github Login</a>\n </div>\n</div>\n</body>\n</html> After it we will create an ejs file under path views/pages/success.js, it will be used to show the user's GitHub information we will get after authorized by Github
\n<!-- views/success.ejs -->\n<!doctype html>\n<html>\n <head>\n <title>Github OAuth</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n <style>\n body { padding-top:70px; }\n </style>\n </head>\n <body>\n <div class="container">\n <div class="jumbotron">\n <h1 class="text-primary text-center"><span class="fa fa-github"></span> Github Information</h1>\n <div class="row">\n <div class="col-sm-6">\n <div class="well">\n <p>\n <strong>Name</strong>: <%= userData.name %><br>\n <strong>Username</strong>: <%= userData.login %><br>\n <strong>Company</strong>: <%= userData.company %><br>\n <strong>Bio</strong>: <%= userData.bio %>\n </p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </body>\n</html>Note: Here we are also using bootstrap and font-awesome css to make our web pages look good.
\nWe have finished building our OAuth authorization page, let's run the application by below command
\nnode index.jsOnce our server is running, we can see our social login page on http://localhost:2400/
![\"Social](\"/30a8f53340a88b24e123fbc8abf19fa9/github_login.webp\" "\\"Social")
We need to click on the Github Login button, which will redirect us to google login page.
\n![\"GIthub](\"/c83c21014895d39200b6fdc8550b465e/github_auth.webp\" "\\"GIthub")
After login with our GitHub credentials, it will redirect back to our application and on the success page, we can see the details of users' GitHub profile and can save this detail in a database for future use also.
\n![\"GIthub](\"/0760ff4728fcbbe849cd12b027a7ab49/github_profile.webp\" "\\"Github")
You can implement the OAuth in Node.js by the above process, You can found the complete code used in this tutorial on out
\n\n","frontmatter":{"date":"March 22, 2020","updated_date":null,"title":"OAuth implementation with Node.js and Github","tags":["Oauth","NodeJs"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.9047619047619047,"src":"/static/bb5df84ab7808c0a554f33a2c8cb76c0/58556/oauth.webp","srcSet":"/static/bb5df84ab7808c0a554f33a2c8cb76c0/61e93/oauth.webp 200w,\n/static/bb5df84ab7808c0a554f33a2c8cb76c0/1f5c5/oauth.webp 400w,\n/static/bb5df84ab7808c0a554f33a2c8cb76c0/58556/oauth.webp 800w,\n/static/bb5df84ab7808c0a554f33a2c8cb76c0/99238/oauth.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/nodejs-and-mongodb-application-authentication-by-jwt/"},"html":"In this blog, we’ll be implementing authentication with JWT in a NodeJS web application. For this, we’ll be using jsonwebtoken package
\nJWT(JSON Web Token) is a token format. It is digitally-signed, self-contained, and compact. It provides a convenient mechanism for transferring data. JWT is not inherently secure, but the use of JWT can ensure the authenticity of the message so long as the signature is verified and the integrity of the payload can be guaranteed. JWT is often used for stateless authentication in simple use cases involving non-complex systems.
\nHere's an example of JWT:
\neyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsImNow, let's authenticate/protect some routes.
\nPre-requisites:
\nyou can install all required packages by using following command:
\nnpm install express mongoose bcrypt --saveStep 1. First, create a directory structure as below :
\nJWTApp
-api\n--models\n----userModel.js\n--controllers\n----userController.js\n--route\n----userRoute.js\n--server.js npm install jsonwebtoken -- saveIn the api/models folder, create a file called user userModel.js by running touch api/models/userModel.js.
\nIn this file, create a mongoose schema with the following properties:
\nAdd the following code
\n'use strict';\n\nvar mongoose = require('mongoose'),\n bcrypt = require('bcrypt'),\n Schema = mongoose.Schema;\n\n/**\n * User Schema\n */\nvar UserSchema = new Schema({\n fullName: {\n type: String,\n trim: true,\n required: true\n },\n email: {\n type: String,\n unique: true,\n lowercase: true,\n trim: true,\n required: true\n },\n hash_password: {\n type: String\n },\n created: {\n type: Date,\n default: Date.now\n }\n});\n\nUserSchema.methods.comparePassword = function(password) {\n return bcrypt.compareSync(password, this.hash_password);\n};\n\nmongoose.model('User', UserSchema);In the api/controllers folder, create a file called user userController.js by running touch api/controllers/userController.js
\nIn the userController file, create three different handlers to handle by using the following code
\n'use strict';\n\nvar mongoose = require('mongoose'),\n jwt = require('jsonwebtoken'),\n bcrypt = require('bcrypt'),\n User = mongoose.model('User');\n\nexports.register = function(req, res) {\n var newUser = new User(req.body);\n newUser.hash_password = bcrypt.hashSync(req.body.password, 10);\n newUser.save(function(err, user) {\n if (err) {\n return res.status(400).send({\n message: err\n });\n } else {\n user.hash_password = undefined;\n return res.json(user);\n }\n });\n};\n\nexports.sign_in = function(req, res) {\n User.findOne({\n email: req.body.email\n }, function(err, user) {\n if (err) throw err;\n if (!user || !user.comparePassword(req.body.password)) {\n return res.status(401).json({ message: 'Authentication failed. Invalid user or password.' });\n }\n return res.json({ token: jwt.sign({ email: user.email, fullName: user.fullName, _id: user._id }, 'RESTFULAPIs') });\n });\n};\n\nexports.loginRequired = function(req, res, next) {\n if (req.user) {\n next();\n } else {\n\n return res.status(401).json({ message: 'Unauthorized user!!' });\n }\n};\nexports.profile = function(req, res, next) {\n if (req.user) {\n res.send(req.user);\n next();\n } \n else {\n return res.status(401).json({ message: 'Invalid token' });\n }\n};Note: A hash password was saved in the database using bcrypt.
\nStep 6. In the api/route folder, create a file called user userRoute.js and add the following code:
\n'use strict';\nmodule.exports = function(app) {\n var userHandlers = require('../controllers/userController.js');\n // todoList Routes\n app.route('/tasks')\n .post(userHandlers.loginRequired, userHandlers.profile);\n app.route('/auth/register')\n .post(userHandlers.register);\n app.route('/auth/sign_in')\n .post(userHandlers.sign_in);\n};'use strict';\n\nvar express = require('express'),\n app = express(),\n port = process.env.PORT || 3000,\n\n\n User = require('./api/models/userModel'),\n bodyParser = require('body-parser'),\n jsonwebtoken = require("jsonwebtoken");\n\nconst mongoose = require('mongoose');\nconst option = {\n socketTimeoutMS: 30000,\n keepAlive: true,\n reconnectTries: 30000\n};\n\nconst mongoURI = process.env.MONGODB_URI;\nmongoose.connect('mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb', option).then(function(){\n //connected successfully\n}, function(err) {\n //err handle\n});\n\napp.use(bodyParser.urlencoded({ extended: true }));\napp.use(bodyParser.json());\n\napp.use(function(req, res, next) {\n if (req.headers && req.headers.authorization && req.headers.authorization.split(' ')[0] === 'JWT') {\n jsonwebtoken.verify(req.headers.authorization.split(' ')[1], 'RESTFULAPIs', function(err, decode) {\n if (err) req.user = undefined;\n req.user = decode;\n next();\n });\n } else {\n req.user = undefined;\n next();\n }\n});\nvar routes = require('./api/routes/userRoutes');\nroutes(app);\n\napp.use(function(req, res) {\n res.status(404).send({ url: req.originalUrl + ' not found' })\n});\n\napp.listen(port);\n\nconsole.log(' RESTful API server started on: ' + port);\n\nmodule.exports = app;Step 9. Now you just need to run the project by using the following command and try logging by using the JWT.
\nnpm startStep 10. Open Postman and create a post request to localhost:3000/auth/register as below:
\n![\"Postman](\"/a6eec58240d18cb17146ca11b5d49dcd/register.webp\")
Step 11. After this, let’s sign with this URL localhost:3000/auth/sign_in . Enter the keys and values for email and password
\n![\"Postman](\"/5cb1b965f14b8f3b4d254d7d310c789d/signIn.webp\")
Under the value, add JWT and the token with a space between, like so:
\nJWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsImZ1bGxOYW1lIjoiT2xhdHVuZGUgR2FydWJhIiwiX2lkIjoiNThmMjYzNDdiMTY1YzUxODM1NDMxYTNkIiwiaWF0IjoxNDkyMjgwMTk4fQ.VcMpybz08cB5PsrMSr25En4_EwCGWZVFgciO4M-3ENEStep 11. Then, enter the parameters for the key and value for fetching the profile. You want to create as shown below and send:
\n![\"Postman](\"/42b50f8f60ca459023e492ce1b802845/profile.webp\")
As we have seen it is fairly easy to build a JWT authentication system with NodeJS, You can found the complete code used in this tutorial here.
\n","frontmatter":{"date":"March 20, 2020","updated_date":null,"title":"NodeJS and MongoDB application authentication by JWT","tags":["NodeJs","JWT","MongoDB","Authentication","JSON Web Token"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.6666666666666667,"src":"/static/2b39d6f99b1ca5d4bc89d3bfccb6e29d/e9589/jwt.webp","srcSet":"/static/2b39d6f99b1ca5d4bc89d3bfccb6e29d/61e93/jwt.webp 200w,\n/static/2b39d6f99b1ca5d4bc89d3bfccb6e29d/1f5c5/jwt.webp 400w,\n/static/2b39d6f99b1ca5d4bc89d3bfccb6e29d/e9589/jwt.webp 500w","sizes":"(max-width: 500px) 100vw, 500px"}}},"author":{"id":"Ashish Sharma","github":"ashish8947","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/google-authentication-with-nodejs-and-passportjs/"},"html":"In this blog, we’ll be implementing OAuth in node js application via Google. For this, we’ll be using Passport.js, an authentication package for Node.js. Here’s a quick guide on implementing OAuth 2.0 in node js.
\nThis tutorial assumes you have:
\nWe can create a client ID and client secret using its Google API Console. You need to follow below steps once you open Google Auth API Console
\nhttp://localhost:3000/auth/google/callbackNote: If Google doesn't support http://localhost:3000, then use http://127.0.0.1:3000
To create OAuth nodejs authentication, first in an empty folder run the below command
\nnpm initIt essentially just creates the package.json file with all the basic information you will provide. after that, we will install all the dependencies needed in our project
\nnpm install express ejs express-session passport passport-google-oauth --saveCreate a file index.js in the root folder of your app and add the following code:
\n// index.js\n\n/* EXPRESS */\n\nconst express = require('express');\nconst app = express();\nconst session = require('express-session');\n\napp.set('view engine', 'ejs');\n\napp.use(session({\n resave: false,\n saveUninitialized: true,\n secret: 'SECRET' \n}));\n\napp.get('/', function(req, res) {\n res.render('pages/auth');\n});\n\nconst port = process.env.PORT || 3000;\napp.listen(port , () => console.log('App listening on port ' + port));Our web server has been set up, now we will add the code related to the passport at the bottom of the index.js file:
\n// index.js\n\n/* PASSPORT SETUP */\n\nconst passport = require('passport');\nvar userProfile;\n\napp.use(passport.initialize());\napp.use(passport.session());\n\napp.set('view engine', 'ejs');\n\napp.get('/success', (req, res) => res.send(userProfile));\napp.get('/error', (req, res) => res.send("error logging in"));\n\npassport.serializeUser(function(user, cb) {\n cb(null, user);\n});\n\npassport.deserializeUser(function(obj, cb) {\n cb(null, obj);\n});Now, at last, we are ready to implement Google Authentication in our app, Add the following code at the bottom of your index.js file, use your client Id and Secret instead of placeholders:
\n// index.js\n\n/* Google AUTH */\n \nconst GoogleStrategy = require('passport-google-oauth').OAuth2Strategy;\nconst GOOGLE_CLIENT_ID = 'our-google-client-id';\nconst GOOGLE_CLIENT_SECRET = 'our-google-client-secret';\npassport.use(new GoogleStrategy({\n clientID: GOOGLE_CLIENT_ID,\n clientSecret: GOOGLE_CLIENT_SECRET,\n callbackURL: "http://localhost:3000/auth/google/callback"\n },\n function(accessToken, refreshToken, profile, done) {\n userProfile=profile;\n return done(null, userProfile);\n }\n));\n \napp.get('/auth/google', \n passport.authenticate('google', { scope : ['profile', 'email'] }));\n \napp.get('/auth/google/callback', \n passport.authenticate('google', { failureRedirect: '/error' }),\n function(req, res) {\n // Successful authentication, redirect success.\n res.redirect('/success');\n });Note: The callback URL should be the same as used in the google app configuration.
\nCreate an ejs file under path views/pages/auth.js, it will render into a nice looking social login page:
\n<!-- views/pages/auth.ejs -->\n<!doctype html>\n<html>\n<head>\n <title>Google SignIn</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css">\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">\n <style>\n body { padding-top:70px; }\n </style>\n</head>\n<body>\n<div class="container">\n <div class="jumbotron text-center text-primary">\n <h1><span class="fa fa-lock"></span> Social Authentication</h1>\n <p>Login or Register with:</p>\n <a href="/auth/google" class="btn btn-danger"><span class="fa fa-google"></span> SignIn with Google</a>\n </div>\n</div>\n</body>\n</html> After it we wll create an ejs file under path views/pages/success.js, it will be used to show the user profile information we will get after authenticated by google
\n<!-- views/success.ejs -->\n<!doctype html>\n<html>\n <head>\n <title>Google SignIn</title>\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bootstrap css -->\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n <style>\n body { padding-top:70px; }\n </style>\n </head>\n <body>\n <div class="container">\n <div class="jumbotron">\n <h1 class="text-primary text-center"><span class="fa fa-user"></span> Profile Information</h1>\n <div class="row">\n <div class="col-sm-6">\n <div class="well">\n <p>\n <strong>Id</strong>: <%= user.id %><br>\n <strong>Email</strong>: <%= user.emails[0].value %><br>\n <strong>Name</strong>: <%= user.displayName %>\n </p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </body>\n</html> Note: Here we are also using bootstrap and font-awesome css to make our web pages look good.
\nWe have finished building our social login page, let's run the application by below command
\nnode index.jsOnce our server is running, we can see our social login page on http://localhost:3000/
![\"Social](\"/93be682112bc04e8f34b5d19a11257c4/social_login.webp\" "\\"Social")
We need to click on SignIn with Google button, which will redirect us to the google login page.
\n![\"Google](\"/6db1545bee5e34124e225af45e79bdbb/google_login.webp\" "\\"Google")
After login with our google credentials, it will redirect back to our application and on the success page, we can see the details of the logged-in user and can save this detail in a database for future use also.
\n![\"Social](\"/f1f8df6035ac3d150544a16b3d1d07a3/profileinfo_google.webp\" "\\"Social")
As we have seen it is fairly easy to build a google social authentication system with Node.js and Passport.js, You can found the complete code used in this tutorial on our Github Repo
\n","frontmatter":{"date":"February 12, 2020","updated_date":null,"title":"Google OAuth2 Authentication in NodeJS - A Guide to Implementing OAuth in Node.js","tags":["NodeJs","SocialLogin","Oauth"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.3071895424836601,"src":"/static/af2ca4c70d0c3c2c4c6726e14a1b25ad/e9589/google_cover.webp","srcSet":"/static/af2ca4c70d0c3c2c4c6726e14a1b25ad/61e93/google_cover.webp 200w,\n/static/af2ca4c70d0c3c2c4c6726e14a1b25ad/1f5c5/google_cover.webp 400w,\n/static/af2ca4c70d0c3c2c4c6726e14a1b25ad/e9589/google_cover.webp 500w","sizes":"(max-width: 500px) 100vw, 500px"}}},"author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/creating-a-google-hangout-bot-with-express-and-node-js/"},"html":"Time Required: 20 minutes.
\nTechnologies: Express, Node.js, JavaScript.
\nPrerequisites:
This tutorial will go over how to build a bot that will respond to pings (i.e. @
Create a new project with the file ‘app.js’.
\nOpen command line/terminal, and navigate to your project directory. Run ‘npm init’, and press enter until package.json is created. Next, install the following dependencies:
npm install express --savenpm install body-parser --savenpm install googleapis --savenpm install unirest --saveIn ‘app.js’, let’s setup our server:
\nconst express = require('express');\nconst bodyParser = require('body-parser');\nconst { google } = require('googleapis');\n\nconst app = express();\n\napp.use(bodyParser.urlencoded({\n extended: false\n}));\n\napp.use(bodyParser.json());\n\napp.listen(8100, function() {\n console.log('App listening on port 8100.');\n});Running ‘node app.js’ will now create a local server on port 8100.
\nThe bot will respond to pings through a HTTP POST endpoint. Create one with express:
\napp.post('/', function(req, res) {\n console.log('someone pinged @');\n\n if (req.body.type === 'MESSAGE') {\n return res.json({\n text: 'sleeping...'\n });\n }\n});The bot will respond with the text: ‘sleeping…’.
\nSynchronously responding to messages simply requires us to return a response to Google. The downside to this is the 30 second time limit before Google no longer accepts responses to the request. For instance, this would be a problem if you were building some kind of reminder app; the bot wouldn't be able to synchronously respond after 30 seconds. This is where async responses come in.
\nTo show this, we will have our bot post to a chat room every 1 minute.
\nSending async messages to Google API requires a Service Account for authentication. Once authenticated, we can make a POST request to a Google API URL that will create a message.
\nSo first, create a Google Service Account following these steps. Take the downloaded JSON file and put it in the root directory of your project. Here, we renamed it to googlekeys.json:
\nconst gkeys = require('./googlekeys.json');We will be making POST requests using Unirest:
\nconst unirest = require('unirest');Now generate a JWT that will be used in our POST request:
\nfunction getJWT() {\n return new Promise(function(resolve, reject) {\n let jwtClient = new google.auth.JWT(\n gkeys.client_email,\n null,\n gkeys.private_key, ['https://www.googleapis.com/auth/chat.bot']\n );\n\n jwtClient.authorize(function(err, tokens) {\n if (err) {\n console.log('Error create JWT hangoutchat');\n reject(err);\n } else {\n resolve(tokens.access_token);\n }\n });\n });\n}Here is our function for posting messages. ROOM-ID can be found in the URL of the hangout chat room page i.e.: https://chat.google.com/u/0/room/{ROOM-ID}
function postMessage(count) {\n return new Promise(function(resolve, reject) {\n getJWT().then(function(token) {\n unirest.post('https://chat.googleapis.com/v1/spaces/' + {ROOM-ID} + '/messages')\n .headers({\n "Content-Type": "application/json",\n "Authorization": "Bearer " + token\n })\n .send(JSON.stringify({\n 'text': 'Hello! This is message number ' + count,\n }))\n .end(function(res) {\n resolve();\n });\n }).catch(function(err) {\n reject(err);\n });\n });\n}Finally, add the code that will repeat our post every minute.
\nconst timer = require('timers');\n\napp.listen(8100, function() {\n console.log('App listening on port 8100.');\n\n let count = 0;\n timer.setInterval(function() {\n postMessage(count += 1);\n }, 60000);\n});Expose your local server to public (we used ngrok).
\nLogin to developer console. Create a new project, and enable Hangout Chat API. Under configuration, set:
\nRestart your local server, and that’s it! Make sure you have your bot added to the chat room, and you can ping it by sending @
There are a lot of different ways to further extend this bot, such as setting reminders/notifications, making to-do lists, displaying server logs, and interacting with API’s.
\n![](\"/8a9a029d9f5b2717f8798fde837c34e0/image2.webp\")
![](\"/b8ded5c577b86826fa436a130babfd07/image1.webp\")
![\"the](\"/4caf8328a2c92711c224c09a0b6c405f/the-guide-to-NPM.webp\")
What is This, and Why Should I Care?NPM is a package manager for javascript. It is used to share and distribute code amongst the coding community. There are over half a million packages for free developed and shared to help your JavaScript development.
\nTo discover packages click here
\nNPM can easily be installed by going to the node.js website. Just click on the link to download an executable file which will install the package manager for you.
\n(If you have brew on Mac or Chocolatey on Windows installed, it is even easier just run the command:
\n[code]brew install npm[/code]
\nOr
\n[code]choco install nodejs[/code]
\nHead over here to search for your package. Once you’ve found it, type in your console:
\n[code]npm install -g[/code]
\nSince NPM packages are open-source, be wary that some of the packages may not be built correctly. A good way to tell would be viewing the top of the page for any errors.
\n![](\"/0f0b906cfb24facfe56af23ea22ec3fd/image1.webp\")
To update the npm packages, simply run:
\n[code]npm update -g[/code]
\nThis will update all your outdated packages to the latest.
\nDetail: Emulates a web-server for client-side testing
\nDetail: Assists in setting up a REST APIs to test on your local server
\nDetail: Unit testing for web-development. Very useful in testing “code coverage” (It tells you where your code is not being tested in a nice HTML file)
\nDetail: For existing customers, simplifies calls to our server for easy customizability
\n