para

head

code


  use v6;

  use Humming-Bird::Core;

  get('/', -> $request, $response {
      $response.html('<h1>Hello World</h1>');
  });

  listen(8080);

  # Navigate to localhost:8080!




  use v6;

  use Humming-Bird::Core;

  post('/password', -> $request, $response {
      my $super_secret_password = '1234';
      my $password = $request.query('password') || 'Wrong!'; # /password?password=
      if $password eq $super_secret_password {
          $response.html('<h1>That password was correct!</h1>'); # Responses default to 200, change the with .status
      } else {
          $response.status(400).html('<h1>Wrong Password!!!</h1>');
      }
  });




  use v6;

  use Humming-Bird::Core;

  my %users = Map.new('bob', '{ "name": "bob" }', 'joe', '{ "name": "joe" }');

  get('/users/:user', -> $request, $response {
      my $user = $request.param('user');

      if %users{$user}:exists {
          $response.json(%users{$user});
      } else {
          $response.status(404);
      }
  });

  listen(8080);




  my $router = Router.new(root => '/foo/bar');

  # Advice and middleware added will be appended to the routes as they are added.
  $router.middleware(-> $request, $response, &next { $response.header('X-MyHeader', 'True'); &next() });
  $router.advice(-> $response { say $response; $response }); 

  $router.get(-> $request, $response { $response.write('abc') }); # Registers a get route on /foo/bar

  $route.get('/abc', -> $request, $response { $response.write('abc') }); # Registers a get route on /foo/bar/abc

  listen(8080); # No need to register or anything. The router is already registered upon creation.




  use v6;

  use Humming-Bird::Core;
  use Humming-Bird::Middleware;

  get('/logged', -> $request, $response {
      $response.html('This request has been logged!');
  }, [ &middleware-logger ]); # &m_logger is provided by Humming-Bird::Middleware

  # Custom middleware
  sub block-firefox($request, $response, &next) {
      return $response.status(400) if $request.header('User-Agent').starts-with('Mozilla');
      $response.status(200);
  }

  get('/no-firefox', -> $request, $response {
      $response.html('You are not using Firefox!');
  }, [ &middleware-logger, &block-firefox ]);

  # Scoped middleware

  # Both of these routes will now share the middleware specified in the last parameter of the group.
  group([
      &get.assuming('/', -> $request, $response {
          $response.write('Index');
      }),

      &post.assuming('/users', -> $request, $response {
          $response.write($request.body).status(204);
      })
  ], [ &middleware-logger, &block-firefox ]);




  use Humming-Bird::Core;

  # Middleware to make sure you have an AUTH cookie
  sub authorized($request, $response, &next) {
    without $request.cookie('AUTH') {
      return $response.status(403);
    }

    &next();
  }

  get('/auth/home', -> $request, $response {
    $response.html('You are logged in!');
  }, [ &authorized ]);

  post('/auth/login', -> $request, $response {
    if $request.body eq 'Password123' {
      # TODO: Implement redirects
      $response.cookie('AUTH', 'logged in!', DateTime.now + Duration.new(3600)).html('You logged in!');
    } else {
      $response.status(400);
    }
  });




  use v6;
  use strict;

  use Humming-Bird::Core;
  use Humming-Bird::Middleware;
  use JSON::Marshal;
  use JSON::Unmarshal;

  # Basic model to represent our User
  class User {
      has Str $.name  is required;
      has Int $.age   is required;
      has Str $.email is required;
  }

  # Fake DB, you can pull in DBIish if you need a real DB.
  my @user-database = User.new(name => 'bob', age => 22, email => 'bob@bob.com');

  get('/users', -> $request, $response {
      $response.json(marshal(@user-database));
  }, [ &middleware-logger ]);

  post('/users', -> $request, $response {
      my $user := unmarshal($request.body, User);
      @user-database.push($user);
      $response.json(marshal($user)); # 204 Created
  });

  listen(8080);



  
  use Humming-Bird::Core;
  use Humming-Bird::Advice;
  
  advice(&advice-logger); # advice-logger is provided by Humming-Bird::Advice.
  
  # Custom advice
  our clicks-today = 0;
  sub update-clicks-today(Response:D $response --> Response:D) {
	clicks-today++;
	$response;
  }
  
  advice(&update-clicks-today); # This will fire after every response is handled.




  use Humming-Bird::Core;
  use HTTP::Status;

  # This will catch any X::AdHoc exceptions and use this as the handler
  error(X::AdHoc, -> $exception, $response {
    $response.status(500).write($exception.payload || 'Internal server error.'); # In this case, when we hit an X::AdHoc lets return a 500 with the payload of the exception
  });




  use v6.d;

  use Humming-Bird::Core;

  static('/static', '/var/www/static'); # Will serve static content from /var/www/static on route /static


root

Middleware

README

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=end nested
=begin nested :!nested
=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

Examples

Simple example:

Query params:

Simple JSON/path param example:

Example using routers

Middleware:

Cookies:

Basic CRUD REST API:

After middleware aka advice

Exception/Error handlers

Static files

Humming-Bird v4.1.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation