Rodney Vg

Rodney Vg

1572918757

NodeJS API Development with Express MongoDB and Mongoose

MongoDB is different from traditional, SQL databases like MySQL and PostgreSQL in that data is stored in binary JSON-like objects called BSON). This structure lends itself well to building Javascript applications that communicate with JSON. Additionally, MongoDB has flexible schema. This means there aren’t database migrations to worry about and data models can grow and change.

In this tutorial, we’re going to set up a Node.js server application, connect it to MongoDB and demonstrate how relationships work between MongoDB Collections. In the table below (provided by MongoDB) you’ll see how traditional aspects of SQL databases stack up against their MongoDB equivalents. You can find the whole source code for this tutorial in this GitHub repo.

This is image title

In SQL databases, we get database relationships using joins. For example, if we had a SQL database with two tables, books and authors, we could get all the books that belong to an author like so:

SELECT b.id AS ‘Post ID’, 
b.title AS ‘Book Title’, 
a.name AS ‘Author Name`, 
a.id AS ‘Author ID’
FROM books b
JOIN authors ON b.author_id = a.id
WHERE a.id = 1234;

This will grab information from both tables and display the results in a single dataset for us. Frameworks like Ruby On Rails and Laravel have abstracted this functionality for developers, making it possible to write PHP or Ruby to grab related information.

In Ruby On Rails, using Active Record finding, an author and related posts could look like:

authorWithBooks = Author.find 1234, :include => [:books]

In Laravel, using Eloquent, we could do:

$authorWithBooks = Author::find(1234)->books();

These results would give us the author with id 1234 and all the books that they’ve written. On the books table, we’d store an author_id, setting up the relationship between authors and books in the SQL world. MongoDB doesn’t use joins though, so how do we achieve this functionality?

There is a helper npm package for working with MongoDB called mongoose that we’re going to use for illustrative purposes in this tutorial. Mongoose is an ORM (stands for Object Relationship Mapper) that is a helper for MongoDB kind of like how ActiveRecord and Eloquent are helpers for working with relational data.

Create Database Models with Mongoosejs

The first thing to do is set up our models in Mongoose. These schemas are flexible but help us define what we want our data to look like.

For the author model, we define a model schema that can reference documents in another collection:

const mongoose = require('mongoose');
const authorModel = mongoose.Schema({
  name: { 
   type: String, 
   required: '{PATH} is required!'
  },
  bio: {
   type: String
  },
  website: {
   type: String
  },
  books: [
    { type: mongoose.Schema.Types.ObjectId, ref: 'Book' }
  ]
}, {
  timestamps: true
});
module.exports = mongoose.model('Author', authorModel);

In the above model, we define that in the authors MongoDB collection authors have name, bio, website and an array of books. Each element in the books array will reference the book id on the books collection. We’ll define that below. The second argument, saying timestamps = true will include “updated at” and “created at” fields when we create author records.

The Books schema models what our book data will look like. The schema has a reference to find the id of an associated author. In this example, I’m saying that a book is written by only one author, though in the real world that’s not always the case! Here’s what a belongs-to relationship could look like using Mongoose.js:

const mongoose = require('mongoose');
const bookModel = mongoose.Schema({
  title: { 
    type: String, 
    required: '{PATH} is required!'
  },
  subtitle: {
    type: String
  },
  author: { 
    type: mongoose.Schema.Types.ObjectId, 
    ref: 'Author' 
  }
}, {
  timestamps: true
});
module.exports = mongoose.model('Book', bookModel);

Instead of an array of authors, the book references one author id as the author of the book. We’re using timestamps again for the “updated at” and “created at fields”.

In the root models directory, I added an index to register the models:

module.exports = {
  'Author': require('./Author'),
  'Book': require('./Book'),
};

Register Routes to Return JSON From Express 4

Now that we have the authors and book models defined, it’s time to return and show the data via a JSON API. For that, I set up a controllers for Authors called AuthorsController and one for Books called BooksController. The controllers are responsible for handling the request after the router determines which route to use. Below, we’ll define a method for rendering a JSON response of all authors and the JSON of one author based on an id.

The authors controller looks like this:

const { Author } = require('../models');
const AuthorsController = {
  async index(req, res){
    const authors = await Author
       .find()
       .populate('books');
    res.send(authors);
  },
  async show(req, res){
    const author = await Author
       .findById(req.params.id)
       .populate(‘books’);
    res.send(author);
  }
};
module.exports = AuthorsController;

Here, I’m importing the author model, grabbing all of them and populating the query result with the related books. To use the async-await functionality with Express 4, I pulled in a package called express-async-errors and registered it in like so: require('express-async-errors');.

Following that Express 4 requires some server boilerplate setup:

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(cors());
app.use(methodOverride());
app.use(cookieParser());
app.use(express.static(__dirname + '/public'));
require('./server/routes')(app);

In the **server/routes.js** file, I register API routes for showing all the authors with their books and individual author with their books:

const express = require('express'),
  path = require('path'),
  rootPath = path.normalize(__dirname + '/../'),
  router = express.Router(),
  { AuthorsController, 
    BooksController } = require('./controllers');
module.exports = function(app){
  router.get('/authors', AuthorsController.index);
  router.get('/authors/:id', AuthorsController.show);
  app.use('/api', router);
};

Now we have a working API that returns authors with the books that they’ve written. The only problem is that there are no authors or books stored in MongoDB yet! To fix that, we’ll need to set up code to seed the database with records. If you visit /api/authors now all you’ll see is an empty array.

Seed Records Into MongoDB

We need to make sure that the Express 4 server connects properly to MongoDB. For that, we can connect via an URL and listen for successful connection events like so:

const mongoose = require('mongoose'),
  env = process.env.NODE_ENV = process.env.NODE_ENV || 'development',
  envConfig = require('../server/env')[env];
mongoose.Promise = require('bluebird');
mongoose.connect(envConfig.db, { useMongoClient: true, });
mongoose.connection.on('connected', function () {  
  console.log(`Database connection open to ${mongoose.connection.host} ${mongoose.connection.name}`);
});
mongoose.connection.on('error',function (err) {  
  console.log('Mongoose default connection error: ' + err);
});
mongoose.connection.on('disconnected', function () {  
  console.log('Mongoose default connection disconnected'); 
});

With the environment config file defined like so:

var path = require('path'),
  rootPath = path.normalize(__dirname + '/../../');
  
module.exports = {
  development: {
    rootPath: rootPath,
    db: 'mongodb://localhost/mongodb-relationships',
    port: process.env.PORT || 3000
  },
  production: {
    rootPath: rootPath,
    db: process.env.MONGOLAB_URI || 'you can add a mongolab uri here ($ heroku config | grep MONGOLAB_URI)',
    port: process.env.PORT || 80
  }
};

The seeder itself we’re going to run from the command line. It’s a bit verbose but goes through the process of creating and updating records in MongoDB with Mongoose.js.

require('./index');
const mongoose = require('mongoose');
const { Author, Book } = require('../server/models');
async function seedAuthors() {
  console.log('Seeding authors to ' + mongoose.connection.name + '...');
  const authors = [
    { name: 'JK Rowling', bio: 'J.K. Rowling is the author of the much-loved series of seven Harry Potter novels, originally published between 1997 and 2007.' },
    { name: 'Tony Robbins', bio: 'Tony Robbins is an entrepreneur, best-selling author, philanthropist and the nation\'s #1 Life and Business Strategist.' },
  ];
for (author of authors) {
    var newAuthor = new Author(author);
    await newAuthor.save();
  }
const a = await Author.find();
  console.log('authors: ', a);
}
async function seedBooks() {
  console.log('Seeding books to ' + mongoose.connection.name + '...');
const jkRowling = await Author.findOne({ name: 'JK Rowling' });
  const tonyRobbins = await Author.findOne({ name: 'Tony Robbins' });
let harryPotter = new Book({ title: 'Harry Potter', author: jkRowling._id });
  let awakenGiant = new Book({ title: 'Awaken the Giant Within', author: tonyRobbins._id });
await harryPotter.save();
  await awakenGiant.save();
jkRowling.books.push(harryPotter);
  tonyRobbins.books.push(awakenGiant);
await jkRowling.save();
  await tonyRobbins.save();
}
seedAuthors();
seedBooks();

This will create a new connection to the MongoDB database and then convert a normal array of JavaScript objects into data we can persistently access. The author will have an array of books with one book for each author in the array. To add more books, we can push to the books array and save the changes. Each book will have one author. MongoDB stores these relationships via the id. Using the populate method in our controller above, we’ll be able to view the entire object.

After running the seeder, you should be able to see your records in MongoDB Compass, as shown below. Compass is a GUI for viewing, creating, deleting, querying and editing MongoDB data.

This is image title

This is image title

Test The API

Now, to view this data from MongoDB via the API, start the Node server with npm run start and visit localhost:3000/api/authors in the web browser.

The final data will look something like:

[ 
   { 
      "_id":"5d51ea23acaf6f3380bcab56",
      "updatedAt":"2019-08-12T22:38:46.925Z",
      "createdAt":"2019-08-12T22:37:23.430Z",
      "name":"JK Rowling",
      "bio":"J.K. Rowling is the author of the much-loved series of seven Harry Potter novels, originally published between 1997 and 2007.",
      "__v":1,
      "books":[ 
         { 
            "_id":"5d51ea76f607f9339d5a76f6",
            "updatedAt":"2019-08-12T22:38:46.919Z",
            "createdAt":"2019-08-12T22:38:46.919Z",
            "title":"Harry Potter",
            "author":"5d51ea23acaf6f3380bcab56",
            "__v":0
         }
      ]
   },
   { 
      "_id":"5d51ea23acaf6f3380bcab57",
      "updatedAt":"2019-08-12T22:38:46.937Z",
      "createdAt":"2019-08-12T22:37:23.475Z",
      "name":"Tony Robbins",
      "bio":"Tony Robbins is an entrepreneur, best-selling author, philanthropist and the nation's #1 Life and Business Strategist.",
      "__v":1,
      "books":[ 
         { 
            "_id":"5d51ea76f607f9339d5a76f7",
            "updatedAt":"2019-08-12T22:38:46.921Z",
            "createdAt":"2019-08-12T22:38:46.921Z",
            "title":"Awaken the Giant Within",
            "author":"5d51ea23acaf6f3380bcab57",
            "__v":0
         }
      ]
   }
]

Congratulations, you’ve built an API with Node.js, Express 4 and MongoDB!

Lastly, a word from the Jscrambler team — before shipping your web apps, make sure you are protecting their JavaScript source code against reverse-engineering, abuse, and tampering. 2 minutes is all it takes to begin your free Jscrambler trial and start protecting JavaScript.

#nodejs #Express #mongodb #MySQL #PostgreSQL

What is GEEK

Buddha Community

NodeJS API Development with Express MongoDB and Mongoose

Hire NodeJs Developer

Looking to build dynamic, extensively featured, and full-fledged web applications?

Hire NodeJs Developer to create a real-time, faster, and scalable application to accelerate your business. At HourlyDeveloper.io, we have a team of expert Node.JS developers, who have experience in working with Bootstrap, HTML5, & CSS, and also hold the knowledge of the most advanced frameworks and platforms.

Contact our experts: https://bit.ly/3hUdppS

#hire nodejs developer #nodejs developer #nodejs development company #nodejs development services #nodejs development #nodejs

Marcelle  Smith

Marcelle Smith

1598437740

A Simple Guide to API Development Tools

APIs can be as simple as 1 endpoint for use by 100s of users or as complex as the AWS APIs with 1000s of endpoints and 100s of thousands of users. Building them can mean spending a couple of hours using a low-code platform or months of work using a multitude of tools. Hosting them can be as simple as using one platform that does everything we need or as complex as setting up and managing ingress control, security, caching, failover, metrics, scaling etc.

What they all have in common are three basic steps to go from nothing to a running API.

Each of these steps has its own set of tools. Here are some I’ve used and popular alternatives.

Design

REST is the most popular API interface and has the best tooling. Our design output for REST services always includes an OpenAPI specification. The specification language can be tricky to get right in JSON (how many curly brackets?) or YAML (how many spaces?) so a good editor saves a lot of time.

Four popular ones are:

I’ve only used Swagger and Postman but both Insomnia and Stoplight look interesting. All of them offer additional functionality like documentation, testing and collaboration so are much more than just specification generators.

#api #apis #api-development #restful-api #rest-api #development-tools #app-development-tools #developer-tools

Top NodeJS Mobile App Development Company in USA

AppClues Infotech is one of the leading NodeJS app development company in USA that offering excellent NodeJS development services for web app development. We provide customized and high-quality NodeJS app development services to clients for different industries with advanced technology and functionalities.

Our dedicated app developers have years of experience in NodeJS development and thus successfully deliver cost-effective and highly customized solutions using the robust JavaScript engine of NodeJS.

Why Choose AppClues Infotech for NodeJS Application Development?
• Fast App Development
• Real-Time Application
• JSON (JavaScript Object Notation) in your Database
• Single Codebase
• Lower Cost
• Built-in NPM Support
• Inexpensive Testing and Hosting

For more info:
Website: https://www.appcluesinfotech.com/
Email: info@appcluesinfotech.com
Call: +1-978-309-9910

#top nodejs app development company in usa #nodejs web app development #nodejs development agency in usa #hire nodejs app developers in usa #custom nodejs app development company #best nodejs app development service company

Laura  Fox

Laura Fox

1641992460

API Development Course with NodeJs, Express and MongoDB [Day 2]

7 Days, Certified, API Development with NodeJs, Express, and MongoDB FREE Bootcamp in collaboration with
Google Developer Groups,  Microsoft Learn Student Ambassador Program, and AWS Students Club.

#mongodb #api #nodejs #express #mongodb #node 

Tracking a Developer’s Journey From Documentation Visit

If your business model involves selling to developers, you probably have already realized that much of the traditional processes and metrics applicable to traditional enterprise sales or consumer marketing don’t work. Specifically, selling to developers usually means attracting them to your platform and helping them succeed in building something, whether that’s a new app, integration, or automating an internal process. Getting developers to adopt your platform can be daunting and requires investment in product, onboarding and developer experience, and documentation. However, there are few tools product managers and developer relations leaders can leverage to measure and improve that experience.

Web and mobile analytics tools like Mixpanel and Amplitude can only measure activity on the website itself, yet most developer platforms price on what happens with the API, not via website activity. On the other hand, most API monitoring tools can only track infrastructure metrics like requests per minute and CPU utilization without any context of the user. To accurately measure your adoption and conversion funnel, you need to track usage across your entire platform from initial ad click and sign up, to what a new developer does with your API.

What is the developer-first marketing strategy

Most developer-first platforms have a B2D (business2developer) go to market strategy which is uniquely different from B2C companies which drive consumer adoption, but also different from B2B companies who maintain large sales forces to push their solution to other businesses. In reality, B2D sits somewhere in the middle between B2B and B2C.

B2D is like B2C in that:

  • Self-service signups and credit card payments takes priority over sales demos and contract negotiation
  • Low-cost acquisition channels like SEO-optimized content, SEM, and partnerships are prioritized over large and expensive sales development teams sending emails.
  • Because almost everything is self-serve and online, you can be very data-driven in terms of product metrics focused over just focusing on 1:1 relationships.

B2D is also like B2B in that:

  • The developer still works at a company who is buying to solve a pain rather than an individual looking for the latest gadget or online hangout spot.
  • Sales processes can still be complex involving multiple stakeholders and require technical validation.
  • Developers are still humans implementing a complex solution and may need high-touch dedicated support vs B2C where support is super transactional handling password resets and returns.

Building a cross-platform funnel across web and API

API product managers can focus on any number of initiatives at any given time, whether that;s API features, pricing and packaging, or top of the funnel acquisition. In order to know which area to focus, you should map out your _entire_funnel from very first ad click to a fully activated customer paying and referring other customers. The beginning of your funnel might start on your website as a visitor signs up to use your API. However, once they created an API key, much of the magic happens on the API side rather than the web side. Many developer platforms build their business model around usage-based pricing, which means your revenue is correlated to API usage, not website usage.

Funnel StageSourceDescriptionWhat to look forSigned UpWebsiteThe first step a developer makes is to show interest in your platform. For developer tools, this usually means signing up and generating an API key.Your analytics solution should be tracking which channel the user came from using UTM parameters, referrer tracking, etc along with which page drove the signup.Made first API CallAPIThis is a huge milestone as many signups never reach this stage. The developer was able to understand your API and give it a spin.Monitor TTFHW (Time to First Hello World) and conversion rate. You should continue looking at which channels drive the most activations.Made over 100 API CallsAPIAfter a 100 or so API calls, you could consider the developer “active”, in that they built a real integration rather than just testing with Postman or CurlA low conversion rate from the last step could imply difficulties with your SDK or unclear integration steps.Approaching Free LimitsAPIMost API products are priced on usage. In order to become a paying customer, they need to exceed some limit.If very few long-term “active” developers exceed their limits,then you may need to optimize your packaging and pricing.Converted to PayingWebsiteCongrats! You now have paying customers.Most developers have more than one value metric they price on. Keep an eye on which ones are driving paid conversions.Evangelized your APIWebsiteAre developers sharing and discussing your platform online?By adding a mechanism to track referrals, you can see which channels and mediums are performing the best. A complete analytics platform can track UTM parameters and things like referring domain. With a mechanism to generate unique links pere customer, you can also track which types of customers share the most.

API Adoption Funnel

Linking web with API activity for users and companies

Business2developer go to market models have elements of both B2C and B2B and involve both individual developers and also companies or accounts. It also involves cross-platform tracking across web and APIs. This can complicate accurate funnel and conversion reporting. Do you track an individual user sign up funnel or do you track companies who integrated and use the API? What happens if a developer clicks on an AdWord and signs up using his or her GitHub account but doesn’t do anything. If the person invited a colleague to do integration, then that person may only be attributed to “direct traffic” or “invite referral” depending on your marketing attribution. We need to still attribute the successful integration to an AdWord click.

One way to solve this is mapping out a 4x4 grid to track:

Developers active on APICompanies active on APIDevelopers active on websiteCompanies active on website

Not all API platforms will follow this model and may fill some boxes with a don’t care. For example, many APIs don’t care or track which developer is accessing the API, yet it’s important to understand which company is using the API. In this case, we want to track the following:

_Not Applicable_Companies active on APIDevelopers active on websiteCompanies active on website

Solving the cross-platform tracking

In order to solve this, analytics platforms like Moesif link everything through user ids and company ids regardless of the sessions. Your API and website should use the same identities regardless of the platform for accurate reporting. By modeling companies as groups of users, the linking can be simplified. This provides flexibility in picking and choosing whether to track usage only at the user-level, only at the company-level, or both for the API and website separately.

While having permanent identifiers are great, sometimes we don’t have all information available when the API call or user action is logged. To solve for these cases, we leverage the website session token or API key to uniquely identify the person and company. An alias table that links both session tokens to user/company ids and also API keys to user/company ids enable end to end funnel tracking.

Closing thoughts

Tracking usage and retention accurately is critical in 2020 as leadership shifts from a growth at all costs to efficient growth driven from product optimizations. You can no longer just measure vanity metrics like pageviews and signups. Instead, you should be measuring the entire funnel and understand the inputs that impact each stage. How does changes to your pricing and packaging modify your conversion rates from active developer to converted paying customer.

#api management #developer marketing #developer relations #developer experience #api adoption #developer advocacy #developer advocate #api product #api program #developer evangelism