wip

src/Tqdev/PhpCrudApi/Cache/Cache.php

 
 interface Cache
 {
-    public function set(String $key, String $value, int $ttl = 0): bool;
-    public function get(String $key): String;
+    public function set(string $key, string $value, int $ttl = 0): bool;
+    public function get(string $key): string;
     public function clear(): bool;
 }

src/Tqdev/PhpCrudApi/Cache/CacheFactory.php

 {
     const PREFIX = 'phpcrudapi-%s-%s-%s-';
 
-    private static function getPrefix(Config $config): String
+    private static function getPrefix(Config $config): string
     {
         $driver = $config->getDriver();
         $database = $config->getDatabase();

src/Tqdev/PhpCrudApi/Cache/MemcacheCache.php

     protected $prefix;
     protected $memcache;
 
-    public function __construct(String $prefix, String $config)
+    public function __construct(string $prefix, string $config)
     {
         $this->prefix = $prefix;
         if ($config == '') {
         return new \Memcache();
     }
 
-    public function set(String $key, String $value, int $ttl = 0): bool
+    public function set(string $key, string $value, int $ttl = 0): bool
     {
         return $this->memcache->set($this->prefix . $key, $value, 0, $ttl);
     }
 
-    public function get(String $key): String
+    public function get(string $key): string
     {
         return $this->memcache->get($this->prefix . $key) ?: '';
     }

src/Tqdev/PhpCrudApi/Cache/MemcachedCache.php

         return new \Memcached();
     }
 
-    public function set(String $key, String $value, int $ttl = 0): bool
+    public function set(string $key, string $value, int $ttl = 0): bool
     {
         return $this->memcache->set($this->prefix . $key, $value, $ttl);
     }

src/Tqdev/PhpCrudApi/Cache/NoCache.php

     {
     }
 
-    public function set(String $key, String $value, int $ttl = 0): bool
+    public function set(string $key, string $value, int $ttl = 0): bool
     {
         return true;
     }
 
-    public function get(String $key): String
+    public function get(string $key): string
     {
         return '';
     }

src/Tqdev/PhpCrudApi/Cache/RedisCache.php

     protected $prefix;
     protected $redis;
 
-    public function __construct(String $prefix, String $config)
+    public function __construct(string $prefix, string $config)
     {
         $this->prefix = $prefix;
         if ($config == '') {
         call_user_func_array(array($this->redis, 'pconnect'), $params);
     }
 
-    public function set(String $key, String $value, int $ttl = 0): bool
+    public function set(string $key, string $value, int $ttl = 0): bool
     {
         return $this->redis->set($this->prefix . $key, $value, $ttl);
     }
 
-    public function get(String $key): String
+    public function get(string $key): string
     {
         return $this->redis->get($this->prefix . $key) ?: '';
     }

src/Tqdev/PhpCrudApi/Cache/TempFileCache.php

     private $path;
     private $segments;
 
-    public function __construct(String $prefix, String $config)
+    public function __construct(string $prefix, string $config)
     {
         $this->segments = [];
         $s = DIRECTORY_SEPARATOR;
         }
     }
 
-    private function getFileName(String $key): String
+    private function getFileName(string $key): string
     {
         $s = DIRECTORY_SEPARATOR;
         $md5 = md5($key);
         return $filename;
     }
 
-    public function set(String $key, String $value, int $ttl = 0): bool
+    public function set(string $key, string $value, int $ttl = 0): bool
     {
         $filename = $this->getFileName($key);
         $dirname = dirname($filename);
         return $string;
     }
 
-    private function getString($filename): String
+    private function getString($filename): string
     {
         $data = $this->fileGetContents($filename);
         if ($data === false) {
         return $string;
     }
 
-    public function get(String $key): String
+    public function get(string $key): string
     {
         $filename = $this->getFileName($key);
         if (!file_exists($filename)) {
         return $string;
     }
 
-    private function clean(String $path, array $segments, int $len, bool $all) /*: void*/
+    private function clean(string $path, array $segments, int $len, bool $all) /*: void*/
     {
         $entries = scandir($path);
         foreach ($entries as $entry) {

src/Tqdev/PhpCrudApi/Column/DefinitionService.php

         $this->reflection = $reflection;
     }
 
-    public function updateTable(String $tableName, /* object */ $changes): bool
+    public function updateTable(string $tableName, /* object */ $changes): bool
     {
         $table = $this->reflection->getTable($tableName);
         $newTable = ReflectedTable::fromJson((object) array_merge((array) $table->jsonSerialize(), (array) $changes));
         return true;
     }
 
-    public function updateColumn(String $tableName, String $columnName, /* object */ $changes): bool
+    public function updateColumn(string $tableName, string $columnName, /* object */ $changes): bool
     {
         $table = $this->reflection->getTable($tableName);
         $column = $table->getColumn($columnName);
         return true;
     }
 
-    public function addColumn(String $tableName, /* object */ $definition)
+    public function addColumn(string $tableName, /* object */ $definition)
     {
         $newColumn = ReflectedColumn::fromJson($definition);
         if (!$this->db->definition()->addColumn($tableName, $newColumn)) {
         return true;
     }
 
-    public function removeTable(String $tableName)
+    public function removeTable(string $tableName)
     {
         if (!$this->db->definition()->removeTable($tableName)) {
             return false;
         return true;
     }
 
-    public function removeColumn(String $tableName, String $columnName)
+    public function removeColumn(string $tableName, string $columnName)
     {
         $table = $this->reflection->getTable($tableName);
         $newColumn = $table->getColumn($columnName);

src/Tqdev/PhpCrudApi/Column/Reflection/ReflectedColumn.php

     private $pk;
     private $fk;
 
-    public function __construct(String $name, String $type, int $length, int $precision, int $scale, bool $nullable, bool $pk, String $fk)
+    public function __construct(string $name, string $type, int $length, int $precision, int $scale, bool $nullable, bool $pk, string $fk)
     {
         $this->name = $name;
         $this->type = $type;
         $this->scale = $this->hasScale() ? $this->getScale() : 0;
     }
 
-    public function getName(): String
+    public function getName(): string
     {
         return $this->name;
     }
         return $this->nullable;
     }
 
-    public function getType(): String
+    public function getType(): string
     {
         return $this->type;
     }
         $this->fk = $value;
     }
 
-    public function getFk(): String
+    public function getFk(): string
     {
         return $this->fk;
     }

src/Tqdev/PhpCrudApi/Column/Reflection/ReflectedDatabase.php

         return new ReflectedDatabase($tableTypes);
     }
 
-    public function hasTable(String $tableName): bool
+    public function hasTable(string $tableName): bool
     {
         return isset($this->tableTypes[$tableName]);
     }
 
-    public function getType(String $tableName): String
+    public function getType(string $tableName): string
     {
         return isset($this->tableTypes[$tableName]) ? $this->tableTypes[$tableName] : '';
     }
         return array_keys($this->tableTypes);
     }
 
-    public function removeTable(String $tableName): bool
+    public function removeTable(string $tableName): bool
     {
         if (!isset($this->tableTypes[$tableName])) {
             return false;

src/Tqdev/PhpCrudApi/Column/Reflection/ReflectedTable.php

     private $pk;
     private $fks;
 
-    public function __construct(String $name, String $type, array $columns)
+    public function __construct(string $name, string $type, array $columns)
     {
         $this->name = $name;
         $this->type = $type;
         }
     }
 
-    public static function fromReflection(GenericReflection $reflection, String $name, String $type): ReflectedTable
+    public static function fromReflection(GenericReflection $reflection, string $name, string $type): ReflectedTable
     {
         // set columns
         $columns = [];
         return new ReflectedTable($name, $type, $columns);
     }
 
-    public function hasColumn(String $columnName): bool
+    public function hasColumn(string $columnName): bool
     {
         return isset($this->columns[$columnName]);
     }
         return $this->pk;
     }
 
-    public function getName(): String
+    public function getName(): string
     {
         return $this->name;
     }
 
-    public function getType(): String
+    public function getType(): string
     {
         return $this->type;
     }
         return $this->columns[$columnName];
     }
 
-    public function getFksTo(String $tableName): array
+    public function getFksTo(string $tableName): array
     {
         $columns = array();
         foreach ($this->fks as $columnName => $referencedTableName) {
         return $columns;
     }
 
-    public function removeColumn(String $columnName): bool
+    public function removeColumn(string $columnName): bool
     {
         if (!isset($this->columns[$columnName])) {
             return false;

src/Tqdev/PhpCrudApi/Column/ReflectionService.php

         return $database;
     }
 
-    private function loadTable(String $tableName, bool $useCache): ReflectedTable
+    private function loadTable(string $tableName, bool $useCache): ReflectedTable
     {
         $data = $useCache ? $this->cache->get("ReflectedTable($tableName)") : '';
         if ($data != '') {
         $this->database = $this->loadDatabase(false);
     }
 
-    public function refreshTable(String $tableName)
+    public function refreshTable(string $tableName)
     {
         $this->tables[$tableName] = $this->loadTable($tableName, false);
     }
 
-    public function hasTable(String $tableName): bool
+    public function hasTable(string $tableName): bool
     {
         return $this->database->hasTable($tableName);
     }
 
-    public function getType(String $tableName): String
+    public function getType(string $tableName): string
     {
         return $this->database->getType($tableName);
     }
 
-    public function getTable(String $tableName): ReflectedTable
+    public function getTable(string $tableName): ReflectedTable
     {
         if (!isset($this->tables[$tableName])) {
             $this->tables[$tableName] = $this->loadTable($tableName, true);
         return $this->database->getTableNames();
     }
 
-    public function getDatabaseName(): String
+    public function getDatabaseName(): string
     {
         return $this->database->getName();
     }
 
-    public function removeTable(String $tableName): bool
+    public function removeTable(string $tableName): bool
     {
         unset($this->tables[$tableName]);
         return $this->database->removeTable($tableName);

src/Tqdev/PhpCrudApi/Config.php

         'openApiBase' => '{"info":{"title":"PHP-CRUD-API","version":"1.0.0"}}',
     ];
 
-    private function getDefaultDriver(array $values): String
+    private function getDefaultDriver(array $values): string
     {
         if (isset($values['driver'])) {
             return $values['driver'];
         return 'mysql';
     }
 
-    private function getDefaultPort(String $driver): int
+    private function getDefaultPort(string $driver): int
     {
         switch ($driver) {
             case 'mysql':return 3306;
         }
     }
 
-    private function getDefaultAddress(String $driver): String
+    private function getDefaultAddress(string $driver): string
     {
         switch ($driver) {
             case 'mysql':return 'localhost';
         }
     }
 
-    private function getDriverDefaults(String $driver): array
+    private function getDriverDefaults(string $driver): array
     {
         return [
             'driver' => $driver,
         return $newValues;
     }
 
-    public function getDriver(): String
+    public function getDriver(): string
     {
         return $this->values['driver'];
     }
 
-    public function getAddress(): String
+    public function getAddress(): string
     {
         return $this->values['address'];
     }
         return $this->values['port'];
     }
 
-    public function getUsername(): String
+    public function getUsername(): string
     {
         return $this->values['username'];
     }
 
-    public function getPassword(): String
+    public function getPassword(): string
     {
         return $this->values['password'];
     }
 
-    public function getDatabase(): String
+    public function getDatabase(): string
     {
         return $this->values['database'];
     }
         return array_map('trim', explode(',', $this->values['controllers']));
     }
 
-    public function getCacheType(): String
+    public function getCacheType(): string
     {
         return $this->values['cacheType'];
     }
 
-    public function getCachePath(): String
+    public function getCachePath(): string
     {
         return $this->values['cachePath'];
     }
         return $this->values['cacheTime'];
     }
 
-    public function getDebug(): String
+    public function getDebug(): string
     {
         return $this->values['debug'];
     }

src/Tqdev/PhpCrudApi/Controller/ColumnController.php

 use Tqdev\PhpCrudApi\Column\ReflectionService;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class ColumnController

src/Tqdev/PhpCrudApi/Controller/RecordController.php

 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
 use Tqdev\PhpCrudApi\Record\RecordService;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class RecordController

src/Tqdev/PhpCrudApi/Controller/Responder.php

 
 class Responder
 {
-    public function error(int $error, String $argument, $details = null): Response
+    public function error(int $error, string $argument, $details = null): Response
     {
         $errorCode = new ErrorCode($error);
         $status = $errorCode->getStatus();

src/Tqdev/PhpCrudApi/Database/ColumnConverter.php

 {
     private $driver;
 
-    public function __construct(String $driver)
+    public function __construct(string $driver)
     {
         $this->driver = $driver;
     }
 
-    public function convertColumnValue(ReflectedColumn $column): String
+    public function convertColumnValue(ReflectedColumn $column): string
     {
         if ($column->isBinary()) {
             switch ($this->driver) {
         return '?';
     }
 
-    public function convertColumnName(ReflectedColumn $column, $value): String
+    public function convertColumnName(ReflectedColumn $column, $value): string
     {
         if ($column->isBinary()) {
             switch ($this->driver) {

src/Tqdev/PhpCrudApi/Database/ColumnsBuilder.php

     private $driver;
     private $converter;
 
-    public function __construct(String $driver)
+    public function __construct(string $driver)
     {
         $this->driver = $driver;
         $this->converter = new ColumnConverter($driver);
     }
 
-    public function getOffsetLimit(int $offset, int $limit): String
+    public function getOffsetLimit(int $offset, int $limit): string
     {
         if ($limit < 0 || $offset < 0) {
             return '';
         }
     }
 
-    private function quoteColumnName(ReflectedColumn $column): String
+    private function quoteColumnName(ReflectedColumn $column): string
     {
         return '"' . $column->getName() . '"';
     }
 
-    public function getOrderBy(ReflectedTable $table, array $columnOrdering): String
+    public function getOrderBy(ReflectedTable $table, array $columnOrdering): string
     {
-        if (count($columnOrdering)==0) {
+        if (count($columnOrdering) == 0) {
             return '';
         }
         $results = array();
             $quotedColumnName = $this->quoteColumnName($column);
             $results[] = $quotedColumnName . ' ' . $ordering;
         }
-        return ' ORDER BY '.implode(',', $results);
+        return ' ORDER BY ' . implode(',', $results);
     }
 
-    public function getSelect(ReflectedTable $table, array $columnNames): String
+    public function getSelect(ReflectedTable $table, array $columnNames): string
     {
         $results = array();
         foreach ($columnNames as $columnName) {
         return implode(',', $results);
     }
 
-    public function getInsert(ReflectedTable $table, array $columnValues): String
+    public function getInsert(ReflectedTable $table, array $columnValues): string
     {
         $columns = array();
         $values = array();
         }
     }
 
-    public function getUpdate(ReflectedTable $table, array $columnValues): String
+    public function getUpdate(ReflectedTable $table, array $columnValues): string
     {
         $results = array();
         foreach ($columnValues as $columnName => $columnValue) {
         return implode(',', $results);
     }
 
-    public function getIncrement(ReflectedTable $table, array $columnValues): String
+    public function getIncrement(ReflectedTable $table, array $columnValues): string
     {
         $results = array();
         foreach ($columnValues as $columnName => $columnValue) {

src/Tqdev/PhpCrudApi/Database/ConditionsBuilder.php

 {
     private $driver;
 
-    public function __construct(String $driver)
+    public function __construct(string $driver)
     {
         $this->driver = $driver;
     }
 
-    private function getConditionSql(Condition $condition, array &$arguments): String
+    private function getConditionSql(Condition $condition, array &$arguments): string
     {
         if ($condition instanceof AndCondition) {
             return $this->getAndConditionSql($condition, $arguments);
         throw new \Exception('Unknown Condition: ' . get_class($condition));
     }
 
-    private function getAndConditionSql(AndCondition $and, array &$arguments): String
+    private function getAndConditionSql(AndCondition $and, array &$arguments): string
     {
         $parts = [];
         foreach ($and->getConditions() as $condition) {
         return '(' . implode(' AND ', $parts) . ')';
     }
 
-    private function getOrConditionSql(OrCondition $or, array &$arguments): String
+    private function getOrConditionSql(OrCondition $or, array &$arguments): string
     {
         $parts = [];
         foreach ($or->getConditions() as $condition) {
         return '(' . implode(' OR ', $parts) . ')';
     }
 
-    private function getNotConditionSql(NotCondition $not, array &$arguments): String
+    private function getNotConditionSql(NotCondition $not, array &$arguments): string
     {
         $condition = $not->getCondition();
         return '(NOT ' . $this->getConditionSql($condition, $arguments) . ')';
     }
 
-    private function quoteColumnName(ReflectedColumn $column): String
+    private function quoteColumnName(ReflectedColumn $column): string
     {
         return '"' . $column->getName() . '"';
     }
 
-    private function escapeLikeValue(String $value): String
+    private function escapeLikeValue(string $value): string
     {
         return addcslashes($value, '%_');
     }
 
-    private function getColumnConditionSql(ColumnCondition $condition, array &$arguments): String
+    private function getColumnConditionSql(ColumnCondition $condition, array &$arguments): string
     {
         $column = $this->quoteColumnName($condition->getColumn());
         $operator = $condition->getOperator();
         return $sql;
     }
 
-    private function getSpatialFunctionName(String $operator): String
+    private function getSpatialFunctionName(string $operator): string
     {
         switch ($operator) {
             case 'co':return 'ST_Contains';
         }
     }
 
-    private function hasSpatialArgument(String $operator): bool
+    private function hasSpatialArgument(string $operator): bool
     {
         return in_array($operator, ['ic', 'is', 'iv']) ? false : true;
     }
 
-    private function getSpatialFunctionCall(String $functionName, String $column, bool $hasArgument): String
+    private function getSpatialFunctionCall(string $functionName, string $column, bool $hasArgument): string
     {
         switch ($this->driver) {
             case 'mysql':
         }
     }
 
-    private function getSpatialConditionSql(ColumnCondition $condition, array &$arguments): String
+    private function getSpatialConditionSql(ColumnCondition $condition, array &$arguments): string
     {
         $column = $this->quoteColumnName($condition->getColumn());
         $operator = $condition->getOperator();
         return $sql;
     }
 
-    public function getWhereClause(Condition $condition, array &$arguments): String
+    public function getWhereClause(Condition $condition, array &$arguments): string
     {
         if ($condition instanceof NoCondition) {
             return '';

src/Tqdev/PhpCrudApi/Database/DataConverter.php

 {
     private $driver;
 
-    public function __construct(String $driver)
+    public function __construct(string $driver)
     {
         $this->driver = $driver;
     }
         return $value;
     }
 
-    private function getRecordValueConversion(ReflectedColumn $column): String
+    private function getRecordValueConversion(ReflectedColumn $column): string
     {
         if (in_array($this->driver, ['mysql', 'sqlsrv']) && $column->isBoolean()) {
             return 'boolean';
         return $value;
     }
 
-    private function getInputValueConversion(ReflectedColumn $column): String
+    private function getInputValueConversion(ReflectedColumn $column): string
     {
         if ($column->isBinary()) {
             return 'base64url_to_base64';

src/Tqdev/PhpCrudApi/Database/GenericDB.php

     private $columns;
     private $converter;
 
-    private function getDsn(String $address, String $port = null, String $database = null): String
+    private function getDsn(string $address, string $port = null, string $database = null): string
     {
         switch ($this->driver) {
             case 'mysql':return "$this->driver:host=$address;port=$port;dbname=$database;charset=utf8mb4";
         }
     }
 
-    public function __construct(String $driver, String $address, String $port = null, String $database = null, String $username = null, String $password = null)
+    public function __construct(string $driver, string $address, string $port = null, string $database = null, string $username = null, string $password = null)
     {
         $this->driver = $driver;
         $this->database = $database;
         return $this->definition;
     }
 
-    private function addMiddlewareConditions(String $tableName, Condition $condition): Condition
+    private function addMiddlewareConditions(string $tableName, Condition $condition): Condition
     {
         $condition1 = VariableStore::get("authorization.conditions.$tableName");
         if ($condition1) {
         return $pkValue;
     }
 
-    public function selectSingle(ReflectedTable $table, array $columnNames, String $id) /*: ?array*/
+    public function selectSingle(ReflectedTable $table, array $columnNames, string $id) /*: ?array*/
     {
         $selectColumns = $this->columns->getSelect($table, $columnNames);
         $tableName = $table->getName();
         return $records;
     }
 
-    public function updateSingle(ReflectedTable $table, array $columnValues, String $id)
+    public function updateSingle(ReflectedTable $table, array $columnValues, string $id)
     {
         if (count($columnValues) == 0) {
             return 0;
         return $stmt->rowCount();
     }
 
-    public function deleteSingle(ReflectedTable $table, String $id)
+    public function deleteSingle(ReflectedTable $table, string $id)
     {
         $tableName = $table->getName();
         $condition = new ColumnCondition($table->getPk(), 'eq', $id);
         return $stmt->rowCount();
     }
 
-    public function incrementSingle(ReflectedTable $table, array $columnValues, String $id)
+    public function incrementSingle(ReflectedTable $table, array $columnValues, string $id)
     {
         if (count($columnValues) == 0) {
             return 0;
         return $stmt->rowCount();
     }
 
-    private function query(String $sql, array $parameters): \PDOStatement
+    private function query(string $sql, array $parameters): \PDOStatement
     {
         $stmt = $this->pdo->prepare($sql);
         //echo "- $sql -- " . json_encode($parameters, JSON_UNESCAPED_UNICODE) . "\n";

src/Tqdev/PhpCrudApi/Database/GenericDefinition.php

     private $typeConverter;
     private $reflection;
 
-    public function __construct(\PDO $pdo, String $driver, String $database)
+    public function __construct(\PDO $pdo, string $driver, string $database)
     {
         $this->pdo = $pdo;
         $this->driver = $driver;
         $this->reflection = new GenericReflection($pdo, $driver, $database);
     }
 
-    private function quote(String $identifier): String
+    private function quote(string $identifier): string
     {
         return '"' . str_replace('"', '', $identifier) . '"';
     }
 
-    public function getColumnType(ReflectedColumn $column, bool $update): String
+    public function getColumnType(ReflectedColumn $column, bool $update): string
     {
         if ($this->driver == 'pgsql' && !$update && $column->getPk() && $this->canAutoIncrement($column)) {
             return 'serial';
         return $type . $size . $null . $auto;
     }
 
-    private function getPrimaryKey(String $tableName): String
+    private function getPrimaryKey(string $tableName): string
     {
         $pks = $this->reflection->getTablePrimaryKeys($tableName);
         if (count($pks) == 1) {
         return in_array($column->getType(), ['integer', 'bigint']);
     }
 
-    private function getColumnAutoIncrement(ReflectedColumn $column, bool $update): String
+    private function getColumnAutoIncrement(ReflectedColumn $column, bool $update): string
     {
         if (!$this->canAutoIncrement($column)) {
             return '';
         }
     }
 
-    private function getColumnNullType(ReflectedColumn $column, bool $update): String
+    private function getColumnNullType(ReflectedColumn $column, bool $update): string
     {
         if ($this->driver == 'pgsql' && $update) {
             return '';
         return $column->getNullable() ? ' NULL' : ' NOT NULL';
     }
 
-    private function getTableRenameSQL(String $tableName, String $newTableName): String
+    private function getTableRenameSQL(string $tableName, string $newTableName): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($newTableName);
         }
     }
 
-    private function getColumnRenameSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getColumnRenameSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
         }
     }
 
-    private function getColumnRetypeSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getColumnRetypeSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
         }
     }
 
-    private function getSetColumnNullableSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getSetColumnNullableSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
         }
     }
 
-    private function getSetColumnPkConstraintSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getSetColumnPkConstraintSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
         }
     }
 
-    private function getSetColumnPkSequenceSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getSetColumnPkSequenceSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
         }
     }
 
-    private function getSetColumnPkSequenceStartSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getSetColumnPkSequenceStartSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
-        
+
         switch ($this->driver) {
             case 'mysql':
                 return "select 1";
         }
     }
 
-    private function getSetColumnPkDefaultSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getSetColumnPkDefaultSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
         }
     }
 
-    private function getAddColumnFkConstraintSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getAddColumnFkConstraintSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
         return "ALTER TABLE $p1 ADD CONSTRAINT $p3 FOREIGN KEY ($p2) REFERENCES $p4 ($p5)";
     }
 
-    private function getRemoveColumnFkConstraintSQL(String $tableName, String $columnName, ReflectedColumn $newColumn): String
+    private function getRemoveColumnFkConstraintSQL(string $tableName, string $columnName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($tableName . '_' . $columnName . '_fkey');
         }
     }
 
-    private function getAddTableSQL(ReflectedTable $newTable): String
+    private function getAddTableSQL(ReflectedTable $newTable): string
     {
         $tableName = $newTable->getName();
         $p1 = $this->quote($tableName);
         return "CREATE TABLE $p1 ($p2);";
     }
 
-    private function getAddColumnSQL(String $tableName, ReflectedColumn $newColumn): String
+    private function getAddColumnSQL(string $tableName, ReflectedColumn $newColumn): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($newColumn->getName());
         $p3 = $this->getColumnType($newColumn, false);
 
-        
         switch ($this->driver) {
             case 'mysql':
             case 'pgsql':
         }
     }
 
-    private function getRemoveTableSQL(String $tableName): String
+    private function getRemoveTableSQL(string $tableName): string
     {
         $p1 = $this->quote($tableName);
 
         }
     }
 
-    private function getRemoveColumnSQL(String $tableName, String $columnName): String
+    private function getRemoveColumnSQL(string $tableName, string $columnName): string
     {
         $p1 = $this->quote($tableName);
         $p2 = $this->quote($columnName);
 
-        
         switch ($this->driver) {
             case 'mysql':
             case 'pgsql':
         }
     }
 
-    public function renameTable(String $tableName, String $newTableName)
+    public function renameTable(string $tableName, string $newTableName)
     {
         $sql = $this->getTableRenameSQL($tableName, $newTableName);
         return $this->query($sql);
     }
 
-    public function renameColumn(String $tableName, String $columnName, ReflectedColumn $newColumn)
+    public function renameColumn(string $tableName, string $columnName, ReflectedColumn $newColumn)
     {
         $sql = $this->getColumnRenameSQL($tableName, $columnName, $newColumn);
         return $this->query($sql);
     }
 
-    public function retypeColumn(String $tableName, String $columnName, ReflectedColumn $newColumn)
+    public function retypeColumn(string $tableName, string $columnName, ReflectedColumn $newColumn)
     {
         $sql = $this->getColumnRetypeSQL($tableName, $columnName, $newColumn);
         return $this->query($sql);
     }
 
-    public function setColumnNullable(String $tableName, String $columnName, ReflectedColumn $newColumn)
+    public function setColumnNullable(string $tableName, string $columnName, ReflectedColumn $newColumn)
     {
         $sql = $this->getSetColumnNullableSQL($tableName, $columnName, $newColumn);
         return $this->query($sql);
     }
 
-    public function addColumnPrimaryKey(String $tableName, String $columnName, ReflectedColumn $newColumn)
+    public function addColumnPrimaryKey(string $tableName, string $columnName, ReflectedColumn $newColumn)
     {
         $sql = $this->getSetColumnPkConstraintSQL($tableName, $columnName, $newColumn);
         $this->query($sql);
         return true;
     }
 
-    public function removeColumnPrimaryKey(String $tableName, String $columnName, ReflectedColumn $newColumn)
+    public function removeColumnPrimaryKey(string $tableName, string $columnName, ReflectedColumn $newColumn)
     {
         if ($this->canAutoIncrement($newColumn)) {
             $sql = $this->getSetColumnPkDefaultSQL($tableName, $columnName, $newColumn);
         return true;
     }
 
-    public function addColumnForeignKey(String $tableName, String $columnName, ReflectedColumn $newColumn)
+    public function addColumnForeignKey(string $tableName, string $columnName, ReflectedColumn $newColumn)
     {
         $sql = $this->getAddColumnFkConstraintSQL($tableName, $columnName, $newColumn);
         return $this->query($sql);
     }
 
-    public function removeColumnForeignKey(String $tableName, String $columnName, ReflectedColumn $newColumn)
+    public function removeColumnForeignKey(string $tableName, string $columnName, ReflectedColumn $newColumn)
     {
         $sql = $this->getRemoveColumnFkConstraintSQL($tableName, $columnName, $newColumn);
         return $this->query($sql);
         return $this->query($sql);
     }
 
-    public function addColumn(String $tableName, ReflectedColumn $newColumn)
+    public function addColumn(string $tableName, ReflectedColumn $newColumn)
     {
         $sql = $this->getAddColumnSQL($tableName, $newColumn);
         return $this->query($sql);
     }
 
-    public function removeTable(String $tableName)
+    public function removeTable(string $tableName)
     {
         $sql = $this->getRemoveTableSQL($tableName);
         return $this->query($sql);
     }
 
-    public function removeColumn(String $tableName, String $columnName)
+    public function removeColumn(string $tableName, string $columnName)
     {
         $sql = $this->getRemoveColumnSQL($tableName, $columnName);
         return $this->query($sql);
     }
 
-    private function query(String $sql): bool
+    private function query(string $sql): bool
     {
         $stmt = $this->pdo->prepare($sql);
         //echo "- $sql -- []\n";

src/Tqdev/PhpCrudApi/Database/GenericReflection.php

     private $database;
     private $typeConverter;
 
-    public function __construct(\PDO $pdo, String $driver, String $database)
+    public function __construct(\PDO $pdo, string $driver, string $database)
     {
         $this->pdo = $pdo;
         $this->driver = $driver;
         }
     }
 
-    private function getTablesSQL(): String
+    private function getTablesSQL(): string
     {
         switch ($this->driver) {
             case 'mysql':return 'SELECT "TABLE_NAME", "TABLE_TYPE" FROM "INFORMATION_SCHEMA"."TABLES" WHERE "TABLE_TYPE" IN (\'BASE TABLE\' , \'VIEW\') AND "TABLE_SCHEMA" = ? ORDER BY BINARY "TABLE_NAME"';
         }
     }
 
-    private function getTableColumnsSQL(): String
+    private function getTableColumnsSQL(): string
     {
         switch ($this->driver) {
             case 'mysql':return 'SELECT "COLUMN_NAME", "IS_NULLABLE", "DATA_TYPE", "CHARACTER_MAXIMUM_LENGTH", "NUMERIC_PRECISION", "NUMERIC_SCALE" FROM "INFORMATION_SCHEMA"."COLUMNS" WHERE "TABLE_NAME" = ? AND "TABLE_SCHEMA" = ?';
         }
     }
 
-    private function getTablePrimaryKeysSQL(): String
+    private function getTablePrimaryKeysSQL(): string
     {
         switch ($this->driver) {
             case 'mysql':return 'SELECT "COLUMN_NAME" FROM "INFORMATION_SCHEMA"."KEY_COLUMN_USAGE" WHERE "CONSTRAINT_NAME" = \'PRIMARY\' AND "TABLE_NAME" = ? AND "TABLE_SCHEMA" = ?';
         }
     }
 
-    private function getTableForeignKeysSQL(): String
+    private function getTableForeignKeysSQL(): string
     {
         switch ($this->driver) {
             case 'mysql':return 'SELECT "COLUMN_NAME", "REFERENCED_TABLE_NAME" FROM "INFORMATION_SCHEMA"."KEY_COLUMN_USAGE" WHERE "REFERENCED_TABLE_NAME" IS NOT NULL AND "TABLE_NAME" = ? AND "TABLE_SCHEMA" = ?';
         }
     }
 
-    public function getDatabaseName(): String
+    public function getDatabaseName(): string
     {
         return $this->database;
     }
         return $results;
     }
 
-    public function getTableColumns(String $tableName, String $type): array
+    public function getTableColumns(string $tableName, string $type): array
     {
         $sql = $this->getTableColumnsSQL();
         $results = $this->query($sql, [$tableName, $this->database]);
         return $results;
     }
 
-    public function getTablePrimaryKeys(String $tableName): array
+    public function getTablePrimaryKeys(string $tableName): array
     {
         $sql = $this->getTablePrimaryKeysSQL();
         $results = $this->query($sql, [$tableName, $this->database]);
         return $primaryKeys;
     }
 
-    public function getTableForeignKeys(String $tableName): array
+    public function getTableForeignKeys(string $tableName): array
     {
         $sql = $this->getTableForeignKeysSQL();
         $results = $this->query($sql, [$tableName, $this->database]);
         return $foreignKeys;
     }
 
-    public function toJdbcType(String $type, int $size): String
+    public function toJdbcType(string $type, int $size): string
     {
         return $this->typeConverter->toJdbc($type, $size);
     }
 
-    private function query(String $sql, array $parameters): array
+    private function query(string $sql, array $parameters): array
     {
         $stmt = $this->pdo->prepare($sql);
         //echo "- $sql -- " . json_encode($parameters, JSON_UNESCAPED_UNICODE) . "\n";

src/Tqdev/PhpCrudApi/Database/TypeConverter.php

 {
     private $driver;
 
-    public function __construct(String $driver)
+    public function __construct(string $driver)
     {
         $this->driver = $driver;
     }
         'geometry' => true,
     ];
 
-    public function toJdbc(String $type, int $size): String
+    public function toJdbc(string $type, int $size): string
     {
         $jdbcType = strtolower($type);
         if (isset($this->toJdbc[$this->driver]["$jdbcType($size)"])) {
         return $jdbcType;
     }
 
-    public function fromJdbc(String $type): String
+    public function fromJdbc(string $type): string
     {
         $jdbcType = strtolower($type);
         if (isset($this->fromJdbc[$this->driver][$jdbcType])) {

src/Tqdev/PhpCrudApi/Middleware/AjaxOnlyMiddleware.php

 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class AjaxOnlyMiddleware extends Middleware
         if (!in_array($method, $excludeMethods)) {
             $headerName = $this->getProperty('headerName', 'X-Requested-With');
             $headerValue = $this->getProperty('headerValue', 'XMLHttpRequest');
-            if ($headerValue != $request->getHeader($headerName)) {
+            if ($headerValue != RequestUtils::getHeader($request, $headerName)) {
                 return $this->responder->error(ErrorCode::ONLY_AJAX_REQUESTS_ALLOWED, $method);
             }
         }

src/Tqdev/PhpCrudApi/Middleware/AuthorizationMiddleware.php

 use Tqdev\PhpCrudApi\Middleware\Communication\VariableStore;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\FilterInfo;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class AuthorizationMiddleware extends Middleware
         $this->reflection = $reflection;
     }
 
-    private function handleColumns(String $operation, String $tableName) /*: void*/
+    private function handleColumns(string $operation, string $tableName) /*: void*/
     {
         $columnHandler = $this->getProperty('columnHandler', '');
         if ($columnHandler) {
         }
     }
 
-    private function handleTable(String $operation, String $tableName) /*: void*/
+    private function handleTable(string $operation, string $tableName) /*: void*/
     {
         if (!$this->reflection->hasTable($tableName)) {
             return;
         }
     }
 
-    private function handleRecords(String $operation, String $tableName) /*: void*/
+    private function handleRecords(string $operation, string $tableName) /*: void*/
     {
         if (!$this->reflection->hasTable($tableName)) {
             return;

src/Tqdev/PhpCrudApi/Middleware/Base/Middleware.php

         $this->next = $handler;
     }
 
-    protected function getArrayProperty(String $key, String $default): array
+    protected function getArrayProperty(string $key, string $default): array
     {
         return array_filter(array_map('trim', explode(',', $this->getProperty($key, $default))));
     }
 
-    protected function getProperty(String $key, $default)
+    protected function getProperty(string $key, $default)
     {
         return isset($this->properties[$key]) ? $this->properties[$key] : $default;
     }

src/Tqdev/PhpCrudApi/Middleware/BasicAuthMiddleware.php

 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class BasicAuthMiddleware extends Middleware
 {
-    private function hasCorrectPassword(String $username, String $password, array &$passwords): bool
+    private function hasCorrectPassword(string $username, string $password, array &$passwords): bool
     {
         $hash = isset($passwords[$username]) ? $passwords[$username] : false;
         if ($hash && password_verify($password, $hash)) {
         return false;
     }
 
-    private function getValidUsername(String $username, String $password, String $passwordFile): String
+    private function getValidUsername(string $username, string $password, string $passwordFile): string
     {
         $passwords = $this->readPasswords($passwordFile);
         $valid = $this->hasCorrectPassword($username, $password, $passwords);
         return $valid ? $username : '';
     }
 
-    private function readPasswords(String $passwordFile): array
+    private function readPasswords(string $passwordFile): array
     {
         $passwords = [];
         $passwordLines = file($passwordFile);
         return $passwords;
     }
 
-    private function writePasswords(String $passwordFile, array $passwords): bool
+    private function writePasswords(string $passwordFile, array $passwords): bool
     {
         $success = false;
         $passwordFileContents = '';
         return $success;
     }
 
-    private function getAuthorizationCredentials(ServerRequestInterface $request): String
+    private function getAuthorizationCredentials(ServerRequestInterface $request): string
     {
         if (isset($_SERVER['PHP_AUTH_USER'])) {
             return $_SERVER['PHP_AUTH_USER'] . ':' . $_SERVER['PHP_AUTH_PW'];
         }
-        $parts = explode(' ', trim($request->getHeader('Authorization')), 2);
+        $header = RequestUtils::getHeader($request, 'Authorization');
+        $parts = explode(' ', trim($header), 2);
         if (count($parts) != 2) {
             return '';
         }

src/Tqdev/PhpCrudApi/Middleware/Communication/VariableStore.php

 {
     static $values = array();
 
-    public static function get(String $key)
+    public static function get(string $key)
     {
         if (isset(self::$values[$key])) {
             return self::$values[$key];
         return null;
     }
 
-    public static function set(String $key, /* object */ $value)
+    public static function set(string $key, /* object */ $value)
     {
         self::$values[$key] = $value;
     }

src/Tqdev/PhpCrudApi/Middleware/CorsMiddleware.php

 
 class CorsMiddleware extends Middleware
 {
-    private function isOriginAllowed(String $origin, String $allowedOrigins): bool
+    private function isOriginAllowed(string $origin, string $allowedOrigins): bool
     {
         $found = false;
         foreach (explode(',', $allowedOrigins) as $allowedOrigin) {

src/Tqdev/PhpCrudApi/Middleware/CustomizationMiddleware.php

 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class CustomizationMiddleware extends Middleware

src/Tqdev/PhpCrudApi/Middleware/FirewallMiddleware.php

 
 class FirewallMiddleware extends Middleware
 {
-    private function ipMatch(String $ip, String $cidr): bool
+    private function ipMatch(string $ip, string $cidr): bool
     {
         if (strpos($cidr, '/') !== false) {
             list($subnet, $mask) = explode('/', trim($cidr));
         return false;
     }
 
-    private function isIpAllowed(String $ipAddress, String $allowedIpAddresses): bool
+    private function isIpAllowed(string $ipAddress, string $allowedIpAddresses): bool
     {
         foreach (explode(',', $allowedIpAddresses) as $allowedIp) {
             if ($this->ipMatch($ipAddress, $allowedIp)) {

src/Tqdev/PhpCrudApi/Middleware/IpAddressMiddleware.php

 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class IpAddressMiddleware extends Middleware
         $this->reflection = $reflection;
     }
 
-    private function callHandler($record, String $operation, ReflectedTable $table) /*: object */
+    private function callHandler($record, string $operation, ReflectedTable $table) /*: object */
     {
         $context = (array) $record;
         $columnNames = $this->getProperty('columns', '');

src/Tqdev/PhpCrudApi/Middleware/JoinLimitsMiddleware.php

 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Communication\VariableStore;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class JoinLimitsMiddleware extends Middleware

src/Tqdev/PhpCrudApi/Middleware/JwtAuthMiddleware.php

 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class JwtAuthMiddleware extends Middleware
 {
-    private function getVerifiedClaims(String $token, int $time, int $leeway, int $ttl, String $secret, array $requirements): array
+    private function getVerifiedClaims(string $token, int $time, int $leeway, int $ttl, string $secret, array $requirements): array
     {
         $algorithms = array(
             'HS256' => 'sha256',
         return $claims;
     }
 
-    private function getClaims(String $token): array
+    private function getClaims(string $token): array
     {
         $time = (int) $this->getProperty('time', time());
         $leeway = (int) $this->getProperty('leeway', '5');
         return $this->getVerifiedClaims($token, $time, $leeway, $ttl, $secret, $requirements);
     }
 
-    private function getAuthorizationToken(ServerRequestInterface $request): String
+    private function getAuthorizationToken(ServerRequestInterface $request): string
     {
-        $header = $this->getProperty('header', 'X-Authorization');
-        $parts = explode(' ', trim($request->getHeader($header)), 2);
+        $headerName = $this->getProperty('header', 'X-Authorization');
+        $headerValue = RequestUtils::getHeader($request, $headerName);
+        $parts = explode(' ', trim($headerValue), 2);
         if (count($parts) != 2) {
             return '';
         }

src/Tqdev/PhpCrudApi/Middleware/MultiTenancyMiddleware.php

 use Tqdev\PhpCrudApi\Record\Condition\ColumnCondition;
 use Tqdev\PhpCrudApi\Record\Condition\Condition;
 use Tqdev\PhpCrudApi\Record\Condition\NoCondition;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class MultiTenancyMiddleware extends Middleware
         $this->reflection = $reflection;
     }
 
-    private function getCondition(String $tableName, array $pairs): Condition
+    private function getCondition(string $tableName, array $pairs): Condition
     {
         $condition = new NoCondition();
         $table = $this->reflection->getTable($tableName);
         return $condition;
     }
 
-    private function getPairs($handler, String $operation, String $tableName): array
+    private function getPairs($handler, string $operation, string $tableName): array
     {
         $result = array();
         $pairs = call_user_func($handler, $operation, $tableName);
         return $result;
     }
 
-    private function handleRecord(ServerRequestInterface $request, String $operation, array $pairs) /*: void*/
+    private function handleRecord(ServerRequestInterface $request, string $operation, array $pairs) /*: void*/
     {
         $record = $request->getBody();
         if ($record === null) {

src/Tqdev/PhpCrudApi/Middleware/PageLimitsMiddleware.php

 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class PageLimitsMiddleware extends Middleware

src/Tqdev/PhpCrudApi/Middleware/Router/Router.php

 
 interface Router extends Handler
 {
-    public function register(String $method, String $path, array $handler);
+    public function register(string $method, string $path, array $handler);
 
     public function load(Middleware $middleware);
 

src/Tqdev/PhpCrudApi/Middleware/Router/SimpleRouter.php

         return $tree;
     }
 
-    public function register(String $method, String $path, array $handler)
+    public function register(string $method, string $path, array $handler)
     {
         $routeNumber = count($this->routeHandlers);
         $this->routeHandlers[$routeNumber] = $handler;

src/Tqdev/PhpCrudApi/Middleware/SanitationMiddleware.php

 use Tqdev\PhpCrudApi\Controller\Responder;
 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class SanitationMiddleware extends Middleware
         $this->reflection = $reflection;
     }
 
-    private function callHandler($handler, $record, String $operation, ReflectedTable $table) /*: object */
+    private function callHandler($handler, $record, string $operation, ReflectedTable $table) /*: object */
     {
         $context = (array) $record;
         $tableName = $table->getName();

src/Tqdev/PhpCrudApi/Middleware/ValidationMiddleware.php

 use Tqdev\PhpCrudApi\Middleware\Base\Middleware;
 use Tqdev\PhpCrudApi\Middleware\Router\Router;
 use Tqdev\PhpCrudApi\Record\ErrorCode;
-use Tqdev\PhpCrudApi\Record\RequestUtils;
+use Tqdev\PhpCrudApi\RequestUtils;
 use Tqdev\PhpCrudApi\Response;
 
 class ValidationMiddleware extends Middleware
         $this->reflection = $reflection;
     }
 
-    private function callHandler($handler, $record, String $operation, ReflectedTable $table) /*: Response?*/
+    private function callHandler($handler, $record, string $operation, ReflectedTable $table) /*: Response?*/
     {
         $context = (array) $record;
         $details = array();

src/Tqdev/PhpCrudApi/Middleware/XsrfMiddleware.php

 
 class XsrfMiddleware extends Middleware
 {
-    private function getToken(): String
+    private function getToken(): string
     {
         $cookieName = $this->getProperty('cookieName', 'XSRF-TOKEN');
         if (isset($_COOKIE[$cookieName])) {

src/Tqdev/PhpCrudApi/OpenApi/OpenApiBuilder.php

         $this->openapi = new OpenApiDefinition($base);
     }
 
-    private function getServerUrl(): String
+    private function getServerUrl(): string
     {
         $protocol = @$_SERVER['HTTP_X_FORWARDED_PROTO'] ?: @$_SERVER['REQUEST_SCHEME'] ?: ((isset($_SERVER["HTTPS"]) && $_SERVER["HTTPS"] == "on") ? "https" : "http");
         $port = @intval($_SERVER['HTTP_X_FORWARDED_PORT']) ?: @intval($_SERVER["SERVER_PORT"]) ?: (($protocol === 'https') ? 443 : 80);
         return $this->openapi;
     }
 
-    private function isOperationOnTableAllowed(String $operation, String $tableName): bool
+    private function isOperationOnTableAllowed(string $operation, string $tableName): bool
     {
         $tableHandler = VariableStore::get('authorization.tableHandler');
         if (!$tableHandler) {
         return (bool) call_user_func($tableHandler, $operation, $tableName);
     }
 
-    private function isOperationOnColumnAllowed(String $operation, String $tableName, String $columnName): bool
+    private function isOperationOnColumnAllowed(string $operation, string $tableName, string $columnName): bool
     {
         $columnHandler = VariableStore::get('authorization.columnHandler');
         if (!$columnHandler) {
         return (bool) call_user_func($columnHandler, $operation, $tableName, $columnName);
     }
 
-    private function setPath(String $tableName) /*: void*/
+    private function setPath(string $tableName) /*: void*/
     {
         $table = $this->reflection->getTable($tableName);
         $type = $table->getType();
         }
     }
 
-    private function setComponentSchema(String $tableName, array $references) /*: void*/
+    private function setComponentSchema(string $tableName, array $references) /*: void*/
     {
         $table = $this->reflection->getTable($tableName);
         $type = $table->getType();
         }
     }
 
-    private function setComponentResponse(String $tableName) /*: void*/
+    private function setComponentResponse(string $tableName) /*: void*/
     {
         $table = $this->reflection->getTable($tableName);
         $type = $table->getType();
         }
     }
 
-    private function setComponentRequestBody(String $tableName) /*: void*/
+    private function setComponentRequestBody(string $tableName) /*: void*/
     {
         $table = $this->reflection->getTable($tableName);
         $type = $table->getType();
         $this->openapi->set("components|parameters|join|required", false);
     }
 
-    private function setTag(int $index, String $tableName) /*: void*/
+    private function setTag(int $index, string $tableName) /*: void*/
     {
         $this->openapi->set("tags|$index|name", "$tableName");
         $this->openapi->set("tags|$index|description", "$tableName operations");

src/Tqdev/PhpCrudApi/OpenApi/OpenApiDefinition.php

         $this->root = $base;
     }
 
-    public function set(String $path, $value) /*: void*/
+    public function set(string $path, $value) /*: void*/
     {
         $parts = explode('|', trim($path, '|'));
         $current = &$this->root;
         $current = $value;
     }
 
-    public function has(String $path): bool
+    public function has(string $path): bool
     {
         $parts = explode('|', trim($path, '|'));
         $current = &$this->root;

src/Tqdev/PhpCrudApi/Record/ColumnIncluder.php

 class ColumnIncluder
 {
 
-    private function isMandatory(String $tableName, String $columnName, array $params): bool
+    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,
+    private function select(string $tableName, bool $primaryTable, array $params, string $paramName,
         array $columnNames, bool $include): array{
         if (!isset($params[$paramName])) {
             return $columnNames;

src/Tqdev/PhpCrudApi/Record/Condition/ColumnCondition.php

     private $operator;
     private $value;
 
-    public function __construct(ReflectedColumn $column, String $operator, String $value)
+    public function __construct(ReflectedColumn $column, string $operator, string $value)
     {
         $this->column = $column;
         $this->operator = $operator;
         return $this->column;
     }
 
-    public function getOperator(): String
+    public function getOperator(): string
     {
         return $this->operator;
     }
 
-    public function getValue(): String
+    public function getValue(): string
     {
         return $this->value;
     }

src/Tqdev/PhpCrudApi/Record/Condition/Condition.php

         return new NotCondition($this);
     }
 
-    public static function fromString(ReflectedTable $table, String $value): Condition
+    public static function fromString(ReflectedTable $table, string $value): Condition
     {
         $condition = new NoCondition();
         $parts = explode(',', $value, 3);

src/Tqdev/PhpCrudApi/Record/Document/ErrorDocument.php

     public $message;
     public $details;
 
-    public function __construct(ErrorCode $errorCode, String $argument, $details)
+    public function __construct(ErrorCode $errorCode, string $argument, $details)
     {
         $this->code = $errorCode->getCode();
         $this->message = $errorCode->getMessage($argument);
         return $this->code;
     }
 
-    public function getMessage(): String
+    public function getMessage(): string
     {
         return $this->message;
     }

src/Tqdev/PhpCrudApi/Record/ErrorCode.php

         return $this->code;
     }
 
-    public function getMessage(String $argument): String
+    public function getMessage(string $argument): string
     {
         return sprintf($this->message, $argument);
     }

src/Tqdev/PhpCrudApi/Record/PathTree.php

         return $this->tree->values;
     }
 
-    public function get(String $key): PathTree
+    public function get(string $key): PathTree
     {
         if (!isset($this->tree->branches->$key)) {
             return null;

src/Tqdev/PhpCrudApi/Record/RecordService.php

         $this->pagination = new PaginationInfo();
     }
 
-    private function sanitizeRecord(String $tableName, /* object */ $record, String $id)
+    private function sanitizeRecord(string $tableName, /* object */ $record, string $id)
     {
         $keyset = array_keys((array) $record);
         foreach ($keyset as $key) {
         }
     }
 
-    public function hasTable(String $table): bool
+    public function hasTable(string $table): bool
     {
         return $this->reflection->hasTable($table);
     }
 
-    public function getType(String $table): String
+    public function getType(string $table): string
     {
         return $this->reflection->getType($table);
     }
 
-    public function create(String $tableName, /* object */ $record, array $params)
+    public function create(string $tableName, /* object */ $record, array $params)
     {
         $this->sanitizeRecord($tableName, $record, '');
         $table = $this->reflection->getTable($tableName);
         return $this->db->createSingle($table, $columnValues);
     }
 
-    public function read(String $tableName, String $id, array $params) /*: ?object*/
+    public function read(string $tableName, string $id, array $params) /*: ?object*/
     {
         $table = $this->reflection->getTable($tableName);
         $this->joiner->addMandatoryColumns($table, $params);
         return $records[0];
     }
 
-    public function update(String $tableName, String $id, /* object */ $record, array $params)
+    public function update(string $tableName, string $id, /* object */ $record, array $params)
     {
         $this->sanitizeRecord($tableName, $record, $id);
         $table = $this->reflection->getTable($tableName);
         return $this->db->updateSingle($table, $columnValues, $id);
     }
 
-    public function delete(String $tableName, String $id, array $params)
+    public function delete(string $tableName, string $id, array $params)
     {
         $table = $this->reflection->getTable($tableName);
         return $this->db->deleteSingle($table, $id);
     }
 
-    public function increment(String $tableName, String $id, /* object */ $record, array $params)
+    public function increment(string $tableName, string $id, /* object */ $record, array $params)
     {
         $this->sanitizeRecord($tableName, $record, $id);
         $table = $this->reflection->getTable($tableName);
         return $this->db->incrementSingle($table, $columnValues, $id);
     }
 
-    public function _list(String $tableName, array $params): ListDocument
+    public function _list(string $tableName, array $params): ListDocument
     {
         $table = $this->reflection->getTable($tableName);
         $this->joiner->addMandatoryColumns($table, $params);

src/Tqdev/PhpCrudApi/Record/RequestUtils.php

-<?php
-namespace Tqdev\PhpCrudApi\Record;
-
-use Psr\Http\Message\ServerRequestInterface;
-use Tqdev\PhpCrudApi\Column\ReflectionService;
-
-class RequestUtils
-{
-    public static function getParams(ServerRequestInterface $request): array
-    {
-        $params = array();
-        $query = $request->getUri()->getQuery();
-        $query = str_replace('][]=', ']=', str_replace('=', '[]=', $query));
-        parse_str($query, $params);
-        return $params;
-    }
-
-    public static function getPathSegment(ServerRequestInterface $request, int $part): String
-    {
-        $pathSegments = explode('/', rtrim($request->getUri()->getPath(), '/'));
-        if ($part < 0 || $part >= count($pathSegments)) {
-            return '';
-        }
-        return $pathSegments[$part];
-    }
-
-    public static function getOperation(ServerRequestInterface $request): String
-    {
-        $method = $request->getMethod();
-        $path = RequestUtils::getPathSegment($request, 1);
-        $hasPk = RequestUtils::getPathSegment($request, 3) != '';
-        switch ($path) {
-            case 'openapi':
-                return 'document';
-            case 'columns':
-                return $method == 'get' ? 'reflect' : 'remodel';
-            case 'records':
-                switch ($method) {
-                    case 'POST':
-                        return 'create';
-                    case 'GET':
-                        return $hasPk ? 'read' : 'list';
-                    case 'PUT':
-                        return 'update';
-                    case 'DELETE':
-                        return 'delete';
-                    case 'PATCH':
-                        return 'increment';
-                }
-        }
-        return 'unknown';
-    }
-
-    private static function getJoinTables(String $tableName, array $parameters): array
-    {
-        $uniqueTableNames = array();
-        $uniqueTableNames[$tableName] = true;
-        if (isset($parameters['join'])) {
-            foreach ($parameters['join'] as $parameter) {
-                $tableNames = explode(',', trim($parameter));
-                foreach ($tableNames as $tableName) {
-                    $uniqueTableNames[$tableName] = true;
-                }
-            }
-        }
-        return array_keys($uniqueTableNames);
-    }
-
-    public static function getTableNames(ServerRequestInterface $request, ReflectionService $reflection): array
-    {
-        $path = RequestUtils::getPathSegment($request, 1);
-        $tableName = RequestUtils::getPathSegment($request, 2);
-        $allTableNames = $reflection->getTableNames();
-        switch ($path) {
-            case 'openapi':
-                return $allTableNames;
-            case 'columns':
-                return $tableName ? [$tableName] : $allTableNames;
-            case 'records':
-                return self::getJoinTables($tableName, RequestUtils::getParams($request));
-        }
-        return $allTableNames;
-    }
-
-}

src/Tqdev/PhpCrudApi/Request.old

     private $headers;
     private $highPerformance;
 
-    public function __construct(String $method = null, String $path = null, String $query = null, array $headers = null, String $body = null, bool $highPerformance = true)
+    public function __construct(string $method = null, string $path = null, string $query = null, array $headers = null, string $body = null, bool $highPerformance = true)
     {
         $this->parseMethod($method);
         $this->parsePath($path);
         $this->highPerformance = $highPerformance;
     }
 
-    private function parseMethod(String $method = null)
+    private function parseMethod(string $method = null)
     {
         if (!$method) {
             if (isset($_SERVER['REQUEST_METHOD'])) {
         $this->method = $method;
     }
 
-    private function parsePath(String $path = null)
+    private function parsePath(string $path = null)
     {
         if (!$path) {
             if (isset($_SERVER['PATH_INFO'])) {
         $this->pathSegments = explode('/', $path);
     }
 
-    private function parseParams(String $query = null)
+    private function parseParams(string $query = null)
     {
         if (!$query) {
             if (isset($_SERVER['QUERY_STRING'])) {
         $this->headers = $headers;
     }
 
-    private function decodeBody(String $body) /*: ?object*/
+    private function decodeBody(string $body) /*: ?object*/
     {
         $first = substr($body, 0, 1);
         if ($first == '[' || $first == '{') {
         return $object;
     }
 
-    private function parseBody(String $body = null) /*: void*/
+    private function parseBody(string $body = null) /*: void*/
     {
         if (!$body) {
             $body = file_get_contents('php://input');
         $this->body = $this->decodeBody($body);
     }
 
-    public function getMethod(): String
+    public function getMethod(): string
     {
         return $this->method;
     }
 
-    public function getPath(): String
+    public function getPath(): string
     {
         return $this->path;
     }
 
-    public function getPathSegment(int $part): String
+    public function getPathSegment(int $part): string
     {
         if ($part < 0 || $part >= count($this->pathSegments)) {
             return '';
         $this->body = $body;
     }
 
-    public function addHeader(String $key, String $value)
+    public function addHeader(string $key, string $value)
     {
         $this->headers[$key] = $value;
     }
 
-    public function getHeader(String $key): String
+    public function getHeader(string $key): string
     {
         if (isset($this->headers[$key])) {
             return $this->headers[$key];
         return $this->headers;
     }
 
-    public static function fromString(String $request): Request
+    public static function fromString(string $request): Request
     {
         $parts = explode("\n\n", trim($request), 2);
         $head = $parts[0];

src/Tqdev/PhpCrudApi/RequestFactory.php

         return $creator->fromGlobals();
     }
 
-    public static function fromString(String $request): ServerRequestInterface
+    public static function fromString(string $request): ServerRequestInterface
     {
         $parts = explode("\n\n", trim($request), 2);
         $lines = explode("\n", $parts[0]);

src/Tqdev/PhpCrudApi/Response.php

         return $this->status;
     }
 
-    public function getBody(): String
+    public function getBody(): string
     {
         return $this->body;
     }
 
-    public function addHeader(String $key, String $value)
+    public function addHeader(string $key, string $value)
     {
         $this->headers[$key] = $value;
     }
 
-    public function getHeader(String $key): String
+    public function getHeader(string $key): string
     {
         if (isset($this->headers[$key])) {
             return $this->headers[$key];
         $this->addHeader('X-Exception-File', $e->getFile() . ':' . $e->getLine());
     }
 
-    public function __toString(): String
+    public function __toString(): string
     {
         $str = "$this->status\n";
         foreach ($this->headers as $key => $value) {