PHP 8 New Features: Nullsafe Operator Causing Payment Bug

<?php

// Simulating an order status coming from the database
$orderStatus = 3;

// OLD WAY: switch — loose comparison, easy to forget break, no return value
// This is the kind of code that causes 2am on-call incidents.
switch ($orderStatus) {
    case 1:
        $label = 'Pending';
        break;
    case 2:
        $label = 'Processing';
        break;
    case 3:
        $label = 'Shipped';
        break;
    default:
        $label = 'Unknown';
}
echo "Switch result: $label" . PHP_EOL;

// NEW WAY: match — strict comparison, returns a value, exhaustive by default
$label = match($orderStatus) {
    1       => 'Pending',
    2       => 'Processing',
    3, 4    => 'Shipped',   // multiple conditions share one arm — switch can't do this cleanly
    5       => 'Delivered',
    default => 'Unknown',
};

echo "Match result: $label" . PHP_EOL;

// Demonstrating strict type safety — this is the killer feature
$statusFromUrl = '3'; // user input is always a string

$labelFromUrl = match($statusFromUrl) {
    1 => 'Pending',
    2 => 'Processing',
    3 => 'Shipped',      // '3' (string) does NOT match 3 (int) — strict comparison
    default => 'Type mismatch caught safely',
};

echo "Strict check result: $labelFromUrl" . PHP_EOL;

// What happens with no match and no default?
try {
    $result = match(99) {
        1 => 'One',
        2 => 'Two',
        // no default — PHP 8 throws UnhandledMatchError instead of silently returning null
    };
} catch (\UnhandledMatchError $e) {
    echo "Caught: " . $e->getMessage() . PHP_EOL;
}

<?php

// Domain model — typical in any Laravel or Symfony application
class Country {
    public function __construct(
        public readonly string $name,
        public readonly string $isoCode
    ) {}

    public function getDiallingCode(): string {
        return match($this->isoCode) {
            'GB' => '+44',
            'US' => '+1',
            'DE' => '+49',
            default => 'unknown',
        };
    }
}

class Address {
    public function __construct(
        public readonly string $street,
        public readonly ?Country $country = null  // country is optional
    ) {}
}

class User {
    public function __construct(
        public readonly string $name,
        public readonly ?Address $shippingAddress = null  // address is optional
    ) {}
}

// --- Scenario 1: A fully populated user ---
$user = new User(
    name: 'Elena Vasquez',
    shippingAddress: new Address(
        street: '12 Baker Street',
        country: new Country('United Kingdom', 'GB')
    )
);

// BEFORE PHP 8 — readable nightmare
if ($user !== null && $user->shippingAddress !== null && $user->shippingAddress->country !== null) {
    $isoCodeOldWay = $user->shippingAddress->country->isoCode;
} else {
    $isoCodeOldWay = null;
}
echo "Old way ISO code: " . ($isoCodeOldWay ?? 'N/A') . PHP_EOL;

// PHP 8 nullsafe — one expression, same result, intent is crystal clear
$isoCode = $user?->shippingAddress?->country?->isoCode;
echo "Nullsafe ISO code: " . ($isoCode ?? 'N/A') . PHP_EOL;

// Chaining method calls also works — not just property access
$diallingCode = $user?->shippingAddress?->country?->getDiallingCode();
echo "Dialling code: " . ($diallingCode ?? 'N/A') . PHP_EOL;

// --- Scenario 2: A guest user with no address ---
$guestUser = new User(name: 'Guest');

// The chain short-circuits at ->shippingAddress (which is null)
// No error thrown — just returns null cleanly
$guestIsoCode = $guestUser?->shippingAddress?->country?->isoCode;
echo "Guest ISO code: " . ($guestIsoCode ?? 'N/A') . PHP_EOL;

<?php

// A function with many optional parameters — typical in formatting utilities
function formatDate(
    DateTimeInterface $date,
    string $format = 'Y-m-d',
    bool $includeTime = false,
    bool $utc = false,
    string $locale = 'en'
): string {
    if ($utc) {
        $date = (clone $date)->setTimezone(new DateTimeZone('UTC'));
    }
    $formatted = $date->format($format);
    if ($includeTime) {
        $formatted .= ' ' . $date->format('H:i:s');
    }
    return $formatted;
}

$now = new DateTimeImmutable();

// Old positional call — what do these booleans mean? You have to count.
echo "Positional: " . formatDate($now, 'c', true, false, 'en') . PHP_EOL;

// Named argument call — reads like plain English, order doesn't matter
echo "Named: " . formatDate(
    date: $now,
    format: 'c',
    includeTime: true
) . PHP_EOL;

// Skip optional params without dummy values
echo "Only date: " . formatDate(date: $now, utc: true) . PHP_EOL;

// Built-in functions also support named arguments
$padded = str_pad(string: '42', length: 8, pad_string: '0', pad_type: STR_PAD_LEFT);
echo "Padded: $padded" . PHP_EOL;

<?php

// Union type on both parameter and return
function findUser(int|string $identifier): array|null {
    // Simulate a database lookup
    $users = [
        ['id' => 1, 'email' => 'alice@example.com', 'name' => 'Alice'],
        ['id' => 2, 'email' => 'bob@example.com', 'name' => 'Bob'],
    ];

    foreach ($users as $user) {
        if (is_int($identifier) && $user['id'] === $identifier) {
            return $user;
        }
        if (is_string($identifier) && $user['email'] === $identifier) {
            return $user;
        }
    }
    return null;
}

// Works with int
$user1 = findUser(1);
echo "By ID: " . ($user1['name'] ?? 'not found') . PHP_EOL;

// Works with string
$user2 = findUser('bob@example.com');
echo "By email: " . ($user2['name'] ?? 'not found') . PHP_EOL;

// TypeError on invalid type — this is the key benefit
try {
    $user3 = findUser(3.14); // float is not int|string
} catch (\TypeError $e) {
    echo "Type caught: " . $e->getMessage() . PHP_EOL;
}

// Return type enforced: function promises array|null
try {
    $result = findUser(99); // null returned, fine
    var_dump($result);
} catch (\TypeError $e) {
    echo "Return type error: " . $e->getMessage() . PHP_EOL;
}

<?php

// ============================================================
// CONSTRUCTOR PROMOTION — before and after
// ============================================================

// BEFORE PHP 8 — the three-step ritual
class MoneyLegacy {
    private int $amountInPence;
    private string $currencyCode;
    private string $formattedSymbol;

    public function __construct(
        int $amountInPence,
        string $currencyCode,
        string $formattedSymbol
    ) {
        $this->amountInPence   = $amountInPence;
        $this->currencyCode    = $currencyCode;
        $this->formattedSymbol = $formattedSymbol;
    }

    public function format(): string {
        return $this->formattedSymbol . number_format($this->amountInPence / 100, 2);
    }
}

// PHP 8 constructor promotion — 60% less code, same behaviour
class Money {
    public function __construct(
        private readonly int    $amountInPence,
        private readonly string $currencyCode,
        private readonly string $formattedSymbol
    ) {}

    public function format(): string {
        return $this->formattedSymbol . number_format($this->amountInPence / 100, 2);
    }

    public function add(Money $other): Money {
        if ($this->currencyCode !== $other->currencyCode) {
            throw new \InvalidArgumentException(
                "Cannot add {$this->currencyCode} to {$other->currencyCode}"
            );
        }
        return new Money(
            amountInPence: $this->amountInPence + $other->amountInPence,
            currencyCode: $this->currencyCode,
            formattedSymbol: $this->formattedSymbol
        );
    }
}

$price    = new Money(amountInPence: 1999, currencyCode: 'GBP', formattedSymbol: '£');
$shipping = new Money(amountInPence: 499,  currencyCode: 'GBP', formattedSymbol: '£');
$total    = $price->add($shipping);
echo "Item: " . $price->format() . PHP_EOL;
echo "Shipping: " . $shipping->format() . PHP_EOL;
echo "Total: " . $total->format() . PHP_EOL;

// Currency guard in action
try {
    $usd = new Money(amountInPence: 2000, currencyCode: 'USD', formattedSymbol: '$');
    $price->add($usd);
} catch (\InvalidArgumentException $e) {
    echo "Caught: " . $e->getMessage() . PHP_EOL;
}

// ============================================================
// JIT configuration (in php.ini, not in code)
// ============================================================
// opcache.enable=1
// opcache.jit_buffer_size=100M
// opcache.jit=tracing

// Verify JIT status at runtime
$jit = opcache_get_status()['jit'] ?? null;
echo "JIT enabled: " . ($jit['enabled'] ? 'Yes' : 'No') . PHP_EOL;
echo "JIT mode: " . ($jit['jit'] ?? 'N/A') . PHP_EOL;

// io.thecodeforge

#[Attribute(Attribute::TARGET_METHOD)]
class Route {
    public function __construct(
        public string $path,
        public string $method = 'GET'
    ) {}
}

class UserController {
    #[Route('/users', 'GET')]
    public function list(): array {
        return ['users' => []];
    }
    
    #[Route('/users/{id}', 'GET')]
    public function show(int $id): array {
        return ['user' => ['id' => $id]];
    }
}

// Runtime reflection
$ref = new ReflectionMethod(UserController::class, 'list');
$route = $ref->getAttributes(Route::class)[0]->newInstance();
echo $route->path; // /users

// io.thecodeforge

class User {
    public function __construct(
        public readonly int $id,
        public readonly string $name
    ) {}
}

class ComputedStats {
    private WeakMap $cache;
    
    public function __construct() {
        $this->cache = new WeakMap();
    }
    
    public function getLastLogin(User $user): ?\DateTimeImmutable {
        if (!isset($this->cache[$user])) {
            // Expensive DB query
            $this->cache[$user] = \DateTimeImmutable::createFromFormat(
                'Y-m-d H:i:s',
                '2024-03-15 14:30:00'
            );
        }
        return $this->cache[$user];
    }
}

$stats = new ComputedStats();
$user = new User(1, 'Alice');
echo $stats->getLastLogin($user)->format('Y-m-d'); // 2024-03-15
unset($user); // Cache entry disappears automatically

// io.thecodeforge

$log = "ERROR: Connection timeout on host 10.0.0.1";

// Old way - bug waiting to happen
if (strpos($log, 'ERROR') !== false) {
    echo "Alert triggered (old)\n";
}

// PHP 8 way - explicit intent
if (str_contains($log, 'ERROR')) {
    echo "Alert triggered (new)\n";
}

// Domain checks
$email = "admin@thecodeforge.io";
if (str_ends_with($email, '@thecodeforge.io')) {
    echo "Internal user\n";
}

// Prefix matching
$path = "/api/v2/users";
if (str_starts_with($path, '/api/')) {
    echo "API request\n";
}