@fleetbase/solid-engine 0.0.3 → 0.0.5

package/server/src/Client/SolidClient.php

@@ -5,6 +5,7 @@ namespace Fleetbase\Solid\Client;
 use Fleetbase\Solid\Models\SolidIdentity;
 use Illuminate\Http\Client\Response;
 use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Str;
 
 class SolidClient
@@ -12,8 +13,8 @@ class SolidClient
     private string $host = 'localhost';
     private int $port    = 3000;
     private bool $secure = true;
-    public ?SolidIdentity $solidIdentity;
-    public ?OpenIDConnectClient $oidc;
+    public SolidIdentity $identity;
+    public OpenIDConnectClient $oidc;
     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';
@@ -95,6 +96,23 @@ class SolidClient
         return $this;
     }
 
+    /**
+     * Make a request with a specific identity.
+     */
+    public function requestWithIdentity(SolidIdentity $identity, string $method, string $uri, string|array $data = [], array $options = []): Response
+    {
+        $this->identity = $identity;
+
+        // Check if we should skip authentication
+        $withoutAuth = data_get($options, 'withoutAuth', false);
+
+        if ($withoutAuth) {
+            return $this->request($method, $uri, $data, $options);
+        }
+
+        return $this->authenticatedRequest($method, $uri, $data, $options);
+    }
+
     /**
      * Make a HTTP request to the Solid server.
      *
@@ -102,17 +120,27 @@ class SolidClient
      * @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
+    protected function request(string $method, string $uri, string|array $data = [], array $options = []): Response
     {
         $url = $this->createRequestUrl($uri);
 
-        return Http::withOptions($options)->{$method}($url, $data);
+        // For development: disable SSL verification when using HTTPS
+        if ($this->secure && app()->environment('local', 'development')) {
+            $options['verify'] = false;
+        }
+
+        // Handle different data types
+        if (is_string($data)) {
+            return Http::withOptions($options)->withBody($data, $options['headers']['Content-Type'] ?? 'text/plain')->send($method, $url);
+        } else {
+            return Http::withOptions($options)->{$method}($url, $data);
+        }
     }
 
     /**
      * Send an authenticated request with the current identity.
      */
-    public function authenticatedRequest(string $method, string $uri, array $data = [], array $options = []): Response
+    public function authenticatedRequest(string $method, string $uri, string|array $data = [], array $options = []): Response
     {
         if (!$this->identity) {
             throw new \Exception('Solid Identity required to make an authenticated request.');
@@ -120,13 +148,81 @@ class SolidClient
 
         $url         = $this->createRequestUrl($uri);
         $accessToken = $this->identity->getAccessToken();
+
+        // Debug: Log access token details
         if ($accessToken) {
-            $options['headers']                  = is_array($options['headers']) ? $options['headers'] : [];
+            try {
+                $tokenParts = explode('.', $accessToken);
+                if (count($tokenParts) === 3) {
+                    $payload = json_decode(base64_decode(strtr($tokenParts[1], '-_', '+/')), true);
+                    Log::debug('[ACCESS TOKEN PAYLOAD]', [
+                        'webid' => $payload['webid'] ?? null,
+                        'sub' => $payload['sub'] ?? null,
+                        'client_id' => $payload['client_id'] ?? null,
+                        'scope' => $payload['scope'] ?? null,
+                        'iat' => $payload['iat'] ?? null,
+                        'exp' => $payload['exp'] ?? null,
+                        'cnf_jkt' => $payload['cnf']['jkt'] ?? null,
+                    ]);
+                }
+            } catch (\Throwable $e) {
+                Log::warning('[ACCESS TOKEN DECODE FAILED]', ['error' => $e->getMessage()]);
+            }
+            
+            $options['headers']                  = isset($options['headers']) && is_array($options['headers']) ? $options['headers'] : [];
             $options['headers']['Authorization'] = 'DPoP ' . $accessToken;
-            $options['headers']['DPoP']          = OpenIDConnectClient::createDPoP($method, $url, $accessToken);
+            $options['headers']['DPoP']          = $this->oidc->createDPoP($method, $url, $accessToken);
+        }
+
+        // For development: disable SSL verification when using HTTPS
+        if ($this->secure && app()->environment('local', 'development')) {
+            $options['verify'] = false;
         }
 
-        return Http::withOptions($options)->{$method}($url, $data);
+        Log::info('[SOLID REQUEST HEADERS]', ['headers' => $options['headers']]);
+
+        // Handle different data types
+        if (is_string($data)) {
+            // For string data, send as raw body
+            $contentType = $options['headers']['Content-Type'] ?? 'text/plain';
+
+            Log::info('[SENDING STRING BODY]', [
+                'method'       => $method,
+                'url'          => $url,
+                'content_type' => $contentType,
+                'body_length'  => strlen($data),
+                'body_preview' => substr($data, 0, 200),
+            ]);
+
+            $response = Http::withOptions($options)->withBody($data, $contentType)->send($method, $url);
+            
+            // Debug: Log response details
+            Log::debug('[SOLID RESPONSE]', [
+                'status' => $response->status(),
+                'headers' => $response->headers(),
+                'body' => $response->body(),
+            ]);
+            
+            return $response;
+        } else {
+            // For array data, use the original method
+            Log::info('[SENDING ARRAY DATA]', [
+                'method' => $method,
+                'url'    => $url,
+                'data'   => $data,
+            ]);
+
+            $response = Http::withOptions($options)->{$method}($url, $data);
+            
+            // Debug: Log response details
+            Log::debug('[SOLID RESPONSE]', [
+                'status' => $response->status(),
+                'headers' => $response->headers(),
+                'body' => $response->body(),
+            ]);
+            
+            return $response;
+        }
     }
 
     /**

package/server/src/Http/Controllers/DataController.php

@@ -0,0 +1,261 @@
+<?php
+
+namespace Fleetbase\Solid\Http\Controllers;
+
+use Fleetbase\Http\Controllers\Controller as BaseController;
+use Fleetbase\Solid\Models\SolidIdentity;
+use Fleetbase\Solid\Services\PodService;
+use Fleetbase\Solid\Services\ResourceSyncService;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Log;
+
+class DataController extends BaseController
+{
+    protected PodService $podService;
+    protected ResourceSyncService $resourceSyncService;
+
+    public function __construct(PodService $podService, ResourceSyncService $resourceSyncService)
+    {
+        $this->podService          = $podService;
+        $this->resourceSyncService = $resourceSyncService;
+    }
+
+    /**
+     * Get the user's pod data (root level folders and files).
+     */
+    public function index(Request $request)
+    {
+        try {
+            $identity = SolidIdentity::current();
+
+            if (!$identity || !$identity->getAccessToken()) {
+                return response()->json(['error' => 'Not authenticated'], 401);
+            }
+
+            // Get the user's primary pod URL from their WebID
+            $profile = $this->podService->getProfileData($identity);
+            $webId = $profile['webid'];
+            $podUrl = $this->podService->getPodUrlFromWebId($webId);
+            
+            Log::info('[DATA INDEX]', [
+                'webid' => $webId,
+                'pod_url' => $podUrl,
+            ]);
+
+            // Get root level contents of the pod
+            $contents = $this->podService->getPodContents($identity, $podUrl);
+
+            return response()->json([
+                'pod_url'  => $podUrl,
+                'contents' => $contents,
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('[DATA INDEX ERROR]', [
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+            ]);
+
+            return response()->json([
+                'error' => $e->getMessage(),
+            ], 500);
+        }
+    }
+
+    /**
+     * Get folder contents by slug.
+     */
+    public function showFolder(Request $request, string $slug)
+    {
+        try {
+            $identity = SolidIdentity::current();
+
+            if (!$identity || !$identity->getAccessToken()) {
+                return response()->json(['error' => 'Not authenticated'], 401);
+            }
+
+            $profile = $this->podService->getProfileData($identity);
+            $webId = $profile['webid'];
+            $podUrl = $this->podService->getPodUrlFromWebId($webId);
+            $folderUrl = rtrim($podUrl, '/') . '/' . ltrim($slug, '/');
+
+            Log::info('[FOLDER SHOW]', [
+                'slug' => $slug,
+                'folder_url' => $folderUrl,
+            ]);
+
+            $contents = $this->podService->getPodContents($identity, $folderUrl);
+
+            return response()->json([
+                'folder_url' => $folderUrl,
+                'slug'       => $slug,
+                'contents'   => $contents,
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('[FOLDER SHOW ERROR]', [
+                'slug'  => $slug,
+                'error' => $e->getMessage(),
+            ]);
+
+            return response()->json([
+                'error' => $e->getMessage(),
+            ], 500);
+        }
+    }
+
+    /**
+     * Create a new folder in the pod.
+     */
+    public function createFolder(Request $request)
+    {
+        try {
+            $identity = SolidIdentity::current();
+
+            if (!$identity || !$identity->getAccessToken()) {
+                return response()->json(['error' => 'Not authenticated'], 401);
+            }
+
+            $request->validate([
+                'name' => 'required|string|max:255',
+                'path' => 'nullable|string',
+            ]);
+
+            $folderName = $request->input('name');
+            $path = $request->input('path', '');
+
+            $profile = $this->podService->getProfileData($identity);
+            $webId = $profile['webid'];
+            $podUrl = $this->podService->getPodUrlFromWebId($webId);
+            
+            // Build parent URL (where to create the folder)
+            $parentUrl = rtrim($podUrl, '/') . '/';
+            if (!empty($path)) {
+                $parentUrl .= trim($path, '/') . '/';
+            }
+
+            Log::info('[FOLDER CREATE]', [
+                'name' => $folderName,
+                'path' => $path,
+                'parent_url' => $parentUrl,
+            ]);
+
+            // Use POST with Slug header (Solid Protocol standard)
+            $result = $this->podService->createFolder($identity, $parentUrl, $folderName);
+
+            return response()->json([
+                'success'    => $result,
+                'folder_url' => $parentUrl . $folderName . '/',
+                'message'    => "Folder '{$folderName}' created successfully",
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('[FOLDER CREATE ERROR]', [
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+            ]);
+
+            return response()->json([
+                'success' => false,
+                'error'   => $e->getMessage(),
+            ], 500);
+        }
+    }
+
+    /**
+     * Delete a folder or file.
+     */
+    public function deleteItem(Request $request, string $type, string $slug)
+    {
+        try {
+            $identity = SolidIdentity::current();
+
+            if (!$identity || !$identity->getAccessToken()) {
+                return response()->json(['error' => 'Not authenticated'], 401);
+            }
+
+            $profile = $this->podService->getProfileData($identity);
+            $webId = $profile['webid'];
+            $podUrl = $this->podService->getPodUrlFromWebId($webId);
+            $itemUrl = rtrim($podUrl, '/') . '/' . ltrim($slug, '/');
+
+            // Add trailing slash for folders
+            if ($type === 'folder') {
+                $itemUrl = rtrim($itemUrl, '/') . '/';
+            }
+
+            Log::info('[ITEM DELETE]', [
+                'type' => $type,
+                'slug' => $slug,
+                'item_url' => $itemUrl,
+            ]);
+
+            $result = $this->podService->deleteResource($identity, $itemUrl);
+
+            return response()->json([
+                'success' => $result,
+                'message' => $result ? ucfirst($type) . ' deleted successfully' : 'Failed to delete ' . $type,
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('[ITEM DELETE ERROR]', [
+                'type'  => $type,
+                'slug'  => $slug,
+                'error' => $e->getMessage(),
+            ]);
+
+            return response()->json([
+                'success' => false,
+                'error'   => $e->getMessage(),
+            ], 500);
+        }
+    }
+
+    /**
+     * Import Fleetops resources into the user's pod.
+     */
+    public function importResources(Request $request)
+    {
+        try {
+            $identity = SolidIdentity::current();
+
+            if (!$identity || !$identity->getAccessToken()) {
+                return response()->json(['error' => 'Not authenticated'], 401);
+            }
+
+            $request->validate([
+                'resource_types'   => 'required|array',
+                'resource_types.*' => 'in:vehicles,drivers,contacts,orders',
+            ]);
+
+            $resourceTypes = $request->input('resource_types');
+
+            // Use the authenticated user's pod (from their WebID)
+            $profile = $this->podService->getProfileData($identity);
+            $webId = $profile['webid'];
+            $podUrl = $this->podService->getPodUrlFromWebId($webId);
+
+            Log::info('[IMPORTING RESOURCES]', [
+                'pod_url'        => $podUrl,
+                'webid'          => $webId,
+                'resource_types' => $resourceTypes,
+            ]);
+
+            $result = $this->resourceSyncService->importResources($identity, $podUrl, $resourceTypes);
+
+            return response()->json([
+                'success'        => true,
+                'imported'       => $result['imported'],
+                'imported_count' => $result['total_count'],
+                'errors'         => $result['errors'],
+                'message'        => "Successfully imported {$result['total_count']} resources",
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('[IMPORT RESOURCES ERROR]', [
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString(),
+            ]);
+
+            return response()->json([
+                'success' => false,
+                'error'   => $e->getMessage(),
+            ], 500);
+        }
+    }
+}

package/server/src/Http/Controllers/OIDCController.php

@@ -7,26 +7,60 @@ use Fleetbase\Solid\Client\SolidClient;
 use Fleetbase\Solid\Models\SolidIdentity;
 use Fleetbase\Support\Utils;
 use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Log;
 
 class OIDCController extends BaseController
 {
     public function completeRegistration(string $identifier, Request $request)
     {
-        if ($request->has('code') && $identifier) {
+        Log::info('[OIDC COMPLETE REGISTRATION]', [
+            'identifier' => $identifier,
+            'request'    => $request->all(),
+            'has_code'   => $request->filled('code'),
+            'has_state'  => $request->filled('state'),
+        ]);
+
+        if ($request->filled('code') && $identifier) {
             try {
                 $identity = SolidIdentity::where('identifier', $identifier)->first();
-                if ($identity) {
-                    $solid = SolidClient::create(['identity' => $identity, 'restore' => true]);
-                    $solid->oidc->authenticate();
-                    $identity->update(['token_response' => $solid->oidc->getTokenResponse()]);
+
+                if (!$identity) {
+                    throw new \Exception('Identity not found for identifier: ' . $identifier);
+                }
+
+                Log::info('[OIDC IDENTITY FOUND]', ['identity_id' => $identity->id]);
+
+                $solid = SolidClient::create(['identity' => $identity, 'restore' => true]);
+
+                // Get the authorization code
+                $code = $request->input('code');
+
+                // CRITICAL: Use requestTokens() instead of authenticate()
+                $tokenResponse = $solid->oidc->exchangeCodeForTokens($code);
+
+                if (isset($tokenResponse->error)) {
+                    throw new \Exception($tokenResponse->error_description ?? $tokenResponse->error);
                 }
+
+                Log::info('[OIDC TOKEN EXCHANGE SUCCESS]', ['has_access_token' => isset($tokenResponse->access_token)]);
+
+                // Save the token response
+                $identity->update(['token_response' => (array) $tokenResponse]);
+
+                // Redirect to success page
+                return redirect(Utils::consoleUrl('solid-protocol', ['success' => 'authenticated']));
             } catch (\Throwable $e) {
+                Log::error('[OIDC ERROR]', [
+                    'error' => $e->getMessage(),
+                    'trace' => $e->getTraceAsString(),
+                ]);
+
                 return redirect(Utils::consoleUrl('solid-protocol', ['error' => $e->getMessage()]));
             }
-
-            return redirect(Utils::consoleUrl('solid-protocol', $request->all()));
         }
 
-        return redirect(Utils::consoleUrl('solid-protocol', ['error' => 'Unable to authenticate with provider']));
+        Log::warning('[OIDC MISSING PARAMS]', ['has_code' => $request->filled('code'), 'identifier' => $identifier]);
+
+        return redirect(Utils::consoleUrl('solid-protocol', ['error' => 'Missing authorization code or identifier']));
     }
 }