Release Engineering

<?php
// .github/workflows/ci.yml structure (shown as PHP config concept)
// Actual YAML workflow is in the repository root

/**
 * CI Pipeline stages for a Symfony application.
 * This class represents the pipeline logic, not the YAML config.
 */

declare(strict_types=1);

namespace App\Deploy;

final readonly class CiPipeline
{
    /**
     * Define pipeline stages and their checks.
     *
     * @return array<string, array{command: string, failFast: bool}>
     */
    public function getStages(): array
    {
        return [
            'install' => [
                'command' => 'composer install --no-interaction --prefer-dist',
                'failFast' => true,
            ],
            'lint' => [
                'command' => 'vendor/bin/php-cs-fixer fix --dry-run --diff',
                'failFast' => true,
            ],
            'static-analysis' => [
                'command' => 'vendor/bin/phpstan analyse -l 9',
                'failFast' => true,
            ],
            'unit-tests' => [
                'command' => 'vendor/bin/phpunit --testsuite=unit',
                'failFast' => true,
            ],
            'integration-tests' => [
                'command' => 'vendor/bin/phpunit --testsuite=integration',
                'failFast' => true,
            ],
            'security-check' => [
                'command' => 'composer audit',
                'failFast' => false,
            ],
        ];
    }
}

package deploy

// CIPipeline defines CI pipeline stages and their checks.
type CIPipeline struct{}

// Stage describes a CI pipeline stage.
type Stage struct {
	Command  string `json:"command"`
	FailFast bool   `json:"fail_fast"`
}

// GetStages returns the ordered CI pipeline stages.
func (p *CIPipeline) GetStages() map[string]Stage {
	return map[string]Stage{
		"install":          {Command: "go mod download", FailFast: true},
		"lint":             {Command: "golangci-lint run ./...", FailFast: true},
		"static-analysis":  {Command: "go vet ./...", FailFast: true},
		"unit-tests":       {Command: "go test -short ./...", FailFast: true},
		"integration-tests": {Command: "go test -run Integration ./...", FailFast: true},
		"security-check":   {Command: "govulncheck ./...", FailFast: false},
	}
}

namespace App.Deploy;

// .github/workflows/ci.yml structure, expressed as pipeline logic.
// The actual YAML workflow lives in the repository root.

// A single CI pipeline stage.
public readonly record struct Stage(string Command, bool FailFast);

// CI pipeline stages for an ASP.NET Core application.
public sealed class CiPipeline
{
    // Ordered pipeline stages and their checks.
    public IReadOnlyDictionary<string, Stage> GetStages() => new Dictionary<string, Stage>
    {
        ["restore"] = new("dotnet restore --locked-mode", FailFast: true),
        ["lint"] = new("dotnet format --verify-no-changes", FailFast: true),
        ["static-analysis"] = new("dotnet build -warnaserror -p:AnalysisMode=All", FailFast: true),
        ["unit-tests"] = new("dotnet test --filter Category=Unit", FailFast: true),
        ["integration-tests"] = new("dotnet test --filter Category=Integration", FailFast: true),
        ["security-check"] = new("dotnet list package --vulnerable --include-transitive", FailFast: false),
    };
}

from dataclasses import dataclass

# .github/workflows/ci.yml structure, expressed as pipeline logic.
# The actual YAML workflow lives in the repository root.

@dataclass(frozen=True, slots=True)
class Stage:
    """A single CI pipeline stage."""

    command: str
    fail_fast: bool

class CiPipeline:
    """CI pipeline stages for a Python web application."""

    def get_stages(self) -> dict[str, Stage]:
        """Ordered pipeline stages and their checks."""
        return {
            "install": Stage("uv sync --frozen", fail_fast=True),
            "lint": Stage("ruff check . && ruff format --check .", fail_fast=True),
            "static-analysis": Stage("mypy --strict src", fail_fast=True),
            "unit-tests": Stage("pytest -m 'not integration'", fail_fast=True),
            "integration-tests": Stage("pytest -m integration", fail_fast=True),
            "security-check": Stage("pip-audit", fail_fast=False),
        }

<?php

declare(strict_types=1);

namespace App\Deploy;

final readonly class CanaryRouter
{
    /**
     * @param int $canaryPercentage Percentage of traffic to route to canary (0-100)
     * @param array<string> $allowedUsers Users always routed to canary (beta testers)
     */
    public function __construct(
        private int $canaryPercentage = 0,
        private array $allowedUsers = [],
    ) {}

    /**
     * Determine if a request should be routed to canary version.
     */
    public function shouldRouteToCanary(string $userId, string $requestId): RoutingDecision
    {
        // Always route allowed users to canary
        if (in_array($userId, $this->allowedUsers, true)) {
            return new RoutingDecision(
                target: DeployTarget::Canary,
                reason: 'User in canary allowlist',
            );
        }

        // Use consistent hashing for sticky sessions
        $hash = crc32($userId);
        $bucket = abs($hash) % 100;

        if ($bucket < $this->canaryPercentage) {
            return new RoutingDecision(
                target: DeployTarget::Canary,
                reason: sprintf('Bucket %d < %d%% canary threshold', $bucket, $this->canaryPercentage),
            );
        }

        return new RoutingDecision(
            target: DeployTarget::Stable,
            reason: sprintf('Bucket %d >= %d%% canary threshold', $bucket, $this->canaryPercentage),
        );
    }
}

enum DeployTarget: string
{
    case Stable = 'stable';
    case Canary = 'canary';
}

final readonly class RoutingDecision
{
    public function __construct(
        public DeployTarget $target,
        public string $reason,
    ) {}
}

package deploy

import "hash/crc32"

// DeployTarget identifies the deployment target.
type DeployTarget string

const (
	TargetStable DeployTarget = "stable"
	TargetCanary DeployTarget = "canary"
)

// RoutingDecision records a canary routing decision.
type RoutingDecision struct {
	Target DeployTarget `json:"target"`
	Reason string       `json:"reason"`
}

// CanaryRouter routes traffic between stable and canary deployments.
type CanaryRouter struct {
	CanaryPercentage int
	AllowedUsers     map[string]bool
}

// ShouldRouteToCanary determines if a request should go to the canary.
func (r *CanaryRouter) ShouldRouteToCanary(userID, requestID string) RoutingDecision {
	if r.AllowedUsers[userID] {
		return RoutingDecision{
			Target: TargetCanary,
			Reason: "User in canary allowlist",
		}
	}

	hash := crc32.ChecksumIEEE([]byte(userID))
	bucket := int(hash) % 100
	if bucket < 0 {
		bucket = -bucket
	}

	if bucket < r.CanaryPercentage {
		return RoutingDecision{
			Target: TargetCanary,
			Reason: fmt.Sprintf("Bucket %d < %d%% canary threshold", bucket, r.CanaryPercentage),
		}
	}

	return RoutingDecision{
		Target: TargetStable,
		Reason: fmt.Sprintf("Bucket %d >= %d%% canary threshold", bucket, r.CanaryPercentage),
	}
}

namespace App.Deploy;

using System.IO.Hashing;
using System.Text;

// DeployTarget identifies the deployment target.
public enum DeployTarget
{
    Stable,
    Canary,
}

// RoutingDecision records a canary routing decision and its rationale.
public readonly record struct RoutingDecision(DeployTarget Target, string Reason);

// CanaryRouter routes traffic between the stable and canary deployments.
public sealed class CanaryRouter(int canaryPercentage = 0, IReadOnlySet<string>? allowedUsers = null)
{
    private readonly IReadOnlySet<string> _allowedUsers = allowedUsers ?? new HashSet<string>();

    // Determine if a request should be routed to the canary version.
    public RoutingDecision ShouldRouteToCanary(string userId, string requestId)
    {
        // Always route allowlisted beta testers to the canary
        if (_allowedUsers.Contains(userId))
        {
            return new RoutingDecision(DeployTarget.Canary, "User in canary allowlist");
        }

        // Consistent hashing keeps a user pinned to the same version
        var hash = Crc32.HashToUInt32(Encoding.UTF8.GetBytes(userId));
        var bucket = (int)(hash % 100);

        return bucket < canaryPercentage
            ? new RoutingDecision(DeployTarget.Canary, $"Bucket {bucket} < {canaryPercentage}% canary threshold")
            : new RoutingDecision(DeployTarget.Stable, $"Bucket {bucket} >= {canaryPercentage}% canary threshold");
    }
}

import zlib
from dataclasses import dataclass
from enum import StrEnum

class DeployTarget(StrEnum):
    """Identifies the deployment target."""

    STABLE = "stable"
    CANARY = "canary"

@dataclass(frozen=True, slots=True)
class RoutingDecision:
    """Records a canary routing decision and its rationale."""

    target: DeployTarget
    reason: str

class CanaryRouter:
    """Routes traffic between the stable and canary deployments."""

    def __init__(
        self,
        canary_percentage: int = 0,
        allowed_users: frozenset[str] = frozenset(),
    ) -> None:
        self._canary_percentage = canary_percentage
        self._allowed_users = allowed_users

    def should_route_to_canary(self, user_id: str, request_id: str) -> RoutingDecision:
        """Determine if a request should be routed to the canary version."""
        # Always route allowlisted beta testers to the canary
        if user_id in self._allowed_users:
            return RoutingDecision(DeployTarget.CANARY, "User in canary allowlist")

        # Consistent hashing keeps a user pinned to the same version
        bucket = zlib.crc32(user_id.encode()) % 100

        if bucket < self._canary_percentage:
            return RoutingDecision(
                DeployTarget.CANARY,
                f"Bucket {bucket} < {self._canary_percentage}% canary threshold",
            )

        return RoutingDecision(
            DeployTarget.STABLE,
            f"Bucket {bucket} >= {self._canary_percentage}% canary threshold",
        )

<?php

declare(strict_types=1);

namespace App\Feature;

enum FlagStatus: string
{
    case Enabled = 'enabled';
    case Disabled = 'disabled';
    case Percentage = 'percentage';
    case UserList = 'user_list';
}

final readonly class FeatureFlag
{
    public function __construct(
        public string $name,
        public FlagStatus $status,
        public int $percentage = 0,
        public array $allowedUsers = [],
        public ?\DateTimeImmutable $expiresAt = null,
    ) {}
}

final class FeatureFlagManager
{
    /** @var array<string, FeatureFlag> */
    private array $flags = [];

    public function __construct(
        private readonly \Redis $redis,
        private readonly string $prefix = 'feature_flag:',
    ) {
        $this->loadFlags();
    }

    /**
     * Check if a feature is enabled for a given context.
     */
    public function isEnabled(string $flagName, ?string $userId = null): bool
    {
        $flag = $this->flags[$flagName] ?? null;

        if ($flag === null) {
            return false;
        }

        // Check expiration
        if ($flag->expiresAt !== null && $flag->expiresAt < new \DateTimeImmutable()) {
            return false;
        }

        return match ($flag->status) {
            FlagStatus::Enabled => true,
            FlagStatus::Disabled => false,
            FlagStatus::Percentage => $this->checkPercentage($flagName, $userId, $flag->percentage),
            FlagStatus::UserList => $userId !== null && in_array($userId, $flag->allowedUsers, true),
        };
    }

    /**
     * Toggle a flag on/off.
     */
    public function toggle(string $flagName, FlagStatus $status): void
    {
        $flag = $this->flags[$flagName] ?? null;

        if ($flag === null) {
            return;
        }

        $updated = new FeatureFlag(
            name: $flag->name,
            status: $status,
            percentage: $flag->percentage,
            allowedUsers: $flag->allowedUsers,
            expiresAt: $flag->expiresAt,
        );

        $this->flags[$flagName] = $updated;
        $this->redis->hSet($this->prefix . 'flags', $flagName, serialize($updated));
    }

    /**
     * Get all flags for debugging.
     *
     * @return array<string, array{status: string, percentage: int}>
     */
    public function getAllFlags(): array
    {
        $result = [];

        foreach ($this->flags as $name => $flag) {
            $result[$name] = [
                'status' => $flag->status->value,
                'percentage' => $flag->percentage,
            ];
        }

        return $result;
    }

    private function checkPercentage(string $flagName, ?string $userId, int $percentage): bool
    {
        // Consistent: same user always gets the same result
        $seed = $userId ?? uniqid('anon_', true);
        $hash = crc32($flagName . ':' . $seed);
        $bucket = abs($hash) % 100;

        return $bucket < $percentage;
    }

    private function loadFlags(): void
    {
        $data = $this->redis->hGetAll($this->prefix . 'flags');

        foreach ($data as $name => $serialized) {
            $this->flags[$name] = unserialize($serialized);
        }
    }
}

package feature

import (
	"context"
	"hash/crc32"
	"sync"
	"time"

	"github.com/redis/go-redis/v9"
)

// FlagStatus represents the state of a feature flag.
type FlagStatus string

const (
	FlagEnabled    FlagStatus = "enabled"
	FlagDisabled   FlagStatus = "disabled"
	FlagPercentage FlagStatus = "percentage"
	FlagUserList   FlagStatus = "user_list"
)

// Flag defines a feature flag configuration.
type Flag struct {
	Name         string     `json:"name"`
	Status       FlagStatus `json:"status"`
	Percentage   int        `json:"percentage"`
	AllowedUsers []string   `json:"allowed_users"`
	ExpiresAt    *time.Time `json:"expires_at,omitempty"`
}

// Manager manages feature flags with Redis persistence.
type Manager struct {
	mu    sync.RWMutex
	flags map[string]Flag
	rdb   *redis.Client
}

// NewManager creates a feature flag manager.
func NewManager(rdb *redis.Client) *Manager {
	return &Manager{
		flags: make(map[string]Flag),
		rdb:   rdb,
	}
}

// IsEnabled checks if a feature is enabled for a given user.
func (m *Manager) IsEnabled(flagName string, userID string) bool {
	m.mu.RLock()
	flag, ok := m.flags[flagName]
	m.mu.RUnlock()

	if !ok {
		return false
	}

	if flag.ExpiresAt != nil && flag.ExpiresAt.Before(time.Now()) {
		return false
	}

	switch flag.Status {
	case FlagEnabled:
		return true
	case FlagDisabled:
		return false
	case FlagPercentage:
		return checkPercentage(flagName, userID, flag.Percentage)
	case FlagUserList:
		for _, u := range flag.AllowedUsers {
			if u == userID {
				return true
			}
		}
		return false
	default:
		return false
	}
}

func checkPercentage(flagName, userID string, percentage int) bool {
	hash := crc32.ChecksumIEEE([]byte(flagName + ":" + userID))
	bucket := int(hash) % 100
	if bucket < 0 {
		bucket = -bucket
	}
	return bucket < percentage
}

namespace App.Feature;

using System.IO.Hashing;
using System.Text;
using System.Text.Json;
using StackExchange.Redis;

// FlagStatus represents the state of a feature flag.
public enum FlagStatus
{
    Enabled,
    Disabled,
    Percentage,
    UserList,
}

// FeatureFlag defines a feature flag configuration.
public sealed record FeatureFlag(
    string Name,
    FlagStatus Status,
    int Percentage = 0,
    IReadOnlyList<string>? AllowedUsers = null,
    DateTimeOffset? ExpiresAt = null);

// FeatureFlagManager manages feature flags with Redis persistence.
public sealed class FeatureFlagManager
{
    private const string HashKey = "feature_flag:flags";

    private readonly IDatabase _db;
    private readonly Dictionary<string, FeatureFlag> _flags = [];

    public FeatureFlagManager(IConnectionMultiplexer redis)
    {
        _db = redis.GetDatabase();
        LoadFlags();
    }

    // Check if a feature is enabled for a given context.
    public bool IsEnabled(string flagName, string? userId = null)
    {
        if (!_flags.TryGetValue(flagName, out var flag))
        {
            return false;
        }

        // Check expiration
        if (flag.ExpiresAt is { } expiresAt && expiresAt < DateTimeOffset.UtcNow)
        {
            return false;
        }

        return flag.Status switch
        {
            FlagStatus.Enabled => true,
            FlagStatus.Disabled => false,
            FlagStatus.Percentage => CheckPercentage(flagName, userId, flag.Percentage),
            FlagStatus.UserList => userId is not null && flag.AllowedUsers?.Contains(userId) == true,
            _ => throw new ArgumentOutOfRangeException(nameof(flagName), flag.Status, "Unknown flag status"),
        };
    }

    // Toggle a flag on/off.
    public void Toggle(string flagName, FlagStatus status)
    {
        if (!_flags.TryGetValue(flagName, out var flag))
        {
            return;
        }

        // Records give a non-destructive copy, so no manual field-by-field rebuild
        var updated = flag with { Status = status };

        _flags[flagName] = updated;
        _db.HashSet(HashKey, flagName, JsonSerializer.Serialize(updated));
    }

    // Get all flags for debugging.
    public IReadOnlyDictionary<string, (string Status, int Percentage)> GetAllFlags() =>
        _flags.ToDictionary(
            entry => entry.Key,
            entry => (entry.Value.Status.ToString(), entry.Value.Percentage));

    private static bool CheckPercentage(string flagName, string? userId, int percentage)
    {
        // Consistent: the same user always lands in the same bucket
        var seed = userId ?? Guid.NewGuid().ToString("N");
        var hash = Crc32.HashToUInt32(Encoding.UTF8.GetBytes($"{flagName}:{seed}"));

        return hash % 100 < percentage;
    }

    private void LoadFlags()
    {
        foreach (var entry in _db.HashGetAll(HashKey))
        {
            var flag = JsonSerializer.Deserialize<FeatureFlag>(entry.Value!);

            if (flag is not null)
            {
                _flags[entry.Name!] = flag;
            }
        }
    }
}

import json
import uuid
import zlib
from dataclasses import asdict, dataclass, replace
from datetime import UTC, datetime
from enum import StrEnum

import redis

class FlagStatus(StrEnum):
    """Represents the state of a feature flag."""

    ENABLED = "enabled"
    DISABLED = "disabled"
    PERCENTAGE = "percentage"
    USER_LIST = "user_list"

@dataclass(frozen=True, slots=True)
class FeatureFlag:
    """Defines a feature flag configuration."""

    name: str
    status: FlagStatus
    percentage: int = 0
    allowed_users: tuple[str, ...] = ()
    expires_at: datetime | None = None

class FeatureFlagManager:
    """Manages feature flags with Redis persistence."""

    HASH_KEY = "feature_flag:flags"

    def __init__(self, client: redis.Redis) -> None:
        self._redis = client
        self._flags: dict[str, FeatureFlag] = {}
        self._load_flags()

    def is_enabled(self, flag_name: str, user_id: str | None = None) -> bool:
        """Check if a feature is enabled for a given context."""
        flag = self._flags.get(flag_name)

        if flag is None:
            return False

        # Check expiration
        if flag.expires_at is not None and flag.expires_at < datetime.now(UTC):
            return False

        match flag.status:
            case FlagStatus.ENABLED:
                return True
            case FlagStatus.DISABLED:
                return False
            case FlagStatus.PERCENTAGE:
                return self._check_percentage(flag_name, user_id, flag.percentage)
            case FlagStatus.USER_LIST:
                return user_id is not None and user_id in flag.allowed_users

    def toggle(self, flag_name: str, status: FlagStatus) -> None:
        """Toggle a flag on/off."""
        flag = self._flags.get(flag_name)

        if flag is None:
            return

        # dataclasses.replace copies the frozen flag with one field changed
        updated = replace(flag, status=status)

        self._flags[flag_name] = updated
        self._redis.hset(self.HASH_KEY, flag_name, self._serialize(updated))

    def get_all_flags(self) -> dict[str, dict[str, object]]:
        """Get all flags for debugging."""
        return {
            name: {"status": flag.status.value, "percentage": flag.percentage}
            for name, flag in self._flags.items()
        }

    @staticmethod
    def _check_percentage(flag_name: str, user_id: str | None, percentage: int) -> bool:
        # Consistent: the same user always lands in the same bucket
        seed = user_id or uuid.uuid4().hex
        bucket = zlib.crc32(f"{flag_name}:{seed}".encode()) % 100

        return bucket < percentage

    @staticmethod
    def _serialize(flag: FeatureFlag) -> str:
        payload = asdict(flag)
        payload["status"] = flag.status.value
        payload["expires_at"] = flag.expires_at.isoformat() if flag.expires_at else None

        return json.dumps(payload)

    def _load_flags(self) -> None:
        for raw_name, raw_flag in self._redis.hgetall(self.HASH_KEY).items():
            payload = json.loads(raw_flag)
            expires_at = payload.get("expires_at")
            name = raw_name.decode() if isinstance(raw_name, bytes) else raw_name

            self._flags[name] = FeatureFlag(
                name=payload["name"],
                status=FlagStatus(payload["status"]),
                percentage=payload.get("percentage", 0),
                allowed_users=tuple(payload.get("allowed_users", ())),
                expires_at=datetime.fromisoformat(expires_at) if expires_at else None,
            )

<?php

declare(strict_types=1);

namespace App\Controller;

use App\Feature\FeatureFlagManager;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

final class OrderController
{
    public function __construct(
        private readonly FeatureFlagManager $features,
        private readonly OrderService $orderService,
        private readonly NewOrderService $newOrderService,
    ) {}

    #[Route('/api/orders', methods: ['POST'])]
    public function create(CreateOrderRequest $request): JsonResponse
    {
        $userId = $request->getUserId();

        // Gradual rollout of new order processing
        if ($this->features->isEnabled('new_order_processing', $userId)) {
            $order = $this->newOrderService->create($request->toDto());
        } else {
            $order = $this->orderService->create($request->toDto());
        }

        return new JsonResponse($order, 201);
    }
}

package api

import (
	"encoding/json"
	"net/http"

	"myapp/feature"
)

// OrderHandler handles order API requests with feature flag support.
type OrderHandler struct {
	features  *feature.Manager
	orderSvc  OrderService
	newSvc    NewOrderService
}

// Create handles POST /api/orders with gradual rollout.
func (h *OrderHandler) Create(w http.ResponseWriter, r *http.Request) {
	userID := r.Context().Value("user_id").(string)

	var req CreateOrderRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "invalid request", http.StatusBadRequest)
		return
	}

	var order *Order
	var err error

	// Gradual rollout of new order processing
	if h.features.IsEnabled("new_order_processing", userID) {
		order, err = h.newSvc.Create(req)
	} else {
		order, err = h.orderSvc.Create(req)
	}

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(order)
}

namespace App.Controllers;

using App.Feature;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/orders")]
public sealed class OrderController(
    FeatureFlagManager features,
    IOrderService orderService,
    INewOrderService newOrderService) : ControllerBase
{
    [HttpPost]
    public async Task<ActionResult<Order>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
    {
        // Gradual rollout of new order processing
        var order = features.IsEnabled("new_order_processing", request.UserId)
            ? await newOrderService.CreateAsync(request.ToDto(), ct)
            : await orderService.CreateAsync(request.ToDto(), ct);

        return Created($"/api/orders/{order.Id}", order);
    }
}

from fastapi import APIRouter, Depends, status

router = APIRouter(prefix="/api/orders", tags=["orders"])

@router.post("", status_code=status.HTTP_201_CREATED)
async def create_order(
    request: CreateOrderRequest,
    features: FeatureFlagManager = Depends(get_feature_flags),
    order_service: OrderService = Depends(get_order_service),
    new_order_service: NewOrderService = Depends(get_new_order_service),
) -> Order:
    """Create an order, routing through the new pipeline behind a feature flag."""
    # Gradual rollout of new order processing
    if features.is_enabled("new_order_processing", request.user_id):
        return await new_order_service.create(request.to_dto())

    return await order_service.create(request.to_dto())

<?php

// deploy.php — Deployer configuration concept
// Demonstrates the deployment recipe structure

declare(strict_types=1);

namespace App\Deploy;

/**
 * Deployment configuration for Symfony application.
 * This represents the Deployer recipe logic.
 */
final readonly class DeploymentConfig
{
    /** @return array<string, mixed> */
    public function getConfig(): array
    {
        return [
            'repository' => '[email protected]:company/app.git',
            'branch' => 'main',
            'shared_dirs' => ['var/log', 'var/sessions'],
            'shared_files' => ['.env.local'],
            'writable_dirs' => ['var'],
            'keep_releases' => 5,
        ];
    }

    /** @return array<string, array<string>> */
    public function getTasks(): array
    {
        return [
            'deploy:prepare' => [
                'deploy:info',
                'deploy:setup',
                'deploy:lock',
                'deploy:release',
                'deploy:update_code',
                'deploy:shared',
            ],
            'deploy:build' => [
                'composer install --no-dev --optimize-autoloader',
                'bin/console cache:clear --env=prod',
                'bin/console cache:warmup --env=prod',
                'bin/console assets:install',
            ],
            'deploy:publish' => [
                'deploy:symlink',  // Atomic switch (blue-green via symlink)
                'deploy:unlock',
                'deploy:cleanup',
            ],
            'rollback' => [
                'deploy:rollback', // Revert symlink to previous release
            ],
        ];
    }
}

package deploy

// DeploymentConfig describes Deployer-style deployment configuration.
type DeploymentConfig struct {
	Repository    string   `json:"repository"`
	Branch        string   `json:"branch"`
	SharedDirs    []string `json:"shared_dirs"`
	SharedFiles   []string `json:"shared_files"`
	WritableDirs  []string `json:"writable_dirs"`
	KeepReleases  int      `json:"keep_releases"`
}

// DefaultConfig returns a typical deployment configuration.
func DefaultConfig() DeploymentConfig {
	return DeploymentConfig{
		Repository:   "[email protected]:company/app.git",
		Branch:       "main",
		SharedDirs:   []string{"var/log", "var/sessions"},
		SharedFiles:  []string{".env.local"},
		WritableDirs: []string{"var"},
		KeepReleases: 5,
	}
}

// Tasks returns deployment stages with their commands.
func (c DeploymentConfig) Tasks() map[string][]string {
	return map[string][]string{
		"deploy:prepare": {
			"deploy:info", "deploy:setup", "deploy:lock",
			"deploy:release", "deploy:update_code", "deploy:shared",
		},
		"deploy:build": {
			"go build -o app ./cmd/server",
			"./app migrate",
		},
		"deploy:publish": {
			"deploy:symlink", // Atomic switch
			"deploy:unlock",
			"deploy:cleanup",
		},
		"rollback": {
			"deploy:rollback", // Revert symlink to previous release
		},
	}
}