PSR-12 compatibility

api.php

 
     class TempFileCache implements Cache
     {
-        const SUFFIX = 'cache';
+        public const SUFFIX = 'cache';
 
         private $path;
         private $segments;
 
     class ReflectedColumn implements \JsonSerializable
     {
-        const DEFAULT_LENGTH = 255;
-        const DEFAULT_PRECISION = 19;
-        const DEFAULT_SCALE = 4;
+        public const DEFAULT_LENGTH = 255;
+        public const DEFAULT_PRECISION = 19;
+        public const DEFAULT_SCALE = 4;
 
         private $name;
         private $type;
             return new ReflectedColumn($name, $type, $length, $precision, $scale, $nullable, $pk, $fk);
         }
 
-        public static function fromJson( /* object */$json): ReflectedColumn
+        public static function fromJson(/* object */$json): ReflectedColumn
         {
             $name = $json->name;
             $type = $json->type;
             return new ReflectedDatabase($tableTypes);
         }
 
-        public static function fromJson( /* object */$json): ReflectedDatabase
+        public static function fromJson(/* object */$json): ReflectedDatabase
         {
             $tableTypes = (array) $json->tables;
             return new ReflectedDatabase($tableTypes);
             return new ReflectedTable($name, $type, array_values($columns));
         }
 
-        public static function fromJson( /* object */$json): ReflectedTable
+        public static function fromJson(/* object */$json): ReflectedTable
         {
             $name = $json->name;
             $type = $json->type;
             return true;
         }
 
-        public function addTable( /* object */$definition)
+        public function addTable(/* object */$definition)
         {
             $newTable = ReflectedTable::fromJson($definition);
             if (!$this->db->definition()->addTable($newTable)) {
             }
             return true;
         }
-
     }
 }
 
         {
             return $this->responder->success($this->cache->clear());
         }
-
     }
 }
 
                 return $this->responder->success($response);
             }
         }
-
     }
 }
 
         {
             return ResponseFactory::fromObject(ResponseFactory::OK, $result);
         }
-
     }
 }
 
         {
             return $this->responder->success($this->openApi->get());
         }
-
     }
 }
 
                 return $this->responder->success($this->service->increment($table, $id, $record, $params));
             }
         }
-
     }
 }
 
         public function error(int $error, string $argument, $details = null): ResponseInterface;
 
         public function success($result): ResponseInterface;
-
     }
 }
 
             }
             return $value;
         }
-
     }
 }
 
             }
             return implode(',', $results);
         }
-
     }
 }
 
             $type = $this->typeConverter->fromJdbc($column->getType());
             if ($column->hasPrecision() && $column->hasScale()) {
                 $size = '(' . $column->getPrecision() . ',' . $column->getScale() . ')';
-            } else if ($column->hasPrecision()) {
+            } elseif ($column->hasPrecision()) {
                 $size = '(' . $column->getPrecision() . ')';
-            } else if ($column->hasLength()) {
+            } elseif ($column->hasLength()) {
                 $size = '(' . $column->getLength() . ')';
             } else {
                 $size = '';
             return [$lon, $lat];
         }
 
-        private function convertRecordToFeature( /*object*/$record, string $primaryKeyColumnName, string $geometryColumnName)
+        private function convertRecordToFeature(/*object*/$record, string $primaryKeyColumnName, string $geometryColumnName)
         {
             $id = null;
             if ($primaryKeyColumnName) {
 
     class VariableStore
     {
-        static $values = array();
+        public static $values = array();
 
         public static function get(string $key)
         {
             }
             return $response;
         }
-
     }
 }
 
     use Psr\Http\Message\ResponseInterface;
     use Psr\Http\Message\ServerRequestInterface;
     use Psr\Http\Server\RequestHandlerInterface;
-    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
+    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Controller\Responder;
     use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
     use Tqdev\PhpCrudApi\Middleware\Router\Router;
     use Psr\Http\Message\ResponseInterface;
     use Psr\Http\Message\ServerRequestInterface;
     use Psr\Http\Server\RequestHandlerInterface;
-    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
+    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Controller\Responder;
     use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
     use Tqdev\PhpCrudApi\Middleware\Router\Router;
     use Psr\Http\Message\ResponseInterface;
     use Psr\Http\Message\ServerRequestInterface;
     use Psr\Http\Server\RequestHandlerInterface;
-    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
+    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Controller\Responder;
     use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
     use Tqdev\PhpCrudApi\Middleware\Router\Router;
         {
             return $this->builder->build();
         }
-
     }
 }
 
             }
             return $condition;
         }
-
     }
 }
 
         {
             return $this;
         }
-
     }
 }
 
 
     class ListDocument implements \JsonSerializable
     {
-
         private $records;
 
         private $results;
 
     class ColumnIncluder
     {
-
         private function isMandatory(string $tableName, string $columnName, array $params): bool
         {
             return isset($params['mandatory']) && in_array($tableName . "." . $columnName, $params['mandatory']);
         }
 
-        private function select(string $tableName, bool $primaryTable, array $params, string $paramName,
-            array $columnNames, bool $include): array{
+        private function select(
+            string $tableName,
+            bool $primaryTable,
+            array $params,
+            string $paramName,
+            array $columnNames,
+            bool $include
+        ): array {
             if (!isset($params[$paramName])) {
                 return $columnNames;
             }
             }
             return $results;
         }
-
     }
 }
 
 
     class ErrorCode
     {
-
         private $code;
         private $message;
         private $status;
 
-        const ERROR_NOT_FOUND = 9999;
-        const ROUTE_NOT_FOUND = 1000;
-        const TABLE_NOT_FOUND = 1001;
-        const ARGUMENT_COUNT_MISMATCH = 1002;
-        const RECORD_NOT_FOUND = 1003;
-        const ORIGIN_FORBIDDEN = 1004;
-        const COLUMN_NOT_FOUND = 1005;
-        const TABLE_ALREADY_EXISTS = 1006;
-        const COLUMN_ALREADY_EXISTS = 1007;
-        const HTTP_MESSAGE_NOT_READABLE = 1008;
-        const DUPLICATE_KEY_EXCEPTION = 1009;
-        const DATA_INTEGRITY_VIOLATION = 1010;
-        const AUTHENTICATION_REQUIRED = 1011;
-        const AUTHENTICATION_FAILED = 1012;
-        const INPUT_VALIDATION_FAILED = 1013;
-        const OPERATION_FORBIDDEN = 1014;
-        const OPERATION_NOT_SUPPORTED = 1015;
-        const TEMPORARY_OR_PERMANENTLY_BLOCKED = 1016;
-        const BAD_OR_MISSING_XSRF_TOKEN = 1017;
-        const ONLY_AJAX_REQUESTS_ALLOWED = 1018;
-        const PAGINATION_FORBIDDEN = 1019;
+        public const ERROR_NOT_FOUND = 9999;
+        public const ROUTE_NOT_FOUND = 1000;
+        public const TABLE_NOT_FOUND = 1001;
+        public const ARGUMENT_COUNT_MISMATCH = 1002;
+        public const RECORD_NOT_FOUND = 1003;
+        public const ORIGIN_FORBIDDEN = 1004;
+        public const COLUMN_NOT_FOUND = 1005;
+        public const TABLE_ALREADY_EXISTS = 1006;
+        public const COLUMN_ALREADY_EXISTS = 1007;
+        public const HTTP_MESSAGE_NOT_READABLE = 1008;
+        public const DUPLICATE_KEY_EXCEPTION = 1009;
+        public const DATA_INTEGRITY_VIOLATION = 1010;
+        public const AUTHENTICATION_REQUIRED = 1011;
+        public const AUTHENTICATION_FAILED = 1012;
+        public const INPUT_VALIDATION_FAILED = 1013;
+        public const OPERATION_FORBIDDEN = 1014;
+        public const OPERATION_NOT_SUPPORTED = 1015;
+        public const TEMPORARY_OR_PERMANENTLY_BLOCKED = 1016;
+        public const BAD_OR_MISSING_XSRF_TOKEN = 1017;
+        public const ONLY_AJAX_REQUESTS_ALLOWED = 1018;
+        public const PAGINATION_FORBIDDEN = 1019;
 
         private $values = [
             9999 => ["%s", ResponseFactory::INTERNAL_SERVER_ERROR],
         {
             return $this->status;
         }
-
     }
 }
 
 
     class FilterInfo
     {
-
         private function addConditionFromFilterPath(PathTree $conditions, array $path, ReflectedTable $table, array $params)
         {
             $key = 'filter' . implode('', $path);
         {
             return $this->combinePathTreeOfConditions($this->getConditionsAsPathTree($table, $params));
         }
-
     }
 }
 
 
     class OrderingInfo
     {
-
         public function getColumnOrdering(ReflectedTable $table, array $params): array
         {
             $fields = array();
 
     class PaginationInfo
     {
-
         public $DEFAULT_PAGE_SIZE = 20;
 
         public function hasPage(array $params): bool
             }
             return $pageLimit;
         }
-
     }
 }
 
 
     class PathTree implements \JsonSerializable
     {
-        const WILDCARD = '*';
+        public const WILDCARD = '*';
 
         private $tree;
 
-        public function __construct( /* object */&$tree = null)
+        public function __construct(/* object */&$tree = null)
         {
             if (!$tree) {
                 $tree = $this->newTree();
             foreach ($path as $key) {
                 if (isset($tree->branches->$key)) {
                     $tree = &$tree->branches->$key;
-                } else if (isset($tree->branches->$star)) {
+                } elseif (isset($tree->branches->$star)) {
                     $tree = &$tree->branches->$star;
                 } else {
                     return [];
             return $tree->values;
         }
 
-        public static function fromJson( /* object */$tree): PathTree
+        public static function fromJson(/* object */$tree): PathTree
         {
             return new PathTree($tree);
         }
 // file: src/Tqdev/PhpCrudApi/Record/RelationJoiner.php
 namespace Tqdev\PhpCrudApi\Record {
 
-    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Column\Reflection\ReflectedTable;
+    use Tqdev\PhpCrudApi\Column\ReflectionService;
     use Tqdev\PhpCrudApi\Database\GenericDB;
     use Tqdev\PhpCrudApi\Middleware\Communication\VariableStore;
     use Tqdev\PhpCrudApi\Record\Condition\ColumnCondition;
 
     class RelationJoiner
     {
-
         private $reflection;
         private $ordering;
         private $columns;
 
         private function addJoinsForTables(ReflectedTable $t1, PathTree $joins, array &$records, array $params, GenericDB $db)
         {
-
             foreach ($joins->getKeys() as $t2Name) {
-
                 $t2 = $this->reflection->getTable($t2Name);
 
                 $belongsTo = count($t1->getFksTo($t2->getName())) > 0;
     use Tqdev\PhpCrudApi\Middleware\IpAddressMiddleware;
     use Tqdev\PhpCrudApi\Middleware\JoinLimitsMiddleware;
     use Tqdev\PhpCrudApi\Middleware\JwtAuthMiddleware;
-    use Tqdev\PhpCrudApi\Middleware\ReconnectMiddleware;
     use Tqdev\PhpCrudApi\Middleware\MultiTenancyMiddleware;
     use Tqdev\PhpCrudApi\Middleware\PageLimitsMiddleware;
+    use Tqdev\PhpCrudApi\Middleware\ReconnectMiddleware;
     use Tqdev\PhpCrudApi\Middleware\Router\SimpleRouter;
     use Tqdev\PhpCrudApi\Middleware\SanitationMiddleware;
     use Tqdev\PhpCrudApi\Middleware\ValidationMiddleware;
 // file: src/Tqdev/PhpCrudApi/RequestFactory.php
 namespace Tqdev\PhpCrudApi {
 
-    use Nyholm\Psr7Server\ServerRequestCreator;
     use Nyholm\Psr7\Factory\Psr17Factory;
+    use Nyholm\Psr7Server\ServerRequestCreator;
     use Psr\Http\Message\ServerRequestInterface;
 
     class RequestFactory
             }
             return $allTableNames;
         }
-
     }
 }
 
 
     class ResponseFactory
     {
-        const OK = 200;
-        const UNAUTHORIZED = 401;
-        const FORBIDDEN = 403;
-        const NOT_FOUND = 404;
-        const METHOD_NOT_ALLOWED = 405;
-        const CONFLICT = 409;
-        const UNPROCESSABLE_ENTITY = 422;
-        const INTERNAL_SERVER_ERROR = 500;
+        public const OK = 200;
+        public const UNAUTHORIZED = 401;
+        public const FORBIDDEN = 403;
+        public const NOT_FOUND = 404;
+        public const METHOD_NOT_ALLOWED = 405;
+        public const CONFLICT = 409;
+        public const UNPROCESSABLE_ENTITY = 422;
+        public const INTERNAL_SERVER_ERROR = 500;
 
         public static function fromHtml(int $status, string $html): ResponseInterface
         {
             $psr17Factory = new Psr17Factory();
             return $psr17Factory->createResponse($status);
         }
-
     }
 }