Download the PHP package davidecesarano/embryo without Composer

Embryo Framework 3 skeleton application

You can use this skeleton application to start working on a new Embryo Framework 3 application.

• Getting Started
  • Requirements
  • Installation
  • Configuration
  • Directory Structure
• Concepts
  • Life Cycle
  • PSR-7
  • Middleware
  • Dependency Container
• Application
  • Routing
  • Middleware
  • Controllers
  • Service Providers
  • Models
  • Views
• Packages
  • Validation
  • Session
  • Cache
  • Http Client
  • Translation
  • Logger
  • CORS
  • Storage

Getting Started

Requirements

• PHP >= 7.2
• URL Rewriting

Installation

Using Composer:

Configuration

Embryo utilizes the DotEnv PHP library. In a fresh Embryo installation, the root directory of your application will contain a .env.example file. When you install Embryo via Composer, this file will automatically be renamed to .env.

Directory Structure

Concepts

Life Cycle

• The app is instantiated in bootstrap/app.php with Embryo\Application class. During instantiation, Embryo registers services for the dependencies (bootstrap/services.php), middlewares (bootstrap/middleware.php) and routes files (in routes directory). The application constructor accepts an optional settings array that configures the application’s behavior (bootstrap/settings.php).
• In routes direcotry define routes using the application instance’s routing methods. These instance methods register a route with the application’s Router object. Each routing method returns the Route instance so you can immediately invoke the Route instance’s methods to add middleware or assign a name.
• In public/index.php invoke the application instance's run() method. This method starts the following process:
  • enter in middleware stack;
  • run application (dispatches the current HTTP request to the appropriate application route object);
  • exit middleware stack;
  • send HTTP response.

PSR-7

Embryo supports PSR-7 interfaces for its Request and Response objects.

Middleware

You can run code before and after your Embryo application to manipulate the Request and Response objects as you see fit. This is called middleware. A middleware implements the PSR-15 Middleware Interface.

Dependency Container

Embryo uses an dependency container to prepare, manage, and inject application dependencies. Embryo supports containers that implement PSR-11.

Application

Routing

You can define application routes using the application instance’s routing methods. Every method accepts two arguments:

• The route pattern (with optional placeholders)
• The route callback (a closure, a class@method string or a ['class', 'method'] array)

Embryo Routing supports GET, POST, PUT, PATCH, DELETE and OPTIONS request methods. Every request method corresponds to a method of the Router object: get(), post(), put(), patch(), delete() and options(). You can use all() and map() methods for supporting all methods or specific route methods.

See full documentation: Embryo Routing.

Register route files

All Embryo routes are defined in your route files, which are located in the routes directory. These files are automatically loaded by your application in boostrap/app.php file. If you want create new ruote file, add it in routes directory and register it in import() method of the application instance in boostrap/app.php file:

Middleware

In Embryo you may create a PSR-15 middleware in app\Middleware directory. You may add middleware to application, to specific route or to route group.

Application middleware

If you want register middleware for every HTTP request, add application middleware in bootstrap\middleware.php. The addMiddleware() method accepts a string, an array or an instance of Psr\Http\Server\MiddlewareInterface.

Route middleware

You can use the middleware() method to assign one or more middleware at the route. The middleware() method accepts a string, an array or an instance of Psr\Http\Server\MiddlewareInterface.

Route group middleware

In addition to the routes, you can assign one or more middleware to a group and to individual routes within the group. The middleware() method accepts a string, an array or an instance of Psr\Http\Server\MiddlewareInterface.

Controllers

Instead of defining all of your request handling logic as closures in your route files, you may wish to organize this behavior using "controller" classes. Let's take a look at an example of a basic controller. Note that the controller extends the base controller class included with Embryo:

You can define a route to this controller method like so:

Controllers are required to extend a base class. However, you will not have access to features such as the get(), request() and response() methods.

Dependency Injection & Controllers

You are able to type-hint any dependencies your controller may need in its constructor. The declared dependencies will automatically be resolved and injected into the controller instance:

In addition to constructor injection, you may also type-hint dependencies on your controller's methods:

In addition, you may also to use the get() method of the base controller class:

Base controller class also has access to PSR-7 request() and response() methods:

Alternatively, you may to access to request() and response() helpers:

Service Providers

Service providers are the central place of all Embryo application bootstrapping. Your own application, as well as all of Embryo's core services, are bootstrapped via service providers.

Writing a service

The service providers era located in app/Services directory. All service providers extend the Embryo\Container\ServiceProvider class and contains a register method. Within the register method, you should only bind things into the service container.

Registering a service

Models

Views

Packages

Validation