Elgato_dark/appwrite
1
0
Fork 0
mirror of https://github.com/appwrite/appwrite synced 2026-05-23 08:58:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge pull request #3697 from appwrite/feat-response-filters-0.16.x

Browse source 
Feat response and request filters 0.16.x
This commit is contained in:
Christy Jacob 2022-09-14 02:52:07 +04:00 committed by GitHub
commit cdb54bcc72
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 3503 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
app/controllers/general.php
View file

@ -21,6 +21,7 @@ use Appwrite\Utopia\Response\Filters\V11 as ResponseV11;
use Appwrite\Utopia\Response\Filters\V12 as ResponseV12;
use Appwrite\Utopia\Response\Filters\V13 as ResponseV13;
use Appwrite\Utopia\Response\Filters\V14 as ResponseV14;
use Appwrite\Utopia\Response\Filters\V15 as ResponseV15;
use Utopia\CLI\Console;
use Utopia\Database\Database;
use Utopia\Database\DateTime;
@ -31,6 +32,7 @@ use Utopia\Validator\Hostname;
use Appwrite\Utopia\Request\Filters\V12 as RequestV12;
use Appwrite\Utopia\Request\Filters\V13 as RequestV13;
use Appwrite\Utopia\Request\Filters\V14 as RequestV14;
use Appwrite\Utopia\Request\Filters\V15 as RequestV15;
use Utopia\Validator\Text;
use Utopia\Validator\WhiteList;
@ -68,6 +70,9 @@ App::init()
case version_compare($requestFormat, '0.14.0', '<'):
Request::setFilter(new RequestV14());
break;
case version_compare($requestFormat, '0.15.3', '<'):
Request::setFilter(new RequestV15());
break;
default:
Request::setFilter(null);
}
@ -194,6 +199,9 @@ App::init()
case version_compare($responseFormat, '0.14.0', '<='):
Response::setFilter(new ResponseV14());
break;
case version_compare($responseFormat, '0.15.3', '<='):
Response::setFilter(new ResponseV15());
break;
default:
Response::setFilter(null);
}

16
composer.lock generated
View file

@ -4812,16 +4812,16 @@
},
{
"name": "sebastian/type",
"version": "3.1.0",
"version": "3.2.0",
"source": {
"type": "git",
"url": "https://github.com/sebastianbergmann/type.git",
"reference": "fb44e1cc6e557418387ad815780360057e40753e"
"reference": "fb3fe09c5f0bae6bc27ef3ce933a1e0ed9464b6e"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/sebastianbergmann/type/zipball/fb44e1cc6e557418387ad815780360057e40753e",
"reference": "fb44e1cc6e557418387ad815780360057e40753e",
"url": "https://api.github.com/repos/sebastianbergmann/type/zipball/fb3fe09c5f0bae6bc27ef3ce933a1e0ed9464b6e",
"reference": "fb3fe09c5f0bae6bc27ef3ce933a1e0ed9464b6e",
"shasum": ""
},
"require": {
@ -4833,7 +4833,7 @@
"type": "library",
"extra": {
"branch-alias": {
"dev-master": "3.1-dev"
"dev-master": "3.2-dev"
}
},
"autoload": {
@ -4856,7 +4856,7 @@
"homepage": "https://github.com/sebastianbergmann/type",
"support": {
"issues": "https://github.com/sebastianbergmann/type/issues",
"source": "https://github.com/sebastianbergmann/type/tree/3.1.0"
"source": "https://github.com/sebastianbergmann/type/tree/3.2.0"
},
"funding": [
{
@ -4864,7 +4864,7 @@
"type": "github"
}
],
"time": "2022-08-29T06:55:37+00:00"
"time": "2022-09-12T14:47:03+00:00"
},
{
"name": "sebastian/version",
@ -5384,5 +5384,5 @@
"platform-overrides": {
"php": "8.0"
},
"plugin-api-version": "2.3.0"
"plugin-api-version": "2.2.0"
}

275
src/Appwrite/Utopia/Request/Filters/V15.php Normal file
View file

@ -0,0 +1,275 @@
<?php
namespace Appwrite\Utopia\Request\Filters;
use Appwrite\Utopia\Request\Filter;
use Utopia\Database\Database;
use Utopia\Database\Permission;
use Utopia\Database\Query;
use Utopia\Database\Role;
class V15 extends Filter
{
// Convert 0.15 params format to 0.16 format
public function parse(array $content, string $model): array
{
switch ($model) {
case 'account.listLogs':
case 'databases.listLogs':
case 'databases.listCollectionLogs':
case 'databases.listDocumentLogs':
case 'teams.listLogs':
case 'users.listLogs':
$content = $this->convertLimitAndOffset($content);
break;
case 'account.initials':
unset($content['color']);
break;
case 'databases.list':
case 'databases.listCollections':
case 'functions.list':
case 'functions.listDeployments':
case 'projects.list':
case 'storage.listBuckets':
case 'storage.listFiles':
case 'teams.list':
case 'teams.listMemberships':
case 'users.list':
$content = $this->convertLimitAndOffset($content);
$content = $this->convertCursor($content);
$content = $this->convertOrderType($content);
break;
case 'databases.createCollection':
case 'databases.updateCollection':
$content = $this->convertCollectionPermission($content);
$content = $this->convertReadWrite($content);
break;
case 'databases.createDocument':
case 'databases.updateDocument':
case 'storage.createFile':
case 'storage.updateFile':
$content = $this->convertReadWrite($content);
break;
case 'databases.listDocuments':
$content = $this->convertFilters($content);
$content = $this->convertLimitAndOffset($content);
$content = $this->convertCursor($content);
$content = $this->convertOrders($content);
break;
case 'functions.create':
case 'functions.update':
$content = $this->convertExecute($content);
break;
case 'functions.listExecutions':
$content = $this->convertLimitAndOffset($content);
$content = $this->convertCursor($content);
break;
case 'projects.createKey':
case 'projects.updateKey':
$content = $this->convertExpire($content);
break;
case 'storage.createBucket':
case 'storage.updateBucket':
$content = $this->convertBucketPermission($content);
$content = $this->convertReadWrite($content);
break;
}
return $content;
}
protected function convertLimitAndOffset($content)
{
if (isset($content['limit'])) {
$content['queries'][] = 'limit(' . $content['limit'] . ')';
}
if (isset($content['offset'])) {
$content['queries'][] = 'offset(' . $content['offset'] . ')';
}
unset($content['limit']);
unset($content['offset']);
return $content;
}
protected function convertCursor($content)
{
if (isset($content['cursor'])) {
$cursorDirection = $content['cursorDirection'] ?? Database::CURSOR_AFTER;
if ($cursorDirection === Database::CURSOR_BEFORE) {
$content['queries'][] = 'cursorBefore("' . $content["cursor"] . '")';
} else {
$content['queries'][] = 'cursorAfter("' . $content["cursor"] . '")';
}
}
unset($content['cursor']);
unset($content['cursorDirection']);
return $content;
}
protected function convertOrderType($content)
{
if (isset($content['orderType'])) {
if ($content['orderType'] === Database::ORDER_DESC) {
$content['queries'][] = 'orderDesc("")';
} else {
$content['queries'][] = 'orderAsc("")';
}
}
unset($content['orderType']);
return $content;
}
protected function convertOrders($content)
{
if (isset($content['orderTypes'])) {
foreach ($content['orderTypes'] as $i => $type) {
$attribute = $content['orderAttributes'][$i] ?? '';
if ($type === Database::ORDER_DESC) {
$content['queries'][] = 'orderDesc("' . $attribute . '")';
} else {
$content['queries'][] = 'orderAsc("' . $attribute . '")';
}
}
}
unset($content['orderAttributes']);
unset($content['orderTypes']);
return $content;
}
protected function convertCollectionPermission($content)
{
if (isset($content['permission'])) {
$content['documentSecurity'] = $content['permission'] === 'document';
}
unset($content['permission']);
return $content;
}
protected function convertReadWrite($content)
{
if (isset($content['read'])) {
foreach ($content['read'] as $read) {
if ($read === 'role:all') {
$content['permissions'][] = Permission::read(Role::any());
} elseif ($read === 'role:guest') {
$content['permissions'][] = Permission::read(Role::guests());
} elseif ($read === 'role:member') {
$content['permissions'][] = Permission::read(Role::users());
} elseif (str_contains($read, ':')) {
$content['permissions'][] = Permission::read(Role::parse($read));
}
}
}
if (isset($content['write'])) {
foreach ($content['write'] as $write) {
if ($write === 'role:all' || $write === 'role:member') {
$content['permissions'][] = Permission::write(Role::users());
} elseif ($write === 'role:guest') {
// don't add because, historically,
// role:guest for write did nothing
} elseif (str_contains($write, ':')) {
$content['permissions'][] = Permission::write(Role::parse($write));
}
}
}
unset($content['read']);
unset($content['write']);
return $content;
}
protected function convertFilters($content)
{
if (!isset($content['queries'])) {
return $content;
}
$operations = [
'equal' => Query::TYPE_EQUAL,
'notEqual' => Query::TYPE_NOTEQUAL,
'lesser' => Query::TYPE_LESSER,
'lesserEqual' => Query::TYPE_LESSEREQUAL,
'greater' => Query::TYPE_GREATER,
'greaterEqual' => Query::TYPE_GREATEREQUAL,
'search' => Query::TYPE_SEARCH,
];
foreach ($content['queries'] as $i => $query) {
foreach ($operations as $oldOperation => $newOperation) {
$middle = ".$oldOperation(";
if (str_contains($query, $middle)) {
$parts = explode($middle, $query);
if (count($parts) > 1) {
$attribute = $parts[0];
$value = rtrim($parts[1], ")");
$content['queries'][$i] = $newOperation . '("' . $attribute . '", [' . $value . '])';
}
}
}
}
return $content;
}
protected function convertExecute($content)
{
if (!isset($content['execute'])) {
return $content;
}
$execute = [];
foreach ($content['execute'] as $role) {
if ($role === 'role:all' || $role === 'role:member') {
$execute[] = Role::users()->toString();
} elseif ($role === 'role:guest') {
// don't add because, historically,
// role:guest for write did nothing
} elseif (str_contains($role, ':')) {
$execute[] = $role;
}
}
$content['execute'] = $execute;
return $content;
}
protected function convertExpire($content)
{
if (!isset($content['expire'])) {
return $content;
}
$expire = (int) $content['expire'];
if ($expire === 0) {
$content['expire'] = null;
} else {
$content['expire'] = date(\DateTime::RFC3339_EXTENDED, $expire);
}
return $content;
}
protected function convertBucketPermission($content)
{
if (isset($content['permission'])) {
$content['fileSecurity'] = $content['permission'] === 'file';
}
unset($content['permission']);
return $content;
}
}

577
src/Appwrite/Utopia/Response/Filters/V15.php Normal file
View file

@ -0,0 +1,577 @@
<?php
namespace Appwrite\Utopia\Response\Filters;
use Appwrite\Utopia\Response;
use Appwrite\Utopia\Response\Filter;
use Utopia\Database\Database;
use Utopia\Database\Permission;
use Utopia\Database\Role;
class V15 extends Filter
{
// Convert 0.16 Data format to 0.15 format
public function parse(array $content, string $model): array
{
$parsedResponse = $content;
switch ($model) {
case Response::MODEL_ACCOUNT:
case Response::MODEL_USER:
$parsedResponse = $this->parseUser($parsedResponse);
break;
case Response::MODEL_USER_LIST:
$listKey = 'users';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseUser($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_METRIC:
$parsedResponse = $this->parseMetric($parsedResponse);
break;
case Response::MODEL_BUILD:
$parsedResponse = $this->parseBuild($parsedResponse);
break;
case Response::MODEL_BUILD_LIST:
$listKey = 'builds';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseBuild($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_BUCKET:
$parsedResponse = $this->parseBucket($parsedResponse);
break;
case Response::MODEL_BUCKET_LIST:
$listKey = 'buckets';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseBucket($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_COLLECTION:
$parsedResponse = $this->parseCollection($parsedResponse);
break;
case Response::MODEL_COLLECTION_LIST:
$listKey = 'collections';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseCollection($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_DATABASE:
case Response::MODEL_DEPLOYMENT:
case Response::MODEL_DOMAIN:
case Response::MODEL_PLATFORM:
case Response::MODEL_PROJECT:
case Response::MODEL_TEAM:
case Response::MODEL_WEBHOOK:
$parsedResponse = $this->parseCreatedAtUpdatedAt($parsedResponse);
break;
case Response::MODEL_DATABASE_LIST:
case Response::MODEL_DEPLOYMENT_LIST:
case Response::MODEL_DOMAIN_LIST:
case Response::MODEL_PLATFORM_LIST:
case Response::MODEL_PROJECT_LIST:
case Response::MODEL_TEAM_LIST:
case Response::MODEL_WEBHOOK_LIST:
$listKey = '';
switch ($model) {
case Response::MODEL_DATABASE_LIST:
$listKey = 'databases';
break;
case Response::MODEL_DEPLOYMENT_LIST:
$listKey = 'deployments';
break;
case Response::MODEL_DOMAIN_LIST:
$listKey = 'domains';
break;
case Response::MODEL_PLATFORM_LIST:
$listKey = 'platforms';
break;
case Response::MODEL_PROJECT_LIST:
$listKey = 'projects';
break;
case Response::MODEL_TEAM_LIST:
$listKey = 'teams';
break;
case Response::MODEL_WEBHOOK_LIST:
$listKey = 'webhooks';
break;
}
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseCreatedAtUpdatedAt($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_DOCUMENT:
case Response::MODEL_FILE:
$parsedResponse = $this->parsePermissionsCreatedAtUpdatedAt($parsedResponse);
break;
case Response::MODEL_DOCUMENT_LIST:
case Response::MODEL_FILE_LIST:
$listKey = '';
switch ($model) {
case Response::MODEL_DOCUMENT_LIST:
$listKey = 'documents';
break;
case Response::MODEL_FILE_LIST:
$listKey = 'files';
break;
}
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parsePermissionsCreatedAtUpdatedAt($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_EXECUTION:
$parsedResponse = $this->parseExecution($parsedResponse);
break;
case Response::MODEL_EXECUTION_LIST:
$listKey = 'executions';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseExecution($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_FUNCTION:
$parsedResponse = $this->parseFunction($parsedResponse);
break;
case Response::MODEL_FUNCTION_LIST:
$listKey = 'functions';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseFunction($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_KEY:
$parsedResponse = $this->parseKey($parsedResponse);
break;
case Response::MODEL_KEY_LIST:
$listKey = 'keys';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseKey($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_LOG:
$parsedResponse = $this->parseLog($parsedResponse);
break;
case Response::MODEL_LOG_LIST:
$listKey = 'logs';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseLog($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_MEMBERSHIP:
$parsedResponse = $this->parseMembership($parsedResponse);
break;
case Response::MODEL_MEMBERSHIP_LIST:
$listKey = 'memberships';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseMembership($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_SESSION:
$parsedResponse = $this->parseSession($parsedResponse);
break;
case Response::MODEL_SESSION_LIST:
$listKey = 'sessions';
$parsedResponse[$listKey] = array_map(fn ($content) => $this->parseSession($content), $parsedResponse[$listKey]);
break;
case Response::MODEL_TOKEN:
$parsedResponse = $this->parseDatetimeAttributes($parsedResponse, ['$createdAt', 'expire']);
break;
case Response::MODEL_USAGE_DATABASES:
$parsedResponse = $this->parseUsageDatabases($parsedResponse);
break;
case Response::MODEL_USAGE_DATABASE:
$parsedResponse = $this->parseUsageDatabase($parsedResponse);
break;
case Response::MODEL_USAGE_COLLECTION:
$parsedResponse = $this->parseUsageCollection($parsedResponse);
break;
case Response::MODEL_USAGE_USERS:
$parsedResponse = $this->parseUsageUsers($parsedResponse);
break;
case Response::MODEL_USAGE_BUCKETS:
$parsedResponse = $this->parseUsageBuckets($parsedResponse);
break;
case Response::MODEL_USAGE_FUNCTIONS:
$parsedResponse = $this->parseUsageFuncs($parsedResponse);
break;
case Response::MODEL_USAGE_PROJECT:
$parsedResponse = $this->parseUsageProject($parsedResponse);
break;
case Response::MODEL_USAGE_STORAGE:
$parsedResponse = $this->parseUsageStorage($parsedResponse);
break;
}
return $parsedResponse;
}
protected function parseBuild(array $content)
{
$content = $this->parseDatetimeAttributes($content, ['startTime', 'endTime']);
return $content;
}
protected function parseBucket(array $content)
{
if (isset($content['fileSecurity'])) {
if ($content['fileSecurity']) {
$content['permission'] = 'file';
} else {
$content['permission'] = 'bucket';
}
}
unset($content['fileSecurity']);
unset($content['compression']);
$content = $this->parsePermissions($content);
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt']);
return $content;
}
protected function parseDatetimeAttributes(array $content, array $attributes): array
{
foreach ($attributes as $attribute) {
if (isset($content[$attribute])) {
$content[$attribute] = strtotime($content[$attribute]);
}
}
return $content;
}
protected function parseUser(array $content): array
{
unset($content['password']);
unset($content['hash']);
unset($content['hashOptions']);
$content = $this->parseDatetimeAttributes($content, ['registration', 'passwordUpdate', '$createdAt', '$updatedAt']);
return $content;
}
protected function parseMetric(array $content)
{
$content = $this->parseDatetimeAttributes($content, ['date']);
return $content;
}
protected function parsePermissions(array $content)
{
if (!isset($content['$permissions'])) {
return $content;
}
$read = [];
$write = [];
// downgrade the permissions
foreach ($content['$permissions'] as $permission) {
$permission = Permission::parse($permission);
$permission_value = $permission->getRole();
if ($permission->getIdentifier()) {
$permission_value .= ':' . $permission->getIdentifier();
}
if ($permission->getDimension()) {
$permission_value .= '/' . $permission->getDimension();
}
// Old type permissions meant that 'write' is equivalent to 'create', 'update' and 'delete'
switch ($permission->getPermission()) {
case Database::PERMISSION_UPDATE:
case Database::PERMISSION_DELETE:
case Database::PERMISSION_WRITE:
case Database::PERMISSION_CREATE:
$write[$this->parseRole($permission_value)] = true;
break;
case Database::PERMISSION_READ:
$read[$this->parseRole($permission_value)] = true;
break;
}
}
$content['$read'] = array_keys($read);
$content['$write'] = array_keys($write);
unset($content['$permissions']);
return $content;
}
protected function parseRole(string $role)
{
switch ($role) {
case Role::any()->toString():
return 'role:all';
case Role::users()->toString():
return 'role:member';
case Role::guests()->toString():
return 'role:guest';
default:
return $role;
}
return $role;
}
protected function parseCollection(array $content)
{
if (isset($content['documentSecurity'])) {
if ($content['documentSecurity']) {
$content['permission'] = 'document';
} else {
$content['permission'] = 'collection';
}
}
unset($content['documentSecurity']);
$content = $this->parsePermissions($content);
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt']);
return $content;
}
protected function parsePermissionsCreatedAtUpdatedAt(array $content)
{
$content = $this->parsePermissions($content);
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt']);
return $content;
}
private function parseExecution($content)
{
unset($content['stdout']);
if (isset($content['$permissions'])) {
$read = [];
foreach ($content['$permissions'] as $role) {
$read[] = $this->parseRole($role);
}
$content['$read'] = $read;
unset($content['$permissions']);
}
if (isset($content['duration'])) {
$content['time'] = $content['duration'];
unset($content['duration']);
}
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt']);
return $content;
}
private function parseCreatedAtUpdatedAt($content)
{
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt']);
return $content;
}
private function parseFunction($content)
{
if (isset($content['execute'])) {
foreach ($content['execute'] as $i => $role) {
$content['execute'][$i] = $this->parseRole($role);
}
}
if (isset($content['vars'])) {
$vars = [];
foreach ($content['vars'] as $i => $var) {
$vars[$var['key']] = $var['value'];
}
$content['vars'] = $vars;
}
if (isset($content['enabled'])) {
$content['status'] = $content['enabled'] ? 'enabled' : 'disabled';
unset($content['enabled']);
}
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt', 'scheduleNext', 'schedulePrevious']);
return $content;
}
private function parseKey($content)
{
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt', 'expire']);
return $content;
}
private function parseLog($content)
{
$content = $this->parseDatetimeAttributes($content, ['time']);
return $content;
}
private function parseMembership($content)
{
$content = $this->parseDatetimeAttributes($content, ['$createdAt', '$updatedAt', 'invited', 'joined']);
return $content;
}
private function parseSession($content)
{
$content = $this->parseDatetimeAttributes($content, ['$createdAt', 'expire', 'providerAccessTokenExpiry']);
return $content;
}
private function parseUsage($content, $keys)
{
foreach ($keys as $key) {
$data = [];
foreach ($content[$key] as $metric) {
$data[] = $this->parseMetric($metric);
}
$content[$key] = $data;
}
return $content;
}
private function parseUsageDatabases($content)
{
$keys = [
'databasesCount',
'documentsCount',
'collectionsCount',
'databasesCreate',
'databasesRead',
'databasesUpdate',
'databasesDelete',
'documentsCreate',
'documentsRead',
'documentsUpdate',
'documentsDelete',
'collectionsCreate',
'collectionsRead',
'collectionsUpdate',
'collectionsDelete',
];
$content = $this->parseUsage($content, $keys);
return $content;
}
private function parseUsageDatabase($content)
{
$keys = [
'documentsCount',
'collectionsCount',
'documentsCreate',
'documentsRead',
'documentsUpdate',
'documentsDelete',
'collectionsCreate',
'collectionsRead',
'collectionsUpdate',
'collectionsDelete',
];
$content = $this->parseUsage($content, $keys);
return $content;
}
private function parseUsageCollection($content)
{
$keys = [
'documentsCount',
'documentsCreate',
'documentsRead',
'documentsUpdate',
'documentsDelete',
];
$content = $this->parseUsage($content, $keys);
return $content;
}
private function parseUsageUsers($content)
{
$keys = [
'usersCount',
'usersCreate',
'usersRead',
'usersUpdate',
'usersDelete',
'sessionsCreate',
'sessionsProviderCreate',
'sessionsDelete',
];
$content = $this->parseUsage($content, $keys);
return $content;
}
private function parseUsageBuckets($content)
{
$keys = [
'filesCount',
'filesStorage',
'filesCreate',
'filesRead',
'filesUpdate',
'filesDelete',
];
$content = $this->parseUsage($content, $keys);
return $content;
}
private function parseUsageFuncs($content)
{
$mapping = [
'executionsTotal' => 'functionsExecutions',
'executionsFailure' => 'functionsFailures',
'executionsTime' => 'functionsCompute',
];
foreach ($mapping as $new => $old) {
if (isset($content[$new])) {
$data = [];
foreach ($content[$new] as $metric) {
$data[] = $this->parseMetric($metric);
}
$content[$old] = $data;
unset($content[$new]);
}
}
unset($content['functionExecutions']);
unset($content['functionFailure']);
unset($content['executionsTime']);
unset($content['buildsTotal']);
unset($content['executionsSuccess']);
unset($content['buildsFailure']);
unset($content['buildsSuccess']);
unset($content['buildsTime']);
return $content;
}
private function parseUsageProject($content)
{
$content['functions'] = $content['executions'];
unset($content['executions']);
$keys = [
'collections',
'documents',
'functions',
'network',
'requests',
'storage',
'users',
];
$content = $this->parseUsage($content, $keys);
return $content;
}
private function parseUsageStorage($content)
{
$content['filesStorage'] = $content['storage'];
unset($content['storage']);
$keys = [
'bucketsCount',
'bucketsCreate',
'bucketsDelete',
'bucketsRead',
'bucketsUpdate',
'filesCount',
'filesCreate',
'filesDelete',
'filesRead',
'filesStorage',
'filesUpdate',
];
$content = $this->parseUsage($content, $keys);
return $content;
}
}

11
src/Appwrite/Utopia/Response/Model/Metric.php
View file

@ -17,12 +17,11 @@ class Metric extends Model
'example' => 1,
])
->addRule('date', [
'type' => self::TYPE_INTEGER,
'description' => 'The UNIX timestamp at which this metric was aggregated.',
'default' => 0,
'example' => 1592981250
])
;
'type' => self::TYPE_DATETIME,
'description' => 'The date at which this metric was aggregated in ISO 8601 format.',
'default' => '',
'example' => self::TYPE_DATETIME_EXAMPLE
]);
}
/**

742
tests/unit/Utopia/Request/Filters/V15Test.php Normal file
View file

@ -0,0 +1,742 @@
<?php
namespace Tests\Unit\Utopia\Request\Filters;
use Appwrite\Utopia\Request\Filter;
use Appwrite\Utopia\Request\Filters\V15;
use Appwrite\Utopia\Response\Model;
use PHPUnit\Framework\TestCase;
class V15Test extends TestCase
{
/**
* @var Filter
*/
protected $filter = null;
public function setUp(): void
{
$this->filter = new V15();
}
public function tearDown(): void
{
}
public function limitOffsetProvider(): array
{
return [
'basic test' => [
['limit' => '12', 'offset' => '0'],
['queries' => ['limit(12)', 'offset(0)']]
],
];
}
/**
* @dataProvider limitOffsetProvider
*/
public function testListAccountLogs(array $content, array $expected): void
{
$model = 'account.listLogs';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
public function testGetAccountInitials(): void
{
$model = 'account.initials';
$content = ['color' => 'deadbeef'];
$expected = [];
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
public function limitOffsetCursorOrderTypeProvider(): array
{
return [
'basic test' => [
[
'limit' => '12',
'offset' => '0',
'cursor' => 'abcd',
'cursorDirection' => 'before',
'orderType' => 'asc',
],
[
'queries' => [
'limit(12)',
'offset(0)',
'cursorBefore("abcd")',
'orderAsc("")'
]
],
],
];
}
public function cursorProvider(): array
{
return [
'cursorDirection after' => [
[
'cursor' => 'abcd',
'cursorDirection' => 'after',
],
[
'queries' => [
'cursorAfter("abcd")',
]
],
],
'cursorDirection invalid' => [
[
'cursor' => 'abcd',
'cursorDirection' => 'invalid',
],
[
'queries' => [
'cursorAfter("abcd")',
]
],
],
];
}
public function orderTypeProvider(): array
{
return [
'orderType desc' => [
[
'orderType' => 'DESC',
],
[
'queries' => [
'orderDesc("")',
]
],
],
'orderType invalid' => [
[
'orderType' => 'invalid',
],
[
'queries' => [
'orderAsc("")',
]
],
],
];
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListDatabases(array $content, array $expected): void
{
$model = 'databases.list';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetProvider
*/
public function testListDatabaseLogs(array $content, array $expected): void
{
$model = 'databases.listLogs';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
public function collectionPermissionProvider(): array
{
return [
'permission collection' => [
['permission' => 'collection'],
['documentSecurity' => false],
],
'permission document' => [
['permission' => 'document'],
['documentSecurity' => true],
],
'permission empty' => [
[],
[],
],
'permission invalid' => [
['permission' => 'invalid'],
['documentSecurity' => false],
],
];
}
public function readWriteProvider(): array
{
return [
'read all types' => [
[
'read' => [
'role:all',
'role:guest',
'role:member',
'user:a',
'team:b',
'team:c/member',
'member:z',
],
],
[
'permissions' => [
'read("any")',
'read("guests")',
'read("users")',
'read("user:a")',
'read("team:b")',
'read("team:c/member")',
'read("member:z")',
],
],
],
'read invalid' => [
['read' => ['invalid', 'invalid:a']],
['permissions' => ['read("invalid:a")']],
],
'write all types' => [
[
'write' => [
'role:all',
'role:guest',
'role:member',
'user:a',
'team:b',
'team:c/member',
'member:z',
],
],
[
'permissions' => [
'write("users")',
'write("users")',
'write("user:a")',
'write("team:b")',
'write("team:c/member")',
'write("member:z")',
],
],
],
'write invalid' => [
['write' => ['invalid', 'invalid:a']],
['permissions' => ['write("invalid:a")']],
]
];
}
/**
* @dataProvider collectionPermissionProvider
* @dataProvider readWriteProvider
*/
public function testCreateCollection(array $content, array $expected): void
{
$model = 'databases.createCollection';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListCollections(array $content, array $expected): void
{
$model = 'databases.listCollections';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetProvider
*/
public function testListCollectionLogs(array $content, array $expected): void
{
$model = 'databases.listCollectionLogs';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider collectionPermissionProvider
* @dataProvider readWriteProvider
*/
public function testUpdateCollection(array $content, array $expected): void
{
$model = 'databases.updateCollection';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider readWriteProvider
*/
public function testCreateDocument(array $content, array $expected): void
{
$model = 'databases.createDocument';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
public function ordersProvider(): array
{
return [
'basic test' => [
[
'orderAttributes' => ['lastName', 'firstName'],
'orderTypes' => ['DESC', 'ASC'],
],
[
'queries' => [
'orderDesc("lastName")',
'orderAsc("firstName")',
]
],
],
'orderType only' => [
[
'orderTypes' => ['DESC'],
],
[
'queries' => [
'orderDesc("")',
]
],
],
'orderType invalid' => [
[
'orderAttributes' => ['lastName'],
'orderTypes' => ['invalid'],
],
[
'queries' => [
'orderAsc("lastName")',
]
],
],
];
}
public function filtersProvider(): array
{
return [
'all filters' => [
[
'queries' => [
'lastName.equal("Smith", "Jackson")',
'firstName.notEqual("John")',
'age.lesser(50)',
'age.lesserEqual(51)',
'age.greater(20)',
'age.greaterEqual(21)',
'address.search("pla")',
],
],
[
'queries' => [
'equal("lastName", ["Smith", "Jackson"])',
'notEqual("firstName", ["John"])',
'lessThan("age", [50])',
'lessThanEqual("age", [51])',
'greaterThan("age", [20])',
'greaterThanEqual("age", [21])',
'search("address", ["pla"])',
]
],
],
];
}
/**
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider ordersProvider
* @dataProvider filtersProvider
*/
public function testListDocuments(array $content, array $expected): void
{
$model = 'databases.listDocuments';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetProvider
*/
public function testListDocumentLogs(array $content, array $expected): void
{
$model = 'databases.listDocumentLogs';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider readWriteProvider
*/
public function testUpdateDocument(array $content, array $expected): void
{
$model = 'databases.updateDocument';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
public function executeProvider(): array
{
return [
'all roles' => [
[
'execute' => [
'role:all',
'role:guest',
'role:member',
'user:a',
'team:b',
'team:c/member',
'member:z',
],
],
[
'execute' => [
'users',
'users',
'user:a',
'team:b',
'team:c/member',
'member:z',
]
],
],
];
}
/**
* @dataProvider executeProvider
*/
public function testCreateFunction(array $content, array $expected): void
{
$model = 'functions.create';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListFunctions(array $content, array $expected): void
{
$model = 'functions.list';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider executeProvider
*/
public function testUpdateFunction(array $content, array $expected): void
{
$model = 'functions.update';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListDeployments(array $content, array $expected): void
{
$model = 'functions.listDeployments';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
*/
public function testListExecutions(array $content, array $expected): void
{
$model = 'functions.listExecutions';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListProjects(array $content, array $expected): void
{
$model = 'projects.list';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
public function expireProvider(): array
{
return [
'empty' => [
[],
[],
],
'zero' => [
['expire' => '0'],
['expire' => null],
],
'value' => [
['expire' => '1602743880'],
['expire' => Model::TYPE_DATETIME_EXAMPLE],
],
];
}
/**
* @dataProvider expireProvider
*/
public function testCreateKey(array $content, array $expected)
{
$model = 'projects.createKey';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider expireProvider
*/
public function testUpdateKey(array $content, array $expected)
{
$model = 'projects.updateKey';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
public function bucketPermissionProvider(): array
{
return [
'permission bucket' => [
['permission' => 'bucket'],
['fileSecurity' => false],
],
'permission document' => [
['permission' => 'file'],
['fileSecurity' => true],
],
'permission empty' => [
[],
[],
],
'permission invalid' => [
['permission' => 'invalid'],
['fileSecurity' => false],
],
];
}
/**
* @dataProvider bucketPermissionProvider
* @dataProvider readWriteProvider
*/
public function testCreateBucket(array $content, array $expected)
{
$model = 'storage.createBucket';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListBuckets(array $content, array $expected): void
{
$model = 'storage.listBuckets';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider bucketPermissionProvider
* @dataProvider readWriteProvider
*/
public function testUpdateBucket(array $content, array $expected)
{
$model = 'storage.updateBucket';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider readWriteProvider
*/
public function testCreateFile(array $content, array $expected)
{
$model = 'storage.createFile';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListFiles(array $content, array $expected): void
{
$model = 'storage.listFiles';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider readWriteProvider
*/
public function testUpdateFile(array $content, array $expected)
{
$model = 'storage.updateFile';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListTeams(array $content, array $expected): void
{
$model = 'teams.list';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListTeamMemberships(array $content, array $expected): void
{
$model = 'teams.listMemberships';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetProvider
*/
public function testListTeamLogs(array $content, array $expected): void
{
$model = 'teams.listLogs';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetCursorOrderTypeProvider
* @dataProvider limitOffsetProvider
* @dataProvider cursorProvider
* @dataProvider orderTypeProvider
*/
public function testListUsers(array $content, array $expected): void
{
$model = 'users.list';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
/**
* @dataProvider limitOffsetProvider
*/
public function testListUserLogs(array $content, array $expected): void
{
$model = 'users.listLogs';
$result = $this->filter->parse($content, $model);
$this->assertEquals($expected, $result);
}
}

1888
tests/unit/Utopia/Response/Filters/V15Test.php Normal file
View file

File diff suppressed because it is too large Load diff