mern ebook added

Author: PrasanKumar93

docs/ebooks/nosql-data-modeling-patterns.mdx

@@ -172,7 +172,7 @@ Notice that in **Code Example 3** we are using the `FT.SEARCH` (RediSearch) comm
 
 ```python title="Code Example 4"
 async def get_product_details(product_id: str):
-    eturn await Product.get(product_id)
+    return await Product.get(product_id)
 ```
 
 When using Redis, you can use RedisInsight as a GUI tool to visualize and interact with the data in your database. **Picture 4** shows you what a `Products` document looks like.

docs/ebooks/three-caching-design-patterns.mdx

@@ -0,0 +1,124 @@
+---
+id: three-caching-design-patterns
+title: 3 design patterns to speed up MEAN and MERN stack applications
+image: /img/ebooks/three-caching-design-patterns/three-caching-design-patterns.png
+sidebar_label: 3 design patterns to speed up MEAN and MERN stack applications
+slug: /ebooks/three-caching-design-patterns
+editUrl: false
+showLastUpdateTime: false
+---
+
+import Excerpt from '@theme/Excerpt';
+import CachingMovieAppDesign from '../howtos/solutions/caching-architecture/common-caching/caching-movie-app.mdx';
+import SourceCodeMovieApp from '../howtos/solutions/caching-architecture/common-caching/source-code-movie-app.mdx';
+
+<Excerpt
+  cta="https://redis.com/docs/three-design-patterns-to-speed-up-mean-and-mern-stack-applications/"
+  image={frontMatter.image}
+  title={frontMatter.title}>
+
+## Introduction
+
+**If you don't design and build software with attention to performance, your applications can encounter significant bottlenecks when they go into production.**
+
+Over time, the development community has learned common techniques that work as reliable **design patterns** to solve well-understood problems, including application performance.
+
+So what are design patterns? They are recommended practices to solve recurring design problems in software systems. A design pattern has four parts: a name, a problem description (a particular set of conditions to which the pattern applies), a solution (the best general strategy for resolving the problem), and a set of consequences.
+
+Two development stacks that have become popular ways to build Node.js applications are the **MEAN** stack and the **MERN** stack. The MEAN stack is made up of the MongoDB database, the Express and Angular.js frameworks, and Node.js. It is a pure JavaScript stack that helps developers create every part of a website or application. In contrast, the MERN stack is made up of MongoDB, the Express and ReactJS frameworks, and Node.js.
+
+Both stacks work well, which accounts for their popularity. But it doesn't mean the software generated runs as fast as it can—or as fast as it needs to.
+
+In this post, we share one popular design pattern that developers use with Redis to improve application performance with MEAN and MERN stack applications: the `master data-lookup pattern`. We explain the pattern in detail and accompany it with an overview, typical use cases, and a code example. Our intent is to help you understand when and how to use this particular pattern in your own software development. The Ebook has other patterns too like `The cache-aside pattern` and `The write-behind pattern`
+
+## Building a movie application
+
+<CachingMovieAppDesign />
+
+This tutorial uses a GitHub sample demo that was built using the following tools:
+
+- **Frontend**: ReactJS (18.2.0)
+- **Backend**: Node.js (16.17.0)
+- **Database**: MongoDB
+- **Cache and database**: Redis stack (using Docker)
+
+<SourceCodeMovieApp />
+
+## The master data-lookup pattern
+
+One ongoing developer challenge is to (swiftly) create, read, update, and (possibly) delete data that lives long, changes infrequently, and is regularly referenced by other data, directly or indirectly. That's a working definition of master data, especially when it also represents the organization's core data that is considered essential for its operations.
+
+Master data generally changes infrequently. Country lists, genres, and movie languages usually stay the same. That presents an opportunity to speed things up. You can address access and manipulation operations so that [data consistency](https://redis.com/blog/database-consistency/) is preserved and data access happens quickly.
+
+From a developer's point of view, master data lookup refers to the process by which master data is accessed in business transactions, in application setup, and any other way that software retrieves the information. Examples of master data lookup include fetching data for user interface (UI) elements (such as drop-down dialogs, select values, multi-language labels), fetching constants, user access control, theme, and other product configuration. And you can do that even when you rely primarily on MongoDB as a persistent data store.
+
+![pattern](/img/ebooks/three-caching-design-patterns/pattern-01.jpg)
+
+To serve master data from Redis, preload the data from MongoDB.
+
+1. Read the master data from MongoDB on application startup and store a copy of the data in Redis. This pre-caches the data for fast retrieval. Use a script or a cron job to repeatedly copy master data to Redis.
+1. The application requests master data.
+1. Instead of MongoDB serving the data, the master data will be served from Redis.
+
+### Use cases
+
+Consider this pattern when you need to
+
+- **Serve master data at speed**: By definition, nearly every application requires access to master data. Pre-caching master data with Redis delivers it to users at high speed.
+- **Support massive master tables**: Master tables often have millions of records. Searching through them can cause performance bottlenecks. Use Redis to perform real-time search on the master data to increase performance with sub-millisecond response.
+- **Postpone expensive hardware and software investments**: Defer costly infrastructure enhancements by using Redis. Get the performance and scaling benefits without asking the CFO to write a check.
+
+### Demo
+
+The image below illustrates a standard way to showcase a UI that is suitable for master data lookups. The developer responsible for this application would treat certain fields as master data, including movie language, country, genre, and ratings, because they are required for common application transactions.
+
+Consider the pop-up dialog that appears when a user who wants to add a new movie clicks the movie application plus the icon. The pop-up includes drop-down menus for both country and language. In this demonstration, Redis loads the values.
+
+![demo-03](/img/ebooks/three-caching-design-patterns/demo-03.png)
+
+### Code
+
+The two code blocks below display a fetch query of master data from both MongoDB and Redis that loads the country and language drop-down values.
+
+Previously, if the application used MongoDB, it searched the static database to retrieve the movie's country and language values. That can be time-consuming if it's read from persistent storage—and is inefficient if the information is static.
+
+```js
+*** BEFORE (MongoDB)***
+*** MongoDB regular search query ***
+function getMasterCategories() {
+  ...
+  db.collection("masterCategories").find({
+    statusCode: {
+      $gt: 0,
+    },
+    category: {
+      $in: ["COUNTRY", "LANGUAGE"],
+    },
+  });
+  ...
+}
+```
+
+Instead, the “after” views in the code blocks show that the master data can be accessed with only a few lines of code—and much faster response times.
+
+```js
+*** AFTER (Redis) ***
+*** Redis OM Node query ***
+function getMasterCategories() {
+  ...
+  masterCategoriesRepository
+    .search()
+    .where("statusCode")
+    .gt(0)
+    .and("categoryTag")
+    .containOneOf("COUNTRY", "LANGUAGE");
+  ...
+}
+```
+
+## Download the E-book
+
+**Sensing a pattern here?**
+The master data-lookup pattern is not the only design pattern you can use to improve application performance.
+
+</Excerpt>

docs/howtos/solutions/caching-architecture/cache-prefetching/index-cache-prefetching.mdx

@@ -32,12 +32,6 @@ Imagine you're building a movie streaming platform. You need to be able to provi
 
 One ongoing developer challenge is to swiftly create, read, update, and delete master data. You might store your master data in a system of record like a SQL database or document database, and then use Redis as a cache to speed up lookups for that data. Then, when an application requests master data, instead of coming from the system of record, the master data is served from Redis. This is called the "master data-lookup" pattern.
 
-Consider this pattern when you need to:
-
-1. Serve master data at speed and scale
-1. Support massive master tables
-1. Postpone expensive hardware and software investments
-
 From a developer's point of view, "master data lookup" refers to the process by which master data is accessed in business transactions, in application setup, and any other way that software retrieves the information. Examples of master data lookup include fetching data for user interface (UI) elements (such as drop-down dialogs, select values, multi-language labels), fetching constants, user access control, theme, and other product configuration.
 
 Below you will find a diagram of the data flow for prefetching master data using Redis with MongoDB as the system of record.

sidebars.js

@@ -609,7 +609,10 @@ module.exports = {
     {
       type: 'category',
       label: 'E-books',
-      items: ['ebooks/nosql-data-modeling-patterns'],
+      items: [
+        'ebooks/nosql-data-modeling-patterns',
+        'ebooks/three-caching-design-patterns'
+      ],
     },
   ],
 };