File Coverage

blib/lib/Net/Amazon/DynamoDB/Table.pm

Criterion	Covered	Total	%
statement	33	92	35.8
branch	14	34	41.1
condition	9	45	20.0
subroutine	6	15	40.0
pod	5	9	55.5
total	67	195	34.3

package Net::Amazon::DynamoDB::Table;
use Net::Amazon::DynamoDB::Lite;
use Carp qw/cluck confess carp croak/;
use Moo;

our $VERSION="0.05";

has table       => (is => 'rw', required => 1);
has hash_key    => (is => 'rw', required => 1);
has range_key   => (is => 'rw', required => 0);
has dynamodb    => (is => 'lazy');
has region      => (is => 'rw', required => 1);
has access_key  => (is => 'rw', lazy => 1, builder => 1);
has secret_key  => (is => 'rw', lazy => 1, builder => 1);
has timeout     => (is => 'rw', default => 5);

sub _build_access_key { $ENV{AWS_ACCESS_KEY} }
sub _build_secret_key { $ENV{AWS_SECRET_KEY} }

sub _build_dynamodb {
    my $self = shift;
    Net::Amazon::DynamoDB::Lite->new(
        region             => $self->region,
        access_key         => $self->access_key,
        secret_key         => $self->secret_key,
        connection_timeout => $self->timeout,
    );
}

sub get {
    my ($self, %args) = @_;
    my $hash_key      = $self->hash_key;
    my $range_key     = $self->range_key;
    my $primary_key   = {};

    die "Key or $hash_key param required" unless $args{Key} || $args{$hash_key};

    if ($args{$hash_key}) {
        my $value = delete $args{$hash_key};
        $primary_key->{$hash_key} = $self->inflate_attribute_value($value);
    }
    if ($range_key && $args{$range_key} ) {
        my $value = delete $args{$range_key};
        $primary_key->{$range_key} = $self->inflate_attribute_value($value);
    }

    $args{Key}       ||= $primary_key;
    $args{TableName} ||= $self->table;

    return $self->dynamodb->get_item(\%args);
}

sub put {
    my ($self, %args)  = @_;

    die "Item param required" unless $args{Item};

    $args{TableName} ||= $self->table;
    $args{Item}        = $self->inflate_item($args{Item});

    return $self->dynamodb->put_item(\%args);
}

sub delete {
    my ($self, %args) = @_;
    my $hash_key      = $self->hash_key;
    my $range_key     = $self->range_key;
    my $primary_key   = {};

    die "Key or $hash_key param required" unless $args{Key} || $args{$hash_key};

    if ($args{$hash_key}) {
        my $value = delete $args{$hash_key};
        $primary_key->{$hash_key} = $self->inflate_attribute_value($value);
    }
    if ($range_key && $args{$range_key} ) {
        my $value = delete $args{$range_key};
        $primary_key->{$range_key} = $self->inflate_attribute_value($value);
    }

    $args{Key}       ||= $primary_key;
    $args{TableName} ||= $self->table;

    return $self->dynamodb->delete_item(\%args);
}

sub inflate_item {
    my ($self, $item) = @_;
    my %new;

    for my $attr (keys %$item) {
        my $val = $item->{$attr};
        $new{$attr} = $self->inflate_attribute_value($val) || next;
    }

    return \%new;
}

sub inflate_hash_key {
    my ($self, $thing) = @_;
    my %new;

    if (ref($thing) eq 'HASH') {
        my %new;
        for my $key (keys %$thing) {
            $new{$key} = $self->inflate_attribute_value($thing->{$key});
        }
        return \%new;
    }
    else {
        return $self->inflate_attribute_value($thing);
    }
}

sub inflate_attribute_value {
    my ($self, $thing) = @_;

    if (ref($thing) eq 'HASH') {
        my %vals;
        for my $key (keys %$thing) {
            $vals{$key} = $self->inflate_attribute_value($thing->{$key}) || next;
        }
        return unless keys %vals;
        return { M => \%vals };
    }
    elsif (ref($thing) eq 'ARRAY') {
        my @vals;
        for my $t (@$thing) {
            push @vals, $self->inflate_attribute_value($t) || next;
        }
        return unless scalar @vals;
        return { L => [@vals] };
    }
    elsif (ref($thing) eq 'SCALAR') {
        return unless $$thing;
        return { B => MIME::Base64::encode_base64($$thing, '') };
    }
    elsif ($self->isa_number($thing)) {
        return { N => "$thing" };
    }
    else {
        return unless $thing;
        return { S => $thing };
    }
}

sub isa_number {
    my ($self, $thing) = @_;
    return 1 if B::svref_2object(\$thing)->FLAGS & (B::SVp_IOK | B::SVp_NOK)
        && 0 + $thing eq $thing
        && $thing * 0 == 0;
    return 0;
}

sub scan {
    my ($self, %args) = @_;
    $args{TableName} ||= $self->table;
    return $self->dynamodb->scan(\%args);
}

sub scan_as_hashref {
    my ($self, %args)  = @_;
    $args{TableName} ||= $self->table;
    my $items_hashref  = {};
    my $items_arrayref = $self->scan(%args);
    my $hash_key_name  = $self->hash_key;

    for my $item (@$items_arrayref) {
        my $hash_key_value = delete $item->{$hash_key_name};
        $items_hashref->{$hash_key_value} = $item;
    }

    return $items_hashref;
}

1;
__END__