@fleetbase/solid-engine 0.0.2

package/server/src/LegacyClient/SolidClient.php

@@ -0,0 +1,270 @@
+<?php
+
+namespace Fleetbase\Solid\LegacyClient;
+
+use EasyRdf\Graph;
+use Fleetbase\Solid\Client\Identity\IdentityProvider;
+use Fleetbase\Solid\Models\SolidIdentity;
+use Illuminate\Http\Client\Response;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Str;
+
+class SolidClient
+{
+    /**
+     * The host of the Solid server.
+     */
+    private string $host = 'localhost';
+
+    /**
+     * The port on which the Solid server is running.
+     */
+    private int $port = 3000;
+
+    /**
+     * Indicates whether the connection to the Solid server should be secure (HTTPS).
+     */
+    private bool $secure = true;
+
+    /**
+     * The identity provider for authentication with the Solid server.
+     */
+    public IdentityProvider $identity;
+
+    public bool $identityProviderInitialized = false;
+
+    private const DEFAULT_MIME_TYPE   = 'text/turtle';
+    private const LDP_BASIC_CONTAINER = 'http://www.w3.org/ns/ldp#BasicContainer';
+    private const LDP_RESOURCE        = 'http://www.w3.org/ns/ldp#Resource';
+    private const OIDC_ISSUER         = 'http://www.w3.org/ns/solid/terms#oidcIssuer';
+
+    /**
+     * Constructor for the SolidClient.
+     *
+     * Initializes the client with the provided options or defaults.
+     *
+     * @param array $options configuration options for the client
+     */
+    public function __construct(array $options = [])
+    {
+        $this->host   = config('solid.server.host', data_get($options, 'host'));
+        $this->port   = (int) config('solid.server.port', data_get($options, 'port'));
+        $this->secure = (bool) config('solid.server.secure', data_get($options, 'secure'));
+        $this->initializeIdentityProvider($options);
+    }
+
+    private function initializeIdentityProvider(array $options = []): IdentityProvider
+    {
+        $this->identity = new IdentityProvider($this);
+        if (isset($options['restore']) && is_string($options['restore'])) {
+            $this->identity->restoreClientCredentials($options['restore']);
+        }
+
+        return $this->identity;
+    }
+
+    /**
+     * Factory method to create a new instance of the SolidClient.
+     *
+     * @param array $options configuration options for the client
+     *
+     * @return static a new instance of SolidClient
+     */
+    public static function create(array $options = []): self
+    {
+        return new static($options);
+    }
+
+    /**
+     * Constructs the URL to the Solid server based on the configured host, port, and security.
+     *
+     * @return string the fully constructed URL
+     */
+    public function getServerUrl(): string
+    {
+        $protocol = $this->secure ? 'https' : 'http';
+        $host     =  preg_replace('#^.*://#', '', $this->host);
+
+        return "{$protocol}://{$host}:{$this->port}";
+    }
+
+    /**
+     * Creates a full request URL based on the server URL and the provided URI.
+     *
+     * This function constructs a complete URL by appending the given URI to the base server URL.
+     * It ensures that there is exactly one slash between the base URL and the URI.
+     *
+     * @param string|null $uri The URI to append to the server URL. If null, only the server URL is returned.
+     *
+     * @return string the fully constructed URL
+     */
+    private function createRequestUrl(string $uri = null): string
+    {
+        $url = $this->getServerUrl();
+
+        if (is_string($uri)) {
+            $uri = '/' . ltrim($uri, '/');
+            $url .= $uri;
+        }
+
+        return $url;
+    }
+
+    /**
+     * Sets the necessary authentication headers for the request.
+     *
+     * This function adds authentication headers to the provided options array.
+     * It includes an Authorization header with a DPoP token if an access token is available.
+     * It also generates a DPoP header based on the request method and URL.
+     *
+     * @param array  &$options The array of options for the HTTP request, passed by reference
+     * @param string $method   The HTTP method of the request (e.g., 'GET', 'POST').
+     * @param string $url      the full URL of the request
+     *
+     * @return array the modified options array with added authentication headers
+     */
+    private function setAuthenticationHeaders(array &$options, string $method, string $url)
+    {
+        $withoutAuth = data_get($options, 'withoutAuth', false);
+        if ($withoutAuth) {
+            return $options;
+        }
+
+        $useCssAuth  = data_get($options, 'useCssAuth', false);
+        $useDpopAuth = data_get($options, 'useDpopAuth', true);
+        $headers     = data_get($options, 'headers', []);
+        $accessToken = isset($this->identity) ? $this->identity->getAccessToken() : null;
+        if ($accessToken) {
+            if ($useDpopAuth) {
+                $headers['Authorization'] = 'DPoP ' . $accessToken;
+                $headers['DPoP']          = $this->identity->createDPoP($method, $url, true);
+            }
+
+            if ($useCssAuth) {
+                $headers['Authorization'] = 'CSS-Account-Token ' . $accessToken;
+            }
+        }
+
+        $options['headers'] = $headers;
+
+        return $options;
+    }
+
+    /**
+     * Make a HTTP request to the Solid server.
+     *
+     * @param string $method  The HTTP method (GET, POST, etc.)
+     * @param string $uri     The URI to send the request to
+     * @param array  $options Options for the request
+     */
+    protected function request(string $method, string $uri, array $data = [], array $options = []): Response
+    {
+        if (Str::startsWith($uri, 'http')) {
+            $url = $uri;
+        } else {
+            $url = $this->createRequestUrl($uri);
+        }
+        $this->setAuthenticationHeaders($options, $method, $url);
+        return Http::withOptions($options)->{$method}($url, $data);
+    }
+
+    public function requestWithIdentity(SolidIdentity $solidIdentity, string $method, string $uri, array $data = [], array $options = [])
+    {
+        if (Str::startsWith($uri, 'http')) {
+            $url = $uri;
+        } else {
+            $url = $this->createRequestUrl($uri);
+        }
+
+        // prepare headers
+        if (!isset($options['headers']) || !is_array($options['headers'])) {
+            $options['headers'] = [];
+        }
+
+        $accessToken = $solidIdentity->getAccessToken();
+        if ($accessToken) {
+            $options['headers']['Authorization'] = 'DPoP ' . $accessToken;
+            $options['headers']['DPoP']          = $this->identity->createDPoP($method, $url, true, $accessToken);
+        }
+
+        // dump($options);
+        return Http::withOptions($options)->{$method}($url, $data);
+    }
+
+    /**
+     * Send a GET request to the Solid server.
+     *
+     * @param string $uri     The URI to send the request to
+     * @param array  $options Options for the request
+     */
+    public function get(string $uri, array $data = [], array $options = []): Response
+    {
+        return $this->request('get', $uri, $data, $options);
+    }
+
+    /**
+     * Send a POST request to the Solid server.
+     *
+     * @param string $uri  The URI to send the request to
+     * @param array  $data Data to be sent in the request body
+     */
+    public function post(string $uri, array $data = [], array $options = []): Response
+    {
+        return $this->request('post', $uri, $data, $options);
+    }
+
+    /**
+     * Send a PUT request to the Solid server.
+     *
+     * @param string $uri  The URI to send the request to
+     * @param array  $data Data to be sent in the request body
+     */
+    public function put(string $uri, array $data = [], array $options = []): Response
+    {
+        return $this->request('put', $uri, $data, $options);
+    }
+
+    /**
+     * Send a PATCH request to the Solid server.
+     *
+     * @param string $uri  The URI to send the request to
+     * @param array  $data Data to be sent in the request body
+     */
+    public function patch(string $uri, array $data = [], array $options = []): Response
+    {
+        return $this->request('patch', $uri, $data, $options);
+    }
+
+    /**
+     * Send a DELETE request to the Solid server.
+     *
+     * @param string $uri     The URI to send the request to
+     * @param array  $options Options for the request
+     */
+    public function delete(string $uri, array $data = [], array $options = []): Response
+    {
+        return $this->request('delete', $uri, $data, $options);
+    }
+
+    public function getProfile(string $webId, array $options = []): Graph
+    {
+        $response = $this->get($webId, $options);
+        if (null !== $format = $response->getHeaders()['content-type'][0] ?? null) {
+            // strip parameters (such as charset) if any
+            $format = explode(';', $format, 2)[0];
+        }
+
+        return new Graph($webId, $response->getContent(), $format);
+    }
+
+    public function getOpenIdConfiguration()
+    {
+        $response = $this->get('.well-known/openid-configuration', [], ['withoutAuth' => true]);
+
+        if ($response->successful()) {
+            return $response->json();
+        }
+
+        throw $response->toException();
+    }
+}

package/server/src/Models/SolidIdentity.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace Fleetbase\Solid\Models;
+
+use Fleetbase\Casts\Json;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\Model;
+use Fleetbase\Models\User;
+use Fleetbase\Solid\Client\SolidClient;
+use Fleetbase\Support\Utils;
+use Fleetbase\Traits\HasUuid;
+use Illuminate\Support\Str;
+
+class SolidIdentity extends Model
+{
+    use HasUuid;
+
+    /**
+     * The database table used by the model.
+     *
+     * @var string
+     */
+    protected $table = 'solid_identities';
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var array
+     */
+    protected $fillable = ['company_uuid', 'user_uuid', 'token_response', 'identifier'];
+
+    /**
+     * The attributes that should be cast to native types.
+     *
+     * @var array
+     */
+    protected $casts = [
+        'token_response' => Json::class,
+    ];
+
+    /**
+     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
+     */
+    public function user()
+    {
+        return $this->belongsTo(User::class, 'user_uuid', 'uuid');
+    }
+
+    /**
+     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
+     */
+    public function company()
+    {
+        return $this->belongsTo(Company::class, 'company_uuid', 'uuid');
+    }
+
+    public function getAccessToken(): ?string
+    {
+        return data_get($this, 'token_response.access_token');
+    }
+
+    public function getRedirectUri(array $query = [], int $port = 8000): string
+    {
+        return Utils::apiUrl('solid/int/v1/oidc/complete-registration/' . $this->identifier, $query, $port);
+    }
+
+    public function generateRequestCode(): SolidIdentity
+    {
+        $requestCode   = static::generateUniqueRequestCode();
+        $this->update(['identifier' => $requestCode]);
+
+        return $this;
+    }
+
+    /**
+     * Generate a unique request code.
+     */
+    public static function generateUniqueRequestCode(): string
+    {
+        do {
+            // Generate a random string.
+            $requestCode = Str::random(16);
+
+            // Check if it's unique in the identifier column
+            $exists = static::where('identifier', $requestCode)->exists();
+        } while ($exists);
+
+        return $requestCode;
+    }
+
+    /**
+     * Initializes a SolidIdentity instance for the current session.
+     *
+     * This method retrieves an existing SolidIdentity based on the user's and company's UUIDs
+     * from the current session. If no identity is found, a new one is created.
+     * In both cases, a new unique request code is generated and updated for the SolidIdentity.
+     * The updated SolidIdentity instance is then returned.
+     *
+     * @return SolidIdentity the SolidIdentity instance with updated request code
+     */
+    public static function initialize(): SolidIdentity
+    {
+        $requestCode   = static::generateUniqueRequestCode();
+        $solidIdentity = static::firstOrCreate(['user_uuid' => session('user'), 'company_uuid' => session('company')]);
+        $solidIdentity->update(['identifier' => $requestCode]);
+
+        return $solidIdentity;
+    }
+
+    public static function current(): SolidIdentity
+    {
+        $solidIdentity = static::where(['user_uuid' => session('user'), 'company_uuid' => session('company')])->first();
+        if (!$solidIdentity) {
+            return static::initialize();
+        }
+
+        // If no request code
+        if (empty($solidIdentity->identifier)) {
+            $solidIdentity->generateRequestCode();
+        }
+
+        return $solidIdentity;
+    }
+
+    public function request(string $method, string $uri, array $data = [], array $options = [])
+    {
+        $solidClient = new SolidClient();
+
+        return $solidClient->requestWithIdentity($this, $method, $uri, $data, $options);
+    }
+}

package/server/src/Providers/SolidServiceProvider.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Fleetbase\Solid\Providers;
+
+use Fleetbase\FleetOps\Providers\FleetOpsServiceProvider;
+use Fleetbase\Providers\CoreServiceProvider;
+
+if (!class_exists(CoreServiceProvider::class)) {
+    throw new \Exception('Solid Extension cannot be loaded without `fleetbase/core-api` installed!');
+}
+
+if (!class_exists(FleetOpsServiceProvider::class)) {
+    throw new \Exception('Solid Extension cannot be loaded without `fleetbase/fleetops-api` installed!');
+}
+
+/**
+ * Solid Protocol Extension Service Provider.
+ */
+class SolidServiceProvider extends CoreServiceProvider
+{
+    /**
+     * The observers registered with the service provider.
+     *
+     * @var array
+     */
+    public $observers = [];
+
+    /**
+     * Register any application services.
+     *
+     * Within the register method, you should only bind things into the
+     * service container. You should never attempt to register any event
+     * listeners, routes, or any other piece of functionality within the
+     * register method.
+     *
+     * More information on this can be found in the Laravel documentation:
+     * https://laravel.com/docs/8.x/providers
+     *
+     * @return void
+     */
+    public function register()
+    {
+        $this->app->register(CoreServiceProvider::class);
+        $this->app->register(FleetOpsServiceProvider::class);
+    }
+
+    /**
+     * Bootstrap any package services.
+     *
+     * @return void
+     *
+     * @throws \Exception if the `fleetbase/core-api` package is not installed
+     */
+    public function boot()
+    {
+        $this->registerObservers();
+        $this->registerExpansionsFrom(__DIR__ . '/../Expansions');
+        $this->loadRoutesFrom(__DIR__ . '/../routes.php');
+        $this->loadMigrationsFrom(__DIR__ . '/../../migrations');
+        $this->mergeConfigFrom(__DIR__ . '/../../config/solid.php', 'solid');
+    }
+}

package/server/src/Support/Utils.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Fleetbase\Solid\Support;
+
+use Fleetbase\Support\Utils as FleetbaseUtils;
+
+class Utils extends FleetbaseUtils
+{
+}

package/server/src/routes.php

@@ -0,0 +1,47 @@
+<?php
+
+use Illuminate\Support\Facades\Route;
+
+/*
+|--------------------------------------------------------------------------
+| API Routes
+|--------------------------------------------------------------------------
+|
+| Here is where you can register API routes for your application. These
+| routes are loaded by the RouteServiceProvider within a group which
+| is assigned the "api" middleware group. Enjoy building your API!
+|
+*/
+
+Route::prefix(config('solid.api.routing.prefix', 'solid'))->namespace('Fleetbase\Solid\Http\Controllers')->group(
+    function ($router) {
+        /*
+        |--------------------------------------------------------------------------
+        | Solid Extension API Routes
+        |--------------------------------------------------------------------------
+        |
+        | Primary internal routes for console.
+        */
+        $router->prefix(config('solid.api.routing.internal_prefix', 'int'))->group(
+            function ($router) {
+                $router->get('test', 'SolidController@play');
+                $router->group(
+                    ['prefix' => 'v1'],
+                    function ($router) {
+                        $router->get('authenticate/{identifier}', 'SolidController@authenticate');
+                        $router->group(['middleware' => ['fleetbase.protected']], function ($router) {
+                            $router->get('account', 'SolidController@getAccountIndex');
+                            $router->get('request-authentication', 'SolidController@requestAuthentication');
+                            $router->get('server-config', 'SolidController@getServerConfig');
+                            $router->post('server-config', 'SolidController@saveServerConfig');
+                        });
+
+                        $router->group(['prefix' => 'oidc'], function ($router) {
+                            $router->any('complete-registration/{identifier}', 'OIDCController@completeRegistration');
+                        });
+                    }
+                );
+            }
+        );
+    }
+);

package/server/tests/Feature.php

@@ -0,0 +1,5 @@
+<?php
+
+test('example', function () {
+    expect(true)->toBeTrue();
+});

package/translations/en-us.yaml

@@ -0,0 +1,2 @@
+solid:
+  extension-name: Solid

package/tsconfig.declarations.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declarationDir": "declarations",
+    "emitDeclarationOnly": true,
+    "noEmit": false,
+    "rootDir": "."
+  },
+  "include": ["addon", "addon-test-support"]
+}