DEV Community: Jordan Soo Yen Yih

Bun - The fastest Javascript Runtime

Jordan Soo Yen Yih — Thu, 07 Jul 2022 11:01:54 +0000

Bun - the new Javascript runtime has just announced its first beta release and makes the claimed that it's significantly faster than Node and Deno, not just a little bit faster, but orders of magnitude faster. What makes Bun special?

Performance ⚡

It doesn't use the V8 engine but instead uses the JavaScriptCore from WebKit which is generally considered to be faster. In addition it's written in a low level programming language called ZIG that similar to C or Rust and the creator of Bun say ZIG the lack of hidden control flow makes it much simpler to write fast software.

All-IN-ONE Runtime 🎁

Native module bundler to replace tools like Webpack.
Native transpiler to support Typescript code out of the box.
Top level await (just like Deno🦖)
Auto transpile JSX files
Supports WebAPI like fetch, WebSocket and ReadableStream
Supports many Node core modules as well as Node API which will allow many NPM packages also work in Bun.
Implements Node.js' module resolution algorithm, means you can install packages from npm into bun and those packages install 20x faster.⚡😲
Environment variables load automatically, no more dotenv.
Native test runner like Jest.

Try it out, if you are using Windows, you are required to use WSL to install Bun.

Thank you for reading.

Temporal instead of Date

Jordan Soo Yen Yih — Sat, 02 Apr 2022 09:35:09 +0000

JavaScript Date is fundamentally specified as the number of milliseconds that have elapsed since the ECMAScript epoch, which is defined as January 1, 1970, UTC. However, there are some problems with the current JavaScript Date implementation.

Problems 😵:

No support for time zones other than the user's local time and UTC.
Parser behavior so unreliable it is unusable.
Date object is mutable.
DST behavior is unpredictable.
Computation APIs are unwieldy.
No support for non-Gregorian calendars.

Actually some of the issues mentioned are fixable, we just need to add some new factory functions or make APIs to Date. Recently, there is a new API update called Temporal API that's going to completely revolutionize dates. Currently Temporal API is in Stage 3 means it's almost finalized. Do check it out and you may report bugs here. As it is still in experimental stage, it shouldn't be use in production.

The temporal API brings a new global object called Temporal to JavaScript that includes a lot of new methods and multiple new classes for handling a variety of date based concerns. In this article, I will cover some of the API that I personally think may often use, if you wish to know more about this API, please check out the full docs

Temporal API Data Types

There are various different data types introduced in the new temporal API, but the majority of new data types are split between plain and zoned version. The only difference between these two types is plain represents a date/time with no timezone information. A zoned datetime on the other hand represents a specific date and time in a specific timezone. Besides that, there are also other data types such as Duration, TimeZone and Calendar.

PlainDateTime 📆⌚

It is an object represents a date and time with no timezone information. It uses the current date and time from the timezone you pass to the method, or your current local timezone if no timezone is passed to the method.

const today = Temporal.Now.plainDateTimeISO()
console.log(today.toString())
// 2022-04-02T15:54:14.92305492

const date = new Temporal.PlainDateTime(2022, 1, 1)
console.log(date.toString())
// 2022-01-01T00:00:00

const date1 = Temporal.PlainDateTime.from("2022-01-01")
console.log(date1.toString())
// 2022-01-01T00:00:00
const date2 = Temporal.PlainDateTime.from({ year: 2022, month: 1, day: 1 })
console.log(date2.toString())
// 2022-01-01T00:00:00

PlainDate 📆

A PlainDate object represents just a date with no other information.

const today = Temporal.Now.plainDateISO()
console.log(today.toString())
// 2022-02-21

const date1 = Temporal.PlainDate.from("2022-01-01")
console.log(date1.toString())
// 2022-01-01
const date2 = Temporal.PlainDate.from({ year: 2022, month: 1, day: 1 })
console.log(date2.toString())
// 2022-01-01

PlainTime ⌚

A PlainTime object represents a time that has no timezone and no date.

const today = Temporal.Now.plainTimeISO()
console.log(today.toString())
// 16:09:22.283962281

const time1 = Temporal.PlainTime.from("04:03:25")
console.log(time1.toString())
// 04:03:25
const time2 = Temporal.PlainTime.from({ hour: 4, minute: 3, second: 25 })
console.log(time2.toString())
// 04:03:25

ZonedDateTime 🗺

A ZonedDateTime is a datetime that contains all timezone related information.

const today = Temporal.Now.zonedDateTimeISO()
console.info(today.toString())
// 2022-04-02T15:54:14.306655305[America/Chicago]

const date1 = Temporal.ZonedDateTime.from("2022-01-01[America/Los_Angeles]")
console.log(date1.toString())
// 2020-01-01T00:00:00-08:00[America/Los_Angeles]

const date2 = Temporal.ZonedDateTime.from({ year: 2022, month: 1, day: 1, timeZone: "America/Los_Angeles" })
console.log(date2.toString())
// 2020-01-01T00:00:00-08:00[America/Los_Angeles]

Instant ⚡

Instant is similar to ZonedDateTime but it is always in UTC time and does not take into account any particular calendar.

const today = Temporal.Now.instant()
console.log(today.toString())
// 2022-04-02T08:24:41.434881434Z

const date = Temporal.Instant.from("2022-01-01-06:00")
console.log(date.toString())
// 2022-01-01T06:00:00Z

PlainMonthDay

Just like PlainDate but it does not include any year information.

const date1 = Temporal.PlainMonthDay.from("01-01")
console.log(date1.toString())
// 01-01
const date2 = Temporal.PlainMonthDay.from({ month: 1, day: 1 })
console.log(date2.toString())
// 01-01

PlainYearMonth

Just like PlainDate but it does not include any day information.

const date1 = Temporal.PlainYearMonth.from("2022-01")
console.log(date1.toString())
// 2022-01
const date2 = Temporal.PlainYearMonth.from({ year: 2022, month: 1 })
console.log(date2.toString())
// 2022-01

Helper Methods 🛠

There are a number of helper functions we can use to solve the common use cases such as add or subtract date or date comparison.

add ➕ / subtract ➖

As in Javascript, adding or subtracting is really annoying to do, but with temporal API all the data types have built in add and subtract methods that make it incredibly easy.

const today = Temporal.Now.plainDateISO()
console.log("Today: " + today.toString())
console.log("Result: " + today.add({ days: 7, months: 1 }).toString())

// Today: 2022-04-02
// Result: 2022-05-09

equals

A simple method to check whether two temporal date objects have the exact same fields.

const today = Temporal.Now.plainDateISO()
const today2 = Temporal.Now.plainDateISO()
console.log(today === today2)
// false
console.log(today.equals(today2))
// true

with

with method takes in an object of fields to overwrite on the current date object.

const today = Temporal.Now.plainDateISO()
console.info(today.toString())
console.log(today.with({ year: 2027, month: 3 }).toString())
// 2022-04-02
// 2027-03-02

compare ⚖

As method named, we can use the compare method to compare with temporal date object or ISO 8601 string.

const today = Temporal.Now.plainDateISO()
const yesterday = today.subtract({ days: 1 })
const tomorrow = '2022-04-03'
console.log([today, yesterday, tomorrow].sort(Temporal.PlainDate.compare))

// [Temporal.PlainDate <2022-04-01>, Temporal.PlainDate <2022-04-02>, '2022-04-03']

Conclusion

Temporal API is a great API for JavaScript to deal with dates. There are currently no browsers with any support for this API yet as it is still in proposal stage 3, but you can use a polyfill if you want to try with this API. There are multiple polyfills available for this API, the one I am using is @js-temporal/polyfill. Thank you for your reading.

How easy to setup Master-master replication in CouchDB

Jordan Soo Yen Yih — Fri, 18 Feb 2022 13:07:06 +0000

Database replication is the process of copying data from a database in one computer or server to a database in another. It is very common if we want to scale our database to increase the availability to access the data. The result is a distributed database in which users can quickly access data relevant to their tasks.

The most common and classic method of database replication is Single-leader based data replication aka Master-slave Replication - one server that receives writes from clients, and replicas draw data from there. It provides read scalability, reduced latency and better availability as compared to no replication. However, the write of data is not scalable as read. We can only write data to the master node, and read from the slave node. This flaw paves way for multi-leader and leaderless replication.

Multi-leader based data replication aka Master-master replication, same as single-leader replication, the only different is it has more than one node to accept writes.

Today I would like to share about how easy to setup Master-master replication in CouchDB. One of CouchDB's strengths is the ability to synchronize two copies of the same database. We can trigger a replication process by sending a JSON object either to the /_replicate api endpoint or storing it as a document into the _replicator database.

Let say we have a database called cars in Server A and we would like to to replicate the cars database to Server B.

POST /_replicate

{
   "create_target": false,
   "continuous": false,
   "source": {
      "url": "http://SERVER_A_HOSTNAME:5984/cars",
      "headers": {
         "Authorization": "YOUR_SERVER_A_CREDENTIAL"
      }
   },
   "target": {
      "url": "http://SERVER_B_HOSTNAME:5984/cars",
      "headers": {
         "Authorization": "YOUR_SERVER_B_CREDENTIAL"
      }
   }
}

I personally recommend document based-replication, by storing document to trigger the replication process as you can review back the replication history and you can stop a running replication process by deleting the document, or by updating it with its cancel property set to true.

For specifying username and password, if you are using CouchDB v3.2.* , there are 3 ways to specify your username and password:

In an "auth": { "basic": "..." } object:

{
    "target": {
        "url": "http://someurl.com/mydb",
        "auth": {
            "basic": {
                "username": "$username",
                "password": "$password"
             }
        }
    },
    ...
}

In the userinfo part of the endpoint URL:

{
    "target":  "http://user:pass@localhost:5984/bar"
    ...
}

In an "Authorization: Basic $b64encoded_username_and_password" header:

{
    "target": {
        "url": "http://someurl.com/mydb",
            "headers": {
                "Authorization": "Basic dXNlcjpwYXNz"
            }
        },
    ...
}

If you are using the CouchDB earlier version < v3.2, you can only use the second and third method to specify the username and password. Second method is not preferred as it prevents using characters like @ and : in usernames or passwords.

After we triggered a replication process, we can inspect CouchDB replication status through the active tasks API /_active_tasks and /_scheduler/jobs. For document based-replications, /_scheduler/docs can be used to get a complete state summary. This API is preferred as it will show the state of the replication document before it becomes a replication job.

If the database doesn't exist in the target CouchDB server, we can set the create_target property to true, it will helps us to create a new database and start replicate the data from the source database. For Master-master replication setup, we would like to setup a long running replication instead of one time off, just set the continuous property to true.

POST /_replicator

{
   "create_target": false,
   "continuous": true,
   "source": {
      "url": "http://SERVER_A_HOSTNAME:5984/cars",
      "headers": {
         "Authorization": "YOUR_SERVER_A_CREDENTIAL"
      }
   },
   "target": {
      "url": "http://SERVER_B_HOSTNAME:5984/cars",
      "headers": {
         "Authorization": "YOUR_SERVER_B_CREDENTIAL"
      }
   }
}

Once we has triggered a continuous database replication from Server A to Server B, then we can trigger one more continuous database replication from Server B to Server A by switching the source and target url.

POST /_replicator

{
   "create_target": false,
   "continuous": true,
   "source": {
      "url": "http://SERVER_B_HOSTNAME:5984/cars",
      "headers": {
         "Authorization": "YOUR_SERVER_A_CREDENTIAL"
      }
   },
   "target": {
      "url": "http://SERVER_A_HOSTNAME:5984/cars",
      "headers": {
         "Authorization": "YOUR_SERVER_B_CREDENTIAL"
      }
   }
}

🎉That's it, now we have both cars databases in Server A and Server B in sync. We can even control which documents to be replicate by using Selector Objects or Filter Functions.
For more detail about CouchDB Replication, please check out the official documentation. Thank you for reading.

New Node.js protocol imports

Jordan Soo Yen Yih — Thu, 20 Jan 2022 12:39:38 +0000

node: is a new protocol imports for loading Node.js built-in modules. Actually it has been there for a while since Node.js v12. However I just heard about this few days ago.😲 Let's find out together how to use this new node: protocol.

Previously

import * as fs from 'fs/promises';

Now

import * as fs from 'node:fs/promises';

Benefits of `node:` imports✨

It resolved the conflict of a module (npm-installed) in node_modules overriding the built-in module. Besides that, it is also clear that a built-in Node.js module is imported.

Supported Node.js versions

v16.0.0, v14.18.0 (ESM import and CommonJS require())
v14.13.1, v12.20.0
Supported in TypeScript by the latest versions of @types/node(>= v16.0.0).

That's it, if this is new to you too, hope you find this useful. Thank you for reading. Please check out the official documentation too

How to easily deal with domain object in Redis

Jordan Soo Yen Yih — Wed, 12 Jan 2022 15:16:48 +0000

Redis, is a mega fast🚀 Open Source in-memory database often used as a cache and to make traditional databases faster. However, most of the developers don't know that redis can also be used as a primary app database. Thanks to a suite of modules that add additional data structures and commands to core redis. Check out the redis modules here.

At the end of 2021, Redis announced a preview release of a new high-level client libraries for Redis, called Redis OM🎉. The main goal is to make developers as easy as possible to use Redis and the Redis modules. Currently it supports for .NET, Node.js, Python, and Java (Spring).

Today, I would like to share about how to use Redis OM in Nodejs.

Installation ✨

npm install --save redis-om

After install, we can import the redis-om in our Node.js project.

import { Client, Entity, Repository, Schema } from "redis-om"

These are the 4 classes that we will deal a lot.

Client Usage 🤝

Client is the main entry point for interacting with Redis. First we initialize a client. Then to connect to our Redis database, we call client open followed by our Redis url.

const client = new Client();

await client.open("redis://<YOUR_REDIS_HOST>:<YOUR_REDIS_PORT>");

If we didn't provide the connection string, by default it uses localhost:6379

Now we ready to talk to redis with the client. Underlying, Redis OM will automatically helps us to serialize and deserialize our structures to redis.

However, we still can run basic Redis commands. For example if we want to clean the redis instance, we can use the execute method to run our Redis command:

await client.execute(['FLUSHALL']);

To close the redis connection, simply call close method with the client instance.

await client.close();

Entity Usage 👮‍♂️

We can define an entity for our data with the Entity class. An entity is basically like a database table. For example we can define a class such as Person or Animal, then extend it with Entity class.

class Person extends Entity {
  get dateAsISO() { return new Date(this.date).toISOString() }
}

Inside the class, we can define some custom functions based on use cases. For example we can define a function to convert our data date field to ISO. It is sort of like computed fields we can use after we fetched our data.

Schema Usage 📜

After we created an entity, we can give it a schema that contains a variety of different properties each with it own data type.

let schema = new Schema(
   Person,
   {
      name: { type: "string" },
      age: { type: "number" },
      gender: { type: "string" },
      createdAt: { type: "number" }
   },
   {
      dataStructure: "JSON"
   }
)

By default, the data represents a hash in the redis database. To use the RedisJSON module, add an object with key dataStructure and value JSON in the third parameter when initializing the schema.

Repository Usage 🛠

Repository is the one for us to perform Create, Read, Update, and Delete. To create a repository, we need to pass in the schema and the client we created earlier.

const repository = new Repository(schema, client);

Create New Data ➕

To create a new data, we can use createEntity method and pass in a javascript object.

const data = { name: "John Doe", age: 20, gender: "male", createdAt: Date.now() };

const person = repository.createEntity(data);

Then we can call save method with the person data to commit into the database and redis will return an automatically generated unique id. Redis OM is using ULIDs (Universally Unique Lexicographically Sortable Identifiers). You can think of a ULID as a kind of user-friendly UUID. ULIDs are sortable, globally unique, URL-safe, and fairly human-readable when base32-encoded.

const id = await repository.save();

console.info(`ID : ${id}`);

// ID : 01ARZ3NDEKTSV4RRFFQ69G5FAV

Read Data 👀

We can read the data with fetch method.

const person = await repository.fetch(id);

Create Index 📝

Before we search our data, we need to create an index for our data. we can call createIndex method with the repository.

// Create Index
await repository.createIndex();

// Drop Index
await repository.dropIndex();

Search Data 🔍

Using RediSearch with Redis OM is where the power of this fully armed and operational battle station starts to become apparent. If you have RediSearch installed on your Redis server you can use the search capabilities of Redis OM. This enables commands like:

const oneDay = Date.now() - 24 * 60 * 60 * 1000;

let persons = await repository.search()
  .where('createdAt').is.greaterThan(oneDay)
  .and('name').matches('john')
  .and('age').equals(20).return.all();

Remove Data 🗑

await repository.remove(id);

That's it

Now we can easily create a CRUD application with Redis. Do checkout the redis-om-node Github too for more detail on how to use Redis OM in Node.js.

CouchDB clients in Javascript

Jordan Soo Yen Yih — Sun, 19 Dec 2021 07:42:11 +0000

Apache CouchDB is an open source NoSQL document database that collects and stores data in JSON-based document formats. Since CouchDB makes use of HTTP protocol, therefore we can use any HTTP client to connect with CouchDB. However, there are some existing CouchDB client libraries that are very easy and convenience to use. Below I would like to share 3 libraries that I frequent use to connect with CouchDB.

1. Nano

The Offical Apache CouchDB library for Node.js.

Setup

npm install --save nano

Connect to CouchDB server

const nano = require('nano')('http://localhost:5984');

Create a new database

nano.db.create('blogs');

Use an existing database

const blogs = nano.db.use('blogs');

That's it, easy peasy.😎 Now we can perform some queries with blogs. nano underlying is making HTTP API calls to CouchDB service. Such operations are asynchronous, we can use either Promises or Callbacks to receive the asynchronous data back from the library.

Promises

blogs.get('post-A').then(response => {
  // succeeded
  console.info(response);
}).catch(err => {
  // failed
  console.error(err)
})
});

// OR

try {
  const response = await blogs.get('post-A')
  // succeeded
  console.log(response)
} catch (e) {
  // failed
  console.error(e)
}

Callbacks

blogs.get('post-A', (err, data) => {
  // errors are in 'err' & response is in 'data'
})

Nano even supports stream which mean we can proxy the whatever requests from CouchDB to the end user.

blogs.listAsStream()
  .on('error', (e) => console.error('error', e))
  .pipe(process.stdout)

Pros:

Easy to use.
CouchDB API compatible.
Supports Stream.
The vast majority of library calls return native Promises.
Detailed TypeScript definitions are built in.
Easy to debug as errors are proxied directly from CouchDB: if you know CouchDB you already know nano.

Cons:

Cannot use in browser. Only Nodejs.

2. PouchDB

An open-source JavaScript database inspired by Apache CouchDB that is designed to run well within the browser. However, PouchDB also runs in Node.js and can be used as a direct interface to CouchDB-compatible servers. The API works the same in every environment, so you can spend less time worrying about browser differences, and more time writing clean, consistent code.

Setup

// For browser
npm install pouchdb-browser

// For Node
npm install pouchdb-node

PouchDB supports custom builds, meaning you can pick and choose the features of PouchDB that you want to use, potentially resulting in smaller bundle sizes and faster build times. Both pouchdb-browser and pouchdb-node contains the replication, HTTP, and map/reduce plugins. I personally prefer pick and choose the features of PouchDB I want instead of using pouchdb-browser or pouchdb-node.

For example:

const PouchDB = require('pouchdb-core')
  .plugin(require('pouchdb-adapter-http'))
  .plugin(require('pouchdb-mapreduce'))
  .plugin(require('pouchdb-replication'));

Connect to a CouchDB database

const blogs = new PouchDB('http://localhost:5984/blogs');

Create a new database

const blogs = new PouchDB('blogs');

Query

PouchDB also supports Promises and Callbacks

blogs.get('post-A').then(doc => {
  // handle doc
}).catch(err => {
  console.log(err);
});

// OR

try {
  const doc = await blogs.get('post-A');
} catch (err) {
  console.log(err);
}

blogs.get('post-A', function(err, doc) {
  if (err) { return console.log(err); }
  // handle doc
});

Pros:

Easy to learn & use.
Works in all modern browsers and Nodejs.
Lightweight
Support Offline
Support Custom Builds / Plugins

Cons:

Not fully support CouchDB API, one of the example is you cannot use CouchDB's update function via PouchDB.
Official library doesn't come with Stream. However, since PouchDB supports custom builds, you still can do stream with external PouchDB projects.

There is a a list of known plugins, tools and projects can be used with PouchDB. You can find it here

3. Axios

If you are a javascript developer, you should probably already know about axios. It is a Promise based HTTP client for the browser and node.js.

Setup

npm install --save axios

Connect to CouchDB server

const couchdb = axios.create({
  baseURL: 'http://localhost:5984',
  timeout: 1000,
  headers: { 'X-Custom-Header': 'foobar'}
});

Create a new database

couchdb.put('/blogs').then(response => {
  // succeeded
}).catch(err => {
  // failed
});

// OR

try {
  const response = await couchdb.put('/blogs');
  console.info(response.data);
} catch (err) {
  console.error(err);
}

Query

couchdb.get('/blogs/post-A').then(response => {
  console.info(response.data);
}).catch(err => {
  console.error(err);
});

// OR

try {
  const response = await couchdb.get('/blogs/post-A');
  console.info(response.data);
} catch (err) {
  console.error(err);
}

Pros:

Works in all modern browsers and Nodejs.
Supports the Promise API
Intercept request and response
Transform request and response data
Cancel requests
Automatic transforms for JSON data

Cons:

Codes are not as clean/minimal as PouchDB. In order to achieve minimal of code with axios, you will need to spend extra time to build your own factory functions on top of axios.

Thanks for Reading.

If you know any other interesting libraries that play well with CouchDB, please leave comments below to share with me. Thank you.☺

10 useful Git tips to improve your workflow

Jordan Soo Yen Yih — Sat, 11 Dec 2021 12:20:02 +0000

Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

Whether you’re just getting started with Git, or you know your way around a command line, it’s always nice to brush up on your skills. Below I would like to share 10 useful Git tips to improve your Git-based workflow.

1. Git aliases 🏷

Create your own aliases for common commands to save you some time in the terminal.

git config --global alias.co checkout
git config --global alias.ci commit
git config --global alias.br branch

Instead of typing git checkout master, you only need to type git co master.

You could also edit these commands or add more by modifying the ~/.gitconfig file directly:

[alias]
    co = checkout
    ci = commit
    br = branch

2. Compare commits ⚖

A simple way to compare the differences between commits or versions of the same file is to use the git diff command.

If you want to compare the same file between different commits, you run the following:

git diff $start_commit..$end_commit -- path/to/file

If you want to compare the changes between two commits:

git diff $start_commit..$end_commit

These commands will open the diff view inside the terminal, but if you prefer to use a more visual tool to compare your diffs, you can use git difftool. Meld is a useful viewer/editor to visually compare diffs.

To configure Meld:

git config --global diff.tool git-meld

To start viewing the diffs:

git difftool $start_commit..$end_commit -- path/to/file

git difftool $start_commit..$end_commit

3. Stashing uncommitted changes 🔖

If you’re ever working on a feature and need to do an emergency fix on the project, you could run into a problem.😰 You don’t want to commit an unfinished feature, and you also don’t want to lose current changes. The solution is to temporarily remove these changes with the Git stash command:

git stash

The git stash command hides changes, giving you a clean working directory and the ability to switch to a new branch to make updates, without having to commit a meaningless snapshot in order to save the current state.

Once you’re done working on a fix and want to revisit your previous changes, you can run:

git stash pop

And your changes will be recovered. 🎉

If you no longer need those changes and want to clear the stash stack, you can do so with:

git stash drop

4. Pull frequently 📥

In order to avoid major conflicts, you should frequently pull the changes from the master branch to your branch to resolve any conflicts as soon as possible and to make merging your branch to master easier.

5. Autocomplete commands 🤖

Using completion scripts, you can quickly create the commands for bash, tcsh and zsh. If you want to type git pull, you can type just the first letter with git p followed by Tab will show the following:

pack-objects   -- create packed archive of objects
pack-redundant -- find redundant pack files
pack-refs      -- pack heads and tags for efficient repository access
parse-remote   -- routines to help parsing remote repository access parameters
patch-id       -- compute unique ID for a patch
prune          -- prune all unreachable objects from the object database
prune-packed   -- remove extra objects that are already in pack files
pull           -- fetch from and merge with another repository or local branch
push           -- update remote refs along with associated objects

To show all available commands, type git in your terminal followed by Tab + Tab.

6. Set a global `.gitignore` 🚫

If you want to avoid committing files like .DS_Store or Vim swp files, you can set up a global .gitignore file.

Create the file:

touch ~/.gitignore

Then run:

git config --global core.excludesFile ~/.gitignore

Or manually add the following to your ~/.gitconfig:

[core]
  excludesFile = ~/.gitignore

You can create a list of the things you want Git to ignore. To learn more, visit the gitignore documentation.

7. Delete local branches that have been removed from remote on fetch/pull 🗑

You likely have stale branches in your local repository that no longer exist in the remote one. To delete them in each fetch/pull, run:

git config --global fetch.prune true

Or manually add the following to your ~/.gitconfig:

[fetch]
  prune = true

8. Use Git blame more efficiently 🕵️‍♂️

Git blame is a handy way to discover who changed a line in a file. Depending on what you want to show, you can pass different flags:

git blame -w  # ignores white space

git blame -M  # ignores moving text

git blame -C  # ignores moving text into other files

9. An alias of `HEAD` 👀

@ is the same as HEAD. Using it during a rebase is a lifesaver:

git rebase -i @~2

10. Resetting files ↩

You’re modifying your code when you suddenly realize that the changes you made are not great, and you’d like to reset them. Rather than clicking undo on everything you edited, you can reset your files to the HEAD of the branch

git reset --hard HEAD

Or if you want to reset a single file:

git checkout HEAD -- path/to/file

Now, if you already committed your changes, but still want to revert back, you can use:

git reset --soft HEAD~1

Extras: ✨

If you want to elevate Git with more commands, try out the git-extras plugin, which includes git info (show information about the repository) and git effort (number of commits per file).

How to setup Clouseau for CouchDB search on Unix-like systems

Jordan Soo Yen Yih — Tue, 23 Nov 2021 13:40:36 +0000

Introduction

Clouseau is written in Scala code and provides access to the Lucene library. You can use Lucene Query Syntax to run search queries. In previous article I did talk about we can query in Apache CouchDB with Clouseau, today I would like to talk about how to setup Clouseau that link with CouchDB.

Prerequisites📜

Before you begin this guide, you should have a regular, non-root user with sudo privileges configured on your server. Additionally, you will need to have a up and running CouchDB version v3+ on your server. You can learn how to install Apache CouchDB on Unix-like systems by following the official documentation here. Besides that, since Clouseau is written in Scala, we also need to install Java to run Clouseau.

The search plugin is runtime-compatible with Java JDKs 6, 7 and 8. Building a release from source requires JDK 6. It will not work with any newer version of Java.

In this tutorial, I am using Ubuntu 20.04, JDK 8 and CouchDB v3.2.1 . CouchDB v3 and higher is a must as CouchDB v3 has extremely simplified the setup of Lucene search.

1. Download Clouseau

You can download the latest Clouseau release from here. Your Clouseau might be different depending on the time you download. My current latest version is Clouseau 2.17.0. I am using wget to download from my Ubuntu server.

sudo wget https://github.com/cloudant-labs/clouseau/releases/download/2.17.0/clouseau-2.17.0-dist.zip

2. Extract Clouseau zip

We are using unzip to extract the Clouseau jar files.

Tips: If you don't have unzip, you can run the command sudo apt-get install unzip for Ubuntu.

Then, we can unzip it with the command below:

sudo unzip clouseau-2.17.0-dist.zip -d /opt/

As you can see, we extract the Clouseau to the destination /opt/
. Now we can navigate to the extracted destination and view the extracted files.

cd /opt/clouseau-2.17.0/

3. Create Configuration files

According to CouchDB official documentation, in order to setup the search plugin, there are 2 configuration files required called clouseau.ini and log4j.properties with the following content:

clouseau.ini

[clouseau]

; the name of the Erlang node created by the service, leave this unchanged
name=clouseau@127.0.0.1

; set this to the same distributed Erlang cookie used by the CouchDB nodes
cookie=monster

; the path where you would like to store the search index files
dir=/opt/couchdb/share/

; the number of search indexes that can be open simultaneously
max_indexes_open=500

log4j.properties

log4j.rootLogger=debug, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %c [%p] %m%n

4. Create a script to run Clouseau

Below is the script to run Clouseau. If you have a Java background, below syntax should be familiar for you. In this case, I will place the script file under /opt/clouseau-2.17.0/bin/ and the file name called clouseau, full path would be /opt/clouseau-2.17.0/bin/clouseau

#!/bin/sh
/usr/bin/java -server \
     -Xmx2G \
     -Dsun.net.inetaddr.ttl=30 \
     -Dsun.net.inetaddr.negative.ttl=30 \
     -Dlog4j.configuration=file:/opt/clouseau-2.17.0/log4j.properties \
     -XX:OnOutOfMemoryError="kill -9 %p" \
     -XX:+UseConcMarkSweepGC \
     -XX:+CMSParallelRemarkEnabled \
     -classpath '/opt/clouseau-2.17.0/*' \
     com.cloudant.clouseau.Main \
     /opt/clouseau-2.17.0/clouseau.ini

Your path could be different, it depends on where you put the clouseau files, you could change the /opt/clouseau-2.17.0/ if needed, in this case, I'm putting all the clouseau files and configurations under /opt/clouseau-2.17.0 directories.

We are almost there. Now we want to tell Ubuntu to run the service when the server startup. To do that, we can navigate to /lib/systemd/system

cd /lib/systemd/system

and create a file called clouseau.service with the content below:

[Unit]
Description=clouseau service

[Service]
WorkingDirectory=/opt/clouseau-2.17.0
ExecStart=/opt/clouseau-2.17.0/bin/clouseau
Restart=always
RestartSec=3
User=root

[Install]
WantedBy=multi-user.target

Once created, then run the 3 commands below:

sudo systemctl daemon-reload

sudo systemctl enable clouseau.service

sudo systemctl start clouseau

Then, Clouseau should already be up and running. Check with the systemd init system to make sure the service is running by typing

sudo systemctl status apache2

Finally, we can check whether our Apache CouchDB and Clouseau is connected by using CouchDB root endpoint.

curl 127.0.0.1:5984

If Clouseau is connected to CouchDB successfully, You should see the search keyword display under features.

That's it, we did it~🎉

Now we can query with Lucene Query Syntax in CouchDB.
Hope you find this guide useful.👋

CSS Variables

Jordan Soo Yen Yih — Sat, 20 Nov 2021 11:13:02 +0000

CSS variables aka custom properties allows you to reuse values throughout your stylesheet. It increases your efficiency, reduce code duplication and a lot of cool tricks you could do with them.🤩

Global Variables

We can define global variables that will be use throughout the entire website on the root element.

:root {
   --warning-color: yellow; 

   /* Format --<YOUR_VARIABLE_NAME>: <ANY_CSS_VALUE> */
}

Start with the double dash, followed by whatever name you want to use for the variable. Then you can use any valid CSS value.

Then you can use the variable with the var function.

body {
   color: var(--warning-color);
}

Tips: When calling a CSS variable with the var function, You can pass in a second argument as a fallback value.

body {
   color: var(--warning-color, red);
}

As example above, if the variable is undefined or invalid CSS value, then it will use red instead.

Now by using the CSS Variables, when we want to change the value, we just need to update once instead of go through every places.

Variable Cascade Downwards

We can override the Global CSS variables value in the children. Let's say we have a global variable in previous example, and we have a card class that change the --warning-color variable to red. So the HTML element with this card class will use the red value instead of yellow value.

/* Global */
:root {
   --warning-color: yellow;
}

/* Local */
.card {
   --warning-color: red;
}

That means we can change the appearance of our website by simply tweaking CSS Variables value. This concept very powerful when combine with Media Queries💪.

For example if the viewport is smaller, you may want to decrease the margin between HTML elements instead of updating potential more than 100 CSS classes😵🤯, just define a media query and change the CSS variables value.

@media screen and (min-width: 600px) {
   :root {
      --margin-base: 10px;
   }
}

/* Small Screens */
@media screen and (max-width: 600px) {
   :root {
      --margin-base: 6px;
   }
}

Another example is we can use the prefers-color-scheme media query to toggle between light theme and dark theme based on the user's device preferences.

@media (prefers-color-scheme: dark) {
    :root {
       --text-color: white;
       --background-color: black;
    }
}

Besides that, CSS variables also work great with calc

.my-title {
   --regular-number: 8;

   margin: calc( var(--regular-number) * 1px );
}

Besides that, you are not limited to use a single variable in a property value. For example below we can define several variables.

:root {
   --red: 86;
   --green: 23;
   --blue: 107;
}

.content-card {
   color: rgb( var(--red), var(--green), var(--blue) );
}

This makes CSS Variables extremely useful on building themes. This is because when we combine with Javascript and change the CSS classes on the fly, then the browser will automatically repaint the style of the website.✨🤩

Thanks for reading.

Above is what I learnt about CSS Variables and how to apply them. If you have any other interesting way on using CSS Variables, please comment below to share with me.🙏😊

Query in Apache CouchDB: Clouseau

Jordan Soo Yen Yih — Mon, 15 Nov 2021 13:14:01 +0000

In previous articles, we have talk about how to query with CouchDB Views and Mango Query. Both methods are working very well and able to cover a lot of use cases. Why Clouseau?

There are still very limited for CouchDB Views and Mango Query when we talk about search, there are a lot of complex searching required which makes the Views function and Mango Index more complex and harder to build, at the same time need to have a great search performance. You are still able to build your own search engine from scratch with Mango and Views. However it is very tough and you have to put a lot of resources to build a good search engine, ton of work like text preprocessing, tokenization, algorithm, ranking and etc...😰

Thanks to Clouseau brought CouchDB search to the next level🥳

Start from CouchDB v3, CouchDB can build and query full-text search indexes using an external Java service that embeds Apache Lucene. If you have been already familiar with Elasticsearch, then it is very easy for you to catch up with CouchDB + Clouseau as they are using the same Lucene Syntax.

Installation

To setup Clouseau works together with CouchDB, you may refer to my tutorial post or the official docs here.

How to use?

It is like Mango Query, create a design document for the search index function, then search with the index function.

Example Search Index Function:

function(document) {
    index("default", document._id);
    if (document.title) {
        index("title", document.title, {"store": true});
    }
    if (document.status) {
        index("status", document.status, { "store": false });
    }
}

Design Document in full view:

{
  "_id": "_design/search",
  "_rev": "1-15807c8c7e310b566c0a41997d79b7fd",
  "views": {},
  "language": "javascript",
  "indexes": {
    "posts": {
      "analyzer": "standard",
      "index": "function(doc) {\r\n    index(\"default\", doc._id);\r\n    if (doc.status) {\r\n        index(\"status\", doc.status, { \"store\": false });\r\n    }\r\n    if (doc.title) {\r\n        index(\"title\", doc.title, {\"store\": true});\r\n    }\r\n}"
    }
  }
}

Above search index function allows us to search with document ID, title and status. By default it is searching with document ID if we didn't provide any key. The "store" with boolean we pass in in the third argument is to indicate whether you want to return the value in the search result, the default value is false.

GET /YOUR_DATABASE_NAME/_design/search/_search/posts?q=ea885d7d-7af2-4858-b7bf-6fd01bcd4544

Result:

{
  "total_rows": 1,
  "bookmark": "g2wAAAABaANkABFjb3VjaGRiQDEyNy4wLjAuMWwAAAACYQBuBAD_____amgCRj_6gH-AAAAAYQFq",
  "rows": [
    {
      "id": "ea885d7d-7af2-4858-b7bf-6fd01bcd4544",
      "order": [
        1.6563715934753418,
        1
      ],
      "fields": {
        "title": "Post Two Title"
      }
    }
  ]
}

Let us try to search with post's status:

GET /YOUR_DATABASE_NAME/_design/search/_search/posts?q=status:submitted

Result:

{
  "total_rows": 2,
  "bookmark": "g2wAAAABaANkABFjb3VjaGRiQDEyNy4wLjAuMWwAAAACYQBuBAD_____amgCRj_0mliAAAAAYQJq",
  "rows": [
    {
      "id": "c2ec3b79-d9ac-45a8-8c68-0f05cb3adfac",
      "order": [
        1.287682056427002,
        0
      ],
      "fields": {
        "title": "Post One Title"
      }
    },
    {
      "id": "4a2348ca-f27c-427f-a490-e29f2a64fdf2",
      "order": [
        1.287682056427002,
        2
      ],
      "fields": {
        "title": "Post Three Title"
      }
    }
  ]
}

Analyzers📈

Analyzers are settings that define how to recognize terms within text. Analyzers can be helpful if you need to index multiple languages.

There are 6 analyzers that are supported by the search:

classic - The standard Lucene analyzer, circa release 3.1.
email - Like the standard analyzer, but tries harder to match an email address as a complete token.
keyword - Input is not tokenized at all.
simple - Divides text at non-letters.
standard - The default analyzer. It implements the Word Break rules from the Unicode Text Segmentation algorithm
whitespace - Divides text at white space boundaries.

Based on your use cases to pick the suitable analyzer for your search index.

Geographical Searches🗺

Besides that, you can also do geographical searches in CouchDB with Lucene's built-in geospatial capabilities.😍

Example geographical data:

{
    "name":"Aberdeen, Scotland",
    "lat":57.15,
    "lon":-2.15,
    "type":"city"
}

Example search index for the geographic data:

function(doc) {
    if (doc.type && doc.type == 'city') {
        index('city', doc.name, {'store': true});
        index('lat', doc.lat, {'store': true});
        index('lon', doc.lon, {'store': true});
    }
}

HTTP Request:

GET /YOUR_DATABASE_NAME/_design/YOUR_DESIGN_DOC_NAME/_search/SEARCH_INDEX_NAME?q=lat:[0+TO+90]&sort="<distance,lon,lat,-74.0059,40.7127,km>"

Abbreviated Result:

{
    "total_rows": 205,
    "bookmark": "g1A...XIU",
    "rows": [
        {
            "id": "city180",
            "order": [
                8.530665755719783,
                18
            ],
            "fields": {
                "city": "New York, N.Y.",
                "lat": 40.78333333333333,
                "lon": -73.96666666666667
            }
        },
        {
            "id": "city177",
            "order": [
                13.756343205985946,
                17
            ],
            "fields": {
                "city": "Newark, N.J.",
                "lat": 40.733333333333334,
                "lon": -74.16666666666667
            }
        },
        {
            "id": "city178",
            "order": [
                113.53603438866077,
                26
            ],
            "fields": {
                "city": "New Haven, Conn.",
                "lat": 41.31666666666667,
                "lon": -72.91666666666667
            }
        }
    ]
}

Thank you for reading.

There are more you can do with CouchDB search. Do checkout the official documentation here and also Lucene Syntax as CouchDB search query syntax is using the Lucene Syntax.😊

Query in Apache CouchDB: Mango Query

Jordan Soo Yen Yih — Sun, 31 Oct 2021 03:38:48 +0000

In previous articles, we talked about design documents and how to use views to query in CouchDB. Besides Javascript query server, CouchDB also has a built-in Mango query server for us to query documents. Therefore in this article, I will talk about what is Mango Query, and when to use Mango Query?

What is Mango 🥭?

Mango is a MongoDB inspired query language interface for Apache CouchDB.

Mango provides a single HTTP API endpoint that accepts JSON bodies via HTTP POST. These bodies provide a set of instructions that will be handled with the results being returned to the client in the same order as they were specified. The general principle of this API is to be simple to implement on the client side while providing users a more natural conversion to Apache CouchDB than would otherwise exist using the standard RESTful HTTP interface that already exists.

How to use mango query in CouchDB?

We use back the same use case example in previous articles (A list of blog posts):

[
  {
    _id: "c2ec3b79-d9ac-45a8-8c68-0f05cb3adfac",
    title: "\"Post One Title\","
    content: "Post one content.",
    author: "John Doe",
    status: "submitted",
    date: "2021-10-30T14:57:05.547Z",
    type: "post"
  },
  {
    _id: "ea885d7d-7af2-4858-b7bf-6fd01bcd4544",
    title: "\"Post Two Title\","
    content: "Post two content.",
    author: "Jane Doe",
    status: "draft",
    date: "2021-09-29T08:37:05.547Z",
    type: "post"
  },
  {
    _id: "4a2348ca-f27c-427f-a490-e29f2a64fdf2",
    title: "\"Post Three Title\","
    content: "Post three content.",
    author: "John Doe",
    status: "submitted",
    date: "2021-08-02T05:31:05.547Z",
    type: "post"
  },
  ...
]

If we want to query the posts with status draft, we can define the mango query as below:

{
    "selector": {
        "status": { "$eq": "draft" }
    },
    "fields": ["_id", "_rev", "title", "content", "date", "author"],
    "sort": [],
    "limit": 10,
    "skip": 0,
    "execution_stats": true
}

Let's us break down line by line before we submit our mango query.

1. Selector 🔎

This is the place you define your query condition, you can give it a document property key that you want to query and the result. With the example above we want to query documents with status "draft", so we can make use of the operator equal $eq .

"selector": {
   "status": { "$eq": "draft" }
}

// If it is an equal operator, we also can define as below too

"selector": {
   "status": "draft"
}

2. Fields 🎁

Sometimes you might just required a property value, or your document might be a big JSON document or you are working for mobile client that you want to optimize the query result download size. Therefore, fields is handy for us to tell CouchDB just return what property fields to us. Just like GraphQL, get what you needed.

"fields": ["_id", "_rev", "title", "content", "date", "author"],

Tips: Fields is Optional, if you didn't define fields, CouchDB will just return the whole document to you.

3. Sort, Limit, Skip

These are normal useful feature that you can do in other normal database. They are optional too.

"sort": [],
"limit": 10,
"skip": 0,

*Note: For limit by default is 25, however there is an internal maximum limit which is around 250 number of documents with a Mango Query request. Therefore, if you didn't define the limit or even set the limit to 1k, it will still return around 250 documents. To solve this issue, either use CouchDB Views for this particular query or use Bookmark (We will talk about bookmark later).

4. Execution Statistics

This is a nice feature for developer to know the basic execution statistics for the specific mango query request. It is Optional too.

And then we can post our mango query to

POST /{YOUR_DATABASE_NAME}/_find

Result:

{ 
   "docs": [
     {
         "_id": "ea885d7d-7af2-4858-b7bf-6fd01bcd4544",
         "_rev": "1-f9397a0bc5b6150270b5309db35ec4b9",
         "title": "Post Two Title",
         "content": "Post two content.",
         "date":"2021-09-29T08:37:05.547Z",
         "author":"Jane Doe"
      }
    ],
    "bookmark": "g1AAAAB4eJzLYWBgYMpgSmHgKy5JLCrJTq2MT8lPzkzJBYqrpCZaWJimmKfomiemGemaWJha6CaZJ6XpmqWlGBgmJaeYmJqYgPRywPQSrSsLAKuSIMM",
    "execution_stats": {
       "total_keys_examined":0,
       "total_docs_examined":1,
       "total_quorum_docs_examined":0,
       "results_returned":1,
       "execution_time_ms":2.253
    },
    "warning": "no matching index found, create an index to optimize query time"
}

Let's us take a look at the result.

1. Docs 📃

Here is the result we got from Mango Query.

"docs": [
     {
         "_id": "ea885d7d-7af2-4858-b7bf-6fd01bcd4544",
         "_rev": "1-f9397a0bc5b6150270b5309db35ec4b9",
         "title": "Post Two Title",
         "content": "Post two content.",
         "date":"2021-09-29T08:37:05.547Z",
         "author":"Jane Doe"
      }
    ],

2. Bookmark 🔖

This is the bookmark we mentioned earlier. Bookmark from official document is

A string that enables us to specify which page of results we require. Used for paging through result sets. Every query returns an opaque string under the bookmark key that can then be passed back in a query to get the next page of results. If any part of the selector query changes between requests, the results are undefined.

"bookmark": "g1AAAAB4eJzLYWBgYMpgSmHgKy5JLCrJTq2MT8lPzkzJBYqrpCZaWJimmKfomiemGemaWJha6CaZJ6XpmqWlGBgmJaeYmJqYgPRywPQSrSsLAKuSIMM"

As I mentioned earlier there is a maximum number of documents for the CouchDB Mango Query return result per request. So if you have result more than 250 and you want the next page result starts from 251, we can just get the current bookmark and put into our next Mango query.

For example:

{
    "selector": {
        "status": { "$eq": "draft" }
    },
    "bookmark": "g1AAAAB4eJzLYWBgYMpgSmHgKy5JLCrJTq2MT8lPzkzJBYqrpCZaWJimmKfomiemGemaWJha6CaZJ6XpmqWlGBgmJaeYmJqYgPRywPQSrSsLAKuSIMM"
}

3. Execution Statistics Result

As our above Mango Query "execution_stats" is set to true, so CouchDB will return the execution statistic report of this mango query request.

"execution_stats": {
   "total_keys_examined":0,
   "total_docs_examined":1,
   "total_quorum_docs_examined":0,
   "results_returned":1,
   "execution_time_ms":2.253
},

4. Warning

This is a kindly reminder from CouchDB that we didn't create an index for this mango query. Just like any other databases. It's always recommended that to create an appropriate index when deploying in production.

"warning": "no matching index found, create an index to optimize query time"

How to create a Mango Index?

Since we are getting the reminder from the above example, now we can create a Mango Index to optimize the query above. This is how a Mango Index looks like:

{
    "index": {
        "fields": ["status"]
    },
    "ddoc" : "posts-by-status",
    "type" : "json"
}

POST /{YOUR_DATABASE_NAME}/_index

After created our index, just define the design document name of the mango index in our mango query.

{
    "selector": {
        "status": { "$eq": "draft" }
    },
    "use_index": "posts-by-status"
}

Then you will no longer see the "warning" message from the return result.

Tips: To check or debug whether your mango index has create/use properly. use /{YOUR_DATABASE_NAME}/_explain endpoint for your mango query.

Another Tips: If you wish to index all fields of your document. You can define fields with empty array when creating the mango index.

When to use Mango Query or CouchDB Views?

For my opinion, I personally think that Mango Query is useful for ad-hoc search / sort / filtering. CouchDB Views is useful for reporting/statistics involve Sum, Count, Median or fixed recurring query. Therefore, depending on your requirement to pick which is the most suitable. But most of the time you will be using both of them within a project.

In Conclusion.

This is a simple guide on using Mango Query in Apache CouchDB. Hope you find these useful. Actually there are more you can do with Mango Query. Check it out.

Thank you for reading. 😊

Query in Apache CouchDB: Views

Jordan Soo Yen Yih — Sat, 30 Oct 2021 17:05:18 +0000

In this articles, I will talk about how to query documents in Apache CouchDB via Views.

What is Apache CouchDB?

A short introduce about CouchDB first for those who don't know. Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang. It is very easy to use as CouchDB makes use of the ubiquitous HTTP protocol and JSON data format. Do check out their Official Website for more detail. 😉

Alright, back to our main topic today.✌

First of all, before we talk about what is view, I need to introduce 2 important things in CouchDB.

Query Server

The first thing to introduce is CouchDB Query Server. What is Query Server? Based on the official documentation:

The Query server is an external process that communicates with CouchDB by JSON protocol through stdio interface and processes all design functions calls, such as JavaScript views.

By default, CouchDB has a built-in Javascript query server running via Mozilla SpiderMonkey. That's mean we can define a javascript function to tell CouchDB what documents you want to query.

Note: If you are not comfortable with Javascript, You can use other programming languages query server such as Python, Ruby, Clojure and etc. You can find the query server configuration here

Ooookay, then where to define the javascript function?🤔

which is the second thing to introduce.

Design Document

Design Document is a special document within a CouchDB database. You can use design document to build indexes, validate document updates, format query results, and filter replications. Below is an example of the design document structure.

{
    "_id": "_design/example",
    "views": {
        "view-number-one": {
            "map": "function (doc) {/* function code here */}"
        },
        "view-number-two": {
            "map": "function (doc) {/* function code here */}",
            "reduce": "function (keys, values, rereduce) {/* function code here */}"
        }
    },
    "updates": {
        "updatefun1": "function(doc,req) {/* function code here */}",
        "updatefun2": "function(doc,req) {/* function code here  */}"
    },
    "filters": {
        "filterfunction1": "function(doc, req){ /* function code here */ }"
    },
    "validate_doc_update": "function(newDoc, oldDoc, userCtx, secObj) { /* function code here */ }",
    "language": "javascript"
}

Let's us break down chunk by chunk.

1. CouchDB's document ID.

Underscore id is a reserved property key for representing the ID of the JSON document you save in the database. If the document starts with _design/ in front, meaning it is a design document.

"_id": "_design/example",

2. View functions

We can define our views query logic here. Mostly driven by Javascript function as Javascript is default query server language. Later we will go more detail on the view function.

"views": {
   "view-number-one": {
      "map": "function (doc) {/* function code here */}"
   },
   "view-number-two": {
      "map": "function (doc) {/* function code here */}",
      "reduce": "function (keys, values, rereduce) {/* function code here */}"
   }
},

3. Update functions

Update functions are functions logic that saved in CouchDB server and then we can request to invoke to create or update a document.

"updates": {
   "updatefun1": "function(doc,req) {/* function code here */}",
   "updatefun2": "function(doc,req) {/* function code here */}"
},

4. Filter functions

Filter functions use to filter database changes feed.

"filters": {
   "filterfunction1": "function(doc, req){ /* function code here */ }"
},

5. Validate Document Update Function

As named, you can define validation rules in this function to validate the document when you post into CouchDB.

"validate_doc_update": "function(newDoc, oldDoc, userCtx, secObj) { /* function code here */ }",

6. Language

Language property is telling CouchDB which programming language query server of this design document belongs to.

"language": "javascript"

I wont dive deep on Update function, Filter function and Validate document function as our focus today is view function. If you are interested, you may leave a message below let me know😉, then I can share a post about how to use update functions too.

✈Back to Views🛬

What is Views?

View in Apache CouchDB actually is a little bit similar to normal SQL database view.

A database view is a subset of a database and is based on a query that runs on one or more database tables.

The difference is CouchDB view is based on Map Reduce.

As example design document above, we can see that actually view function consists of 2 property keys (map & reduce), one is map function, another one is reduce function. (Reduce function is Optional)

1. Map function 🔍

Map functions accept a single document as the argument and (optionally) emit() key/value pairs that are stored in a view.

Let's say we have a list of blog post documents saved in our CouchDB database.

[
  {
    _id: "c2ec3b79-d9ac-45a8-8c68-0f05cb3adfac",
    title: "Post One Title",
    content: "Post one content.",
    author: "John Doe",
    status: "submitted",
    date: "2021-10-30T14:57:05.547Z",
    type: "post"
  },
  {
    _id: "ea885d7d-7af2-4858-b7bf-6fd01bcd4544",
    title: "Post Two Title",
    content: "Post two content.",
    author: "Jane Doe",
    status: "draft",
    date: "2021-09-29T08:37:05.547Z",
    type: "post"
  },
  {
    _id: "4a2348ca-f27c-427f-a490-e29f2a64fdf2",
    title: "Post Three Title",
    content: "Post three content.",
    author: "John Doe",
    status: "submitted",
    date: "2021-08-02T05:31:05.547Z",
    type: "post"
  },
  ...
]

If we want to query posts by status, we can create a javascript map function as below:

function (document) {
  emit(document.status, document);
}

For the whole design document will look like this:

{
    "_id": "_design/posts",
    "views": {
        "byStatus": {
            "map": "function (document) { emit(document.status, document); }"
        }
    },
    "language": "javascript"
}

After we saved this design document into CouchDB, CouchDB will start building the view. That's it, we have create a CouchDB view successfully.🎉🥳

To use the view, just send a GET method http request with the url below:

http://{YOUR_COUCHDB_HOST}:5984/{YOUR_DATABASE_NAME}/_design/posts/_view/byStatus

Result:

If we want to get all the posts with status "draft", then we call the http request with parameters key="draft", it will return us all the posts with status "draft" only.

http://{YOUR_COUCHDB_HOST}:5984/{YOUR_DATABASE_NAME}/_design/posts/_view/byStatus?key="draft"

Result:

Let say another map function emit document by date:

function (document) {
  emit(document.date, document);
}

Then we can query blog posts by date range.

http://{YOUR_COUCHDB_HOST}:5984/{YOUR_DATABASE_NAME}/_design/posts/_view/byDate?startkey=""&endkey="2021-09-29\uffff"

Result:

As query above, I defined a start date via startkey and end date via endkey , then CouchDB will return we the posts within the startkey and endkey. However my startkey is empty string, meaning that I don't care about start date, just give me the first post document until the date of the endkey.

Tips: If you want to reverse the return result, you can just add a parameter "descending=true"

2. Reduce/Rereduce ✂

Reduce function is optional to a view, it is based on the map function result then you can perform SUM, COUNT or custom logic with to filter or derive into any desire result.

Let's say we have a map result shows (month, expenses):

function (document) {
  emit(document.month, document.expenses);
}

Example Result:

If we want to get february expenses only, then we will put a parameter key="february", then it will return us february expenses only.
Based on the map result, we can add a reduce function to help us to sum the february expenses amount.

function(keys, values, rereduce) {
  return sum(values);
}

Result for key="february" after reduce :

That's it. We can instantly get the sum result no matter how many documents you have in the database. This is the power of Map Reduce. You can even rereduce, meaning perform second time reduce logic based on the first reduce result. For more detail, you may check out the official documentation here

In Conclusion

CouchDB views is very powerful, flexible and super fast to query a result like Hadoop. However, CouchDB only supports one layer map reduce derivation. If you do not understand what is Map Reduce, you may check out this Youtube video.

Thank you for your reading.😊

DEV Community: Jordan Soo Yen Yih

Bun - The fastest Javascript Runtime

Performance ⚡

All-IN-ONE Runtime 🎁

Temporal instead of Date

Temporal API Data Types

PlainDateTime 📆⌚

PlainDate 📆

PlainTime ⌚

ZonedDateTime 🗺

Instant ⚡

PlainMonthDay

PlainYearMonth

Helper Methods 🛠

add ➕ / subtract ➖

equals

with

compare ⚖

Conclusion

How easy to setup Master-master replication in CouchDB

New Node.js protocol imports

Previously

Now

Benefits of node: imports✨

Supported Node.js versions

How to easily deal with domain object in Redis

Installation ✨

Client Usage 🤝

Entity Usage 👮‍♂️

Schema Usage 📜

Repository Usage 🛠

Create New Data ➕

Read Data 👀

Create Index 📝

Search Data 🔍

Remove Data 🗑

That's it

CouchDB clients in Javascript

1. Nano

Setup

Connect to CouchDB server

Create a new database

Use an existing database

Promises

Callbacks

Pros:

Cons:

2. PouchDB

Setup

Connect to a CouchDB database

Create a new database

Query

Pros:

Cons:

3. Axios

Setup

Connect to CouchDB server

Create a new database

Query

Pros:

Cons:

Thanks for Reading.

10 useful Git tips to improve your workflow

1. Git aliases 🏷

2. Compare commits ⚖

3. Stashing uncommitted changes 🔖

4. Pull frequently 📥

5. Autocomplete commands 🤖

6. Set a global .gitignore 🚫

7. Delete local branches that have been removed from remote on fetch/pull 🗑

8. Use Git blame more efficiently 🕵️‍♂️

9. An alias of HEAD 👀

10. Resetting files ↩

Extras: ✨

How to setup Clouseau for CouchDB search on Unix-like systems

Introduction

Prerequisites📜

1. Download Clouseau

2. Extract Clouseau zip

3. Create Configuration files

Benefits of `node:` imports✨

6. Set a global `.gitignore` 🚫

9. An alias of `HEAD` 👀