Forem: pvivekdev (Vivekananthan P)

Decorators in Typescript

pvivekdev (Vivekananthan P) — Wed, 04 Jan 2023 00:51:16 +0000

Decorators are similar to annotations in JAVA or the attributes in C#. They provide additional definitions for a class, property, or function. Decorators are proposed as a part of ECMAScript 7. Decorators are useful to inject additional capabilities into existing definitions without the need to rewrite or duplicate the existing code.

To use decorator we need to enable “experimentalDecorators” to true in tsconfig.json. Otherwise, we will be prompted with the below compile time error when compiling typescript tsc

error TS1219: Experimental support for decorators is a feature that is subject to change in a future release. Set the ‘experimentalDecorators’ option in your ‘tsconfig’ or ‘jsconfig’ to remove this warning.

I came across this when developing microservice using Nestjs and it becomes really important to understand them as it is widely used across in Nestjs ecosystem. e.g. @UseGuards in Nestjs is an example of a method | class decorator.

Decorators can be viewed as simple functions with input parameters that provide definitions of a class, property, or function at runtime. Note the usage of @.

Decorators are called during the definition stage and not in the instance creation stage. To understand better let's look at this example

`function simpleDecorator(target:Function)
{
console.log("I am from simple decorator");
}
@simpleDecorator
export class ClassType
{
constructor()
{
console.log("I am from ctor");
}
}
let instance = new ClassType();

output:
I am from simple decorator
I am from ctor`

“I am from simple decorator” is printed in the console before “I am from ctor” We can see that decorators are invoked before instance creations. in fact, if we create multiple instances of classType we will see decorators are called only once when the classType is defined.

Ok, But why we are having the parameter of decorator as a function why not another type in the above example? That is because the Class in TS is a Function in Javascript. If we don’t have the type as the function and have it as string type then we will get an error “Argument of type ‘type ClassType’ is not assignable to parameter of type ‘String’.”

Can we have multiple decorators applied to a class, property, or function? Yes.

What if we have to pass parameters to the decorator? For this, we have to use a decorator factory. The decorator factory returns a decorator function e.g.

//Decorator factory return a decorator function
function decoratorFactory(paramters: any[])
{
return function(ctor:Function)
{
console.log(Data passed onto decorator:${paramters});
}
}
@decoratorFactory(["param 1", "param 2", "param n"])
export class TargetClass{
}

Types of Decorators

Class decorators.

Method decorators.

Property decorators.

Parameter decorators.

Class decorator

All the above examples we have seen so far are of class decorators. With class-level decorators, we can inject property through prototypes e.g.

function Component(targetClass:Function)
{
//Injecting porperty via decorator.
targetClass.prototype.FrmDecoraator = "prototype property set by decorator";
console.log(targetClass.name);

//Accessing the name property of the target class Function.
console.log((targetClass).StaticProperty);
}
//class decorator
@Component
export class TargetClass
{
static StaticProperty:string ="static property";
constructor()
{
console.log("I am from ctor");
}
}
let instanceOfTargetClass= new TargetClass();
//Injected prototype from decorator function into TargetClass
console.log((instanceOfTargetClass).FrmDecoraator);
Property Decorators :

Property decorators are applied to the properties within a class. it is a function that accepts the prototype of the class and the property key as its input parameters. In the below e.g. we can access the static property values but not the instance property value as decorators are created before instance creation.

@propetryDecorators
static staticProperty:string ="Static property";
}
let instance = new propetryDecoratorExample();
Method decorators:

As the name suggests these decorators are applied to the method in the class. Method decorators are functions with three parameters (class prototype, method name, and the optional param descriptor about the method). e.g. AuthGaurd() in Nest is an example of a method decorator. AuthGaurd is triggered first before the method invocation.

Parameter decorators

To decorate the parameters of a method. .e.g @body(), @param() in Nest js routes are of parameter decorator type. Parameter decorators can be used to check if the parameter is part of the method. To probe further on the parameter say the type of the parameter we need to install a third-party tool npm install reflect-metadata --save-dev and enable "emitDecoratorMetadata": true in tsconfig.json file.

import 'reflect-metadata';

//using reflection to probe more on the parameter.
let designType = Reflect.getMetadata(
"design:type", target, methodName);
console.log(designType: ${designType});

let designParamTypes = Reflect.getMetadata(
"design:paramtypes", target, methodName);
console.log(`paramtypes : ${designParamTypes}`);
if(designParamTypes !== String)
{
   console.log("not string");
}

}
class ClassType
{
Method(@paramDecorator param:number , nonParameterDecorator:string)
{}
}
After enabling the "emitDecoratorMetadata": true, Generated .js file will have info about the __decorate __metadata.

__decorate([
__param(0, paramDecorator),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Number, String]),
__metadata("design:returntype", void 0)
], ClassType.prototype, "Method", null);

References for further reading on this topic

Packt Mastering Type script second edition by Mr. Nathan Rozentals

https://docs.nestjs.com/custom-decorators

https://javascript.plainenglish.io/master-the-typescript-keyof-type-operator-bf7f18865a8b

Thank you for reading. Until we meet again I Wish you the very best.
Vivek

Indexing on MongoDB Collection - Part 1

pvivekdev (Vivekananthan P) — Tue, 01 Nov 2022 06:56:11 +0000

Indexing makes the read queries faster. We can apply indexing on any of the fields in the document including the embedded fields. When documents are indexed MongoDB will search with filtered offset first rather than doing COLLSCAN ( column-span) on all documents and then applying filter criteria to it.

Let us understand this by creating an index to the existing collection and comparing the query execution stats before and after applying the indexing.

By the way, I am using Mongo DB Atlas Free cluster for this walk-through. Mongo Altas is a cloud-based solution to host and manage NoSQL data and it also provides a free cluster for learning purposes with one click option to load sample data set into your free cluster. I liked it :)

To connect to the Atlas cluster I am using VS Code extension “MongoDB VS Code”. There are other ways as well such as using mongo shell, mongo Atlas UI. Please refer to the link below https://www.mongodb.com/docs/atlas/getting-started/

I am using the “sample_airbnb” data set loaded into my Atlas account and querying them using MongoDB for VS code extension.

Please note In case the image screenshot are not clearly visible kindly open them in a new tab or click on the image description to open in new tab.

In above query , I am executing find query on collection: “listingAndReviews” where the property_type is house. I am also using regex to fetch result ignoring case sensitive and the explain(‘executionStats’) function to get query plan.

In the presence of indexing, the winningPlan section will have inputStage.stage as IXSCAN

I removed all pre-created indexes from the “listingAndReviews” collection and re-execute the same query. We can see the winningPlan.stage as “COLLSPAN” and the executionStats.executionTimeMillis as 118. The totalDocsExamined as 5555 to find the 606 records matching our search criteria.

Let us create an index on the field “property_ type” to fetch results faster.

To define an index , We need to understand the queries required and the volume of read and write operations that going to be performed on the collection. Indexing will have some amount of taxation on the write operation that’s the reason we shouldn’t apply indexing to all the document fields.

Note* Creating indices on the fields where the fetch query will return close to all documents from the collection will not help and in fact will slow the query execution. Create index based on the query use case such that the query result should return only the limited fetch result.

Compound Index

The above examples are on the single index field. There is another type of index called “Compound Index” where two or more fields are considered for indexing in the same order they were added.

If we have two fields added as compound indexes the precedence will start from left to right. For example, let us create a compound index on “listingAndReviews” collection using “beds and address.country_code ” (embedded document) fields.

The order of the fields is important here and precedence is from left to right. i.e. the field beds get first priority and followed by address.country_code.

In the above query, Even though we use two filters in the find query to fetch results having beds count as 1 and can accommodate 4 people. here “accommodates” field is not part of our index keys. Mongo DB performs IXSCAN i.e. index scan and not the COLLSPAN column spanning all the documents within the collection because we have the “beds” added as part of our key index and the precedence is from left to right.

In case we query only with accommodates fields, Mongo DB performs COLLSPAN and examines all the documents of a total count of 5555

Rules for defining an index

Use the ESR (Equality, Sort, Range) Rule
Create Indexes to Support Your Queries
Use Indexes to Sort Query Results

We need index not only for fetching the results quickly but also to use sorting. In case of non indexed document, Mongo DB has limit of 32 MB in memory and this will time out in case sorting (Default in- memory sorting) of huge millions of document without indexing.

Ensure Indexes Fit in RAM
Create Queries that Ensure Selectivity

In the next part of this series, we will drill down to other types of indexes and the best practices to follow while creating indexes.

To be continued.