DEV Community: Mohamed Amine Griche

build your own deno-dotenv module

Mohamed Amine Griche — Wed, 24 Jun 2020 10:05:23 +0000

Hello DEV,

In the last post we have seen how we can create a REST API using Deno with oak.

Here is the post Simple REST API with Deno if you want to take a look at it.

Today we are going to build a deno-dotenv module inspired from the node dotenv module

What is the node dotenv module ?

Dotenv is a zero-dependency module that loads environment variables from a .env file into process.env. Storing configuration in the environment separate from code is based on The Twelve-Factor App methodology.

for more information: check it's page on npm and it's repository on github.

what is a .env file ?

.env is the file that contains the environment variables you want to load to your application, each line of the .env file has this format KEY=VALUE

example:

HOST=https://www.example.com
PORT=7700
KEY=J46Sq8r4s5d9

With that out of the way, let's get started by defining the steps to create this module:

The main steps

These are the main steps to build this module:

Read the content from the .env.
Parse the environment variables from the content.
Set environment variables in Deno.env.

1. Read the content from the `.env`:

Let's start by creating the mod.ts file and add this function to it

const readFileToStrSync = (filePath: string): string => {
    const bytes = Deno.readFileSync(filePath)
    const fileContent = new TextDecoder("utf-8").decode(bytes)
    return fileContent
}

NOTE: You can name the file however you want, but as a best practice we are going to stick to mod.ts

What does this function do is:

Synchronously reads and returns the entire content of a file as an array of bytes. using the Deno.readFileSync(filePath) function.
Convert the array of bytes to a string using the new TextDecoder("utf-8").decode(bytes) method.
return the content of the file a string.

Now that we have the .env file content let's parse the environment variables in it.

2. Parse the environment variables:

To do that let's add the parse function to the mod.ts file

const LINE_BREAK: RegExp = /\r\n?|\n/

const parse = (envContent: string): string[][] => {
    const envList = envContent.split(LINE_BREAK)
    let parsedContent: string[][] = []
    for ( let i = 0; i < envList.length; i++) {
        parsedContent.push(envList[i].split("="))
    }
    return parsedContent
}

what does this code do is:

The LINE_BREAK is a regular expression that matches the line break.
The parse function takes the content of the .env file as a parameter of type string ( the string returned from the previous function readFileStrSync ), split the content into separate lines ( because each line contain one environment variable with the structure KEY=VALUE ) using the split function with LINE_BREAK RegExp as a parameter, then loop throw all the lines and retrieve the KEY and the VALUE in a form of an array of strings [KEY, VALUE] and push it to the two-dimensional array parsedContent which will be returned when the loop is completed.

Now we have the environment variables in a form of a two-dimensional array, all we have left to do is to set it to the Deno.env so it will be accessible in all the application.

3. Set the environment variables in `Deno.env`:

Now, let's add the setEnv function to the mod.ts file

const setEnv = (parsedEnv: string[][]): void => {
  for (let i = 0; i < parsedEnv.length; i++) {
    Deno.env.set(parsedEnv[i][0], parsedEnv[i][1])
  }
}

This function takes the environment variables in a form of a two-dimensional array ( returned from the parse function ) and add them to the Deno.env object with the Deno.env.set() function.

Now we have all the functions we need created, but they are not doing anything yet, they have to collaborate with each other to provide the functionality we are looking for. So let's just create a function to do that let's give a name of dotenv

const dotenv = (envFilePath?:string) => {
  const filePath: string = envFilePath || ".env"
  const fileContent = readFileToStrSync(filePath)
  const parsedEnv = parse(fileContent)
  setEnv(parsedEnv)
}

This function take an optional parameter envFilePath which is the path to the .env file ( if it's provided the function will use it, if not the function will use '.env' as a path value ), then using this path filePath to read the content of the .env file synchronously using the readFileToStrSync(filePath), then parse the result using the parse(fileContent) function, then uses the parsed result in the setEnv(parsedEnv) function to set the environment variables in the Deno.env object.

4. Finally `export`

Now that we have the functionality create and ready, we need just to export the dotenv function so the users can use it in their apps.

export default dotenv

# Let's test the module

First create a .env file and add some KEY=VALUE pairs, something like:

PASSWORD=1234567
KEY=12T1S654Ts6sc5fsd4Q6np9dx2A

Then create a typescript file, call it test.ts or however you want, import the dotenv function from the dotenv module we just created, and execute it, so that the environment variables will be available to use from the Deno.env object

import dotenv from "./mod.ts"
// or you can use import  if from this URL
// import dotenv from "https://raw.githubusercontent.com/AM-77/deno-dotenv/master/mod.ts"
dotenv()

now create a snapshot of the environment variables from the Deno.env using the Deno.env.toObject() function and just use it:

const env = Deno.env.toObject()
console.log("PASSWORD: ", env.PASSWORD)
console.log("KEY: ", env.KEY)

Run your test.tsusing the flags --allow-read --allow-env

$ deno run --allow-read --allow-env test.ts
PASSWORD: 1234567
KEY: 12T1S654Ts6sc5fsd4Q6np9dx2A

And that's all, we are finished. Thank you.

Here is the source code (I re-factored it a little bit).

Simple REST API with Deno

Mohamed Amine Griche — Thu, 14 May 2020 18:15:09 +0000

After 2 years of its first release, Deno v1.0 is finally here.

So, what is Deno anyway ?

Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. Deno's official website

Ryan Dahl the original creator of Node.js (the popular server-side JavaScript runtime) announced Deno at JSConf EU 2018 on is his talk titled "10 Things I Regret About Node.js" ( From the title you can see where are we heading to ). In another word, if you are familiar with Node.js then Deno is just like that. Except that it's improved in many ways, it's created from bottom to top to be a better implementation of Node.js.

Simple comparison with Node.js

Since Deno and Node.js serve the same purpose, it's possible to compare the two directly.

	Node	Deno
Engine	V8	V8
Written in	C++ & JavaScript	Rust & Typescript
Package managing	package managers: npm	uses URLs
Importing pacakges	CommonJS syntax	ES Modules
Security	full access	permissioned access
TypeScript support	not built in	built in

A Deno tutorial

Let's play a little bit with Deno.

Deno's Installation

To install Deno just copy and paste this command line in your terminal.

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

For more details check Deno's official installation guide.

When it's done, you will have access to the deno command.

You can run deno --help to get the list of the options and subcommands provided by Deno, and you can run deno <subcommand> --help to get additional informations specific the subcommand for example: deno run --help

Now you can run deno or deno repl to open the REPL (Read-Execute-Print-Loop) and start typing some Javascript

$ deno repl
Deno 1.0.0
exit using ctrl+d or close()
> console.log("Hello World !")
Hello World !

For the mean time (depending on when you're reading this) on May 14 2020 the REPL supports only Javascript:

There are many things we can do to improve the REPL without introducing the TS compiler. We should do those things first (e.g. improve inspect, tab completion). Once we're on par with Node's REPL, we can start looking into how to go beyond that by using typescript. Ryan Dahl's comment on TypeScript support in REPL

Run a Deno app

Use deno run <entry-point> command to launch a Deno app.

The entry point can be .js file, .ts file or even a URL that points to an app entry point and Deno will download, compile and then run it for you:

for example: deno run https://deno.land/std/examples/welcome.ts

$ deno run https://deno.land/std/examples/welcome.ts
Download https://deno.land/std/examples/welcome.ts
Compile https://deno.land/std/examples/welcome.ts
Welcome to Deno 🦕

If you run the program again, it gets compiled directly it does not need to be downloaded again, it's now cached by Deno:

$ deno run https://deno.land/std/examples/welcome.ts
Compile https://deno.land/std/examples/welcome.ts
Welcome to Deno 🦕

You can force a reload of the original source with the --reload flag

deno run --reload https://deno.land/std/examples/welcome.ts

And If you open the https://deno.land/std/examples/welcome.ts URL with the browser, you'll get the page that contains the code and it's documentation.

The Deno website provides other examples in the examples page.

Let's build a simple REST API

We are going to use oak framework and Typescript (you can also use Javascript if you want to)

Let's start by creating an app.ts file that imports the Application from https://deno.land/x/oak/mod.ts and the router from './router.ts'

import { Application } from 'https://deno.land/x/oak/mod.ts'
import router from './routes.ts'

then we need to set the environment variables HOST and PORT

const HOST = '127.0.0.1'
const PORT = 7700

Now let's create the routes.ts file import Router from https://deno.land/x/oak/mod.ts and create the routes.

import { Router }from 'https://deno.land/x/oak/mod.ts'
import { getBooks, getBook, addBook, updateBook, deleteBook } from './controller.ts'

const router = new Router()
router.get('/books', getBooks)
      .get('/books/:isbn', getBook)
      .post('/books', addBook)
      .put('/books/:isbn', updateBook)
      .delete('/books/:isbn', deleteBook)

export default router

NOTE: the functions getBooks, getBook, addBook, updateBook and deleteBook are imported from a local file, it's just we haven't created them yet.

After creating the router, let's finish our app.ts by adding this code to it,

const app = new Application()

app.use(router.routes())
app.use(router.allowedMethods())

console.log(`Listening on port ${PORT} ...`)
await app.listen(`${HOST}:${PORT}`)

Now, let's create the controller.ts file and define an interface for a book IBook, then we declare an initial array of book objects:

interface IBook {
  isbn: string;
  author: string;
  title: string;
}

let books: Array<IBook> = [{
  isbn: "1",
  author: "Robin Wieruch",
  title: "The Road to React",
},{
  isbn: "2",
  author: "Kyle Simpson",
  title: "You Don't Know JS: Scope & Closures",
},{
  isbn: "3",
  author: "Andreas A. Antonopoulos",
  title: "Mastering Bitcoin",
}]

Now let's implement the functions one by one

getBooks: returns all the books on the list.

const getBooks = ({ response }: { response: any }) => { 
  response.body = books 
}

getBook: returns a single book by its isbn, or error message if not found.

const getBook = ({ params, response }: { params: { isbn: string }; response: any }) => {
  const book: IBook | undefined = searchBookByIsbn(params.isbn)
  if (book) {
    response.status = 200
    response.body = book
  } else {
    response.status = 404
    response.body = { message: `Book not found.` }
  }   
}

addBook: add a book to the books list.

const addBook = async ({ request, response }: { request: any; response: any }) => {
  const body = await request.body()
  const book: IBook = body.value  
  books.push(book)
  response.body = { message: 'OK' }
  response.status = 200
}

updateBook: updates a book if exists, return error message if not.

const updateBook = async ({ params, request, response }: { params: { isbn: string }; request: any; response: any }) => {
  let book: IBook | undefined = searchBookByIsbn(params.isbn)
  if (book) {
    const body = await request.body()
    const updateInfos: { author?: string; title?: string } = body.value
    book = { ...book, ...updateInfos}
    books = [...books.filter(book => book.isbn !== params.isbn), book]
    response.status = 200
    response.body = { message: 'OK' }
  } else {
    response.status = 404
    response.body = { message: `Book not found` }
  }  
}

deleteBook: deletes a book from the books list.

const deleteBook = ({ params, response }: { params: { isbn: string }; response: any }) => {
  books = books.filter(book => book.isbn !== params.isbn)
  response.body = { message: 'OK' }
  response.status = 200
}

After adding the functions to the controller.ts we need to export them so we can use them in the router.ts file

/* return the book if found and undefined if not */
const searchBookByIsbn = (isbn: string): ( IBook | undefined ) => books.filter(book => book.isbn === isbn )[0]

export { getBooks, getBook, addBook, updateBook, deleteBook }

NOTE: the searchBookByIsbn() it's just a helper function.

Here is the source code on github

You want more of Deno ?

Here is some resources: Deno's official website, The API documentation and you can find a lot more resources, libraries and frameworks in the Deno's awesome list.