The document outlines a talk on developing a basic REST API using Node.js and MongoDB with a focus on test-driven development (TDD). It covers the creation of a shopping cart application, schema design principles, and the use of the Express framework along with Mongoose for handling MongoDB data. Additionally, it discusses testing strategies with tools like Mocha and Superagent while providing resources for further learning.

1. Developing a Basic REST API from
Scratch Using TDD
Valeri Karpov
NodeJS Engineer, MongoDB
www.thecodebarbarian.com
github.com/vkarpov15
@code_barbarian

2. *
What is this talk about?
•Earlier you heard about:
– Building a basic app
– Schema design principles
•MongoDB is great for storing web/mobile app data
•So let’s build a REST API using NodeJS!
•+ learn a bit about test-driven dev with NodeJS

3. *
Overview
•Part 1: Shopping Cart Application
– Search for products
– Add them to your cart
– Check out with Stripe
•Part 2: Using the Mongoose ODM
•Part 3: Schema Design
•Part 4: Building an API with the Express framework
•Part 5: Testing with Mocha + Superagent

4. *
What Does the App Do?

5. *
What Does the App Do?

6. *
What Does the App Do?

7. *
App Structure
•"Bad programmers worry about the code. Good
programmers worry about data structures and their
relationships." - Linus Torvalds
•3 schemas for 3 collections:
•Products
•Categories
•Users

8. *
Schema Relationships
•Product belongs to one or more categories
•Users can have multiple products in their cart

9. *
Part 2: Using the Mongoose ODM
•“Object document mapper” (like ORM, but for
MongoDB)
•Written for NodeJS
•Provides schema validation

10. *
Brief Overview of NodeJS
•require()
● Async I/O

11. *
Your First Mongoose Schema

12. *
Using Your Schema

13. *
Using Your Schema

14. *
Part 3: Schema Design
•3 schemas:
– Product
– Category
– User
•Going to use mongoose to define schemas

15. *
Product Schema

16. *
Product Schema in Action

17. *
Category Schema

18. *
Category Schema Queries
•What categories are descendants of “Electronics”?
•
•What categories are children of “Non-Fiction”?
•
•What categories are ancestors of “Phones”?

19. *
Product + Category Schemas

20. *
Category Schema Takeaways
•Queries in MongoDB should be simple
•“Store what you query for”
•“If you need [to use the aggregation framework in
an API endpoint], you're screwed anyway, and
should fix your program.” - Linus Torvalds

21. *
User Schema

22. *
Principle of Least Cardinality
•Product and user = many-to-many relationship
•Don’t necessarily need a mapping table
•User won’t have 1000s of products in cart
•Can represent relationship as array in user since
one side is small
•Arrays that grow without bound are an
antipattern!

23. *
Part 4: The Express Framework
•Most popular NodeJS web framework
•Simple, pluggable, and fast
•Great tool for building REST APIs

24. *
Your First Express App

25. *
Your First Express App

26. *
Your First Express App

27. *
What is REST?
•Representational State Transfer
•HTTP request -> JSON HTTP response
•Business logic on top of MongoDB schemas

28. *
Structuring Your REST API

29. *
GET /category/id/:id

30. *
GET /category/parent/:id

31. *
GET /product/category/:id

32. *
Adding Products to User’s Cart
•Recall cart is an array of products

33. *
Adding Products to User’s Cart

34. *
PUT /me/cart Takeaways
•Mongoose lets you be lazy
•Access control using subdocs

35. *
Bonus: Stripe Checkout

36. *
Bonus: Stripe Checkout

37. *
Part 4 Takeaways
•Express REST API on top of mongoose
– Access control
– Business logic
– Define what operations user can take on database
•Mongoose casting and validation for APIs

38. *
Part 5: Test-Driven Development
•Building an API is tricky
•Lots of different error conditions
•Express has a lot of magic under the hood

39. *
NodeJS Concurrency and Testing
•NodeJS runs in an event loop
•Single threaded
•Can run client and server on same thread!
•Test server end-to-end

40. *
Superagent
•NodeJS HTTP client
•Isomorphic: runs in both browser and NodeJS
•Same author as Express

41. *
Mocha
•Testing Framework for NodeJS
•Same author as Express
•BDD-style syntax

42. *
Setting Up Category API Tests

43. *
Testing GET /category/id/:id

44. *
Part 5 Takeaways
•NodeJS concurrency makes testing easy
•Not just unit tests - full E2E for your REST API
•Can manipulate database and make arbitrary
HTTP requests

45. *
•Upcoming EdX Video Course
•Looking for beta testers! Fill out survey for info
– database.mongodb.com/community-survey
•More NodeJS+MongoDB content at:
– www.thecodebarbarian.com
– Twitter: @code_barbarian
Thanks for Listening!