2019-05-09 18:54:39 +12:00
|
|
|
<?php
|
|
|
|
|
2020-03-25 17:34:06 +13:00
|
|
|
/**
|
|
|
|
* Init
|
2022-05-24 02:54:50 +12:00
|
|
|
*
|
2020-09-25 10:32:39 +12:00
|
|
|
* Initializes both Appwrite API entry point, queue workers, and CLI tasks.
|
2020-12-27 00:56:29 +13:00
|
|
|
* Set configuration, framework resources & app constants
|
2022-05-24 02:54:50 +12:00
|
|
|
*
|
2020-03-25 17:34:06 +13:00
|
|
|
*/
|
2022-05-24 02:54:50 +12:00
|
|
|
|
|
|
|
if (\file_exists(__DIR__ . '/../vendor/autoload.php')) {
|
|
|
|
require_once __DIR__ . '/../vendor/autoload.php';
|
2019-08-01 08:35:42 +12:00
|
|
|
}
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
ini_set('memory_limit', '512M');
|
2021-06-12 04:09:46 +12:00
|
|
|
ini_set('display_errors', 1);
|
|
|
|
ini_set('display_startup_errors', 1);
|
|
|
|
ini_set('default_socket_timeout', -1);
|
|
|
|
error_reporting(E_ALL);
|
|
|
|
|
2023-10-02 06:39:26 +13:00
|
|
|
use Appwrite\Event\Migration;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Appwrite\Event\Usage;
|
2022-02-07 10:27:16 +13:00
|
|
|
use Appwrite\Extend\Exception;
|
2020-07-01 06:08:02 +12:00
|
|
|
use Appwrite\Auth\Auth;
|
2022-04-14 00:39:31 +12:00
|
|
|
use Appwrite\Event\Audit;
|
|
|
|
use Appwrite\Event\Database as EventDatabase;
|
2020-06-28 07:42:38 +12:00
|
|
|
use Appwrite\Event\Event;
|
2022-04-14 00:39:31 +12:00
|
|
|
use Appwrite\Event\Mail;
|
2022-06-09 01:57:34 +12:00
|
|
|
use Appwrite\Event\Phone;
|
2022-10-15 21:52:50 +13:00
|
|
|
use Appwrite\Event\Delete;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Appwrite\GraphQL\Schema;
|
2021-07-24 02:59:55 +12:00
|
|
|
use Appwrite\Network\Validator\Email;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Appwrite\Network\Validator\Origin;
|
2020-05-13 10:00:00 +12:00
|
|
|
use Appwrite\OpenSSL\OpenSSL;
|
2022-10-20 01:41:38 +13:00
|
|
|
use Appwrite\URL\URL as AppwriteURL;
|
2020-07-02 10:34:05 +12:00
|
|
|
use Utopia\App;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Utopia\Logger\Logger;
|
2022-07-13 21:34:56 +12:00
|
|
|
use Utopia\Cache\Adapter\Redis as RedisCache;
|
|
|
|
use Utopia\Cache\Cache;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Utopia\Config\Config;
|
|
|
|
use Utopia\Database\Helpers\ID;
|
2021-08-22 03:09:08 +12:00
|
|
|
use Utopia\Database\Database;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Utopia\Database\Document;
|
2021-08-20 23:15:17 +12:00
|
|
|
use Utopia\Database\Query;
|
2022-10-15 21:52:50 +13:00
|
|
|
use Utopia\Database\Validator\Authorization;
|
2023-03-13 03:04:18 +13:00
|
|
|
use Utopia\Database\Validator\Datetime as DatetimeValidator;
|
2022-10-15 21:52:50 +13:00
|
|
|
use Utopia\Database\Validator\Structure;
|
|
|
|
use Utopia\Locale\Locale;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Utopia\DSN\DSN;
|
|
|
|
use Utopia\Messaging\Adapters\SMS\Mock;
|
|
|
|
use Appwrite\GraphQL\Promises\Adapter\Swoole;
|
|
|
|
use Utopia\Messaging\Adapters\SMS\Msg91;
|
|
|
|
use Utopia\Messaging\Adapters\SMS\Telesign;
|
|
|
|
use Utopia\Messaging\Adapters\SMS\TextMagic;
|
|
|
|
use Utopia\Messaging\Adapters\SMS\Twilio;
|
|
|
|
use Utopia\Messaging\Adapters\SMS\Vonage;
|
2022-10-15 21:52:50 +13:00
|
|
|
use Utopia\Registry\Registry;
|
2022-02-17 22:13:39 +13:00
|
|
|
use Utopia\Storage\Device;
|
2022-05-10 23:15:56 +12:00
|
|
|
use Utopia\Storage\Device\Backblaze;
|
2022-02-09 04:40:56 +13:00
|
|
|
use Utopia\Storage\Device\DOSpaces;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Utopia\Storage\Device\Linode;
|
2021-12-13 20:34:15 +13:00
|
|
|
use Utopia\Storage\Device\Local;
|
|
|
|
use Utopia\Storage\Device\S3;
|
2022-03-19 06:17:43 +13:00
|
|
|
use Utopia\Storage\Device\Wasabi;
|
2022-10-17 00:42:00 +13:00
|
|
|
use Utopia\Cache\Adapter\Sharding;
|
2022-10-15 21:52:50 +13:00
|
|
|
use Utopia\Database\Adapter\MariaDB;
|
|
|
|
use Utopia\Database\Adapter\MySQL;
|
|
|
|
use Utopia\Pools\Group;
|
|
|
|
use Utopia\Pools\Pool;
|
2022-10-17 00:42:00 +13:00
|
|
|
use Ahc\Jwt\JWT;
|
|
|
|
use Ahc\Jwt\JWTException;
|
2022-12-21 01:22:58 +13:00
|
|
|
use Appwrite\Event\Build;
|
2022-12-14 00:16:12 +13:00
|
|
|
use Appwrite\Event\Certificate;
|
2022-11-16 07:13:17 +13:00
|
|
|
use Appwrite\Event\Func;
|
2022-10-17 00:42:00 +13:00
|
|
|
use MaxMind\Db\Reader;
|
|
|
|
use PHPMailer\PHPMailer\PHPMailer;
|
|
|
|
use Swoole\Database\PDOProxy;
|
2022-11-10 06:01:43 +13:00
|
|
|
use Utopia\Queue;
|
2022-11-17 08:39:35 +13:00
|
|
|
use Utopia\Queue\Connection;
|
2022-11-18 06:43:59 +13:00
|
|
|
use Utopia\Storage\Storage;
|
2023-05-26 20:44:08 +12:00
|
|
|
use Utopia\VCS\Adapter\Git\GitHub as VcsGitHub;
|
2023-05-24 01:43:03 +12:00
|
|
|
use Utopia\Validator\Range;
|
|
|
|
use Utopia\Validator\IP;
|
|
|
|
use Utopia\Validator\URL;
|
|
|
|
use Utopia\Validator\WhiteList;
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2019-10-01 17:57:41 +13:00
|
|
|
const APP_NAME = 'Appwrite';
|
|
|
|
const APP_DOMAIN = 'appwrite.io';
|
2020-03-02 11:10:52 +13:00
|
|
|
const APP_EMAIL_TEAM = 'team@localhost.test'; // Default email address
|
2021-02-19 05:48:11 +13:00
|
|
|
const APP_EMAIL_SECURITY = ''; // Default security email address
|
2022-05-24 02:54:50 +12:00
|
|
|
const APP_USERAGENT = APP_NAME . '-Server v%s. Please report abuse at %s';
|
2020-11-19 11:08:45 +13:00
|
|
|
const APP_MODE_DEFAULT = 'default';
|
2019-10-01 17:57:41 +13:00
|
|
|
const APP_MODE_ADMIN = 'admin';
|
2020-07-20 02:43:34 +12:00
|
|
|
const APP_PAGING_LIMIT = 12;
|
2021-05-10 06:37:47 +12:00
|
|
|
const APP_LIMIT_COUNT = 5000;
|
|
|
|
const APP_LIMIT_USERS = 10000;
|
2022-12-16 23:37:49 +13:00
|
|
|
const APP_LIMIT_USER_PASSWORD_HISTORY = 20;
|
2023-05-24 01:43:03 +12:00
|
|
|
const APP_LIMIT_USER_SESSIONS_MAX = 100;
|
|
|
|
const APP_LIMIT_USER_SESSIONS_DEFAULT = 10;
|
2022-01-31 21:37:45 +13:00
|
|
|
const APP_LIMIT_ANTIVIRUS = 20000000; //20MB
|
|
|
|
const APP_LIMIT_ENCRYPTION = 20000000; //20MB
|
|
|
|
const APP_LIMIT_COMPRESSION = 20000000; //20MB
|
2022-05-01 19:54:58 +12:00
|
|
|
const APP_LIMIT_ARRAY_PARAMS_SIZE = 100; // Default maximum of how many elements can there be in API parameter that expects array value
|
2022-06-22 21:08:11 +12:00
|
|
|
const APP_LIMIT_ARRAY_ELEMENT_SIZE = 4096; // Default maximum length of element in array parameter represented by maximum URL length.
|
2022-05-31 00:01:39 +12:00
|
|
|
const APP_LIMIT_SUBQUERY = 1000;
|
2022-08-31 11:34:17 +12:00
|
|
|
const APP_LIMIT_WRITE_RATE_DEFAULT = 60; // Default maximum write rate per rate period
|
|
|
|
const APP_LIMIT_WRITE_RATE_PERIOD_DEFAULT = 60; // Default maximum write rate period in seconds
|
2023-05-24 01:43:03 +12:00
|
|
|
const APP_LIMIT_LIST_DEFAULT = 25; // Default maximum number of items to return in list API calls
|
2022-08-09 17:56:53 +12:00
|
|
|
const APP_KEY_ACCCESS = 24 * 60 * 60; // 24 hours
|
2023-07-07 12:12:39 +12:00
|
|
|
const APP_USER_ACCCESS = 24 * 60 * 60; // 24 hours
|
2022-09-01 01:11:23 +12:00
|
|
|
const APP_CACHE_UPDATE = 24 * 60 * 60; // 24 hours
|
2023-09-15 08:05:51 +12:00
|
|
|
const APP_CACHE_BUSTER = 510;
|
2023-09-15 07:53:32 +12:00
|
|
|
const APP_VERSION_STABLE = '1.4.3';
|
2021-08-17 10:05:52 +12:00
|
|
|
const APP_DATABASE_ATTRIBUTE_EMAIL = 'email';
|
2021-09-11 08:12:22 +12:00
|
|
|
const APP_DATABASE_ATTRIBUTE_ENUM = 'enum';
|
2021-08-17 10:05:52 +12:00
|
|
|
const APP_DATABASE_ATTRIBUTE_IP = 'ip';
|
2022-07-25 20:53:41 +12:00
|
|
|
const APP_DATABASE_ATTRIBUTE_DATETIME = 'datetime';
|
2021-08-17 10:05:52 +12:00
|
|
|
const APP_DATABASE_ATTRIBUTE_URL = 'url';
|
|
|
|
const APP_DATABASE_ATTRIBUTE_INT_RANGE = 'intRange';
|
|
|
|
const APP_DATABASE_ATTRIBUTE_FLOAT_RANGE = 'floatRange';
|
2021-10-27 09:28:16 +13:00
|
|
|
const APP_DATABASE_ATTRIBUTE_STRING_MAX_LENGTH = 1073741824; // 2^32 bits / 4 bits per char
|
2020-02-20 01:41:23 +13:00
|
|
|
const APP_STORAGE_UPLOADS = '/storage/uploads';
|
2020-07-15 09:20:46 +12:00
|
|
|
const APP_STORAGE_FUNCTIONS = '/storage/functions';
|
2021-12-09 04:08:53 +13:00
|
|
|
const APP_STORAGE_BUILDS = '/storage/builds';
|
2020-02-20 01:41:23 +13:00
|
|
|
const APP_STORAGE_CACHE = '/storage/cache';
|
|
|
|
const APP_STORAGE_CERTIFICATES = '/storage/certificates';
|
2020-02-25 23:04:12 +13:00
|
|
|
const APP_STORAGE_CONFIG = '/storage/config';
|
2022-01-31 21:37:45 +13:00
|
|
|
const APP_STORAGE_READ_BUFFER = 20 * (1000 * 1000); //20MB other names `APP_STORAGE_MEMORY_LIMIT`, `APP_STORAGE_MEMORY_BUFFER`, `APP_STORAGE_READ_LIMIT`, `APP_STORAGE_BUFFER_LIMIT`
|
2021-12-12 09:17:33 +13:00
|
|
|
const APP_SOCIAL_TWITTER = 'https://twitter.com/appwrite';
|
|
|
|
const APP_SOCIAL_TWITTER_HANDLE = 'appwrite';
|
2020-02-21 09:43:06 +13:00
|
|
|
const APP_SOCIAL_FACEBOOK = 'https://www.facebook.com/appwrite.io';
|
|
|
|
const APP_SOCIAL_LINKEDIN = 'https://www.linkedin.com/company/appwrite';
|
|
|
|
const APP_SOCIAL_INSTAGRAM = 'https://www.instagram.com/appwrite.io';
|
|
|
|
const APP_SOCIAL_GITHUB = 'https://github.com/appwrite';
|
2020-07-20 15:59:04 +12:00
|
|
|
const APP_SOCIAL_DISCORD = 'https://appwrite.io/discord';
|
2021-04-11 04:14:15 +12:00
|
|
|
const APP_SOCIAL_DISCORD_CHANNEL = '564160730845151244';
|
2020-05-18 03:57:42 +12:00
|
|
|
const APP_SOCIAL_DEV = 'https://dev.to/appwrite';
|
2022-05-24 02:54:50 +12:00
|
|
|
const APP_SOCIAL_STACKSHARE = 'https://stackshare.io/appwrite';
|
2021-12-11 13:17:28 +13:00
|
|
|
const APP_SOCIAL_YOUTUBE = 'https://www.youtube.com/c/appwrite?sub_confirmation=1';
|
2023-08-17 06:08:24 +12:00
|
|
|
const APP_HOSTNAME_INTERNAL = 'appwrite';
|
2022-01-22 06:32:27 +13:00
|
|
|
// Database Reconnect
|
|
|
|
const DATABASE_RECONNECT_SLEEP = 2;
|
|
|
|
const DATABASE_RECONNECT_MAX_ATTEMPTS = 10;
|
2021-08-09 11:42:08 +12:00
|
|
|
// Database Worker Types
|
|
|
|
const DATABASE_TYPE_CREATE_ATTRIBUTE = 'createAttribute';
|
|
|
|
const DATABASE_TYPE_CREATE_INDEX = 'createIndex';
|
|
|
|
const DATABASE_TYPE_DELETE_ATTRIBUTE = 'deleteAttribute';
|
|
|
|
const DATABASE_TYPE_DELETE_INDEX = 'deleteIndex';
|
2022-01-24 12:01:42 +13:00
|
|
|
// Build Worker Types
|
2022-01-27 02:09:32 +13:00
|
|
|
const BUILD_TYPE_DEPLOYMENT = 'deployment';
|
2022-01-24 12:01:42 +13:00
|
|
|
const BUILD_TYPE_RETRY = 'retry';
|
2020-12-19 03:05:15 +13:00
|
|
|
// Deletion Types
|
2022-06-22 22:51:49 +12:00
|
|
|
const DELETE_TYPE_DATABASES = 'databases';
|
2020-12-19 03:05:15 +13:00
|
|
|
const DELETE_TYPE_DOCUMENT = 'document';
|
2021-10-26 13:14:55 +13:00
|
|
|
const DELETE_TYPE_COLLECTIONS = 'collections';
|
|
|
|
const DELETE_TYPE_PROJECTS = 'projects';
|
|
|
|
const DELETE_TYPE_FUNCTIONS = 'functions';
|
2022-01-28 12:36:30 +13:00
|
|
|
const DELETE_TYPE_DEPLOYMENTS = 'deployments';
|
2021-10-26 13:14:55 +13:00
|
|
|
const DELETE_TYPE_USERS = 'users';
|
2022-05-24 02:54:50 +12:00
|
|
|
const DELETE_TYPE_TEAMS = 'teams';
|
2020-12-28 06:57:35 +13:00
|
|
|
const DELETE_TYPE_EXECUTIONS = 'executions';
|
2020-12-19 03:05:15 +13:00
|
|
|
const DELETE_TYPE_AUDIT = 'audit';
|
|
|
|
const DELETE_TYPE_ABUSE = 'abuse';
|
2021-09-08 18:55:48 +12:00
|
|
|
const DELETE_TYPE_USAGE = 'usage';
|
2021-06-16 21:35:37 +12:00
|
|
|
const DELETE_TYPE_REALTIME = 'realtime';
|
2021-11-07 18:54:28 +13:00
|
|
|
const DELETE_TYPE_BUCKETS = 'buckets';
|
2023-07-31 07:10:25 +12:00
|
|
|
const DELETE_TYPE_INSTALLATIONS = 'installations';
|
2023-03-10 20:42:52 +13:00
|
|
|
const DELETE_TYPE_RULES = 'rules';
|
2022-06-02 22:20:03 +12:00
|
|
|
const DELETE_TYPE_SESSIONS = 'sessions';
|
2022-08-15 21:05:41 +12:00
|
|
|
const DELETE_TYPE_CACHE_BY_TIMESTAMP = 'cacheByTimeStamp';
|
|
|
|
const DELETE_TYPE_CACHE_BY_RESOURCE = 'cacheByResource';
|
2022-11-17 01:51:43 +13:00
|
|
|
const DELETE_TYPE_SCHEDULES = 'schedules';
|
2022-08-31 21:51:20 +12:00
|
|
|
// Compression type
|
|
|
|
const COMPRESSION_TYPE_NONE = 'none';
|
|
|
|
const COMPRESSION_TYPE_GZIP = 'gzip';
|
|
|
|
const COMPRESSION_TYPE_ZSTD = 'zstd';
|
2021-07-28 08:31:19 +12:00
|
|
|
// Mail Types
|
|
|
|
const MAIL_TYPE_VERIFICATION = 'verification';
|
2021-08-30 22:44:52 +12:00
|
|
|
const MAIL_TYPE_MAGIC_SESSION = 'magicSession';
|
2021-07-28 08:31:19 +12:00
|
|
|
const MAIL_TYPE_RECOVERY = 'recovery';
|
|
|
|
const MAIL_TYPE_INVITATION = 'invitation';
|
2022-04-14 00:26:07 +12:00
|
|
|
const MAIL_TYPE_CERTIFICATE = 'certificate';
|
2021-03-29 10:22:12 +13:00
|
|
|
// Auth Types
|
|
|
|
const APP_AUTH_TYPE_SESSION = 'Session';
|
|
|
|
const APP_AUTH_TYPE_JWT = 'JWT';
|
|
|
|
const APP_AUTH_TYPE_KEY = 'Key';
|
|
|
|
const APP_AUTH_TYPE_ADMIN = 'Admin';
|
2021-09-30 21:41:29 +13:00
|
|
|
// Response related
|
2022-05-24 02:54:50 +12:00
|
|
|
const MAX_OUTPUT_CHUNK_SIZE = 2 * 1024 * 1024; // 2MB
|
2023-07-30 19:17:23 +12:00
|
|
|
// Function headers
|
2023-08-20 23:43:06 +12:00
|
|
|
const FUNCTION_ALLOWLIST_HEADERS_REQUEST = ['content-type', 'agent', 'content-length', 'host'];
|
2023-08-12 01:34:57 +12:00
|
|
|
const FUNCTION_ALLOWLIST_HEADERS_RESPONSE = ['content-type', 'content-length'];
|
2023-05-24 01:43:03 +12:00
|
|
|
// Usage metrics
|
|
|
|
const METRIC_TEAMS = 'teams';
|
|
|
|
const METRIC_USERS = 'users';
|
|
|
|
const METRIC_SESSIONS = 'sessions';
|
|
|
|
const METRIC_DATABASES = 'databases';
|
|
|
|
const METRIC_COLLECTIONS = 'collections';
|
|
|
|
const METRIC_DATABASE_ID_COLLECTIONS = '{databaseInternalId}.collections';
|
|
|
|
const METRIC_DOCUMENTS = 'documents';
|
|
|
|
const METRIC_DATABASE_ID_DOCUMENTS = '{databaseInternalId}.documents';
|
|
|
|
const METRIC_DATABASE_ID_COLLECTION_ID_DOCUMENTS = '{databaseInternalId}.{collectionInternalId}.documents';
|
|
|
|
const METRIC_BUCKETS = 'buckets';
|
|
|
|
const METRIC_FILES = 'files';
|
|
|
|
const METRIC_FILES_STORAGE = 'files.storage';
|
|
|
|
const METRIC_BUCKET_ID_FILES = '{bucketInternalId}.files';
|
|
|
|
const METRIC_BUCKET_ID_FILES_STORAGE = '{bucketInternalId}.files.storage';
|
|
|
|
const METRIC_FUNCTIONS = 'functions';
|
|
|
|
const METRIC_DEPLOYMENTS = 'deployments';
|
|
|
|
const METRIC_DEPLOYMENTS_STORAGE = 'deployments.storage';
|
|
|
|
const METRIC_BUILDS = 'builds';
|
|
|
|
const METRIC_BUILDS_STORAGE = 'builds.storage';
|
|
|
|
const METRIC_BUILDS_COMPUTE = 'builds.compute';
|
|
|
|
const METRIC_FUNCTION_ID_BUILDS = '{functionInternalId}.builds';
|
|
|
|
const METRIC_FUNCTION_ID_BUILDS_STORAGE = '{functionInternalId}.builds.storage';
|
|
|
|
const METRIC_FUNCTION_ID_BUILDS_COMPUTE = '{functionInternalId}.builds.compute';
|
|
|
|
const METRIC_FUNCTION_ID_DEPLOYMENTS = '{resourceType}.{resourceInternalId}.deployments';
|
|
|
|
const METRIC_FUNCTION_ID_DEPLOYMENTS_STORAGE = '{resourceType}.{resourceInternalId}.deployments.storage';
|
|
|
|
const METRIC_EXECUTIONS = 'executions';
|
|
|
|
const METRIC_EXECUTIONS_COMPUTE = 'executions.compute';
|
|
|
|
const METRIC_FUNCTION_ID_EXECUTIONS = '{functionInternalId}.executions';
|
|
|
|
const METRIC_FUNCTION_ID_EXECUTIONS_COMPUTE = '{functionInternalId}.executions.compute';
|
|
|
|
const METRIC_NETWORK_REQUESTS = 'network.requests';
|
|
|
|
const METRIC_NETWORK_INBOUND = 'network.inbound';
|
|
|
|
const METRIC_NETWORK_OUTBOUND = 'network.outbound';
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2019-10-01 17:57:41 +13:00
|
|
|
$register = new Registry();
|
2020-06-19 12:04:09 +12:00
|
|
|
|
2020-06-29 05:31:21 +12:00
|
|
|
App::setMode(App::getEnv('_APP_ENV', App::MODE_TYPE_PRODUCTION));
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2019-10-01 17:57:41 +13:00
|
|
|
/*
|
2019-05-09 18:54:39 +12:00
|
|
|
* ENV vars
|
|
|
|
*/
|
2022-05-24 02:54:50 +12:00
|
|
|
Config::load('events', __DIR__ . '/config/events.php');
|
|
|
|
Config::load('auth', __DIR__ . '/config/auth.php');
|
|
|
|
Config::load('errors', __DIR__ . '/config/errors.php');
|
|
|
|
Config::load('providers', __DIR__ . '/config/providers.php');
|
|
|
|
Config::load('platforms', __DIR__ . '/config/platforms.php');
|
|
|
|
Config::load('collections', __DIR__ . '/config/collections.php');
|
|
|
|
Config::load('runtimes', __DIR__ . '/config/runtimes.php');
|
2023-10-02 07:30:52 +13:00
|
|
|
Config::load('runtimes-v2', __DIR__ . '/config/runtimes-v2.php');
|
2023-05-24 01:43:03 +12:00
|
|
|
Config::load('usage', __DIR__ . '/config/usage.php');
|
2022-05-24 02:54:50 +12:00
|
|
|
Config::load('roles', __DIR__ . '/config/roles.php'); // User roles and scopes
|
|
|
|
Config::load('scopes', __DIR__ . '/config/scopes.php'); // User roles and scopes
|
|
|
|
Config::load('services', __DIR__ . '/config/services.php'); // List of services
|
|
|
|
Config::load('variables', __DIR__ . '/config/variables.php'); // List of env variables
|
2022-10-01 01:22:11 +13:00
|
|
|
Config::load('regions', __DIR__ . '/config/regions.php'); // List of available regions
|
2022-05-24 02:54:50 +12:00
|
|
|
Config::load('avatar-browsers', __DIR__ . '/config/avatars/browsers.php');
|
|
|
|
Config::load('avatar-credit-cards', __DIR__ . '/config/avatars/credit-cards.php');
|
|
|
|
Config::load('avatar-flags', __DIR__ . '/config/avatars/flags.php');
|
|
|
|
Config::load('locale-codes', __DIR__ . '/config/locale/codes.php');
|
|
|
|
Config::load('locale-currencies', __DIR__ . '/config/locale/currencies.php');
|
|
|
|
Config::load('locale-eu', __DIR__ . '/config/locale/eu.php');
|
|
|
|
Config::load('locale-languages', __DIR__ . '/config/locale/languages.php');
|
|
|
|
Config::load('locale-phones', __DIR__ . '/config/locale/phones.php');
|
|
|
|
Config::load('locale-countries', __DIR__ . '/config/locale/countries.php');
|
|
|
|
Config::load('locale-continents', __DIR__ . '/config/locale/continents.php');
|
2023-03-10 02:44:23 +13:00
|
|
|
Config::load('locale-templates', __DIR__ . '/config/locale/templates.php');
|
2022-05-24 02:54:50 +12:00
|
|
|
Config::load('storage-logos', __DIR__ . '/config/storage/logos.php');
|
|
|
|
Config::load('storage-mimes', __DIR__ . '/config/storage/mimes.php');
|
|
|
|
Config::load('storage-inputs', __DIR__ . '/config/storage/inputs.php');
|
|
|
|
Config::load('storage-outputs', __DIR__ . '/config/storage/outputs.php');
|
|
|
|
|
|
|
|
$user = App::getEnv('_APP_REDIS_USER', '');
|
|
|
|
$pass = App::getEnv('_APP_REDIS_PASS', '');
|
|
|
|
if (!empty($user) || !empty($pass)) {
|
|
|
|
Resque::setBackend('redis://' . $user . ':' . $pass . '@' . App::getEnv('_APP_REDIS_HOST', '') . ':' . App::getEnv('_APP_REDIS_PORT', ''));
|
2021-01-31 18:24:38 +13:00
|
|
|
} else {
|
2022-05-24 02:54:50 +12:00
|
|
|
Resque::setBackend(App::getEnv('_APP_REDIS_HOST', '') . ':' . App::getEnv('_APP_REDIS_PORT', ''));
|
2021-01-31 18:24:38 +13:00
|
|
|
}
|
2021-08-20 23:15:17 +12:00
|
|
|
|
2021-08-28 05:12:16 +12:00
|
|
|
/**
|
|
|
|
* New DB Filters
|
|
|
|
*/
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'casting',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2022-04-22 01:14:01 +12:00
|
|
|
return json_encode(['value' => $value], JSON_PRESERVE_ZERO_FRACTION);
|
2021-08-28 05:12:16 +12:00
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2021-08-28 11:42:53 +12:00
|
|
|
if (is_null($value)) {
|
|
|
|
return null;
|
|
|
|
}
|
2022-05-31 00:01:39 +12:00
|
|
|
|
2021-08-28 08:27:48 +12:00
|
|
|
return json_decode($value, true)['value'];
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'enum',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $attribute) {
|
2021-09-11 08:14:12 +12:00
|
|
|
if ($attribute->isSet('elements')) {
|
|
|
|
$attribute->removeAttribute('elements');
|
|
|
|
}
|
2022-05-31 00:01:39 +12:00
|
|
|
|
2021-09-11 08:14:12 +12:00
|
|
|
return $value;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $attribute) {
|
2023-08-22 15:25:55 +12:00
|
|
|
$formatOptions = \json_decode($attribute->getAttribute('formatOptions', '[]'), true);
|
2021-09-11 08:14:12 +12:00
|
|
|
if (isset($formatOptions['elements'])) {
|
|
|
|
$attribute->setAttribute('elements', $formatOptions['elements']);
|
|
|
|
}
|
2022-05-31 00:01:39 +12:00
|
|
|
|
2021-09-11 08:14:12 +12:00
|
|
|
return $value;
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'range',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $attribute) {
|
2021-08-28 08:27:48 +12:00
|
|
|
if ($attribute->isSet('min')) {
|
|
|
|
$attribute->removeAttribute('min');
|
|
|
|
}
|
|
|
|
if ($attribute->isSet('max')) {
|
|
|
|
$attribute->removeAttribute('max');
|
|
|
|
}
|
2022-05-31 00:01:39 +12:00
|
|
|
|
2021-08-28 08:27:48 +12:00
|
|
|
return $value;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $attribute) {
|
2021-12-09 06:49:44 +13:00
|
|
|
$formatOptions = json_decode($attribute->getAttribute('formatOptions', '[]'), true);
|
2021-08-28 08:27:48 +12:00
|
|
|
if (isset($formatOptions['min']) || isset($formatOptions['max'])) {
|
|
|
|
$attribute
|
|
|
|
->setAttribute('min', $formatOptions['min'])
|
|
|
|
->setAttribute('max', $formatOptions['max'])
|
|
|
|
;
|
|
|
|
}
|
2022-05-31 00:01:39 +12:00
|
|
|
|
2021-08-28 08:27:48 +12:00
|
|
|
return $value;
|
2021-08-28 05:12:16 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryAttributes',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2021-08-21 05:02:44 +12:00
|
|
|
return null;
|
2021-08-20 23:15:17 +12:00
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2023-03-25 16:28:07 +13:00
|
|
|
$attributes = $database->find('attributes', [
|
|
|
|
Query::equal('collectionInternalId', [$document->getInternalId()]),
|
|
|
|
Query::equal('databaseInternalId', [$document->getAttribute('databaseInternalId')]),
|
|
|
|
Query::limit($database->getLimitForAttributes()),
|
|
|
|
]);
|
|
|
|
|
|
|
|
foreach ($attributes as $attribute) {
|
|
|
|
if ($attribute->getAttribute('type') === Database::VAR_RELATIONSHIP) {
|
|
|
|
$options = $attribute->getAttribute('options');
|
|
|
|
foreach ($options as $key => $value) {
|
|
|
|
$attribute->setAttribute($key, $value);
|
|
|
|
}
|
|
|
|
$attribute->removeAttribute('options');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $attributes;
|
2021-08-20 23:15:17 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryIndexes',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2021-08-23 03:00:00 +12:00
|
|
|
return null;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2021-08-23 03:00:00 +12:00
|
|
|
return $database
|
|
|
|
->find('indexes', [
|
2022-08-12 11:53:52 +12:00
|
|
|
Query::equal('collectionInternalId', [$document->getInternalId()]),
|
|
|
|
Query::equal('databaseInternalId', [$document->getAttribute('databaseInternalId')]),
|
2023-08-22 15:25:55 +12:00
|
|
|
Query::limit($database->getLimitForIndexes()),
|
2022-08-12 11:53:52 +12:00
|
|
|
]);
|
2021-08-23 03:00:00 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryPlatforms',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2021-08-30 19:33:45 +12:00
|
|
|
return null;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2021-08-30 19:33:45 +12:00
|
|
|
return $database
|
2021-09-01 20:43:35 +12:00
|
|
|
->find('platforms', [
|
2022-08-12 11:53:52 +12:00
|
|
|
Query::equal('projectInternalId', [$document->getInternalId()]),
|
|
|
|
Query::limit(APP_LIMIT_SUBQUERY),
|
|
|
|
]);
|
2021-08-31 02:24:50 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryKeys',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2021-08-31 02:24:50 +12:00
|
|
|
return null;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2021-08-31 02:24:50 +12:00
|
|
|
return $database
|
2021-09-01 20:43:35 +12:00
|
|
|
->find('keys', [
|
2022-08-12 11:53:52 +12:00
|
|
|
Query::equal('projectInternalId', [$document->getInternalId()]),
|
|
|
|
Query::limit(APP_LIMIT_SUBQUERY),
|
|
|
|
]);
|
2021-08-31 02:24:50 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryWebhooks',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2021-08-31 02:24:50 +12:00
|
|
|
return null;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2021-08-31 02:24:50 +12:00
|
|
|
return $database
|
2021-09-01 20:43:35 +12:00
|
|
|
->find('webhooks', [
|
2022-08-12 11:53:52 +12:00
|
|
|
Query::equal('projectInternalId', [$document->getInternalId()]),
|
|
|
|
Query::limit(APP_LIMIT_SUBQUERY),
|
|
|
|
]);
|
2021-08-23 03:00:00 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQuerySessions',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2022-04-04 21:59:32 +12:00
|
|
|
return null;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2022-06-02 05:13:15 +12:00
|
|
|
return Authorization::skip(fn () => $database->find('sessions', [
|
2022-08-12 11:53:52 +12:00
|
|
|
Query::equal('userInternalId', [$document->getInternalId()]),
|
|
|
|
Query::limit(APP_LIMIT_SUBQUERY),
|
|
|
|
]));
|
2022-04-04 21:59:32 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryTokens',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2022-04-27 23:06:53 +12:00
|
|
|
return null;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2022-04-28 02:11:12 +12:00
|
|
|
return Authorization::skip(fn() => $database
|
2022-04-27 23:06:53 +12:00
|
|
|
->find('tokens', [
|
2022-08-12 11:53:52 +12:00
|
|
|
Query::equal('userInternalId', [$document->getInternalId()]),
|
|
|
|
Query::limit(APP_LIMIT_SUBQUERY),
|
|
|
|
]));
|
2022-05-09 02:39:24 +12:00
|
|
|
}
|
|
|
|
);
|
2022-05-31 00:01:39 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryMemberships',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2022-04-28 00:44:47 +12:00
|
|
|
return null;
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2022-04-28 00:44:47 +12:00
|
|
|
return Authorization::skip(fn() => $database
|
|
|
|
->find('memberships', [
|
2022-08-12 11:53:52 +12:00
|
|
|
Query::equal('userInternalId', [$document->getInternalId()]),
|
|
|
|
Query::limit(APP_LIMIT_SUBQUERY),
|
|
|
|
]));
|
2021-08-23 03:00:00 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-07-20 19:18:49 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryVariables',
|
|
|
|
function (mixed $value) {
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
function (mixed $value, Document $document, Database $database) {
|
2022-08-10 00:32:33 +12:00
|
|
|
return $database
|
2022-07-20 19:18:49 +12:00
|
|
|
->find('variables', [
|
2023-03-12 05:06:02 +13:00
|
|
|
Query::equal('resourceInternalId', [$document->getInternalId()]),
|
|
|
|
Query::equal('resourceType', ['function']),
|
2022-09-03 02:19:36 +12:00
|
|
|
Query::limit(APP_LIMIT_SUBQUERY),
|
|
|
|
]);
|
2022-07-20 19:18:49 +12:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'encrypt',
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2021-05-05 09:25:17 +12:00
|
|
|
$key = App::getEnv('_APP_OPENSSL_KEY_V1');
|
|
|
|
$iv = OpenSSL::randomPseudoBytes(OpenSSL::cipherIVLength(OpenSSL::CIPHER_AES_128_GCM));
|
|
|
|
$tag = null;
|
2022-05-31 00:01:39 +12:00
|
|
|
|
2021-05-05 09:25:17 +12:00
|
|
|
return json_encode([
|
|
|
|
'data' => OpenSSL::encrypt($value, OpenSSL::CIPHER_AES_128_GCM, $key, 0, $iv, $tag),
|
|
|
|
'method' => OpenSSL::CIPHER_AES_128_GCM,
|
2021-12-15 01:10:38 +13:00
|
|
|
'iv' => \bin2hex($iv),
|
|
|
|
'tag' => \bin2hex($tag ?? ''),
|
2021-05-05 09:25:17 +12:00
|
|
|
'version' => '1',
|
|
|
|
]);
|
|
|
|
},
|
2022-06-02 02:32:59 +12:00
|
|
|
function (mixed $value) {
|
2022-05-24 02:54:50 +12:00
|
|
|
if (is_null($value)) {
|
2021-12-03 20:38:21 +13:00
|
|
|
return null;
|
|
|
|
}
|
2021-05-05 09:25:17 +12:00
|
|
|
$value = json_decode($value, true);
|
2022-05-24 02:54:50 +12:00
|
|
|
$key = App::getEnv('_APP_OPENSSL_KEY_V' . $value['version']);
|
2021-05-05 09:25:17 +12:00
|
|
|
|
|
|
|
return OpenSSL::decrypt($value['data'], $value['method'], $key, 0, hex2bin($value['iv']), hex2bin($value['tag']));
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2023-07-28 19:56:07 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'subQueryProjectVariables',
|
|
|
|
function (mixed $value) {
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
function (mixed $value, Document $document, Database $database) {
|
|
|
|
return $database
|
|
|
|
->find('variables', [
|
|
|
|
Query::equal('resourceType', ['project']),
|
|
|
|
Query::limit(APP_LIMIT_SUBQUERY)
|
|
|
|
]);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2023-07-06 07:17:47 +12:00
|
|
|
Database::addFilter(
|
|
|
|
'userSearch',
|
|
|
|
function (mixed $value, Document $user) {
|
|
|
|
$searchValues = [
|
|
|
|
$user->getId(),
|
|
|
|
$user->getAttribute('email', ''),
|
|
|
|
$user->getAttribute('name', ''),
|
|
|
|
$user->getAttribute('phone', '')
|
|
|
|
];
|
|
|
|
|
|
|
|
foreach ($user->getAttribute('labels', []) as $label) {
|
|
|
|
$searchValues[] = 'label:' . $label;
|
|
|
|
}
|
|
|
|
|
|
|
|
$search = implode(' ', \array_filter($searchValues));
|
|
|
|
|
|
|
|
return $search;
|
|
|
|
},
|
|
|
|
function (mixed $value) {
|
|
|
|
return $value;
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2021-08-20 23:15:17 +12:00
|
|
|
/**
|
|
|
|
* DB Formats
|
|
|
|
*/
|
2022-05-24 02:54:50 +12:00
|
|
|
Structure::addFormat(APP_DATABASE_ATTRIBUTE_EMAIL, function () {
|
2021-07-27 11:10:39 +12:00
|
|
|
return new Email();
|
2021-08-22 03:09:08 +12:00
|
|
|
}, Database::VAR_STRING);
|
2021-07-27 11:10:39 +12:00
|
|
|
|
2022-07-29 00:38:54 +12:00
|
|
|
Structure::addFormat(APP_DATABASE_ATTRIBUTE_DATETIME, function () {
|
|
|
|
return new DatetimeValidator();
|
|
|
|
}, Database::VAR_DATETIME);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Structure::addFormat(APP_DATABASE_ATTRIBUTE_ENUM, function ($attribute) {
|
2021-09-11 08:12:22 +12:00
|
|
|
$elements = $attribute['formatOptions']['elements'];
|
2021-12-16 23:15:55 +13:00
|
|
|
return new WhiteList($elements, true);
|
2021-09-11 08:12:22 +12:00
|
|
|
}, Database::VAR_STRING);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Structure::addFormat(APP_DATABASE_ATTRIBUTE_IP, function () {
|
2021-07-27 11:10:39 +12:00
|
|
|
return new IP();
|
2021-08-22 03:09:08 +12:00
|
|
|
}, Database::VAR_STRING);
|
2021-07-27 11:10:39 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Structure::addFormat(APP_DATABASE_ATTRIBUTE_URL, function () {
|
2021-07-27 11:10:39 +12:00
|
|
|
return new URL();
|
2021-08-22 03:09:08 +12:00
|
|
|
}, Database::VAR_STRING);
|
2021-07-27 11:10:39 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Structure::addFormat(APP_DATABASE_ATTRIBUTE_INT_RANGE, function ($attribute) {
|
2021-08-22 03:09:08 +12:00
|
|
|
$min = $attribute['formatOptions']['min'] ?? -INF;
|
|
|
|
$max = $attribute['formatOptions']['max'] ?? INF;
|
|
|
|
return new Range($min, $max, Range::TYPE_INTEGER);
|
|
|
|
}, Database::VAR_INTEGER);
|
2021-07-28 06:19:37 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Structure::addFormat(APP_DATABASE_ATTRIBUTE_FLOAT_RANGE, function ($attribute) {
|
2021-08-22 03:09:08 +12:00
|
|
|
$min = $attribute['formatOptions']['min'] ?? -INF;
|
|
|
|
$max = $attribute['formatOptions']['max'] ?? INF;
|
|
|
|
return new Range($min, $max, Range::TYPE_FLOAT);
|
|
|
|
}, Database::VAR_FLOAT);
|
2021-07-24 02:59:55 +12:00
|
|
|
|
2019-10-01 17:57:41 +13:00
|
|
|
/*
|
2019-05-09 18:54:39 +12:00
|
|
|
* Registry
|
|
|
|
*/
|
2022-05-24 02:54:50 +12:00
|
|
|
$register->set('logger', function () {
|
2022-06-24 21:48:55 +12:00
|
|
|
// Register error logger
|
2021-11-23 05:12:18 +13:00
|
|
|
$providerName = App::getEnv('_APP_LOGGING_PROVIDER', '');
|
|
|
|
$providerConfig = App::getEnv('_APP_LOGGING_CONFIG', '');
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
if (empty($providerName) || empty($providerConfig)) {
|
2021-12-07 02:14:55 +13:00
|
|
|
return null;
|
2021-11-23 05:12:18 +13:00
|
|
|
}
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
if (!Logger::hasProvider($providerName)) {
|
2022-08-14 17:35:25 +12:00
|
|
|
throw new Exception(Exception::GENERAL_SERVER_ERROR, "Logging provider not supported. Logging is disabled");
|
2021-11-23 05:12:18 +13:00
|
|
|
}
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
$classname = '\\Utopia\\Logger\\Adapter\\' . \ucfirst($providerName);
|
2021-11-23 05:12:18 +13:00
|
|
|
$adapter = new $classname($providerConfig);
|
|
|
|
return new Logger($adapter);
|
|
|
|
});
|
2022-11-16 12:50:37 +13:00
|
|
|
$register->set('pools', function () {
|
2022-10-19 21:35:30 +13:00
|
|
|
$group = new Group();
|
2022-06-23 20:50:00 +12:00
|
|
|
|
2023-08-23 23:52:17 +12:00
|
|
|
$fallbackForDB = 'db_main=' . AppwriteURL::unparse([
|
2022-10-17 00:42:00 +13:00
|
|
|
'scheme' => 'mariadb',
|
|
|
|
'host' => App::getEnv('_APP_DB_HOST', 'mariadb'),
|
|
|
|
'port' => App::getEnv('_APP_DB_PORT', '3306'),
|
|
|
|
'user' => App::getEnv('_APP_DB_USER', ''),
|
|
|
|
'pass' => App::getEnv('_APP_DB_PASS', ''),
|
2023-08-23 23:52:17 +12:00
|
|
|
'path' => App::getEnv('_APP_DB_SCHEMA', ''),
|
2022-10-17 00:42:00 +13:00
|
|
|
]);
|
2023-08-23 23:52:17 +12:00
|
|
|
$fallbackForRedis = 'redis_main=' . AppwriteURL::unparse([
|
2022-10-17 00:42:00 +13:00
|
|
|
'scheme' => 'redis',
|
|
|
|
'host' => App::getEnv('_APP_REDIS_HOST', 'redis'),
|
|
|
|
'port' => App::getEnv('_APP_REDIS_PORT', '6379'),
|
|
|
|
'user' => App::getEnv('_APP_REDIS_USER', ''),
|
|
|
|
'pass' => App::getEnv('_APP_REDIS_PASS', ''),
|
|
|
|
]);
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2022-10-15 21:52:50 +13:00
|
|
|
$connections = [
|
|
|
|
'console' => [
|
|
|
|
'type' => 'database',
|
2022-10-17 00:42:00 +13:00
|
|
|
'dsns' => App::getEnv('_APP_CONNECTIONS_DB_CONSOLE', $fallbackForDB),
|
2022-10-15 21:52:50 +13:00
|
|
|
'multiple' => false,
|
|
|
|
'schemes' => ['mariadb', 'mysql'],
|
|
|
|
],
|
|
|
|
'database' => [
|
|
|
|
'type' => 'database',
|
2022-10-17 00:42:00 +13:00
|
|
|
'dsns' => App::getEnv('_APP_CONNECTIONS_DB_PROJECT', $fallbackForDB),
|
2022-10-15 21:52:50 +13:00
|
|
|
'multiple' => true,
|
|
|
|
'schemes' => ['mariadb', 'mysql'],
|
|
|
|
],
|
|
|
|
'queue' => [
|
|
|
|
'type' => 'queue',
|
2022-10-17 00:42:00 +13:00
|
|
|
'dsns' => App::getEnv('_APP_CONNECTIONS_QUEUE', $fallbackForRedis),
|
2022-10-15 21:52:50 +13:00
|
|
|
'multiple' => false,
|
|
|
|
'schemes' => ['redis'],
|
|
|
|
],
|
|
|
|
'pubsub' => [
|
|
|
|
'type' => 'pubsub',
|
2022-10-17 00:42:00 +13:00
|
|
|
'dsns' => App::getEnv('_APP_CONNECTIONS_PUBSUB', $fallbackForRedis),
|
2022-10-15 21:52:50 +13:00
|
|
|
'multiple' => false,
|
|
|
|
'schemes' => ['redis'],
|
|
|
|
],
|
|
|
|
'cache' => [
|
|
|
|
'type' => 'cache',
|
2022-10-17 00:42:00 +13:00
|
|
|
'dsns' => App::getEnv('_APP_CONNECTIONS_CACHE', $fallbackForRedis),
|
|
|
|
'multiple' => true,
|
2022-10-15 21:52:50 +13:00
|
|
|
'schemes' => ['redis'],
|
|
|
|
],
|
|
|
|
];
|
|
|
|
|
2022-11-23 04:37:04 +13:00
|
|
|
$maxConnections = App::getEnv('_APP_CONNECTIONS_MAX', 151);
|
|
|
|
$instanceConnections = $maxConnections / App::getEnv('_APP_POOL_CLIENTS', 14);
|
2022-11-22 20:17:56 +13:00
|
|
|
|
2022-11-23 04:37:04 +13:00
|
|
|
$multiprocessing = App::getEnv('_APP_SERVER_MULTIPROCESS', 'disabled') === 'enabled';
|
2022-11-22 20:17:56 +13:00
|
|
|
|
2022-11-22 20:57:44 +13:00
|
|
|
if ($multiprocessing) {
|
2022-11-22 20:17:56 +13:00
|
|
|
$workerCount = swoole_cpu_num() * intval(App::getEnv('_APP_WORKER_PER_CORE', 6));
|
|
|
|
} else {
|
|
|
|
$workerCount = 1;
|
|
|
|
}
|
2022-11-16 12:50:37 +13:00
|
|
|
|
2022-11-16 20:18:59 +13:00
|
|
|
if ($workerCount > $instanceConnections) {
|
|
|
|
throw new \Exception('Pool size is too small. Increase the number of allowed database connections or decrease the number of workers.', 500);
|
2021-06-12 04:09:46 +12:00
|
|
|
}
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2022-11-16 20:18:59 +13:00
|
|
|
$poolSize = (int)($instanceConnections / $workerCount);
|
2022-11-16 12:50:37 +13:00
|
|
|
|
2022-10-15 21:52:50 +13:00
|
|
|
foreach ($connections as $key => $connection) {
|
|
|
|
$type = $connection['type'] ?? '';
|
|
|
|
$dsns = $connection['dsns'] ?? '';
|
|
|
|
$multipe = $connection['multiple'] ?? false;
|
|
|
|
$schemes = $connection['schemes'] ?? [];
|
2022-10-16 03:14:17 +13:00
|
|
|
$config = [];
|
|
|
|
$dsns = explode(',', $connection['dsns'] ?? '');
|
|
|
|
foreach ($dsns as &$dsn) {
|
2022-10-15 21:52:50 +13:00
|
|
|
$dsn = explode('=', $dsn);
|
2022-10-19 21:35:30 +13:00
|
|
|
$name = ($multipe) ? $key . '_' . $dsn[0] : $key;
|
2022-10-16 03:14:17 +13:00
|
|
|
$dsn = $dsn[1] ?? '';
|
|
|
|
$config[] = $name;
|
2022-10-19 21:35:30 +13:00
|
|
|
if (empty($dsn)) {
|
2022-10-16 07:17:03 +13:00
|
|
|
//throw new Exception(Exception::GENERAL_SERVER_ERROR, "Missing value for DSN connection in {$key}");
|
|
|
|
continue;
|
2022-10-16 03:14:17 +13:00
|
|
|
}
|
2022-10-15 21:52:50 +13:00
|
|
|
|
|
|
|
$dsn = new DSN($dsn);
|
|
|
|
$dsnHost = $dsn->getHost();
|
|
|
|
$dsnPort = $dsn->getPort();
|
|
|
|
$dsnUser = $dsn->getUser();
|
|
|
|
$dsnPass = $dsn->getPassword();
|
2022-10-20 02:55:58 +13:00
|
|
|
$dsnScheme = $dsn->getScheme();
|
2022-11-18 03:56:10 +13:00
|
|
|
$dsnDatabase = $dsn->getPath();
|
2022-10-15 21:52:50 +13:00
|
|
|
|
2022-11-16 05:03:42 +13:00
|
|
|
if (!in_array($dsnScheme, $schemes)) {
|
2022-10-15 21:52:50 +13:00
|
|
|
throw new Exception(Exception::GENERAL_SERVER_ERROR, "Invalid console database scheme");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get Resource
|
2022-10-19 21:35:30 +13:00
|
|
|
*
|
2022-10-15 21:52:50 +13:00
|
|
|
* Creation could be reused accross connection types like database, cache, queue, etc.
|
2022-10-19 21:35:30 +13:00
|
|
|
*
|
2022-10-15 21:52:50 +13:00
|
|
|
* Resource assignment to an adapter will happen below.
|
|
|
|
*/
|
2022-10-20 02:55:58 +13:00
|
|
|
switch ($dsnScheme) {
|
2022-10-15 21:52:50 +13:00
|
|
|
case 'mysql':
|
|
|
|
case 'mariadb':
|
2022-10-20 02:55:58 +13:00
|
|
|
$resource = function () use ($dsnHost, $dsnPort, $dsnUser, $dsnPass, $dsnDatabase) {
|
|
|
|
return new PDOProxy(function () use ($dsnHost, $dsnPort, $dsnUser, $dsnPass, $dsnDatabase) {
|
|
|
|
return new PDO("mysql:host={$dsnHost};port={$dsnPort};dbname={$dsnDatabase};charset=utf8mb4", $dsnUser, $dsnPass, array(
|
2022-10-17 11:49:53 +13:00
|
|
|
PDO::ATTR_TIMEOUT => 3, // Seconds
|
|
|
|
PDO::ATTR_PERSISTENT => true,
|
|
|
|
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
|
|
|
PDO::ATTR_ERRMODE => App::isDevelopment() ? PDO::ERRMODE_WARNING : PDO::ERRMODE_SILENT, // If in production mode, warnings are not displayed
|
|
|
|
PDO::ATTR_EMULATE_PREPARES => true,
|
|
|
|
PDO::ATTR_STRINGIFY_FETCHES => true
|
|
|
|
));
|
|
|
|
});
|
|
|
|
};
|
2022-10-15 21:52:50 +13:00
|
|
|
break;
|
|
|
|
case 'redis':
|
2022-10-19 21:35:30 +13:00
|
|
|
$resource = function () use ($dsnHost, $dsnPort, $dsnPass) {
|
2022-10-17 11:49:53 +13:00
|
|
|
$redis = new Redis();
|
2022-10-18 05:43:51 +13:00
|
|
|
@$redis->pconnect($dsnHost, (int)$dsnPort);
|
2022-10-19 21:35:30 +13:00
|
|
|
if ($dsnPass) {
|
2022-10-17 11:49:53 +13:00
|
|
|
$redis->auth($dsnPass);
|
|
|
|
}
|
|
|
|
$redis->setOption(Redis::OPT_READ_TIMEOUT, -1);
|
2022-10-19 21:35:30 +13:00
|
|
|
|
2022-10-17 11:49:53 +13:00
|
|
|
return $redis;
|
|
|
|
};
|
2022-10-15 21:52:50 +13:00
|
|
|
break;
|
2022-10-19 21:35:30 +13:00
|
|
|
|
2022-10-15 21:52:50 +13:00
|
|
|
default:
|
|
|
|
throw new Exception(Exception::GENERAL_SERVER_ERROR, "Invalid scheme");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-11-16 20:18:59 +13:00
|
|
|
$pool = new Pool($name, $poolSize, function () use ($type, $resource, $dsn) {
|
2022-10-17 11:49:53 +13:00
|
|
|
// Get Adapter
|
|
|
|
$adapter = null;
|
|
|
|
switch ($type) {
|
|
|
|
case 'database':
|
|
|
|
$adapter = match ($dsn->getScheme()) {
|
|
|
|
'mariadb' => new MariaDB($resource()),
|
|
|
|
'mysql' => new MySQL($resource()),
|
|
|
|
default => null
|
|
|
|
};
|
2022-10-19 21:35:30 +13:00
|
|
|
|
2022-11-18 03:56:10 +13:00
|
|
|
$adapter->setDefaultDatabase($dsn->getPath());
|
2022-10-17 11:49:53 +13:00
|
|
|
break;
|
|
|
|
case 'pubsub':
|
2022-10-18 00:43:57 +13:00
|
|
|
$adapter = $resource();
|
2022-11-16 05:03:42 +13:00
|
|
|
break;
|
2022-11-10 06:01:43 +13:00
|
|
|
case 'queue':
|
|
|
|
$adapter = match ($dsn->getScheme()) {
|
|
|
|
'redis' => new Queue\Connection\Redis($dsn->getHost(), $dsn->getPort()),
|
2022-11-16 05:03:42 +13:00
|
|
|
default => null
|
2022-11-10 06:01:43 +13:00
|
|
|
};
|
2022-10-17 11:49:53 +13:00
|
|
|
break;
|
|
|
|
case 'cache':
|
|
|
|
$adapter = match ($dsn->getScheme()) {
|
|
|
|
'redis' => new RedisCache($resource()),
|
|
|
|
default => null
|
|
|
|
};
|
|
|
|
break;
|
2022-10-19 21:35:30 +13:00
|
|
|
|
2022-10-17 11:49:53 +13:00
|
|
|
default:
|
|
|
|
throw new Exception(Exception::GENERAL_SERVER_ERROR, "Server error: Missing adapter implementation.");
|
|
|
|
break;
|
|
|
|
}
|
2022-10-19 21:35:30 +13:00
|
|
|
|
2022-10-16 03:14:17 +13:00
|
|
|
return $adapter;
|
2022-10-15 21:52:50 +13:00
|
|
|
});
|
|
|
|
|
|
|
|
$group->add($pool);
|
|
|
|
}
|
2022-10-16 03:14:17 +13:00
|
|
|
|
2022-10-19 21:35:30 +13:00
|
|
|
Config::setParam('pools-' . $key, $config);
|
2021-06-12 04:09:46 +12:00
|
|
|
}
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2022-10-15 21:52:50 +13:00
|
|
|
return $group;
|
2019-05-09 18:54:39 +12:00
|
|
|
});
|
2022-11-16 05:03:42 +13:00
|
|
|
|
2020-06-29 08:45:36 +12:00
|
|
|
$register->set('smtp', function () {
|
2019-08-09 09:49:46 +12:00
|
|
|
$mail = new PHPMailer(true);
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2019-08-09 09:49:46 +12:00
|
|
|
$mail->isSMTP();
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2023-08-30 16:30:44 +12:00
|
|
|
$username = App::getEnv('_APP_SMTP_USERNAME');
|
|
|
|
$password = App::getEnv('_APP_SMTP_PASSWORD');
|
2019-08-09 09:49:46 +12:00
|
|
|
|
2019-10-01 17:57:41 +13:00
|
|
|
$mail->XMailer = 'Appwrite Mailer';
|
2020-06-29 05:31:21 +12:00
|
|
|
$mail->Host = App::getEnv('_APP_SMTP_HOST', 'smtp');
|
|
|
|
$mail->Port = App::getEnv('_APP_SMTP_PORT', 25);
|
2023-08-30 16:56:08 +12:00
|
|
|
$mail->SMTPAuth = !empty($username) && !empty($password);
|
2019-10-01 17:57:41 +13:00
|
|
|
$mail->Username = $username;
|
|
|
|
$mail->Password = $password;
|
2023-08-30 16:30:44 +12:00
|
|
|
$mail->SMTPSecure = App::getEnv('_APP_SMTP_SECURE', '');
|
2020-01-12 02:58:02 +13:00
|
|
|
$mail->SMTPAutoTLS = false;
|
2020-06-13 04:49:56 +12:00
|
|
|
$mail->CharSet = 'UTF-8';
|
2019-08-09 09:49:46 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
$from = \urldecode(App::getEnv('_APP_SYSTEM_EMAIL_NAME', APP_NAME . ' Server'));
|
2020-06-29 05:31:21 +12:00
|
|
|
$email = App::getEnv('_APP_SYSTEM_EMAIL_ADDRESS', APP_EMAIL_TEAM);
|
2020-02-08 12:19:13 +13:00
|
|
|
|
|
|
|
$mail->setFrom($email, $from);
|
|
|
|
$mail->addReplyTo($email, $from);
|
2019-05-09 18:54:39 +12:00
|
|
|
|
2019-08-09 09:49:46 +12:00
|
|
|
$mail->isHTML(true);
|
2019-09-28 13:48:50 +12:00
|
|
|
|
2019-08-09 09:49:46 +12:00
|
|
|
return $mail;
|
2019-05-09 18:54:39 +12:00
|
|
|
});
|
2020-10-30 03:08:09 +13:00
|
|
|
$register->set('geodb', function () {
|
2023-05-24 01:43:03 +12:00
|
|
|
return new Reader(__DIR__ . '/assets/dbip/dbip-country-lite-2023-01.mmdb');
|
|
|
|
});
|
2022-12-26 22:24:51 +13:00
|
|
|
$register->set('passwordsDictionary', function () {
|
2022-12-26 23:22:38 +13:00
|
|
|
$content = \file_get_contents(__DIR__ . '/assets/security/10k-common-passwords');
|
2022-12-27 19:16:19 +13:00
|
|
|
$content = explode("\n", $content);
|
2022-12-26 23:22:38 +13:00
|
|
|
$content = array_flip($content);
|
|
|
|
return $content;
|
2022-12-23 20:19:11 +13:00
|
|
|
});
|
2023-05-24 01:43:03 +12:00
|
|
|
$register->set('promiseAdapter', function () {
|
|
|
|
return new Swoole();
|
2020-10-30 03:08:09 +13:00
|
|
|
});
|
2019-10-01 17:57:41 +13:00
|
|
|
/*
|
2019-05-09 18:54:39 +12:00
|
|
|
* Localization
|
|
|
|
*/
|
|
|
|
Locale::$exceptions = false;
|
2023-04-17 14:10:17 +12:00
|
|
|
|
|
|
|
$locales = Config::getParam('locale-codes', []);
|
|
|
|
|
2023-04-17 14:15:46 +12:00
|
|
|
foreach ($locales as $locale) {
|
2023-04-17 14:10:17 +12:00
|
|
|
$code = $locale['code'];
|
2023-04-18 19:14:03 +12:00
|
|
|
|
2023-04-17 14:10:17 +12:00
|
|
|
$path = __DIR__ . '/config/locale/translations/' . $code . '.json';
|
|
|
|
|
2023-04-17 14:15:46 +12:00
|
|
|
if (!\file_exists($path)) {
|
2023-04-17 21:10:41 +12:00
|
|
|
$path = __DIR__ . '/config/locale/translations/' . \substr($code, 0, 2) . '.json'; // if `ar-ae` doesn't exist, look for `ar`
|
2023-04-18 19:14:03 +12:00
|
|
|
if (!\file_exists($path)) {
|
2023-04-17 21:10:41 +12:00
|
|
|
$path = __DIR__ . '/config/locale/translations/en.json'; // if none translation exists, use default from `en.json`
|
|
|
|
}
|
2023-04-17 14:10:17 +12:00
|
|
|
}
|
|
|
|
|
2023-04-17 21:10:41 +12:00
|
|
|
Locale::setLanguageFromJSON($code, $path);
|
2023-04-17 14:10:17 +12:00
|
|
|
}
|
2019-10-09 17:33:33 +13:00
|
|
|
|
2020-06-20 23:20:49 +12:00
|
|
|
\stream_context_set_default([ // Set global user agent and http settings
|
2019-05-09 18:54:39 +12:00
|
|
|
'http' => [
|
|
|
|
'method' => 'GET',
|
2022-05-24 02:54:50 +12:00
|
|
|
'user_agent' => \sprintf(
|
|
|
|
APP_USERAGENT,
|
2020-06-30 23:09:28 +12:00
|
|
|
App::getEnv('_APP_VERSION', 'UNKNOWN'),
|
2022-05-24 02:54:50 +12:00
|
|
|
App::getEnv('_APP_SYSTEM_SECURITY_EMAIL_ADDRESS', APP_EMAIL_SECURITY)
|
|
|
|
),
|
2019-10-01 17:57:41 +13:00
|
|
|
'timeout' => 2,
|
|
|
|
],
|
2019-05-09 18:54:39 +12:00
|
|
|
]);
|
|
|
|
|
2020-06-30 16:34:13 +12:00
|
|
|
// Runtime Execution
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('logger', function ($register) {
|
2021-11-23 05:12:18 +13:00
|
|
|
return $register->get('logger');
|
|
|
|
}, ['register']);
|
2020-06-30 16:34:13 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('loggerBreadcrumbs', function () {
|
2021-11-24 03:24:25 +13:00
|
|
|
return [];
|
2020-06-30 16:34:13 +12:00
|
|
|
});
|
|
|
|
|
2021-12-17 23:41:26 +13:00
|
|
|
App::setResource('register', fn() => $register);
|
2021-12-21 23:48:10 +13:00
|
|
|
App::setResource('locale', fn() => new Locale(App::getEnv('_APP_LOCALE', 'en')));
|
2020-06-30 16:34:13 +12:00
|
|
|
|
2023-04-17 14:15:46 +12:00
|
|
|
App::setResource('localeCodes', function () {
|
2023-04-17 14:10:17 +12:00
|
|
|
return array_map(fn($locale) => $locale['code'], Config::getParam('locale-codes', []));
|
|
|
|
});
|
|
|
|
|
2020-06-30 16:34:13 +12:00
|
|
|
// Queues
|
2022-11-19 03:20:05 +13:00
|
|
|
App::setResource('queue', function (Group $pools) {
|
2022-11-17 08:39:35 +13:00
|
|
|
return $pools->get('queue')->pop()->getResource();
|
2022-11-16 07:13:17 +13:00
|
|
|
}, ['pools']);
|
2022-12-21 05:11:30 +13:00
|
|
|
App::setResource('queueForMessaging', function (Connection $queue) {
|
2022-12-18 09:45:58 +13:00
|
|
|
return new Phone($queue);
|
|
|
|
}, ['queue']);
|
2023-06-12 02:08:48 +12:00
|
|
|
App::setResource('queueForMails', function (Connection $queue) {
|
2022-12-21 00:24:26 +13:00
|
|
|
return new Mail($queue);
|
|
|
|
}, ['queue']);
|
2022-12-21 05:11:30 +13:00
|
|
|
App::setResource('queueForBuilds', function (Connection $queue) {
|
2022-12-21 01:22:58 +13:00
|
|
|
return new Build($queue);
|
|
|
|
}, ['queue']);
|
2022-12-21 05:11:30 +13:00
|
|
|
App::setResource('queueForDatabase', function (Connection $queue) {
|
2022-12-21 00:23:26 +13:00
|
|
|
return new EventDatabase($queue);
|
2022-12-21 01:22:58 +13:00
|
|
|
}, ['queue']);
|
2022-12-21 05:11:30 +13:00
|
|
|
App::setResource('queueForDeletes', function (Connection $queue) {
|
2022-12-21 00:23:26 +13:00
|
|
|
return new Delete($queue);
|
|
|
|
}, ['queue']);
|
2022-12-21 05:11:30 +13:00
|
|
|
App::setResource('queueForEvents', function (Connection $queue) {
|
2023-06-02 15:54:34 +12:00
|
|
|
return new Event($queue);
|
2022-12-21 01:22:58 +13:00
|
|
|
}, ['queue']);
|
2022-12-21 05:11:30 +13:00
|
|
|
App::setResource('queueForAudits', function (Connection $queue) {
|
2022-12-21 00:11:36 +13:00
|
|
|
return new Audit($queue);
|
2022-12-21 01:22:58 +13:00
|
|
|
}, ['queue']);
|
2022-11-19 03:20:05 +13:00
|
|
|
App::setResource('queueForFunctions', function (Connection $queue) {
|
|
|
|
return new Func($queue);
|
|
|
|
}, ['queue']);
|
2023-05-24 01:43:03 +12:00
|
|
|
App::setResource('queueForUsage', function (Connection $queue) {
|
|
|
|
return new Usage($queue);
|
|
|
|
}, ['queue']);
|
2022-12-21 05:11:30 +13:00
|
|
|
App::setResource('queueForCertificates', function (Connection $queue) {
|
2022-12-14 00:16:12 +13:00
|
|
|
return new Certificate($queue);
|
|
|
|
}, ['queue']);
|
2023-10-02 06:39:26 +13:00
|
|
|
App::setResource('queueForMigrations', function (Connection $queue) {
|
|
|
|
return new Migration($queue);
|
|
|
|
}, ['queue']);
|
2021-12-28 01:45:23 +13:00
|
|
|
App::setResource('clients', function ($request, $console, $project) {
|
2021-08-20 23:15:17 +12:00
|
|
|
$console->setAttribute('platforms', [ // Always allow current host
|
2022-08-14 22:33:36 +12:00
|
|
|
'$collection' => ID::custom('platforms'),
|
2021-01-13 05:36:21 +13:00
|
|
|
'name' => 'Current Host',
|
2023-05-24 01:43:03 +12:00
|
|
|
'type' => Origin::CLIENT_TYPE_WEB,
|
2021-01-13 05:36:21 +13:00
|
|
|
'hostname' => $request->getHostname(),
|
|
|
|
], Document::SET_TYPE_APPEND);
|
2021-12-21 23:48:10 +13:00
|
|
|
|
2020-07-01 06:08:02 +12:00
|
|
|
/**
|
|
|
|
* Get All verified client URLs for both console and current projects
|
|
|
|
* + Filter for duplicated entries
|
|
|
|
*/
|
2021-12-28 01:45:23 +13:00
|
|
|
$clientsConsole = \array_map(
|
|
|
|
fn ($node) => $node['hostname'],
|
|
|
|
\array_filter(
|
|
|
|
$console->getAttribute('platforms', []),
|
2023-05-24 01:43:03 +12:00
|
|
|
fn ($node) => (isset($node['type']) && ($node['type'] === Origin::CLIENT_TYPE_WEB) && isset($node['hostname']) && !empty($node['hostname']))
|
2021-12-28 01:45:23 +13:00
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
$clients = \array_unique(
|
|
|
|
\array_merge(
|
|
|
|
$clientsConsole,
|
|
|
|
\array_map(
|
|
|
|
fn ($node) => $node['hostname'],
|
|
|
|
\array_filter(
|
|
|
|
$project->getAttribute('platforms', []),
|
2023-05-24 01:43:03 +12:00
|
|
|
fn ($node) => (isset($node['type']) && ($node['type'] === Origin::CLIENT_TYPE_WEB || $node['type'] === Origin::CLIENT_TYPE_FLUTTER_WEB) && isset($node['hostname']) && !empty($node['hostname']))
|
2021-12-28 01:45:23 +13:00
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
2020-07-01 06:08:02 +12:00
|
|
|
|
|
|
|
return $clients;
|
2021-01-13 05:36:21 +13:00
|
|
|
}, ['request', 'console', 'project']);
|
2020-07-01 06:08:02 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('user', function ($mode, $project, $console, $request, $response, $dbForProject, $dbForConsole) {
|
2022-01-01 04:50:07 +13:00
|
|
|
/** @var Appwrite\Utopia\Request $request */
|
2020-10-30 02:50:49 +13:00
|
|
|
/** @var Appwrite\Utopia\Response $response */
|
2021-05-07 10:31:05 +12:00
|
|
|
/** @var Utopia\Database\Document $project */
|
2021-12-28 01:45:23 +13:00
|
|
|
/** @var Utopia\Database\Database $dbForProject */
|
2021-05-07 10:31:05 +12:00
|
|
|
/** @var Utopia\Database\Database $dbForConsole */
|
2021-06-12 04:09:46 +12:00
|
|
|
/** @var string $mode */
|
2020-07-01 06:08:02 +12:00
|
|
|
|
2020-07-03 18:08:37 +12:00
|
|
|
Authorization::setDefaultStatus(true);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
Auth::setCookieName('a_session_' . $project->getId());
|
2022-11-22 03:24:52 +13:00
|
|
|
$authDuration = $project->getAttribute('auths', [])['duration'] ?? Auth::TOKEN_EXPIRATION_LOGIN_LONG;
|
2020-07-01 06:08:02 +12:00
|
|
|
|
|
|
|
if (APP_MODE_ADMIN === $mode) {
|
2022-05-24 02:54:50 +12:00
|
|
|
Auth::setCookieName('a_session_' . $console->getId());
|
2022-11-22 03:24:52 +13:00
|
|
|
$authDuration = Auth::TOKEN_EXPIRATION_LOGIN_LONG;
|
2020-07-01 06:08:02 +12:00
|
|
|
}
|
|
|
|
|
|
|
|
$session = Auth::decodeSession(
|
2022-05-24 02:54:50 +12:00
|
|
|
$request->getCookie(
|
|
|
|
Auth::$cookieName, // Get sessions
|
|
|
|
$request->getCookie(Auth::$cookieName . '_legacy', '')
|
|
|
|
)
|
|
|
|
);// Get fallback session from old clients (no SameSite support)
|
2020-07-01 06:08:02 +12:00
|
|
|
|
|
|
|
// Get fallback session from clients who block 3rd-party cookies
|
2022-05-24 02:54:50 +12:00
|
|
|
if ($response) {
|
|
|
|
$response->addHeader('X-Debug-Fallback', 'false');
|
|
|
|
}
|
2020-07-01 06:08:02 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
if (empty($session['id']) && empty($session['secret'])) {
|
|
|
|
if ($response) {
|
|
|
|
$response->addHeader('X-Debug-Fallback', 'true');
|
|
|
|
}
|
2020-07-05 10:22:22 +12:00
|
|
|
$fallback = $request->getHeader('x-fallback-cookies', '');
|
2020-07-01 06:08:02 +12:00
|
|
|
$fallback = \json_decode($fallback, true);
|
|
|
|
$session = Auth::decodeSession(((isset($fallback[Auth::$cookieName])) ? $fallback[Auth::$cookieName] : ''));
|
|
|
|
}
|
2020-07-03 17:56:28 +12:00
|
|
|
|
2021-05-07 10:31:05 +12:00
|
|
|
Auth::$unique = $session['id'] ?? '';
|
|
|
|
Auth::$secret = $session['secret'] ?? '';
|
2020-07-01 06:08:02 +12:00
|
|
|
|
2021-05-16 22:55:12 +12:00
|
|
|
if (APP_MODE_ADMIN !== $mode) {
|
2021-05-17 21:37:33 +12:00
|
|
|
if ($project->isEmpty()) {
|
2023-08-11 22:49:05 +12:00
|
|
|
$user = new Document([]);
|
2022-05-24 02:54:50 +12:00
|
|
|
} else {
|
2023-06-19 02:08:53 +12:00
|
|
|
if ($project->getId() === 'console') {
|
2023-06-18 23:38:37 +12:00
|
|
|
$user = $dbForConsole->getDocument('users', Auth::$unique);
|
|
|
|
} else {
|
|
|
|
$user = $dbForProject->getDocument('users', Auth::$unique);
|
|
|
|
}
|
2021-05-17 21:37:33 +12:00
|
|
|
}
|
2022-05-24 02:54:50 +12:00
|
|
|
} else {
|
2021-05-07 10:31:05 +12:00
|
|
|
$user = $dbForConsole->getDocument('users', Auth::$unique);
|
2020-07-01 06:08:02 +12:00
|
|
|
}
|
2020-06-30 16:34:13 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
if (
|
|
|
|
$user->isEmpty() // Check a document has been found in the DB
|
2022-11-14 22:30:45 +13:00
|
|
|
|| !Auth::sessionVerify($user->getAttribute('sessions', []), Auth::$secret, $authDuration)
|
2022-05-24 02:54:50 +12:00
|
|
|
) { // Validate user has valid login token
|
2023-08-11 22:49:05 +12:00
|
|
|
$user = new Document([]);
|
2020-07-01 06:08:02 +12:00
|
|
|
}
|
|
|
|
|
|
|
|
if (APP_MODE_ADMIN === $mode) {
|
2021-05-16 22:55:12 +12:00
|
|
|
if ($user->find('teamId', $project->getAttribute('teamId'), 'memberships')) {
|
2020-07-03 17:56:28 +12:00
|
|
|
Authorization::setDefaultStatus(false); // Cancel security segmentation for admin users.
|
2020-07-01 06:08:02 +12:00
|
|
|
} else {
|
2023-08-11 22:49:05 +12:00
|
|
|
$user = new Document([]);
|
2020-07-01 06:08:02 +12:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-29 09:31:42 +13:00
|
|
|
$authJWT = $request->getHeader('x-appwrite-jwt', '');
|
|
|
|
|
2021-05-17 21:37:33 +12:00
|
|
|
if (!empty($authJWT) && !$project->isEmpty()) { // JWT authentication
|
2020-12-29 10:23:09 +13:00
|
|
|
$jwt = new JWT(App::getEnv('_APP_OPENSSL_KEY_V1'), 'HS256', 900, 10); // Instantiate with key, algo, maxAge and leeway.
|
|
|
|
|
2020-12-29 09:31:42 +13:00
|
|
|
try {
|
|
|
|
$payload = $jwt->decode($authJWT);
|
|
|
|
} catch (JWTException $error) {
|
2022-08-14 17:35:25 +12:00
|
|
|
throw new Exception(Exception::USER_JWT_INVALID, 'Failed to verify JWT. ' . $error->getMessage());
|
2020-12-29 09:31:42 +13:00
|
|
|
}
|
2021-08-17 20:58:33 +12:00
|
|
|
|
2020-12-29 09:31:42 +13:00
|
|
|
$jwtUserId = $payload['userId'] ?? '';
|
|
|
|
$jwtSessionId = $payload['sessionId'] ?? '';
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
if ($jwtUserId && $jwtSessionId) {
|
2021-12-28 01:45:23 +13:00
|
|
|
$user = $dbForProject->getDocument('users', $jwtUserId);
|
2020-12-29 09:31:42 +13:00
|
|
|
}
|
|
|
|
|
2021-05-16 10:41:42 +12:00
|
|
|
if (empty($user->find('$id', $jwtSessionId, 'sessions'))) { // Match JWT to active token
|
2023-08-11 22:49:05 +12:00
|
|
|
$user = new Document([]);
|
2020-12-29 09:31:42 +13:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-01 06:08:02 +12:00
|
|
|
return $user;
|
2021-12-28 01:45:23 +13:00
|
|
|
}, ['mode', 'project', 'console', 'request', 'response', 'dbForProject', 'dbForConsole']);
|
2020-07-01 06:08:02 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('project', function ($dbForConsole, $request, $console) {
|
2022-01-01 04:50:07 +13:00
|
|
|
/** @var Appwrite\Utopia\Request $request */
|
2021-05-17 21:37:33 +12:00
|
|
|
/** @var Utopia\Database\Database $dbForConsole */
|
|
|
|
/** @var Utopia\Database\Document $console */
|
2021-05-16 21:18:34 +12:00
|
|
|
|
2023-06-03 11:22:54 +12:00
|
|
|
$projectId = $request->getParam('project', $request->getHeader('x-appwrite-project', ''));
|
2020-06-30 16:34:13 +12:00
|
|
|
|
2023-08-06 22:30:38 +12:00
|
|
|
if (empty($projectId) || $projectId === 'console') {
|
2021-05-16 21:18:34 +12:00
|
|
|
return $console;
|
|
|
|
}
|
2020-07-01 20:55:14 +12:00
|
|
|
|
2021-12-18 04:25:05 +13:00
|
|
|
$project = Authorization::skip(fn() => $dbForConsole->getDocument('projects', $projectId));
|
2020-07-01 06:08:02 +12:00
|
|
|
|
|
|
|
return $project;
|
2021-05-16 21:18:34 +12:00
|
|
|
}, ['dbForConsole', 'request', 'console']);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('console', function () {
|
2021-08-20 23:15:17 +12:00
|
|
|
return new Document([
|
2022-08-14 22:33:36 +12:00
|
|
|
'$id' => ID::custom('console'),
|
|
|
|
'$internalId' => ID::custom('console'),
|
2021-05-16 21:18:34 +12:00
|
|
|
'name' => 'Appwrite',
|
2022-08-14 22:33:36 +12:00
|
|
|
'$collection' => ID::custom('projects'),
|
2021-05-16 21:18:34 +12:00
|
|
|
'description' => 'Appwrite core engine',
|
|
|
|
'logo' => '',
|
|
|
|
'teamId' => -1,
|
|
|
|
'webhooks' => [],
|
|
|
|
'keys' => [],
|
|
|
|
'platforms' => [
|
|
|
|
[
|
2022-08-14 22:33:36 +12:00
|
|
|
'$collection' => ID::custom('platforms'),
|
2021-05-16 21:18:34 +12:00
|
|
|
'name' => 'Localhost',
|
2023-05-24 01:43:03 +12:00
|
|
|
'type' => Origin::CLIENT_TYPE_WEB,
|
2021-05-16 21:18:34 +12:00
|
|
|
'hostname' => 'localhost',
|
|
|
|
], // Current host is added on app init
|
|
|
|
],
|
|
|
|
'legalName' => '',
|
|
|
|
'legalCountry' => '',
|
|
|
|
'legalState' => '',
|
|
|
|
'legalCity' => '',
|
|
|
|
'legalAddress' => '',
|
|
|
|
'legalTaxId' => '',
|
2021-08-06 20:34:17 +12:00
|
|
|
'auths' => [
|
2022-11-18 21:51:28 +13:00
|
|
|
'invites' => App::getEnv('_APP_CONSOLE_INVITES', 'enabled') === 'enabled',
|
2021-08-06 20:34:17 +12:00
|
|
|
'limit' => (App::getEnv('_APP_CONSOLE_WHITELIST_ROOT', 'enabled') === 'enabled') ? 1 : 0, // limit signup to 1 user
|
2022-11-14 22:30:45 +13:00
|
|
|
'duration' => Auth::TOKEN_EXPIRATION_LOGIN_LONG, // 1 Year in seconds
|
2021-08-06 20:34:17 +12:00
|
|
|
],
|
2021-05-16 21:18:34 +12:00
|
|
|
'authWhitelistEmails' => (!empty(App::getEnv('_APP_CONSOLE_WHITELIST_EMAILS', null))) ? \explode(',', App::getEnv('_APP_CONSOLE_WHITELIST_EMAILS', null)) : [],
|
|
|
|
'authWhitelistIPs' => (!empty(App::getEnv('_APP_CONSOLE_WHITELIST_IPS', null))) ? \explode(',', App::getEnv('_APP_CONSOLE_WHITELIST_IPS', null)) : [],
|
2023-04-18 00:22:47 +12:00
|
|
|
'authProviders' => [
|
|
|
|
'githubEnabled' => true,
|
2023-04-26 20:22:20 +12:00
|
|
|
'githubSecret' => App::getEnv('_APP_CONSOLE_GITHUB_SECRET', ''),
|
|
|
|
'githubAppid' => App::getEnv('_APP_CONSOLE_GITHUB_APP_ID', '')
|
2023-04-18 00:22:47 +12:00
|
|
|
],
|
2021-05-16 21:18:34 +12:00
|
|
|
]);
|
|
|
|
}, []);
|
2020-06-30 16:34:13 +12:00
|
|
|
|
2022-10-16 03:14:17 +13:00
|
|
|
App::setResource('dbForProject', function (Group $pools, Database $dbForConsole, Cache $cache, Document $project) {
|
2022-10-19 21:35:30 +13:00
|
|
|
if ($project->isEmpty() || $project->getId() === 'console') {
|
2022-10-16 03:14:17 +13:00
|
|
|
return $dbForConsole;
|
|
|
|
}
|
2021-05-03 20:28:31 +12:00
|
|
|
|
2022-10-15 21:52:50 +13:00
|
|
|
$dbAdapter = $pools
|
2022-10-16 03:14:17 +13:00
|
|
|
->get($project->getAttribute('database'))
|
2022-10-15 21:52:50 +13:00
|
|
|
->pop()
|
|
|
|
->getResource()
|
|
|
|
;
|
|
|
|
|
|
|
|
$database = new Database($dbAdapter, $cache);
|
2022-10-19 21:35:30 +13:00
|
|
|
$database->setNamespace('_' . $project->getInternalId());
|
2021-05-03 20:28:31 +12:00
|
|
|
|
|
|
|
return $database;
|
2022-10-16 03:14:17 +13:00
|
|
|
}, ['pools', 'dbForConsole', 'cache', 'project']);
|
2022-10-15 21:52:50 +13:00
|
|
|
|
|
|
|
App::setResource('dbForConsole', function (Group $pools, Cache $cache) {
|
|
|
|
$dbAdapter = $pools
|
|
|
|
->get('console')
|
|
|
|
->pop()
|
|
|
|
->getResource()
|
|
|
|
;
|
2021-05-04 21:31:26 +12:00
|
|
|
|
2022-10-15 21:52:50 +13:00
|
|
|
$database = new Database($dbAdapter, $cache);
|
2021-05-04 21:31:26 +12:00
|
|
|
|
2023-08-17 11:34:54 +12:00
|
|
|
$database->setNamespace('_console');
|
2021-05-04 21:31:26 +12:00
|
|
|
|
|
|
|
return $database;
|
2022-10-15 21:52:50 +13:00
|
|
|
}, ['pools', 'cache']);
|
2022-07-28 04:59:27 +12:00
|
|
|
|
2023-05-23 16:37:25 +12:00
|
|
|
App::setResource('getProjectDB', function (Group $pools, Database $dbForConsole, $cache) {
|
|
|
|
$databases = []; // TODO: @Meldiron This should probably be responsibility of utopia-php/pools
|
|
|
|
|
|
|
|
$getProjectDB = function (Document $project) use ($pools, $dbForConsole, $cache, &$databases) {
|
|
|
|
if ($project->isEmpty() || $project->getId() === 'console') {
|
|
|
|
return $dbForConsole;
|
|
|
|
}
|
|
|
|
|
|
|
|
$databaseName = $project->getAttribute('database');
|
|
|
|
|
|
|
|
if (isset($databases[$databaseName])) {
|
|
|
|
$database = $databases[$databaseName];
|
|
|
|
$database->setNamespace('_' . $project->getInternalId());
|
|
|
|
return $database;
|
|
|
|
}
|
|
|
|
|
|
|
|
$dbAdapter = $pools
|
|
|
|
->get($databaseName)
|
|
|
|
->pop()
|
|
|
|
->getResource();
|
|
|
|
|
|
|
|
$database = new Database($dbAdapter, $cache);
|
|
|
|
|
|
|
|
$databases[$databaseName] = $database;
|
|
|
|
|
|
|
|
$database->setNamespace('_' . $project->getInternalId());
|
|
|
|
|
|
|
|
return $database;
|
|
|
|
};
|
|
|
|
|
|
|
|
return $getProjectDB;
|
|
|
|
}, ['pools', 'dbForConsole', 'cache']);
|
|
|
|
|
2022-10-16 03:14:17 +13:00
|
|
|
App::setResource('cache', function (Group $pools) {
|
2022-10-17 00:42:00 +13:00
|
|
|
$list = Config::getParam('pools-cache', []);
|
|
|
|
$adapters = [];
|
2022-10-19 21:35:30 +13:00
|
|
|
|
2022-10-17 00:42:00 +13:00
|
|
|
foreach ($list as $value) {
|
|
|
|
$adapters[] = $pools
|
|
|
|
->get($value)
|
|
|
|
->pop()
|
|
|
|
->getResource()
|
|
|
|
;
|
|
|
|
}
|
2021-05-04 21:31:26 +12:00
|
|
|
|
2022-10-17 00:42:00 +13:00
|
|
|
return new Cache(new Sharding($adapters));
|
2022-10-16 03:14:17 +13:00
|
|
|
}, ['pools']);
|
2022-01-07 23:02:38 +13:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('deviceLocal', function () {
|
2021-12-13 20:34:15 +13:00
|
|
|
return new Local();
|
|
|
|
});
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('deviceFiles', function ($project) {
|
2022-02-17 21:26:24 +13:00
|
|
|
return getDevice(APP_STORAGE_UPLOADS . '/app-' . $project->getId());
|
2021-12-13 20:34:15 +13:00
|
|
|
}, ['project']);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('deviceFunctions', function ($project) {
|
2022-02-17 21:26:24 +13:00
|
|
|
return getDevice(APP_STORAGE_FUNCTIONS . '/app-' . $project->getId());
|
|
|
|
}, ['project']);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('deviceBuilds', function ($project) {
|
2022-02-17 21:26:24 +13:00
|
|
|
return getDevice(APP_STORAGE_BUILDS . '/app-' . $project->getId());
|
|
|
|
}, ['project']);
|
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
function getDevice($root): Device
|
|
|
|
{
|
2022-11-17 19:36:41 +13:00
|
|
|
$connection = App::getEnv('_APP_CONNECTIONS_STORAGE', '');
|
2022-10-26 19:46:22 +13:00
|
|
|
|
2023-08-23 22:08:48 +12:00
|
|
|
if (!empty($connection)) {
|
|
|
|
$acl = 'private';
|
|
|
|
$device = Storage::DEVICE_LOCAL;
|
|
|
|
$accessKey = '';
|
|
|
|
$accessSecret = '';
|
|
|
|
$bucket = '';
|
|
|
|
$region = '';
|
|
|
|
|
|
|
|
try {
|
|
|
|
$dsn = new DSN($connection);
|
|
|
|
$device = $dsn->getScheme();
|
2023-08-23 23:52:17 +12:00
|
|
|
$accessKey = $dsn->getUser() ?? '';
|
|
|
|
$accessSecret = $dsn->getPassword() ?? '';
|
|
|
|
$bucket = $dsn->getPath() ?? '';
|
2023-08-23 22:08:48 +12:00
|
|
|
$region = $dsn->getParam('region');
|
|
|
|
} catch (\Exception $e) {
|
2023-08-23 23:52:17 +12:00
|
|
|
Console::warning($e->getMessage() . 'Invalid DSN. Defaulting to Local device.');
|
2023-08-23 22:08:48 +12:00
|
|
|
}
|
2022-10-26 19:46:22 +13:00
|
|
|
|
2023-08-23 22:08:48 +12:00
|
|
|
switch ($device) {
|
|
|
|
case Storage::DEVICE_S3:
|
|
|
|
return new S3($root, $accessKey, $accessSecret, $bucket, $region, $acl);
|
|
|
|
case STORAGE::DEVICE_DO_SPACES:
|
|
|
|
return new DOSpaces($root, $accessKey, $accessSecret, $bucket, $region, $acl);
|
|
|
|
case Storage::DEVICE_BACKBLAZE:
|
|
|
|
return new Backblaze($root, $accessKey, $accessSecret, $bucket, $region, $acl);
|
|
|
|
case Storage::DEVICE_LINODE:
|
|
|
|
return new Linode($root, $accessKey, $accessSecret, $bucket, $region, $acl);
|
|
|
|
case Storage::DEVICE_WASABI:
|
|
|
|
return new Wasabi($root, $accessKey, $accessSecret, $bucket, $region, $acl);
|
|
|
|
case Storage::DEVICE_LOCAL:
|
|
|
|
default:
|
|
|
|
return new Local($root);
|
|
|
|
}
|
|
|
|
} else {
|
2023-08-23 23:52:17 +12:00
|
|
|
switch (strtolower(App::getEnv('_APP_STORAGE_DEVICE', Storage::DEVICE_LOCAL) ?? '')) {
|
2023-08-23 22:08:48 +12:00
|
|
|
case Storage::DEVICE_LOCAL:
|
|
|
|
default:
|
|
|
|
return new Local($root);
|
|
|
|
case Storage::DEVICE_S3:
|
|
|
|
$s3AccessKey = App::getEnv('_APP_STORAGE_S3_ACCESS_KEY', '');
|
|
|
|
$s3SecretKey = App::getEnv('_APP_STORAGE_S3_SECRET', '');
|
|
|
|
$s3Region = App::getEnv('_APP_STORAGE_S3_REGION', '');
|
|
|
|
$s3Bucket = App::getEnv('_APP_STORAGE_S3_BUCKET', '');
|
|
|
|
$s3Acl = 'private';
|
|
|
|
return new S3($root, $s3AccessKey, $s3SecretKey, $s3Bucket, $s3Region, $s3Acl);
|
|
|
|
case Storage::DEVICE_DO_SPACES:
|
|
|
|
$doSpacesAccessKey = App::getEnv('_APP_STORAGE_DO_SPACES_ACCESS_KEY', '');
|
|
|
|
$doSpacesSecretKey = App::getEnv('_APP_STORAGE_DO_SPACES_SECRET', '');
|
|
|
|
$doSpacesRegion = App::getEnv('_APP_STORAGE_DO_SPACES_REGION', '');
|
|
|
|
$doSpacesBucket = App::getEnv('_APP_STORAGE_DO_SPACES_BUCKET', '');
|
|
|
|
$doSpacesAcl = 'private';
|
|
|
|
return new DOSpaces($root, $doSpacesAccessKey, $doSpacesSecretKey, $doSpacesBucket, $doSpacesRegion, $doSpacesAcl);
|
|
|
|
case Storage::DEVICE_BACKBLAZE:
|
|
|
|
$backblazeAccessKey = App::getEnv('_APP_STORAGE_BACKBLAZE_ACCESS_KEY', '');
|
|
|
|
$backblazeSecretKey = App::getEnv('_APP_STORAGE_BACKBLAZE_SECRET', '');
|
|
|
|
$backblazeRegion = App::getEnv('_APP_STORAGE_BACKBLAZE_REGION', '');
|
|
|
|
$backblazeBucket = App::getEnv('_APP_STORAGE_BACKBLAZE_BUCKET', '');
|
|
|
|
$backblazeAcl = 'private';
|
|
|
|
return new Backblaze($root, $backblazeAccessKey, $backblazeSecretKey, $backblazeBucket, $backblazeRegion, $backblazeAcl);
|
|
|
|
case Storage::DEVICE_LINODE:
|
|
|
|
$linodeAccessKey = App::getEnv('_APP_STORAGE_LINODE_ACCESS_KEY', '');
|
|
|
|
$linodeSecretKey = App::getEnv('_APP_STORAGE_LINODE_SECRET', '');
|
|
|
|
$linodeRegion = App::getEnv('_APP_STORAGE_LINODE_REGION', '');
|
|
|
|
$linodeBucket = App::getEnv('_APP_STORAGE_LINODE_BUCKET', '');
|
|
|
|
$linodeAcl = 'private';
|
|
|
|
return new Linode($root, $linodeAccessKey, $linodeSecretKey, $linodeBucket, $linodeRegion, $linodeAcl);
|
|
|
|
case Storage::DEVICE_WASABI:
|
|
|
|
$wasabiAccessKey = App::getEnv('_APP_STORAGE_WASABI_ACCESS_KEY', '');
|
|
|
|
$wasabiSecretKey = App::getEnv('_APP_STORAGE_WASABI_SECRET', '');
|
|
|
|
$wasabiRegion = App::getEnv('_APP_STORAGE_WASABI_REGION', '');
|
|
|
|
$wasabiBucket = App::getEnv('_APP_STORAGE_WASABI_BUCKET', '');
|
|
|
|
$wasabiAcl = 'private';
|
|
|
|
return new Wasabi($root, $wasabiAccessKey, $wasabiSecretKey, $wasabiBucket, $wasabiRegion, $wasabiAcl);
|
|
|
|
}
|
2021-12-13 20:34:15 +13:00
|
|
|
}
|
2022-02-17 21:26:24 +13:00
|
|
|
}
|
2021-12-13 20:34:15 +13:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('mode', function ($request) {
|
2022-01-01 04:50:07 +13:00
|
|
|
/** @var Appwrite\Utopia\Request $request */
|
2021-12-15 00:15:00 +13:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Defines the mode for the request:
|
|
|
|
* - 'default' => Requests for Client and Server Side
|
|
|
|
* - 'admin' => Request from the Console on non-console projects
|
|
|
|
*/
|
2020-11-19 11:08:45 +13:00
|
|
|
return $request->getParam('mode', $request->getHeader('x-appwrite-mode', APP_MODE_DEFAULT));
|
2020-07-01 06:08:02 +12:00
|
|
|
}, ['request']);
|
2020-07-03 08:24:14 +12:00
|
|
|
|
2022-05-24 02:54:50 +12:00
|
|
|
App::setResource('geodb', function ($register) {
|
2020-10-30 04:54:36 +13:00
|
|
|
/** @var Utopia\Registry\Registry $register */
|
2020-10-30 03:08:09 +13:00
|
|
|
return $register->get('geodb');
|
2020-10-30 04:54:36 +13:00
|
|
|
}, ['register']);
|
2022-06-08 21:00:38 +12:00
|
|
|
|
2022-12-26 22:19:06 +13:00
|
|
|
App::setResource('passwordsDictionary', function ($register) {
|
2022-12-23 20:19:11 +13:00
|
|
|
/** @var Utopia\Registry\Registry $register */
|
2022-12-26 22:24:51 +13:00
|
|
|
return $register->get('passwordsDictionary');
|
2022-12-23 20:19:11 +13:00
|
|
|
}, ['register']);
|
|
|
|
|
2022-08-15 01:43:41 +12:00
|
|
|
App::setResource('sms', function () {
|
|
|
|
$dsn = new DSN(App::getEnv('_APP_SMS_PROVIDER'));
|
2022-06-21 00:22:35 +12:00
|
|
|
$user = $dsn->getUser();
|
|
|
|
$secret = $dsn->getPassword();
|
2022-06-08 21:00:38 +12:00
|
|
|
|
2022-06-21 00:22:35 +12:00
|
|
|
return match ($dsn->getHost()) {
|
2022-09-19 20:09:48 +12:00
|
|
|
'mock' => new Mock($user, $secret), // used for tests
|
2022-06-08 21:00:38 +12:00
|
|
|
'twilio' => new Twilio($user, $secret),
|
|
|
|
'text-magic' => new TextMagic($user, $secret),
|
|
|
|
'telesign' => new Telesign($user, $secret),
|
2022-07-10 02:04:57 +12:00
|
|
|
'msg91' => new Msg91($user, $secret),
|
2022-07-13 03:45:22 +12:00
|
|
|
'vonage' => new Vonage($user, $secret),
|
2022-06-08 21:00:38 +12:00
|
|
|
default => null
|
|
|
|
};
|
2022-06-09 02:18:28 +12:00
|
|
|
});
|
2022-08-11 01:45:04 +12:00
|
|
|
|
|
|
|
App::setResource('servers', function () {
|
|
|
|
$platforms = Config::getParam('platforms');
|
|
|
|
$server = $platforms[APP_PLATFORM_SERVER];
|
|
|
|
|
|
|
|
$languages = array_map(function ($language) {
|
|
|
|
return strtolower($language['name']);
|
2023-05-24 01:43:03 +12:00
|
|
|
}, $server['sdks']);
|
2022-08-11 01:45:04 +12:00
|
|
|
|
|
|
|
return $languages;
|
2022-08-11 01:49:56 +12:00
|
|
|
});
|
2023-05-24 01:43:03 +12:00
|
|
|
|
|
|
|
App::setResource('promiseAdapter', function ($register) {
|
|
|
|
return $register->get('promiseAdapter');
|
|
|
|
}, ['register']);
|
|
|
|
|
|
|
|
App::setResource('schema', function ($utopia, $dbForProject) {
|
|
|
|
|
|
|
|
$complexity = function (int $complexity, array $args) {
|
|
|
|
$queries = Query::parseQueries($args['queries'] ?? []);
|
2023-05-01 21:18:50 +12:00
|
|
|
$query = Query::getByType($queries, [Query::TYPE_LIMIT])[0] ?? null;
|
2023-05-24 01:43:03 +12:00
|
|
|
$limit = $query ? $query->getValue() : APP_LIMIT_LIST_DEFAULT;
|
|
|
|
|
|
|
|
return $complexity * $limit;
|
|
|
|
};
|
|
|
|
|
|
|
|
$attributes = function (int $limit, int $offset) use ($dbForProject) {
|
|
|
|
$attrs = Authorization::skip(fn() => $dbForProject->find('attributes', [
|
|
|
|
Query::limit($limit),
|
|
|
|
Query::offset($offset),
|
|
|
|
]));
|
|
|
|
|
|
|
|
return \array_map(function ($attr) {
|
|
|
|
return $attr->getArrayCopy();
|
|
|
|
}, $attrs);
|
|
|
|
};
|
|
|
|
|
|
|
|
$urls = [
|
|
|
|
'list' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
return "/v1/databases/$databaseId/collections/$collectionId/documents";
|
|
|
|
},
|
|
|
|
'create' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
return "/v1/databases/$databaseId/collections/$collectionId/documents";
|
|
|
|
},
|
|
|
|
'read' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
return "/v1/databases/$databaseId/collections/$collectionId/documents/{$args['documentId']}";
|
|
|
|
},
|
|
|
|
'update' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
return "/v1/databases/$databaseId/collections/$collectionId/documents/{$args['documentId']}";
|
|
|
|
},
|
|
|
|
'delete' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
return "/v1/databases/$databaseId/collections/$collectionId/documents/{$args['documentId']}";
|
|
|
|
},
|
|
|
|
];
|
|
|
|
|
|
|
|
$params = [
|
|
|
|
'list' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
return [ 'queries' => $args['queries']];
|
|
|
|
},
|
|
|
|
'create' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
$id = $args['id'] ?? 'unique()';
|
|
|
|
$permissions = $args['permissions'] ?? null;
|
|
|
|
|
|
|
|
unset($args['id']);
|
|
|
|
unset($args['permissions']);
|
|
|
|
|
|
|
|
// Order must be the same as the route params
|
|
|
|
return [
|
|
|
|
'databaseId' => $databaseId,
|
|
|
|
'documentId' => $id,
|
|
|
|
'collectionId' => $collectionId,
|
|
|
|
'data' => $args,
|
|
|
|
'permissions' => $permissions,
|
|
|
|
];
|
|
|
|
},
|
|
|
|
'update' => function (string $databaseId, string $collectionId, array $args) {
|
|
|
|
$documentId = $args['id'];
|
|
|
|
$permissions = $args['permissions'] ?? null;
|
|
|
|
|
|
|
|
unset($args['id']);
|
|
|
|
unset($args['permissions']);
|
|
|
|
|
|
|
|
// Order must be the same as the route params
|
|
|
|
return [
|
|
|
|
'databaseId' => $databaseId,
|
|
|
|
'collectionId' => $collectionId,
|
|
|
|
'documentId' => $documentId,
|
|
|
|
'data' => $args,
|
|
|
|
'permissions' => $permissions,
|
|
|
|
];
|
|
|
|
},
|
|
|
|
];
|
|
|
|
|
|
|
|
return Schema::build(
|
|
|
|
$utopia,
|
|
|
|
$complexity,
|
|
|
|
$attributes,
|
|
|
|
$urls,
|
|
|
|
$params,
|
|
|
|
);
|
|
|
|
}, ['utopia', 'dbForProject']);
|
2023-07-10 15:06:48 +12:00
|
|
|
|
2023-04-26 20:21:10 +12:00
|
|
|
App::setResource('contributors', function () {
|
2023-08-30 06:25:00 +12:00
|
|
|
$path = 'app/config/contributors.json';
|
2023-04-26 20:21:10 +12:00
|
|
|
$list = (file_exists($path)) ? json_decode(file_get_contents($path), true) : [];
|
|
|
|
return $list;
|
2023-08-30 06:25:00 +12:00
|
|
|
});
|
2023-04-26 20:21:10 +12:00
|
|
|
|
|
|
|
App::setResource('employees', function () {
|
2023-08-30 06:25:00 +12:00
|
|
|
$path = 'app/config/employees.json';
|
2023-04-26 20:21:10 +12:00
|
|
|
$list = (file_exists($path)) ? json_decode(file_get_contents($path), true) : [];
|
|
|
|
return $list;
|
2023-08-30 06:25:00 +12:00
|
|
|
});
|
2023-04-26 20:21:10 +12:00
|
|
|
|
|
|
|
App::setResource('heroes', function () {
|
2023-08-30 06:25:00 +12:00
|
|
|
$path = 'app/config/heroes.json';
|
2023-04-26 20:21:10 +12:00
|
|
|
$list = (file_exists($path)) ? json_decode(file_get_contents($path), true) : [];
|
|
|
|
return $list;
|
2023-08-30 06:25:00 +12:00
|
|
|
});
|
2023-05-26 20:44:08 +12:00
|
|
|
|
|
|
|
App::setResource('gitHub', function (Cache $cache) {
|
|
|
|
return new VcsGitHub($cache);
|
|
|
|
}, ['cache']);
|
2023-08-06 19:31:32 +12:00
|
|
|
|
2023-01-20 13:36:17 +13:00
|
|
|
App::setResource('requestTimestamp', function ($request) {
|
2023-04-12 02:59:45 +12:00
|
|
|
//TODO: Move this to the Request class itself
|
2023-01-20 13:36:17 +13:00
|
|
|
$timestampHeader = $request->getHeader('x-appwrite-timestamp');
|
|
|
|
$requestTimestamp = null;
|
|
|
|
if (!empty($timestampHeader)) {
|
|
|
|
try {
|
|
|
|
$requestTimestamp = new \DateTime($timestampHeader);
|
|
|
|
} catch (\Throwable $e) {
|
|
|
|
throw new Exception(Exception::GENERAL_ARGUMENT_INVALID, 'Invalid X-Appwrite-Timestamp header value');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $requestTimestamp;
|
|
|
|
}, ['request']);
|