DEV Community: Vivek Chauhan

Understanding MySQL Enums: Unveiling Surprising Behaviors

Vivek Chauhan — Fri, 27 Oct 2023 10:20:05 +0000

Have you ever encountered MySQL enums in your database work and been left puzzled by their behavior? In this blog, we'll delve into MySQL enums, what they are, and explore some of the intriguing and, at times, counterintuitive aspects of how they work.

What Are MySQL Enums?

Let's start with the basics. MySQL enums are a column type that allows you to define a set list of values. From a human perspective, you can view this column as a list of strings. However, beneath the surface, the database treats them as integers, resulting in compact storage on disk. This dual nature provides a hint of data validation, as you can only choose from the predefined list of values.

The Right Down-the-Middle Use Case

To illustrate a straightforward use case, imagine an "orders" table with a "size" column, which is defined as an enum. The allowed values for this column are: Extra Small, Small, Medium, Large, and Extra Large. These are the only options you can select, ensuring data integrity.

Unveiling the Integer-String Duality

Now, here's where it gets interesting. MySQL enums offer both the readability of strings and the efficiency of integers. To prove this, you can perform a simple query: SELECT size and SELECT size + 0. The former will return the string label (e.g., "Small"), while the latter will coerce it into the underlying integer (e.g., 2 for "Small"). This clever design gives you the best of both worlds.

Ordering by Enums

One intriguing aspect of enums is their behavior when it comes to sorting or ordering. When you use ORDER BY on an enum column, it sorts by the underlying integer values, not the string labels. This may initially seem odd, as you might expect strings to be ordered alphabetically. However, it's essential to remember that the database operates based on integers, not strings.

For instance, if you order the "size" column, you'll notice that "Extra Small" (1), "Small" (2), "Large" (4), and "Extra Large" (5) are sorted based on their integer positions. This behavior might feel counterintuitive, but it's crucial to know when working with enum columns.

The Most Surprising Quirk: Max and Min Functions

Here comes the real surprise. While ordering by an enum column follows the integer values, the MAX and MIN functions take an unexpected approach. Instead of considering the integer positions, these functions base their calculations on the string values.

For example, if you were to run SELECT MAX(size) FROM orders, you might expect it to return "Extra Large" since it's in position 5. However, the result will be "Extra Small" because, alphabetically, it's the largest string label.

Wrapping It Up

In summary, MySQL enums can be incredibly useful for specific use cases where you need to maintain a specific order of values. However, it's crucial to declare the enum values in the order you want them sorted.

The quirky behavior of enums, where ordering follows integers and max/min functions consider string values, may seem inconsistent, but it's an essential aspect to keep in mind when working with these data types. Understanding these nuances will help you make the most of MySQL enums in your database management endeavors.

Error Handling and Logging in NestJS: Best Practices

Vivek Chauhan — Thu, 26 Oct 2023 04:50:22 +0000

When building applications with NestJS, handling errors and implementing robust logging are crucial aspects of ensuring your application’s reliability and maintainability. In this comprehensive guide, we’ll explore the best practices for error handling and logging in NestJS, specifically tailored for beginners. So, fasten your seatbelts and let’s embark on this journey to master error handling and logging in NestJS!

Understanding Error Handling in NestJS

Error handling is the process of gracefully handling and managing unexpected situations that may arise during the execution of your application. NestJS offers a structured approach to handle errors effectively. The primary mechanism to achieve this is by using Exception Filters. Exception Filters allow you to intercept thrown exceptions and take appropriate actions, such as returning meaningful error responses to clients.

Let’s take a look at how to implement an Exception Filter:

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: exception.message,
    });
  }
}

In this example, we’ve created an HttpExceptionFilter, which catches any HttpException that might occur in our application. It then extracts relevant information from the exception and sends a structured JSON response to the client, including the status code, timestamp, request path, and error message.

To apply this filter globally to your application, you can use the app.useGlobalFilters() method in your main.ts file:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { HttpExceptionFilter } from './http-exception.filter';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new HttpExceptionFilter());
  await app.listen(3000);
}
bootstrap();

With this setup, all HttpExceptions will be caught by our HttpExceptionFilter, ensuring consistent error responses throughout the application.

Handling Custom Exceptions

While NestJS provides several built-in exceptions, you’ll often encounter scenarios where you need to define your custom exceptions. Creating custom exceptions is simple and allows you to provide specific details about the error to the client.

Let’s say we want to create a custom NotFoundException:

export class NotFoundException extends HttpException {
  constructor(message: string) {
    super(message, HttpStatus.NOT_FOUND);
  }
}

We can then use this custom exception within our application’s services or controllers:

import { Injectable, NotFoundException } from '@nestjs/common';
import { Task } from './interfaces/task.interface';

@Injectable()
export class TaskService {
  private tasks: Task[] = [];

  getTaskById(id: string): Task {
    const task = this.tasks.find((task) => task.id === id);
    if (!task) {
      throw new NotFoundException(`Task with ID ${id} not found.`);
    }
    return task;
  }
}

In this example, if the requested task with a specific id is not found, we throw the NotFoundException, which will be caught by our global HttpExceptionFilter. This allows us to send a user-friendly response back to the client without leaking sensitive implementation details.

Logging in NestJS

Effective logging is essential for monitoring the behavior of your application and diagnosing potential issues. NestJS provides a powerful logging mechanism out of the box, allowing you to choose from various logging levels, log formatters, and transports.

By default, NestJS uses the Logger class to handle application logs. To use the default logger in your services or controllers, you can inject it using the @Logger() decorator:

import { Injectable, Logger } from '@nestjs/common';

@Injectable()
export class TaskService {
  private logger = new Logger(TaskService.name);

  // ...

  someMethod() {
    this.logger.log('This is a log message.');
    this.logger.debug('Debugging some process...');
    this.logger.warn('Warning: Something seems off!');
    this.logger.error('Oops! An error occurred.');
  }
}

The Logger class provides methods for various log levels, such as log, debug, warn, and error. Each log level corresponds to a specific severity, and you can configure the logging behavior in your NestJS application.

Customizing Logging Behavior

If you need more control over your application’s logging behavior, NestJS allows you to create custom loggers by implementing the LoggerService interface.

Let’s create a fun custom logger that writes logs to a file and also includes emojis!

import { LoggerService } from '@nestjs/common';

export class EmojiLogger implements LoggerService {
  log(message: string) {
    this.writeToFile('📢 ' + message);
  }

  error(message: string, trace: string) {
    this.writeToFile('❌ ' + message);
    this.writeToFile('🔍 Stack Trace: ' + trace);
  }

  warn(message: string) {
    this.writeToFile('⚠️ ' + message);
  }

  debug(message: string) {
    this.writeToFile('🐞 ' + message);
  }

  private writeToFile(message: string) {
    // Implement the logic to write logs to a file here.
    console.log(message); // For demonstration purposes, we'll just log to the console.
  }
}

Now, to use our EmojiLogger, let’s update the main.ts file:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { EmojiLogger } from './emoji-logger';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, { logger: new EmojiLogger() });
  await app.listen(3000);
}
bootstrap();

With this setup, our application will use the fun EmojiLogger to log messages. Feel free to customize the writeToFile method to write logs to a file or any other preferred destination.

Conclusion

In this article, we’ve explored the best practices for error handling and logging in NestJS. We’ve learned how to use Exception Filters to gracefully handle errors and send structured error responses to clients. Additionally, we’ve seen how to create custom exceptions for more specific error reporting. Furthermore, we’ve delved into the world of logging and discovered how to use the default Logger class and create custom loggers, like our EmojiLogger.

By mastering error handling and logging in NestJS, you’re well on your way to building robust and reliable applications. So, keep experimenting, stay curious, and be happy coding! 🚀🌟

How to save JSON array in MySQL with TypeORM

Vivek Chauhan — Fri, 28 Jan 2022 16:54:30 +0000

Introduction

This article is NestJS a record of the know-how I realized while developing through the framework. There may be a better way than the one I suggested. Suggestions are always welcome :)
NestJS - The framework TypeORMmanages the DB through the library. This article TypeORM deals with how to store JSON arrays in MySQL DB.

When we save 'array' in DB column?

Storing an array type in a DB column appears more often than you think.

Foreign Key Relation (OneToMany/ManyToOne)

Person Email Consider a case in which Entity and Entity exist for. At this time, since one person can have multiple emails, the relationship between the two is 'OneToMany/ManyToOne'. The MySQL table is stored as follows.

+----+--------------------+--------------+
| id | person             | email_id(fk) |
+----+--------------------+--------------+
| 1  | Tom                | 1            |
| 2  | Evans              | 2, 3         |
+----+--------------------+--------------+

+----+------------------+----------------+
| id | email            | person_id(fk)  |
+----+------------------+----------------+
| 1  | tom@mail.com     | 1              |
| 2  | evans@mail.com   | 2              |
| 3  | evans@univ.ac.kr | 2              |
+----+------------------+----------------+

Looking at the two tables, each has a foreign key called email_id and person_id. Person in the Evans case of , it has two emails in particular, so it has an email_id array of.
That is, you can find fk_id Array under the OneToMany/ManyToOne relationship.

`simple-array`

Even if it is not a foreign key, you can store arrays in MySQL columns. TypeORM helps simple-array you to store simple arrays in MySQL through.

@Column('simple-array')
num_arr: number[];

@Column('simple-array')
str_arr: string[];

However , if you store it in a simple-array way string[], some problems arise. This is dealt with in more detail later.

How to save JSON array?

So far, we have looked at the case where an array is stored in MySQL. Now let's see how we can store JSON array in MySQL.

`simple-array` Let's try it!

@Column('simple-array')
json_arr: JSON[];

@Column, simple-array and declared in the form of an array as before. Can this be saved? NOPE! In this case, an error occurs. Let's look at the error message.

DataTypeNotSupportedError: Data type "Array" in "example.json_arr" is not supported by "mysql" database.

?? Earlier we looked at the case where MySQL uses arrays. Array but now the error message says that the type is not supported by MySQL .
The error message is correct. MySQL Array does not support types. It's just giving us the feeling of supporting arrays in some way!!

`simple-array` Let's try it! - `string[]` version

Let's see how to circumvent the current problem. Our purpose is still to store JSON arrays in MySQL. But the JSON[] form is impossible, so string[] let's bypass the method we looked at earlier.

@Column('simple-array')
json_arr: string[];

In javascript, it can be serialized in the form of through JSON.stringify() a function called . Our plan is as follows-

The API receives input as a JSON array.
Iterates through the received JSON array and applies to all JSON JSON.stringify() to serialize
string[] Save as MySQL
Get Whenever string[] a request comes in, the string in the string array stored as JSON.parse() is parsed and returned as

If you do this, you can convert the JSON array to a string array and store it in the DB without an error message.

But…

string[] version issue

For those of us who store JSON, this method also has problems.
Let's say you have a JSON array like this:

[{name: 'Baker', job: 'musician'}, {name: 'Euler', job: 'mathematician'}]

JSON.stringify()If we change this to

["{name: 'Baker', job: 'musician'}", "{name: 'Euler', job: 'mathematician'}"]

becomes
Saving to DB works fine. However Get, if you check what is stored in the DB with ...

["{name: 'Baker'", 
 "job: 'musician'}",
 "{name: 'Euler'", 
 "job: 'mathematician'}"]

It has the following bizarre form... !!
The reason is that…

MySQL pseudo-Array

We thought that MySQL supports number arrays or string arrays, even if JSON arrays cannot be stored. But… That was TypeORM a trick of !!

Actually MySQL Array doesn't support types at all!! (Already confirmed with an error message.) So simple-array, how did we save it using properties?
simple-array stores all arrays as string. If it is a number array, "1, 2, 3", if it is a string array, "Bill, John, Baker". So, if even a comma (,) is inserted in the middle of the string, it is stored in the DB like this.

"'In other words, please be true', 'In other words, I love you'"

That is, even if it is a string array, only one string is stored in the DB. And parses the information of the column declared as TypeORM, based on the comma (,). simple-array therefore, even if you originally saved 2 strings, you will get 4 strings if you read the DB value.

Actually MySQL there is nothing wrong with it. TypeORM it is possible that the simple-array method of MySQL, especially in , is causing this problem. In other DBs, it may not be stored as a single string like this. 2 In MySQL, this is… ㅠㅠ

In the case of JSON, commas (,) must appear to list objects, but in general strings, commas are rare. So TypeORM the developer may not have noticed. However, even such a small error can become a big obstacle or cause an error in development. (I lost half a day because of this...)

[Solution] Just save it as a string!

Through several trials and errors, simple-array I confirmed how TypeORM stores arrays in MySQL...
So let's use this to reorganize our code.

@Column()
json_arr: string;

Column is simply string set to .

Each JSON in the JSON array JSON.stringify() is serialized as a function. Then, they JSON.parse() are transformed into a possible form and stored.

// save JSON array into MySQL DB
saveJSONArray(json_arr: JSON[]) {
  let jsonArr_string = "[";
  for(let i=0; i < json_arr.lenght; i++){
    jsonArr_string += JSON.stringify(json_arr[i]);
    if(i < json_arr.lenght-1){
      jsonArr_string += ",";
    }
  }
  jsonArr_string += "]";
  this.yourRepository.save({ json_arr: jsonArr_string });
}

// load JSON array from MySQL DB
async findJSONArray(): Promise<YourEntry[]> {
  const entry_arr = await this.yourRepository.find();
  for(let i=0; i < entry_arr.lenght; i++){
    entry_arr[i].json_arr = JSON.parse(entry_arr[i].json_arr);
  }
  return entry_arr;
}

I think the best way is json_arr: string to set it to , parse the DB value to , and return it as JSON. JSON.parse() (Of course, someone may have found a better way than this and put it to good use!)

Adding Audio to Your App with jQuery

Vivek Chauhan — Fri, 11 Dec 2020 07:17:22 +0000

Want to add some sound effects to your website or game? With HTML5, it’s easy! Here’s a quick tutorial. (If you have your soundbite already and want to get straight to the code, skip to step 4.)

Step 1: Find a soundbite

You can Google around for the sound you want, but I would suggest signing up for a free sound effect library. I found freesound.org to be very helpful for finding those clicks, pops, and chimes. Alternatively, you can grab sounds from YouTube using an MP3 converter like this one. When you find the sound you want, download it.

Step 2: Trim the soundbite

For this, you’ll want a free, lightweight audio editor. Audacity is my recommendation. Download it, install it and fire it up. Import your soundbite.
Here’s the fun part. Zoom in really close, and trim off any dead space from the beginning of the sound. This subtle (or sometimes not-so-subtle) improvement will ultimately make your app feel more responsive and satisfying. Notice the straight line at the beginning of the example below. If you see that in your file, highlight it and press delete. Your soundbite is now ready for use.

Step 3: Import soundbite into your project

Simply use Finder or Windows Explorer to move the freshly trimmed audio file into your app directory. If you will have multiple audio files, it is helpful to make a dedicated audio folder to keep things organized.

Step 4: HTML

Add an audio element in your HTML file. This will not show up on the page, so you can put it anywhere. It simply needs to exist so you can reference it with jQuery. In our example, we are using a file called pop.wav.
<audio id="pop"> <source src="audio/pop.wav" type="audio/mpeg"> </audio>
(Note: If you want to add an audio player with play, pause, and volume controls, follow the below format. This will, of course, show up on the page.)
<audio controls> <source src="horse.mp3" type="audio/mpeg"> </audio>

Step 5: jQuery

In your .js file, wherever you want your soundbite to play, use the following code:
$('audio#pop')[0].play()

$('audio#pop') uses jQuery to select all audio elements with an id of ‘pop’.
This will return an array, so you need to specify the first element by adding [0].
Finally, .play() will play your soundbite.

Note: if you have a long soundbite, you can pause it by calling .pause(). There is no “stop” function, so if you’d like it to restart from the beginning, call .currentTime = 0 on another line.
Altogether, that looks like this:
$('audio#pop')[0].pause() $('audio#pop')[0].currentTime = 0

7 Git tricks that changed my life

Vivek Chauhan — Thu, 12 Nov 2020 18:07:23 +0000

These helpful tips will change the way you work with the popular version control system.

Git is one of the most common version control systems available, and it’s used on private systems and publicly hosted websites for all kinds of development work. Regardless of how proficient with Git I become, it seems there are always features left to discover. Here are seven tricks that have changed the way I work with Git.

1. Autocorrection in Git

We all make typos sometimes, but if you have Git’s auto-correct feature enabled, you can let Git automatically fix a mistyped subcommand.
Suppose you want to check the status with git status but you type git stats by accident. Under normal circumstances, Git tells you that 'stats' is not a valid command:
$ git stats git: ‘stats’ is not a git command. See ‘git --help’. The most similar command is status

To avoid similar scenarios, enable Git autocorrection in your Git configuration:
$ git config --global help.autocorrect 1
If you want this to apply only to your current repository, omit the --global option.
This command enables the autocorrection feature. An in-depth tutorial is available at GitDocs, but trying the same errant command as above gives you a good idea of what this configuration does:
$ git stats git: ‘stats’ is not a git command. See ‘git --help’. On branch master Your branch is up to date with ‘origin/master’. nothing to commit, working tree clean
Instead of suggesting an alternative subcommand, Git now just runs the top suggestion, which in this case was git status.

2. Count your commits

There are many reasons you might need to count your commits. Many developers count the number of commits to judge when to increment the build number, for instance, or just to get a feel for how the project is progressing.
To count your commits is really easy and straightforward; here is the Git command:
$ git rev-list --count
In the above command, the branch-name should be a valid branch name in your current repository.
$ git rev-list –count master 32 $ git rev-list –count dev 34

3. Optimize your repo

Your code repository is valuable not only for you but also for your organization. You can keep your repository clean and up to date with a few simple practices. One of the best practices is to use the .gitignore file. By using this file, you are telling Git not to store many unwanted files like binaries, temporary files, and so on.
To optimize your repository further, you can use Git garbage collection.
$ git gc --prune=now --aggressive
This command helps when you or your team heavily use pull or push commands.
This command is an internal utility that cleans up unreachable or “orphaned” Git objects in your repository.

4. Take a backup of untracked files

Most of the time, it’s safe to delete all the untracked files. But many times, there is a situation wherein you want to delete, but also to create a backup of your untracked files just in case you need them later.
Git, along with some Bash command piping, makes it easy to create a zip archive for your untracked files.
$ git ls-files --others --exclude-standard -z |\ xargs -0 tar rvf ~/backup-untracked.zip
The above command makes an archive (and excludes files listed in .gitignore) with the name backup-untracked.zip

5. Know your .git folder

Every repository has a .git folder. It is a special hidden folder.
$ ls -a . … .git
Git mainly works with two things:
The working tree (the state of files in your current checkout)
The path of your Git repository (specifically, the location of the .git folder, which contains the versioning information)
This folder stores all references and other important details like configurations, repository data, the state of HEAD, logs, and much more.
If you delete this folder, the current state of your source code is not deleted, but your remote information, such as your project history, is. Deleting this folder means your project (at least, the local copy) isn’t under version control anymore. It means you cannot track your changes; you cannot pull or push from a remote.
Generally, there’s not much you need to do or should do, in your .git folder. It’s managed by Git and is considered mostly off-limits. However, there are some interesting artifacts in this directory, including the current state of HEAD:
$ cat .git/HEAD ref: refs/heads/master
It also contains, potentially, a description of your repository:
$ cat .git/description This is an unnamed repository; edit this file ‘description’ to name the repository.

6. View a file of another branch

Sometimes you want to view the content of the file from another branch. It’s possible with a simple Git command, and without actually switching your branch.
Suppose you have a file called README.md, and it’s in the main branch. You’re working on a branch called dev.
With the following Git command, you can do it from the terminal.
$ git show main:README.md
Once you execute this command, you can view the content of the file in your terminal.

7. Search in Git

You can search in Git like a pro with one simple command. Better still, you can search in Git even if you aren’t sure which commit — or even branch — you made your changes.
$ git rev-list --all | xargs git grep -F ‘’
For example, suppose you want to search for the string “font-size: 52 px;” in your repository:
$ git rev-list –all | xargs git grep -F ‘font-size: 52 px;’ F3022…9e12:HtmlTemplate/style.css: font-size: 52 px; E9211…8244:RR.Web/Content/style/style.css: font-size: 52 px;