Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/kberov/mojolicious-command-generate-resources

Routes from database for your application
https://github.com/kberov/mojolicious-command-generate-resources

command crud generator mojolicious mojolicious-command perl rest web web-framework

Last synced: about 2 months ago
JSON representation

Routes from database for your application

Awesome Lists containing this project

README 

        
NAME

    Mojolicious::Command::Author::generate::resources - Generate MVC &

    OpenAPI RESTful API files from database tables



SYNOPSIS

      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



PERL REQUIREMENTS

    This command uses "signatures" in feature, therefore Perl 5.20 is

    required.



DESCRIPTION

    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.



OPTIONS

    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.



  H|home_dir=s

    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.



  L|lib=s

    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.



  api_dir=s

    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.



  C|controller_namespace=s

    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']);



  M|model_namespace=s

    Optional. The namespace for the model classes to be generated. Defaults

    to MyApp::Model.



  T|templates_root=s

    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');



  D|db_helper=s

    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.



  t|tables=s@

    Mandatory. List of tables separated by commas for which controllers

    should be generated.



SUPPORT

    Please report bugs, contribute and make merge requests on Github

    .



ATTRIBUTES

    Mojolicious::Command::generate::resources inherits all attributes from

    Mojolicious::Command and implements the following new ones.



  args

    Used for storing arguments from the command-line.



      my $args = $self->args;



  description

      my $description = $command->description;

      $command        = $command->description('Foo!');



    Short description of this command, used for the "~$ mojo generate"

    commands list.



  routes

      $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.



  usage

      my $usage = $command->usage;

      $command  = $command->usage('Foo!');



    Usage information for this command, used for the help screen.



METHODS

    Mojolicious::Command::generate::resources inherits all methods from

    Mojolicious::Command and implements the following new ones.



  run

      Mojolicious::Command::generate::resources->new(app=>$app)->run(@ARGV);



    Run this command.



  render_template_to_file

    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);



  generate_formfields

    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);



  generate_openapi

    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".



  generate_path_api

    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".



  generate_validation

    Generates code for the "_validation" method in the respective controler.



        $validation_code = $self->generate_validation($table_name);



TODO

    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.



AUTHOR

        Красимир Беров

        CPAN ID: BEROV

        [email protected]



COPYRIGHT

    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.



SEE ALSO

    Mojolicious::Command::generate, Mojolicious::Command, Mojolicious,

    Mojolicious::Plugin::OpenAPI, Perl .