DEV Community: Sameer Gurung

How to run Serverless offline?

Sameer Gurung — Mon, 30 Mar 2020 02:46:00 +0000

Photo by Aleksandar Cvetanovic on Unsplash

In this blog, I will be demonstrating you how to run Serverless Offline using a serverless plugin that emulates AWS λ and API Gateway on your local machine to speed up your development cycles. It helps us save time as we can see logs and also debug in our local machine rather than on cloud vendors.

Local environment reduces conflict with our team members who might be dependant on using the same function (even though in development) that you are working on and might get confused to why the function is not working whilst it was working before. You can make any changes and trials carefree as you will be the only one using this environment (unless you share it to the network) 😜.

This blog is for those who already know basics of Serverless Framework and its workarounds.

The Serverless Framework helps you build serverless apps with radically less overhead and cost. It provides a powerful, unified experience to develop, deploy, test, secure and monitor your serverless applications. — Serverless Framework

Steps:

Since you already know the basics of Serverless Framework, you must have installed the framework. Next, install the package serverless-offline from npm.

Install package — serverless-offline

npm install serverless-offline --save-dev

Add this installed plugin to your serverless project.

plugins:

  - serverless-offline

Run serverless offline using command:

> serverless offline 

or

> sls offline

You can see the list of available endpoints on http://localhost:3000/ and also use http://localhost:3000/ a base endpoint. Additional usage and command line options are available on the plugin’s official documentationpage.

Reference:

https://github.com/dherault/serverless-offline

Git basics in a FLASH!

Sameer Gurung — Thu, 19 Mar 2020 10:59:54 +0000

Photo by Yancy Min on Unsplash

Hello World! Apart from adding, committing and pushing files to the repository, here are some common git operations, in a flash!

1. Branching

Branching is necessary when you want to work on a new feature (or for other reasons) and separate your code from master branch.

Create a branch and checkout:

git checkout -b nameOfYourNewBranch

Delete a local branch :

git branch -d branchName

Delete a remote branch:

git push origin -d branchName

2. Merging

Merging a branch is necessary because you might want to merge a feature branch to the master branch.

# Start a new feature

git checkout -b new-feature master

# Edit some files

git add <file>

git commit -m “Start a feature”

# Edit some files

git add <file>

git commit -m “Finish a feature”

# Merge in the new-feature branch

git checkout master

git merge new-feature

# Delete the new-feature branch

git branch -d new-feature

3. Stashing

Stashing is used when you temporarily want to put away your change and have the clean woking tree. Don’t worry, you will be able to get your stashed changes back.

Stashing current work:

git stash

Listing stashes

git stash list

Importing latest stash:

git stash pop

Importing particular stash if more than one:

git stash pop stash@{n}

Dropping stash:

git stash drop stash@{n}

Here, n refers to a number, 0, 1, 2… which represents which stash to delete.

4. Cleaning Cache

Cleaning cache is required when you want to remove previously added files which you don’t want to track anymore.

Clean all git cache:

git rm -r --cached .

Clean cache of only required file:

git rm fileName --cached

5 JavaScript array methods you need to know!

Sameer Gurung — Thu, 06 Feb 2020 03:06:01 +0000

Photo by Mohamad Mahdi Abbasi on Unsplash

These are some JavaScript array methods you need to know to make your life a bit easier.

1. Array.map()

The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.

const array1 = [1, 4, 9, 16];

// pass a function to map
const map1 = array1.map(x => x \* 2);

console.log(map1);
// expected output: Array [2, 8, 18, 32]

2. Array.find()

The find() method returns the value of the first element in the provided array that satisfies the provided testing function.

const array1 = [5, 12, 8, 130, 44];

const found = array1.find(element => element > 10);

console.log(found);
// expected output: 12

3. Array.filter()

The filter() method creates a new array with all elements that pass the test implemented by the provided function.

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

4. Array.forEach()

The forEach() method executes a provided function once for each array element.

const array1 = ['a', 'b', 'c'];

array1.forEach(element => console.log(element));

// expected output: "a"
// expected output: "b"
// expected output: "c"

5. Array.slice() and Array.splice()

The slice() method returns a shallow copy of a portion of an array into a new array object selected from begin to end (end not included) where begin and end represent the index of items in that array. The original array will not be modified.

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

The splice() method changes the contents of an array by removing or replacing existing elements and/or adding new elements in place.

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "June"]

months.splice(4, 1, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "May"]

References:

How to check unused npm packages?

Sameer Gurung — Mon, 06 Jan 2020 23:11:52 +0000

Meme showing node_modules as heaviest object in the universe. (source: https://bit.ly/2IG40Wb)

I know… I know… After a streak of installing various npm (Node Package Manager) modules, you tend to forget which ones you still use and which ones you already abandoned. Of course, you can check it manually, but why the hassle when you already have a solution?

Let me introduce you to this genie — ‘depcheck’

Depcheck is a tool for analyzing the dependencies in a project to see: how each dependency is used, which dependencies are useless, and which dependencies are missing from package.json. — npmjs

Let’s start by installing the package depcheck from npm registry. You can install it globally by entering the following code in your terminal:

npm install -g depcheck

Note: depcheck needs node.js >= 6

Now, navigate to the folder where you want your dependencies to be checked. Then enter:

depcheck

It takes a while depending upon the project’s complexity and then provides you with results which is similar to the output shown below:

depcheck performed in freshly installed ionic 4 project

You can also pass additional parameters according to your need:

depcheck [directory] [arguments]

The [directory] argument is the root level directory of the project where package.json file is present. It defaults to current directory if not specified.

The [arguments] parameter can be used to specify different flags to customise our output. For example: --ignore-bin-packages=true ignores the packages containing bin entry.

Full usage instructions can be found in: https://www.npmjs.com/package/depcheck#usage

Don’t want to install ‘depcheck’? No problem:

If you don’t want to install depcheck , you can use npx to run it without installing globally in your machine.

If you don’t have npx , install it globally by:

npm install -g npx

Then, run depcheck by:

npx depcheck

Here,npx will execute the command either from local node_modules/.bin or from a central cache and installs any packages if required.

Enjoy! 👌

References:

Rendering JSON data in HTML

Sameer Gurung — Mon, 06 Jan 2020 23:10:04 +0000

Photo by Warren Wong on Unsplash

Tired of teaching your non-IT colleagues how to see what they got as a result from the API? Or are you yourself tired of opening the console?

Try displaying them in HTML using “Renderjson”.

Renderjson is a simple JavaScript package which render JSON into collapsible, themeable HTML. It can be used as debugging tool, however you are the boss and you can use it wherever it is useful.

Renderjson example

The code renders the JSON lazily, only building the HTML when the user reveals the JSON by clicking the disclosure icons. This makes it extremely fast to do the initial render of huge JSON objects, since the only thing that renders initially is a single disclosure icon.

Installing Plugin:

npm i renderjson

Example Usage:

<div **id** ="test"></div>

<script **type** ="text/javascript" **src** ="renderjson.js"></script>

<script>

document.getElementById("test").appendChild(

renderjson({ hello **:** [1,2,3,4], there **:** { a **:** 1, b **:** 2, c **:** ["hello", null] } })

);

</script>

Just call the library in whatever way/tech you are using and then append the result of the JSON data passed on to renderjson() function. It takes in the JSON you want to render as a single argument and returns an HTML element.

Options:

Call set_show_to_level() to show different amounts of the JSON by default. The default is 0, and 1 is a popular choice. As a special case, if level is the string "all" then all the JSON will be shown by default. This, of course, removes the benefit of the lazy rendering, so it may be slow with large JSON objects.

renderjson.set\_show\_to\_level(level);

Other options are discussed in the plugin page: https://www.npmjs.com/package/renderjson#options

References used are from the plugin’s official website: https://github.com/caldwell/renderjson

How to duplicate an existing Zoho configuration to a new account?

Sameer Gurung — Wed, 20 Nov 2019 05:05:00 +0000

Photo by Mark Duffel on Unsplash

Copying existing configuration from current Zoho account to a new one is termed as Copying Customization in Zoho. According to Zoho’s knowledge base:

Copying Customization

Larger companies with multiple branches or services may require multiple CRM accounts. However, the core requirements remains the same for each CRM. Hence companies do not want to waste time cutomizing each CRM account individually. Zoho CRM comes with a solution to this problem in the form of Copy Customization. This feature allows users to duplicate the custom settings of one CRM account into another account.

Notes before starting

You can use the Copy Customization feature to copy system-level configurations to the target accounts.
Permission Required: Users with the Administrator profile can access this feature.
Copy Customization requires having both the user accounts with same Edition. For example, you cannot copy the customizations from Professional Edition to Enterprise Edition. Both account A and B should have the same Paid Edition. Account B can also be the Trial Version of the Paid Edition.
The source account should not have a company logo in the template while copying the customization. (Don’t know why this is there.)
You need the User ID (email address) of the CRM account to which the customization needs to be copied.
The destination account must be a new one. Copy customization does not work for older CRM accounts. No customization should be created in target account.
Keep in mind that the data centre of the source and destination both needs to be in the same region. The customization cannot be copied across different data centres. (As per their support, this can be selected while creating an account in Zoho at first. To find out in which region the account’s data centre is, we need to look at the url in the address bar. For example: crmplus.zoho.com is from the US and crmplus.zoho.com.au is from AU.)
This is a one-time process and you cannot process “Copy Customization” a second time for the same customer.
The values of lookup or multi-select lookup fields will not be copied from the source to the destination account.

Process Copy Customization

The Copy Customization feature helps organizations get the same custom settings across all their CRM accounts with reduced effort and time. The Zoho CRM user will need to specify the User ID (email address) of the CRM account to which the customization needs to be copied. With this feature, you can copy the various customizations that include Fields, Sections, Page Layouts, Tabs, Custom Reports, Email & Inventory Templates, and Logos.

To process copy customization

Go to Setup > Customization > Copy Customization.
In the Copy Customization page, specify the User Email (email address) of the CRM account to which the customization needs to be copied.
Click Copy. An email will be sent to the Super Administrator of the target account. The Copy Customization scheduler starts only after the customer (Super Administrator) confirms the process.

Note: A table listing out the customizations that will be copied and the ones that will not be is shown in here.

Based upon my experience, copy customization is not a piece of cake and requires configurations as above to match. I will be updating the issues as I encounter more of those.

Reference:https://help.zoho.com/portal/kb/articles/copy-customization

Writer’s note: This article is an extension of the article referenced above.

Git push to new repo from existing repo’s branch

Sameer Gurung — Tue, 01 Oct 2019 06:09:55 +0000

Project setup to git push from my-project repository (repo) to new-project repo

While working with multiple projects, you might have encountered a situation where you need to create a new project from existing project’s (repo) some branch. We can always do it manually by copying and pasting and uploading it to new repo.

However, this is another “better way” to achieve this, with the help of git itself.

Lets start by adding new remote repository into existing git project:

 **Go to current project:** 

$ cd my-project

**List current remote:** 

$ git remote -v
originhttps://github.com/my-org/my-project (fetch)
originhttps://github.com/my-org/my-project (push)

**Add new origin (origin2): git remote add origin2 <git\_url>**

$ git remote add origin2 https://github.com/my-org/new-project

(By default, git uses origin, so lets add new origin as origin2)

**Lets see recently added origin:** 

$ git remote -v
originhttps://github.com/my-org/my-project (fetch)
originhttps://github.com/my-org/my-project (push)
origin2 [https://github.com/my-org/new-project](https://github.com/my-org/new-project) (fetch)
origin2 [https://github.com/my-org/new-project](https://github.com/my-org/new-project) (push)

Pushing ‘master’ branch to the new repository:

The following command pushes master branch of current repo to master branch of new repo with remote configured as origin2.

**$ git push <remote\_name> <remote\_repo\_branch>**

$ git push origin2 master

Pushing specific branch:

The following command pushes specific branch (say dev) of current repo to master branch of new repo with remote configured as origin2.

**$ git push origin2 <source\_branch>:<destination\_branch>**

$ git push origin2 dev:master

**Use --force (to forcefully push into that new branch if required)**

$ git push origin2 <source\_branch>:<destination\_branch> --force

Removing previous commits or tracking history of current repository:

If you want to push to the new repo without all the history of the existing repo, then you can create new orphan type branch which does not record previous history. Then push this new branch to our desired repo:

git checkout --orphan clean-branch

**Add the files and commit:**

$ git add . && git commit -m "initial commit to new repo"

Push to new repository from the new clean-branch:

**git push origin2 <source\_branch>:<destination\_branch>**

i.e;

$ git push origin2 clean-branch:master

Note: You can push to origin2 from new clean-branch created locally and don’t need to push this new clean-branch to server.

Deleting branch:

You can delete the newly created local branch if you wish. Just checkout to a different branch than the one you want to delete and then delete using commands:

**Checkout another branch:**

$ git checkout master

**Delete the newly created branch:**

$ git branch -D clean-branch