feat: Implement required port validation for service applications

- Added `requiredPort` property to `ServiceApplicationView` to track the required port for services.
- Introduced modal confirmation for removing required ports, including methods to confirm or cancel the action.
- Enhanced `Service` model with `getRequiredPort` and `requiresPort` methods to retrieve port information from service templates.
- Implemented `extractPortFromUrl` method in `ServiceApplication` to extract port from FQDN URLs.
- Updated frontend views to display warnings when required ports are missing from domains.
- Created unit tests for service port validation and extraction logic, ensuring correct behavior for various scenarios.
- Added feature tests for Livewire component handling of domain submissions with required ports.

tests/Unit/DockerComposeEmptyStringPreservationTest.php

@@ -19,13 +19,13 @@ it('ensures parsers.php preserves empty strings in application parser', function
     $hasApplicationParser = str_contains($parsersFile, 'function applicationParser(');
     expect($hasApplicationParser)->toBeTrue('applicationParser function should exist');
 
-    // The code should NOT unconditionally set $value = null for empty strings
-    // Instead, it should preserve empty strings when no database override exists
+    // The code should distinguish between null and empty string
+    // Check for the pattern where we explicitly check for null vs empty string
+    $hasNullCheck = str_contains($parsersFile, 'if ($value === null)');
+    $hasEmptyStringCheck = str_contains($parsersFile, "} elseif (\$value === '') {");
 
-    // Check for the pattern where we only override with database values when they're non-empty
-    // We're checking the fix is in place by looking for the logic pattern
-    $pattern1 = str_contains($parsersFile, 'if (str($value)->isEmpty())');
-    expect($pattern1)->toBeTrue('Empty string check should exist');
+    expect($hasNullCheck)->toBeTrue('Should have explicit null check');
+    expect($hasEmptyStringCheck)->toBeTrue('Should have explicit empty string check');
 });
 
 it('ensures parsers.php preserves empty strings in service parser', function () {
@@ -35,10 +35,13 @@ it('ensures parsers.php preserves empty strings in service parser', function ()
     $hasServiceParser = str_contains($parsersFile, 'function serviceParser(');
     expect($hasServiceParser)->toBeTrue('serviceParser function should exist');
 
-    // The code should NOT unconditionally set $value = null for empty strings
-    // Same check as above for service parser
-    $pattern1 = str_contains($parsersFile, 'if (str($value)->isEmpty())');
-    expect($pattern1)->toBeTrue('Empty string check should exist');
+    // The code should distinguish between null and empty string
+    // Same check as application parser
+    $hasNullCheck = str_contains($parsersFile, 'if ($value === null)');
+    $hasEmptyStringCheck = str_contains($parsersFile, "} elseif (\$value === '') {");
+
+    expect($hasNullCheck)->toBeTrue('Should have explicit null check');
+    expect($hasEmptyStringCheck)->toBeTrue('Should have explicit empty string check');
 });
 
 it('verifies YAML parsing preserves empty strings correctly', function () {
@@ -186,3 +189,108 @@ it('verifies the distinction between empty string and null in PHP', function ()
     expect(isset($arrayWithEmpty['key']))->toBeTrue();
     expect(isset($arrayWithNull['key']))->toBeFalse();
 });
+
+it('verifies YAML null syntax options all produce PHP null', function () {
+    // Test all three ways to write null in YAML
+    $yamlWithNullSyntax = <<<'YAML'
+environment:
+  VAR_NO_VALUE:
+  VAR_EXPLICIT_NULL: null
+  VAR_TILDE: ~
+  VAR_EMPTY_STRING: ""
+YAML;
+
+    $parsed = Yaml::parse($yamlWithNullSyntax);
+
+    // All three null syntaxes should produce PHP null
+    expect($parsed['environment']['VAR_NO_VALUE'])->toBeNull();
+    expect($parsed['environment']['VAR_EXPLICIT_NULL'])->toBeNull();
+    expect($parsed['environment']['VAR_TILDE'])->toBeNull();
+
+    // Empty string should remain empty string
+    expect($parsed['environment']['VAR_EMPTY_STRING'])->toBe('');
+});
+
+it('verifies null round-trip through YAML', function () {
+    // Test full round-trip: null -> YAML -> parse -> serialize -> parse
+    $original = [
+        'environment' => [
+            'NULL_VAR' => null,
+            'EMPTY_VAR' => '',
+            'VALUE_VAR' => 'localhost',
+        ],
+    ];
+
+    // Serialize to YAML
+    $yaml1 = Yaml::dump($original, 10, 2);
+
+    // Parse back
+    $parsed1 = Yaml::parse($yaml1);
+
+    // Verify types are preserved
+    expect($parsed1['environment']['NULL_VAR'])->toBeNull();
+    expect($parsed1['environment']['EMPTY_VAR'])->toBe('');
+    expect($parsed1['environment']['VALUE_VAR'])->toBe('localhost');
+
+    // Serialize again
+    $yaml2 = Yaml::dump($parsed1, 10, 2);
+
+    // Parse again
+    $parsed2 = Yaml::parse($yaml2);
+
+    // Should still have correct types
+    expect($parsed2['environment']['NULL_VAR'])->toBeNull();
+    expect($parsed2['environment']['EMPTY_VAR'])->toBe('');
+    expect($parsed2['environment']['VALUE_VAR'])->toBe('localhost');
+
+    // Both YAML representations should be equivalent
+    expect($yaml1)->toBe($yaml2);
+});
+
+it('verifies null vs empty string behavior difference', function () {
+    // Document the critical difference between null and empty string
+
+    // Null in YAML
+    $yamlNull = "VAR: null\n";
+    $parsedNull = Yaml::parse($yamlNull);
+    expect($parsedNull['VAR'])->toBeNull();
+
+    // Empty string in YAML
+    $yamlEmpty = "VAR: \"\"\n";
+    $parsedEmpty = Yaml::parse($yamlEmpty);
+    expect($parsedEmpty['VAR'])->toBe('');
+
+    // They should NOT be equal
+    expect($parsedNull['VAR'] === $parsedEmpty['VAR'])->toBeFalse();
+
+    // Verify type differences
+    expect(is_null($parsedNull['VAR']))->toBeTrue();
+    expect(is_string($parsedEmpty['VAR']))->toBeTrue();
+});
+
+it('verifies parser logic distinguishes null from empty string', function () {
+    // Test the exact === comparison behavior
+    $nullValue = null;
+    $emptyString = '';
+
+    // PHP strict comparison
+    expect($nullValue === null)->toBeTrue();
+    expect($emptyString === '')->toBeTrue();
+    expect($nullValue === $emptyString)->toBeFalse();
+
+    // This is what the parser should use for correct behavior
+    if ($nullValue === null) {
+        $nullHandled = true;
+    } else {
+        $nullHandled = false;
+    }
+
+    if ($emptyString === '') {
+        $emptyHandled = true;
+    } else {
+        $emptyHandled = false;
+    }
+
+    expect($nullHandled)->toBeTrue();
+    expect($emptyHandled)->toBeTrue();
+});