Catalyst::Plugin::Session::Store::Jifty::DBI - Store your session with Jifty::DBI

  # prepare a table like this.
  # note that we use "session_id" instead of simple "id",
  # as "id" is usually reserved as serial by Jifty::DBI
  # (which is configurable but changing this is not recommended).
  package MyApp::Schema::Session;
  use Jifty::DBI::Schema;
  use Jifty::DBI::Record schema {
    column session_id
      => type is 'char(72)', is mandatory, is distinct, is indexed;
    column session_data => type is 'text';
    column expires      => type is 'integer';
  };

  # and a model
  package MyApp::Model::DB;
  use base qw( Catalyst::Model::Jifty::DBI );
  __PACKAGE__->config->{schema_base} = 'MyApp::Schema';

  # and your app.
  MyApp->config('Plugin::Session' => {
    expires => 3600,
    moniker => 'DB::Session',
  });

  # then in an action
  $c->session->[foo} = 'bar'; # will be saved

  MyApp->config('Plugin::Session' => {
    expires => 3600,
    moniker => 'DB::Session',
    columns => {
      id           => 'sid',
      session_data => 'body',
      expires      => 'until',
    },
  });

package Catalyst::Plugin::Session::Store::Jifty::DBI;

use strict;
use warnings;
use base qw( Catalyst::Plugin::Session::Store );
use Storable qw( nfreeze thaw );
use MIME::Base64;
use Catalyst::Exception;
use MRO::Compat;
use mro 'c3';

our $VERSION = '0.03';

sub setup_session {
  my $c = shift;

  $c->maybe::next::method(@_);

  unless ( $c->_session_plugin_config->{moniker} ) {
    Catalyst::Exception->throw(
      "Session::Store::Jifty::DBI: 'moniker' is missing"
    );
  }
  $c->_session_plugin_config->{moniker_collection}
    ||= $c->_session_plugin_config->{moniker} . 'Collection';

  my %column = %{ $c->_session_plugin_config->{columns} || {} };
  unless ( $column{id} && $column{session_data} && $column{expires} ) {
    $column{id}           ||= 'session_id';
    $column{session_data} ||= 'session_data';
    $column{expires}      ||= 'expires';
    $c->_session_plugin_config->{columns} = \%column;
  }
}

sub get_session_data {
  my ($c, $key) = @_;

  my $moniker = $c->_session_plugin_config->{moniker};
  my %column  = %{ $c->_session_plugin_config->{columns} };

  my $record = $c->model($moniker);
  if ( my ($sid) = $key =~ /^expires:(.*)/ ) {
    $key = "session:$sid";
    $record->load_by_cols( $column{id} => $key );
    return $record->_value( $column{expires} );
  }
  else {
    $record->load_by_cols( $column{id} => $key );
    my $data = $record->_value( $column{session_data} );
    return ( $c->_session_plugin_config->{use_custom_serialization} )
      ? $data
      : thaw( decode_base64( $data ) );
  }
  return;
}

sub store_session_data {
  my ($c, $key, $data) = @_;

  my $moniker = $c->_session_plugin_config->{moniker};
  my %column  = %{ $c->_session_plugin_config->{columns} };

  my $record = $c->model($moniker);
  if ( my ($sid) = $key =~ /^expires:(.*)/ ) {
    $key = "session:$sid";
    $record->load_by_cols( $column{id} => $key );
    if ( $record->id ) {
      $record->_set(
        column => $column{expires},
        value  => $c->session_expires,
      );
    }
  }
  else {
    unless ( $c->_session_plugin_config->{use_custom_serialization} ) {
      $data = encode_base64( nfreeze( $data ) );
    }

    my $expires = ( $key =~ /^(?:session|flash):/ )
                ? $c->session_expires
                : undef;

    $record->load_by_cols( $column{id} => $key );
    if ( $record->id ) {
      $c->model($moniker)->_handle->begin_transaction;
      eval {
        $record->_set(
          column => $column{session_data},
          value  => $data,
        );
        $record->_set(
          column => $column{expires},
          value  => $expires,
        );
      };
      $@ ? $c->model($moniker)->_handle->rollback
         : $c->model($moniker)->_handle->commit;
    }
    else {
      $record->create(
        $column{id}           => $key,
        $column{session_data} => $data,
        $column{expires}      => $expires,
      );
    }
  }
  return;
}

sub delete_session_data {
  my ($c, $key) = @_;

  return if $key =~ /^expires:/;

  my $moniker = $c->_session_plugin_config->{moniker};
  my %column  = %{ $c->_session_plugin_config->{columns} };

  my $record = $c->model($moniker);
  $record->load_by_cols( $column{id} => $key );
  $record->delete;
}

sub delete_expired_sessions {
  my $c = shift;

  # XXX: this must be much better to do with simple_query

  my $moniker = $c->_session_plugin_config->{moniker_collection};
  my %column  = %{ $c->_session_plugin_config->{columns} };

  my $collection = $c->model($moniker);
  $collection->limit(
    column   => $column{expires},
    value    => undef,
    operator => 'IS NOT',
  );
  $collection->limit(
    column   => $column{expires},
    value    => time(),
    operator => '<',
  );

  while( my $record = $collection->next ) {
    $record->delete;
  }
}

1;

__END__