Projects ​

Projects are serverless applications deployed to Web URLs. Projects in Netzo are programmed using Deno, a simple, modern and secure runtime for JavaScript and TypeScript. In essence, a project consist of collections of static files that are automatically hosted by netzo. Each Project is deployed to its own unique URL and ran globally at the network edge when an HTTP Request is made to its URL. The netzo module can be used within projects to make coding projects even simpler.

Creating Projects ​

1. Head over to the Projects page within a Workspace and click the Create button.

2. Give a unique name for the project and select a starting template. We'll select the basic TypeScript example for now.

3. Add the necessary environment variables in the drawer to the right.

Project URLs ​

Projects can be invoked via HTTP requests to any of:

• Production URL: https://{uid}.deno.dev
• Preview URL: https://{uid}-{deploymentId}.deno.dev

CORS Headers ​

To be able to invoke a Project from the browser, you'll need to enable CORS. By default, CORS headers will be set to * unless you specify otherwise in the Response headers.

For example, to allow all origins, methods and headers for the Project:

Deno.serve((req: Request): Response => new Response("Hello World!"));

Deno.serve((req: Request): Response => new Response("Hello World!"));

To allow only a specific origin, method or header you can overwrite the defaults of * individually or all at once as follows:

Deno.serve((req: Request): Response => new Response("Hello World!", {
  headers: {
    "access-control-allow-origin": "https://app.netzo.io",
    "access-control-allow-methods": "GET, POST",
    "access-control-allow-headers": "x-foo, x-bar"
  }
}));

Deno.serve((req: Request): Response => new Response("Hello World!", {
  headers: {
    "access-control-allow-origin": "https://app.netzo.io",
    "access-control-allow-methods": "GET, POST",
    "access-control-allow-headers": "x-foo, x-bar"
  }
}));

Modules ​

Modules are reusable code bundles distributed via URLs. Netzo makes it easy to author and deploy Modules on the click of a button. Modules can be private or public, in which case they can be imported by third-party scripts (without authentication).

• import allows you to include and use local or remote modules in your code.
• export allows you to expose code to be imported by other modules.

Import Maps ​

Import maps allows control over what URLs get fetched by import statements and import() expressions. They can be thought of as shortcuts to map short and memorable aliases to (longer) import URLs. There are 2 ways of declaring an import map:

1. Set inline in the "imports" property of deno.json(c) (recommended)

{
  "imports": {
    "@/": "./",
    "netzo/": "https://deno.land/x/netzo/"
  }
}

{
  "imports": {
    "@/": "./",
    "netzo/": "https://deno.land/x/netzo/"
  }
}

2. Set the URL of an import_map.json to the "importMap" property of deno.json(c)

{
  "importMap": "./import_map.json"
}

{
  "importMap": "./import_map.json"
}

{
  "imports": {
    "@/": "./",
    "netzo/": "https://deno.land/x/netzo/"
  }
}

{
  "imports": {
    "@/": "./",
    "netzo/": "https://deno.land/x/netzo/"
  }
}

Hosting ​

Netzo will automatically host all your modules under https://api.netzo.io/deployments/{id}/{...path} with path being a valid file path including etension (e.g. components/Table.tsx). Files will be served with their corresponding Content-Type header by Netzo, for example text/html for .html files.

Publishing ​

Modules can also be published to the Deno ecosystem via the official https://deno.land/x hosting service. It caches releases of open source modules and serves them at one easy to remember domain. Navigate to their official docs to learn more.

Requests ​

Requests are HTTP requests made to invoke any of a project's deployments. These attempts will count towards the Requests quota of the Workspace. Requests have the following properties:

• Method: The HTTP method used to make the request. For example, GET, POST, PUT, DELETE, etc.
• URL: The URL of the project.
• Query: The HTTP query string sent with the request.
• Headers: The HTTP headers sent with the request.
• Body: The HTTP body sent with the request.

Runtime Environment ​

Runtime APIs ​

The following Web and Deno APIs are supported on the runtime.

• addEventListener
• Cache
• Durable Objects
• Encoding
• Fetch
• FetchEvent
• Headers
• HTMLRewriter
• KV
• Request
• Response
• ScheduledEvent
• Streams
• Web Crypto
• Web standards
• WebSockets
• eval()
• new Function()

(Virtual) Filesystem ​

Projects have access to a read-only virtual filesystem that is scoped to the Project's files and mounted at file:///src/. Reading outside of the project root is not allowed.

Netzo supports a limited set of the file system APIs available in Deno. These file system APIs can access static files from your deployments.

The APIs that are available are:

• Deno.cwd returns the current working directory of your deployment.
• Deno.readDir allows listing the contents of a directory.
• Deno.readFile allows reading a file into memory.
• Deno.readTextFile allows reading a file into memory (decoded as UTF-8 string).
• Deno.open allows opening a file, returning a file handle
• Deno.stat reads a file system entry's metadata.
• Deno.lstat reads a file system entry's metadata (without following symlinks).
• Deno.realPath reads a file system entry's metadata (without following symlinks).
• Deno.readLink returns the target path for a symlink.

For example, a file example.txt at the project root can be read in multiple ways:

await Deno.readTextFile("example.txt");
await Deno.readTextFile("./example.txt");
await Deno.readTextFile("/src/example.txt");
await Deno.readTextFile("file:///src/example.txt"); // ❌ throws error
await Deno.readTextFile(new URL("file:///src/example.txt"));

await Deno.readTextFile("example.txt");
await Deno.readTextFile("./example.txt");
await Deno.readTextFile("/src/example.txt");
await Deno.readTextFile("file:///src/example.txt"); // ❌ throws error
await Deno.readTextFile(new URL("file:///src/example.txt"));

Refer to the Deno documentation for more information.

import data from "./data.json" assert { type: "json" };

import data from "./data.json" assert { type: "json" };

const data = JSON.parse(await Deno.readTextFile("./data.json"));

const data = JSON.parse(await Deno.readTextFile("./data.json"));

Regions ​

Netzo deploys projects globally to the edge. Each new Request is served from the closest region to the client making the request. The following regions are available:

• 1. Taiwan: asia-east1
• 2. Hong Kong: asia-east2
• 3. Tokyo: asia-northeast1
• 4. Osaka: asia-northeast2
• 5. Seoul: asia-northeast3
• 6. Mumbai: asia-south1
• 7. Delhi: asia-south2
• 8. Singapore: asia-southeast1
• 9. Jakarta: asia-southeast2
• 10. Sydney: australia-southeast1
• 11. Melbourne: australia-southeast2
• 12. Warsaw: europe-central2
• 13. Finland: europe-north1
• 14. Belgium: europe-west1
• 15. London: europe-west2
• 16. Frankfurt: europe-west3
• 17. Netherlands: europe-west4
• 18. Zurich: europe-west6
• 19. Milan: europe-west8
• 20. Paris: europe-west9
• 21. Tel Aviv: me-west1
• 22. Madrid: europe-southwest1
• 23. Montréal: northamerica-northeast1
• 24. Toronto: northamerica-northeast2
• 25. São Paulo: southamerica-east1
• 26. Chile: southamerica-west1
• 27. Iowa: us-central1
• 28. South Carolina: us-east1
• 29. North Virginia: us-east4
• 30. Ohio: us-east5
• 31. Texas: us-south1
• 32. Oregon: us-west1
• 33. California: us-west2
• 34. Utah: us-west3
• 35. Nevada: us-west4

This list will be updated as new regions are added.