Mojolicious::Command::Author::generate::resources - Generate MVC & OpenAPI RESTful API files from database tables
Usage: APPLICATION generate resources [OPTIONS]
my_app.pl generate help resources # help with all available options
my_app.pl generate resources --tables users,groups
my_app.pl generate resources --tables users,groups -D dbx
This command uses "signatures" in feature, therefore Perl 5.20 is required.
An usable release...
Mojolicious::Command::generate::resources generates directory structure for a fully functional MVC set of files, routes and RESTful API specification in OpenAPI format based on existing tables in your application's database.
The purpose of this tool is to promote RAD by generating the boilerplate code for model (M), templates (V) and controller (C) and help programmers to quickly create well structured, fully functional applications. It assumes that you already have tables created in a database and you just want to generate CRUD actions for them.
In the generated actions you will find eventually working code for reading,
creating, updating and deleting records from the tables you specified on the
command-line. The generated code is just boilerplate to give you a jump start,
so you can concentrate on writing your business-specific code. It is assumed
that you will modify the generated code to suit your specific needs. All the
generated code is produced from templates. You can copy the folder with the
templates, push it to @{$app->renderer->paths} and modify to your
taste. Please look into the t/blog folder of this distribution for examples.
The command expects to find and will use one of the commonly used helpers
pg, mysql sqlite. The supported wrappers are respectively Mojo::Pg,
Mojo::mysql and Mojo::SQLite.
Below are the options this command accepts, described in Getopt::Long notation.
Both short and long variants are shown as well as the types of values they
accept. All of them, beside --tables, are guessed from your application and
usually do not need to be specified.
Optional. Defaults to app->home (which is MyApp home directory). Used to
set the root directory to which the files will be dumped. If you set this
option, respectively the lib and api folders will be created under the
new home_dir. If you want them elsewhere, set these options explicitly.
Optional. Defaults to app->home/lib (relative to the --home_dir
directory). If you installed MyApp in some custom path and you wish to
generate your controllers into e.g. site_lib, set this option.
Optional. Directory where
the OpenAPI json file will
be generated. Defaults to app->home/api (relative to the --home_dir
directory). If you installed MyApp in some custom path and you wish to
generate your OpenApi files into for example site_lib/MyApp/etc/api, set
this option explicitly.
Optional. The namespace for the controller classes to be generated. Defaults to
app->routes->namespaces->[0], usually MyApp::Controller, where
MyApp is the name of your application. If you decide to use another namespace
for the controllers, do not forget to add it to the list
app->routes->namespaces in myapp.conf or your plugin
configuration file. Here is an example.
# Setting the Controller class from which all controllers must inherit.
# See /perldoc/Mojolicious/#controller_class
# See /perldoc/Mojolicious/Guides/Growing#Controller-class
app->controller_class('MyApp::C');
# Namespace(s) to load controllers from
# See /perldoc/Mojolicious#routes
app->routes->namespaces(['MyApp::C']);
Optional. The namespace for the model classes to be generated. Defaults to MyApp::Model.
Optional. Defaults to app->renderer->paths->[0]. This is usually
app->home/templates directory. If you want to use another directory, do
not forget to add it to the app->renderer->paths list in your
configuration file. Here is how to add a new directory to
app->renderer->paths in myapp.conf.
# Application/site specific templates
# See /perldoc/Mojolicious/Renderer#paths
unshift @{app->renderer->paths}, $home->rel_file('site_templates');
Optional. If passed, this method name will be used when generating Model classes and helpers. The application is still expected to support the unified API of the supported database adapters. This feature helps to generate code for an application that wants to support all the three adaptors or if for example tomorrow suddenly appears a Mojo::Oracle tiny wrapper around DBD::Oracle.
Mandatory. List of tables separated by commas for which controllers should be generated.
Please report bugs, contribute and make merge requests on Github.
Mojolicious::Command::generate::resources inherits all attributes from Mojolicious::Command and implements the following new ones.
Used for storing arguments from the command-line.
my $args = $self->args;
my $description = $command->description;
$command = $command->description('Foo!');
Short description of this command, used for the ~$ mojo generate commands
list.
$self->routes;
Returns an ARRAY reference containing routes, prepared after
$self->args->{tables}. Suggested Perl code for the routes is dumped
in a file named TODO in --homedir so you can copy and paste into your
application code.
my $usage = $command->usage;
$command = $command->usage('Foo!');
Usage information for this command, used for the help screen.
Mojolicious::Command::generate::resources inherits all methods from Mojolicious::Command and implements the following new ones.
Mojolicious::Command::generate::resources->new(app=>$app)->run(@ARGV);
Run this command.
Renders a template from a file to a file using Mojo::Template. Parameters:
$tmpl_file - full path tho the template file; $target_file - full path to
the file to be written; $template_args - a hash reference containing the
arguments to the template. See also "render_to_file" in Mojolicious::Command.
$self->render_template_to_file($tmpl_file, $target_file, $template_args);
Generates form-fields from columns information found in the respective table.
The result is put into _form.html.ep. The programmer can then modify the
generated form-fields.
$form_fields = $self->generate_formfields($table_name);
Generates Open API file in json
format. The generated file is put in "--api_dir". The filename is
api.json. This is the file which will be loaded by MyApp.
Generates API definitions and paths for each table. Invoked in
"generate_openapi". Paramaters: $t - the table name;
$api_defs_object - the object API definition, based on the table name;
$tmpl_args - the arguments for the templates. $api_defs_object and
$tmpl_args will be enriched with additional key-value pairs as required by
the OpenAPI specification. Returns void.
Generates code for the _validation method in the respective controler.
$validation_code = $self->generate_validation($table_name);
The work on the features may not go in the same order specified here. Some parts may be fully implemented while others may be left for later.
- Improve documentation.
- Add initial documentation stub to the generated classes.
- Improve templates to generate code to which is more ready to use.
- Append to the existing api.json if it already exists. More tests.
Красимир Беров
CPAN ID: BEROV
[email protected]
This program is free software licensed under
Artistic License 2.0
The full text of the license can be found in the LICENSE file included with this module.
Mojolicious::Command::generate, Mojolicious::Command, Mojolicious, Mojolicious::Plugin::OpenAPI, Perl.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent