File Coverage

blib/lib/DNS/Hetzner/Schema.pm

Criterion	Covered	Total	%
statement	112	114	98.2
branch	33	36	91.6
condition	4	5	80.0
subroutine	12	13	92.3
pod	1	1	100.0
total	162	169	95.8

package DNS::Hetzner::Schema;
$DNS::Hetzner::Schema::VERSION = '0.05';
# ABSTRACT: OpenAPI schema for the DNS API

use v5.24;

use Mojo::Base -strict, -signatures;

use JSON::Validator;
use JSON::Validator::Formats;
use List::Util qw(uniq);
use Mojo::JSON qw(decode_json);
use Mojo::Loader qw(data_section);
use Mojo::Util qw(camelize);

use constant IV_SIZE => eval 'require Config;$Config::Config{ivsize}';

sub validate ( $class, $operation, $params = {} ) {
    my ($spec, $validator) = _get_params($operation);

    my %check_params = map {
        my $camelized = camelize $_;
        $camelized =~ s{Id$}{ID};

        $spec->{param_names}->{$camelized} ?
            ($camelized => $params->{$_}) :
            ($_ => $params->{$_});
    } keys $params->%*;

    my @errors = $validator->validate(
        \%check_params,
    );

    if ( @errors ) {
        return ( undef, @errors );
    }

    my %request_params;

    for my $param_name ( sort keys $spec->{param_names}->%* ) {
        my $key = $spec->{param_names}->{$param_name};

        next if !$check_params{$param_name};

        $request_params{$key}->{$param_name} = $check_params{$param_name};
    }

    return \%request_params;
}

sub _get_params ($operation) {
    state %operation_params;

    my $op_data = $operation_params{$operation};
    return $op_data->@* if $op_data;

    my $api_spec = data_section(__PACKAGE__, 'openapi.json');
    $api_spec    =~ s{/components/schemas}{}g;

    my $data    = decode_json( $api_spec );
    my $schemas = $data->{components}->{schemas};

    my %paths = $data->{paths}->%*;

    my $op;

    for my $path ( keys %paths ) {

        METHOD:
        for my $method_name ( keys $paths{$path}->%* ) {
            next METHOD if 'HASH' ne ref $paths{$path}->{$method_name};

            my $method = $paths{$path}->{$method_name};
            if ( $method->{operationId} && $method->{operationId} eq $operation ) {
                $op = $method;
            }
        }
    }

    return {} if !$op;

    my $params = $op->{parameters};

    my %properties;
    my @required;
    my %param_names;

    PARAM:
    for my $param ( $params->@* ) {
        next PARAM if $param->{name} eq 'Auth-API-Token';

        my $name = $param->{name};

        if ( $param->{required} ) {
            push @required, $name;
        }

        $param_names{$name} = $param->{in};
        $properties{$name}  = $param;
    }

    my ($content_type, $body_required);
    if ( $op->{requestBody} ) {
       my $body       = $op->{requestBody}->{content};
       $body_required = $op->{requestBody}->{required};

       ($content_type) = sort keys $body->%*;

       if ( $content_type eq 'application/json' ) {
           my $schema = $body->{$content_type}->{schema};
           my $prop   = $schema->{properties} || {};
           for my $property ( keys $prop->%* ) {
               $properties{$property}  = delete $prop->{$property};
               $param_names{$property} = 'body';
           }

           if ( $schema->{'$ref'} ) {  # '$ref' is not a typo. The key is named '$ref'!
               $properties{'$ref'} = $schema->{'$ref'};
           }
       }
       elsif ( $content_type eq 'text/plain' ) {
           $properties{text}  = { type => "string" };
           $param_names{text} = 'body';
       }
    }

    my $spec = {
        type          => 'object',
        required      => \@required,
        body_required => $body_required,
        properties    => \%properties,
        param_names   => \%param_names,
        content_type  => $content_type,
        $schemas->%*,
    };

    my $validator = JSON::Validator->new->schema($spec);

    $validator->formats->{uint32} = sub {
        my ($sub) = JSON::Validator::Formats->can('_match_number');

        $sub->( unint32 => $_[0], 'L' );
    };

    $validator->formats->{uint64} = sub {
        my ($sub) = JSON::Validator::Formats->can('_match_number');

        $sub->( unint32 => $_[0], IV_SIZE >= 8 ? 'Q' : '' );
    };

    if ( $spec->{properties}->{'$ref'} ) {
        my @ref = $spec->{properties}->{'$ref'};
        while ( my $ref = shift @ref ) {
            $ref =~ s{^#}{};

            my $data = $validator->get( $ref );
            if ( $data->{properties} ) {
                for my $property ( keys $data->{properties}->%* ) {
                    next if $data->{properties}->{$property}->{readOnly};

                    $spec->{param_names}->{$property} = 'body';
                }
            }

            if ( $data->{allOf} ) {
                push @ref, map{ $_->{'$ref'} } $data->{allOf}->@*;
                if ( $data->{required} ) {
                    push $spec->{required}->@*, $data->{required}->@*;
                }
            }
        }
    }

    $spec->{required}->@* = uniq $spec->{required}->@*;

    $operation_params{$operation} = [ $spec, $validator ];
    return $operation_params{$operation}->@*;
}

1;

=pod

=encoding UTF-8

=head1 NAME

DNS::Hetzner::Schema - OpenAPI schema for the DNS API

=head1 VERSION

version 0.05

=head1 SYNOPSIS

=head1 METHODS

=head2 validate

=head1 AUTHOR

Renee Baecker

=head1 COPYRIGHT AND LICENSE

This software is Copyright (c) 2020 by Renee Baecker.

This is free software, licensed under:

  The Artistic License 2.0 (GPL Compatible)

=cut

__DATA__