File Coverage

blib/lib/Modern/OpenAPI/Generator.pm

Criterion	Covered	Total	%
statement	69	70	98.5
branch	8	14	57.1
condition	23	40	57.5
subroutine	17	17	100.0
pod	2	2	100.0
total	119	143	83.2

package Modern::OpenAPI::Generator;

use v5.26;
use strict;
use warnings;
use Carp qw(croak);

our $VERSION = '0.001';

use Modern::OpenAPI::Generator::Spec ();
use Modern::OpenAPI::Generator::Writer ();
use Modern::OpenAPI::Generator::CodeGen::Client ();
use Modern::OpenAPI::Generator::CodeGen::ClientModels ();
use Modern::OpenAPI::Generator::CodeGen::Server ();
use Modern::OpenAPI::Generator::CodeGen::StubData ();
use Modern::OpenAPI::Generator::CodeGen::Auth ();
use Modern::OpenAPI::Generator::CodeGen::Docs ();
use Modern::OpenAPI::Generator::CodeGen::Tests ();
use Path::Tiny qw(path);

sub new {
    my ( $class, %arg ) = @_;
    bless {
        spec_path => ( $arg{spec_path} // croak('spec_path required') ),
        output_dir => (
            length( $arg{output_dir} // '' )
            ? $arg{output_dir}
            : croak('output_dir required')
        ),
        name       => ( $arg{name} // croak('name required') ),
        client     => $arg{client}     // 1,
        server     => $arg{server}     // 1,
        ui         => $arg{ui}         // 1,
        sync       => $arg{sync}       // 1,
        async      => $arg{async}      // 1,
        skeleton   => $arg{skeleton}   // 0,
        force      => $arg{force}      // 0,
        merge       => $arg{merge}       // 0,
        signatures  => $arg{signatures}  // [],
        local_test  => $arg{local_test}  // 0,
    }, $class;
}

sub run {
    my ($self) = @_;

    my $spec = Modern::OpenAPI::Generator::Spec->load( $self->{spec_path} );
    my $writer = Modern::OpenAPI::Generator::Writer->new(
        root  => $self->{output_dir},
        force => $self->{force},
        merge => $self->{merge},
    );

    path( $self->{output_dir} )->mkpath( { mode => 0755 } );

    my $copy_spec = path( $self->{output_dir} )->child('share')->child('openapi.yaml');
    $copy_spec->parent->mkpath( { mode => 0755 } );
    if ( !( $self->{merge} && -e $copy_spec ) ) {
        path( $self->{spec_path} )->copy($copy_spec);
    }

    my $base = $self->{name};

    Modern::OpenAPI::Generator::CodeGen::Auth->emit_plugins(
        writer     => $writer,
        base       => $base,
        signatures => $self->{signatures},
    );

    if ( $self->{client} ) {
        Modern::OpenAPI::Generator::CodeGen::Client->generate(
            writer   => $writer,
            spec     => $spec,
            base     => $base,
            sync     => $self->{sync},
            async    => $self->{async},
            signatures => $self->{signatures},
        );
    }

    # Models are required for StubData when serving with --local-test without a generated HTTP client.
    if ( $self->{client} || ( $self->{server} && $self->{local_test} ) ) {
        Modern::OpenAPI::Generator::CodeGen::ClientModels->generate(
            writer => $writer,
            spec   => $spec,
            base   => $base,
        );
    }

    if ( $self->{server} ) {
        Modern::OpenAPI::Generator::CodeGen::Server->generate(
            writer     => $writer,
            spec       => $spec,
            base       => $base,
            skeleton   => $self->{skeleton},
            local_test => $self->{local_test},
            ui         => $self->{ui},
            signatures => $self->{signatures},
        );
        if ( $self->{local_test} ) {
            Modern::OpenAPI::Generator::CodeGen::StubData->generate(
                writer => $writer,
                base   => $base,
            );
        }
    }
    elsif ( $self->{ui} ) {
        Modern::OpenAPI::Generator::CodeGen::Server->generate_spec_ui_only(
            writer => $writer,
            spec   => $spec,
            base   => $base,
        );
    }

    my $ui_only = !$self->{server} && $self->{ui};

    Modern::OpenAPI::Generator::CodeGen::Docs->generate(
        writer     => $writer,
        spec       => $spec,
        base       => $base,
        client     => $self->{client},
        server     => $self->{server},
        ui         => $self->{ui},
        sync       => $self->{sync},
        async      => $self->{async},
        ui_only    => $ui_only,
        local_test => $self->{local_test},
    );

    Modern::OpenAPI::Generator::CodeGen::Tests->generate(
        writer      => $writer,
        base        => $base,
        client      => $self->{client},
        server      => $self->{server},
        ui          => $self->{ui},
        sync        => $self->{sync},
        async       => $self->{async},
        signatures  => $self->{signatures},
        ui_only     => $ui_only,
        local_test  => $self->{local_test},
    );

    $self->_write_root_cpanfile($writer);
    return $self;
}

sub _write_root_cpanfile {
    my ( $self, $writer ) = @_;
    my $txt = <<'CPAN';
requires 'perl', '5.026';
requires 'Mojolicious', '9.0';
requires 'Mojolicious::Plugin::OpenAPI', '5.00';
requires 'Mojolicious::Plugin::SwaggerUI', '0';
requires 'JSON::Validator', '5.0';
requires 'OpenAPI::Modern', '0.060';
requires 'Moo', '2.005';
requires 'Types::Standard', '2.000';
requires 'YAML::PP', '0.034';
requires 'JSON::MaybeXS', '1.004';
requires 'Modern::Perl::Prelude', '0';
requires 'Digest::SHA', '6.00';

on test => sub {
    requires 'Test::More', '0.96';
};
CPAN
    $writer->write( 'cpanfile', $txt );
}

1;

__END__