Android архитектура

<?php

declare(strict_types=1);

/**
 * API design considerations for mobile clients.
 * Mobile apps can be killed and restarted at any moment.
 */
final class MobileAwareApiController
{
    public function __construct(
        private readonly SyncService $syncService,
        private readonly IdempotencyService $idempotency,
    ) {}

    /**
     * Idempotent endpoint for mobile clients.
     * Mobile app may retry requests if it was killed mid-request.
     *
     * @param string $idempotencyKey Client-generated unique key
     * @param array<string, mixed> $payload
     * @return array{status: string, data: mixed}
     */
    public function createOrder(
        string $idempotencyKey,
        array $payload,
    ): array {
        // Check if this request was already processed
        $existing = $this->idempotency->find($idempotencyKey);
        if ($existing !== null) {
            // Return same response without re-processing
            return ['status' => 'ok', 'data' => $existing];
        }

        // Process the order
        $order = $this->processOrder($payload);

        // Store result with idempotency key
        $this->idempotency->store($idempotencyKey, $order, ttlSeconds: 86400);

        return ['status' => 'created', 'data' => $order];
    }

    /**
     * Delta sync endpoint for mobile clients.
     * Instead of fetching all data, client sends last sync timestamp.
     * Returns only changes since that timestamp.
     */
    public function syncData(
        string $userId,
        string $lastSyncAt,
    ): array {
        $changes = $this->syncService->getChangesSince(
            userId: $userId,
            since: new \DateTimeImmutable($lastSyncAt),
        );

        return [
            'created' => $changes['created'],
            'updated' => $changes['updated'],
            'deleted' => $changes['deleted_ids'],
            'sync_timestamp' => (new \DateTimeImmutable())->format('c'),
        ];
    }
}

package api

import (
	"context"
	"encoding/json"
	"net/http"
	"time"
)

// MobileAwareHandler provides idempotent endpoints for mobile clients.
type MobileAwareHandler struct {
	syncService      SyncService
	idempotencyStore IdempotencyStore
}

// CreateOrder is an idempotent endpoint for mobile clients.
// Mobile apps may retry requests if killed mid-request.
func (h *MobileAwareHandler) CreateOrder(w http.ResponseWriter, r *http.Request) {
	idempotencyKey := r.Header.Get("Idempotency-Key")
	if idempotencyKey == "" {
		http.Error(w, "Idempotency-Key header required", http.StatusBadRequest)
		return
	}

	ctx := r.Context()

	// Check if this request was already processed
	existing, err := h.idempotencyStore.Find(ctx, idempotencyKey)
	if err == nil && existing != nil {
		writeJSON(w, http.StatusOK, map[string]any{"status": "ok", "data": existing})
		return
	}

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

	order, err := processOrder(ctx, payload)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Store result with idempotency key (TTL 24h)
	_ = h.idempotencyStore.Store(ctx, idempotencyKey, order, 24*time.Hour)

	writeJSON(w, http.StatusCreated, map[string]any{"status": "created", "data": order})
}

// SyncData returns only changes since the client's last sync timestamp.
func (h *MobileAwareHandler) SyncData(w http.ResponseWriter, r *http.Request) {
	userID := r.URL.Query().Get("user_id")
	lastSyncAt, err := time.Parse(time.RFC3339, r.URL.Query().Get("last_sync_at"))
	if err != nil {
		http.Error(w, "invalid last_sync_at", http.StatusBadRequest)
		return
	}

	changes, err := h.syncService.GetChangesSince(r.Context(), userID, lastSyncAt)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	writeJSON(w, http.StatusOK, map[string]any{
		"created":        changes.Created,
		"updated":        changes.Updated,
		"deleted":        changes.DeletedIDs,
		"sync_timestamp": time.Now().Format(time.RFC3339),
	})
}

func writeJSON(w http.ResponseWriter, status int, data any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(data)
}

using Microsoft.AspNetCore.Mvc;

namespace Foundations.Mobile;

public sealed record OrderPayload(string ProductId, int Quantity);

public sealed record SyncResponse(
    IReadOnlyList<object> Created,
    IReadOnlyList<object> Updated,
    IReadOnlyList<string> Deleted,
    DateTimeOffset SyncTimestamp);

/// <summary>
/// API design considerations for mobile clients.
/// Mobile apps can be killed and restarted at any moment.
/// </summary>
[ApiController]
[Route("api/mobile")]
public sealed class MobileAwareController : ControllerBase
{
    private readonly ISyncService _syncService;
    private readonly IIdempotencyService _idempotency;

    public MobileAwareController(ISyncService syncService, IIdempotencyService idempotency)
    {
        _syncService = syncService;
        _idempotency = idempotency;
    }

    /// <summary>
    /// Idempotent endpoint for mobile clients.
    /// The app may retry a request if it was killed mid-flight.
    /// </summary>
    [HttpPost("orders")]
    public async Task<IActionResult> CreateOrderAsync(
        [FromHeader(Name = "Idempotency-Key")] string idempotencyKey,
        [FromBody] OrderPayload payload,
        CancellationToken ct)
    {
        if (string.IsNullOrWhiteSpace(idempotencyKey))
        {
            return BadRequest(new { error = "Idempotency-Key header required" });
        }

        // Check if this request was already processed
        var existing = await _idempotency.FindAsync(idempotencyKey, ct);
        if (existing is not null)
        {
            // Return same response without re-processing
            return Ok(new { status = "ok", data = existing });
        }

        var order = await _syncService.ProcessOrderAsync(payload, ct);

        // Store result with idempotency key
        await _idempotency.StoreAsync(idempotencyKey, order, TimeSpan.FromHours(24), ct);

        return StatusCode(StatusCodes.Status201Created, new { status = "created", data = order });
    }

    /// <summary>
    /// Delta sync endpoint. Instead of fetching all data, the client sends
    /// its last sync timestamp and receives only the changes since then.
    /// </summary>
    [HttpGet("sync")]
    public async Task<ActionResult<SyncResponse>> SyncDataAsync(
        [FromQuery] string userId,
        [FromQuery] DateTimeOffset lastSyncAt,
        CancellationToken ct)
    {
        var changes = await _syncService.GetChangesSinceAsync(userId, lastSyncAt, ct);

        return Ok(new SyncResponse(
            changes.Created,
            changes.Updated,
            changes.DeletedIds,
            DateTimeOffset.UtcNow));
    }
}

from __future__ import annotations

from datetime import UTC, datetime
from typing import Annotated, Any

from fastapi import APIRouter, Header, HTTPException, Query, status
from pydantic import BaseModel

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

class OrderPayload(BaseModel):
    product_id: str
    quantity: int

class SyncResponse(BaseModel):
    created: list[dict[str, Any]]
    updated: list[dict[str, Any]]
    deleted: list[str]
    sync_timestamp: datetime

@router.post("/orders", status_code=status.HTTP_201_CREATED)
async def create_order(
    payload: OrderPayload,
    idempotency_key: Annotated[str, Header(alias="Idempotency-Key")],
) -> dict[str, Any]:
    """Idempotent endpoint for mobile clients.

    The app may retry a request if it was killed mid-flight, so the same
    key must always produce the same response.
    """
    if not idempotency_key:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Idempotency-Key header required",
        )

    # Check if this request was already processed
    existing = await idempotency_service.find(idempotency_key)
    if existing is not None:
        # Return same response without re-processing
        return {"status": "ok", "data": existing}

    order = await sync_service.process_order(payload)

    # Store result with idempotency key
    await idempotency_service.store(idempotency_key, order, ttl_seconds=86_400)

    return {"status": "created", "data": order}

@router.get("/sync")
async def sync_data(
    user_id: Annotated[str, Query()],
    last_sync_at: Annotated[datetime, Query()],
) -> SyncResponse:
    """Delta sync: return only the changes since the client's last sync."""
    changes = await sync_service.get_changes_since(user_id=user_id, since=last_sync_at)

    return SyncResponse(
        created=changes.created,
        updated=changes.updated,
        deleted=changes.deleted_ids,
        sync_timestamp=datetime.now(UTC),
    )

<?php

declare(strict_types=1);

/**
 * Batch API endpoint to reduce number of network requests.
 * Mobile clients benefit from fewer, larger requests.
 */
final class BatchApiController
{
    /**
     * Process multiple API calls in a single HTTP request.
     * Reduces latency overhead from multiple round-trips.
     *
     * @param array<int, array{method: string, path: string, body?: array}> $requests
     * @return array<int, array{status: int, body: mixed}>
     */
    public function batch(array $requests): array
    {
        if (count($requests) > 20) {
            throw new \InvalidArgumentException('Maximum 20 requests per batch');
        }

        $responses = [];

        foreach ($requests as $index => $request) {
            $responses[$index] = $this->processSubRequest(
                method: $request['method'],
                path: $request['path'],
                body: $request['body'] ?? [],
            );
        }

        return $responses;
    }

    /**
     * @return array{status: int, body: mixed}
     */
    private function processSubRequest(
        string $method,
        string $path,
        array $body,
    ): array {
        // Route sub-request to appropriate handler
        // Each sub-request runs independently
        try {
            $result = $this->router->dispatch($method, $path, $body);
            return ['status' => 200, 'body' => $result];
        } catch (\Throwable $e) {
            return ['status' => 500, 'body' => ['error' => $e->getMessage()]];
        }
    }
}

package api

import (
	"encoding/json"
	"fmt"
	"net/http"
	"sync"
)

const maxBatchSize = 20

// BatchRequest represents a single sub-request in a batch.
type BatchRequest struct {
	Method string         `json:"method"`
	Path   string         `json:"path"`
	Body   map[string]any `json:"body,omitempty"`
}

// BatchResponse represents the result of a single sub-request.
type BatchResponse struct {
	Status int `json:"status"`
	Body   any `json:"body"`
}

// BatchHandler processes multiple API calls in a single HTTP request.
// Reduces latency overhead from multiple round-trips for mobile clients.
func (h *MobileAwareHandler) BatchHandler(w http.ResponseWriter, r *http.Request) {
	var requests []BatchRequest
	if err := json.NewDecoder(r.Body).Decode(&requests); err != nil {
		http.Error(w, "invalid batch payload", http.StatusBadRequest)
		return
	}

	if len(requests) > maxBatchSize {
		http.Error(w, fmt.Sprintf("maximum %d requests per batch", maxBatchSize), http.StatusBadRequest)
		return
	}

	// Process sub-requests concurrently for better performance
	responses := make([]BatchResponse, len(requests))
	var wg sync.WaitGroup

	for i, req := range requests {
		wg.Add(1)
		go func() {
			defer wg.Done()
			responses[i] = h.processSubRequest(r.Context(), req)
		}()
	}

	wg.Wait()
	writeJSON(w, http.StatusOK, responses)
}

func (h *MobileAwareHandler) processSubRequest(ctx context.Context, req BatchRequest) BatchResponse {
	defer func() {
		if r := recover(); r != nil {
			// Recover from panics in sub-request handlers
		}
	}()

	result, err := h.router.Dispatch(ctx, req.Method, req.Path, req.Body)
	if err != nil {
		return BatchResponse{Status: 500, Body: map[string]string{"error": err.Error()}}
	}
	return BatchResponse{Status: 200, Body: result}
}

using Microsoft.AspNetCore.Mvc;

namespace Foundations.Mobile;

public sealed record BatchRequest(string Method, string Path, Dictionary<string, object>? Body);

public sealed record BatchResponse(int Status, object Body);

/// <summary>
/// Batch API endpoint to reduce the number of network requests.
/// Mobile clients benefit from fewer, larger requests.
/// </summary>
[ApiController]
[Route("api/batch")]
public sealed class BatchApiController : ControllerBase
{
    private const int MaxBatchSize = 20;

    private readonly ISubRequestRouter _router;

    public BatchApiController(ISubRequestRouter router) => _router = router;

    /// <summary>
    /// Process multiple API calls in a single HTTP request.
    /// Reduces latency overhead from multiple round-trips.
    /// </summary>
    [HttpPost]
    public async Task<ActionResult<IReadOnlyList<BatchResponse>>> BatchAsync(
        [FromBody] IReadOnlyList<BatchRequest> requests,
        CancellationToken ct)
    {
        if (requests.Count > MaxBatchSize)
        {
            return BadRequest(new { error = $"Maximum {MaxBatchSize} requests per batch" });
        }

        // Process sub-requests concurrently for better performance
        var responses = await Task.WhenAll(
            requests.Select(request => ProcessSubRequestAsync(request, ct)));

        return Ok(responses);
    }

    private async Task<BatchResponse> ProcessSubRequestAsync(BatchRequest request, CancellationToken ct)
    {
        // Each sub-request runs independently - one failure must not
        // abort the whole batch
        try
        {
            var result = await _router.DispatchAsync(
                request.Method,
                request.Path,
                request.Body ?? [],
                ct);

            return new BatchResponse(StatusCodes.Status200OK, result);
        }
        catch (Exception exception) when (exception is not OperationCanceledException)
        {
            return new BatchResponse(
                StatusCodes.Status500InternalServerError,
                new { error = exception.Message });
        }
    }
}

from __future__ import annotations

import asyncio
from typing import Any

from fastapi import APIRouter, HTTPException, status
from pydantic import BaseModel

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

MAX_BATCH_SIZE = 20

class BatchRequest(BaseModel):
    method: str
    path: str
    body: dict[str, Any] = {}

class BatchResponse(BaseModel):
    status: int
    body: Any

@router.post("")
async def batch(requests: list[BatchRequest]) -> list[BatchResponse]:
    """Process multiple API calls in a single HTTP request.

    Reduces latency overhead from multiple round-trips for mobile clients.
    """
    if len(requests) > MAX_BATCH_SIZE:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Maximum {MAX_BATCH_SIZE} requests per batch",
        )

    # Sub-requests are I/O-bound, so asyncio runs them concurrently
    # in a single thread - the GIL is never a bottleneck here
    return await asyncio.gather(*(_process_sub_request(request) for request in requests))

async def _process_sub_request(request: BatchRequest) -> BatchResponse:
    """Each sub-request runs independently - one failure must not abort the batch."""
    try:
        result = await sub_request_router.dispatch(request.method, request.path, request.body)
    except Exception as exc:  # noqa: BLE001 - isolate sub-request failures
        return BatchResponse(status=500, body={"error": str(exc)})

    return BatchResponse(status=200, body=result)