Generate PDFs from Laravel

// config/services.php
'pdfglyph' => [
    'url' => env('PDFGLYPH_URL'),
    'key' => env('PDFGLYPH_API_KEY'),
    'template' => env('PDFGLYPH_TEMPLATE_ID'),
],

PDFGLYPH_API_KEY=sb_your_key_here
PDFGLYPH_TEMPLATE_ID=tpl_invoice_8x2k

<?php
// app/Services/PdfGlyph.php

namespace App\Services;

use App\Exceptions\PdfGlyphException;
use Illuminate\Http\Client\ConnectionException;
use Illuminate\Support\Facades\Http;

class PdfGlyph
{
    /** Codes where a retry cannot help: fix the cause instead. */
    private const PERMANENT = [
        'invalid_data', 'invalid_json', 'template_not_found',
        'template_not_published', 'unauthorized', 'payment_required',
        'account_suspended', 'limit_exceeded', 'idempotency_conflict',
        'render_failed',
    ];

    public function __construct(
        private readonly string $baseUrl,
        private readonly string $apiKey,
    ) {}

    /**
     * Render a published template with $data and return the PDF bytes.
     *
     * $idempotencyKey makes the call replayable: a repeat with the same key comes
     * back as the same generation, billed once, instead of billing twice. Derive it
     * from the business event (invoice id + revision), never from a random value.
     */
    public function generate(string $templateId, array $data, ?string $idempotencyKey = null): string
    {
        $attempts = 0;

        while (true) {
            $attempts++;

            try {
                $response = Http::withToken($this->apiKey)
                    ->timeout(60)        // the render itself is bounded server-side
                    ->connectTimeout(10)
                    ->withHeaders($idempotencyKey ? ['Idempotency-Key' => $idempotencyKey] : [])
                    ->post("{$this->baseUrl}/v1/generate", [
                        'templateId' => $templateId,
                        'data' => $data,
                    ]);
            } catch (ConnectionException $e) {
                // The response was lost, so the request may have completed and been
                // billed. Only replay it when a key guarantees the API replays too.
                if ($idempotencyKey && $attempts < 3) {
                    sleep($attempts);
                    continue;
                }
                throw new PdfGlyphException('network_error', $e->getMessage(), retryable: (bool) $idempotencyKey);
            }

            if ($response->successful()) {
                return $response->body();   // raw PDF bytes
            }

            $code = $response->json('error.code') ?? 'unknown';
            $message = $response->json('error.message') ?? $response->body();
            $requestId = $response->header('X-Request-Id');

            // 429 rate_limited and 503 are pacing, not rejection: wait as told and retry.
            if (in_array($code, ['rate_limited', 'service_unavailable'], true) && $attempts < 3) {
                sleep(max(1, (int) $response->header('Retry-After')));
                continue;
            }

            throw new PdfGlyphException(
                $code,
                $message,
                retryable: ! in_array($code, self::PERMANENT, true),
                requestId: $requestId,
            );
        }
    }
}

// app/Providers/AppServiceProvider.php  (register method)
$this->app->singleton(PdfGlyph::class, fn () => new PdfGlyph(
    rtrim(config('services.pdfglyph.url'), '/'),
    config('services.pdfglyph.key'),
));

<?php
// app/Exceptions/PdfGlyphException.php

namespace App\Exceptions;

use RuntimeException;

class PdfGlyphException extends RuntimeException
{
    public function __construct(
        // NOT `$code`: PHP's Exception already declares a non-readonly int $code, and
        // redeclaring it readonly is a fatal error — "Cannot redeclare non-readonly
        // property Exception::$code as readonly".
        public readonly string $errorCode,
        string $message,
        public readonly bool $retryable = false,
        public readonly ?string $requestId = null,
    ) {
        parent::__construct($message);
    }
}

<?php
// app/Support/InvoicePdfData.php

namespace App\Support;

use App\Models\Invoice;

class InvoicePdfData
{
    public static function from(Invoice $invoice): array
    {
        return [
            'invoiceNumber' => $invoice->number,
            'issueDate' => $invoice->issued_at->translatedFormat('F j, Y'),
            'dueDate' => $invoice->due_at->translatedFormat('F j, Y'),
            'company' => [
                'name' => config('app.name'),
                'addressLine1' => '128 Maple Avenue, Suite 5',
                'addressLine2' => 'Portland, OR 97204',
                'email' => 'billing@northwind.studio',
            ],
            'billTo' => [
                'name' => $invoice->customer->name,
                'addressLine1' => $invoice->customer->address_line1,
                'addressLine2' => $invoice->customer->address_line2,
            ],
            'items' => $invoice->lines->map(fn ($line) => [
                'description' => $line->description,
                'quantity' => (string) $line->quantity,
                'rate' => self::money($line->unit_price_cents),
                'amount' => self::money($line->quantity * $line->unit_price_cents),
            ])->all(),
            'subtotal' => self::money($invoice->subtotal_cents),
            'taxLabel' => "VAT ({$invoice->tax_rate}%)",
            'taxAmount' => self::money($invoice->tax_cents),
            'total' => self::money($invoice->total_cents),
            'payment' => [
                'bankName' => 'First Cascade Bank',
                'accountNumber' => '0041 2298 7745',
                'swift' => 'FCSBUS6P',
            ],
            'notes' => $invoice->notes,
        ];
    }

    private static function money(int $cents): string
    {
        return '$' . number_format($cents / 100, 2);
    }
}

<?php
// app/Http/Controllers/InvoicePdfController.php

namespace App\Http\Controllers;

use App\Models\Invoice;
use App\Services\PdfGlyph;
use App\Support\InvoicePdfData;
use Illuminate\Support\Facades\Gate;

class InvoicePdfController extends Controller
{
    public function __invoke(Invoice $invoice, PdfGlyph $pdfglyph)
    {
        // It is a customer's financial document. `Gate::authorize` rather than
        // `$this->authorize`, which needs a trait the slim skeleton no longer adds.
        Gate::authorize('view', $invoice);

        $pdf = $pdfglyph->generate(
            config('services.pdfglyph.template'),
            InvoicePdfData::from($invoice),
            "invoice-pdf:{$invoice->id}:{$invoice->updated_at->timestamp}",
        );

        return response($pdf, 200, [
            'Content-Type' => 'application/pdf',
            'Content-Disposition' => "inline; filename=\"invoice-{$invoice->number}.pdf\"",
            'Content-Length' => strlen($pdf),
        ]);
    }
}

->withExceptions(function (Exceptions $exceptions) {
    $exceptions->render(fn (PdfGlyphException $e) => response()->json([
        'message' => $e->retryable ? 'Please try again in a moment.' : 'This document cannot be generated.',
    ], $e->retryable ? 503 : 422));
})

<?php
// app/Jobs/SendInvoiceEmail.php

namespace App\Jobs;

use App\Mail\InvoiceMail;
use App\Models\Invoice;
use App\Services\PdfGlyph;
use App\Support\InvoicePdfData;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;
use Illuminate\Support\Facades\Mail;

class SendInvoiceEmail implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;

    public function __construct(public Invoice $invoice) {}

    public function handle(PdfGlyph $pdfglyph): void
    {
        // A job retry reuses this key, so the retry replays instead of billing twice.
        $pdf = $pdfglyph->generate(
            config('services.pdfglyph.template'),
            InvoicePdfData::from($this->invoice),
            "invoice-email:{$this->invoice->id}:{$this->invoice->updated_at->timestamp}",
        );

        Mail::to($this->invoice->customer->email)->send(new InvoiceMail($this->invoice, $pdf));
    }
}

// app/Mail/InvoiceMail.php  (in the Mailable)
use Illuminate\Mail\Mailables\Attachment;

public function attachments(): array
{
    return [
        Attachment::fromData(fn () => $this->pdf, "invoice-{$this->invoice->number}.pdf")
            ->withMime('application/pdf'),
    ];
}

// tests/Feature/InvoicePdfTest.php (Pest)
use App\Models\Invoice;
use App\Models\InvoiceLine;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Http;

uses(RefreshDatabase::class);

it('streams a PDF for an invoice', function () {
    Http::fake([
        '*/v1/generate' => Http::response('%PDF-1.4 fake bytes', 201, [
            'Content-Type' => 'application/pdf',
        ]),
    ]);

    $invoice = Invoice::factory()->has(InvoiceLine::factory()->count(3), 'lines')->create();

    $this->actingAs($invoice->user)
        ->get(route('invoices.pdf', $invoice))
        ->assertOk()
        ->assertHeader('Content-Type', 'application/pdf');

    // The assertion that actually protects you: what you SENT satisfies the template.
    Http::assertSent(function ($request) use ($invoice) {
        expect($request['data']['invoiceNumber'])->toBe($invoice->number)
            ->and($request['data']['items'])->toHaveCount(3)
            ->and($request['data']['total'])->toMatch('/^\$[\d,]+\.\d{2}$/');

        return $request->hasHeader('Idempotency-Key');
    });
});

php artisan tinker
>>> $pdf = app(App\Services\PdfGlyph::class)->generate(config('services.pdfglyph.template'), App\Support\InvoicePdfData::from(App\Models\Invoice::first()));
>>> file_put_contents('invoice.pdf', $pdf);
>>> strlen($pdf);
>>> substr($pdf, 0, 8);