DEV Community: Guilherme Nascimento

Artisan server for Lumen

Guilherme Nascimento — Mon, 15 Feb 2021 20:44:00 +0000

I came across many suggestions for implementing the php artisan serve command in Lumen, however sometimes in development, especially with the popularization of microservices, that is, there may be situations where different applications need to communicate, usually in a development environment using only ports as access.

So starting application by application with php -S host:port -t public can be a little tricky or just annoying.

Fortunately if we have the value of APP_URL in env we can facilitate part of the process.

First create a file called ServeCommand.php in the ./app/Console/Commands/ folder, after edit app/Console/Kernel.php and put ServerCommand, like this:

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Laravel\Lumen\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    protected $commands = [
        Commands\ServeCommand::class,
    ];

The class Illuminate\Console\Command has a protected method called getOptions(), with it we can define default values for parameters in a command, or also inform if a parameter is optional (Symfony\Component\Console\Input\InputOption::VALUE_OPTIONAL) or required (Symfony\Component\Console\Input\InputArgument::REQUIRED).

More details in: https://symfony.com/doc/current/console/input.html

The proposal is to use as an option, that is, allow the user to change the host or port if desired when entering a command, or else use the value of APP_URL. To get the default host and port values I used parse_url, example usage:

protected function getOptions()
{
    $url = env('APP_URL');

    return [
        [
            'host', null, InputOption::VALUE_OPTIONAL, 'The host address to serve the application on.', parse_url($url, PHP_URL_HOST)
        ], [
            'port', null, InputOption::VALUE_OPTIONAL, 'The port to serve the application on.', parse_url($url, PHP_URL_PORT)
        ],
    ];
}

to obtain the host and port (defined via command line or .env) use:

$host = $this->input->getOption('host');

$port = $this->input->getOption('port');

However there is still a detail, it is possible for the user to start the artisan serve from a different folder level so we set the -t (php built in webserver) to start the public directory. To get the project directory use:

$base = $this->laravel->basePath();

The command call should look like this:

passthru('"' . PHP_BINARY . '"' . " -S {$host}:{$port} -t \"{$base}/public\"");

Source on gist: https://gist.github.com/brcontainer/44f47d35f47cd4e33f14023f8521bea1

Full source code:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Symfony\Component\Console\Input\InputOption;

class ServeCommand extends Command {

    /**
     * The console command name.
     *
     * @var string
     */
    protected $name = 'serve';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = "Serve the application on the PHP development server";

    /**
     * Execute the console command.
     *
     * @return void
     */
    public function handle()
    {
        $host = $this->input->getOption('host');

        $port = $this->input->getOption('port');

        $base = $this->laravel->basePath();

        $this->info("Lumen development server started on http://{$host}:{$port}/");

        passthru('"' . PHP_BINARY . '"' . " -S {$host}:{$port} -t \"{$base}/public\"");
    }

    /**
     * Get the console command options.
     *
     * @return array
     */
    protected function getOptions()
    {
        $url = env('APP_URL');

        return [
            [
                'host', null, InputOption::VALUE_OPTIONAL, 'The host address to serve the application on.', parse_url($url, PHP_URL_HOST)
            ], [
                'port', null, InputOption::VALUE_OPTIONAL, 'The port to serve the application on.', parse_url($url, PHP_URL_PORT)
            ],
        ];
    }

}

Improving the regex in route patterns (Teeny PHP route system)

Guilherme Nascimento — Mon, 15 Feb 2021 18:34:21 +0000

As I have already presented, Teeny is my proposal for an extremely light and small route Teeny, a route system for PHP

However, a colleague from here on the site proposed that I improve the system using the grouping of regular expressions, in order to decrease mainly operations on that.

It wasn't that simple, I had to change the approach, isolating the routes with callback patterns, because in this case it seemed to me that working with indexes would be easier.

Another situation is that the gropus are named by the user of the route system and it is not something automatic, so I had to be careful with that, to avoid that the gropus with duplicate names conflict, I used (?J) in regex, an example of use:

^((?J)(/foo/(?P<user>.*?)/(?P<test>\d+))|(/bar/(?P<user>.*?)/(?P<test>\d+))|(/baz/(?P<name>.*?)/(?P<id>\d+)))$

In this example, the regex can matches to:

/foo/username/10
/bar/username/10
/baz/username/10

For this test I created three very simple scripts, after all object orientation and advanced methodologies for this case seemed to me an exaggeration, so the scripts are very simple:

generate-routes.php

<?php

$patterns = array(
    'alnum' => '[\da-zA-Z]+',
    'alpha' => '[a-zA-Z]+',
    'decimal' => '\d+\.\d+',
    'num' => '\d+',
    'noslash' => '[^\/]+',
    'nospace' => '\S+',
    'uuid' => '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}',
    'version' => '\d+\.\d+(\.\d+(-[\da-zA-Z]+(\.[\da-zA-Z]+)*(\+[\da-zA-Z]+(\.[\da-zA-Z]+)*)?)?)?'
);

$paramRoutes = array();
$paramCallbacks = array();

for ($i = 0; $i < 300; ++$i) { 
    $paramRoutes[] = "/{$i}/<user>/<test:num>";
    $paramCallbacks[] = "callback_{$i}";
}

$paramRoutes[] = '/foo/<name>/<id:num>';
$paramCallbacks[] = 'callback_success1';

$paramRoutes[] = '/aaa/bbb/ccc';
$paramCallbacks[] = 'callback_success2';

// To simulate $_SERVER['PATH_INFO']
$pathinfo = '/foo/bar/1234';

As the script above, the desired route is the penultimate, that is, in a loop it should take to be obtained in comparison to the first ones, in the script 300 routes for testing are also generated.

ungroup-routes.php

This script works similarly to what Teeny already does today

<?php

require 'generate-routes.php';

$start = microtime(true);

foreach ($paramRoutes as $index => $value) {
    $pRegex = preg_replace($getParams, '(?P<$1><$3>)', $value);
    $pRegex = str_replace('<>)', '.*?)', $pRegex);

    foreach ($patterns as $pattern => $regex) {
        $pRegex = str_replace('<' . $pattern . '>)', $regex . ')', $pRegex);
    }

    if (preg_match('#^(' . $pRegex . ')$#', $pathinfo, $matches)) {
        foreach ($matches as $key => $value) {
            if ($value === '' || is_int($key)) {
                unset($matches[$key]);
            }
        }

        var_dump($matches);

        break;
    }
}

echo round(microtime(true) - $start, 6), "s\n";

group-routes.php

This script is the optimization proposal

<?php

require 'generate-routes.php';

$start = microtime(true);

// Max regex test
$limit = 15;

for ($i = 0, $j = count($paramRoutes); $i < $j; $i += $limit) { 
    $slice = array_slice($paramRoutes, $i, $limit);

    $pRegex = implode(')|(', $slice);

    $pRegex = preg_replace($getParams, '(?P<$1><$3>)', $pRegex);
    $pRegex = str_replace('<>)', '.*?)', $pRegex);

    foreach ($patterns as $pattern => $regex) {
        $pRegex = str_replace('<' . $pattern . '>)', $regex . ')', $pRegex);
    }

    if (preg_match('#^((?J)(' . $pRegex . '))$#', $pathinfo, $matches)) {
        foreach ($matches as $key => $value) {
            if ($value === '' || is_int($key)) {
                unset($matches[$key]);
            }
        }

        var_dump($matches);
        break;
    }
}

echo round(microtime(true) - $start, 6), "ms\n";

Performing the tests

Although many tests are done directly in the environment I chose to use ApacheBench, because I needed to be sure of the effects on multiple HTTP requests occurring almost at the same time.

The first test was to run the ungroup

ab -n 1000 -c 10 http://localhost/benchmark-routes/ungroup-routes.php

the following result was obtained:

Requests per second:    1566.68 [#/sec] (mean)
Time per request:       6.383 [ms] (mean)
Time per request:       0.638 [ms] (mean, across all concurrent requests)
Transfer rate:          472.54 [Kbytes/sec] received

The first test was to run the ungroup

ab -n 1000 -c 10 http://localhost/benchmark-routes/group-routes.php

the following result was obtained:

Requests per second:    3995.64 [#/sec] (mean)
Time per request:       2.503 [ms] (mean)
Time per request:       0.250 [ms] (mean, across all concurrent requests)
Transfer rate:          1209.19 [Kbytes/sec] received

In tests like this, it is evaluated how many operations on average it is possible to perform in a second, in other words, more HTTP requests per second is better, of course, we should consider benefits when it is possible to have much more per second compared to two different tests, if the difference is minimal, it can really be overkill.

According to the test we got about ~2400 (approximately, the tests always vary) more HTTP requests (in a single second), that is, we got more than twice as many requests, which was totally beneficial.

However, I needed to make sure that this apparent improvement would not harm a system with few routes, because what can work well for many requests can sometimes be harmful for a few requests. So I reduced the number of routes in group-routes.php to 30, and ran the tests again:

ungroup-routes.php:

Requests per second:    5361.82 [#/sec] (mean)
Time per request:       1.865 [ms] (mean)
Time per request:       0.187 [ms] (mean, across all concurrent requests)
Transfer rate:          1617.39 [Kbytes/sec] received

group-routes.php:

Requests per second:    5361.82 [#/sec] (mean)
Time per request:       1.865 [ms] (mean)
Time per request:       0.187 [ms] (mean, across all concurrent requests)
Transfer rate:          1617.39 [Kbytes/sec] received

And to my surprise, the new structure did not affect systems with few routes having practically the same performance.

The new version is now available for download at: https://github.com/inphinit/teeny/releases/tag/0.2.8 or using composer:

composer create-project inphinit/teeny <project name>

Thanks

I thank @hbgl, as it was his suggestions that helped with this improvement.

Teeny.go server with CLI mode

Guilherme Nascimento — Thu, 04 Feb 2021 07:21:42 +0000

As I said in https://dev.to/brcontainer/teeny-go-a-route-system-for-go-golang-2o10, Teeny.go (or teenygo or only teeny) is a micro-module for create a micro-webserver with support for routes and routes with patterns similar to PHP and JavaScript web-frameworks

For install use

go get -u github.com/inphinit/teeny.go

For create a application with support for command line arguments you can create manualy using os.Args or using app.CliMode(), example:

package main

import (
    "fmt"
    "net/http"
    "github.com/inphinit/teenygo"
)

func main() {
    //Default host and port
    app := teeny.Serve("localhost", 7000)

    app.Action("GET", "/", func (response http.ResponseWriter, request *http.Request) {
        fmt.Fprint(response, "Homepage")
    })

    app.Action("GET", "/about", func (response http.ResponseWriter, request *http.Request) {
        fmt.Fprint(response, "About page")
    })

    app.HandlerCodes([]int {403, 404, 405}, func (response http.ResponseWriter, request *http.Request, code int) {
        fmt.Fprintf(response, "Error: %d", code)
    })

    app.CliMode()
}

For build:

go build program.go

Usage example:

program.exe --debug --host 0.0.0.0 --port 8080 --public "/home/foo/bar/assets"

CLI mode arguments

Argument	Example	Description
`--tls`	`program --tls`	Enable TLS mode in your program (use with `--cert` and `--key` if it is not pre-configured)
`--tls`	`program --no-tls`	Disable TLS (if in the initial configuration of the script it was enabled)
`--debug`	`program --debug`	Enable debug mode in your program
`--debug`	`program --no-debug`	Disable debug (if in the initial configuration of the script it was enabled)
`--fcgi`	`program --fcgi`	Enable Fast-CGI mode in your program
`--fcgi`	`program --no-fcgi`	Disable Fast-CGI (if in the initial configuration of the script it was enabled)
`--cert`	`program --cert /home/foo/cert.pem`	Define certificate file (use with `--tls` if it is not pre-configured)
`--key`	`program --key /home/foo/key.pem`	Define key file (use with `--tls` if it is not pre-configured)
`--public`	`program --public /home/foo/assets`	Define folder for access static files
`--host`	`program --host 0.0.0.0`	Define host address
`--port`	`program --port 9000`	Define port addres

Alternative for __dirname in Node when using ECMAScript modules

Guilherme Nascimento — Thu, 04 Feb 2021 04:14:19 +0000

As I searched the Stack Overflow I came across several solutions that suggest using import.meta.url with fileURLToPath, however what was not mentioned is that the purpose of fileURLToPath is beyond "resolving" URLs with file://, as the documentation itself demonstrates (url.fileURLToPath):

fileURLToPath('file:///C:/path/');    // Output:   C:\path\ (Windows)
fileURLToPath('file://nas/foo.txt');  // Output:   \\nas\foo.txt (Windows)
fileURLToPath('file:///你好.txt');    // Output:   /你好.txt (POSIX)
fileURLToPath('file:///hello world'); // Output:   /hello world (POSIX)

In most cases, using what is native to Node.js (with ES Modules), not external resources, the use of __filename and __dirname for most cases can be totally unnecessary. Most (if not all) of the native methods for reading (streaming) supports the new URL, as the Node.js documentation itself suggests that we use:

No __filename or __dirname

For example, reading a file at the same level as the current script:

import { readFileSync } from 'fs';

const output = readFileSync(new URL('./foo.txt', import.meta.url));

console.log(output.toString());

List all files in the script directory:

import { readdirSync } from 'fs';

readdirSync(new URL('./', import.meta.url)).forEach((dirContent) => {
  console.log(dirContent);
});

As you can see in the description of the methods, the parameter shows the supported formats, and in them include the URL, examples:

fs.readFile(path[, options], callback) path <string> | <Buffer> | <URL> | <integer>
fs.readFileSync(path[, options]) path <string> | <Buffer> | <URL> | <integer>
fsPromises.readdir(path[, options]) path <string> | <Buffer> | <URL>
fs.readdir(path[, options], callback) path <string> | <Buffer> | <URL>
fs.readdirSync(path[, options]) path <string> | <Buffer> | <URL> | <integer>

So with new URL('<path or file>', import.meta.url) it solves and you don't need to be treating strings and creating variables to be concatenated later.

Note: In the examples I used the synchronous functions just to make it easier to copy and execute.

Note that if you are interested in using something like "require" in strategic moments, you can use module.createRequire(filename) (Node 12.2.0+) to load scripts at different levels from the level of the current script, example:

import { createRequire } from 'module';
const require = createRequire(import.meta.url);

// foo-bar.js is a CommonJS module.
const fooBar = require('./foo-bar');

fooBar();

foo-bar.js contents:

module.exports = () => {
    console.log('hello world!');
};

Responsive YouTube Player API with the responsive-youtube.js lib

Guilherme Nascimento — Thu, 04 Feb 2021 03:22:16 +0000

The need to create this library was when I tried to use
YouTube Embedded Players with width="100%":

<iframe width="100%" src="https://www.youtube.com/embed/<video ID>" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

But the height does not match the proportion of the width.

Then I tried to use the YouTube Player API with width: '100%':

player = new YT.Player('<element ID>', {
    width: '100%',
    videoId: '<video ID>'
});

But I was also not able to make the player work well in responsive and adaptive layouts. However, I noticed that placing the player without specifying the width and height makes the player start with the size based on the approximate proportion of the original size of the video, with this information I decided to get the width and height using Element.clientWidth and Element.clientHeight from the original player and then applied a simple calculation in the following situations:

onReady (Youtube API)
onresize
setTimeout (300ms)

The simple calculation:

if (originalWidth != originalHeight) 
    element.height = currentWidth / (originalWidth / originalHeight);
} else 
    element.height = currentWidth;
}

Partially solved problem. However, there are systems that load specific things on "demand", such as paging using XMLHttpRequest with History API (like Vue.js, Angular, and the like), to solve this the best option looked like the MutationObserver API with { childList: true }.

So as more than one need arose to resolve this, I decided it would be better to turn it into a library and share it.

The library has 3,15KB (minified) and 1,55KB when gzipped from webserver (like ngx_http_gzip_module or mod_deflate).

Configure

You can download from releases responsive-youtube.min.js and put in your page:

<script src="responsive-youtube.min.js"></script>

Or use CDN:

<script src="https://cdn.jsdelivr.net/npm/responsive-youtube.js@0.2/responsive-youtube.min.js"></script>

Using npm:

npm i responsive-youtube.js

And import using:

const SimpleCopy = require('responsive-youtube.js');

Using ECMAScript modules:

import SimpleCopy from 'responsive-youtube.js'

Add player in your page

A simples example:

<!-- embed video in page -->
<div data-ry-video="Tdjk9dhT_AU"></div>

<!-- embed video in page without "responsive" -->
<div data-ry-video="5ABos9UTfJU" data-ry-ignore="true"></div>

<script src="responsive-youtube.js"></script>
<script>
ResponsiveYoutube.start();
</script>

Examples

Browser support


✔	✔	✔	✔	6+ ✔	10+ ✔

simple-copy.js a tiny lib for copy text and DOM

Guilherme Nascimento — Thu, 04 Feb 2021 00:38:35 +0000

I've used some great clipboard libs, however I found that occasionally most of the things I needed were something simple, I noticed this when seeing the work of other developers, who instead of using a lib made use of the basics that the API for browsers provides, the document.execDocument() (although considered obsolete).

What I realized is that a big problem (at least for me) is that although libraries are small and make use of Gzip compression, on servers disabled for this feature it ended up being something that should weigh on average ~2KB ended up becoming ~10KB (I mean separate libs), I understand perfectly that there are compression and minification strategies (which I always use) and even some "lazyload" feature, but in this process I needed something that was light, without depending on much planning.

I admit that at the beginning I didn't think about sharing the lib prototype, but it was interesting enough, when used on servers with GZip enabled, lib got ~1,2KB, when GZip disabled it got ~2,5KB, that is, that is, a minimal difference (~1KB).

I am working so that the lib in the future will use ClipboardAPI while maintaining backward compatibility for older browsers.

Configure

You can use CDN (jsdelivr) and put directly in your page:

<script src="https://cdn.jsdelivr.net/npm/simple-copy.js@0.5/simple-copy.min.js"></script>

Can download from source: https://github.com/brcontainer/simple-copy.js/blob/0.5.2/simple-copy.min.js

Can too install using npm:

npm i simple-copy.js

And use with require():

const SimpleCopy = require('simple-copy.js');

Or use with ECMAScript modules:

import SimpleCopy from 'simple-copy.js'

Usage

Copying content from a element using selector:

SimpleCopy.copy("<selector>");

Copying text from a element using selector:

SimpleCopy.copy("<selector>", { "text": true });

Copying entire element using selector:

SimpleCopy.copy("<selector>", { "node": true });

Copying content from a element using selector:

var element = document.querySelector(".foobar");
SimpleCopy.copy(element);

Copying text from a element using selector:

var element = document.getElementById("idelement");
SimpleCopy.copy(element, { "text": true });

Copying entire element:

var element = document.getElementsByClassName("<class>");
SimpleCopy.copy(element[0], { "node": true });

Select text in a element using selector:

SimpleCopy.select("<selector>");

Select content in a element:

var element = document.querySelector(".foobar");
SimpleCopy.select(element);

Select entire node:

var element = document.querySelector(".foobar");
SimpleCopy.select(element, { "node": true });

Set text in clipboard:

SimpleCopy.data("Hello, world!");

Copy content from element defined in data attributes:

<button data-simplecopy-target="<selector>">Copy</button>

Copy entire element defined in data attributes:

<button data-simplecopy-target="<selector>" data-simplecopy-node="true">Copy</button>

Select content from element defined in data attributes:

<button data-simplecopy-target="<selector>" data-simplecopy-select="true">Select text</button>

Copy html content without format:

<button data-simplecopy-target="<selector>" data-simplecopy-text="true">Copy</button>

Set text in clipboard by data attribute:

<button data-simplecopy-data="Hello, world!">Copy text</button>

Browser Support


✔	✔	✔	✔	10+ ✔	9+ ✔

Teeny, a route system for PHP

Guilherme Nascimento — Wed, 03 Feb 2021 01:57:02 +0000

Teeny is a micro-route system that is really micro, supports PHP 5.3 to PHP 8, is extremely simple and ready to use.

For create your project use:

composer create-project inphinit/teeny <project name>

Replace <project name> by your project name, for exemple, if want create your project with "blog" name (folder name), use:

composer create-project inphinit/teeny blog

Download without composer

If is not using composer try direct download from https://github.com/inphinit/teeny/releases

Copy release or create project in Apache or Nginx folder and configure Vhost in Apache or execute direct from folder

For use with composer-auto configure index.php like this:

<?php
require_once 'vendor/teeny.php';

$app = new \Inphinit\Teeny;

...

return $app->exec();

For use without composer-autoload

<?php
require_once 'vendor/teeny.php';
require_once 'vendor/autoload.php';

$app = new \Inphinit\Teeny;

...

return $app->exec();

Stand-alone server

For use without Apache or Nginx you can execute this command in folder:

php -S localhost:8080 index.php

Handling Http errors (like ErrorDocument)

For handling errors for not defined routes (404 Not Found) and when try access a route with invalid (not defined) method uses $app->handlerCodes(array $codes, mixed $callback), example (in routes.js), example:

$app->handlerCodes([ 403, 404, 405 ], function ($code) {
    echo 'Custom page error ', $code;
});

Route patterns

You can create your own patterns to use with the routes in Teeny, but there are also ready-to-use patterns:

Type	Example	Description
`alnum`	`$app->action('GET', '/baz/<video:alnum>', ...);`	Only accepts parameters with alpha-numeric format and `$params` returns `array( video => ...)`
`alpha`	`$app->action('GET', '/foo/bar/<name:alpha>', ...);`	Only accepts parameters with alpha format and `$params` returns `array( name => ...)`
`decimal`	`$app->action('GET', '/baz/<price:decimal>', ...);`	Only accepts parameters with decimal format and `$params` returns `array( price => ...)`
`num`	`$app->action('GET', '/foo/<id:num>', ...);`	Only accepts parameters with integer format and `$params` returns `array( id => ...)`
`noslash`	`$app->action('GET', '/foo/<noslash:noslash>', ...);`	Accpets any characters expcet slashs (`/`)
`nospace`	`$app->action('GET', '/foo/<nospace:nospace>', ...);`	Accpets any characters expcet spaces, like white-spaces (`%20`), tabs (`%0A`) and others (see about `\S` in regex)
`uuid`	`$app->action('GET', '/bar/<barcode:alnum>', ...);`	Only accepts parameters with uuid format and `$params` returns `array( barcode => ...)`
`version`	`$app->action('GET', '/baz/<api:version>', ...);`	Only accepts parameters with semversion (v2) format and `$params` returns `array( api => ...)`

For use a pattern in routes, set like this:

$app->action('GET', '/user/<name:alnum>', function ($request, $response, $params) {
    return "Hello {$params['name']}";
});

$app->action('GET', '/api/<foobar:version>', function ($request, $response, $params) {
    return "Version: {$params['foobar']}";
});

$app->action('GET', '/product/<id:num>', function ($request, $response, $params) {
    return "Product ID: {$params['id']}";
});

...

return $app->exec();

Teeny.js, a route system for Node.js

Guilherme Nascimento — Wed, 03 Feb 2021 01:25:13 +0000

The main objective of this project is to be light, simple, easy to learn, to serve other projects that need a route system to use together with other libraries and mainly to explore the native resources from language and engine (Node).

Advantages of using Teeny.js

It is possible to use modules in the routes and method app.handlerCodes() and these modules are loaded only when necessary.

When you edit the file containing the routes, Teeny.js detects and updates everything on its own without having to restart the server, something that is often necessary in other similar libs. This makes it easy to quickly maintain or reconfigure anything called within routes.js.

It is possible to create your own patterns to use in route parameters.

Get Start

For create a example:

mkdir foobar
cd foobar
npm init

After this install package:

npm i teeny.js

Create two files index.js and routes.js (you can change the names), example:

const { Teeny } = require('teeny.js');

const app = new Teeny(`${__dirname}/routes.js`, 7000);

app.exec();

For use with "ECMAScript modules" for load from same level path (like: __dirname):

import { Teeny } from 'Teeny.js';
import { createRequire } from 'module';

const app = new Teeny('./routes.js', 7000);

app.setRequire(createRequire(import.meta.url));

app.exec();

In routes.js put this:

module.exports = (app) => {
    // Enable (or disable) debug mode
    app.setDebug(true);

    // Access http://localhost:7000/ for see "Hello world"
    app.action('GET', '/', (request, response) => {
        return 'Hello World!';
    });

    // Access http://localhost:7000/async for see response from a async function
    app.action('GET', '/async', async (request, response) => {
        const result = new Promise((resolve) => setTimeout(resolve, 1000, `Async working ${new Date()}!`));

        return result;
    });

    // Access http://localhost:7000/user/mary (or another nickname)
    app.action('GET', '/user/<username:alnum>', (request, response, params) => {
        return `Hello ${params.username}`;
    });
};

Handling Http errors (like `ErrorDocument`)

For handling errors for not defined routes (404 Not Found) and when try access a route with invalid (not defined) method uses app.handlerCodes(Array codes, Function callback), example (in routes.js):

module.exports = (app) => {
    // Enable (or disable) debug mode
    app.setDebug(true);

    app.handlerCodes([ 404, 405 ], (status) => {
        return `Error page: ${status}`;
    });

...

Route patterns

You can create your own patterns to use with the routes in "Teeny.js", but there are also ready-to-use patterns:

Pattern	Regex used	Description
`alnum`	`[\\da-zA-Z]+`	Matches routes with param using alpha-numeric in route
`alpha`	`[a-zA-Z]+`	Matches routes with param using A to Z letters in route
`decimal`	`\\d+\\.\\d+`	Matches routes with param using decimal format (like `1.2`, `3.5`, `100.50`) in route
`num`	`\\d+`	Matches routes with param using numeric format in route
`noslash`	`[^\\/]+`	Matches routes with param using any character except slashs (`\/` or `/`) in route
`nospace`	`\\S+`	Matches routes with param using any character except spaces, tabs or NUL in route
`uuid`	`[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}`	Matches routes with param using uuid format in route
`version`	`\\d+\\.\\d+(\\.\\d+(-[\\da-zA-Z]+(\\.[\\da-zA-Z]+)(\\+[\\da-zA-Z]+(\\.[\\da-zA-Z]+))?)?)?`	Matches routes with param using `semver.org` format in route

For use a pattern in routes, set like this:

module.exports = (app) => {
    app.action('GET', '/user/<name:alnum>', (request, response, params) => {
        return `Hello ${params.name}`;
    });

    app.action('GET', '/api/<foobar:version>', (request, response, params) => {
        return `Version: ${params.foobar}`;
    });

    app.action('GET', '/product/<id:num>', (request, response, params) => {
        return `Product ID: ${params.id}`;
    });
...

Teeny.go, a route system for Go (Golang)

Guilherme Nascimento — Wed, 03 Feb 2021 01:12:50 +0000

Teeny.go (or teenygo or only teeny) is a micro-module for create a micro-webserver with support for routes and routes with patterns similar to PHP and JavaScript web-frameworks

For install use

go get -u github.com/inphinit/teeny.go

Then create a file with any name and extension .go, example foo.go and put this content:

package main

import (
    "fmt"
    "net/http"
    "github.com/inphinit/teenygo"
)

func main() {
    app := teeny.Serve("localhost", 7000)

    app.Action("GET", "/", func (response http.ResponseWriter, request *http.Request) {
        fmt.Fprint(response, "Homepage")
    })

    app.Action("GET", "/about", func (response http.ResponseWriter, request *http.Request) {
        fmt.Fprint(response, "About page")
    })

    app.Exec()
}

For execute local serve run this command:

go run foo.go

For build executes:

go build foo.go
foo

This is a very simple example, for access http://localhost:7000/ and http://localhost:7000/about

Handling Http errors (like `ErrorDocument`)

For handling errors for not defined routes (404 Not Found) and when try access a route with invalid (not defined) method uses app.HandlerCodes(codes []int, func TeenyStatusCallback), example:

func main() {
    app := teeny.Serve("localhost", 7000)

    var codes = []int {404, 405}

    app.HandlerCodes(codes, func (response http.ResponseWriter, request *http.Request, code int) {
        fmt.Fprintf(response, "Error %d", code)
    })

    ...
}

Route patterns

For use patterns in router uses app.Params(method string, path string, func TeenyPatternCallback), example with num and alnum pattern:

    app.Params("GET", "/users/<id:num>/<name:alnum>", func (response http.ResponseWriter, request *http.Request, params map[string]string) {
        fmt.Fprint(response, "Params:\n")

        for key, value := range params {
            fmt.Fprintf(response, "%s = %s\n", key, value)
        }
    })

Supported patterns:

Pattern	Regex used	Description
`alnum`	`[\da-zA-Z]+`	Matches routes with param using alpha-numeric in route
`alpha`	`[a-zA-Z]+`	Matches routes with param using A to Z letters in route
`decimal`	`\d+\.\d+`	Matches routes with param using decimal format (like `1.2`, `3.5`, `100.50`) in route
`num`	`\d+`	Matches routes with param using numeric format in route
`noslash`	`[^\/]+`	Matches routes with param using any character except slashs (`\/` or `/`) in route
`nospace`	`\S+`	Matches routes with param using any character except spaces, tabs or NUL in route
`uuid`	`[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}`	Matches routes with param using uuid format in route
`version`	`\d+\.\d+(\.\d+(-[\da-zA-Z]+(\.[\da-zA-Z]+)(\+[\da-zA-Z]+(\.[\da-zA-Z]+))?)?)?`	Matches routes with param using `semver.org` format in route