PHP + Tools

{
  "name": "acme/shop",
  "type": "project",
  "require": {
    "php": "^8.3",
    "ext-pdo": "*",
    "monolog/monolog": "^3.0"
  },
  "require-dev": {
    "phpunit/phpunit": "^12.0",
    "phpstan/phpstan": "^2.0"
  },
  "autoload": {
    "psr-4": { "App\\": "src/" }
  },
  "autoload-dev": {
    "psr-4": { "App\\Tests\\": "tests/" }
  },
  "scripts": {
    "test": "phpunit",
    "analyse": "phpstan analyse src tests --level 6"
  },
  "config": { "sort-packages": true }
}

// routes/api.php
use App\Http\Controllers\ProductController;
use Illuminate\Support\Facades\Route;

Route::get('/products', [ProductController::class, 'index']);
Route::get('/products/{product}', [ProductController::class, 'show']);
Route::post('/products', [ProductController::class, 'store']);

// app/Models/Product.php
namespace App\Models;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = ['name', 'price_cents', 'active'];

    protected function casts(): array
    {
        return ['price_cents' => 'integer', 'active' => 'boolean'];
    }

    public function scopeActive(Builder $query): void   // Product::query()->active()
    {
        $query->where('active', true);
    }
}

// app/Http/Controllers/ProductController.php
namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function index()
    {
        return Product::query()->active()->orderBy('name')->paginate(20);
    }

    public function show(Product $product): Product      // 404 if the id does not exist
    {
        return $product;
    }

    public function store(Request $request): JsonResponse
    {
        $data = $request->validate([
            'name'        => ['required', 'string', 'max:120'],
            'price_cents' => ['required', 'integer', 'min:0'],
        ]);
        return response()->json(Product::create($data), 201);
    }
}

// curl -X POST localhost:8000/api/products -H 'Accept: application/json' \
//      -d name=Pen -d price_cents=150
// curl localhost:8000/api/products/1

// app/Providers/AppServiceProvider.php
namespace App\Providers;

use App\Billing\HttpPaymentGateway;
use App\Billing\PaymentGateway;
use App\Support\ExchangeRates;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // interface -> implementation (new object each time)
        $this->app->bind(PaymentGateway::class, HttpPaymentGateway::class);

        // built once per request / worker, with config the container cannot guess
        $this->app->singleton(ExchangeRates::class, fn ($app) => new ExchangeRates(
            apiKey: config('services.rates.key'),
            ttlSeconds: 600,
        ));
    }
}

// app/Http/Controllers/CheckoutController.php — constructor injection
class CheckoutController extends Controller
{
    public function __construct(private PaymentGateway $gateway) {}

    public function __invoke(Order $order): JsonResponse
    {
        $receipt = $this->gateway->charge($order->total_cents, $order->currency);
        return response()->json(['receipt' => $receipt->id]);
    }
}

// tests/Feature/CheckoutTest.php — swap in a fake
public function test_checkout_charges_the_order(): void
{
    $fake = new FakePaymentGateway();
    $this->app->instance(PaymentGateway::class, $fake);

    $this->postJson('/api/orders/1/checkout')->assertOk();
    $this->assertSame(4999, $fake->lastChargeCents);
}

// src/Controller/ProductController.php
namespace App\Controller;

use App\Repository\ProductRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

final class ProductController extends AbstractController
{
    public function __construct(private ProductRepository $products) {}

    #[Route('/api/products/{id}', name: 'product_show', methods: ['GET'], requirements: ['id' => '\d+'])]
    public function show(int $id): JsonResponse
    {
        $product = $this->products->find($id) ?? throw $this->createNotFoundException();

        return $this->json([
            'id'    => $product->getId(),
            'name'  => $product->getName(),
            'price' => $product->getPriceCents() / 100,
        ]);
    }
}

// php bin/console debug:router        list every route
// php bin/console debug:autowiring    list the services you can type-hint

<?php
declare(strict_types=1);

function connect(): PDO
{
    $dsn = getenv('DB_DSN') ?: 'mysql:host=127.0.0.1;port=3306;dbname=shop;charset=utf8mb4';
    // PostgreSQL: 'pgsql:host=127.0.0.1;port=5432;dbname=shop'

    return new PDO($dsn, getenv('DB_USER') ?: 'shop', getenv('DB_PASSWORD') ?: '', [
        PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
        PDO::ATTR_EMULATE_PREPARES   => false,
    ]);
}

$pdo = connect();
$stmt = $pdo->prepare('SELECT id, name, price_cents FROM products WHERE price_cents <= :max ORDER BY name LIMIT 20');
$stmt->execute(['max' => 1000]);
foreach ($stmt as $row) {
    printf("%d  %-20s %6.2f\n", $row['id'], $row['name'], $row['price_cents'] / 100);
}

// MySQL upsert:      INSERT ... ON DUPLICATE KEY UPDATE stock = VALUES(stock)
// PostgreSQL upsert: INSERT ... ON CONFLICT (sku) DO UPDATE SET stock = EXCLUDED.stock
// PostgreSQL returns ids with: INSERT ... RETURNING id   (MySQL: $pdo->lastInsertId())

<?php
$redis = new Redis();
$redis->connect(getenv('REDIS_HOST') ?: '127.0.0.1', 6379);

function product(Redis $redis, PDO $pdo, int $id): array
{
    $key = "product:$id";
    $cached = $redis->get($key);                 // false on a miss
    if ($cached !== false) {
        return json_decode($cached, true, flags: JSON_THROW_ON_ERROR);
    }
    $stmt = $pdo->prepare('SELECT id, name, price_cents FROM products WHERE id = ?');
    $stmt->execute([$id]);
    $row = $stmt->fetch() ?: throw new RuntimeException("No product $id");
    $redis->setex($key, 600, json_encode($row, JSON_THROW_ON_ERROR));   // 10 minutes
    return $row;
}

// after an update, invalidate:  $redis->del("product:$id");
// a simple rate limit:          $n = $redis->incr("login:$ip"); if ($n === 1) $redis->expire("login:$ip", 60);

// Laravel (CACHE_STORE=redis in .env):
// $product = Cache::remember("product:$id", 600, fn () => Product::findOrFail($id));
// Cache::forget("product:$id");

// src/Shipping.php
namespace App;

final class Shipping
{
    /** Free over 50.00, otherwise 4.99 plus 1.00 per started kilo over 2 kg. */
    public static function feeCents(int $orderCents, int $grams): int
    {
        if ($grams <= 0) {
            throw new \InvalidArgumentException("weight must be positive, got $grams");
        }
        if ($orderCents >= 5000) {
            return 0;
        }
        $extraKilos = max(0, (int) ceil(($grams - 2000) / 1000));
        return 499 + 100 * $extraKilos;
    }
}

// tests/ShippingTest.php
namespace App\Tests;

use App\Shipping;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

final class ShippingTest extends TestCase
{
    public static function cases(): array
    {
        return [
            'light, small order' => [1000, 500, 499],
            'exactly 2 kg'       => [1000, 2000, 499],
            'just over 2 kg'     => [1000, 2001, 599],
            'just below free'    => [4999, 500, 499],
            'free at 50.00'      => [5000, 9000, 0],
        ];
    }

    #[DataProvider('cases')]
    public function testFee(int $orderCents, int $grams, int $expected): void
    {
        $this->assertSame($expected, Shipping::feeCents($orderCents, $grams));
    }

    public function testZeroWeightIsRejected(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('got 0');
        Shipping::feeCents(1000, 0);
    }
}

// vendor/bin/phpunit                      run everything
// vendor/bin/phpunit --filter testFee     run one test
// XDEBUG_MODE=coverage vendor/bin/phpunit --coverage-text

# Dockerfile
FROM php:8.5-fpm-alpine

# PHP extensions (the installer handles build dependencies for you)
COPY --from=mlocati/php-extension-installer /usr/bin/install-php-extensions /usr/local/bin/
RUN install-php-extensions pdo_mysql redis opcache

COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
WORKDIR /var/www/html

# dependencies first: this layer is cached until composer.lock changes
COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts --no-autoloader --prefer-dist --no-interaction

COPY . .
RUN composer dump-autoload --no-dev --classmap-authoritative

USER www-data
# php-fpm listens on 9000 (inherited CMD)

# ---------------------------------------------------------------
# compose.yaml
# services:
#   app:
#     build: .
#     environment:
#       DB_DSN: "mysql:host=db;dbname=shop;charset=utf8mb4"
#       DB_USER: shop
#       DB_PASSWORD: secret
#       REDIS_HOST: redis
#     depends_on:
#       db: { condition: service_healthy }
#       redis: { condition: service_started }
#   web:
#     image: nginx:1.27-alpine
#     ports: ["8080:80"]
#     volumes:
#       - ./public:/var/www/html/public:ro
#       - ./docker/nginx.conf:/etc/nginx/conf.d/default.conf:ro
#     depends_on: [app]
#   db:
#     image: mysql:8.4
#     environment:
#       MYSQL_DATABASE: shop
#       MYSQL_USER: shop
#       MYSQL_PASSWORD: secret
#       MYSQL_ROOT_PASSWORD: rootsecret
#     volumes: [dbdata:/var/lib/mysql]
#     healthcheck:
#       test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
#       interval: 5s
#       retries: 10
#   redis:
#     image: redis:7-alpine
# volumes:
#   dbdata:
#
# docker compose up -d --build      then open http://localhost:8080
# docker compose exec app php -v    run commands inside the PHP container

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: shivammathur/setup-php@v2
        with:
          php-version: '8.5'
          extensions: pdo_sqlite, mbstring
          coverage: none

      - name: Validate composer.json and composer.lock
        run: composer validate --strict

      - name: Install dependencies
        run: composer install --no-interaction --prefer-dist --no-progress

      - name: Static analysis
        run: vendor/bin/phpstan analyse --no-progress

      - name: Tests
        run: vendor/bin/phpunit