Edge Computing with Cloudflare Workers & Deno · Lesson

Module System & Permissions

Understand Deno's URL-based module system and its granular permission model for secure execution.

Module System & Permissions is a free Edge Computing with Cloudflare Workers & Deno lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Edge Computing with Cloudflare Workers & Deno learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Deno Modules: Building Blocks

In Deno, applications are built using modules. Think of modules as individual files that contain related code, like functions, classes, or variables.

They help keep your code organized and reusable, preventing your project from becoming one giant, hard-to-manage file.

URLs as Module Paths

Unlike Node.js, Deno doesn't use a node_modules folder. Instead, Deno imports modules directly using URLs or file paths.

Local Files: Use relative or absolute paths (e.g., ./my_module.ts).
Remote Files: Use full URLs (e.g., https://deno.land/std/fs/mod.ts).

This simple approach makes dependency management very straightforward!

Importing Your Own Code

Let's create two files: utils.ts with a simple function, and main.ts to import and use it. This is how you share logic within your own project.

utils.ts:

export function greet(name: string): string {
  return `Hello, ${name}!`;
}

Running Local Module Example

Now, let's import and use our greet function in main.ts. Notice the relative path ./utils.ts.

Try running this example:

// main.ts
import { greet } from "./utils.ts";

console.log(greet("CoddyKit"));

Fetching Modules from the Web

Deno can directly import modules from web URLs. This is powerful, but also requires trust in the source. Deno caches these modules after the first download.

Here's how to import a utility from Deno's standard library:

// main.ts
import { join } from "https://deno.land/std/path/mod.ts";

const path = join("/users", "coddy", "documents");
console.log(`Joined path: ${path}`);

Deno Caches Remote Modules

When you first run a Deno script that imports remote modules, Deno downloads and caches them locally. This makes subsequent runs much faster.

Cached modules are stored in a global directory.
You can manually clear the cache with deno cache --reload or deno cache --reset.
Deno verifies module integrity using checksums.

Secure by Default: Permissions

Deno is designed to be secure. By default, a Deno program has no access to your file system, network, or environment variables.

You must explicitly grant these permissions using command-line flags when running your script. This prevents malicious code from doing harm without your knowledge.

Reading Files Securely

To allow your Deno program to read files, you need the --allow-read permission. You can specify specific paths or allow access to everything with . (current directory) or by omitting a path.

data.txt:

Hello Deno permissions!

`--allow-read` in Action

Let's try to read data.txt. Without permission, it will fail. With --allow-read, it works! (e.g., deno run --allow-read main.ts)

Try running this example:

// main.ts
const filePath = "./data.txt";
try {
  const content = await Deno.readTextFile(filePath);
  console.log("File content:", content);
} catch (error) {
  console.error("Error reading file:", error.message);
}

Making Network Requests

To allow your Deno program to make network requests (like fetching data from an API), you need the --allow-net permission.

You can specify specific hosts (e.g., --allow-net=api.example.com) or allow all network access. (e.g., deno run --allow-net main.ts)

// main.ts
try {
  const response = await fetch("https://deno.land/std/README.md");
  if (response.ok) {
    const text = await response.text();
    console.log("Fetched content (first 50 chars):");
    console.log(text.substring(0, 50));
  } else {
    console.error("Failed to fetch:", response.statusText);
  }
} catch (error) {
  console.error("Network error:", error.message);
}

Permission Challenge!

Which of the following Deno commands would allow a script named app.ts to both read files from the current directory AND make network requests to any domain?

Recap: Modules & Permissions

Great job! You've learned about Deno's modern module system, which uses URLs for both local and remote imports, simplifying dependency management.

You also explored Deno's robust permission model, understanding how to grant specific access (like --allow-read and --allow-net) to your scripts for secure execution. This "secure by default" approach is a core Deno feature!

Frequently asked questions

Is the “Module System & Permissions” lesson free?

Yes — the full text of “Module System & Permissions” is free to read here on the web, and the Edge Computing with Cloudflare Workers & Deno course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Edge Computing with Cloudflare Workers & Deno course, upgrade to CoddyKit PRO.

What will I learn in “Module System & Permissions”?

Understand Deno's URL-based module system and its granular permission model for secure execution. You practise Edge Computing with Cloudflare Workers & Deno with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Edge Computing with Cloudflare Workers & Deno?

No prior experience is required. Edge Computing with Cloudflare Workers & Deno on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Module System & Permissions” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Edge Computing with Cloudflare Workers & Deno lesson?

Yes. Every Edge Computing with Cloudflare Workers & Deno lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Edge Computing with Cloudflare Workers & Deno