update

v4_ci4/system/API/ResponseTrait.php

@@ -0,0 +1,532 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\API;
+
+use CodeIgniter\Database\BaseBuilder;
+use CodeIgniter\Database\Exceptions\DatabaseException;
+use CodeIgniter\Format\Format;
+use CodeIgniter\Format\FormatterInterface;
+use CodeIgniter\HTTP\CLIRequest;
+use CodeIgniter\HTTP\IncomingRequest;
+use CodeIgniter\HTTP\ResponseInterface;
+use CodeIgniter\HTTP\URI;
+use CodeIgniter\Model;
+use Throwable;
+
+/**
+ * Provides common, more readable, methods to provide
+ * consistent HTTP responses under a variety of common
+ * situations when working as an API.
+ *
+ * @property CLIRequest|IncomingRequest $request
+ * @property ResponseInterface          $response
+ * @property bool                       $stringAsHtml Whether to treat string data as HTML in JSON response.
+ *                                                    Setting `true` is only for backward compatibility.
+ */
+trait ResponseTrait
+{
+    /**
+     * Allows child classes to override the
+     * status code that is used in their API.
+     *
+     * @var array<string, int>
+     */
+    protected $codes = [
+        'created'                   => 201,
+        'deleted'                   => 200,
+        'updated'                   => 200,
+        'no_content'                => 204,
+        'invalid_request'           => 400,
+        'unsupported_response_type' => 400,
+        'invalid_scope'             => 400,
+        'temporarily_unavailable'   => 400,
+        'invalid_grant'             => 400,
+        'invalid_credentials'       => 400,
+        'invalid_refresh'           => 400,
+        'no_data'                   => 400,
+        'invalid_data'              => 400,
+        'access_denied'             => 401,
+        'unauthorized'              => 401,
+        'invalid_client'            => 401,
+        'forbidden'                 => 403,
+        'resource_not_found'        => 404,
+        'not_acceptable'            => 406,
+        'resource_exists'           => 409,
+        'conflict'                  => 409,
+        'resource_gone'             => 410,
+        'payload_too_large'         => 413,
+        'unsupported_media_type'    => 415,
+        'too_many_requests'         => 429,
+        'server_error'              => 500,
+        'unsupported_grant_type'    => 501,
+        'not_implemented'           => 501,
+    ];
+
+    /**
+     * How to format the response data.
+     * Either 'json' or 'xml'. If null is set, it will be determined through
+     * content negotiation.
+     *
+     * @var 'html'|'json'|'xml'|null
+     */
+    protected $format = 'json';
+
+    /**
+     * Current Formatter instance. This is usually set by ResponseTrait::format
+     *
+     * @var FormatterInterface|null
+     */
+    protected $formatter;
+
+    /**
+     * Provides a single, simple method to return an API response, formatted
+     * to match the requested format, with proper content-type and status code.
+     *
+     * @param array<string, mixed>|string|null $data
+     *
+     * @return ResponseInterface
+     */
+    protected function respond($data = null, ?int $status = null, string $message = '')
+    {
+        if ($data === null && $status === null) {
+            $status = 404;
+            $output = null;
+            $this->format($data);
+        } elseif ($data === null && is_numeric($status)) {
+            $output = null;
+            $this->format($data);
+        } else {
+            $status ??= 200;
+            $output = $this->format($data);
+        }
+
+        if ($output !== null) {
+            if ($this->format === 'json') {
+                return $this->response->setJSON($output)->setStatusCode($status, $message);
+            }
+
+            if ($this->format === 'xml') {
+                return $this->response->setXML($output)->setStatusCode($status, $message);
+            }
+        }
+
+        return $this->response->setBody($output)->setStatusCode($status, $message);
+    }
+
+    /**
+     * Used for generic failures that no custom methods exist for.
+     *
+     * @param array<array-key, string>|string $messages
+     * @param int                             $status   HTTP status code
+     * @param string|null                     $code     Custom, API-specific, error code
+     *
+     * @return ResponseInterface
+     */
+    protected function fail($messages, int $status = 400, ?string $code = null, string $customMessage = '')
+    {
+        if (! is_array($messages)) {
+            $messages = ['error' => $messages];
+        }
+
+        $response = [
+            'status'   => $status,
+            'error'    => $code ?? $status,
+            'messages' => $messages,
+        ];
+
+        return $this->respond($response, $status, $customMessage);
+    }
+
+    // --------------------------------------------------------------------
+    // Response Helpers
+    // --------------------------------------------------------------------
+
+    /**
+     * Used after successfully creating a new resource.
+     *
+     * @param array<string, mixed>|string|null $data
+     *
+     * @return ResponseInterface
+     */
+    protected function respondCreated($data = null, string $message = '')
+    {
+        return $this->respond($data, $this->codes['created'], $message);
+    }
+
+    /**
+     * Used after a resource has been successfully deleted.
+     *
+     * @param array<string, mixed>|string|null $data
+     *
+     * @return ResponseInterface
+     */
+    protected function respondDeleted($data = null, string $message = '')
+    {
+        return $this->respond($data, $this->codes['deleted'], $message);
+    }
+
+    /**
+     * Used after a resource has been successfully updated.
+     *
+     * @param array<string, mixed>|string|null $data
+     *
+     * @return ResponseInterface
+     */
+    protected function respondUpdated($data = null, string $message = '')
+    {
+        return $this->respond($data, $this->codes['updated'], $message);
+    }
+
+    /**
+     * Used after a command has been successfully executed but there is no
+     * meaningful reply to send back to the client.
+     *
+     * @return ResponseInterface
+     */
+    protected function respondNoContent(string $message = 'No Content')
+    {
+        return $this->respond(null, $this->codes['no_content'], $message);
+    }
+
+    /**
+     * Used when the client is either didn't send authorization information,
+     * or had bad authorization credentials. User is encouraged to try again
+     * with the proper information.
+     *
+     * @return ResponseInterface
+     */
+    protected function failUnauthorized(string $description = 'Unauthorized', ?string $code = null, string $message = '')
+    {
+        return $this->fail($description, $this->codes['unauthorized'], $code, $message);
+    }
+
+    /**
+     * Used when access is always denied to this resource and no amount
+     * of trying again will help.
+     *
+     * @return ResponseInterface
+     */
+    protected function failForbidden(string $description = 'Forbidden', ?string $code = null, string $message = '')
+    {
+        return $this->fail($description, $this->codes['forbidden'], $code, $message);
+    }
+
+    /**
+     * Used when a specified resource cannot be found.
+     *
+     * @return ResponseInterface
+     */
+    protected function failNotFound(string $description = 'Not Found', ?string $code = null, string $message = '')
+    {
+        return $this->fail($description, $this->codes['resource_not_found'], $code, $message);
+    }
+
+    /**
+     * Used when the data provided by the client cannot be validated on one or more fields.
+     *
+     * @param array<array-key, string>|string $errors
+     *
+     * @return ResponseInterface
+     */
+    protected function failValidationErrors($errors, ?string $code = null, string $message = '')
+    {
+        return $this->fail($errors, $this->codes['invalid_data'], $code, $message);
+    }
+
+    /**
+     * Use when trying to create a new resource and it already exists.
+     *
+     * @return ResponseInterface
+     */
+    protected function failResourceExists(string $description = 'Conflict', ?string $code = null, string $message = '')
+    {
+        return $this->fail($description, $this->codes['resource_exists'], $code, $message);
+    }
+
+    /**
+     * Use when a resource was previously deleted. This is different than
+     * Not Found, because here we know the data previously existed, but is now gone,
+     * where Not Found means we simply cannot find any information about it.
+     *
+     * @return ResponseInterface
+     */
+    protected function failResourceGone(string $description = 'Gone', ?string $code = null, string $message = '')
+    {
+        return $this->fail($description, $this->codes['resource_gone'], $code, $message);
+    }
+
+    /**
+     * Used when the user has made too many requests for the resource recently.
+     *
+     * @return ResponseInterface
+     */
+    protected function failTooManyRequests(string $description = 'Too Many Requests', ?string $code = null, string $message = '')
+    {
+        return $this->fail($description, $this->codes['too_many_requests'], $code, $message);
+    }
+
+    /**
+     * Used when there is a server error.
+     *
+     * @param string      $description The error message to show the user.
+     * @param string|null $code        A custom, API-specific, error code.
+     * @param string      $message     A custom "reason" message to return.
+     */
+    protected function failServerError(string $description = 'Internal Server Error', ?string $code = null, string $message = ''): ResponseInterface
+    {
+        return $this->fail($description, $this->codes['server_error'], $code, $message);
+    }
+
+    // --------------------------------------------------------------------
+    // Utility Methods
+    // --------------------------------------------------------------------
+
+    /**
+     * Handles formatting a response. Currently, makes some heavy assumptions
+     * and needs updating! :)
+     *
+     * @param array<string, mixed>|string|null $data
+     *
+     * @return string|null
+     */
+    protected function format($data = null)
+    {
+        /** @var Format $format */
+        $format = service('format');
+
+        $mime = $this->format === null
+            ? $format->getConfig()->supportedResponseFormats[0]
+            : "application/{$this->format}";
+
+        // Determine correct response type through content negotiation if not explicitly declared
+        if (
+            ! in_array($this->format, ['json', 'xml'], true)
+            && $this->request instanceof IncomingRequest
+        ) {
+            $mime = $this->request->negotiate(
+                'media',
+                $format->getConfig()->supportedResponseFormats,
+                false,
+            );
+        }
+
+        $this->response->setContentType($mime);
+
+        // if we don't have a formatter, make one
+        $this->formatter ??= $format->getFormatter($mime);
+
+        $asHtml = property_exists($this, 'stringAsHtml') ? $this->stringAsHtml : false;
+
+        if (
+            ($mime === 'application/json' && $asHtml && is_string($data))
+            || ($mime !== 'application/json' && is_string($data))
+        ) {
+            // The content type should be text/... and not application/...
+            $contentType = $this->response->getHeaderLine('Content-Type');
+            $contentType = str_replace('application/json', 'text/html', $contentType);
+            $contentType = str_replace('application/', 'text/', $contentType);
+            $this->response->setContentType($contentType);
+            $this->format = 'html';
+
+            return $data;
+        }
+
+        if ($mime !== 'application/json') {
+            // Recursively convert objects into associative arrays
+            // Conversion not required for JSONFormatter
+            /** @var array<string, mixed>|string|null $data */
+            $data = json_decode(json_encode($data), true);
+        }
+
+        return $this->formatter->format($data);
+    }
+
+    /**
+     * Sets the format the response should be in.
+     *
+     * @param 'json'|'xml' $format Response format
+     *
+     * @return $this
+     */
+    protected function setResponseFormat(?string $format = null)
+    {
+        $this->format = $format === null ? null : strtolower($format);
+
+        return $this;
+    }
+
+    // --------------------------------------------------------------------
+    // Pagination Methods
+    // --------------------------------------------------------------------
+
+    /**
+     * Paginates the given model or query builder and returns
+     * an array containing the paginated results along with
+     * metadata such as total items, total pages, current page,
+     * and items per page.
+     *
+     * The result would be in the following format:
+     * [
+     *   'data' => [...],
+     *   'meta' => [
+     *       'page' => 1,
+     *       'perPage' => 20,
+     *       'total' => 100,
+     *       'totalPages' => 5,
+     *   ],
+     *   'links' => [
+     *       'self' => '/api/items?page=1&perPage=20',
+     *       'first' => '/api/items?page=1&perPage=20',
+     *       'last' => '/api/items?page=5&perPage=20',
+     *       'prev' => null,
+     *       'next' => '/api/items?page=2&perPage=20',
+     *   ]
+     * ]
+     *
+     * @param class-string<TransformerInterface>|null $transformWith
+     */
+    protected function paginate(BaseBuilder|Model $resource, int $perPage = 20, ?string $transformWith = null): ResponseInterface
+    {
+        try {
+            assert($this->request instanceof IncomingRequest);
+
+            $page = max(1, (int) ($this->request->getGet('page') ?? 1));
+
+            // If using a Model we can use its built-in paginate method
+            if ($resource instanceof Model) {
+                $data  = $resource->paginate($perPage, 'default', $page);
+                $pager = $resource->pager;
+
+                $meta = [
+                    'page'       => $pager->getCurrentPage(),
+                    'perPage'    => $pager->getPerPage(),
+                    'total'      => $pager->getTotal(),
+                    'totalPages' => $pager->getPageCount(),
+                ];
+            } else {
+                // Query Builder, we need to handle pagination manually
+                $offset = ($page - 1) * $perPage;
+                $total  = (clone $resource)->countAllResults();
+                $data   = $resource->limit($perPage, $offset)->get()->getResultArray();
+
+                $meta = [
+                    'page'       => $page,
+                    'perPage'    => $perPage,
+                    'total'      => $total,
+                    'totalPages' => (int) ceil($total / $perPage),
+                ];
+            }
+
+            // Transform data if a transformer is provided
+            if ($transformWith !== null) {
+                if (! class_exists($transformWith)) {
+                    throw ApiException::forTransformerNotFound($transformWith);
+                }
+
+                $transformer = new $transformWith($this->request);
+
+                if (! $transformer instanceof TransformerInterface) {
+                    throw ApiException::forInvalidTransformer($transformWith);
+                }
+
+                $data = $transformer->transformMany($data);
+            }
+
+            $links = $this->buildLinks($meta);
+
+            $this->response->setHeader('Link', $this->linkHeader($links));
+            $this->response->setHeader('X-Total-Count', (string) $meta['total']);
+
+            return $this->respond([
+                'data'  => $data,
+                'meta'  => $meta,
+                'links' => $links,
+            ]);
+        } catch (ApiException $e) {
+            // Re-throw ApiExceptions so they can be handled by the caller
+            throw $e;
+        } catch (DatabaseException $e) {
+            log_message('error', lang('RESTful.cannotPaginate') . ' ' . $e->getMessage());
+
+            return $this->failServerError(lang('RESTful.cannotPaginate'));
+        } catch (Throwable $e) {
+            log_message('error', lang('RESTful.paginateError') . ' ' . $e->getMessage());
+
+            return $this->failServerError(lang('RESTful.paginateError'));
+        }
+    }
+
+    /**
+     * Builds pagination links based on the current request URI and pagination metadata.
+     *
+     * @param array<string, int> $meta Pagination metadata (page, perPage, total, totalPages)
+     *
+     * @return array<string, string|null> Array of pagination links with relations as keys
+     */
+    private function buildLinks(array $meta): array
+    {
+        assert($this->request instanceof IncomingRequest);
+
+        /** @var URI $uri */
+        $uri   = current_url(true);
+        $query = $this->request->getGet();
+
+        $set = static function ($page) use ($uri, $query, $meta): string {
+            $params         = $query;
+            $params['page'] = $page;
+
+            // Ensure perPage is in the links if it's not default
+            if (! isset($params['perPage']) && $meta['perPage'] !== 20) {
+                $params['perPage'] = $meta['perPage'];
+            }
+
+            return (string) (new URI((string) $uri))->setQuery(http_build_query($params));
+        };
+
+        $totalPages = max(1, (int) $meta['totalPages']);
+        $page       = (int) $meta['page'];
+
+        return [
+            'self'  => $set($page),
+            'first' => $set(1),
+            'last'  => $set($totalPages),
+            'prev'  => $page > 1 ? $set($page - 1) : null,
+            'next'  => $page < $totalPages ? $set($page + 1) : null,
+        ];
+    }
+
+    /**
+     * Formats the pagination links into a single Link header string
+     * for middleware/machine use.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
+     * @see https://datatracker.ietf.org/doc/html/rfc8288
+     *
+     * @param array<string, string|null> $links Pagination links with relations as keys
+     *
+     * @return string Formatted Link header value
+     */
+    private function linkHeader(array $links): string
+    {
+        $parts = [];
+
+        foreach (['self', 'first', 'prev', 'next', 'last'] as $rel) {
+            if ($links[$rel] !== null && $links[$rel] !== '') {
+                $parts[] = "<{$links[$rel]}>; rel=\"{$rel}\"";
+            }
+        }
+
+        return implode(', ', $parts);
+    }
+}