{"componentChunkName":"component---src-templates-tag-js","path":"/tags/deno/","result":{"data":{"site":{"siteMetadata":{"title":"LoginRadius Blog"}},"allMarkdownRemark":{"totalCount":7,"edges":[{"node":{"fields":{"slug":"/engineering/guest-post/how-to-implement-jwt-authentication-in-deno/"},"html":"

Introduction

\n

It is essential to protect your APIs for a secure experience, and JSON Web Token (JWT) authentication allows you to protect your APIs so that an unauthorized person will not have access.

\n

Prerequisites

\n

This is a hands-on tutorial to follow. To get the most out of it, ensure you have:

\n\n

What is Deno?

\n

Deno is developed in Rust. It is a modern runtime environment for JavaScript/TypeScript and a WebAssembly that uses the Google V8 engine. It is simple and safe. It implements web platform standards and provides web platform capabilities.

\n

Deno’s features are intended to enhance Node.js’s capabilities. It’s secure by default, with no access to files, networks, or the environment except explicitly enabled. And it supports both JavaScript and TypeScript out of the box.

\n

Why Use Deno?

\n

Deno is a well-thought-out modular system. Apart from its simplicity and high security, there are so many other reasons to use Deno:

\n\n

What is JSON Web Token?

\n

JSON Web Token, popularly called JWT, is an open standard that offers a concise and self-contained method for securely transferring data between parties as a JSON object. It holds information in an easy-to-access format for developers and computers; the token's compact size makes it simple to send through URL, POST parameter, or HTTP header. It allows two parties — a client and a server — to share information securely. A secret or public/private key pair is used to digitally sign the information in a JWT.

\n

Authentication is the primary use of JWT. It is assigned to a user after they sign in to an application, and with the assigned JWT, a user can request other routes.

\n

Install Deno

\n

Without too many shenanigans, let's start by installing Deno!

\n

Deno installation in Windows isn't as smooth sailing as on Mac or Linux. Unlike in Node.js, where you run a command on your terminal, Deno in Windows can be installed using PowerShell, Scoop (a command-line installer), or Chocolatey (a package manager). Click here for the guide on how to install Deno.

\n

To install Deno with PowerShell, open your PowerShell and run the following command:

\n
iwr https://deno.land/x/install/install.ps1 -useb | iex
\n

Relax while Deno is being installed. When completed, exit PowerShell and close and reopen a terminal. The new PATH is activated by closing and reopening the terminal. Now that you have installed Deno, let's check the version of Deno.

\n

To check the version of your installed Deno, run: deno -V

\n

Project Setup

\n

With installation out of the way, let us set up your project. Create a folder DenoAPI_JWT_Auth; you can call it any name you choose. Create an app.ts file and a folder src in your folder.

\n

Inside your src folder, create the following folders: controllers, database, middlewares, routes, schema, and utils.

\n

Your project directory should look as follows:

\n

DenoAPI_JWT_Auth

\n

│\n└─src
\n│ └───controllers
\n│ │\n│ └───database
\n│ │\n│ └───middlewares
\n│ │\n│ └───routes
\n│ │\n│ └───schema
\n│ │\n│ └───utils
\n└─app.ts

\n

Create Oak Server

\n

Next is to create your Oak server. Oak is a Deno middleware system that provides a router middleware for HTTP servers.

\n

Go to app.ts, import Application from the Deno Oak URL, create an instance of the application, define your port, and call a middleware, as follows.

\n

app.ts

\n
import { Application } from "https://deno.land/x/oak/mod.ts";\n\nconst app = new Application();\nconst PORT = 8080;\n\n   app.use((ctx, next) => {\n       ctx.response.body = 'Welcome';\n        next();\n       });\n\nconsole.log(`Application is listening on port: ${PORT}`);\n\nawait app.listen({port:PORT});
\n

Let's quickly run your server: to run the server, use deno run --allow-net app.ts

\n

Deno will always request permission to use your network. --allow-net gives Deno permission to all network calls.

\n

You should see Application is listening on port: 8080

\n

Now, in your routes folder, create a file called allRoutes.ts, and set up your router by importing Router from the oak URL, then create an instance of the router and export the default router.

\n

routes.allRoutes.ts

\n
import { Router } from "https://deno.land/x/oak/mod.ts";\n\nconst router = new Router();\n\nexport default router;
\n

Moving on, you need to modify app.ts. So, go to app.ts and import the router. Let the app use router.routes() and router.allowedMethods() methods, then remove the middleware, so it doesn't overshadow the imported routes. The allowedMethods() tells Deno to include all routes by your router.

\n

app.ts

\n
import { Application } from "https://deno.land/x/oak/mod.ts";\nimport router from "./src/routes/allRoutes.ts";\n\nconst app = new Application();\nconst PORT = 8080;\n\napp.use(router.routes());\napp.use(router.allowedMethods());\n\nconsole.log(`Application is listening on port: ${PORT}`);\n\nawait app.listen({port:PORT});
\n

You can rerun your app with the same command: deno run --allow-net app.ts

\n

Create User Data

\n

Now, you need to create user data. But before that, let's connect your application to the MongoDB database.

\n\n

database.connectDB.ts

\n
import { MongoClient } from "https://deno.land/x/mongo@v0.30.0/mod.ts";\n\n  // Connecting to a Mongo Database\n  const client = new MongoClient();\n  \n  const dbString = "DB_String"\n\n  await client.connect(dbString)\n  \n console.log("Database connected!");\n \n const db = client.database("deno_auth");\n\n export default db;\n
\n

With that out of the way, let's create an interface for your database.

\n

In your schema folder, create a file user.ts, import objectId from deno MongoDB URL, then define and export your schema.

\n

schema.user.ts

\n
import {ObjectId} from "https://deno.land/x/mongo@v0.30.0/mod.ts";\n\nexport interface UserSchema {\n    _id: ObjectId;\n    username: string;\n    password: string;\n  }
\n

Let's play with some logic: go to your controllers folder, and create a file called users.ts. In the file, import your database and UserSchema.

\n

It's not a good practice to store your password in plain text for security reasons. To has your password, let's import bcrypt from the deno bcrypt URL.

\n

So, create a function called signup that takes username and password. Take the user details from the request body, hash the password, and save them to your database.

\n

controllers.users.ts

\n
import db from "../database/connectBD.ts";\nimport * as bcrypt from "https://deno.land/x/bcrypt/mod.ts";\nimport { UserSchema } from "../schema/user.ts";\n\nconst Users = db.collection<UserSchema>("users");\n\nexport const signup = async({request, response}:{request:any;response:any}) => {\n    const {username, password} = await request.body().value;\n    const salt = await bcrypt.genSalt(8);\n    const hashedPassword = await bcrypt.hash(password, salt);\n\n    const _id = await Users.insertOne({\n        username,\n        password:hashedPassword\n      });\n      response.status =201;\n      response.body = {message: "User created", userId:_id, user:username}\n      \n};
\n

Now, head over to allRoutes.ts in your routes folder, import the signup function from the controller, and create a POST route for signup, as follows.

\n

routes.allRoutes.ts

\n
import { Router } from "https://deno.land/x/oak/mod.ts";\nimport {signup} from "../controllers/users.ts";\n\nconst router = new Router();\n\n//User routes\nrouter.post("/api/signup", signup)\n\nexport default router;
\n

Create Authenticate User route

\n

Next, create an authentication route that authenticates your user route. The latest version of Deno does not allow a string as a secret key but accepts a cryptokey generated from a Web Crypto API with the generatekey() method of the SubtleCrypto interface.

\n

So, head over to your utils folder, create a file called apiKey.ts, and in the file, generate your key and export it, as follows.

\n

utils.apiKey.ts

\n
export const key = await crypto.subtle.generateKey(\n    { name: "HMAC", hash: "SHA-512" },\n    true,\n    ["sign", "verify"],\n  );
\n

Now that you have successfully created your key, you can create a user authentication route so that every user that logs in will get authenticated.

\n

Head over to user.ts in your controller, import the API key, create a signin function, and write some validation logic to validate that the user exists in your database. If validation is successful, you create a token to authenticate the user.

\n

Using JWT to Authenticate a User

\n

Now, let's import Deno JWT (djwt) create function from the URL to create a token. When a user logs in, take the id and username, pass the payload into the JWT create function, generate a token, and use the token to authenticate the user.

\n

controllers.users.ts

\n
import db from "../database/connectDB.ts";\nimport * as bcrypt from "https://deno.land/x/bcrypt/mod.ts";\nimport { UserSchema } from "../schema/user.ts";\nimport { create } from "https://deno.land/x/djwt@v2.4/mod.ts";\nimport { key } from "../utils/apiKey.ts";\n\nconst Users = db.collection<UserSchema>("users");\n\n    //create a user\n    export const signup = async({request, response}:{request:any;response:any}) => {\n    const {username, password} = await request.body().value;\n    const salt = await bcrypt.genSalt(8);\n    const hashedPassword = await bcrypt.hash(password, salt);\n\n    const _id = await Users.insertOne({\n        username,\n        password:hashedPassword\n      });\n      response.status =201;\n      response.body = {message: "User created", userId:_id, user:username}     \n};\n\n   //sign in a user\n    export const signin = async ({request, response}:{request:any; response:any}) => {\n\n    const body = await request.body();\n    const {username, password} = await body.value;\n\n    const user = await Users.findOne({username});\n\n    if(!user) {\n        response.body = 404;\n        response.body = {message: `user "${username}" not found`};\n        return;\n    }\n    const confirmPassword = await bcrypt.compare(password, user.password);\n    if(!confirmPassword){\n        response.body = 404;\n        response.body = {message: "Incorrect password"};\n        return;\n    }\n    \n    //authenticate a user\n    const payload = {\n        id: user._id,\n        name: username\n    };\n    const jwt =  await create({ alg: "HS512", typ: "JWT" }, { payload }, key);\n\n    if(jwt) {\n        response.status = 200;\n        response.body = {\n            userId: user._id,\n            username: user.username,\n            token: jwt,\n        }\n     } else {\n        response.status = 500;\n        response.body = {\n            message: "internal server error"\n        }\n    }\n        return;\n    }
\n

So far, you have progressed well. The next thing is to import your signin function in the routes and create a post request for it, as follows.

\n

routes.allRoutes.ts

\n
import { Router } from "https://deno.land/x/oak/mod.ts";\nimport {signup, signin} from "../controllers/users.ts";\n\nconst router = new Router();\n\n//User routes\nrouter.post("/api/signup", signup)\n      .post("/api/signin", signin);\n      \n\nexport default router;
\n

Congratulations on making it this far! You are through with the authentication route. Now, you can register a user, sign in, and authenticate the user.

\n

You need to create your todo CRUD API and protect the routes so that a random person will not be able to access your route except when authenticated.

\n

Go to your schema folder, and create a file task.ts. In the file, create your tasks interface and export it.

\n

Create Todo Route

\n

schema.task.ts

\n
export interface TaskSchema {\n    name: string;\n    isCompleted: boolean;\n  }
\n

After successfully creating the task interface, move to our controller, create a file tasks.ts, and import the database, schema, and object Id. Then write the logic for our todo CRUD API.

\n

controllers.tasks.ts

\n
import db from "../database/connectDB.ts";\nimport { TaskSchema } from "../schema/task.ts";\nimport {ObjectId} from "https://deno.land/x/mongo@v0.30.0/mod.ts";\n\nconst tasks = db.collection<TaskSchema>("tasks");\n\nexport const create = async({request, response}:{request:any;response:any}) => {\n    const {name, isCompleted} = await request.body().value;\n\n    const _id = await tasks.insertOne({\n        name,\n        isCompleted\n      });\n      response.body = {message: "Task created!!", id:_id, name:name, Completed:isCompleted}\n    };\n\n    export const getTasks = async ({response}:{response:any}) => {\n    const allTasks = await tasks.find({}).toArray();\n\n    response.status = 200;\n    response.body = {tasks:allTasks};\n  };\n\n    export const getById = async ({\n    params,\n    response\n   }:{\n    params:{taskId:string};\n    response:any;\n  }) => {\n    const taskId = params.taskId;\n    const task = await tasks.findOne({_id:new ObjectId(taskId)});\n\n    if(!task){\n        response.body = {message: `no task with Id: ${taskId}`};\n        return;\n}\n    response.status = 200;\n    response.body = {task: task}\n};\n\nexport const updateById = async ({\n    params,\n    request,\n    response\n}:{\n    params:{taskId:string};\n    request:any;\n    response:any;\n}) => {\n    const taskId = params.taskId;\n    const {name, isCompleted} = await request.body().value;\n    const task = await tasks.updateOne({_id:new ObjectId(taskId)},\n    {$set:{name:name, isCompleted:isCompleted}});\n\n    response.status = 200;\n    response.body = {message:"Updated task", task:task};\n};\n\nexport const deleteTask = async ({\n    params,\n    response,\n}:{\n    params:{taskId:string};\n    response:any;\n}) => {\n    const taskId = params.taskId;\n    const task = await tasks.deleteOne({_id:new ObjectId(taskId)});\n    response.status = 200;\n    response.body = {message:"Deleted task", task:task};\n};
\n

With that out of the way, you need to create your todo CRUD routes. So, head over to allRoutes.ts and import the CRUD functions from the task controllers, then create the routes for our todo, as follows.

\n

routes.allRoutes.ts

\n
import { Router } from "https://deno.land/x/oak/mod.ts";\nimport {signup, signin} from "../controllers/users.ts";\nimport {create, getTasks, getById, updateById, deleteTask} from "../controllers/tasks.ts";\n\nconst router = new Router();\n\n//User routes\nrouter.post("/api/signup", signup)\n      .post("/api/signin", signin);\n\n//Task routes\nrouter.post("/api/tasks", create)\n      .get("/api/tasks", getTasks)\n      .get("/api/tasks/:taskId", getById)\n      .patch("/api/tasks/:taskId", updateById)\n      .delete("/api/tasks/:taskId", deleteTask);\n\nexport default router;
\n

Protect Todo Routes

\n

You need to protect your todo routes so that an unauthorized person will not be able to access them.

\n

To protect the todo routes, go to your middlewares folder: create a file called isAuthorized.ts, import the verify function from deno JWT URL, import Context from deno, import the secret key you've created, and create the authorized function.

\n

The authorize function checks if a user has a JWT token, grant the user access if he does, and deny him access if otherwise.

\n

middlewares.isAuthorized.ts

\n
import { verify } from "https://deno.land/x/djwt@v2.4/mod.ts";\nimport { key } from "../utils/apiKey.ts";\nimport { Context } from "https://deno.land/x/oak/mod.ts";\n\nexport const authourized = async (ctx: Context, next:any) => {\n    try{   \n    const headers: Headers = ctx.request.headers;\n    const authorization = headers.get('Authorization');\n    if(!authorization) {\n        ctx.response.status = 401;\n        return;\n    }\n    const jwt = authorization.split(' ')[1];\n\n    if(!jwt) {\n        ctx.response.status = 401;\n        return;\n    }\n    const payload = await verify(jwt, key);\n\n    if(!payload){\n    throw new Error("!payload")\n    }\n     await next();\n     \n     } catch (error) {\n        ctx.response.status = 401;\n        ctx.response.body ={message: "You are not authorized to access this route"}\n        return;\n    }\n};
\n

To protect your todo routes, import the authorized middleware function from the isAuthorized.ts middleware file and pass the middleware into the todo routes to protect them from unauthorized people.

\n

routes.allRoutes.ts

\n
import { Router } from "https://deno.land/x/oak/mod.ts";\nimport {signup, signin} from "../controllers/users.ts";\nimport {create, getTasks, getById, updateById, deleteTask} from "../controllers/tasks.ts";\nimport { authourized } from "../middlewares/isAuthorized.ts";\n\nconst router = new Router();\n\n//User routes\nrouter.post("/api/signup", signup)\n      .post("/api/signin", signin);\n\n//Task routes\nrouter.post("/api/tasks", authourized, create)\n      .get("/api/tasks", authourized, getTasks)\n      .get("/api/tasks/:taskId", authourized, getById)\n      .patch("/api/tasks/:taskId", authourized, updateById)\n      .delete("/api/tasks/:taskId", authourized, deleteTask);\n\nexport default router;
\n

Awesome! Your application is ready, but wait! Don't get too excited yet, relax let's test the application :)

\n

Below is what your final project directory looks like:

\n

DenoAPI_JWT_Auth

\n

│
\n└─src
\n│ └───controllers
\n│ │ └───users.ts
\n│ │ └───tasks.ts
\n│ │\n│ └───database
\n│ │ └───connectDB.ts
\n│ │
\n│ └───middlewares
\n│ │ └───isAuthorized.ts
\n│ │
\n│ └───routes
\n│ │ └───allRoutes.ts
\n│ │\n│ └───schema
\n│ │ └───user.ts
\n│ │ └───task.ts
\n│ │\n│ └───utils
\n│ │ └───apiKey.ts
\n│ │
\n└─app.ts

\n

Test Application

\n

Now that your application is ready, you need to test the various routes to ensure they are working. To test the routes, rerun your server with deno run --allow-net app.ts.

\n

\n \n \n

\n

Sign-in Route

\n

\n \n \n

\n

\n \n \n

\n

Amazing! Now that you have signed up and authenticated a user, the returned token, which shows that the user has been authenticated, can be used to access your todo CRUD APIs.

\n

Accessing the Todo Routes

\n

First, let's try accessing your todo routes without the token...

\n

Create Task Route

\n

\n \n \n

\n

\n \n \n

\n

As you can see, when you tried to create a task, you got a message You are not authorized to access this route because a random person did it without a token.

\n

Now, let's also try accessing the delete by Id route without the token...

\n

Delete Task Route

\n

\n \n \n

\n

\n \n \n

\n

Your todo CRUD APIs have been protected, and the only way a user can access them is by getting authenticated. Now let's log in again and use the returned token to access the todo routes.

\n

\n \n \n

\n

So, you have logged a user in and put the returned Bearer's token in the authorization header. You can access our todo APIs now because, with the bearer's token, you are authorized to access the todo APIs.

\n

Create Task Route

\n

\n \n \n

\n

\n \n \n

\n

Get All Tasks Route

\n

\n \n \n

\n

\n \n \n

\n

Get Task By Id Route

\n

\n \n \n

\n

\n \n

The code for this tutorial is available here on Github. Feel free to clone and extend the features of the application.

\n","frontmatter":{"date":"July 28, 2022","updated_date":null,"title":"How to Implement JWT Authentication for CRUD APIs in Deno","tags":["JWT","Deno","Authentication"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/4d526ec8bb1f9453095b950dfc3c462d/ee604/jwt-authentication-with-deno.png","srcSet":"/static/4d526ec8bb1f9453095b950dfc3c462d/69585/jwt-authentication-with-deno.png 200w,\n/static/4d526ec8bb1f9453095b950dfc3c462d/497c6/jwt-authentication-with-deno.png 400w,\n/static/4d526ec8bb1f9453095b950dfc3c462d/ee604/jwt-authentication-with-deno.png 800w,\n/static/4d526ec8bb1f9453095b950dfc3c462d/f3583/jwt-authentication-with-deno.png 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Ekekenta Odionyenfe Clinton","github":"icode247","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/jwt-authentication-with-deno/"},"html":"

In this blog, we’ll see how to create and validate a JWT(JSON Web Token) in Deno. For this, we’ll be using djwt, the absolute minimum library to make JSON Web Tokens in deno and Oak framework

\n

Before You Get Started

\n

This tutorial assumes you have:

\n\n

What is JWT?

\n

JSON Web Token is an internet standard used to create tokens for an application. These tokens hold JSON data and are cryptographically signed.

\n

Here is how a sample Json Web Token looks like

\n
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsIm
\n

JWT is a good way of securely sending information between parties. Because JWTs can be signed—for, you can be sure the senders are who they say they are. And, as the signature is generated using the header and the payload, you can also verify that the content hasn't been tampered with.

\n

JWT can contain user information in the payload and also can be used in the session to authenticate the user.

\n

If you want to know more about JSON Web Token, We have a very good article about it.

\n

How to generate JWT token in Deno

\n

First, let's set up a Deno server to accept requests, for it, we are using Oak framework, it is quite simple and few lines of codes as you can see below.

\n
// index.ts\nimport { Application, Router } from "https://deno.land/x/oak/mod.ts";\n\nconst router = new Router();\nrouter\n  .get("/", (context) => {\n    context.response.body = "JWT Example!";\n  })\n\nconst app = new Application();\napp.use(router.routes());\napp.use(router.allowedMethods());\n\nawait app.listen({ port: 8000 });
\n

Once our program is ready for accepting request Let's import djwt functions to generate JWT token, In below code we can use a secret key, expiry time for JWT token in 1 hour from the time program will run and we are using HS256 algorithm.

\n

Add the below code in index.ts and update the router as shown below, you can now get a brand new token on http://localhost:8000/generate

\n
// index.ts\n...\n\nimport { makeJwt, setExpiration, Jose, Payload } from "https://deno.land/x/djwt/create.ts";\n\nconst key = "secret-key";\nconst payload: Payload = {\n  iss: "Jon Doe",\n  exp: setExpiration(new Date().getTime() + 60000),\n};\nconst header: Jose = {\n  alg: "HS256",\n  typ: "JWT",\n};\n\n\nconst router = new Router();\nrouter\n  .get("/", (context) => {\n    context.response.body = "JWT Example!";\n  })\n  .get("/generate", (context) => {\n    context.response.body = makeJwt({ header, payload, key }) + "\\n";\n  })\n\n...
\n

Validating a JWT token

\n

Once you get a JWT token you can validate the token by validateJwt function in djwt, let us import the validateJwt and add one more route /validate/:token

\n

Now you can verify any token by passing it to a route like - http://localhost:8000/validate/jwt_token (jwt_token is a placeholder, please replace it with a real JWT token)

\n
// index.ts\n...\n\nimport { validateJwt } from "https://deno.land/x/djwt/validate.ts";\n\n...\n\nrouter\n  .get("/", (context) => {\n    context.response.body = "JWT Example!";\n  })\n  .get("/generate", (context) => {\n    context.response.body = makeJwt({ header, payload, key }) + "\\n";\n  })\n  .get("/validate/:token", async (context) => {\n    if ( context.params && context.params.token && (await validateJwt(context.params.token, key)).isValid) {\n      context.response.body = "Valid JWT\\n";\n    } else {\n      context.response.body = "Invalid JWT\\n";\n    }\n  });\n\n...
\n

Now you know how to generate and verify a JWT token in Deno, you can easily use it in your application, The complete source code used in this blog can be found in this Github Repo

\n","frontmatter":{"date":"July 10, 2020","updated_date":null,"title":"How to create and validate JSON Web Tokens in Deno","tags":["Deno","JWT","JSON Web Token"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.492537313432836,"src":"/static/4f62fb01daec253b0246b5ba0f244846/ee604/deno_jwt.png","srcSet":"/static/4f62fb01daec253b0246b5ba0f244846/69585/deno_jwt.png 200w,\n/static/4f62fb01daec253b0246b5ba0f244846/497c6/deno_jwt.png 400w,\n/static/4f62fb01daec253b0246b5ba0f244846/ee604/deno_jwt.png 800w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/read-and-write-in-a-local-file-with-deno/"},"html":"

In this blog, we will see how we can read and write into a local file with the help of Deno

\n\n

Before You Get Started

\n

This tutorial assumes you have basic knowledge about Deno and you have latest Deno version installed on your system, if you haven't installed Deno on your system or never ran Deno code please look at this great introductory blog - Hello world with Deno

\n

Part 1: Read a file and print text out of it

\n

First, add a file called quotes.txt in the folder you want to run the Deno code, We will read these quotes with the help of Deno

\n
Don't worry about what anybody else is going to do. The best way to predict the future is to invent it. - Alan Kay\nPremature optimization is the root of all evil in programming. - Donald Knuth\nClarity and brevity sometimes are at odds. When they are, I choose clarity.  - Jacob Kaplan-Moss\nOptimism is an occupational hazard of programming; feedback is the treatment. - Kent Beck\nA lot of times, people don't know what they want until you show it to them.  - Steve Jobs\nNine people can't make a baby in a month. - Fred Brooks\nA clever person solves a problem. A wise person avoids it. - Albert Einstein
\n

And then create an index.ts file in which we will write Deno code, we can also write Deno code in javascript instead of Typescript, but as Deno is built on TypeScript we are using Typescript here

\n
const getQuotes = async (fileName: string): Promise<Array<string>> => {\n const decoder = new TextDecoder("utf-8");\n\n const text: string = decoder.decode(await Deno.readFile(fileName));\n return text.split("\\n");\n};\n\nconst quotesArr: Array<string> = await getQuotes("quotes.txt");\n\nconst randomQuote: string =  quotesArr[Math.floor(Math.random() * quotesArr.length)];\nconsole.log(randomQuote);
\n

In the getQuotes function, we are using Deno.readFile #readfile to read the contents of a file as an array of bytes and using TextDecoder to convert the bytes to string and then splitting it in a string array and return

\n

Then we are just picking a randomQuote with Math.random and console.log that on our screen

\n

To run the above code we need to put --allow-read flag in our command as shown below because we need to access the local filesystem to read the file.

\n
deno run --allow-read index.ts
\n

Deno is secure by default, with no file, network, or environment access unless explicitly enabled. You can run deno run --help to see all the available flags for different permissions

\n

Once your program run initially you will see that Deno is compiling the index.ts file and printing a random quote from quotes.txt, if you run the programme again without changing the code it will not compile it again and will just show another random quote.

\n
deno run --allow-read index.ts\nCompile file:///C:/Users/PuneetSingh/Documents/deno_fs/index.ts\nPremature optimization is the root of all evil in programming. - Donald Knuth\n\n\ndeno run --allow-read index.ts\nA lot of times, people don't know what they want until you show it to them.  - Steve Jobs
\n

Part 2: Create a file and write text in it

\n

Let's create another TypeScript file write.ts and put the below code in it

\n
import { readLines } from "https://deno.land/std@v0.52.0/io/bufio.ts";\n\nconsole.log('Start typing...');\n\nconst encoder = new TextEncoder();\nawait Deno.writeFile("input.txt", new Uint8Array());\n\n// Listen to stdin input by readLines\nfor await(const line of readLines(Deno.stdin)) {\n   const data = encoder.encode(line+"\\n");\n   await Deno.writeFile("input.txt", data, {append: true});\n   console.log("Wrote the above text in input.txt\\n") \n}
\n

In the above code we are using readLines to raed user input line by line, Every time we run the code Deno.writeFile(\"input.txt\", new Uint8Array()) will create an empty input.txt file in the folder.

\n

Then const line of readLines(Deno.stdin) in a loop will wait for the user to input any text, as we will give any input Deno.writeFile with {append: true} is used to append data in input.txt

\n

Let's run the program, Once we run it, whatever text we will give to the program through standard input will be written to input.txt

\n
deno run --allow-write write.ts\n\nStart typing...\nThis is a demo for Deno\nWrote the above text in input.txt\n\nIn this demo, we will write some text in a file\nWrote the above text in input.txt
\n

If you check the input.txt file you will found the content which was given as input

\n
This is a demo for Deno\nIn this demo, we will write some text in a file
\n

Now you know how to read from a text file and how to write in a text file with Deno, You can found the complete source code used in the above blog on our Github Repo

\n","frontmatter":{"date":"June 09, 2020","updated_date":null,"title":"Read and Write in a local file with Deno","tags":["Deno"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.6666666666666667,"src":"/static/051c3d60bd1877dbdbc0c04965cdc4db/2a4de/deno_file_system.png","srcSet":"/static/051c3d60bd1877dbdbc0c04965cdc4db/69585/deno_file_system.png 200w,\n/static/051c3d60bd1877dbdbc0c04965cdc4db/497c6/deno_file_system.png 400w,\n/static/051c3d60bd1877dbdbc0c04965cdc4db/2a4de/deno_file_system.png 600w","sizes":"(max-width: 600px) 100vw, 600px"}}},"author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/build-a-cli-tool-using-deno/"},"html":"

What is Deno?

\n

Deno is a JavaScript/TypeScript runtime with secure defaults and great developer experience. It's built on V8, Rust, and Tokio.\nI suggest you watch these talks by Ryan: He talks about his mistakes with Nodejs here and a more in-depth look into deno here

\n
Features
\n\n

Let's Build Something!!!

\n

In this article, we're going to build a simple cli tool to demonstrate some of the features of deno. Our cli will be interacting with a COVID API to fetch live data.

\n
\n

Requirement: make sure you have deno installed. If you don't, refer to this link. It's pretty straightforward.

\n
\n

Deno has the entry file mod.ts so we will follow the same in this article if you are following this article along with the coding you can create a folder named covid-cli, inside that folder you can create a file called mod.ts and copy the below code there.

\n
const { args } = Deno;\nimport { parse } from "https://deno.land/std/flags/mod.ts";\n\nconsole.dir(parse(args));
\n

Here the parse(args, options = {}); contains two parameters where args is an Array and options is an object, let try to run the above code using this cmd.

\n
deno run mod.ts arg1 -f hello --flag World --booleanFlag
\n

After running the above code you will see the output as

\n
{ _: [ "arg1" ], f: "hello", flag: "World", booleanFlag: true }
\n
\n

The first property in the object is always an array containing all arguments that did not have an option associated with them(i.e it doesn't match -f or --flag). If you do not pass a corresponding value to a flag, it defaults to true.

\n
\n

I will be using the this postman doc for all the COVID related API and we will perform the below to action through our CLI.

\n
    \n
  1. A summary of new and total cases globally updated daily.
    2. \n
  2. A summary of new and total cases per country updated daily.
    3. \n
\n

Let's write out the function for our first command, so our mod.ts file will look like this.

\n
const { args } = Deno;\nimport { parse } from "https://deno.land/std/flags/mod.ts";\n\n// flags:\n// -h, --help: display help message\n// -g, --global: display global stats\n// -c, --country: get data of mentioned country\n\nconst BASE_URL: string = "https://api.covid19api.com/"\nconst parsedArgs = parse(args)\n\nasync function getGlobalStats() {\n    const res = await fetch(`${BASE_URL}summary`)\n    const data = await res.json();\n    console.log(data["Global"])\n}
\n

Here, we have an async function that returns the data from our API call. We're making a fetch request (yes, deno has browser functionality in-built) to the API endpoint to get the global stat of covid19.

\n

The function for the second command looks very similar, just we need to filter our data only for a particular country which is provided.

\n
async function getCountryStats(country: string) {\n  if (country) {\n    const res = await fetch(`${BASE_URL}summary`);\n    const data = await res.json();\n    const index = data["Countries"].findIndex((c: any) => c.Country.toLowerCase() === country.toLowerCase())\n    if (index !== -1) {\n        console.log(data["Countries"][index])\n    } else {\n        console.log("Country Not Found")\n    }\n  } else {\n    console.log("Country Name is needed")\n  }\n}
\n

We will now write our main() function. We have a switch statement to check the first flag that was passed and calls the appropriate function. The default case simply displays a welcome message. Let add the below code in our mod.ts file

\n
async function main() {\n  switch (Object.keys(parsedArgs)[1]) {\n    case "help":\n    case "h":\n      console.log(displayHelpMsg());\n      break;\n    case "global":\n    case "g":\n      await getGlobalStats();\n      break;\n    case "country":\n    case "c":\n       let country = parsedArgs.c || parsedArgs.country || ""\n       await getCountryStats(country)\n       break;\n    default:\n       console.log(displayHelpMsg());\n  }\n}\n\nmain()
\n

And our displayHelpMsg() will look something like this

\n
function displayHelpMsg() {\n  return "flags:\\n-h, --help: display help message\\n-g, --global: display global stats\\n-c, --country: get data of mentioned country ";\n}
\n

Testing Time!!!

\n

To test our program, we're going to run $ deno run --allow-net mod.ts -g. We should get the following result:

\n\n

\n \n \n

\n\n

\n here. In conclusion, Deno is a very exciting project especially because you get all the benefits of typescript out of the box without the need to compile your files to js.

\n

You can build a lot with it, ranging from cli Programs to HTTP servers. Do have a look at one of my blog where I have built a basic calculator app using the abc module.

\n","frontmatter":{"date":"June 08, 2020","updated_date":null,"title":"Build A Simple CLI Tool using Deno","tags":["Deno","CLI","Programming"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7857142857142858,"src":"/static/313a3b2de31b5d15db618e72b377a867/ee604/cli-tool.png","srcSet":"/static/313a3b2de31b5d15db618e72b377a867/69585/cli-tool.png 200w,\n/static/313a3b2de31b5d15db618e72b377a867/497c6/cli-tool.png 400w,\n/static/313a3b2de31b5d15db618e72b377a867/ee604/cli-tool.png 800w,\n/static/313a3b2de31b5d15db618e72b377a867/5493e/cli-tool.png 860w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Mohammed Modi","github":"mohammed786","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/create-rest-api-in-deno/"},"html":"

Deno, the creation of Ryan Dahl is a simple, modern, and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. As Deno 1.0.0 has released, there is much-awaited curiosity amongst developers around working with this new stack.

\n

When it comes to learning a new language, the first thing that comes to our mind is the creation of a todo app, supporting CRUD functionality. So here we will be creating a very simple Todo application using the Deno.

\n

So before starting I assume you have installed Deno on your system, if not then you can find the link here.\nFor the database, we will be using the JSON file as of now to completely focus on creating web API using Deno. Not more words and now let's start.

\n

The file structure we are going to follow is as below

\n
  // Final directory structure\n  deno-todo-api/\n    --|controllers/\n      |--|todo.ts\n      |data/\n      |--|todos.ts\n      |interfaces/\n      |--|Todo.ts\n      |routes/\n      |--|todo.ts\n    --|server.ts\n
\n

At any point in time, if you are stuck somewhere, you can follow this link to get the complete code.

\n
    \n
  1. Create a directory named deno-todo-api and move into that directory
    2. \n
\n
  mkdir deno-todo-api && cd deno-todo-api
\n
    \n
  1. Create the file server.ts in the root of the directory.
    2. \n
  2. Write the following code into the server.ts file to start a server
    3. \n
\n
import { Application, Router } from "https://deno.land/x/oak@v17.1.4/mod.ts";\n\nconst app = new Application();\nconst port: number = 8080;\n\nconst router = new Router();\nrouter.get("/", ({ response }: { response: any }) => {\n  response.body = {\n    message: "Rest API tutorial with Deno",\n  };\n});\napp.use(router.routes());\napp.use(router.allowedMethods());\n\nconsole.log('running on port ', port);\nawait app.listen({ port });
\n

Unlike NodeJS Deno does not need the package.json file for dependency management. Dependency management is simplified by having a list of modules and their respective URLs.

\n

Here we have used oak, a middleware framework for Deno's HTTP server, including a router middleware.

\n
    \n
  1. server.ts is the entry point for our web application. To check it run the following command in the root directory
    2. \n
\n
deno run --allow-net server.ts
\n

Open the browser and hit the URL http://localhost:8080/

\n

You can see the following output in your browser

\n

\n \n \n

\n
    \n
  1. Now following the directory structure, we will create following folders in our project with the help of below command
    2. \n
\n
mkdir controllers data interfaces routes
\n
    \n
  1. First of all, we will create dummy data to play with our todo APIs.Go to the data folder and create a file called todos.ts and the following code into it
    2. \n
\n
import { v4 } from "https://deno.land/std/uuid/mod.ts";\n// interface\nimport Todo from '../interfaces/Todo.ts';\n\nlet todos: Todo[] = [\n  {\n    id: v4.generate(),\n    task: 'Hello world app with Deno',\n    done: true,\n  },\n  {\n    id: v4.generate(),\n    task: 'Simple Rest API with Deno',\n    done: false,\n  },\n];\n\nexport default todos;
\n

We will be using v4 provided by the uuid module to generate unique IDs.

\n
    \n
  1. Now create a file in interface/ folder Todo.ts and paste the following code.
    2. \n
\n
export default interface Todo {\n  id: string,\n  task: string,\n  done: boolean,\n}
\n

What are the interfaces??

\n

An interface defines the specifications of an entity.

\n
\n

One of TypeScript’s core principles is that type checking focuses on the shape that values have. In TypeScript, interfaces fill the role of naming these types and are a powerful way of defining contracts within your code as well as contracts with code outside of your project.

\n
\n
    \n
  1. Now create a file named todo.ts in controllers/ directory and paste the following code
    2. \n
\n
import { v4 } from "https://deno.land/std/uuid/mod.ts";\n// interfaces\nimport Todo from "../interfaces/Todo.ts";\n// stubs\nimport todos from "../data/todos.ts";\n\nexport default {\n  getAll: ({ response }: { response: any }) => {\n    response.status = 200;\n    response.body = {\n      data: todos\n    };\n  },\n  create: async (\n    { request, response }: { request: any; response: any },\n  ) => {\n    const body = await request.body();\n    if (!request.hasBody) {\n      response.status = 400;\n      response.body = {\n        message: "Please provide the task detail and  status",\n      };\n      return;\n    }\n    let newTodo: Todo = {\n      id: v4.generate(),\n      task: body.value.todo,\n      done: false,\n    };\n    let data = [...todos, newTodo];\n    response.body = {\n      data\n    };\n  },\n  getById: (\n    { params, response }: { params: { id: string }; response: any },\n  ) => {\n    const todo: Todo | undefined = todos.find((t) => {\n      return t.id === params.id;\n    });\n    if (!todo) {\n      response.status = 404;\n      response.body = {\n        message: "No task found related to given ID",\n      };\n      return;\n    }\n    response.status = 200;\n    response.body = {\n      data: todo\n    };\n  },\n  update: async (\n    { params, request, response }: {\n      params: { id: string },\n      request: any,\n      response: any,\n    },\n  ) => {\n    const todo: Todo | undefined = todos.find((t) => t.id === params.id);\n    if (!todo) {\n      response.status = 404;\n      response.body = {\n        message: "No todo found",\n      };\n      return;\n    }\n\n    const body = await request.body();\n    const updatedData: { task?: string; done?: boolean } = body.value;\n\n    let newTodos = todos.map((t) => {\n      return t.id === params.id ? { ...t, ...updatedData } : t;\n    });\n    response.status = 200;\n    response.body = {\n      data: newTodos,\n    };\n  },\n  delete: (\n    { params, response }: { params: { id: string }; response: any },\n  ) => {\n    const allTodos = todos.filter((t) => t.id !== params.id);\n\n    response.status = 200;\n    response.body = {\n      data: allTodos,\n    };\n  },\n};
\n
    \n
  1. Now go to routes and create todo.ts file in it and paste the following code
    2. \n
\n
import { Router } from "https://deno.land/x/oak/mod.ts";\n\nconst router = new Router();\n// controller\nimport todoController from "../controllers/todo.ts";\n\nrouter\n  .get("/todos", todoController.getAll)\n  .post("/todos", todoController.create)\n  .get("/todos/:id", todoController.getById)\n  .put("/todos/:id", todoController.update)\n  .delete("/todos/:id", todoController.delete);\n\nexport default router;
\n
    \n
  1. Now since we have created the complete MVC project for our todo APIs, we will be going to update our main server.ts file with following code
    2. \n
\n
import { Application, Router } from "https://deno.land/x/oak/mod.ts";\nimport todoRouter from "./routes/todo.ts"; // added the router call\n\nconst app = new Application();\nconst port: number = 8080;\n\napp.use(todoRouter.routes()); // Intitialize the router with our application. \napp.use(todoRouter.allowedMethods());\n\napp.addEventListener("listen", ({ secure, hostname, port }) => {\n  const protocol = secure ? "https://" : "http://";\n  const url = `${protocol}${hostname ?? "localhost"}:${port}`;\n  console.log(`Listening on: ${port}`);\n});\n\nawait app.listen({ port });
\n
    \n
  1. Now run again the server with the following command
    2. \n
\n
deno run --allow-net server.ts
\n

Now open the postman and hit the get URL http://localhost:8080/todos/

\n

\n \n \n

\n

To check the getByID router, copy the ID of any task and hit the URL like

\n

http://localhost:8080/todos/:id

\n

You will be getting output like below

\n
{\n    "data": {\n        "id": "eeacacdc-e55b-4299-aab7-5f631a2e3975",\n        "task": "Hello world app with Deno",\n        "done": true\n    }\n}
\n

Similarly, we can verify the complete crud API created. Below is the reference of all APIs created in the blog post

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
APIMethodDescription
http://localhost:8080/todos/GETFetch All todos
http://localhost:8080/todos/{id}GETFetch todo by ID
http://localhost:8080/todos/POSTCreate New todo
http://localhost:8080/todos/{id}PUTUpdate todo by ID
http://localhost:8080/todos/{id}DELETEDelete todo by ID
\n

You can find the complete code of the repo here

\n","frontmatter":{"date":"June 08, 2020","updated_date":null,"title":"Create REST API using deno ","tags":["Deno","REST","API"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/760c77dba96d96a216f28565d2a442eb/ee604/task.png","srcSet":"/static/760c77dba96d96a216f28565d2a442eb/69585/task.png 200w,\n/static/760c77dba96d96a216f28565d2a442eb/497c6/task.png 400w,\n/static/760c77dba96d96a216f28565d2a442eb/ee604/task.png 800w,\n/static/760c77dba96d96a216f28565d2a442eb/f3583/task.png 1200w,\n/static/760c77dba96d96a216f28565d2a442eb/e4d72/task.png 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Aman Agrawal","github":"aman-agrwl","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/a-webapp-in-deno/"},"html":"

Hello, let's create a simple web app using deno, In this blog, I will be using the Deno Third-Party Module called abc for creating a simple web application.

\n

I am assuming that you are familiar with the basic setup of deno. If not you can start with basic deno installation from here

\n

Simple Web Application

\n

So without wasting time Let's jump into the code and write a simple hello world program using the abc module.

\n

Create a file index.ts, and copy the code there.

\n
import { Application } from "https://deno.land/x/abc@v1.0.0-rc10/mod.ts";\n\nconst app = new Application();\n\napp\n  .get("/hello", (c) => {\n    return "Hello, Abc!";\n  })\n  .start({ port: 8000 });
\n

After saving the file you can run the code using the below cmd

\n
deno run --allow-net=0.0.0.0:8000 index.ts
\n

Explanation:\nDeno is secure by default. Therefore, unless you specifically enable it, a deno module has no file, network, or environment access for example. Access to security-sensitive areas or functions requires the use of permissions to be granted to a deno process on the command line.

\n

--allow-net=\\<allow-net> Allow network access. You can specify an optional, comma-separated list of domains to provide a whitelist of allowed domains. For more information on the different kind of permissions needed in the deno you can visit Permissions in Demo

\n

Now once you run the above cmd you can see the Hello, Abc! in the browser by redirecting to http://localhost:8000/hello

\n

Let's Go Deeper!!!

\n

Now let's try to serve the static file using the abc module. In the above example, app will have lots of different methods that we can use, one of them is static(), it used to serve the static files.

\n

Let us create a folder called public in the root of the project. And inside that create an index.html file. Your index.html will look something like this.

\n
<!doctype html>\n<html>\n    <head>\n        <title>Deno Web Application</title>\n    </head>\n    \n    <body>\n    <div>\n        <h1>Deno Web Application</h1>\n    </div>\n    </body>\n</html>
\n

After creating this file let's modify our index.tsx file by adding the below code.

\n
import { Application } from "https://deno.land/x/abc@v1.0.0-rc10/mod.ts";\n\nconst app = new Application();\n\napp\n  .get("/hello", (c) => {\n    return "Hello World"\n  })\n  .static("/", "./public")\n  .start({ port: 8000 });
\n

Explanation:\nAs you can see .static(\"/\", \"./public\") we have added this route / and we are serving our static file using the static() method provided by the abc module.

\n

static() registers a new route with path prefix to serve static files from the provided root directory.

\n

Let's try to run this using the previous cmd that is

\n
deno run --allow-net=0.0.0.0:8000 index.ts
\n

Oops!! once you try to run this it will compile successfully but when you visit this path\nhttp://localhost:8000/index.html, you will get below error in the browser.

\n
{"statusCode":500,"error":"Internal Server Error","message":"read access to <CWD>, run again with the --allow-read flag"}
\n

It's because as we know deno requires the permission to read the file from the system. Hence to run the above cmd with --allow-read flag will solve our problem. So let's use this cmd to compile our index file.

\n
deno run --allow-read --allow-net=0.0.0.0:8000 index.ts
\n

After successful compile, you will see the output as below.

\n

\n \n \n

\n

Creating a basic calculator app

\n

Hence after the successful serving of our static file, we can also add js in it. Let start with the basic calculator app for now.

\n

Firstly Let's modify our index.html file and add the below code

\n
<html>\n  <head>\n    <script src="script.js"></script>\n    <link rel="stylesheet" type="text/css" href="style.css">\n  </head>\n  <!-- create table -->\n  <body>\n    <div class="title">Deno Calculator App</div>\n    <table border="1">\n      <tr>\n        <td colspan="3"><input type="text" id="result" /></td>\n        <!-- clr() function will call clr to clear all value -->\n        <td><input type="button" value="c" onclick="clr()" /></td>\n      </tr>\n      <tr>\n        <!-- create button and assign value to each button -->\n        <!-- dis("1") will call function dis to display value -->\n        <td><input type="button" value="1" onclick="dis('1')" /></td>\n        <td><input type="button" value="2" onclick="dis('2')" /></td>\n        <td><input type="button" value="3" onclick="dis('3')" /></td>\n        <td><input type="button" value="/" onclick="dis('/')" /></td>\n      </tr>\n      <tr>\n        <td><input type="button" value="4" onclick="dis('4')" /></td>\n        <td><input type="button" value="5" onclick="dis('5')" /></td>\n        <td><input type="button" value="6" onclick="dis('6')" /></td>\n        <td><input type="button" value="-" onclick="dis('-')" /></td>\n      </tr>\n      <tr>\n        <td><input type="button" value="7" onclick="dis('7')" /></td>\n        <td><input type="button" value="8" onclick="dis('8')" /></td>\n        <td><input type="button" value="9" onclick="dis('9')" /></td>\n        <td><input type="button" value="+" onclick="dis('+')" /></td>\n      </tr>\n      <tr>\n        <td><input type="button" value="." onclick="dis('.')" /></td>\n        <td><input type="button" value="0" onclick="dis('0')" /></td>\n        <!-- solve function call function solve to evaluate value -->\n        <td><input type="button" value="=" onclick="solve()" /></td>\n        <td><input type="button" value="*" onclick="dis('*')" /></td>\n      </tr>\n    </table>\n  </body>\n</html>
\n

As you can see the above code we have already imported our js and css inside to so Let's create JS file called script.js and add the following functions in it.

\n
//function that display value\nfunction dis(val) {\n  document.getElementById("result").value += val;\n}\n\n//function that evaluates the digit and return result\nfunction solve() {\n  let x = document.getElementById("result").value;\n  let y = eval(x);\n  document.getElementById("result").value = y;\n}\n\n//function that clear the display\nfunction clr() {\n  document.getElementById("result").value = "";\n}
\n

And also add some css into it by creating style.css file.

\n
.title {\n  margin-bottom: 10px;\n  text-align: center;\n  width: 210px;\n  color: #0d8dcf;\n  border: solid black 2px;\n}\n\ninput[type="button"] {\n  background-color: #0d8dcf;\n  color: black;\n  border: solid black 2px;\n  width: 100%;\n}\n\ninput[type="text"] {\n  background-color: white;\n  border: solid black 2px;\n  width: 100%;\n}
\n

Great!!! Our calculator app is now almost ready, let's save all the file and reload the http://localhost:8000/index.html.

\n

You can see our calculator app in the browser like below.

\n

\n \n \n

\n

If you'd like to see the full code, the repository is linked here.

\n","frontmatter":{"date":"June 03, 2020","updated_date":null,"title":"Creating a Web Application using Deno","tags":["Deno"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.8018018018018018,"src":"/static/f298cd015f4f5a18176173e399b9bd68/14b42/deno.jpg","srcSet":"/static/f298cd015f4f5a18176173e399b9bd68/f836f/deno.jpg 200w,\n/static/f298cd015f4f5a18176173e399b9bd68/2244e/deno.jpg 400w,\n/static/f298cd015f4f5a18176173e399b9bd68/14b42/deno.jpg 800w,\n/static/f298cd015f4f5a18176173e399b9bd68/47498/deno.jpg 1200w,\n/static/f298cd015f4f5a18176173e399b9bd68/ec6c5/deno.jpg 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Mohammed Modi","github":"mohammed786","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/hello-world-deno/"},"html":"

Hello, Deno

\n

Deno is a new platform for writing applications using JavaScript and TypeScript. It is based on the V8 JavaScript engine and the Rust.

\n

Deno’s lowest level binding layer to the system is tied to promises (called ops). Deno is secure by default, provides first-class TypeScript support, has built-in utilities like a dependency inspector, and supports third-party modules such as lodash .

\n

Btw, this is the best damn geeky one-liner code to explain what is Deno. Totally cool.

\n

\n \n \n

\n

Installation

\n

Deno works on macOS, Linux, and Windows. Deno is a single binary executable and it has no external dependencies.

\n

See all installation.

\n

Install Deno on Windows 10/8/7

\n

Launch Windows PowerShell and run the following command to install Deno on Windows 10/8/7

\n
iwr https://deno.land/x/install/install.ps1 -useb | iex
\n

Install Deno on Linux and macOS

\n

Launch terminal and run the following command to install Deno on Linux and Mac

\n
curl -fsSL https://deno.land/x/install/install.sh | sh
\n

Open a new terminal and run deno. You should get a > prompt. Type exit.

\n

After installing deno on your system we just need to create a simple Hello World program by using the following steps :

\n

Step 1. Create a Folder as per your project name by using command prompt

\n
mkdir HelloWorldDeno
\n

Step 2. Create a typeScript file and name it index.ts.

\n

Step 3. Add the following code in index.ts.

\n
const helloWorld = (name: string = "world") => {\n  console.log(`Hello ${name}!!`);\n}\n\nhelloWorld();\n\nhelloWorld("Friend");
\n

Step 4. Run the following project by using the following command

\n
deno run index.ts
\n

You can check the result here

\n

\n \n \n

\n

Yupppp it works this is your first Deno program !!

\n","frontmatter":{"date":"June 02, 2020","updated_date":null,"title":"Hello world with Deno","tags":["Deno","HelloWorld","NodeJs"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/9e27529ebed74724b5d86438b9445e49/ee604/deno.png","srcSet":"/static/9e27529ebed74724b5d86438b9445e49/69585/deno.png 200w,\n/static/9e27529ebed74724b5d86438b9445e49/497c6/deno.png 400w,\n/static/9e27529ebed74724b5d86438b9445e49/ee604/deno.png 800w,\n/static/9e27529ebed74724b5d86438b9445e49/f3583/deno.png 1200w,\n/static/9e27529ebed74724b5d86438b9445e49/e4d72/deno.png 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Ashish Sharma","github":"ashish8947","avatar":null}}}}]}},"pageContext":{"tag":"Deno"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}