DEV Community: Drakos

Javascript Template Engines Benchmark (2024)

Drakos — Sun, 02 Jun 2024 07:40:12 +0000

TLDR

About

Template engines have long been a cornerstone of web development, enabling developers to dynamically generate HTML using logic and data. As the landscape of JavaScript library and framework options has expanded, so too has the variety of template engines available. This article explores the performance characteristics of several popular JavaScript template engines through rigorous benchmarking.

What tested

The primary goal of a template engine is to separate the presentation layer from the business logic, making it easier to manage and maintain code. Given the rapid evolution of web applications and the intensive demands placed upon them, performance is a critical consideration. To help you make an informed decision, we will benchmark a selection of contemporary template engines:

Eta.js
Liquid.js
Handlebars
Nunjucks
EJS
Edge.js

Source

https://github.com/crafter999/template-engine-benchmarks

Support

If you liked this article follow me on Twitter, it's free!
https://twitter.com/devcrafter91

Publish private NPM packages securely with scopes on CodeArtifact

Drakos — Mon, 13 Dec 2021 16:33:07 +0000

NPM is a package manager configured by default to use the public registry but what if your code is proprietary and you want full disclosure? The easiest way is to use any cloud services (that support private registries) like Github, Amazon Web Services, or Google Cloud.
With just a few clicks you can setup a private registry for free. In this example, I'll be using CodeArtifact, I'm not affiliated in any way with Amazon Web Services, I had an account and didn't want to waste time trying other services.

Disclaimer: I realize that people are dangerously messing up their environments and the most accurate way to prevent your modules from pushing to wrong servers is using NPM's scope packages. https://docs.npmjs.com/cli/v7/using-npm/scope

Install AWS CLI Version 2

Pushing packages to CodeArtifact requires AWS authentication using the official CLI from Amazon, just run the following 3 commands to install it.

Linux

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
./aws/install # as root

macOS

curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
sudo installer -pkg AWSCLIV2.pkg -target /

Output:

# /usr/local/bin/aws --version
aws-cli/2.2.47 Python/3.8.8 Linux/5.10.0-8-amd64 exe/x86_64.debian prompt/off

Setup an IAM user (API Keys)

Go to IAM https://console.aws.amazon.com/iamv2/home#/users
Click Add users
Select Access Key as credential type
Create new group and give AWSCodeArtifactAdminAccess permissions.
Write down the generated Access key ID & Secret access key.

Login using the generated keys

Running aws configure will setup the AWS (needed for generating the NPM token later).

**Don't forget to choose the default region. In this example I'm using Ireland EU.

Output:

aws configure

AWS Access Key ID [None]: ----------------
AWS Secret Access Key [None]: ------------
Default region name [None]: eu-west-1
Default output format [None]: json

Create a new NPM scope repo

Login to the AWS dashboard.
Go to CodeArtifact and click Create repository. To avoid collisions give the scope repo a unique name like ca-priv-repo-01
Follow the instructions from AWS.

Publish & Pull the modules

Here comes the hard part. The most valid & secure way to configure any project, is using scopes (namespaces).
Publishing and pulling packages securely without messing up with global configuration files which can lead to massive data leaks & terrible headaches. Thank to NPM's scopes, AWS will play fair with the package manager.

Tip: Check the dummy project here https://github.com/crafter999/private-npm-package

Publish

Create a fresh package using the AWS repository name as an NPM scope. For example @ca-priv-repo-01/mypackage. Example package.json: "name": "@ca-priv-repo-01/private-npm-package"
Go to the CodeArtifact panel.
Click on the target repository & then View connection instructions.
From there, select the npm package manager.
Choose Manual Setup. (Skip Recommended setup for the obvious reasons)

Run the first generated command on a terminal to export the CodeArtifact token.

Example: 

export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain mydomain --domain-owner 00000000 --query authorizationToken --output text`

Copy paste the 3 lines to the .npmrc replacing registry= with @myscope:registry

Example: 
@ca-priv-repo-01:registry=https://-----------.amazonaws.com/npm/ca-priv-repo-01/
//-----------.amazonaws.com/npm/ca-priv-repo-01/:always-auth=true
//-----------.amazonaws.com/npm/ca-priv-repo-01/:_authToken=${CODEARTIFACT_AUTH_TOKEN}

Add the following lines to the package.json replacing ---id--- with te registry name.

  "publishConfig": {
    "registry": "https://---id---.codeartifact.eu-west-1.amazonaws.com/npm/ca-priv-repo-01/"
  },

Lastly, upload any package using npm publish.

NOTE 1: If you're getting authentication errors like the following one, make sure you successfully exported the CODEARTIFACT_AUTH_TOKEN.

npm ERR! code E401
npm ERR! Unable to authenticate, your authentication token seems to be invalid.
npm ERR! To correct this please trying logging in again with:
npm ERR! npm login

NOTE 2: If you're getting domain errors like the following, make sure you are on the right region.

An error occurred (ResourceNotFoundException) when calling the GetAuthorizationToken operation: Domain not found. Domain 'example' owned by account '0000000000' does not exist.

Pull

Create a new project.
Copy paste the .npmrc from the previous step to root folder of your project.
Export the token. Use the generated command from Connection Instructions (Manual Setup).
Install using npm install @myscope/mypackage.

Example Code

You can find a dummy project here. https://github.com/crafter999/private-npm-package

Support

If you liked this article please follow me on Twitter, it's free. https://twitter.com/devcrafter91

Debug Node.js Typescript app using VS Code (Mac,Linux)

Drakos — Thu, 05 Nov 2020 11:34:51 +0000

Using the following configuration I managed to debug flawlessly Node.js applications written in Typescript using the Visual Studio Code IDE. I have tested it on Mac OS and almost every Linux distro like Debian, Ubuntu, Arch.

Configure tsconfig.json

First of all, enable source maps "sourceMap": true and declarations "declarationMap": true, "declaration": true.

Don't forget to specify the destination folder using the outDir parameter.

Configure VSCODE

Paste the following snippet and change __MYAPP__ to the typescript file you want to debug and __MYDIST_FOLDER__ to the dist folder of your project.

Don't forget to whitelist (OUTPUT) port 9229 locally on your iptables.

Examples:
__MYAPP__ = src/app.ts
__MYDIST_FOLDER__ = dist

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "node",
            "request": "launch",
            "name": "Debug Node.js",
            "program": "${workspaceFolder}/__MYAPP__.ts",
            "outFiles": [
                "${workspaceFolder}/__MYDIST_FOLDER__/**/*.js"
            ],
            "sourceMaps": true,
            "port": 9229,
            "runtimeArgs": [
                "--inspect-brk=9229"
            ],
            "console": "integratedTerminal"
        }
    ]
}

Support

If you liked this quick guide follow me on Twitter :) https://twitter.com/devcrafter91

How to install Kubernetes on Windows 10

Drakos — Thu, 30 Jul 2020 22:23:50 +0000

Intro (Updated 17/07/2022)

Kubernetes is made for managing your cloud resources and build scalable apps. It's considered the most popular tool for automating, deploying, and scaling your whole cloud. It runs on all major operating systems and it is the most popular open source tool in the cloud market. Kubernetes can scale your whole infrastructure, check the health of each service, work as a load balancer, automate deployments and many more. You can install & setup as many nodes (clusters) as you want, and deploy your pods (docker containers) and services across the cloud. In this tutorial you will learn how to setup Kubernetes and deploy the official web GUI dashboard where you can manage and monitor everything but first you have to install Hyper-V & Docker in order to use Kubernetes.

Step 1: Install & Setup Hyper-V

Windows as we all know, have their own virtualization software and it's called Hyper-V which is basically something like VirtualBox on steroids. Hyper-V can manage your virtual machines (VM) using the default GUI tool provided by Microsoft for free, or through command line. Enabling Hyper-V can be easily done but first, make sure your PC meets the following requirements: Your OS should be Windows 10 (Enterprise, Pro or Education) with minimum 4GB RAM and CPU Virtualization support, although you have to double check if it's enabled in your BIOS settings.

You can remove or add features that don't come up pre-installed during the installation of Windows, like Hyper-V. Always remember that some of the features require internet access to download extra components from Windows Update. Follow the next steps to enable Hyper-V on your machine.

Go to Control Panel
On your left panel, click on Programs
Then click Programs and Features followed by Turn Windows features on and off.
Check Hyper-V and Windows Hypervisor Platform
Click OK

Your system will now start installing Hyper-V on the background, it may need to reboot a couple of times until everything is configured properly. Don't expect any notification or something! Run the following powershelgl command as Administrator and verify if Hyper-V is installed successfully on your machine: Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V

Example.

PS C:\Windows\system32> Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V

FeatureName      : Microsoft-Hyper-V
DisplayName      : Hyper-V Platform
Description      : Provides the services that you can use to create and manage virtual machines and their resources.
RestartRequired  : Possible
State            : Enabled

Step 2: Install Docker for Windows

Kubernetes is build on top of Docker, theoretically is just a tool that communicate with your Docker containers and manage everything on enterprise level. To install Docker just grab & run the following installer https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe . During installation Docker will ask you to choose between Hyper-V and WSL. For better security uncheck WSL 2. Docker will setup a Linux virtual machine on top of Hyper-V and start all the necessary services without manually configure anything. After the installation, you can either "communicate" with Docker using the CLI tool docker or running HTTP requests though its API.

Step 3: Install Kubernetes on Windows 10

Docker comes with a handy GUI tool where you can modify some settings or install & enable Kubernetes. Follow the following instructions, WARNING! If Docker is installed successfully and you can't locate its tray icon, you have to reboot your system. If the problem persists, check the official troubleshooting guide here https://docs.docker.com/docker-for-windows/troubleshoot/. Now follow the instructions to install Kubernetes.

Right-click the Docker tray icon
Click "Settings"
On the left panel click "Kubernetes"
Check Enable Kubernetes and click "Apply"

*** If you're behind a firewall, don't forget to allow:

C:\program files\docker\docker\frontend\docker desktop.exe
C:\program files\docker\docker\resources\com.docker.backend.exe
C:\program files\docker\docker\resources\bin\kubectl.exe
C:\program files\docker\docker\resources\com.docker.vpnkit.exe

During installation, Docker is going to install additional packages and dependencies. It may take around 5~10 minutes and the installation time depends on your Internet speed and your PC performance. Wait until the 'Installation complete!' popup message is shown up. After installing Kubernetes you can make sure that everything is working fine using the Docker app. If both services (Docker & Kubernetes) are running successfully without any errors then both icons at bottom left will go green.

Example.

Step 4: Install Kubernetes Dashboard

Kubernetes Dashboard is the official web-based UI where you can manage Kubernetes resources. It's not installed by default. Deploying applications with Kubernetes can be easily managed using the cli tool called kubectl where you can interact with your cloud and manage your Pods, Nodes, or Clusters. If you pass the apply argument followed by your YAML configuration file you can easily create or update Kubernetes resources. Run the following commands to deploy & enable the Kubernetes Dashboard using the following commands.

Go to https://github.com/kubernetes/dashboard/releases
Scroll down to Installation and download latest yaml configuration file for example https://raw.githubusercontent.com/kubernetes/dashboard/v2.6.0/aio/deploy/recommended.yaml
Deploy it using kubectl apply -f .\recommended.yaml
Verify that it's running using the following command: kubectl.exe get -f .\recommended.yaml.txt

Example.

PS C:\Users\user\Desktop> kubectl.exe get -f .\recommended.yaml.txt

NAME                             STATUS   AGE

namespace/kubernetes-dashboard   Active   2m10s

NAME                                  SECRETS   AGE

serviceaccount/kubernetes-dashboard   1         2m10s

NAME                           TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE

service/kubernetes-dashboard   ClusterIP   10.97.3.127   <none>        443/TCP   2m9s

Step 5: Access the dashboard

There are two ways to access the dashboard with tokens, the first one (deprecated, works only for older versions) is using the default token that was crated during the installation of Kubernetes and the second (more secure) way is by creating users, giving them permissions, and then get the generated token.

Newest version

Create a new configuration file:
dashboard-admin.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
name: admin-user
namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: admin-user
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: cluster-admin
subjects:
- kind: ServiceAccount
name: admin-user
namespace: kubernetes-dashboard

Deploy it using kubectl.exe apply -f .\dashboard-admin.yaml.txt
Generate token using kubectl.exe -n kubernetes-dashboard create token admin-user
Run kubectl proxy
Copy paste the token to http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/

Old version (deprecated)

Run the following command powershell (not cmd) ((kubectl -n kube-system describe secret default | Select-String "token:") -split " +")[1]
Copy the generated token
Run kubectl proxy.
Open the following link on your browser: http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/
Select Token & paste the generated token
Sign In

Finally

If everything is configured properly you'll be able to see the dashboard and your cloud resources. From there you can do almost all the "hard" work without dealing with the CLI every time. You may sometimes get your hands dirty with the command line but if you don't understand the concept of Docker and Kubernetes or you don't have time to for maintaining your own cloud, it's better to stick with some PaaS providers that can cost you a fortune.

Support

If you liked this article please follow me on Twitter :)
https://twitter.com/devcrafter91

Elegant way to check if a Promise is pending

Drakos — Sun, 12 Jul 2020 19:20:42 +0000

Intro

There's no solid way to check if a Promise is pending or finished, at least not in Node.js, so I wrote this simple snippet back in few months ago while I was searching for a simple way. I couldn't' find anything with one line max that will check the state of a promise so I came up with this simple solution. I have posted this solution on StackOverflow too. It's nothing special just an elegant & hacky way but works flawlessly on every Node.js version from 8~14. It's not stable though and the rational solution here should be a native method inside V8's core to check if a promise is pending or not.

The trick

If we take the whole object of a promise and inspect it using the inspect method from the native libraries of Node.js, we will get either 'Promise { <pending> }' while pending or 'Promise { undefined }' when finished.
Now if we check the string for the word pending we could define the state and check if a promise is pending or not using the following one line: util.inspect(myPromise).includes("pending").

Here's an example to get you started:

const util = require("util")

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

(async ()=>{
  let letmesleep = sleep(13000)
  setInterval(()=>{
    console.log(util.inspect(letmesleep).includes("pending"))
  },1000)
})()

Result

true
true
false
false
false

Support

If you liked this article please follow me on Twitter :)
https://twitter.com/devcrafter91