README

SierraTecnologia Escritor integration services escritor and providers for users required by various SierraTecnologia packages. Validator functionality, and basic controller included out-of-the-box.

📚 Índice

Introdução
Instalação
Arquitetura e Estrutura Interna
Principais Funcionalidades
Uso Prático
Integração com o Ecossistema SierraTecnologia
Extensão e Customização
Exemplos Reais
Guia de Contribuição
Ferramentas de Qualidade (GitHub Tools)

🎯 Introdução

O que é o Escriba

O Escriba (também conhecido como Escritor) é um módulo completo de e-commerce e gestão comercial desenvolvido pela SierraTecnologia, projetado para integrar funcionalidades robustas de loja virtual, gestão de produtos, processamento de pedidos e transações financeiras em aplicações Laravel.

Objetivo e Motivação

O projeto nasceu da necessidade de fornecer uma solução empresarial completa e modular para PMEs, permitindo:

Gestão completa de produtos com variantes, imagens e arquivos digitais
Carrinho de compras inteligente com gestão de sessão
Processamento de pedidos e controle de estoque
Sistema de transações financeiras integrado
Planos de assinatura (subscriptions) opcionais
Cupons de desconto e promoções
Analytics e relatórios de vendas
Favoritos e listas de desejos

Contexto no Ecossistema SierraTecnologia / Rica Soluções

O Escriba é um componente fundamental do ecossistema SierraTecnologia, atuando como camada comercial para diversos produtos e serviços da Rica Soluções. Ele integra-se nativamente com:

Pedreiro - Fundação e estruturas base
Muleta - Helpers e utilitários
Crypto - Criptografia e segurança
MediaManager - Gestão de arquivos e imagens
Porteiro - Autenticação e autorização
Facilitador - Automações e integrações

Benefícios no Gerenciamento Comercial

✅ Modularidade: Arquitetura desacoplada e extensível
✅ Integração Nativa: Funciona perfeitamente com Laravel e o ecossistema SierraTecnologia
✅ Escalabilidade: Preparado para alta demanda e múltiplos canais de venda
✅ Flexibilidade: Suporte a produtos físicos, digitais e assinaturas
✅ Analytics: Dashboards e relatórios prontos para uso
✅ Multi-tenant: Suporte opcional para múltiplas lojas

📦 Instalação

Requisitos Mínimos

PHP: ^8.0 (recomendado 8.2+)
Laravel: ^9.0 | ^10.0 | ^11.0
Extensões PHP: mbstring, xml, bcmath, pdo, gd, fileinfo
Dependências:
- sierratecnologia/pedreiro
- sierratecnologia/muleta
- sierratecnologia/crypto

Instalação via Composer

composer require sierratecnologia/escriba

Publicação de Arquivos de Configuração

Após a instalação, publique os arquivos de configuração, migrations e assets:

# Publicar configurações
php artisan vendor:publish --provider="Escritor\EscritorProvider" --tag=config

# Publicar views (opcional)
php artisan vendor:publish --provider="Escritor\EscritorProvider" --tag=views

# Publicar assets (opcional)
php artisan vendor:publish --provider="Escritor\EscritorProvider" --tag=public

# Executar migrations
php artisan migrate

Registro Automático de Service Providers

O Service Provider é registrado automaticamente via Laravel Package Auto-Discovery. Caso necessário registrar manualmente, adicione ao config/app.php:

'providers' => [
    // ...
    Escritor\EscritorProvider::class,
],

'aliases' => [
    // ...
    'Escritor' => Escritor\Facades\Escritor::class,
    'StoreHelper' => Escritor\Facades\StoreHelper::class,
],

Configuração Básica

Edite o arquivo config/sitec/escritor.php:

<?php

return [
    /**
     * Caso venda externamente em vários mercados
     * Ou venda Internamente
     */
    'multi-escritores' => true,

    /**
     * Ativar sistema de planos/assinaturas
     */
    'have-plans' => false,

    /**
     * Ativar sistema de cupons
     */
    'have-coupons' => false,
];

🏗️ Arquitetura e Estrutura Interna

Estrutura de Diretórios

src/
├── Cacheable/           # Camadas de cache
├── Console/             # Comandos Artisan
├── Contracts/           # Interfaces e contratos
├── Exceptions/          # Exceções personalizadas
├── Facades/             # Facades Laravel
│   ├── Escritor.php
│   └── StoreHelper.php
├── Http/
│   ├── Controllers/     # Controllers REST e Admin
│   │   ├── Api/        # API endpoints
│   │   └── Admin/      # Painel administrativo
│   ├── Policies/       # Autorização
│   └── Requests/       # Form Requests
├── Interfaces/         # Interfaces de serviço
├── Models/             # Eloquent Models
│   ├── Product.php
│   ├── Order.php
│   ├── Transaction.php
│   ├── Cart.php
│   ├── Plan.php
│   └── Coupon.php
├── Observers/          # Model Observers
├── Repositories/       # Repository Pattern
├── Resources/          # API Resources
├── Scopes/            # Query Scopes
├── Services/          # Business Logic Layer
│   ├── CartService.php
│   ├── ProductService.php
│   ├── OrderService.php
│   ├── PaymentService.php
│   ├── LogisticService.php
│   └── AnalyticsService.php
├── Escritor.php        # Classe principal
└── EscritorProvider.php # Service Provider

Padrões de Design Adotados

1. Service Layer Pattern

Toda lógica de negócio está encapsulada em Services:

// Exemplo: CartService
namespace Escritor\Services;

class CartService
{
    public function addToCart(Product $product, int $quantity = 1)
    {
        // Lógica de adição ao carrinho
    }

    public function removeFromCart(int $cartId)
    {
        // Lógica de remoção
    }

    public function calculateTotal()
    {
        // Cálculo de totais
    }
}

2. Repository Pattern

Abstração da camada de dados para facilitar testes e manutenção.

3. Observer Pattern

Model Observers para eventos (criação, atualização, deleção):

// Executado automaticamente em eventos de Product
ProductObserver::class
OrderObserver::class
TransactionObserver::class

4. Facade Pattern

Acesso simplificado aos serviços principais:

use Escritor;
use StoreHelper;

Escritor::url('products.index');
StoreHelper::formatPrice($value);

Interação entre Módulos

[Controller] → [Request Validation] → [Service Layer] → [Repository] → [Model] → [Database]
     ↓                                       ↓
[View/JSON Response]                  [Events/Observers]

Boas Práticas de Modularidade

Dependency Injection: Todos os services são injetáveis
Single Responsibility: Cada classe tem uma responsabilidade única
Open/Closed Principle: Extensível via herança e interfaces
Interface Segregation: Contratos específicos para cada funcionalidade

⚡ Principais Funcionalidades

1. Gestão de Produtos

Criação de Produtos

use Escritor\Models\Product;

$product = Product::create([
    'name' => 'MacBook Pro M3',
    'code' => 'MBPM3-2024',
    'price' => 299900, // Valor em centavos
    'weight' => 1400,  // Peso em gramas
    'stock' => 50,
    'details' => 'Notebook profissional com chip M3',
    'is_available' => true,
    'is_published' => true,
    'is_featured' => true,
]);

Produtos Digitais (Downloads)

$ebook = Product::create([
    'name' => 'E-book Laravel Avançado',
    'price' => 4900,
    'is_download' => true,
    'file' => 'products/ebooks/laravel-avancado.pdf',
]);

Variantes de Produtos

use Escritor\Services\ProductService;

$productService = app(ProductService::class);

// Adicionar variantes (tamanho, cor, etc.)
$variants = $productService->variants($product);

2. Carrinho de Compras

use Escritor\Services\CartService;

$cartService = app(CartService::class);

// Adicionar ao carrinho
$cartService->addToCart($product, quantity: 2);

// Renderizar botão "Adicionar ao Carrinho"
{!! $product->addToCartBtn('Comprar Agora', 'btn btn-primary') !!}

// Calcular total
$total = $cartService->calculateTotal();

3. Processamento de Pedidos

use Escritor\Services\OrderService;

$orderService = app(OrderService::class);

$order = $orderService->createFromCart([
    'customer_id' => auth()->id(),
    'shipping_address' => '...',
    'billing_address' => '...',
]);

4. Sistema de Transações

use Escritor\Services\PaymentService;

$paymentService = app(PaymentService::class);

$transaction = $paymentService->processPayment($order, [
    'method' => 'credit_card',
    'token' => $paymentToken,
]);

5. Planos de Assinatura (Subscriptions)

use Escritor\Models\Plan;
use Escritor\Services\PlanService;

// Criar plano
$plan = Plan::create([
    'name' => 'Plano Premium',
    'price' => 9900, // R$ 99,00/mês
    'frequency' => 'monthly',
]);

// Assinar plano
$planService = app(PlanService::class);
$subscription = $planService->subscribe(auth()->user(), $plan);

6. Cupons de Desconto

use Escritor\Models\Coupon;
use Escritor\Services\CouponService;

$coupon = Coupon::create([
    'code' => 'PROMO2024',
    'discount_type' => 'percentage',
    'discount' => 15, // 15% de desconto
    'valid_until' => now()->addDays(30),
]);

// Aplicar cupom
$couponService = app(CouponService::class);
$discount = $couponService->applyCoupon('PROMO2024', $cart);

7. Favoritos e Wishlist

// Adicionar aos favoritos
{!! $product->favoriteToggleBtn('♥', 'Favoritar', 'Remover', 'btn-favorite') !!}

// Verificar se é favorito
if ($product->isFavorite()) {
    // ...
}

8. Analytics e Relatórios

use Escritor\Services\AnalyticsService;

$analytics = app(AnalyticsService::class);

// Relatório de vendas
$salesReport = $analytics->salesByPeriod(
    startDate: now()->subMonth(),
    endDate: now()
);

// Produtos mais vendidos
$topProducts = $analytics->topSellingProducts(limit: 10);

💻 Uso Prático

Como Gerar uma Venda Completa

Exemplo 1: Fluxo Básico de Compra

namespace App\Http\Controllers;

use Escritor\Models\Product;
use Escritor\Services\CartService;
use Escritor\Services\OrderService;
use Escritor\Services\PaymentService;
use Illuminate\Http\Request;

class CheckoutController extends Controller
{
    public function addToCart(Request $request, Product $product)
    {
        $cartService = app(CartService::class);

        $cartService->addToCart(
            product: $product,
            quantity: $request->input('quantity', 1)
        );

        return redirect()->route('cart.index')
            ->with('success', 'Produto adicionado ao carrinho!');
    }

    public function processCheckout(Request $request)
    {
        $validated = $request->validate([
            'shipping_address' => 'required|string',
            'payment_method' => 'required|string',
            'payment_token' => 'required|string',
        ]);

        // 1. Criar pedido a partir do carrinho
        $orderService = app(OrderService::class);
        $order = $orderService->createFromCart([
            'customer_id' => auth()->id(),
            'shipping_address' => $validated['shipping_address'],
        ]);

        // 2. Processar pagamento
        $paymentService = app(PaymentService::class);
        $transaction = $paymentService->processPayment($order, [
            'method' => $validated['payment_method'],
            'token' => $validated['payment_token'],
        ]);

        // 3. Limpar carrinho
        $cartService = app(CartService::class);
        $cartService->clear();

        return redirect()->route('orders.show', $order)
            ->with('success', 'Pedido realizado com sucesso!');
    }
}

Exemplo 2: Blade View com Produtos

{{-- resources/views/products/index.blade.php --}}

@extends('layouts.app')

@section('content')
<div class="container">
    <h1>Nossos Produtos</h1>

    <div class="row">
        @foreach($products as $product)
        <div class="col-md-4">
            <div class="product-card">
                <img src="{{ $product->hero_image_url }}" alt="{{ $product->name }}">

                <h3>{{ $product->name }}</h3>
                <p>{{ $product->details }}</p>

                <div class="price">
                    R$ {{ number_format($product->price, 2, ',', '.') }}
                </div>

                {{-- Botão de adicionar ao carrinho --}}
                {!! $product->addToCartBtn('Comprar', 'btn btn-primary') !!}

                {{-- Botão de favoritos --}}
                {!! $product->favoriteToggleBtn('♥', 'Favoritar', 'Remover dos Favoritos', 'btn btn-outline-danger') !!}

                {{-- Botão de detalhes --}}
                {!! $product->detailsBtn('btn btn-secondary') !!}
            </div>
        </div>
        @endforeach
    </div>
</div>
@endsection

Integração com Filas e Jobs

namespace App\Jobs;

use Escritor\Models\Order;
use Escritor\Services\LogisticService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;

class ProcessShippingJob implements ShouldQueue
{
    use Dispatchable, Queueable;

    public function __construct(
        public Order $order
    ) {}

    public function handle()
    {
        $logisticService = app(LogisticService::class);

        // Calcular frete
        $shipping = $logisticService->calculateShipping($this->order);

        // Gerar etiqueta
        $label = $logisticService->generateShippingLabel($this->order);

        // Atualizar status
        $this->order->update([
            'shipping_code' => $label->code,
            'status' => 'shipped',
        ]);
    }
}

Notificações Automáticas

namespace App\Notifications;

use Escritor\Models\Order;
use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Messages\MailMessage;

class OrderConfirmationNotification extends Notification
{
    public function __construct(
        public Order $order
    ) {}

    public function via($notifiable)
    {
        return ['mail', 'database'];
    }

    public function toMail($notifiable)
    {
        return (new MailMessage)
            ->subject('Pedido #' . $this->order->id . ' Confirmado')
            ->line('Seu pedido foi confirmado com sucesso!')
            ->action('Ver Pedido', route('orders.show', $this->order))
            ->line('Obrigado por comprar conosco!');
    }
}

Boas Práticas de Performance

// 1. Eager Loading para evitar N+1
$products = Product::with(['images', 'variants'])
    ->where('is_published', true)
    ->get();

// 2. Cache de produtos em destaque
$featuredProducts = Cache::remember('featured_products', 3600, function() {
    return Product::where('is_featured', true)
        ->where('is_available', true)
        ->limit(10)
        ->get();
});

// 3. Paginação para listagens grandes
$products = Product::paginate(20);

🔗 Integração com o Ecossistema SierraTecnologia

Relação com Outros Pacotes

Pedreiro (Fundação)

Fornece estruturas base, migrations e seeders compartilhados.

use Pedreiro\Traits\HasSlug;

class Product extends Model
{
    use HasSlug; // Gera automaticamente URLs amigáveis
}

Muleta (Helpers)

Utilitários e helpers compartilhados.

use Muleta\Helpers\StringHelper;

$slug = StringHelper::slugify($product->name);

MediaManager (Gestão de Arquivos)

Integração para upload e gestão de imagens de produtos.

use MediaManager\Services\FileService;

$fileService = app(FileService::class);

// Upload de imagem do produto
$heroImage = $fileService->uploadProductImage($request->file('image'), $product);

// URL pública da imagem
$url = $product->hero_image_url;

// Download de arquivo digital
$downloadUrl = $product->file_download_href;

Crypto (Segurança)

Criptografia de dados sensíveis e URLs seguras.

use Crypto;

// URL segura para asset
$secureUrl = Crypto::url_encode($assetPath);

Como o Escriba é Utilizado no Ecossistema

O Escriba atua como camada comercial para diversos produtos:

CMS Corporativo: Venda de templates e módulos
Plataformas SaaS: Sistema de billing e assinaturas
Marketplaces: Multi-vendor com gestão centralizada
E-learning: Venda de cursos e certificações
Serviços Profissionais: Agendamento e pagamento de consultorias

Integração com APIs Externas

namespace App\Services;

use Escritor\Services\PaymentService;
use Escritor\Models\Transaction;

class StripePaymentIntegration extends PaymentService
{
    public function processPayment($order, array $data): Transaction
    {
        // Integração com Stripe API
        $charge = \Stripe\Charge::create([
            'amount' => $order->total,
            'currency' => 'brl',
            'source' => $data['token'],
        ]);

        return Transaction::create([
            'order_id' => $order->id,
            'gateway' => 'stripe',
            'gateway_transaction_id' => $charge->id,
            'status' => $charge->status,
        ]);
    }
}

🔧 Extensão e Customização

Como Criar Novos Services

namespace App\Services;

use Escritor\Models\Product;
use Escritor\Services\ProductService as BaseProductService;

class CustomProductService extends BaseProductService
{
    /**
     * Adicionar funcionalidade de recomendação por IA
     */
    public function getAIRecommendations(Product $product, int $limit = 5)
    {
        // Sua lógica de IA/ML
        return Product::where('category', $product->category)
            ->where('id', '!=', $product->id)
            ->inRandomOrder()
            ->limit($limit)
            ->get();
    }
}

Registrar Service Customizado

// app/Providers/AppServiceProvider.php

public function register()
{
    $this->app->bind(
        \Escritor\Services\ProductService::class,
        \App\Services\CustomProductService::class
    );
}

Como Criar Templates Personalizados

# Publicar views
php artisan vendor:publish --provider="Escritor\EscritorProvider" --tag=views

Edite em resources/views/vendor/escritor/:

{{-- resources/views/vendor/escritor/products/card.blade.php --}}

<div class="custom-product-card">
    <div class="product-badge">
        @if($product->is_featured)
            <span class="badge badge-premium">Premium</span>
        @endif
    </div>

    <img src="{{ $product->hero_image_url }}" loading="lazy">

    <h3>{{ $product->name }}</h3>

    <div class="product-meta">
        <span class="price">{{ StoreHelper::formatPrice($product->price) }}</span>
        <span class="stock">{{ $product->stock }} em estoque</span>
    </div>

    {!! $product->addToCartBtn() !!}
</div>

Versões Multilíngue

# Publicar traduções
php artisan vendor:publish --provider="Escritor\EscritorProvider" --tag=lang

Edite em resources/lang/vendor/escritor/:

// resources/lang/vendor/escritor/pt_BR/messages.php

return [
    'add_to_cart' => 'Adicionar ao Carrinho',
    'buy_now' => 'Comprar Agora',
    'out_of_stock' => 'Fora de Estoque',
    'free_shipping' => 'Frete Grátis',
];

Como Adicionar Metadados e SEO

use Escritor\Models\Product;

$product = Product::create([
    'name' => 'iPhone 15 Pro',
    'seo_description' => 'iPhone 15 Pro com chip A17 Pro, câmera de 48MP e design em titânio',
    'seo_keywords' => 'iphone, apple, smartphone, a17 pro',
]);

Integração com QR Codes

use SimpleSoftwareIO\QrCode\Facades\QrCode;

// Gerar QR Code para produto
$qrCode = QrCode::size(300)->generate($product->href);

// Na view
{!! $qrCode !!}

📊 Exemplos Reais

Caso de Uso 1: Marketplace Multi-Vendor

namespace App\Models;

use Escritor\Models\Product as BaseProduct;

class VendorProduct extends BaseProduct
{
    protected $fillable = [
        'vendor_id',
        'commission_rate',
        // ... outros campos
    ];

    public function vendor()
    {
        return $this->belongsTo(Vendor::class);
    }

    public function calculateCommission()
    {
        return $this->price * ($this->commission_rate / 100);
    }
}

Caso de Uso 2: Sistema de Assinaturas (SaaS)

use Escritor\Models\Plan;
use Escritor\Services\PlanService;

// Criar planos SaaS
$plans = [
    [
        'name' => 'Starter',
        'price' => 2900, // R$ 29/mês
        'frequency' => 'monthly',
        'features' => ['5 usuários', '10GB storage'],
    ],
    [
        'name' => 'Professional',
        'price' => 9900, // R$ 99/mês
        'frequency' => 'monthly',
        'features' => ['Usuários ilimitados', '100GB storage', 'API Access'],
    ],
    [
        'name' => 'Enterprise',
        'price' => 29900, // R$ 299/mês
        'frequency' => 'monthly',
        'features' => ['Tudo incluso', 'Suporte prioritário', 'SLA 99.9%'],
    ],
];

foreach ($plans as $planData) {
    Plan::create($planData);
}

Caso de Uso 3: E-commerce com Certificados Digitais

use Escritor\Models\Product;
use Escritor\Models\Order;
use App\Services\CertificateGenerator;

// Após aprovação do pagamento
$order->items->each(function ($item) use ($order) {
    if ($item->product->is_download) {
        // Gerar certificado digital
        $certificate = app(CertificateGenerator::class)->generate([
            'customer' => $order->customer,
            'product' => $item->product,
            'order' => $order,
        ]);

        // Enviar por email
        $order->customer->notify(
            new CertificateReadyNotification($certificate)
        );
    }
});

Exemplo "Antes e Depois"

❌ Antes (Sem Escriba)

// Código duplicado, sem padrão, difícil de manter
public function checkout(Request $request)
{
    $cart = session()->get('cart', []);
    $total = 0;

    foreach ($cart as $item) {
        $product = Product::find($item['id']);
        $total += $product->price * $item['qty'];
    }

    // Lógica de pagamento espalhada
    // Sem validação adequada
    // Sem tratamento de erros
    // Difícil de testar
}

✅ Depois (Com Escriba)

// Código limpo, testável, modular
public function checkout(Request $request)
{
    $validated = $request->validate([
        'payment_method' => 'required',
        'shipping_address' => 'required',
    ]);

    $orderService = app(OrderService::class);
    $paymentService = app(PaymentService::class);

    try {
        $order = $orderService->createFromCart($validated);
        $transaction = $paymentService->processPayment($order, $validated);

        return redirect()->route('orders.success', $order);
    } catch (\Exception $e) {
        return back()->withErrors(['payment' => $e->getMessage()]);
    }
}

Benefícios Reais Mensurados

⚡ 80% menos código boilerplate
🧪 100% testável com mocks e fakes
📈 3x mais rápido para desenvolver novas features
🔒 Segurança garantida com validações e autorização
📊 Analytics prontos out-of-the-box

🤝 Guia de Contribuição

Como Contribuir

Contribuições são muito bem-vindas! Para contribuir:

Fork o repositório
Crie uma branch para sua feature: git checkout -b feature/minha-feature
Commit suas mudanças: git commit -m 'feat: adiciona nova funcionalidade'
Push para a branch: git push origin feature/minha-feature
Abra um Pull Request

Padrões de Commits

Seguimos o Conventional Commits:

feat: adiciona suporte a variantes de produtos
fix: corrige cálculo de frete
docs: atualiza documentação de instalação
style: aplica PSR-12 em CartService
refactor: simplifica lógica de desconto
test: adiciona testes para OrderService
chore: atualiza dependências

Branch Naming

feature/nome-da-feature - Nova funcionalidade
fix/nome-do-bug - Correção de bug
docs/descricao - Melhorias na documentação
refactor/descricao - Refatoração de código

Execução Local das Ferramentas

PHPUnit (Testes)

# Executar todos os testes
composer test

# Com coverage
composer test-coverage

# Teste específico
vendor/bin/phpunit --filter ProductTest

PHPCS (Code Style - PSR-12)

# Verificar estilo de código
vendor/bin/phpcs --standard=PSR12 src/

# Auto-fix
vendor/bin/phpcbf --standard=PSR12 src/

PHPStan (Análise Estática - Nível 8)

# Análise completa
vendor/bin/phpstan analyse src/ --level=8

# Com configuração customizada
vendor/bin/phpstan analyse -c phpstan.neon

PHPMD (Mess Detector)

# Detectar code smells
vendor/bin/phpmd src/ text phpmd.xml

# Formato HTML
vendor/bin/phpmd src/ html phpmd.xml > report.html

PHP-CS-Fixer (Auto-formatação)

# Aplicar correções
composer format

# Dry-run (apenas visualizar)
vendor/bin/php-cs-fixer fix --config=.php_cs --dry-run --diff

🛠️ Ferramentas de Qualidade (GitHub Tools)

Este projeto mantém altos padrões de qualidade através de ferramentas automatizadas:

CI/CD Pipeline

✅ GitHub Actions Workflows

1. Testes Automatizados (.github/workflows/run-tests.yml)

Executa testes em PHP 8.0, 8.1, 8.2, 8.3
Suporte para Laravel 9.x, 10.x, 11.x
Matrix testing com prefer-lowest e prefer-stable

2. Análise Estática (.github/workflows/psalm.yml)

Psalm nível 7 com Laravel Plugin
Análise de tipos e possíveis bugs
Integração com Shepherd

3. Code Style (.github/workflows/php-cs-fixer.yml)

PHP-CS-Fixer com PSR-12
Auto-fix e commit de correções
Validação em PRs

4. CI Completo (.github/workflows/ci.yml)

Consolidação de PHPUnit, PHPCS, PHPStan, PHPMD
Code coverage report (Codecov)
Security check automático

Configurações de Ferramentas

PHPUnit (`phpunit.xml`)

✅ Configurado para Laravel testing
✅ Code coverage habilitado
✅ Database SQLite in-memory

PHPCS (`phpcs.xml`)

✅ Padrão PSR-12
✅ Exclusões configuradas (vendor, publishes, resources)
✅ Execução paralela

PHPStan (`phpstan.neon`)

✅ Nível 8 (máximo rigor)
✅ Larastan integration
✅ Ignora patterns específicos do Laravel

PHPMD (`phpmd.xml`)

✅ Clean Code rules
✅ Code Size analysis
✅ Customizado para Laravel

Status e Badges

Para mais informações sobre qualidade de código, consulte os reports no repositório.

Changelog

Refer to the Changelog for a full history of the project.

Support

The following support channels are available at your fingertips:

Contributing & Protocols

Thank you for considering contributing to this project! The contribution guide can be found in CONTRIBUTING.md.

Bug reports, feature requests, and pull requests are very welcome.

Security Vulnerabilities

If you discover a security vulnerability within this project, please send an e-mail to help@sierratecnologia.com.br. All security vulnerabilities will be promptly addressed.

About SierraTecnologia

SierraTecnologia is a software solutions startup, specialized in integrated enterprise solutions for SMEs established in Rio de Janeiro, Brazil since June 2008. We believe that our drive The Value, The Reach, and The Impact is what differentiates us and unleash the endless possibilities of our philosophy through the power of software. We like to call it Innovation At The Speed Of Life. That's how we do our share of advancing humanity.

License

This software is released under The MIT License (MIT).

sierratecnologia / escritor

Maintainers

Details