File Coverage

blib/lib/Starch/Store/DBIx/Connector.pm

Criterion	Covered	Total	%
statement	46	47	97.8
branch	3	6	50.0
condition			n/a
subroutine	17	17	100.0
pod	0	1	0.0
total	66	71	92.9

package Starch::Store::DBIx::Connector;
use 5.008001;
use strictures 2;
our $VERSION = '0.04';

=head1 NAME

Starch::Store::DBIx::Connector - Starch storage backend using DBIx::Connector.

=head1 SYNOPSIS

    my $starch = Starch->new(
        store => {
            class => '::DBIx::Connector',
            connector => [
                $dsn,
                $username,
                $password,
                { RaiseError=>1, AutoCommit=>1 },
            ],
        },
    );

=head1 DESCRIPTION

This L store uses L to set and get state data.

The table in your database should contain three columns.  This
is the SQLite syntax for creating a compatible table which you
can modify to work for your particular database's syntax:

    CREATE TABLE starch_states (
        key TEXT NOT NULL PRIMARY KEY,
        data TEXT NOT NULL,
        expiration INTEGER NOT NULL
    )

=cut

use DBIx::Connector;
use Types::Standard -types;
use Types::Common::String -types;
use Scalar::Util qw( blessed );
use Data::Serializer::Raw;

use Moo;
use namespace::clean;

with qw(
    Starch::Store
);

after BUILD => sub{
    my ($self) = @_;

    # Get this loaded as early as possible.
    $self->connector();

    return;
};

=head1 REQUIRED ARGUMENTS

=head2 connector

This must be set to either an array ref arguments for L
or a pre-built object (often retrieved using a method proxy).

When configuring Starch from static configuration files using a
L
is a good way to link your existing L object
constructor in with Starch so that starch doesn't build its own.

=cut

has _connector_arg => (
    is       => 'ro',
    isa      => (InstanceOf[ 'DBIx::Connector' ]) | ArrayRef,
    init_arg => 'connector',
    required => 1,
);

has connector => (
    is       => 'lazy',
    isa      => InstanceOf[ 'DBIx::Connector' ],
    init_arg => undef,
);
sub _build_connector {
    my ($self) = @_;

    my $connector = $self->_connector_arg();
    return $connector if blessed $connector;

    return DBIx::Connector->new( @$connector );
}

=head1 OPTIONAL ARGUMENTS

=head2 serializer

A L for serializing the state data for storage
in the L.  Can be specified as string containing the
serializer name, a hash ref of Data::Serializer::Raw arguments, or as a
pre-created Data::Serializer::Raw object.  Defaults to C.

Consider using the C or C serializers for speed.

C will likely be the fastest and produce the most compact data.

=cut

has _serializer_arg => (
    is       => 'ro',
    isa      => ((InstanceOf[ 'Data::Serializer::Raw' ]) | HashRef) | NonEmptySimpleStr,
    init_arg => 'serializer',
    default  => 'JSON',
);

has serializer => (
    is       => 'lazy',
    isa      => InstanceOf[ 'Data::Serializer::Raw' ],
    init_arg => undef,
);
sub _build_serializer {
    my ($self) = @_;

    my $serializer = $self->_serializer_arg();
    return $serializer if blessed $serializer;

    if (ref $serializer) {
        return Data::Serializer::Raw->new( %$serializer );
    }

    return Data::Serializer::Raw->new(
        serializer => $serializer,
    );
}

=head2 method

The L method to call when executing queries.
Must be one of C, C, or C.  Defaults to C.

=cut

has method => (
    is      => 'ro',
    isa     => Enum['run', 'txn', 'svp'],
    default => 'run',
);

=head2 mode

The L to use
when running the L.  Defaults to C which lets
L use whichever mode it has been configured to use.
Must be on of C, C, C, or C.

Typically you will not want to set this as you will have provided
a pre-built L object, using a method proxy, which
you've already called L on.

=cut

has mode => (
    is => 'ro',
    isa => (Enum['ping', 'fixup', 'no_ping']) | Undef,
);

=head2 table

The table name where states are stored in the database.
Defaults to C.

=cut

has table => (
    is      => 'ro',
    isa     => NonEmptySimpleStr,
    default => 'starch_states',
);

=head2 key_column

The column in the L