Catalyst::Model::EmailStore - Email::Store Model Class

    # use the helper
    create model EmailStore EmailStore dsn user password

    # lib/MyApp/Model/EmailStore.pm
    package MyApp::Model::EmailStore;

    use base 'Catalyst::Model::EmailStore';

    __PACKAGE__->config(
        dsn                    => 'dbi:Pg:dbname=myapp',
        password               => '',
        user                   => 'postgres',
        options                => { AutoCommit => 1 },
        cdbi_plugins           => [ qw/AbstractCount Pager/ ],
        upgrade_relationships  => 1
    );

    1;

    # As object method
    $c->model('EmailStore::Address')->search(...);

    # As class method
    MyApp::Model::EmailStore::Adress->search(...);

package Catalyst::Model::EmailStore;

use warnings;
use strict;
use base qw/Catalyst::Base/;
use NEXT;
use Data::Dumper;
use Scalar::Util;
use Clone qw();

our $VERSION = '0.03';

BEGIN {

  require Email::Store::DBI;
  require Module::Pluggable::Ordered;

  {

	 #BUG: this doesn't allow to refine plugins in the Catalyst model
	 #BUG: but I really don't know how to fix this

	 sub Email::Store::call_plugins {
		shift; Catalyst::Model::EmailStore->call_plugins( @_ );
	 }

	 package Email::Store::DBI;
	 sub _cataylst_model_email_store_import_hook {
		my $class = shift;
		my $to_import = shift;
		$to_import->import(@_);
	 };

	 # remove overloading of bool done by CDBI which will cause
    # problems with $c->model and maybe other stuff as well
	 use overload bool => sub { $_[0] };
  }

}

sub new {
  my $class = shift;
  my $self  = $class->NEXT::new( @_ );
  my $c     = shift;
  my $prefix = $c  . '::Model::EmailStore';

  return bless {%$self}, $class if $class =~ /^$prefix\::/;

  my %p = %{ $self };

  my $caller = caller();

  Module::Pluggable::Ordered->import
		( inner => 1, search_path => [ "Email::Store" ] );
  Email::Store::DBI->import( @p{ qw/dsn user password options/ } );


  # exclude Email::Store::DBI which is wrongly detected as plugin of
  # Email::Store and import only model classes (i.e. E::S::DBI descendants)
  # from this namespace

  my @models = grep{
	 $_ ne qw/Email::Store::DBI/ and $_->isa( qw/Email::Store::DBI/ );
  } __PACKAGE__->plugins;

  for my $plugin ( @models ) {
	 no strict 'refs';
	 $plugin->require;
	 my $model = $plugin;
	 $model =~ s/^Email::Store/$prefix/;
	 @{"$model\::ISA"} = ( $plugin, ref( $self ) );
    *{"$model\::new"} = sub { bless {%$self}, $model };
	 $c->components->{$model} ||= $model->new();
  }

  $c->log->info( "Loaded Email::Store models: @models" ) if $c->debug;

  if ( $self->{upgrade_relationships} ) {
	 # upgrade table relationships
	 require Clone;
	 for my $plugin ( @models ) {
		my $model = $plugin;
		$model =~ s/^Email::Store/$prefix/;

		$c->log->debug( "Upgradin relationships of $model" ) if $c->debug;

		# create a clean copy of table meta information
		my $meta = $model->__meta_info( Clone::clone( $plugin->__meta_info ) );

		# use a recursive anonymous sub to change all keys that describe
		# class relationships from Email::Store to the newly created
		# Catalyst models
		my $recursive_upgrade;
		$recursive_upgrade = sub {
		  my $href = shift;
		  my $changes = 0;
		  for ( keys %{ $href } ) {
			 if ( ref($href->{$_}) eq 'HASH' ) {
				$changes += &$recursive_upgrade($href->{$_});
				next;
			 }
			 if ( Scalar::Util::blessed($href->{$_}) ) {
				$changes += &$recursive_upgrade($href->{$_});
				# if we encountered a relationship we have to
				# reinitialize it so that the correct accessors will
				# be created
				next unless $changes;
				if ( $href->{$_}->isa( qw/Class::DBI::Relationship/ ) ) {
				  $href->{$_}->_set_up_class_data;
				  $href->{$_}->_add_triggers;
				  $href->{$_}->_add_methods;
				}
				# all changes to this relationship have been done
				# so we can reset our counter here ( relationships
				# can't be nested as far as I know )
				$changes = 0;
			 }
			 if ( $_ =~ /class$/ ) {
				$changes += ( $href->{$_} =~ s/Email::Store/$prefix/ );
			 }
		  }
		  return $changes;
		};
		&$recursive_upgrade( $meta );
	 }
  }

  # pull in the requested cdbi plugins
  if ( exists( $self->{cdbi_plugins} ) ) {
	 my @cdbi_plugins = map{"Class::DBI::Plugin::$_"} @{$self->{cdbi_plugins}};
	 for my $plugin ( @cdbi_plugins ) {
		$plugin->require;
		Email::Store::DBI->_cataylst_model_email_store_import_hook( $plugin );
	 }
	 $c->log->info( "Loaded CDBI plugins for Email::Store: @cdbi_plugins" )
		if $c->debug;
  }

  return $self;
}

1;

__END__