@symbo.ls/sdk 2.34.35 → 3.1.2

package/dist/cjs/services/BaseService.js

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,56 +14,26 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var BaseService_exports = {};
 __export(BaseService_exports, {
   BaseService: () => BaseService
 });
 module.exports = __toCommonJS(BaseService_exports);
-var import_environment = __toESM(require("../config/environment.js"), 1);
-var import_TokenManager = require("../utils/TokenManager.js");
 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;
-      this._apiUrl = apiUrl || import_environment.default.apiUrl;
-      if (!this._apiUrl) {
-        throw new Error("Service base URL not configured");
-      }
-      this._tokenManager = (0, import_TokenManager.getTokenManager)({
-        apiUrl: this._apiUrl,
-        onTokenError: (error) => {
-          console.error("Token management error:", error);
-        }
-      });
-      this._setReady();
-    } catch (error) {
-      this._setError(error);
-      throw error;
-    }
+  init() {
+    throw new Error("init() must be implemented by service");
   }
   // Update context
   updateContext(context) {
-    if (context && typeof context === "object") {
-      Object.assign(this._context, context);
-    }
+    this._context = { ...this._context, ...context };
   }
   // Get service status
   getStatus() {
@@ -88,134 +56,14 @@ class BaseService {
     this._ready = false;
     this._error = error;
   }
-  _getTrackingService() {
-    var _a;
-    const services = (_a = this._context) == null ? void 0 : _a.services;
-    const tracking = services == null ? void 0 : services.tracking;
-    if (!tracking || typeof tracking.trackError !== "function") {
-      return null;
-    }
-    return tracking;
-  }
-  _shouldTrackErrors() {
-    var _a;
-    const name = (_a = this == null ? void 0 : this.constructor) == null ? void 0 : _a.name;
-    return name !== "TrackingService";
-  }
-  _trackServiceError(error, details = {}) {
-    var _a;
-    if (!this._shouldTrackErrors()) {
-      return;
-    }
-    try {
-      const tracking = this._getTrackingService();
-      if (!tracking) {
-        return;
-      }
-      const context = {
-        service: ((_a = this == null ? void 0 : this.constructor) == null ? void 0 : _a.name) || "UnknownService",
-        apiUrl: this._apiUrl || null,
-        ...details
-      };
-      tracking.trackError(error instanceof Error ? error : new Error(String(error)), context);
-    } catch {
-    }
-  }
   _requireAuth() {
-    if (!this.getAuthToken()) {
+    if (!this._context.authToken) {
       throw new Error("Authentication required");
     }
   }
-  _requireReady(methodName = "unknown") {
+  _requireReady() {
     if (!this.isReady()) {
-      throw new Error(`Service not initialized for method: ${methodName}`);
+      throw new Error("Service not initialized");
     }
   }
-  // Shared HTTP request method
-  async _request(endpoint, options = {}) {
-    const url = `${this._apiUrl}/core${endpoint}`;
-    const defaultHeaders = {};
-    if (!(options.body instanceof FormData)) {
-      defaultHeaders["Content-Type"] = "application/json";
-    }
-    if (this._requiresInit(options.methodName) && this._tokenManager) {
-      try {
-        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 {
-        }
-        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) {
-      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 = /* @__PURE__ */ 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);
-  }
 }