* initial version

config/.gitignore

@@ -0,0 +1 @@
+development.config.php

config/autoload/.gitignore

@@ -0,0 +1,2 @@
+local.php
+*.local.php

config/autoload/dependencies.global.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+return [
+    // Provides application-wide services.
+    // We recommend using fully-qualified class names whenever possible as
+    // service names.
+    'dependencies' => [
+        // Use 'aliases' to alias a service name to another service. The
+        // key is the alias name, the value is the service to which it points.
+        'aliases' => [
+            // Fully\Qualified\ClassOrInterfaceName::class => Fully\Qualified\ClassName::class,
+        ],
+        // Use 'invokables' for constructor-less services, or services that do
+        // not require arguments to the constructor. Map a service name to the
+        // class name.
+        'invokables' => [
+            // Fully\Qualified\InterfaceName::class => Fully\Qualified\ClassName::class,
+        ],
+        // Use 'factories' for services provided by callbacks/factory classes.
+        'factories'  => [
+            // Fully\Qualified\ClassName::class => Fully\Qualified\FactoryName::class,
+        ],
+    ],
+];

config/autoload/development.local.php.dist

@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * Development-only configuration.
+ *
+ * Put settings you want enabled when under development mode in this file, and
+ * check it into your repository.
+ *
+ * Developers on your team will then automatically enable them by calling on
+ * `composer development-enable`.
+ */
+
+declare(strict_types=1);
+
+use Mezzio\Container;
+use Mezzio\Middleware\ErrorResponseGenerator;
+
+return [
+    'dependencies' => [
+        'factories' => [
+            ErrorResponseGenerator::class => Container\WhoopsErrorResponseGeneratorFactory::class,
+            'Mezzio\Whoops'               => Container\WhoopsFactory::class,
+            'Mezzio\WhoopsPageHandler'    => Container\WhoopsPageHandlerFactory::class,
+        ],
+    ],
+    'whoops'       => [
+        'json_exceptions' => [
+            'display'    => true,
+            'show_trace' => true,
+            'ajax_only'  => true,
+        ],
+    ],
+];

config/autoload/local.php.dist

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * Local configuration.
+ *
+ * Copy this file to `local.php` and change its settings as required.
+ * `local.php` is ignored by git and safe to use for local and sensitive data like usernames and passwords.
+ */
+
+declare(strict_types=1);
+
+return [
+];

config/autoload/mezzio.global.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+use Laminas\ConfigAggregator\ConfigAggregator;
+
+return [
+    // Toggle the configuration cache. Set this to boolean false, or remove the
+    // directive, to disable configuration caching. Toggling development mode
+    // will also disable it by default; clear the configuration cache using
+    // `composer clear-config-cache`.
+    ConfigAggregator::ENABLE_CACHE => true,
+
+    // Enable debugging; typically used to provide debugging information within templates.
+    'debug' => false,
+
+    'mezzio' => [
+        // Provide templates for the error handling middleware to use when
+        // generating responses.
+        'error_handler' => [
+            'template_404'   => 'error::404',
+            'template_error' => 'error::error',
+        ],
+    ],
+];

config/config.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+use Laminas\ConfigAggregator\ArrayProvider;
+use Laminas\ConfigAggregator\ConfigAggregator;
+use Laminas\ConfigAggregator\PhpFileProvider;
+
+// To enable or disable caching, set the `ConfigAggregator::ENABLE_CACHE` boolean in
+// `config/autoload/local.php`.
+$cacheConfig = [
+    'config_cache_path' => 'data/cache/config-cache.php',
+];
+
+$aggregator = new ConfigAggregator([
+    \Laminas\Log\ConfigProvider::class,
+    \Mezzio\Router\FastRouteRouter\ConfigProvider::class,
+    \Laminas\HttpHandlerRunner\ConfigProvider::class,
+    // Include cache configuration
+    new ArrayProvider($cacheConfig),
+
+    \Mezzio\Helper\ConfigProvider::class,
+    \Mezzio\ConfigProvider::class,
+    \Mezzio\Router\ConfigProvider::class,
+    \Laminas\Diactoros\ConfigProvider::class,
+
+    // Swoole config to overwrite some services (if installed)
+    class_exists(\Mezzio\Swoole\ConfigProvider::class)
+        ? \Mezzio\Swoole\ConfigProvider::class
+        : function(): array { return[]; },
+
+    // Default App module config
+    App\ConfigProvider::class,
+
+    // Load application config in a pre-defined order in such a way that local settings
+    // overwrite global settings. (Loaded as first to last):
+    //   - `global.php`
+    //   - `*.global.php`
+    //   - `local.php`
+    //   - `*.local.php`
+    new PhpFileProvider(realpath(__DIR__) . '/autoload/{{,*.}global,{,*.}local}.php'),
+
+    // Load development config if it exists
+    new PhpFileProvider(realpath(__DIR__) . '/development.config.php'),
+], $cacheConfig['config_cache_path']);
+
+return $aggregator->getMergedConfig();

config/container.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+use Laminas\ServiceManager\ServiceManager;
+
+// Load configuration
+$config = require __DIR__ . '/config.php';
+
+$dependencies                       = $config['dependencies'];
+$dependencies['services']['config'] = $config;
+
+// Build container
+return new ServiceManager($dependencies);

config/development.config.php.dist

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * File required to allow enablement of development mode.
+ *
+ * For use with the laminas-development-mode tool.
+ *
+ * Usage:
+ *  $ composer development-disable
+ *  $ composer development-enable
+ *  $ composer development-status
+ *
+ * DO NOT MODIFY THIS FILE.
+ *
+ * Provide your own development-mode settings by editing the file
+ * `config/autoload/development.local.php.dist`.
+ *
+ * Because this file is aggregated last, it simply ensures:
+ *
+ * - The `debug` flag is _enabled_.
+ * - Configuration caching is _disabled_.
+ */
+
+declare(strict_types=1);
+
+use Laminas\ConfigAggregator\ConfigAggregator;
+
+return [
+    'debug' => true,
+    ConfigAggregator::ENABLE_CACHE => false,
+];

config/pipeline.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+use Laminas\Stratigility\Middleware\ErrorHandler;
+use Mezzio\Application;
+use Mezzio\Handler\NotFoundHandler;
+use Mezzio\Helper\ServerUrlMiddleware;
+use Mezzio\Helper\UrlHelperMiddleware;
+use Mezzio\MiddlewareFactory;
+use Mezzio\Router\Middleware\DispatchMiddleware;
+use Mezzio\Router\Middleware\ImplicitHeadMiddleware;
+use Mezzio\Router\Middleware\ImplicitOptionsMiddleware;
+use Mezzio\Router\Middleware\MethodNotAllowedMiddleware;
+use Mezzio\Router\Middleware\RouteMiddleware;
+use Psr\Container\ContainerInterface;
+
+/**
+ * Setup middleware pipeline:
+ */
+return function (Application $app, MiddlewareFactory $factory, ContainerInterface $container) : void {
+    // The error handler should be the first (most outer) middleware to catch
+    // all Exceptions.
+    $app->pipe(ErrorHandler::class);
+    $app->pipe(ServerUrlMiddleware::class);
+
+    // Pipe more middleware here that you want to execute on every request:
+    // - bootstrapping
+    // - pre-conditions
+    // - modifications to outgoing responses
+    //
+    // Piped Middleware may be either callables or service names. Middleware may
+    // also be passed as an array; each item in the array must resolve to
+    // middleware eventually (i.e., callable or service name).
+    //
+    // Middleware can be attached to specific paths, allowing you to mix and match
+    // applications under a common domain.  The handlers in each middleware
+    // attached this way will see a URI with the matched path segment removed.
+    //
+    // i.e., path of "/api/member/profile" only passes "/member/profile" to $apiMiddleware
+    // - $app->pipe('/api', $apiMiddleware);
+    // - $app->pipe('/docs', $apiDocMiddleware);
+    // - $app->pipe('/files', $filesMiddleware);
+
+    // Register the routing middleware in the middleware pipeline.
+    // This middleware registers the Mezzio\Router\RouteResult request attribute.
+    $app->pipe(RouteMiddleware::class);
+
+    // The following handle routing failures for common conditions:
+    // - HEAD request but no routes answer that method
+    // - OPTIONS request but no routes answer that method
+    // - method not allowed
+    // Order here matters; the MethodNotAllowedMiddleware should be placed
+    // after the Implicit*Middleware.
+    $app->pipe(ImplicitHeadMiddleware::class);
+    $app->pipe(ImplicitOptionsMiddleware::class);
+    $app->pipe(MethodNotAllowedMiddleware::class);
+
+    // Seed the UrlHelper with the routing results:
+    $app->pipe(UrlHelperMiddleware::class);
+
+    // Add more middleware here that needs to introspect the routing results; this
+    // might include:
+    //
+    // - route-based authentication
+    // - route-based validation
+    // - etc.
+
+    // Register the dispatch middleware in the middleware pipeline
+    $app->pipe(DispatchMiddleware::class);
+
+    // At this point, if no Response is returned by any middleware, the
+    // NotFoundHandler kicks in; alternately, you can provide other fallback
+    // middleware to execute.
+    $app->pipe(NotFoundHandler::class);
+};

config/routes.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+use Mezzio\Application;
+use Mezzio\MiddlewareFactory;
+use Psr\Container\ContainerInterface;
+
+/**
+ * FastRoute route configuration
+ *
+ * @see https://github.com/nikic/FastRoute
+ *
+ * Setup routes with a single request method:
+ *
+ * $app->get('/', App\Handler\HomePageHandler::class, 'home');
+ * $app->post('/album', App\Handler\AlbumCreateHandler::class, 'album.create');
+ * $app->put('/album/{id:\d+}', App\Handler\AlbumUpdateHandler::class, 'album.put');
+ * $app->patch('/album/{id:\d+}', App\Handler\AlbumUpdateHandler::class, 'album.patch');
+ * $app->delete('/album/{id:\d+}', App\Handler\AlbumDeleteHandler::class, 'album.delete');
+ *
+ * Or with multiple request methods:
+ *
+ * $app->route('/contact', App\Handler\ContactHandler::class, ['GET', 'POST', ...], 'contact');
+ *
+ * Or handling all request methods:
+ *
+ * $app->route('/contact', App\Handler\ContactHandler::class)->setName('contact');
+ *
+ * or:
+ *
+ * $app->route(
+ *     '/contact',
+ *     App\Handler\ContactHandler::class,
+ *     Mezzio\Router\Route::HTTP_METHOD_ANY,
+ *     'contact'
+ * );
+ */
+return static function (Application $app, MiddlewareFactory $factory, ContainerInterface $container): void {
+    $app->get('/', App\Handler\HomePageHandler::class, 'home');
+    $app->get('/api/ping', App\Handler\PingHandler::class, 'api.ping');
+};