Migrating a Node.js project to Deno - Step-by-Step Execution

Concept Flow - Migrating a Node.js project to Deno

Start: Node.js Project

↓

Identify Node.js APIs

↓

Replace Node.js APIs with Deno APIs

↓

Update Import Statements

↓

Adjust Permissions for Deno

↓

Test and Debug in Deno

↓

Project Runs Successfully in Deno

This flow shows the step-by-step process of changing a Node.js project to work in Deno by replacing APIs, updating imports, setting permissions, and testing.

Execution Sample

Deno

import { serve } from "https://deno.land/std@0.177.0/http/server.ts";

serve((_req) => new Response("Hello from Deno!"), { port: 8000 });

This code starts a simple HTTP server in Deno that responds with a greeting message.

Execution Table

Step	Action	Code/Command	Result/Output
1	Import Deno HTTP server module	import { serve } from "https://deno.land/std@0.177.0/http/server.ts";	Module loaded from URL
2	Start server with handler	serve((_req) => new Response("Hello from Deno!"), { port: 8000 });	Server listens on port 8000
3	Receive HTTP request	Client sends request to localhost:8000	Handler function runs
4	Return response	new Response("Hello from Deno!")	Client receives 'Hello from Deno!'
5	Exit	Server runs until stopped	Process continues running

💡 Server runs continuously until manually stopped

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
serve	undefined	Function imported	Function called	Handler executed	Server running
_req	undefined	undefined	Request object received	Used in handler	Request handled

Key Moments - 3 Insights

Why do we replace Node.js 'require' imports with URL imports in Deno?

Deno uses ES module syntax with URL imports instead of Node.js 'require'. This is shown in execution_table step 1 where the import uses a URL.

How does Deno handle permissions differently from Node.js?

Deno requires explicit permission flags (like --allow-net) to access network or file system, unlike Node.js which allows by default. This is part of the migration step before running the server.

Why do we need to change Node.js APIs like 'http' to Deno's 'serve'?

Deno provides its own standard library with different APIs. The Node.js 'http' module is replaced by Deno's 'serve' function as shown in the execution sample and steps 1-2.

Visual Quiz - 3 Questions

Look at the execution_table step 1, what does the import statement do?

A Loads a module from a URL

B Loads a local file module

C Starts the server

D Sends a response

💡 Hint

Check the 'Code/Command' column in step 1 showing the URL import

At which step does the server start listening for requests?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Result/Output' column for when the server listens on port 8000

If we forget to add --allow-net permission when running Deno, what happens?

A Server starts normally

B Import fails

C Runtime error due to missing network permission

D Response is empty

💡 Hint

Recall key moment about Deno permissions and migration steps

Concept Snapshot

Migrating Node.js to Deno:
- Replace 'require' with ES module URL imports
- Swap Node.js APIs (e.g., 'http') with Deno std APIs (e.g., 'serve')
- Run with explicit permissions (e.g., --allow-net)
- Test server runs and responds correctly
- Deno uses secure, modern JavaScript by default

Full Transcript

Migrating a Node.js project to Deno involves several steps. First, identify Node.js specific APIs and replace them with Deno equivalents. For example, Node.js 'require' imports become ES module imports from URLs in Deno. The HTTP server code changes from using Node.js 'http' module to Deno's 'serve' function from its standard library. Permissions must be explicitly granted when running Deno, such as network access with --allow-net. Testing the server ensures it responds correctly. This process improves security and uses modern JavaScript standards.

Practice

1. Which of the following is a key difference when migrating a Node.js project to Deno?

easy

A. Deno uses CommonJS modules by default.

B. Deno uses URL imports instead of npm packages.

C. Deno requires no code changes from Node.js.

D. Deno automatically grants all permissions to the code.

Solution

1. Step 1: Understand module import differences

   Node.js uses npm packages imported by name, while Deno uses direct URL imports.

2. Step 2: Check permission handling and module system

   Deno requires explicit permission grants and uses ES modules, not CommonJS.

3. Final Answer:

   Deno uses URL imports instead of npm packages. -> Option B

4. Quick Check:

   Module import style = D [OK]

Hint: Remember: Deno imports modules via URLs, not npm names. [OK]

Common Mistakes:

• Assuming Deno uses npm packages directly
• Thinking Deno grants permissions automatically
• Believing Node.js code runs unchanged in Deno

2. Which syntax correctly imports the lodash library in Deno?

easy

A. import _ from 'https://cdn.skypack.dev/lodash';

B. const _ = require('lodash');

C. import _ from 'lodash';

D. import _ from 'npm:lodash';

Solution

1. Step 1: Identify Deno import style

   Deno imports modules using URLs, not package names or require().

2. Step 2: Check each option

   import _ from 'https://cdn.skypack.dev/lodash'; uses a valid URL import from a CDN, which is correct for Deno.

3. Final Answer:

   import _ from 'https://cdn.skypack.dev/lodash'; -> Option A

4. Quick Check:

   URL import syntax = C [OK]

Hint: Use full URLs for imports in Deno, not package names. [OK]

Common Mistakes:

• Using require() which is Node.js only
• Importing by package name without URL
• Using npm: prefix which Deno does not support

3. What will be the output when running this Deno script?

import { readFileStr } from 'https://deno.land/std/fs/mod.ts';
const data = await readFileStr('./file.txt');
console.log(data.trim());

Assuming file.txt contains " Hello Deno \n".

medium

A. Error: readFileStr is not a function

B. Hello Deno

C. undefined

D. oneD olleH

Solution

1. Step 1: Understand readFileStr usage

   The function readFileStr was deprecated and removed in recent versions of Deno std library. Using it will cause an error.

2. Step 2: Analyze output

   Since readFileStr is not a function, the script will throw an error.

3. Final Answer:

   Error: readFileStr is not a function -> Option A

4. Quick Check:

   Function availability = D [OK]

Hint: Use Deno.readTextFile or Deno.readTextFileSync instead of deprecated readFileStr. [OK]

Common Mistakes:

• Expecting original spaces without trim()
• Confusing readFileStr with non-existent function
• Ignoring await causing undefined

4. You migrated a Node.js script to Deno but get this error: PermissionDenied: read access to './data.json' is not allowed. How do you fix it?

medium

A. Install the missing npm package for file access.

B. Change the file path to an absolute path.

C. Run the script with deno run --allow-read flag.

D. Use require() instead of import.

Solution

1. Step 1: Understand Deno's permission model

   Deno requires explicit permission flags to access files for security.

2. Step 2: Apply correct permission flag

   Using --allow-read grants read access to files, fixing the error.

3. Final Answer:

   Run the script with deno run --allow-read flag. -> Option C

4. Quick Check:

   Permission error fix = A [OK]

Hint: Add --allow-read flag to grant file read permission. [OK]

Common Mistakes:

• Ignoring permission flags in Deno
• Trying to fix path instead of permissions
• Using Node.js require() which Deno disallows

5. You have this Node.js code snippet using the 'fs' module:

const fs = require('fs');
const data = fs.readFileSync('./info.txt', 'utf8');
console.log(data);

How should you rewrite it in Deno to read the file synchronously?

hard

A. const data = Deno.readFile('./info.txt'); console.log(data);

B. const data = await Deno.readTextFile('./info.txt'); console.log(data);

C. import fs from 'https://deno.land/std/fs/mod.ts'; const data = fs.readFileSync('./info.txt');

D. const data = Deno.readTextFileSync('./info.txt'); console.log(data);

Solution

1. Step 1: Identify synchronous file read in Deno

   Deno provides readTextFileSync() for synchronous text file reading.

2. Step 2: Compare options

   const data = Deno.readTextFileSync('./info.txt'); console.log(data); correctly uses readTextFileSync and logs the data synchronously.

3. Final Answer:

   const data = Deno.readTextFileSync('./info.txt'); console.log(data); -> Option D

4. Quick Check:

   Synchronous file read in Deno = A [OK]

Hint: Use Deno.readTextFileSync for sync file reading like Node's readFileSync. [OK]

Common Mistakes:

• Using await with synchronous functions
• Trying to import Node.js fs module in Deno
• Using readFile which returns Uint8Array, not string