DEV Community: prakash chokalingam

Set up MongoDB primary and secondary with Docker.

prakash chokalingam — Sun, 05 Jan 2025 19:10:33 +0000

MongoDB is a popular choice for developers today when it comes to NoSQL databases. The MongoDB Community Edition is readily available as a Docker image.

To enable MongoDB transactional queries, you need to configure a replica set with primary and secondary database connections.

In this post, we’ll walk through how to set up MongoDB’s primary and secondary nodes and configure a replica set using a single docker-compose file.

Prerequisites for Running the Below docker-compose File

Create a Docker Network

 docker network create dev_network

Replica Set Configuration Script

Create a file named replicaset.sh under the scripts directory to configure the replica set:

scripts/replicaset.sh

Grant Permissions to the Script Ensure the script has execute permissions so Docker can access it:

 chmod +x scripts/replicaset.sh

Update the Host File for Resolvers

Map the Mongo paths to localhost by editing the /etc/hosts file:

127.0.0.1   primary secondary1 secondary2 # mongo docker resolvers

Create the Docker Compose File

Define your MongoDB configuration in a docker-compose.yml file:

Run the Docker Compose File Start the containers using the following command:

docker-compose up

🎉 That’s it! Your MongoDB primary and secondaries are up and running. The replica set is configured and ready to use.

Your MongoDB connection URL is:

mongodb://localhost:27020,localhost:27021,localhost:27022/dbname?replicaSet=rs0&retryWrites=true&w=majority

Spin a Framework-Free HTTP Router Server in Go 1.22 With Ease

prakash chokalingam — Thu, 15 Feb 2024 10:20:19 +0000

Transitioning from Node.js or Python development, you're likely familiar with the convenience of frameworks like Express or Flask for spinning up HTTP servers with rich routing capabilities. Similarly, in the Go ecosystem, frameworks such as Gin and Gorilla/Mux have been the go-to solutions for developers seeking to implement efficient routing within their applications.

However, the landscape has evolved with the release of Go 1.22. The net/http package, a staple for network-related operations in Go, has received significant enhancements, particularly in its routing capabilities. This evolution means that developers can now implement complex HTTP servers without relying on external frameworks, streamlining the development process and reducing dependency overhead.

Here's how to build a simple todo application using the net/http server mux.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    router := http.NewServeMux()

    router.HandleFunc("POST /todos", func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("create a todo")
    })

    router.HandleFunc("GET /todos", func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("get all todos")
    })

    router.HandleFunc("PATCH /todos/{id}", func(w http.ResponseWriter, r *http.Request) {
        id := r.PathValue("id")
        fmt.Println("update a todo by id", id)
    })

    router.HandleFunc("DELETE /todos/{id}", func(w http.ResponseWriter, r *http.Request) {
        id := r.PathValue("id")
        fmt.Println("delete a todo by id", id)
    })

    http.ListenAndServe(":8080", router)
}

You can also create a route that matches exactly or uses a wildcard for flexible matching.

// wild card
router.HandleFunc("PATCH /todos/{rest...}", func(w http.ResponseWriter, r *http.Request) {
  rest := r.PathValue("rest")
  fmt.Println("wild card route", rest)
})

// exact match
router.HandleFunc("/todos/{$}", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprint(w, "exact match")
})

For more details deep dive into the official go documentation https://pkg.go.dev/net/http#ServeMux.

Seamlessly Embed Files Into Your Go Binary

prakash chokalingam — Fri, 02 Feb 2024 08:07:28 +0000

Incorporating YAML, JSON, or other configuration files into your Go application is becoming a standard practice, these files are often being referenced by file paths within the project. Although the go-build process completes smoothly, executing the standalone binary can result in a 'file not found' error. This means you have to keep these setting files close to your app wherever you run it.

To circumvent this issue, Go offers a powerful feature known as embed. This allows developers to include their files directly within the binary by creating an embedded file system.

Usage

import "embed"

//go:embed config.yaml
var embedFS embed.FS

# access config file
config, _ := embedFS.ReadFile("config.yaml")

You can even embed a list of directories as part of your go binary,

import "embed"

//go:embed templates/* config/*
var embedFS embed.FS

# access email template
template, _ := embedFS.ReadFile("templates/email.hbs")

This feature enables you to run the go binary standalone without any external dependencies.

For more details please check the go embed documentation.

Envoy External Authorization with Golang GRPC service

prakash chokalingam — Wed, 21 Jun 2023 12:10:11 +0000

Envoy is a cloud native opensource proxy server. The Envoy proxy offers a variety of http filters to handle incoming requests.

Out of them External authorisation is a filter type that directs an incoming request to an external service and waits for its authorisation to continue the request.The external service, which has the ability to modify or suspend the incoming request, can be either a grpc_service or a http_service.

Working example: prakashchokalingam/envoy_ext_auth_grpc_go

Let's look at connecting a GRPC-based Golang service using the Envoy external auth filter.

Create a golang grpc based server:

main.go



package main

import (
  "fmt"
  "net"
  "google.golang.org/grpc"
)

func main() {
  endPoint := fmt.Sprintf("localhost:%d", 3001)
  listen, err := net.Listen("tcp", endPoint)

  grpcServer := grpc.NewServer()
  grpcServer.Serve(listen)
}

Extend with go-control-plane protobuf

The above server should be extended and registered with the envoyproxy go-control-plane protobuf server with a check function defined struct.

main.go



package main

import (
  "fmt"
  "net"

   auth_pb "github.com/envoyproxy/go-control-plane/envoy/service/auth/v3"
  "google.golang.org/grpc"
)

func main() {
  // struct with check method
  type AuthServer struct {}

  func (server *AuthServer) Check(
    ctx context.Context, 
    request *auth_pb.CheckRequest,
  ) (*auth_pb.CheckResponse, error) {
    fmt.println("All request goes through me")

    // block if path is /private
    path = request.Attributes.Request.Http.Path[1:]
    if path == 'private' {
      return nil, fmt.Errorf('private request not allowed')
    }

    // allow all other requests
    return &auth_pb.CheckResponse{}, nil
  }


  endPoint := fmt.Sprintf("localhost:%d", 3001)
  listen, err := net.Listen("tcp", endPoint)

  grpcServer := grpc.NewServer()

  // register envoy proto server
  server := &AuthServer{}
  auth_pb.RegisterAuthorizationServer(grpcServer, server)

  grpcServer.Serve(listen)
}

If nil is returned in the check method rather than &auth_pb.CheckResponse, the request will be suspended with a 403 error code.

Note: Envoy will also return 403 if the service is offline or unreachable.

Last but not least, set up your Envoy

In your envoy config add the filter envoy.filters.http.ext_authzand point it to the Go service cluster

envoy.yml



static_resources:
  listeners:
    - name: listener_0
      address:
        socket_address: { address: 0.0.0.0, port_value: 80 }
      filter_chains:
        - filters:
            - name: envoy.filters.network.http_connection_manager
              typed_config:
                "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
                codec_type: auto
                stat_prefix: ingress_http
                route_config:
                  name: local_route
                  virtual_hosts:
                   ...
                http_filters:
                  - name: envoy.filters.http.ext_authz
                    typed_config:
                      "@type": type.googleapis.com/envoy.extensions.filters.http.ext_authz.v3.ExtAuthz
                      transport_api_version: v3
                      grpc_service:
                        envoy_grpc:
                          cluster_name: go_grpc_cluster
                      include_peer_certificate: true
                        ...
  clusters:
    - name: go_grpc_cluster
      connect_timeout: 0.25s
      type: LOGICAL_DNS
      typed_extension_protocol_options:
        envoy.extensions.upstreams.http.v3.HttpProtocolOptions:
          "@type": type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions
          explicit_http_config:
            http2_protocol_options: {}
      load_assignment:
        cluster_name: go_grpc_cluster
        endpoints:
        - lb_endpoints:
          - endpoint:
              address:
                socket_address:
                  address: 127.0.0.1
                  port_value: 3001

To see an example snippet for customising headers, click here

Check out this repository for a fully functional code sample

prakashchokalingam / envoy_ext_auth_grpc_go

Working example of envoy external auth filter with go lang grpc service

Example repo to demonstrate Envoy External Authorization with Golang GRPC service

This repository provides an envoy configuration file with an external auth filter activated for all incoming routes at port 8080

The envoy is configured with two clusters,

go_grpc_filter

The filter envoy.filters.http.ext_authz in envoy is pointed at this go grpc cluster. All incoming requests will be forwarded to this cluster.

The Check method will be called during a request; it then adds a custom header to all other requests and rejects requests with the path '/private'.

Request	grpc_filter	status	http_server_response
/	x-custom-header = "Hello World"	200	Hello World
/ private	403	-	-

go_simple_http

It is a straightforward Golang HTTP server that merely emits the custom header value x-custom-header added via the go_grpc_filter cluster.

To run this example

Start the envoy server

envoy -c envoy.yml

start the go_grpc_filter & go_simple_http servers by navigating to the cluster root.

go run main.go

View on GitHub

Codebytes: REPL it with NestJs

prakash chokalingam — Tue, 29 Nov 2022 19:17:02 +0000

I am a big fan of byebug, a powerful ruby debugger, and I was thrilled to know about the REPL server in the NestJS V9 release notes.

source: manshagraphics-Flaticon

The REPL server acts as a debugger for NestJS by launching an interactive server with all of the context required for your nest app. So you can basically interact with all of your methods directly.

To start the REPL server in your NestJS app,

Make a REPL entry file called repl.ts alongside main.ts.
Include your app module to the repl method in the repl.ts file.

// repl.ts

import { repl } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  await repl(AppModule);
}
bootstrap();

Launch your repl server using the below command,

npm run start -- --entryFile repl

It will initiate an interactive node server, from which you can easily access your nest app methods by getting them,

get(AppService).sayHelloWorld()

play with REPL on codesandbox

for more usage methods on REPL click here to read the official documentation.

Introduction to a stateful & maintainable React Local Storage hook

prakash chokalingam — Thu, 30 Dec 2021 07:09:13 +0000

When it comes to storing a value on the client-side persistently, most of us will prefer browser storage (local or session storage) because of its simplified APIs to store and retrieve data.

Yet maintaining these storages in large-scale applications are not so easy, especially with micro frontends architecture.

The hook @webcored/react-local-storage provides an awesome set of features to maintain the browser storage effortlessly for the long run.

Namespacing & Configurations
Defaults & States
Versions & Migrations

Namespacing & Configurations

Unless it's documented, we don't know the storage keys being used in an application & we are not sure about the values of the keys as well.

Key name conflicts are more common in micro-frontends. An app should control its own set of keys and it should not override the common or other app's key. Hence, namespacing plays a major factor to avoid these conflicts.

import { storageConfig } from "@webcored/react-local-storage";

storageConfig({
  namespace: 'dev',
  delimiter: '#',
})

If the key is user, the storage key name is dev#user.

other available storage configurations,

storage: choose between local or session storage
storages: key configurations
react: instance for state management (useState hook)

import react from 'react';
import { user } from './storages/user';

import { storageConfig } from "@webcored/react-local-storage";

storageConfig({
  namespace: 'dev',
  delimiter: '#',
  storage: window.sessionStorage,
  storages: {
   user // user key configs
  },
  react,
})

Defaults & States

The default state for keys in browser storage is the most required feature. It indulges a lot of programming effort to maintain the default state for every key.

In @webcored/react-local-storage each key can have its config, and the default states for keys can be incorporated easily.

/storages/user.js

import { storageKeyConfig } from "@webcored/react-local-storage"

const user = storageKeyConfig({
  defaults: {
    name: 'Guest',
    email: 'guest@email.com'
  }
})

The storages are simply accessible via the useLocalStorage hook in a stateful way.

/component.js

import { useLocalStorage } from "@webcored/react-local-storage";

const [user, userStorage] = useLocalStorage('user');

And the dispatcher comes with painless APIs to invoke the storage programmatically.

update

userStorage.update({ ...user, avatar: 'avatar.jpg' });

reset

Reset the storage to the default state.

userStorage.reset();

remove

userStorage.remove();

Versions & Migrations

Since the storages are persistent, changing its data structure quite often may be challenging, and it involves a lot of code changes per key. With @webcored/react-local-storage these data migrations can be simply handled with a version number & a migration callback in the key config.

import { storageKeyConfig } from "@webcored/react-local-storage"

const user = storageKeyConfig({
  defaults: {
    name: 'Guest',
    email: 'guest@email.com',
    avatar: 'guest.png' // new
  },
  version: 2,
  migration: (currentValue, defaultValue) {
    return Object.assign({}, ...currentValue, ...defaultValue);
  }
})

@webcored/react-local-storage supports versioning of keys by default.
As per the above code block, the current version of user storage is incremented. While rendering, if the browser had an outdated version of storage, the migration method will be invoked. The migrated value will be considered as the latest version.

other highlights

supports all data types
typescript supported

checkout the sample apps

javascript | typescript

If you like, Promote the lib with a star ⭐️

webcored / react-local-storage

A stateful react hook for browser storage

React Local Storage

A stateful react hook for browser storage.

Why?

Install

npm install @webcored/react-local-storage

Usage

component.jsx

import { useLocalStorage } from "@webcored/react-local-storage";

const [user, userStorage] = useLocalStorage('user');

....

typescript

const [user, userStorage] = useLocalStorage<User>('user');
  
....

update

userStorage.update({ ...user, name: 'new name' });

remove

userStorage.remove();

reset

Reset's to the default value provided in the key config

userStorage.reset();

Sample app

View on Github

typescript

View on Github

Configurations

import React from 'react';
import { user } from './storages/user';

import { storageConfig } from "@webcored/react-local-storage";

storageConfig({
  namespace: 'app',
  delimiter: '/'
  react: React
  storages: {
    user
  }
}

…

View on GitHub

Codebytes: Shorter UUIDs with collision prediction using nanoid

prakash chokalingam — Fri, 15 Oct 2021 15:33:12 +0000

To generate an unique ID most of us use npm libraries and node utils like uuid, crypto.randomUUID. One of the major cons is these IDs are larger in size and the shorter UUID generation will increase the probability of duplicate IDs.

Here comes the saviour, nanoid - A tiny, secure, URL-friendly, unique string ID generator for JavaScript.

Since the bigger alphabet is being used in the UUID generation, nanoid can generate random unique ids within 21 chars.

And its 2x faster and safer than other UUID generators.

Wait... This will blow your mind!

Nanoid is completely configurable from size to char's, to be used while generating the UUIDs. Then how does it avoid the probability of duplication? It comes with a collision calculator which helps to predict the probability of collision based on configuration.

It has support for various other programming languages. Checkout this awesome repo:

ai / nanoid

A tiny (124 bytes), secure, URL-friendly, unique string ID generator for JavaScript

Nano ID

English | Русский | 简体中文 | Bahasa Indonesia

A tiny, secure, URL-friendly, unique string ID generator for JavaScript.

“An amazing level of senseless perfectionism which is simply impossible not to respect.”

Small. 116 bytes (minified and brotlied). No dependencies Size Limit controls the size.
Safe. It uses hardware random generator. Can be used in clusters.
Short IDs. It uses a larger alphabet than UUID (A-Za-z0-9_-). So ID size was reduced from 36 to 21 symbols.
Portable. Nano ID was ported to over 20 programming languages.

import { nanoid } from 'nanoid'
model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT"

Made at Evil Martians, product consulting for developer tools.

Table of Contents
Comparison with UUID
Benchmark
Security
Install
API
Usage
- React
- React Native
- PouchDB and CouchDB
- Web Workers
- CLI
- Other…

View on GitHub

Codebytes: provide / inject is a bliss in vue3

prakash chokalingam — Thu, 20 May 2021 16:29:37 +0000

Before the existence of these wonderful helpers provide / inject from the vue3 composition apis, if we have to pass props from a top-level component to the child-level components, we have to ensure that the props are passed all the way down or we should rely on state managers like vuex to avoid passing props.

But these new helpers allow us to consume the props in the child components easily from the parent component without passing them redundantly.

Let's look at the below example where the parent component provides the title prop and the child component utilizes the title prop by simply injecting it.

// article-component.vue (ancestor)
import { ref, provide } from 'vue';
....
setup() {
  const title = ref('Article Title');
  provide('title', title);
}

// article-title-component.vue (child)
import { ref, inject } from 'vue';
....
setup() {
  const title = inject('title');
  return {
     title
  }
}

And what if the child component wants to update the injected prop? Let's provide the update callback as well.

// article-component.vue (ancestor)
import { ref, provide } from 'vue';
....
setup() {
  const title = ref('Article Title');
  provide('title', title);
  provide('updateTitle', (newTitle) => title.value = newTitle);
}

// article-title-component.vue (child)
import { ref, inject } from 'vue';
....
setup() {
  const title = inject('title');
  const updateTitle = inject('updateTitle');

  updateTitle(`Draft: ${title}`);
}

See, that's why it's a bliss!

PS: Used https://www.figma.com/figjam/ for the quick flow diagrams.

Generating files with 'vue-cli-plugin-pod'

prakash chokalingam — Sat, 15 May 2021 15:28:18 +0000

If you are working on an awesome vue project, give this awesome vue-cli-pod-plugin a spin.

Why?

Create your components and its related files in a snap
Set file path guidelines
Enforce conventions and rules via default template file content
Customise and extend the pod configurations

How?

Add the plugin to your vue project using the below command:

vue add pod

To know more about vue cli plugins click here.

Now your project has access to the following pod commands. The tasks can be triggered using yarn or npm.

npm run <command> <file type> <file name or file path>

The pod CLI plugin allows component, directive and mixin as the default file type. It can also be extended.

Generate

The generate command creates files of a given type using the config.

npm run generate component UI/dropdown

By default, the vue-pod plugin will use the default configuration to generate files in the pod structure. It can be overridden by customising the configs using the below config command.

Config

The config command creates the pod.config.js file to the root of your vue project with the default settings. The file can be customised and it will be used by pod cli for further invocations.

npm run config

Click here to check the available configuration options.

Rename

The rename command replaces the generated files with an alternative name.

npm run rename component UI/Dropdown UI/Selectbox

Delete

The delete command removes the generated files in the specified path and deletes the directories from the project if it's empty.

npm run delete component UI/Dropdown UI/Selectbox

Extend

Vue is incrementally adoptable and it lets you include scalable features like routes, stores(vuex) to your project later. Don't worry! like vue, vue-cli-plugin-pod is also extensible.

Introduce new file types and their file path in the config at ease.

If you like the plugin, donate a star to the repo 🤩

webcored / vue-cli-plugin-pod

Extended CLI to manage file templates for vue projects

vue-cli-plugin-pod

Extended cli to manage file templates for vue projects

Refer

https://dev.to/prakash_chokalingam/generating-files-with-vue-cli-plugin-pod-5639

Installation

Add this vue cli plugin to your awesome vue project using the below command:

vue add pod

once installed, your project will have access to the following tasks:

Generate

Creates template files for the specified file type

npm run generate <filetype> <file name or path&gt

Example: npm run generate component UI/Button

Rename

Renames template files for the specified file type

npm run rename <filetype> <old file name or path> <new file name or path&gt

Example: npm run rename component icon avatar

Delete

Deletes template files for the specified file type

npm run delete <filetype> <file name or path&gt

Example: npm run delete component UI/Button

Config

Get a clone of the default pod config file and customize it.

npm run config

The above command will generate a pod.config.js file to the root of your project.

click here to…

View on GitHub

Codebytes: How to mock upload files in the test cases

prakash chokalingam — Sun, 19 Jul 2020 06:27:42 +0000

Mocking file uploads with file input elements is not straight forward as mocking other HTML elements while writing test cases. Why and how do we do that?



<input type="file" id="file-upload" onchange="doSomething" />

The file input elements have FileList object as its value. The FileList is nothing but a collection of File objects. The FileList object is read-only and we cannot construct custom FileList since it has no implementation of its constructor.

However, there is a way to construct them using the DataTransfer object.

DataTransfer object is responsible for holding the file objects in FileList during files drag & drop. We are gonna bypass the DataTransfer event's file addition methods to construct a FileList with our mocked files.

Let's create one,



const dt = () => new DataTransfer() || new ClipboardEvent('').clipboardData;

If the browser didn't support constructing a new DataTransfer, let's get the DataTransfer object from the ClipboardEvent (mock's file copy-paste) alternatively.

let's create a blob to construct a file object.



let fileString = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z/C/HgAGgwJ/lK3Q6wAAAABJRU5ErkJggg==';

(or)

let fileString = 'https://some-image-url.png';

let blob = await fetch(fileString).then(res => {
  return res.blob();
});

And now file object,



let file = new File([blob], "sample.jpg", { type: 'image/png'})

will add the file object to the DataTransfer,



let dt = dt();
dt.items.add(file);

and it's time to add the FileList to the file input element



let $fileElement = document.getElementById('file-upload');
$fileElement.files = dt.files;

🎉 Yay! The files have been added to the file element and now let's emit the change event so that your UI can respond to the file upload.



let changeEvent = new Event('change');
$fileElement.dispatchEvent(changeEvent);

To ease this, I have created a test helper util to fill files to the file input element.



await fillInFIle('#file-upload') ✅

Check the GitHub repo for more details on the util:

prakashchokalingam / fill-in-file

A test util that helps to fill files in your file input element

Codebytes: Caching mongoose models in Redis (MongoDB).

prakash chokalingam — Wed, 27 May 2020 05:15:59 +0000

Ever considered caching your mongoose models in a super caching tool like Redis to avoid frequent MongoDB hit and refrained from doing that because you may lose the mongoose object privileges like calling model._id as model.id or model.toObject() or the superior one model.populate() and others.

Here comes the saviour,
https://mongoosejs.com/docs/api.html#model_Model.hydrate

Hydrate method in mongoose API converts your raw JSON data into the mongoose model object(s).

Example: Simple model

// set cache

let todo = Todo.findById(id);
redis.set(key, todo); // stores as raw json

// read cache

let todoCache = redis.get(key); // returns raw json
let todo = Todo.hydrate(todoCache); // converts in to mongoose model

let createdBy = todo.populate('createdBy');

Example: Array of models

// set cache

let todos = Todo.findAll();
redis.set('todos', todos); // stores as array of son

// read cache

let cachedTodos = redis.get('todos'); // returns array of json
let todos = cachedTodos.map(todo => Todo.hydrate(todo)); // converts in to mongoose model

let incompleteTodos = todos.filter(todo => !todo.isDone);

DEV Community: prakash chokalingam

Set up MongoDB primary and secondary with Docker.

Prerequisites for Running the Below docker-compose File

Spin a Framework-Free HTTP Router Server in Go 1.22 With Ease

Seamlessly Embed Files Into Your Go Binary

Usage

Envoy External Authorization with Golang GRPC service

Create a golang grpc based server:

main.go

Extend with go-control-plane protobuf

main.go

Last but not least, set up your Envoy

envoy.yml

prakashchokalingam / envoy_ext_auth_grpc_go

Working example of envoy external auth filter with go lang grpc service

Example repo to demonstrate Envoy External Authorization with Golang GRPC service

go_grpc_filter

go_simple_http

To run this example

Codebytes: REPL it with NestJs

Introduction to a stateful & maintainable React Local Storage hook

Namespacing & Configurations

other available storage configurations,

Defaults & States

update

reset

remove

Versions & Migrations

other highlights

checkout the sample apps

webcored / react-local-storage

A stateful react hook for browser storage

React Local Storage

Why?

Install

Usage

update

remove

reset

Sample app

Configurations

Codebytes: Shorter UUIDs with collision prediction using nanoid

Wait... This will blow your mind!

ai / nanoid

A tiny (124 bytes), secure, URL-friendly, unique string ID generator for JavaScript

Nano ID

Table of Contents

Codebytes: provide / inject is a bliss in vue3

Generating files with 'vue-cli-plugin-pod'

Why?

How?

Generate

Config

Rename

Delete

Extend

webcored / vue-cli-plugin-pod

Extended CLI to manage file templates for vue projects

vue-cli-plugin-pod

Refer

Installation

Generate

Rename

Delete

Config

Codebytes: How to mock upload files in the test cases

prakashchokalingam / fill-in-file

A test util that helps to fill files in your file input element

Codebytes: Caching mongoose models in Redis (MongoDB).