Using Azure Static Web Apps with Snowpack for TypeScript in your frontend #ServerlessSeptember
Tags: serverless, javascript, webdev, azure
Published: 2020-09-01 17:04:26

In 2020, I’m finding myself writing TypeScript as much as I’m using C\# for my day-to-day dev. I’ve found myself experimenting, building multiplayer browser-based games, small self-contained PWAs and other “mostly browser-based things” over the last year or so.

One of the most frustrating things you have to just sort of accept when you’re in the browser, or running in node, is the frequently entirely incoherent and flaky world of node and JavaScript toolchains.

Without wanting to labour the point too much, many of the tools in the JavaScript ecosystem just don’t work very well, are poorly maintained, or poorly documented, and even some of the absolutely most popular tools like WebPack and Babel that sit underneath almost everything rely on mystery meat configuration, and fairly opaque error messages.

There is a reason that time and time again I run into frontend teams that hardly know how their software is built. I’ve spent the last year working on continual iterations of “what productive really looks like” in a TypeScript-first development environment, and fighting that healthy tension between tools that want to offer plenty of control, but die by the hands of their own configuration, to tools that wish to be you entire development stack (Create React App, and friends).

# What do I want from a frontend development stack?

In all software design, I love tools that are **correct by default** and ideally require **zero configuration.**

I expect hot-reload, it’s **the fast feedback cycle of the web** and to accept the inconsistencies of browser-based development without the benefit it’s a foolish thing.

I want native TypeScript compilation that I don’t have to think about. I don’t want to configure it, I want it to just work for **v.current of the evergreen browsers.**

I want **source maps and debugger support** by default.

I want the tool to be able handle native ES Modules, and be able to consume dependencies from **npm**.

Because I’ve been putting a lot of time into hosting websites as **Azure Static Web Apps**, I also want whatever tool I use to play nicely in that environment, and be trivially deployable from a **GitHub Action** to **Azure Static Web Apps**.

# Enter Snowpack

>   **Snowpack is a modern, lightweight toolchain for faster web
development.** Traditional JavaScript build tools like webpack and Parcel need to rebuild & rebundle entire chunks of your application every time you save a single file. This rebundling step introduces lag between hitting save on your changes and seeing them reflected in the browser.

I was introduced to snowpack by one of it’s contributors, an old friend, when complaining about the state of “tools that don’t just work” in the JavaScript ecosystem as a tool that was trying to pretty much do all the things I was looking for, so I’ve decided to use it for a couple of things to see if it fits the kind of projects I’ve been working on.

And honestly, it pretty much just works perfectly.

# Setting up snowpack to work with Azure Static Web Apps

Last month I wrote about how [Azure Static Web Apps are Awesome](
<https://www.davidwhitney.co.uk/Blog/2020/07/29/azure_static_web_apps_are_awesome>) with a walkthrough of setting up a static web app for any old HTML site, and I want to build on that today to show you how to configure a new project with snowpack that deploys cleanly, and uses TypeScript.

## Create a package.json

First, like in all JavaScript projects, we’re going to start by creating a package.json file.

You can do this on the command line by typing

```bash
npm init
```

We’re then going to add a handful of dependencies:

```bash
npm install npm-run-all snowpack typescript --save-dev
```

Which should leave us with a package.json that looks a little bit like this

```js
{
    "name": "static-app",
    "version": "",
    "description": "",
    "repository": "http://tempuri.org",
    "license": "http://tempuri.org",
    "author": "",
    "dependencies": {},
    "devDependencies": {
        "npm-run-all": "^4.1.5",
        "snowpack": "^2.9.0",
        "typescript": "^4.0.2"
    }
}
```

## Add some build tasks

Now, we’ll open up our package.json file and add a couple of tasks to it:

```js
{
    ...
    "scripts": {
        "start": "run-p dev:api dev:server",
        "dev:api": "npm run start --prefix api",
        "dev:server": "npx snowpack dev",
        "build:azure": "npx snowpack build"
    },
    ...
}
```

What we’re doing here, is filling in the default node **start** task – using a module called **npm-run-all** that allows us to execute two tasks at once. We’re also defining a task to run an **Azure Functions** API, and the **snowpack dev server**.

## Create our web application

Next, we’re going to create a directory called **app** and add an
**app/index.html** file to it.

```html
<html>
<head>
    <title>Hello Snowpack TypeScript</title>
    <script src="/index.js" type="module"></script>
</head>

<body>
    Hello world.
</body>
</html>
```

And we’ll create a **TypeScript** file called **app/index.ts**

```js
class Greeter {
    private _hasGreeted: boolean;

    constructor() {
        this._hasGreeted = false;
    }

    public sayHello(): void {
        console.log("Hello World");
        this._hasGreeted = true;
    }
}

const greeter = new Greeter();
greeter.sayHello();
```

You’ll notice we’re using TypeScript type annotations (Boolean, and : void in this code, along with public access modifiers).

## Configuring Snowpack to look in our APP directory

Next, we’re going to add a snowpack configuration file to the root of our repository. We’re adding this because by default, snowpack works from the root of your repository, and we’re putting our app in /app to help **Azure Static Web Apps** correctly host our app later.

Create a file called **snowpack.config.json** that looks like this:

```js
{
    "mount": {
        "app": "/"
    },
    "proxy": {
        "/api": "http://127.0.0.1:7071/api"
    }
}
```

Here we’re telling snowpack to mount our content from “app” to “/”, and to reverse proxy “/api” to a running **Azure Functions API**. We’ll come back to that, but first, let’s test what we have.

```bash
npm run dev:server
```

Will open a browser, and both in the console and on the screen, you should see “Hello World”.

Snowpack has silently Transpiled your TypeScript code, into a JavaScript file with the same filename, that your webapp is referencing using ES Module syntax.

The cool thing here, is everything you would expect to work in your frontend now does. You can use TypeScript, **you can reference npm modules in your frontend code** and all this happens with next to no startup time.

You can extend this process using various snowpack plugins, and it probably supports the JavaScript tooling you’re already using natively – read more at [snowpack.dev](http://snowpack.dev)

## Create our Azure Functions API

Because Azure Static Web Apps understand Azure functions, you can add some **serverless APIs** into a subdirectory called **api** in your repository, and **Azure Oryx** will detect and auto-host and scale them for you as part of it’s automated deployment.

Make sure you have the Azure Functions Core Tools installed by running

```bash
npm install -g azure-functions-core-tools@3
```

Now we’re going to run a few commands to create an Azure functions app.

```bash
mkdir api  
cd api  
func init --worker-runtime=node --language=javascript
```

This generates a default javascript+node functions app in our API directory, we just need to create a function for our web app to call. Back in the command line, we’ll type (still in our /api directory)

```bash
func new --template "Http Trigger" --name HelloWorld
```

This will add a new function called HelloWorld into your API directory.

In the file **api/package.json** make sure the following two tasks are present:

```js
  "scripts": {
    "prestart": "func extensions install",
    "start": "func start"
  },
```

If we now return to the root of our repository and type

```bash
npm run start
```

A whole lot of text will scroll past your console, and snowpacks live dev server will start up, along with the **Azure Functions** app with our new “HelloWorld”
function in it.

**Let’s add a little bit of code to our app/index.html to call this**

The cool thing, is we can just do this with the app running, and both the functions runtime, and the snowpack server, will watch for and hot-reload changes we make.

## Calling our API

We’re just going to add some code to **app/index.ts** to call our function, borrowed from the previous blog post. Underneath our greeter code, we’re going to add a **fetch** call

```js
…
const greeter = new Greeter();
greeter.sayHello();

fetch("/api/HelloWorld")
    .then(response => response.text())
    .then(data => console.log(data));
```

Now if you look in your browser console, you’ll notice that the line of text

“This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.”

Is printed to the window. That’s the text returned from our “HelloWorld” API.

# And that’s kind of it!

Really, that is it – you’ve now got a TypeScript compatible, hot-reloading dev server, with a serverless API, that is buttery smooth to develop on top of. But for our final trick, we’re going to configure **Azure Static Web Apps** to host our application.

# Configuring Static Web Apps

First, go skim down the guide to setting up Azure Static Web Apps I put together here -
<https://dev.to/david_whitney/azure-static-web-apps-are-awesome-4dn2>

You’re going to need to push your repository to **GitHub**, go and signup / login to the **Azure Portal**, and navigate to **Azure Static Web Apps** and click Create.

Once you’re in the creation process, you’ll need to again, authenticate with **GitHub** and select your new repository from the drop-downs provided.

You’ll be prompted to select the kind of Static Web App you’re deploying, and you should select **Custom**. You’ll then be faced with the **Build Details** settings, where you need to make sure you fill in the following:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/v8ct30qafgg068c2o7mx.png)

```
App Location: /  
API location: api  
App artifact location: build
```

Remember at the very start when we configured some npm tasks in our root? Well the **Oryx** build service is going to be looking for the task **build:azure** in your scripts configuration.

We populated that build task with “npx snowpack build” – a built in snowpack task that will compile and produce a **build** folder with your application in it ready to be hosted.

This configuration let’s Azure know that our final files will be available in the generated **build** directory so it knows what to host.

When you complete this creation flow, Azure will commit a GitHub action to your repository, and trigger a build to deploy your website. It takes around 2 minutes the first time you set this up.

# That’s it.

I’ve been using snowpack for a couple of weeks now, and I’ve had a wonderful time with it letting me build rich frontends with TypeScript, using NPM packages, without really worrying about building, bundling, or deploying.

These are the kind of tools that we should spend time investing in, that remove the nuance of low-level control, and replace it with pure productivity.

Give Azure Static Sites with Snowpack a go for your next project.