What are Edge Functions?
Edge Functions are serverless functions that are designed to be executed at the edge of a network. These functions are executed at the point closest to the user, which results in faster response times and reduced latency. Invertase is a company that provides a suite of tools for building serverless applications.

These serverless functions are executed at the edge of Firebase Hosting, which is a content delivery network (CDN) that delivers your static content to users around the world. These functions are written in Node.js and are executed by Google Cloud Functions.

URL Rewriting

URL Rewriting is the process of changing the requested URL by the client to a different URL on the server. This can be useful for serving content from different locations or redirecting users to a new location. You can use Edge Functions to perform URL rewriting at the edge of Firebase Hosting. For example, you can use an Edge Function to redirect all requests for non-www URLs to their www equivalent, or vice versa.

To perform URL rewriting with Edge Functions in Dart, you can use the Rewriter class from the shelf package. Here's an example:

import 'package:shelf/shelf.dart';

Response _redirectNonWWW(Request request) {
  final uri = request.requestedUri;
  if (uri.host.startsWith('www.')) {
    return Response.notFound('Page not found');
  }
  final newUri = uri.replace(host: 'www.${uri.host}');
  return Response.movedPermanently(newUri.toString());
}

void main() {
  final app = const Pipeline()
      .addMiddleware(corsMiddleware())
      .addHandler(_redirectNonWWW);

  runZoned(() {
    serve(app, InternetAddress.anyIPv4, 8080);
  }, onError: (e, s) => print('Error: $e $s'));
}

Server-Side Rendering

Server-Side Rendering (SSR) is the process of rendering a web page on the server before sending it to the client. This can be useful for improving the performance of web applications by reducing the amount of work that needs to be done on the client. You can use Edge Functions to perform SSR at the edge of Firebase Hosting.

To perform server-side rendering with Edge Functions in Dart, you can use the flutter package, which allows you to render Flutter widgets to HTML. Here's an example:

import 'package:flutter/widgets.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/material.dart';
import 'package:shelf/shelf.dart';

Response _serveWidget(Request request) {
  final html = renderToString(
    MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Hello World'),
        ),
        body: const Center(
          child: Text('Hello, World!', style: TextStyle(fontSize: 24.0)),
        ),
      ),
    ),
  );
  return Response.ok(html, headers: {'content-type': 'text/html'});
}

void main() {
  final app = const Pipeline().addHandler(_serveWidget);

  runZoned(() {
    serve(app, InternetAddress.anyIPv4, 8080);
  }, onError: (e, s) => print('Error: $e $s'));
}

Real-Time Processing

Real-Time Processing is the process of processing user requests in real-time, as they come in. This can be useful for performing actions such as geolocation lookups or personalized recommendations. You can use Edge Functions to perform real-time processing at the edge of Firebase Hosting. For example, you can use an Edge Function to look up the geolocation of a user based on their IP address and serve content that is relevant to their location.

To perform real-time processing with Edge Functions in Dart, you can use any library that provides the functionality you need. For example, you can use the ip_geolocation package to perform geolocation lookups based on IP addresses. Here's an example:

import 'dart:async';
import 'package:ip_geolocation/ip_geolocation.dart';
import 'package:shelf/shelf.dart';

Future<Response> _serveContent(Request request) async {
  final ip = request.headers['x-forwarded-for']?.split(',').first;
  if (ip != null) {
    final location = await IpGeolocation.getIpLocation(ip);
    // Do something with location data, such as serving personalized content
  }
  return Response.ok('Hello, World!', headers: {'content-type': 'text/plain'});
}

void main() {
  final app = const Pipeline().addHandler(_serveContent);

  runZoned(() {
    serve(app, InternetAddress.anyIPv4, 8080);
  }, onError: (e, s) => print('Error: $e $s'));
}

This function uses the ip_geolocation package to perform a geolocation lookup based on the user's IP address, and then uses the location data to serve personalized content.

Keynotes on Edge Functions

Performance

Edge Functions are executed at the edge of Firebase Hosting, which results in faster response times and reduced latency. By executing code at the edge of a network, Edge Functions can significantly reduce the time it takes for a user to receive a response, which can improve the user experience.

Scalability

Edge Functions are highly scalable, as they are executed by Google Cloud Functions, which is a highly scalable and reliable platform. This means that Edge Functions can handle large amounts of traffic and can scale up or down automatically based on demand.

Ease of Use

Edge Functions are easy to set up and use, as they can be deployed using the Firebase CLI. This means that developers can easily add functionality to their static websites hosted on Firebase Hosting without having to set up and manage their server infrastructure.

Conclusion

Edge Functions are a powerful tool for building serverless applications that are highly responsive and scalable. By executing code at the edge of a network, Edge Functions can significantly improve the performance of web applications and improve the user experience. With Invertase, it is easy to set up and deploy Edge Functions, and developers can use them to perform tasks such as URL rewriting, server-side rendering, and real-time processing.

In summary, Edge Functions offer a convenient and effective way to improve the performance of static websites hosted on Firebase Hosting. They can be used to perform a range of tasks at the edge of the network, which can significantly reduce the latency of web applications and improve the user experience. If you are building a serverless application on Firebase Hosting, be sure to consider using Edge Functions in Invertase as a tool to enhance your application's performance and scalability.

💙💙 If I am wrong or do need to update any of this explanation. Please guide me through, I would love to make changes 💙💙

Keep on clapping till your claps sum to 10.

Check my previous series on Flutter interview questions for every level. Have a look into it and do share your thoughts.
https://mukundjogi.hashnode.dev/series/flutter-interview

Keep sharing🫰🏻keep learning 🙌🏻 Do practice these examples🤘🏻