@symbo.ls/sdk 3.1.2 → 3.2.6

package/src/services/BaseService.js

@@ -1,20 +1,49 @@
+import environment from '../config/environment.js'
+import { getTokenManager } from '../utils/TokenManager.js'
+
 export class BaseService {
   constructor ({ context, options } = {}) {
     this._context = context || {}
     this._options = options || {}
     this._ready = false
     this._error = null
+    this._apiUrl = null
+    this._tokenManager = null
   }
 
   // Initialize service
+  init ({ context }) {
+    try {
+      const { apiUrl } = context || this._context
+
+      // Get base URL from environment config
+      this._apiUrl = apiUrl || environment.apiUrl
+
+      if (!this._apiUrl) {
+        throw new Error('Service base URL not configured')
+      }
+
+      // Initialize token manager (singleton). TokenManager handles persistence
+      this._tokenManager = getTokenManager({
+        apiUrl: this._apiUrl,
+        onTokenError: error => {
+          console.error('Token management error:', error)
+        }
+      })
 
-  init () {
-    throw new Error('init() must be implemented by service')
+      this._setReady()
+    } catch (error) {
+      this._setError(error)
+      throw error
+    }
   }
 
   // Update context
   updateContext (context) {
-    this._context = { ...this._context, ...context }
+    // Mutate in place to preserve the shared reference with the SDK context
+    if (context && typeof context === 'object') {
+      Object.assign(this._context, context)
+    }
   }
 
   // Get service status
@@ -42,15 +71,146 @@ export class BaseService {
     this._error = error
   }
 
+  _getTrackingService () {
+    const services = this._context?.services
+    const tracking = services?.tracking
+    if (!tracking || typeof tracking.trackError !== 'function') {return null}
+    return tracking
+  }
+
+  _shouldTrackErrors () {
+    const name = this?.constructor?.name
+    return name !== 'TrackingService'
+  }
+
+  _trackServiceError (error, details = {}) {
+    if (!this._shouldTrackErrors()) {return}
+    try {
+      const tracking = this._getTrackingService()
+      if (!tracking) {return}
+      const context = {
+        service: this?.constructor?.name || 'UnknownService',
+        apiUrl: this._apiUrl || null,
+        ...details
+      }
+      tracking.trackError(error instanceof Error ? error : new Error(String(error)), context)
+    } catch {
+      // Do not let tracking failures affect service flow
+    }
+  }
+
   _requireAuth () {
-    if (!this._context.authToken) {
+    if (!this.getAuthToken()) {
       throw new Error('Authentication required')
     }
   }
 
-  _requireReady () {
+  _requireReady (methodName = 'unknown') {
     if (!this.isReady()) {
-      throw new Error('Service not initialized')
+      throw new Error(`Service not initialized for method: ${methodName}`)
     }
   }
+
+  // Shared HTTP request method
+  async _request (endpoint, options = {}) {
+    const url = `${this._apiUrl}/core${endpoint}`
+
+    const defaultHeaders = {}
+
+    // Only set Content-Type for JSON requests, not for FormData
+    if (!(options.body instanceof FormData)) {
+      defaultHeaders['Content-Type'] = 'application/json'
+    }
+
+    // Use TokenManager for automatic token management
+    if (this._requiresInit(options.methodName) && this._tokenManager) {
+      try {
+        // Ensure we have a valid token (will refresh if needed)
+        const validToken = await this._tokenManager.ensureValidToken()
+
+        if (validToken) {
+          const authHeader = this._tokenManager.getAuthHeader()
+          if (authHeader) {
+            defaultHeaders.Authorization = authHeader
+          }
+        }
+      } catch (error) {
+        console.warn(
+          'Token management failed, proceeding without authentication:',
+          error
+        )
+      }
+    }
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...defaultHeaders,
+          ...options.headers
+        }
+      })
+
+      if (!response.ok) {
+        let error = {
+          message: `HTTP ${response.status}: ${response.statusText}`
+        }
+        try {
+          error = await response.json()
+        } catch {
+          // Use default error message
+        }
+        // Track HTTP error before throwing
+        this._trackServiceError(
+          new Error(error.message || error.error || `HTTP ${response.status}: ${response.statusText}`),
+          {
+            endpoint,
+            methodName: options.methodName,
+            status: response.status,
+            statusText: response.statusText
+          }
+        )
+        throw new Error(error.message || error.error || 'Request failed', { cause: error })
+      }
+
+      return response.status === 204 ? null : response.json()
+    } catch (error) {
+      // Track network/other request errors before rethrowing
+      this._trackServiceError(error, {
+        endpoint,
+        methodName: options.methodName
+      })
+      throw new Error(`Request failed: ${error.message}`, { cause: error })
+    }
+  }
+
+  // Helper method to determine if a method requires initialization
+  _requiresInit (methodName) {
+    const noInitMethods = new Set([
+      'register',
+      'login',
+      'googleAuth',
+      'googleAuthCallback',
+      'githubAuth',
+      'requestPasswordReset',
+      'confirmPasswordReset',
+      'confirmRegistration',
+      'verifyEmail',
+      'getPlans',
+      'getPlan',
+      'listPublicProjects',
+      'getPublicProject'
+    ])
+    return !noInitMethods.has(methodName)
+  }
+
+  // Cleanup method
+  destroy () {
+    if (this._tokenManager) {
+      this._tokenManager.destroy()
+      this._tokenManager = null
+    }
+    this._ready = false
+    this._setReady(false)
+  }
 }