Node.js: Code Outside the Browser / Working with npm (Node Package Manager)

3rd Party Modules

🎯 Goal of This Note

Learn how to require and use a third-party npm package (slugify) in code — completing the picture alongside core modules (like fs, http) and custom modules (like replaceTemplate).

🔄 Recap: Three Types of require() Imports

📌 Imports are conventionally placed at the top of the file, in this order:

  1. ⚙️ Core Node.js modules (e.g., fs, http, url)

  2. 📦 Third-party modules installed via npm (e.g., slugify) ← this note's focus

  3. 🧩 Your own custom modules (e.g., replaceTemplate)

📥 Step 1: Requiring a Third-Party Package

const slugify = require('slugify');

🔍 How This Works

  • 📦 Just like requiring a core module, you use require() with the package name.

  • 📂 Since slugify isn't a built-in Node module, Node automatically knows to look inside the node_modules folder (created earlier when you ran npm install slugify) to find it.

  • 🏷️ The result — a function, in this case — is stored in a variable (named slugify here, matching the package name for clarity).

🔗 Step 2: What Is a "Slug"?

  • 📝 A slug is the human-readable, unique part of a URL that identifies a specific resource — commonly seen in blog posts and product pages.

💡 Example

  • ❌ Instead of a URL like:

/product?id=0

You could have something more meaningful like:

/product/fresh-avocados

Here, fresh-avocados is the slug — generated from a name like "Fresh avocados" by:

  • Converting it to lowercase.

  • Replacing spaces with dashes.

  • This is much more descriptive and SEO-friendly than a plain numeric ID.

📖 Step 3: Checking the Documentation

  • 💡 When using a new package for the first time, it's good practice to check its documentation on npmjs.com:

  1. Search for the package by name (slugify) on npmjs.com.

  2. The docs show usage examples, such as:

slugify(string, options);

  1. ⚙️ Available options include things like:

  • 🔄 replacement — the character used to replace spaces (defaults to , but could be _ or nothing).

  • 🔡 lower — whether to convert everything to lowercase (true/false).

💡 Lesson: Documentation is essential for correctly understanding a package's options and behavior — don't guess, check the docs.

🧪 Step 4: Testing Slugify

console.log(slugify('Fresh avocados', { lower: true }));

  • 🔄 This converts "Fresh avocados" into a clean slug: fresh-avocados.

💡 Bonus tip: Since Nodemon is now running (from the previous lecture), there's no need to manually stop and restart the server after each code change — Nodemon automatically restarts it and shows the updated console output.

🏷️ Step 5: Generating Slugs for All Products

  • 📦 Using the array of products (dataObject) and the familiar .map() method:

const slugs = dataObj.map(el => slugify(el.productName, { lower: true }));
console.log(slugs);

🔍 How This Works

  • 🔁 .map() loops through each product object (el) in dataObject.

  • 🏷️ For each one, it creates a slug from el.productName (the field holding the product's name).

  • 📋 The result is a new array of slug strings — one for each of the five products.

📦 Key Concept: This Package Is Now a Dependency

  • By using slugify in the code, the project now genuinely depends on it — without this package installed, this part of the code would break.

  • This is exactly why npm tracks it under "dependencies" in package.json.

🚫 What Wasn't Done (On Purpose)

  • The lecture stops short of actually:

    • 💾 Saving these generated slugs into data.json.

    • 🔗 Updating the app's routing/templates to use slugs instead of numeric IDs in URLs.

  • This is intentional — doing so would just be repeating the same concepts already learned (modifying JSON, updating routes, templates, etc.) without introducing anything new.

  • The purpose of this lecture was purely to demonstrate the process of integrating a third-party npm package:

    1. 📥 Install it (npm install).

    2. 📦 require() it in code.

    3. 📖 Check its documentation.

    4. 🚀 Use it with a simple example.

🎯Key Takeaways

📌 Concept

💡 Explanation

📥 require('package-name')

Loads a third-party package from node_modules (installed via npm)

📦 Import order convention

Core modules → third-party modules → your own custom modules

🏷️ Slug

A readable, unique URL string (e.g., fresh-avocados) — more meaningful than a plain ID

📖 Checking documentation

Essential for correctly using unfamiliar packages and their options (e.g., lower vs. lowercase)

🔁 .map() with a package function

Common pattern: transform an array of data using a third-party function inside the callback

✅ A used package = a dependency

Once your code relies on a package to function, it becomes a real dependency of your project

➡️ This completes the module import trilogy:

  • ⚙️ Core modules

  • 🧩 Own modules

  • 📦 Third-party modules

all imported using the same require() function, just resolving to different locations (Node's built-ins, your local files, or node_modules).