Transações e Autorizações do jeito simples

Eu realmente gosto de seguir o DRY: Don't Repeat Yourself. No desenvolvimento do Epitáfio (um sistema de gestão de cemitérios que eu mencionei outro dia), eu estava trabalhando nas minhas classes model - note que isso não é um model DBIC, mas uma classe normal que vai acessar um schema DBIC - e eu percebi que para cada um dos métodos eu precisaria de duas coisas:

• Embutir em uma transação, mais ou menos como:

  $schema->txn_do(sub { ... })

• Autorizar em relação a uma role específica:

  die 'Access denied!' unless $user->in_role('foo')

Então eu comecei a pensar no #catalyst se teria um jeito bonito de fazer isso. Eu já estava usando o Catalyst::Component::InstancePerContext, ams o mst rapidamente me guiou em evitar salvar o contexto no model, mas simplesmente pegar os valores que eu preciso de lá. Já que os meus models vão ter basicamente esse mesmo princípio, eu fiz uma superclasse:

package Epitafio::Model;
use Moose;
with 'Catalyst::Component::InstancePerContext';
has 'user' => (is => 'rw');
has 'dbic' => (is => 'rw');

sub build_per_context_instance {
  my ($self, $c) = @_;
  $self->new(user => $c->user->obj,
             dbic => $c->model('DB')->schema->restrict_with_object($c->user->obj));
}
1;

Veja que eu ainda estou usando o C::M::DBIC::Schema como sempre, mas eu estou, adicionalmente, fazendo um dbic schema local que é restrito de acordo com o usuário autenticado. Veja a documentação do DBIx::Class::Schema::RestrictWithObject para os detalhes, e mst++ pela dica.

Ok, agira as minhas classes model sabem quem é o usuário logado (independente do Catalyst) e também têm acesso ao dbic schema principal da aplicação. Agora precisamos apenas DRO - Don't Repeat Ourselves.

Seguindo, novamente, a dica do mst++, eu decidi não tentar uma solução fancy, e ir para o puro e simples:

txn_method 'foo' => authorize 'rolename' => sub {
   ...
}

Para aqueles que não entenderam como isso é interpretado, poderia ser reescrito como:

txn_method('foo',authorize('rolename',sub { }))

Isso funciona da seguinte forma:

• authorize recebe o nome de uma role e a referência para o código, retornando outra referencia para um código que checa se o usuário tem a role antes de chamar o código efetivo.
• txn_method recebe o nome de um método e uma referência para um código e instala um coderef que embute o coderef passado em uma transação no namespace do pacote, como se fosse uma rotina regular.

Isso significa que você pode ter um txn_method sem authorize, mas iria requerer

our &foo = authorize 'rolename' => sub { ... }

para ter autorização sem transação. Mas como a minha aplicação eu vou precisar dos dois a maior parte do tempo, isso deve servir.

Mas para que o txn_method..authorize seja interpretado, as duas subs precisam estar no namespace do pacote em tempo de BEGIN, para resolver isso sem ter que colar as rotinas toda vida, escrevi um módulo simples Epitafio::ModelUtil que exporta-os.

package Epitafio::ModelUtil;
use strict;
use warnings;
use base 'Exporter';

our @EXPORT = qw(txn_method authorized);

sub txn_method {
  my ($name, $code) = @_;
  my $method_name = caller().'::'.$name;
  no strict 'refs';
  *{$method_name} = sub {
    $_[0]->dbic->txn_do($code, @_)
  };
}

sub authorized {
  my ($role, $code) = @_;
  return sub {
    if ($_[0]->user->in_role($role)) {
      $code->(@_);
    } else {
      die 'Access Denied!';
    }
  }
}

1;

E agora o código do model é bonito e não repetitivo ;). Veja os fontes para a versão completa.