PHP code example of anyo-lab / api-response

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

anyo-lab / api-response example snippets

  use Illuminate\Support\Facades\Cache;

  $data = Cache::remember('users.list', 3600, fn () => User::all());
  return api_success($data, 'Success');
  

use ApiResponse\ApiResponse;

class UserController extends Controller
{
    public function index(ApiResponse $apiResponse)
    {
        $users = User::paginate(10);
        
        return $apiResponse->paginated($users, 'Users retrieved successfully');
    }

    public function store(Request $request, ApiResponse $apiResponse)
    {
        $user = User::create($request->validated());
        
        return $apiResponse->created($user, 'User created successfully');
    }
}

use ApiResponse\ApiResponse;

class UserController extends Controller
{
    public function index(ApiResponse $apiResponse)
    {
        $users = User::paginate(10);
        
        return $apiResponse->paginated($users, 'Users retrieved successfully');
    }

    public function store(Request $request, ApiResponse $apiResponse)
    {
        $user = User::create($request->validated());
        
        return $apiResponse->created($user, 'User created successfully');
    }
}

use ApiResponse\Traits\ApiResponseTrait;

class UserController extends Controller
{
    use ApiResponseTrait;

    public function index()
    {
        $users = User::paginate(10);
        
        return $this->paginatedResponse($users, 'Users retrieved successfully');
    }

    public function store(Request $request)
    {
        $user = User::create($request->validated());
        
        return $this->createdResponse($user, 'User created successfully');
    }
}

use ApiResponse\Facades\ApiResponse;

class UserController extends Controller
{
    public function index()
    {
        $users = User::paginate(10);
        
        return ApiResponse::paginated($users, 'Users retrieved successfully');
    }

    public function store(Request $request)
    {
        $user = User::create($request->validated());
        
        return ApiResponse::created($user, 'User created successfully');
    }
}

class UserController extends Controller
{
    public function index()
    {
        $users = User::paginate(10);
        
        return response()->apiPaginated($users, 'Users retrieved successfully');
    }

    public function store(Request $request)
    {
        $user = User::create($request->validated());
        
        return response()->apiCreated($user, 'User created successfully');
    }
}

class UserController extends Controller
{
    public function index()
    {
        $users = User::paginate(10);
        
        return api_paginated($users, 'Users retrieved successfully');
    }

    public function store(Request $request)
    {
        $user = User::create($request->validated());
        
        return api_created($user, 'User created successfully');
    }
}

use ApiResponse\Resources\ApiResource;
use Illuminate\Http\Request;

class UserResource extends ApiResource
{
    protected function transformData(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'created_at' => $this->created_at?->toISOString(),
        ];
    }

    protected function getMessage(): string
    {
        return 'User retrieved successfully';
    }
}

class UserController extends Controller
{
    public function show($id)
    {
        $user = User::findOrFail($id);
        
        return new UserResource($user);
    }

    public function index()
    {
        $users = User::paginate(10);
        
        return UserResource::collection($users);
    }
}

// Basic success response
$apiResponse->success($data, 'Success message');

// Created response (201)
$apiResponse->created($data, 'Resource created');

// No content response (204)
$apiResponse->noContent('No content available');

// Paginated response
$apiResponse->paginated($paginator, 'Data retrieved');

// Collection response
$apiResponse->collection($collection, 'Data retrieved');

// Resource response
$apiResponse->resource($resource, 'Resource retrieved');

// Basic error response
$apiResponse->error('Error message', 400);

// Validation error (422)
$apiResponse->validationError($errors, 'Validation failed');

// Not found (404)
$apiResponse->notFound('Resource not found');

// Unauthorized (401)
$apiResponse->unauthorized('Authentication sts (429)
$apiResponse->tooManyRequests('Rate limit exceeded');

'structure' => [
    'success' => 'success',
    'message' => 'message',
    'data' => 'data',
    'errors' => 'errors',
    'meta' => 'meta',
    'timestamp' => 'timestamp',
],

'messages' => [
    'success' => 'Success',
    'created' => 'Resource created successfully',
    'updated' => 'Resource updated successfully',
    'deleted' => 'Resource deleted successfully',
    'not_found' => 'Resource not found',
    'unauthorized' => 'Unauthorized',
    'forbidden' => 'Forbidden',
    'validation_failed' => 'Validation failed',
    'server_error' => 'Internal server error',
    'bad_request' => 'Bad request',
    'conflict' => 'Conflict occurred',
    'too_many_requests' => 'Too many requests',
],

''timestamp_format' => 'Y-m-d H:i:s',
'debug' => env('APP_DEBUG', false),
'use_exception_handler' => true,
'api_routes_pattern' => 'api/*',

// In your routes/api.php
Route::middleware(['api.response'])->group(function () {
    Route::get('/users', [UserController::class, 'index']);
    Route::post('/users', [UserController::class, 'store']);
});

// Or register globally in App\Http\Kernel.php
protected $middlewareGroups = [
    'api' => [
        \ApiResponse\Http\Middleware\ApiResponseMiddleware::class,
        // ... other middleware
    ],
];

use ApiResponse\Services\ApiVersioningService;

class UserController extends Controller
{
    public function index(ApiVersioningService $versioning)
    {
        $version = $versioning->getVersion(request());
        
        if ($version === 'v2') {
            // Return v2 format
            return $this->paginatedResponseV2($users);
        }
        
        // Return v1 format
        return $this->paginatedResponse($users);
    }
}

use ApiResponse\Services\ResponseCompressionService;

class UserController extends Controller
{
    public function index(ResponseCompressionService $compression)
    {
        $response = $this->paginatedResponse($users);
        
        return $compression->compress(request(), $response);
    }
}

use ApiResponse\Services\PerformanceMonitoringService;

class UserController extends Controller
{
    public function index(PerformanceMonitoringService $monitoring)
    {
        $monitoring->startMonitoring(request());

        $users = User::paginate(10);
        $response = $this->paginatedResponse($users);

        $monitoring->endMonitoring(request(), $response);

        return $response;
    }
}

namespace Tests\Feature;

use Tests\TestCase;
use App\Models\User;

class UserApiTest extends TestCase
{
    public function test_can_get_users()
    {
        $response = $this->getJson('/api/users');

        $response->assertStatus(200)
                ->assertJsonStructure([
                    'success',
                    'message',
                    'data',
                    'meta',
                    'timestamp'
                ])
                ->assertJson([
                    'success' => true,
                    'message' => 'Users retrieved successfully'
                ]);
    }

    public function test_can_create_user()
    {
        $userData = [
            'name' => 'John Doe',
            'email' => '[email protected]',
            'password' => 'password123'
        ];

        $response = $this->postJson('/api/users', $userData);

        $response->assertStatus(201)
                ->assertJson([
                    'success' => true,
                    'message' => 'User created successfully'
                ]);
    }

    public function test_validation_errors()
    {
        $response = $this->postJson('/api/users', []);

        $response->assertStatus(422)
                ->assertJson([
                    'success' => false,
                    'message' => 'Validation failed'
                ])
                ->assertJsonStructure([
                    'errors' => [
                        'name',
                        'email',
                        'password'
                    ]
                ]);
    }
}

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use ApiResponse\Traits\ApiResponseTrait;
use Illuminate\Validation\ValidationException;
use Illuminate\Database\Eloquent\ModelNotFoundException;

class UserController extends Controller
{
    use ApiResponseTrait;

    public function index()
    {
        try {
            $users = User::paginate(10);
            return $this->paginatedResponse($users, 'Users retrieved successfully');
        } catch (\Exception $e) {
            return $this->serverErrorResponse('Failed to retrieve users');
        }
    }

    public function store(Request $request)
    {
        try {
            $validated = $request->validate([
                'name' => 'this->notFoundResponse('User not found');
        }
    }

    public function update(Request $request, $id)
    {
        try {
            $user = User::findOrFail($id);
            $validated = $request->validate([
                'name' => 'sometimes|string|max:255',
                'email' => 'sometimes|email|unique:users,email,' . $id,
            ]);

            $user->update($validated);
            return $this->successResponse($user, 'User updated successfully');
        } catch (ModelNotFoundException $e) {
            return $this->notFoundResponse('User not found');
        } catch (ValidationException $e) {
            return $this->validationErrorResponse($e->errors(), 'Validation failed');
        }
    }

    public function destroy($id)
    {
        try {
            $user = User::findOrFail($id);
            $user->delete();
            return $this->successResponse(null, 'User deleted successfully');
        } catch (ModelNotFoundException $e) {
            return $this->notFoundResponse('User not found');
        }
    }
}

bash
php artisan vendor:publish --provider="ApiResponse\ApiResponseServiceProvider" --tag="api-response-config"