Additional Laravel Artisan xmake command for faster resource creating and scaffolding. Created to speed up developing process and stop typing same things in various places.
This package was developed for Laravel 5.8 and up. I haven't tested earlier versions yet.
Require this package with composer for development only.
composer require arkadiuszbachorski/laravel-xmake --devPublish config
php artisan vendor:publish --tag=xmake-configChange default resource paths if you would like to.
Publish resources
php artisan vendor:publish --tag=xmake-resources- Scaffold your app quicker
- Create many related files with just one command: model, controller, request, resource, migration, seeder and factory
- Provide fields in one place, rest will be prepared or even filled for you
- Easily customize stubs for your needs
You'd rather see than read?
Example:
php artisan xmake -i --fields=title,foo,bar --modelName=Foobar --model --request --controller --apiResult
FoobarController.php
<?php
namespace App\Http\Controllers;
use App\Foobar;
use App\Http\Requests\FoobarRequest;
class FoobarController extends Controller
{
/**
* Display a listing of the resource.
*
* @return Response
*/
public function index()
{
$foobars = Foobar::all();
return response()->json([]);
}
/**
* Show the form for creating a new resource.
*
* @return Response
*/
public function create()
{
return response()->json([]);
}
/**
* Store a newly created resource in storage.
*
* @param FoobarRequest $request
* @return Response
*/
public function store(FoobarRequest $request)
{
Foobar::create($request->validated());
return response()->json([]);
}
/**
* Display the specified resource.
*
* @param Foobar $foobar
* @return \Illuminate\Http\Response
*/
public function show(Foobar $foobar)
{
return response()->json([]);
}
/**
* Show the form for editing the specified resource.
*
* @param Foobar $foobar
* @return \Illuminate\Http\Response
*/
public function edit(Foobar $foobar)
{
return response()->json([]);
}
/**
* Update the specified resource in storage.
*
* @param FoobarRequest $request
* @param Foobar $foobar
* @return \Illuminate\Http\Response
*/
public function update(FoobarRequest $request, Foobar $foobar)
{
$foobar->update($request->validated());
return response()->json([]);
}
/**
* Remove the specified resource from storage.
*
* @param Foobar $foobar
* @return \Illuminate\Http\Response
* @throws \Exception
*/
public function destroy(Foobar $foobar)
{
$foobar->delete();
return response()->json([]);
}
}Foobar.php
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Foobar extends Model
{
protected $guarded = [];
}FoobarRequest.php
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class FoobarRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize()
{
return false;
}
/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules()
{
return [
'title' => '',
'foo' => '',
'bar' => '',
];
}
}Pretty nice, huh? For more details and possibilities, see documentation.
- Guessing factory based on validation and migration field type
- Guessing migration field type based on validation
config/xmake.php
[
'paths' => [
// Path where stubs are expected to exist. This path affects vendors publishing too.
'stubs' => '/resources/xmake/stubs',
// Path where fields.php is expected to exist. This path affects vendors publishing too.
'fields' => '/resources/xmake',
],
'database' => [
// Flag that indicates whether ->nullable() should be automatically added if provided in validation
'addNullableIfAppearsInValidation' => true,
],
'controller' => [
// You can change PHPDoc methods captions there
'docs' => [
'index' => 'Display a listing of the resource.',
'create' => 'Show the form for creating a new resource.',
'store' => 'Store a newly created resource in storage.',
'show' => 'Display the specified resource.',
'edit' => 'Show the form for editing the specified resource.',
'update' => 'Update the specified resource in storage.',
'destroy' => 'Remove the specified resource from storage.',
],
// You can change CRUD methods names there
'methods' => [
'index' => 'index',
'create' => 'create',
'store' => 'store',
'show' => 'show',
'edit' => 'edit',
'update' => 'update',
'destroy' => 'destroy',
],
],
'seeder' => [
// Default amount used in seeders if not provided by --amount option
'defaultAmount' => 50,
],
'resource' => [
// Flag that indicates whether resource fields should be parsed to camelCase
'camelizeFields' => true,
],
'validation' => [
// It enables parsing pipe syntax (i.e. "string|nullable") to array
'parseArray' => true,
// It enables guessing validation based on database field. I.e. string('foobar') parses to 'string' validation.
'guessBasedOnDatabase' => true,
],
// You can change what will be created if you select "create everything"/"all" option
'createEverything' => [
'model' => true,
'migration' => true,
'factory' => true,
'seeder' => true,
'request' => true,
'resource' => true,
'controller' => true,
],
];Stubs can be found in /resources/xmake/stubs path by default. You will see a few text files there. All of them contain "Dummy..." content, that means it will be replaced by generated things. Everything what isn't prefixed with "Dummy..." can be customised by you.
Fields file can be found in /resources/xmake/fields.php path by default. It's a source of data about fields.
[
// key used in --fields option
'title20ch' => [
/*
Field name used in Eloquent, database migration.
I.e $model->title
*/
'name' => 'title',
/*
Used in factory after $faker->
I.e. 'title' => $faker->sentence(2)
*/
'factory' => 'sentence(2)',
'validation' => 'string|nullable',
/*
Migration, NAME will by replaced with actual name automatically
I.e. string('title', 20)->default('test'),
*/
'database' => 'string(NAME, 20)->default("test")',
],
];You don't have to fill in all the data about each field. The only required one is the "name". If you enter unknown field to --fields option, it will be treated as the key is the name and the other parameters are empty.
This means you can completely ignore this file if you would like just list every field in created files.
However Xmake has a few self-filling and data processing mechanisms as you could see in config. If you provide database field there is probability of getting at least some of repetitive things filled in validation and factory.
Every command has --help, so you can check available options faster than checking here.
In examples below I assume default config and file fields.php contains:
[
'foo' => [
'name' => 'foo',
'factory' => 'sentence(2)',
'validation' => 'string|nullable',
'database' => 'string(NAME, 20)->default("test")',
],
];It's a command that will be used most often, because it gives powerful scaffolding ability. It can call every single command listed below.
Xmake by default runs interactive shell experience. If you would like to create resources even faster - use --instant flag. Results are almost the same, but you can't name your files independently. Probably you wouldn't do it anyway, because auto-naming works great.
Use this flag if you want don't want to use interactive shell.
This parameter is required, almost every command uses it.
Get fields keys array, use comma as separator
Create everything based on your config. By default - it's literally everything.
Create API version of Controller and enable resource creating
Create model with given modelName
Create migration with given fields prepared or filled
Create factory with given fields prepared of filled
Create seeder that invokes factory
Create request with given fields prepared or filled
Create resource with given fields prepared of filled
Create controller with various options - request, resource and api, based on your previous choices.
It simply creates model.
Example
php artisan xmake:model FoobarResult:
Foobar.php
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Foobar extends Model
{
protected $guarded = [];
}It creates controller with:
- basic CRUD operations for your model
- Blade views or REST API
- Validation inside or injected
It's required. You must provide your models name.
It's a flag that changes responses from Blade views to REST API.
You can provide fields for validation there.
It injects given resource to index, store, show, edit and update returns. It does nothing when no --api flag provided.
It injects given request to create and update methods. If the file doesn't exist - it can be created with fields you provided.
Example
php artisan xmake:controller FoobarController --api --fields=foo,bar --model=FoobarResult:
<?php
namespace App\Http\Controllers;
use App\Foobar;
use Illuminate\Http\Request;
class FoobarController extends Controller
{
/**
* Display a listing of the resource.
*
* @return \Illuminate\Http\Response
*/
public function index()
{
$foobars = Foobar::all();
return response()->json([]);
}
/**
* Show the form for creating a new resource.
*
* @return \Illuminate\Http\Response
*/
public function create()
{
return response()->json([]);
}
/**
* Store a newly created resource in storage.
*
* @param Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
$data = $request->validate([
'foo' => 'string|nullable',
'bar' => '',
]);
Foobar::create($data);
return response()->json([]);
}
/**
* Display the specified resource.
*
* @param Foobar $foobar
* @return \Illuminate\Http\Response
*/
public function show(Foobar $foobar)
{
return response()->json([]);
}
/**
* Show the form for editing the specified resource.
*
* @param Foobar $foobar
* @return \Illuminate\Http\Response
*/
public function edit(Foobar $foobar)
{
return response()->json([]);
}
/**
* Update the specified resource in storage.
*
* @param Request $request
* @param Foobar $foobar
* @return \Illuminate\Http\Response
*/
public function update(Request $request, Foobar $foobar)
{
$data = $request->validate([
'foo' => 'string|nullable',
'bar' => '',
]);
$foobar->update($data);
return response()->json([]);
}
/**
* Remove the specified resource from storage.
*
* @param Foobar $foobar
* @return \Illuminate\Http\Response
* @throws \Exception
*/
public function destroy(Foobar $foobar)
{
$foobar->delete();
return response()->json([]);
}
}It creates resource with given fields filled. It makes fields name camelCase by default, however it can be changed in config.
Example
php artisan xmake:resource FoobarResource --fields=foo,bar,not_camel_case_fieldResult:
<?php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\JsonResource;
class FoobarResource extends JsonResource
{
/**
* Transform the resource into an array.
*
* @param \Illuminate\Http\Request $request
* @return array
*/
public function toArray($request)
{
return [
'foo' => $this->foo,
'bar' => $this->bar,
'notCamelCaseField' => $this->not_camel_case_field,
];
}
}It creates migration with given fields prepared or filled.
Table name
Example
php artisan xmake:migration create_foobar_table --create=foobar --fields=foo,barResult:
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateFoobarTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('foobar', function (Blueprint $table) {
$table->bigIncrements('id');
$table->string('foo', 20)->default("test")->nullable();
$table->('bar');
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('foobar');
}
}It creates request with given validation rules prepared or filled.
Example
php artisan xmake:request FoobarRequest --fields=foo,barResult:
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class FoobarRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize()
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules()
{
return [
'foo' => 'string|nullable',
'bar' => '',
];
}
}It creates factory with given factory rules prepared or filled.
Example
php artisan xmake:factory FoobarFactory --fields=foo,barResult:
<?php
/* @var $factory \Illuminate\Database\Eloquent\Factory */
use App\Foobar;
use Faker\Generator as Faker;
$factory->define(Foobar::class, function (Faker $faker) {
return [
'foo' => $faker->sentence(2),
'bar' => $faker->,
];
});It creates seeder with given model.
Model name.
Number of models to be created in seeder. Default value can be changed in config.
Example
php artisan xmake:seeder FoobarSeeder --model=foo,bar --amount=33Result:
<?php
use Illuminate\Database\Seeder;
use App\Foobar;
class FoobarSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
factory(Foobar::class, 33);
}
}All the above files can be created with just one command:
php artisan xmake -i --modelName=Foobar --all --api --fields=foo,bar