Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\Support\Laravel;

use Clockwork\Clockwork;

use Clockwork\Authentication\NullAuthenticator;

use Clockwork\Authentication\SimpleAuthenticator;

use Clockwork\DataSource\PhpDataSource;

use Clockwork\Helpers\Serializer;

use Clockwork\Helpers\ServerTiming;

use Clockwork\Helpers\StackFilter;

use Clockwork\Helpers\StackTrace;

use Clockwork\Request\IncomingRequest;

use Clockwork\Request\Request;

use Clockwork\Storage\FileStorage;

use Clockwork\Storage\Search;

use Clockwork\Storage\SqlStorage;

use Clockwork\Web\Web;

use Illuminate\Contracts\Foundation\Application;

use Illuminate\Contracts\Console\Kernel as ConsoleKernel;

use Illuminate\Http\JsonResponse;

use Illuminate\Http\Response;

use Illuminate\Redis\RedisManager;

use Symfony\Component\HttpFoundation\BinaryFileResponse;

use Symfony\Component\HttpFoundation\Cookie;

use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

// Support class for the Laravel integration

class ClockworkSupport

{

	// Laravel application instance

	protected $app;

	// Laravel artisan (console application) instance

	protected $artisan;

	// Incoming request instance

	protected $incomingRequest;

	public function __construct(Application $app)

	{

		$this->app = $app;

	}

	// Get a value form the Clockwork config

	public function getConfig($key, $default = null)

	{

		return $this->app['config']->get("clockwork.{$key}", $default);

	}

	// Retrieve metadata

	public function getData($id = null, $direction = null, $count = null, $filter = [], $extended = false)

	{

		if (isset($this->app['session'])) $this->app['session.store']->reflash();

		$authenticator = $this->app['clockwork']->authenticator();

		$storage = $this->app['clockwork']->storage();

		$authenticated = $authenticator->check($this->app['request']->header('X-Clockwork-Auth'));

		if ($authenticated !== true) {

			return new JsonResponse([ 'message' => $authenticated, 'requires' => $authenticator->requires() ], 403);

		}

		if ($direction == 'previous') {

			$data = $storage->previous($id, $count, Search::fromRequest($this->app['request']->all()));

		} elseif ($direction == 'next') {

			$data = $storage->next($id, $count, Search::fromRequest($this->app['request']->all()));

		} elseif ($id == 'latest') {

			$data = $storage->latest(Search::fromRequest($this->app['request']->all()));

		} else {

			$data = $storage->find($id);

		}

		if ($extended) {

			$this->addDataSources();

			$this->app['clockwork']->extendRequest($data);

		}

		$except = isset($filter['except']) ? explode(',', $filter['except']) : [];

		$only = isset($filter['only']) ? explode(',', $filter['only']) : null;

		if (is_array($data)) {

			$data = array_map(function ($request) use ($except, $only) {

				return $only ? $request->only(array_diff($only, [ 'updateToken' ])) : $request->except(array_merge($except, [ 'updateToken' ]));

			}, $data);

		} elseif ($data) {

			$data = $only ? $data->only(array_diff($only, [ 'updateToken' ])) : $data->except(array_merge($except, [ 'updateToken' ]));

		}

		return new JsonResponse($data);

	}

	// Retrieve extended metadata

	public function getExtendedData($id, $filter = [])

	{

		return $this->getData($id, null, null, $filter, true);

	}

	// Update metadata

	public function updateData($id, $input = [])

	{

		if (isset($this->app['session'])) $this->app['session.store']->reflash();

		if (! $this->isCollectingClientMetrics()) {

			throw new NotFoundHttpException;

		}

		$storage = $this->app['clockwork']->storage();

		$request = $storage->find($id);

		if (! $request) {

			return new JsonResponse([ 'message' => 'Request not found.' ], 404);

		}

		$token = isset($input['_token']) ? $input['_token'] : '';

		if (! $request->updateToken || ! hash_equals($request->updateToken, $token)) {

			return new JsonResponse([ 'message' => 'Invalid update token.' ], 403);

		}

		foreach ($input as $key => $value) {

			if (in_array($key, [ 'clientMetrics', 'webVitals' ])) {

				$request->$key = $value;

			}

		}

		$storage->update($request);

	}

	// Return an asset for web ui based on it's path, resolves correct mime-type and protectes from accessing files

	// outside of Clockwork public dir

	public function getWebAsset($path)

	{

		$asset = (new Web)->asset($path);

		if (! $asset) throw new NotFoundHttpException;

		return new BinaryFileResponse($asset['path'], 200, [ 'Content-Type' => $asset['mime'] ]);

	}

	// Add enabled data sources

	public function addDataSources()

	{

		$clockwork = $this->app['clockwork'];

		$clockwork

			->addDataSource(new PhpDataSource)

			->addDataSource($this->frameworkDataSource());

		if ($this->isFeatureEnabled('database')) $clockwork->addDataSource($this->app['clockwork.eloquent']);

		if ($this->isFeatureEnabled('cache')) $clockwork->addDataSource($this->app['clockwork.cache']);

		if ($this->isFeatureEnabled('redis')) $clockwork->addDataSource($this->app['clockwork.redis']);

		if ($this->isFeatureEnabled('queue')) $clockwork->addDataSource($this->app['clockwork.queue']);

		if ($this->isFeatureEnabled('events')) $clockwork->addDataSource($this->app['clockwork.events']);

		if ($this->isFeatureEnabled('notifications')) {

			$clockwork->addDataSource(

				$this->isFeatureAvailable('notifications-events')

					? $this->app['clockwork.notifications'] : $this->app['clockwork.swift']

			);

		}

		if ($this->isFeatureAvailable('xdebug')) $clockwork->addDataSource($this->app['clockwork.xdebug']);

		if ($this->isFeatureEnabled('views')) {

			$clockwork->addDataSource(

				$this->getConfig('features.views.use_twig_profiler', false)

					? $this->app['clockwork.twig'] : $this->app['clockwork.views']

			);

		}

		return $this;

	}

	// Start listening to events

	public function listenToEvents()

	{

		$this->frameworkDataSource()->listenToEvents();

		if ($this->isFeatureEnabled('cache')) $this->app['clockwork.cache']->listenToEvents();

		if ($this->isFeatureEnabled('database')) $this->app['clockwork.eloquent']->listenToEvents();

		if ($this->isFeatureEnabled('events')) $this->app['clockwork.events']->listenToEvents();

		if ($this->isFeatureEnabled('notifications')) {

			$this->isFeatureAvailable('notifications-events')

				? $this->app['clockwork.notifications']->listenToEvents() : $this->app['clockwork.swift']->listenToEvents();

		}

		if ($this->isFeatureEnabled('queue')) {

			$this->app['clockwork.queue']->listenToEvents();

			$this->app['clockwork.queue']->setCurrentRequestId($this->app['clockwork.request']->id);

		}

		if ($this->isFeatureEnabled('redis')) {

			$this->app[RedisManager::class]->enableEvents();

			$this->app['clockwork.redis']->listenToEvents();

		}

		if ($this->isFeatureEnabled('views')) {

			$this->getConfig('features.views.use_twig_profiler', false)

				? $this->app['clockwork.twig']->listenToEvents() : $this->app['clockwork.views']->listenToEvents();

		}

		if ($this->isCollectingCommands()) $this->collectCommands();

		if ($this->isCollectingQueueJobs()) $this->collectQueueJobs();

		return $this;

	}

	// Resolves the framework data source from the container

	protected function frameworkDataSource()

	{

		return $this->app['clockwork.laravel'];

	}

	public function handleArtisanEvents()

	{

		if (class_exists(\Illuminate\Console\Events\ArtisanStarting::class)) {

			$this->app['events']->listen(\Illuminate\Console\Events\ArtisanStarting::class, function ($event) {

				$this->artisan = $event->artisan;

			});

		}

	}

	public function handleOctaneEvents()

	{

		$this->app['events']->listen(\Laravel\Octane\Events\RequestReceived::class, function ($event) {

			$this->app = $event->sandbox;

			$this->incomingRequest = null;

			$this->app->forgetInstance('clockwork.request');

			$request = $this->app->make('clockwork.request')->override('requestTime', microtime(true));

			$this->app['clockwork']->reset()->request($request);

			$this->app['clockwork.laravel']->setApplication($this->app);

		});

	}

	// Make a storage instance based on the current configuration

	public function makeStorage()

	{

		$expiration = $this->getConfig('storage_expiration');

		if ($this->getConfig('storage', 'files') == 'sql') {

			$database = $this->getConfig('storage_sql_database', storage_path('clockwork.sqlite'));

			$table = $this->getConfig('storage_sql_table', 'clockwork');

			if ($this->app['config']->get("database.connections.{$database}")) {

				$database = $this->app['db']->connection($database)->getPdo();

			} else {

				$database = "sqlite:{$database}";

			}

			return new SqlStorage($database, $table, null, null, $expiration);

		} else {

			return new FileStorage(

				$this->getConfig('storage_files_path', storage_path('clockwork')),

				0700,

				$expiration,

				$this->getConfig('storage_files_compress', false)

			);

		}

	}

	// Make an authenticator instance based on the current configuration

	public function makeAuthenticator()

	{

		$authenticator = $this->getConfig('authentication');

		if (is_string($authenticator)) {

			return $this->app->make($authenticator);

		} elseif ($authenticator) {

			return new SimpleAuthenticator($this->getConfig('authentication_password'));

		} else {

			return new NullAuthenticator;

		}

	}

	// Set up collecting of executed artisan commands

	public function collectCommands()

	{

		$this->app['events']->listen(\Illuminate\Console\Events\CommandStarting::class, function ($event) {

			// only collect commands ran through artisan cli, other commands are recorded as part of respective request

			if (basename(StackTrace::get()->last()->file) != 'artisan') return;

			if (! $this->getConfig('artisan.collect_output')) return;

			if (! $event->command || $this->isCommandFiltered($event->command)) return;

			$event->output->setFormatter(

				version_compare(\Illuminate\Foundation\Application::VERSION, '9.0.0', '<')

					? new Console\CapturingLegacyFormatter($event->output->getFormatter())

					: new Console\CapturingFormatter($event->output->getFormatter())

			);

		});

		$this->app['events']->listen(\Illuminate\Console\Events\CommandFinished::class, function ($event) {

			// only collect commands ran through artisan cli, other commands are recorded as part of respective request

			if (basename(StackTrace::get()->last()->file) != 'artisan') return;

			if (! $event->command || $this->isCommandFiltered($event->command)) return;

			$command = $this->artisan->find($event->command);

			$allArguments = $event->input->getArguments();

			$allOptions = $event->input->getOptions();

			$defaultArguments = $command->getDefinition()->getArgumentDefaults();

			$defaultOptions = $command->getDefinition()->getOptionDefaults();

			$this->app->make('clockwork')

				->resolveAsCommand(

					$event->command,

					$event->exitCode,

					array_udiff_assoc($allArguments, $defaultArguments, function ($a, $b) { return $a == $b ? 0 : 1; }),

					array_udiff_assoc($allOptions, $defaultOptions, function ($a, $b) { return $a == $b ? 0 : 1; }),

					$defaultArguments,

					$defaultOptions,

					$this->getConfig('artisan.collect_output') ? $event->output->getFormatter()->capturedOutput() : null

				)

				->storeRequest();

		});

	}

	// Set up collecting of executed queue jobs

	public function collectQueueJobs()

	{

		$this->app['events']->listen(\Illuminate\Queue\Events\JobProcessing::class, function ($event) {

			// sync jobs are recorded as part of the parent request

			if ($event->job instanceof \Illuminate\Queue\Jobs\SyncJob) return;

			$payload = $event->job->payload();

			if (! isset($payload['clockwork_id']) || $this->isQueueJobFiltered($payload['displayName'])) return;

			$request = new Request([ 'id' => $payload['clockwork_id'] ]);

			if (isset($payload['clockwork_parent_id'])) $request->setParent($payload['clockwork_parent_id']);

			$this->app->make('clockwork')->reset()->request($request);

			$this->app['clockwork.queue']->setCurrentRequestId($request->id);

		});

		$this->app['events']->listen(\Illuminate\Queue\Events\JobProcessed::class, function ($event) {

			$this->processQueueJob($event->job);

		});

		$this->app['events']->listen(\Illuminate\Queue\Events\JobFailed::class, function ($event) {

			$this->processQueueJob($event->job, $event->exception);

		});

	}

	// Process an executed queue job, resolves and records the current request

	protected function processQueueJob($job, $exception = null)

	{

		// sync jobs are recorded as part of the parent request

		if ($job instanceof \Illuminate\Queue\Jobs\SyncJob) return;

		$payload = $job->payload();

		if (! isset($payload['clockwork_id'])) return;

		$unserialized = isset($payload['data']['command']) ? unserialize($payload['data']['command']) : null;

		if (! $unserialized || $this->isQueueJobFiltered(get_class($unserialized))) return;

		if ($exception) {

			$this->app->make('clockwork')->error($exception->getMessage(), [ 'exception' => $exception ]);

		}

		$this->app->make('clockwork')

			->resolveAsQueueJob(

				get_class($unserialized),

				$payload['displayName'],

				$job->hasFailed() ? 'failed' : ($job->isReleased() ? 'released' : 'done'),

				$unserialized,

				$job->getQueue(),

				$job->getConnectionName(),

				array_filter([

					'maxTries'     => isset($payload['maxTries']) ? $payload['maxTries'] : null,

					'delaySeconds' => isset($payload['delaySeconds']) ? $payload['delaySeconds'] : null,

					'timeout'      => isset($payload['timeout']) ? $payload['timeout'] : null,

					'timeoutAt'    => isset($payload['timeoutAt']) ? $payload['timeoutAt'] : null

				])

			)

			->storeRequest();

	}

	// Process an executed http request, resolves the current request, sets Clockwork headers and cookies

	public function processRequest($request, $response)

	{

		if (! $this->isCollectingRequests()) {

			return $response; // Clockwork is not collecting data, additional check when the middleware is enabled manually

		}

		$clockwork = $this->app['clockwork'];

		$clockworkRequest = $clockwork->request();

		$clockwork->event('Controller')->end();

		$this->setResponse($response);

		$clockwork->resolveRequest();

		if (! $this->isEnabled() || ! $this->isRecording($clockworkRequest)) {

			return $response; // Clockwork is disabled or we are not recording this request

		}

		$response->headers->set('X-Clockwork-Id', $clockworkRequest->id, true);

		$response->headers->set('X-Clockwork-Version', Clockwork::VERSION, true);

		if ($request->getBasePath()) {

			$response->headers->set('X-Clockwork-Path', $request->getBasePath() . '/__clockwork/', true);

		}

		foreach ($this->getConfig('headers', []) as $headerName => $headerValue) {

			$response->headers->set("X-Clockwork-Header-{$headerName}", $headerValue);

		}

		foreach ($clockwork->request()->subrequests as $subrequest) {

			$url = urlencode($subrequest['url']);

			$path = urlencode($subrequest['path']);

			$response->headers->set('X-Clockwork-Subrequest', "{$subrequest['id']};{$url};{$path}", false);

		}

		$this->appendServerTimingHeader($response, $clockworkRequest);

		if (! ($response instanceof Response)) {

			return $response;

		}

		if ($this->isCollectingClientMetrics() || $this->isToolbarEnabled()) {

			$clockworkBrowser = [

				'requestId' => $clockworkRequest->id,

				'version'   => Clockwork::VERSION,

				'path'      => $request->getBasePath() . '/__clockwork/',

				'webPath'   => $request->getBasePath() . '/' . $this->webPaths()[0] . '/app',

				'token'     => $clockworkRequest->updateToken,

				'metrics'   => $this->isCollectingClientMetrics(),

				'toolbar'   => $this->isToolbarEnabled()

			];

			$response->cookie(

				new Cookie('x-clockwork', json_encode($clockworkBrowser), time() + 60, null, null, null, false)

			);

		}

		return $response;

	}

	// Records the current http request

	public function recordRequest()

	{

		if (! $this->isCollectingRequests()) {

			return; // Clockwork is not collecting data, additional check when the middleware is enabled manually

		}

		$clockwork = $this->app['clockwork'];

		if (! $this->isRecording($clockwork->request())) {

			return; // Collecting data is disabled, return immediately

		}

		$clockwork->storeRequest();

	}

	// Set current http response on the framework data source

	protected function setResponse($response)

	{

		$this->app['clockwork.laravel']->setResponse($response);

	}

	// Configure serializer defaults

	public function configureSerializer()

	{

		Serializer::defaults([

			'limit'       => $this->getConfig('serialization_depth'),

			'blackbox'    => $this->getConfig('serialization_blackbox'),

			'traces'      => $this->getConfig('stack_traces.enabled', true),

			'tracesSkip'  => StackFilter::make()

				->isNotVendor(array_merge(

					$this->getConfig('stack_traces.skip_vendors', []),

					[ 'itsgoingd', 'laravel', 'illuminate', 'psr' ]

				))

				->isNotNamespace($this->getConfig('stack_traces.skip_namespaces', []))

				->isNotFunction([ 'call_user_func', 'call_user_func_array' ])

				->isNotClass($this->getConfig('stack_traces.skip_classes', [])),

			'tracesLimit' => $this->getConfig('stack_traces.limit', 10)

		]);

		return $this;

	}

	// Configure should collect rules

	public function configureShouldCollect()

	{

		$this->app['clockwork']->shouldCollect([

			'onDemand'        => $this->getConfig('requests.on_demand', false),

			'sample'          => $this->getConfig('requests.sample', false),

			'except'          => $this->getConfig('requests.except', []),

			'only'            => $this->getConfig('requests.only', []),

			'exceptPreflight' => $this->getConfig('requests.except_preflight', [])

		]);

		// don't collect data for Clockwork requests

		$webPath = $this->webPaths()[0];

		$this->app['clockwork']->shouldCollect()->except([ '/__clockwork(?:/.*)?', "/{$webPath}(?:/.*)?" ]);

		return $this;

	}

	// Configure should record rules

	public function configureShouldRecord()

	{

		$this->app['clockwork']->shouldRecord([

			'errorsOnly' => $this->getConfig('requests.errors_only', false),

			'slowOnly'   => $this->getConfig('requests.slow_only', false) ? $this->getConfig('requests.slow_threshold') : false

		]);

		return $this;

	}

	// Check whether Clockwork is enabled at all

	public function isEnabled()

	{

		return $this->getConfig('enable')

			|| $this->getConfig('enable') === null && $this->app['config']->get('app.debug');

	}

	// Check whether we are collecting data

	public function isCollectingData()

	{

		return $this->isCollectingCommands()

			|| $this->isCollectingQueueJobs()

			|| $this->isCollectingRequests()

			|| $this->isCollectingTests();

	}

	// Check whether we are collecting artisan commands

	public function isCollectingCommands()

	{

		return ($this->isEnabled() || $this->getConfig('collect_data_always', false))

			&& $this->app->runningInConsole()

			&& $this->getConfig('artisan.collect', false);

	}

	// Check whether we are collecting queue jobs

	public function isCollectingQueueJobs()

	{

		return ($this->isEnabled() || $this->getConfig('collect_data_always', false))

			&& $this->app->runningInConsole()

			&& $this->getConfig('queue.collect', false);

	}

	// Check whether we are collecting http requests

	public function isCollectingRequests()

	{

		return ($this->isEnabled() || $this->getConfig('collect_data_always', false))

			&& ! $this->app->runningInConsole()

			&& $this->app['clockwork']->shouldCollect()->filter($this->incomingRequest());

	}

	// Check whether we are collecting tests

	public function isCollectingTests()

	{

		return ($this->isEnabled() || $this->getConfig('collect_data_always', false))

			&& $this->app->runningInConsole()

			&& $this->getConfig('tests.collect', false);

	}

	// Check whether we are recording the passed request

	public function isRecording($incomingRequest)

	{

		return ($this->isEnabled() || $this->getConfig('collect_data_always', false))

			&& $this->app['clockwork']->shouldRecord()->filter($incomingRequest);

	}

	// Check whether a feature is enabled

	public function isFeatureEnabled($feature)

	{

		return $this->getConfig("features.{$feature}.enabled") && $this->isFeatureAvailable($feature);

	}

	// Check whether a feature is available

	public function isFeatureAvailable($feature)

	{

		if ($feature == 'database') {

			return $this->app['config']->get('database.default');

		} elseif ($feature == 'notifications-events') {

			return class_exists(\Illuminate\Mail\Events\MessageSent::class)

				&& class_exists(\Illuminate\Notifications\Events\NotificationSent::class);

		} elseif ($feature == 'redis') {

			return method_exists(\Illuminate\Redis\RedisManager::class, 'enableEvents');

		} elseif ($feature == 'queue') {

			return method_exists(\Illuminate\Queue\Queue::class, 'createPayloadUsing');

		} elseif ($feature == 'xdebug') {

			return in_array('xdebug', get_loaded_extensions());

		}

		return true;

	}

	// Check whether we are collecting client metrics

	public function isCollectingClientMetrics()

	{

		return $this->getConfig('features.performance.client_metrics', true);

	}

	// Check whether the toolbar is enabled

	public function isToolbarEnabled()

	{

		return $this->getConfig('toolbar', false);

	}

	// Check whether the web ui is enabled

	public function isWebEnabled()

	{

		return $this->getConfig('web', true);

	}

	// Check whether a command should not be collected

	protected function isCommandFiltered($command)

	{

		$only = $this->getConfig('artisan.only', []);

		if (count($only)) return ! in_array($command, $only);

		$except = $this->getConfig('artisan.except', []);

		if ($this->getConfig('artisan.except_laravel_commands', true)) {

			$except = array_merge($except, $this->builtinLaravelCommands());

		}

		$except = array_merge($except, $this->builtinClockworkCommands());

		return in_array($command, $except);

	}

	// Check whether a queue job should not be collected

	protected function isQueueJobFiltered($queueJob)

	{

		$only = $this->getConfig('queue.only', []);

		if (count($only)) return ! in_array($queueJob, $only);

		$except = $this->getConfig('queue.except', []);

		return in_array($queueJob, $except);

	}

	// Check whether a test should not be collected

	public function isTestFiltered($test)

	{

		$except = $this->getConfig('tests.except', []);

		return in_array($test, $except);

	}

	// Append server timing headers from a Clockwork request to a http response

	protected function appendServerTimingHeader($response, $request)

	{

		if (($eventsCount = $this->getConfig('server_timing', 10)) !== false) {

			$response->headers->set('Server-Timing', ServerTiming::fromRequest($request, $eventsCount)->value());

		}

	}

	// Make an incoming request instance

	protected function incomingRequest()

	{

		if ($this->incomingRequest) return $this->incomingRequest;

		return $this->incomingRequest = new IncomingRequest([

			'method'  => $this->app['request']->getMethod(),

			'uri'     => $this->app['request']->getRequestUri(),

			'input'   => $this->app['request']->input(),

			'cookies' => $this->app['request']->cookie()

		]);

	}

	// Return an array of web ui paths

	public function webPaths()

	{

		$path = $this->getConfig('web', true);

		if (is_string($path)) return collect([ trim($path, '/') ]);

		return collect([ 'clockwork', '__clockwork' ]);

	}

	// Return an array of built-in Laravel commands

	protected function builtinLaravelCommands()

	{

		return [

			'clear-compiled', 'completion', 'db', 'down', 'dump-server', 'env', 'help', 'list', 'migrate', 'optimize',

			'preset', 'serve', 'test', 'tinker', 'up',

			'app:name',

			'auth:clear-resets',

			'cache:clear', 'cache:forget', 'cache:table',

			'config:cache', 'config:clear',

			'db:seed', 'db:wipe',

			'event:cache', 'event:clear', 'event:generate', 'event:list',

			'horizon', 'horizon:clear', 'horizon:continue', 'horizon:continue-supervisor', 'horizon:forget',

			'horizon:install', 'horizon:list', 'horizon:pause', 'horizon:pause-supervisor', 'horizon:publish',

			'horizon:purge', 'horizon:snapshot', 'horizon:status', 'horizon:supervisors', 'horizon:terminate',

			'horizon:work',

			'key:generate',

			'make:auth', 'make:cast', 'make:channel', 'make:command', 'make:component', 'make:controller', 'make:event',

			'make:exception', 'make:factory', 'make:job', 'make:listener', 'make:mail', 'make:middleware',

			'make:migration', 'make:model', 'make:notification', 'make:observer', 'make:policy', 'make:provider',

			'make:request', 'make:resource', 'make:rule', 'make:scope', 'make:seeder', 'make:test',

			'migrate:fresh', 'migrate:install', 'migrate:refresh', 'migrate:reset', 'migrate:rollback',

			'migrate:status',

			'model:prune',

			'notifications:table',

			'octane:install', 'octane:reload', 'octane:start', 'octane:status', 'octane:stop',

			'optimize:clear',

			'package:discover',

			'queue:batches-table', 'queue:clear', 'queue:failed', 'queue:failed-table', 'queue:flush', 'queue:forget',

			'queue:listen', 'queue:monitor', 'queue:prune-batches', 'queue:prune-failed', 'queue:restart',

			'queue:retry', 'queue:retry-batch', 'queue:table', 'queue:work',

			'route:cache', 'route:clear', 'route:list',

			'sail:install', 'sail:publish',

			'schedule:clear-cache', 'schedule:list', 'schedule:run', 'schedule:test', 'schedule:work',

			'schema:dump',

			'session:table',

			'storage:link',

			'stub:publish',

			'vendor:publish',

			'view:cache', 'view:clear'

		];

	}

	// Return an array of built-in Clockwork commands

	protected function builtinClockworkCommands()

	{

		return [

			'clockwork:clean'

		];

	}

}