mini fwk
1.0.0
Mini-FWK est un cadre PHP pour l'accent mis sur les performances. Il a les fonctionnalités suivantes:
OBS: Cette documentation ne couvre pas toutes les fonctionnalités du cadre. N'hésitez pas à ajouter plus d'exemples ou de sections.
Exécutez la commande suivante pour cloner l'exemple et installer les dépendances
$ git clone [email protected]:StartiOne/mini-fwk.git myproject
$ cd myproject
$ rm -Rf .git
$ cp .env.example .env Les contrôleurs sont le point d'entrée pour les demandes HTTP. Des annotations spéciales sont utilisées pour définir les URL et les femmes moyennes pour les méthodes de contrôleur. Store Controllers dans le dossier src/Controllers suivant l'exemple:
<?php
namespace App Controllers ;
use Mini Helpers Request ;
class ExampleController
{
/**
* @Get("/example")
* @Middleware("permission:SOME_PERMISSION")
*/
public function index ()
{
$ data = Request:: instance ()-> get ( ' data ' );
response ()-> json ([ ' data ' => $ data ]);
}
} Par défaut, les fichiers liés au routage d'URL sont stockés dans src/routes . Comme les contrôleurs peuvent définir des itinéraires avec des annotations, vous n'aurez pas besoin de les modifier. Pour générer des itinéraires à partir de vos annotations de contrôleur, exécutez la commande suivante dans votre répertoire de projet:
$ ./console route:scan Vous pouvez lire et écrire JSON avec MiniHelpersRequest et MiniHelpersResponse . Voir les exemples suivants:
<?php
namespace App Controllers ;
class RequestExampleController
{
/**
* @Get("/request-example")
*/
public function index ()
{
$ req = Mini Helpers Request:: instance ();
echo $ req -> get ( ' data.name ' ); // Get the key from the JSON input, $_REQUEST or $_FILES using *dots* to represent nested arrays
( new Mini Helpers Response )-> json ([ ' data ' =>[ ' token ' => ' ab ' ]], 200 ); // Output {data: {token: 'ab'}}
response ()-> json ([ ' data ' =>[ ' token ' => ' ab ' ]], 200 ); // Use a helper to do the same
}
} Middlewares est utile pour exécuter une logique avant la méthode du contrôleur. Stockez MiddleWares dans le dossier src/Middlewares , puis mettez à jour src/routers/middlewares.php suivant l'exemple:
<?php
// src/routers/middlewares.php
return [
' permission ' => App Middlewares PermissionMiddleware::class
]; <?php
// src/Middlewares/PermissionMiddleware.php
namespace App Middlewares ;
class PermissionMiddleware
{
public function handler ( $ permission )
{
$ auth = app ()-> get ( ' App/Auth ' ); // Use the dependency container to store Auth class
$ token = $ auth -> getAccessToken ();
if ( $ token === null ) {
response ()-> json ([
' error ' => [
' code ' => ' 0001 ' ,
' detail ' => ' Unauthorized. ' ,
]
], 401 );
} else if ( $ auth -> hasPermission ( $ permission ) === false ) {
response ()-> json ([
' error ' => [
' code ' => ' 0001 ' ,
' detail ' => ' Forbidden. ' ,
]
], 403 );
}
}
} La validation des données fonctionne avec la classe MiniValidationValidator et les règles actuellement prises en charge sont: requises, char, chaîne, texte, entier, float, double, décimal, booléen, date, datetime, heure, e-mail, maxLength, MinLength, Min, Max.
Vous pouvez vérifier des exemples sur les tests unitaires
<?php
namespace App Controllers ;
use Mini Helpers Request ;
use Mini Controllers BaseControllers ; // Implements validate and validateEntity
use App Models User ;
use App Models Retailer ;
class ValidationExampleController
{
/**
* @Get("/validation-example")
*/
public function index ()
{
// Complete example
$ validator = app ()-> get ( ' MiniValidationValidator ' );
$ validator -> setData (Request:: instance ()-> get ( ' data ' ))
$ validator -> validate ([
' name ' => ' string|required ' , // Rules are separeted by '|'
' addresses.*.street ' => ' string|required ' // Validate nested arrays inside 'addresses' key
]);
// Will throw ValidationException if error is found
echo ' Data successfuly validated ' ;
// Example using validate method. So you don't need a $validator instance
$ this -> validate ([
' name ' => ' string:6:255 ' , // Limit by length between 6 and 255 chars
]);
// Example using rules from model classe
$ this -> validateEntity ( new User );
// Example using multiple models
$ this -> validateEntities ([
' * ' => new Retailer ,
' owner ' => new User
]);
}
} Les services sont stockés dans src/Services , ils sont utilisés pour contenir une logique HTTP (contrôleurs) distincte à partir de la logique métier et peuvent étendre MiniEntityDataMapper .
Les modèles représentent des objets commerciaux comme «utilisateur» ou «détaillant» et contiennent des données liées au schéma d'attribut. Ils sont stockés dans src/Models suivant l'exemple:
<?php
namespace App Models ;
use Mini Entity Entity ;
use Mini Entity Behaviors QueryAware ;
class User extends Entity
{
use QueryAware; // Implement methods from MySQL ORM. Example: User::q()->listObject();
/**
* Table name used in MySQL
*
* @var string
*/
public $ table = ' users ' ;
/**
* Define fields 'updated_at' and 'created_at' to control timestamps
*
* @var bool
*/
public $ useTimeStamps = true ;
/**
* Define field 'deleted_at' to mark a row as deleted. Further calls to User::q() will automatically check for this field
*
* @type bool
*/
public $ useSoftDeletes = true ;
/**
* Field definition
*
* @type array
*/
public $ definition = [
' id ' => ' pk ' ,
' name ' => ' string ' ,
' password ' => ' string '
];
/**
* Fields that are filled and validated
*
* @var array
*/
public $ fillable = [
' name ' ,
' password '
];
/**
* Fields that are serialized with json_encode
*
* @var array
*/
public $ visible = [
' id ' ,
' name '
];
} Vous pouvez créer des requêtes MySQL complexes avec une classe MiniEntityQuery . Suivez les exemples.
<?php
use Mini Entity Query ;
use App Models User ;
// Complete example
$ query = ( new Query )
-> connection ( ' default ' )
-> from ( ' users ' )
-> alias ( ' u ' )
-> select ([ ' u.id ' , ' u.name ' , ' um.email ' ])
-> innerJoin ( ' user_emails um ' , ' um.user_id ' , ' = ' , ' u.id ' )
-> where ( ' id ' , ' = ' , 1 );
$ user = $ query -> getArray ();
// Generating an sql
$ sql = $ query -> makeSql ();
// Using entity query alias in a Model that uses the trait `MiniEntityBehaviorsQueryAware`
$ users = User:: q ()-> limit ( 0 , 1 )-> listObject (); // Can be listArray if you dont need an objectVous pouvez vérifier des exemples sur les tests unitaires
Vous pouvez construire des requêtes MongoDB complexes avec une classe MiniEntityMongoQuery . Suivez les exemples.
<?php
use Mini Entity Mongo Query ;
use App Models User ;
// Complete example
$ chatMessages = ( new Query ( ' mongo ' , ' chat_messages ' ))
-> filter ( ' chat_id ' , 1 )
-> projection ([ ' description ' => 1 ])
-> sort ([ ' timestamp ' => 1 ])
-> skip ( 5 )
-> limit ( 10 )
-> listArray ();
// Using entity query alias in a Model that uses the trait `MiniEntityMongoBehaviorsMongoQueryAware`
$ chatMessages = ChatMessage:: q ()-> filter ( ' chat_id ' , 1 )-> listArray ();Les migrations de données et les graines sont essentielles pour maintenir les schémas MySQL et les données par défaut en synchronisation entre le développement et l'environnement de production. Il existe deux façons de créer une migration: manuellement et automatique. Le plus courant est de générer une migration qui vérifie automatiquement les différences dans la définition de votre entité et le schéma d'information MySQL. Utilisez l'exemple suivant:
./console make:migration --diff # Create a migration for all tables
./console make:migration --diff --force # Force "alter tables" on "not null" columns
./console make:migration --diff --filter ' (permissoes|perfil_permissoes) ' # Check only tables matching the pattern
./console migrate # Run this after checking if the generated migration is okDans d'autres moments, la création d'une migration manuellement sera nécessaire. Exécutez la commande suivante et vérifiez la migration créée.
$ ./console make:migration
Migration file created at ~ /PROJECT_FOLDER/migrations/Migration20170531174950.php <?php
use Mini Entity Migration AbstractMigration ;
class Migration20170531174950 extends AbstractMigration
{
public $ connection = ' default ' ;
public function up ()
{
// this method is auto-generated, please modify it to your needs
$ this -> addSql ( ' UPDATE users SET email = NULL WHERE email = ''' );
}
public function down ()
{
// this method is auto-generated, please modify it to your needs
}
}Lorsque vous utilisez des graines, veillez à utiliser les graines initiales uniquement pour des choses qui ne changeront pas ou ne seront pas ajoutées dans la production.
Créer des fichiers dans 'Seeds / Initial / Your_Table_Name' ou 'Seeds / Test / Your_Table_name' en suivant cet exemple:
<?php
return [
' connection ' => ' default ' ,
' rows ' => [
[
' id ' => ' 1 ' , // Primary keys is required
' name ' => ' AdmFirewall ' ,
],
[
' id ' => ' 2 ' ,
' name ' => ' AdmVoice ' ,
]
]
];Ensuite, vous pouvez exécuter des graines avec des drapeaux "- initial" ou "- tester". Cette commande supprimera toutes les lignes de vos tables en semer qui ne sont pas dans le fichier.
$ ./console db:seed --initialL'exécutable de la console disponible dans le répertoire racine de votre projet peut exécuter plusieurs commandes spécifiques à Framework. Mais il peut également exécuter des commandes générées par l'utilisateur.
$ ./console make:command --name script:license:refresh --description " Update license file "
Command file created at ~ /PROJECT_FOLDER/src/Commands/ScriptLicenseRefresh.php <?php
namespace App Commands ;
use Mini Console Command AbstractCommand ;
use Commando Command as Commando ;
class ScriptLicenseRefresh extends AbstractCommand
{
/**
* @return string
*/
public function getName ()
{
return ' script:license:refresh ' ;
}
/**
* @return string
*/
public function getDescription ()
{
return ' Update license file ' ;
}
/**
* @param Commando $commando
*/
public function setUp ( Commando $ commando )
{
/**
* Example:
*
* $commando->option('name')
* ->describedAs('Command name, example: "script:invoice:process"')
* ->defaultsTo('');
*/
}
/**
* @param Commando $commando
*/
public function run ( Commando $ commando )
{
/**
* Example:
*
* echo $commando['name'];
*/
}
}Alors vous pouvez exécuter votre commande
. /console script:license:refreshCertaines tâches telles que l'envoi d'e-mails et l'importation de données doivent être exécutées en arrière-plan. Les travailleurs sont des processus qui s'exécutent en attente de commandes en file d'attente. Tout d'abord, installez Beanstalkd dans votre machine.
$ apt-get install beanstalkd # Ubuntu/Debian
$ yum install beanstalkd # Fedora/CentosÉtape 1: Configuration de BeanStalkd dans votre fichier .env
printf ' WORKER_DRIVER=BEANSTALKDnBEANSTALKD_HOST="127.0.0.1"nBEANSTALKD_PORT=11300 ' >> .env Étape 2: Créez un fichier de classe de travailleurs dans src/Workers
$ ./console make:worker --name ImportFile Étape 3: Modifiez le fichier src/Workers/ImportFileWorker et exécutez le travailleur
$ ./console worker --run ImportFile # In production use something like supervisord to keep the process running foreverÉtape 4: Envoyez des emplois
<?php
namespace App Controllers ;
use Mini Helpers Request ;
use Mini Workers WorkerQueue ;
class ExampleController
{
/**
* @Get("/example")
* @Middleware("permission:SOME_PERMISSION")
*/
public function index ()
{
WorkerQueue:: addQueue (
' SendEmail ' ,
[
' someparam ' => ' someargument '
]
);
}
} Le fichier src/Application.php peut être utilisé pour configurer des classes et gérer les exceptions. Exemple:
<?php
namespace Mini ;
use Throwable ;
/**
* Application
*
* Handle application specific behaviors using predefined hooks methods. You can extend it in your app
*
* @package Mini
*/
class Application
{
public function afterContainerSetUp ()
{
// Is exected before router initialize
}
public function afterConfigurationSetup ()
{
// Is exected before router initialize
}
public function onException ( $ exception )
{
if ( $ exception instanceof Mini Validation ValidationException) {
response ()-> json ([
' error ' => [
' detail ' => $ exception -> errors
]
], 400 );
} else {
response ()-> json ([
' error ' => [
' detail ' => $ exception -> getMessage () . ' ' . $ exception -> getTraceAsString ()
]
], 500 );
}
}
}Il existe des fonctions globales qui viennent avec le cadre. Exemples:
// Get an item from an array using "dot" notation.
array_get ( $ _POST , ' user.email ' );
// Get variables from .env file
env ( ' DATABASE_NAME ' );
// Filter array keys
array_only ([ ' name ' => ' John ' , ' password ' => ' 123 ' ], [ ' name ' ]);
// Exclude array keys
array_except ([ ' name ' => ' John ' , ' password ' => ' 123 ' ], [ ' password ' ]);Vous pouvez vérifier plus d'exemples sur le code source
