datastake-daf 0.6.493 → 0.6.495

package/dist/services/index.js

@@ -6146,7 +6146,18 @@ class BaseHTTPService {
     // Init
     this.cancelToken = {};
     this.token = this.getToken();
-    this.setupAxios();
+
+    // 🔥 NEW: Don't setup axios immediately, do it lazily
+    this.api = null;
+    this._axiosInitialized = false;
+  }
+
+  // 🔥 NEW: Lazy initialization method
+  _ensureAxiosInitialized() {
+    if (!this._axiosInitialized) {
+      this.setupAxios();
+      this._axiosInitialized = true;
+    }
   }
   setupAxios() {
     const headers = {
@@ -6164,8 +6175,6 @@ class BaseHTTPService {
   }
   setupInterceptors() {
     this.api.interceptors.response.use(response => response, error => Promise.reject(error));
-
-    // Request interceptor - clean JSON data
     this.api.interceptors.request.use(config => {
       if (['post', 'put', 'patch'].includes(config.method)) {
         config.data = this.cleanJSON(config.data);
@@ -6190,6 +6199,7 @@ class BaseHTTPService {
     }
     this.api = axios$1.create(options);
     this.setupInterceptors();
+    this._axiosInitialized = true; // 🔥 Mark as initialized
   }
   async formatResponse(call) {
     try {
@@ -6210,6 +6220,8 @@ class BaseHTTPService {
     }
   }
   apiPost(options) {
+    this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+
     // Check if there are any previous pending requests
     if (typeof this.cancelToken[options.url] != typeof undefined) {
       try {
@@ -6235,6 +6247,8 @@ class BaseHTTPService {
     }).catch(err => this.onError(err)));
   }
   apiGet(options) {
+    this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+
     const token = this.getToken();
     if (token !== this.token || !token) {
       this.reloadAxios();
@@ -6254,6 +6268,8 @@ class BaseHTTPService {
     }).catch(err => this.onError(err)));
   }
   apiDelete(options) {
+    this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+
     const token = this.getToken();
     if (token !== this.token || !token) {
       this.reloadAxios();
@@ -6273,6 +6289,8 @@ class BaseHTTPService {
     }).catch(err => this.onError(err)));
   }
   apiPut(options) {
+    this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+
     if (typeof this.cancelToken[options.url] != typeof undefined) {
       try {
         this.cancelToken[options.url].cancel("Operation canceled due to new request.");
@@ -6297,6 +6315,8 @@ class BaseHTTPService {
     }).catch(err => this.onError(err, options.onUnauthorized)));
   }
   apiPatch(options) {
+    this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+
     const token = this.getToken();
     if (token !== this.token || !token) {
       this.reloadAxios();
@@ -6378,8 +6398,16 @@ const configureServices = config => {
     ...globalConfig,
     ...config
   };
+  console.log({
+    configureServices: globalConfig
+  });
+};
+const getConfig = () => {
+  console.log({
+    getConfig: globalConfig
+  });
+  return globalConfig;
 };
-const getConfig = () => globalConfig;
 
 /**
  * Generic error handler factory for axios requests
@@ -6475,46 +6503,53 @@ class ErrorService {
   }
 }
 
+// In datastake-daf - src/services/BaseService.js
 class BaseService extends BaseHTTPService {
   constructor() {
-    const config = getConfig();
-    const onError = createErrorHandler({
-      getStorageManager: () => StorageManager,
-      handleError: ({
-        status,
-        statusText,
-        data
-      }) => {
-        ErrorService.handle({
-          status,
-          statusText,
-          data
-        });
-      },
-      tokenStorageKey: 'token',
-      unauthorizedRedirect: '/',
-      checkTokenValidity: true,
-      handleNetworkError: true
-    });
+    // Call super with lazy getters that fetch config at runtime
     super({
       getToken: () => getToken(),
-      getHeaders: () => ({
-        Language: config.language || StorageManager.get('datastakeLng') || 'en',
-        'ngrok-skip-browser-warning': true,
-        Application: config.application
-      }),
+      getHeaders: () => {
+        const config = getConfig();
+        return {
+          Language: config.language || StorageManager.get('datastakeLng') || 'en',
+          'ngrok-skip-browser-warning': true,
+          Application: config.application
+        };
+      },
       getBaseURL: options => {
+        const config = getConfig();
         if (options?.isStore) return config.storeUrl;
         return config.mainApiUrl;
       },
-      onError: onError,
+      onError: error => {
+        // Create error handler lazily
+        const errorHandler = createErrorHandler({
+          getStorageManager: () => StorageManager,
+          handleError: ({
+            status,
+            statusText,
+            data
+          }) => {
+            ErrorService.handle({
+              status,
+              statusText,
+              data
+            });
+          },
+          tokenStorageKey: 'token',
+          unauthorizedRedirect: '/',
+          checkTokenValidity: true,
+          handleNetworkError: true
+        });
+        return errorHandler(error);
+      },
       timeout: 300000
     });
-    this.config = config;
   }
   apiGet(options) {
     const token = getToken();
-    const config = this.config;
+    const config = getConfig();
     if (token !== this.token || !token) {
       this.reloadAxios();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "datastake-daf",
-	"version": "0.6.493",
+	"version": "0.6.495",
 	"dependencies": {
 		"@ant-design/icons": "^5.2.5",
 		"@antv/g2": "^5.1.1",

package/src/@daf/services/BaseService.js

@@ -1,3 +1,4 @@
+// In datastake-daf - src/services/BaseService.js
 import { BaseHTTPService } from './helpers/BaseHTTPService.js';
 import { getToken } from '../../helpers/Token.js';
 import { createErrorHandler } from '../../helpers/errorHandling.js';
@@ -7,40 +8,43 @@ import { ErrorService } from './ErrorService.js';
 
 export class BaseService extends BaseHTTPService {
   constructor() {
-    const config = getConfig();
-    
-    const onError = createErrorHandler({
-      getStorageManager: () => StorageManager,
-      handleError: ({ status, statusText, data }) => {
-        ErrorService.handle({ status, statusText, data });
-      },
-      tokenStorageKey: 'token',
-      unauthorizedRedirect: '/',
-      checkTokenValidity: true,
-      handleNetworkError: true,
-    });
-
+    // Call super with lazy getters that fetch config at runtime
     super({
       getToken: () => getToken(),
-      getHeaders: () => ({
-        Language: config.language || StorageManager.get('datastakeLng') || 'en',
-        'ngrok-skip-browser-warning': true,
-        Application: config.application,
-      }),
+      getHeaders: () => {
+        const config = getConfig();
+        return {
+          Language: config.language || StorageManager.get('datastakeLng') || 'en',
+          'ngrok-skip-browser-warning': true,
+          Application: config.application,
+        };
+      },
       getBaseURL: (options) => {
+        const config = getConfig();
         if (options?.isStore) return config.storeUrl;
         return config.mainApiUrl;
       },
-      onError: onError,
+      onError: (error) => {
+        // Create error handler lazily
+        const errorHandler = createErrorHandler({
+          getStorageManager: () => StorageManager,
+          handleError: ({ status, statusText, data }) => {
+            ErrorService.handle({ status, statusText, data });
+          },
+          tokenStorageKey: 'token',
+          unauthorizedRedirect: '/',
+          checkTokenValidity: true,
+          handleNetworkError: true,
+        });
+        return errorHandler(error);
+      },
       timeout: 300000,
     });
-    
-    this.config = config;
   }
 
   apiGet(options) {
     const token = getToken();
-    const config = this.config;
+    const config = getConfig();
     
     if (token !== this.token || !token) {
       this.reloadAxios();

package/src/@daf/services/helpers/BaseHTTPService.js

@@ -34,224 +34,243 @@ const paramsSerializer = (params) => {
  * Provides axios wrapper with token management, cancel tokens, and interceptors
  */
 export class BaseHTTPService {
-    constructor(config = {}) {
-        const {getHeaders, getBaseURL, onError, timeout = 300000, customAxiosConfig = {}} = config;
+  constructor(config = {}) {
+      const {getHeaders, getBaseURL, onError, timeout = 300000, customAxiosConfig = {}} = config;
 
-        this.getToken = getToken || (() => null);
-        this.getHeaders = getHeaders || (() => ({}));
-        this.getBaseURL = getBaseURL || (() => null);
-        this.onError = onError || (() => null);
-        this.cleanJSON = cleanJSON;
-        this.timeout = timeout;
-        this.customAxiosConfig = customAxiosConfig;
+      this.getToken = getToken || (() => null);
+      this.getHeaders = getHeaders || (() => ({}));
+      this.getBaseURL = getBaseURL || (() => null);
+      this.onError = onError || (() => null);
+      this.cleanJSON = cleanJSON;
+      this.timeout = timeout;
+      this.customAxiosConfig = customAxiosConfig;
 
-        // Init
-        this.cancelToken = {}
-        this.token = this.getToken();
+      // Init
+      this.cancelToken = {}
+      this.token = this.getToken();
+      
+      // 🔥 NEW: Don't setup axios immediately, do it lazily
+      this.api = null;
+      this._axiosInitialized = false;
+  }
 
-        this.setupAxios();
-    }
+  // 🔥 NEW: Lazy initialization method
+  _ensureAxiosInitialized() {
+      if (!this._axiosInitialized) {
+          this.setupAxios();
+          this._axiosInitialized = true;
+      }
+  }
 
-    setupAxios() {
-        const headers = {
-            Authorization: `Bearer ${this.token}`,
-            ...this.getHeaders(),
-        };
+  setupAxios() {
+      const headers = {
+          Authorization: `Bearer ${this.token}`,
+          ...this.getHeaders(),
+      };
 
-        this.api = axios.create({
-            baseURL: this.getBaseURL(),
-            headers,
-            timeout: this.timeout,
-            paramsSerializer: paramsSerializer,
-            ...this.customAxiosConfig,
-        });
+      this.api = axios.create({
+          baseURL: this.getBaseURL(),
+          headers,
+          timeout: this.timeout,
+          paramsSerializer: paramsSerializer,
+          ...this.customAxiosConfig,
+      });
 
-        this.setupInterceptors();
-    }
+      this.setupInterceptors();
+  }
 
-    setupInterceptors() {
-        this.api.interceptors.response.use(
-            (response) => response,
-            (error) => Promise.reject(error)
-        );
+  setupInterceptors() {
+      this.api.interceptors.response.use(
+          (response) => response,
+          (error) => Promise.reject(error)
+      );
 
-        // Request interceptor - clean JSON data
-        this.api.interceptors.request.use(
-            (config) => {
-                if (['post', 'put', 'patch'].includes(config.method)) {
-                    config.data = this.cleanJSON(config.data);
-                }
-                
-                return config;
-            },
-            (error) => Promise.reject(error)
-        );
-    }
-    
-    reloadAxios() {
-        const token = this.getToken();
-        this.token = token;
+      this.api.interceptors.request.use(
+          (config) => {
+              if (['post', 'put', 'patch'].includes(config.method)) {
+                  config.data = this.cleanJSON(config.data);
+              }
+              return config;
+          },
+          (error) => Promise.reject(error)
+      );
+  }
+  
+  reloadAxios() {
+      const token = this.getToken();
+      this.token = token;
 
-        const options = {
-            baseURL: this.getBaseURL(),
-            timeout: this.timeout,
-            paramsSerializer: paramsSerializer,
-            ...this.customAxiosConfig,
-        };
+      const options = {
+          baseURL: this.getBaseURL(),
+          timeout: this.timeout,
+          paramsSerializer: paramsSerializer,
+          ...this.customAxiosConfig,
+      };
 
-        if (token) {
-            options.headers = {
-              Authorization: `Bearer ${token}`,
-              ...this.getHeaders(),
-            };
-        }
+      if (token) {
+          options.headers = {
+            Authorization: `Bearer ${token}`,
+            ...this.getHeaders(),
+          };
+      }
+
+      this.api = axios.create(options);
+      this.setupInterceptors();
+      this._axiosInitialized = true; // 🔥 Mark as initialized
+  }
 
-        this.api = axios.create(options);
-        this.setupInterceptors();
-    }
+  async formatResponse(call) {
+      try {
+        const res = await call;
+        const { data, status, statusText } = res || {};
+        this.cancelToken = {};
+        return { data, status, statusText };
+      } catch (error) {
+        return Promise.reject(error);
+      }
+  }
 
-    async formatResponse(call) {
+  apiPost(options) {
+      this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+      
+      // Check if there are any previous pending requests
+      if (typeof this.cancelToken[options.url] != typeof undefined) {
         try {
-          const res = await call;
-          const { data, status, statusText } = res || {};
-          this.cancelToken = {};
-          return { data, status, statusText };
-        } catch (error) {
-          return Promise.reject(error);
+          this.cancelToken[options.url].cancel("Operation canceled due to new request.");
+        } catch (e) {
+          console.log(e);
+          return {};
         }
-    }
+      }
+      
+      this.cancelToken[options.url] = axios.CancelToken.source();
+      const token = this.getToken();
+      
+      if (token !== this.token || !token) {
+        this.reloadAxios();
+      }
+  
+      return this.formatResponse(
+        this.api.post(options.url, options.data, {
+          baseURL: options.baseURL || this.getBaseURL(options),
+          cancelToken: this.cancelToken[options.url].token,
+          headers: {
+            Authorization: `Bearer ${this.getToken()}`,
+            ...this.getHeaders(),
+            ...(options?.headers || {}),
+          }
+        })
+          .catch((err) => this.onError(err))
+      );
+  }
 
-    apiPost(options) {
-        // Check if there are any previous pending requests
-        if (typeof this.cancelToken[options.url] != typeof undefined) {
-          try {
-            this.cancelToken[options.url].cancel("Operation canceled due to new request.");
-          } catch (e) {
-            console.log(e);
-            return {};
+  apiGet(options) {
+      this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+      
+      const token = this.getToken();
+      
+      if (token !== this.token || !token) {
+        this.reloadAxios();
+      }
+      
+      const { url, ...config } = options;
+  
+      return this.formatResponse(
+        this.api.get(url, {
+          ...config,
+          baseURL: options.baseURL || this.getBaseURL(options),
+          headers: {
+            Authorization: `Bearer ${this.getToken()}`,
+            ...this.getHeaders(),
+            ...(config?.headers || {}),
           }
-        }
-        
-        this.cancelToken[options.url] = axios.CancelToken.source();
-        const token = this.getToken();
-        
-        if (token !== this.token || !token) {
-          this.reloadAxios();
-        }
-    
-        return this.formatResponse(
-          this.api.post(options.url, options.data, {
-            baseURL: options.baseURL || this.getBaseURL(options),
-            cancelToken: this.cancelToken[options.url].token,
-            headers: {
-              Authorization: `Bearer ${this.getToken()}`,
-              ...this.getHeaders(),
-              ...(options?.headers || {}),
-            }
-          })
-            .catch((err) => this.onError(err))
-        );
-    }
+        })
+          .catch((err) => this.onError(err))
+      );
+  }
 
-    apiGet(options) {
-        const token = this.getToken();
-        
-        if (token !== this.token || !token) {
-          this.reloadAxios();
-        }
-        
-        const { url, ...config } = options;
-    
-        return this.formatResponse(
-          this.api.get(url, {
-            ...config,
-            baseURL: options.baseURL || this.getBaseURL(options),
-            headers: {
-              Authorization: `Bearer ${this.getToken()}`,
-              ...this.getHeaders(),
-              ...(config?.headers || {}),
-            }
-          })
-            .catch((err) => this.onError(err))
-        );
-    }
+  apiDelete(options) {
+      this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+      
+      const token = this.getToken();
+      
+      if (token !== this.token || !token) {
+        this.reloadAxios();
+      }
+      
+      const { url, ...config } = options;
+  
+      return this.formatResponse(
+        this.api.delete(url, {
+          ...config,
+          baseURL: options.baseURL || this.getBaseURL(options),
+          headers: {
+            Authorization: `Bearer ${this.getToken()}`,
+            ...this.getHeaders(),
+            ...(config?.headers || {}),
+          }
+        })
+          .catch((err) => this.onError(err))
+      );
+  }
 
-    apiDelete(options) {
-        const token = this.getToken();
-        
-        if (token !== this.token || !token) {
-          this.reloadAxios();
+  apiPut(options) {
+      this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+      
+      if (typeof this.cancelToken[options.url] != typeof undefined) {
+        try {
+          this.cancelToken[options.url].cancel("Operation canceled due to new request.");
+        } catch (e) {
+          console.log(e);
+          return {};
         }
-        
-        const { url, ...config } = options;
-    
-        return this.formatResponse(
-          this.api.delete(url, {
-            ...config,
-            baseURL: options.baseURL || this.getBaseURL(options),
-            headers: {
-              Authorization: `Bearer ${this.getToken()}`,
-              ...this.getHeaders(),
-              ...(config?.headers || {}),
-            }
-          })
-            .catch((err) => this.onError(err))
-        );
-    }
-
-    apiPut(options) {
-        if (typeof this.cancelToken[options.url] != typeof undefined) {
-          try {
-            this.cancelToken[options.url].cancel("Operation canceled due to new request.");
-          } catch (e) {
-            console.log(e);
-            return {};
+      }
+      
+      this.cancelToken[options.url] = axios.CancelToken.source();
+      const token = this.getToken();
+      
+      if (token !== this.token || !token) {
+        this.reloadAxios();
+      }
+  
+      return this.formatResponse(
+        this.api.put(options.url, options.data, {
+          cancelToken: this.cancelToken[options.url].token,
+          baseURL: options.baseURL || this.getBaseURL(options),
+          headers: {
+            Authorization: `Bearer ${this.getToken()}`,
+            ...this.getHeaders(),
+            ...(options?.headers || {}),
           }
-        }
-        
-        this.cancelToken[options.url] = axios.CancelToken.source();
-        const token = this.getToken();
-        
-        if (token !== this.token || !token) {
-          this.reloadAxios();
-        }
-    
-        return this.formatResponse(
-          this.api.put(options.url, options.data, {
-            cancelToken: this.cancelToken[options.url].token,
-            baseURL: options.baseURL || this.getBaseURL(options),
-            headers: {
-              Authorization: `Bearer ${this.getToken()}`,
-              ...this.getHeaders(),
-              ...(options?.headers || {}),
-            }
-          })
-            .catch((err) => this.onError(err, options.onUnauthorized))
-        );
-    }
+        })
+          .catch((err) => this.onError(err, options.onUnauthorized))
+      );
+  }
 
-    apiPatch(options) {
-        const token = this.getToken();
-        
-        if (token !== this.token || !token) {
-          this.reloadAxios();
-        }
-    
-        return this.formatResponse(
-          this.api.patch(options.url, options.data, {
-            baseURL: options.baseURL || this.getBaseURL(options),
-            headers: {
-              Authorization: `Bearer ${this.getToken()}`,
-              ...this.getHeaders(),
-              ...(options?.headers || {}),
-            }
-          })
-            .catch((err) => this.onError(err))
-        );
-    }
-    
-    // Utility method
-    assignParamsToUrl(path, params) {
-        return assignParamsToUrl(path, params);
-    }
+  apiPatch(options) {
+      this._ensureAxiosInitialized(); // 🔥 Ensure initialized
+      
+      const token = this.getToken();
+      
+      if (token !== this.token || !token) {
+        this.reloadAxios();
+      }
+  
+      return this.formatResponse(
+        this.api.patch(options.url, options.data, {
+          baseURL: options.baseURL || this.getBaseURL(options),
+          headers: {
+            Authorization: `Bearer ${this.getToken()}`,
+            ...this.getHeaders(),
+            ...(options?.headers || {}),
+          }
+        })
+          .catch((err) => this.onError(err))
+      );
+  }
+  
+  // Utility method
+  assignParamsToUrl(path, params) {
+      return assignParamsToUrl(path, params);
+  }
 }

package/src/@daf/services/helpers/config.js

@@ -11,6 +11,10 @@ let globalConfig = {
   
 export const configureServices = (config) => {
     globalConfig = { ...globalConfig, ...config };
+    console.log({configureServices: globalConfig})
 };
   
-export const getConfig = () => globalConfig;
+export const getConfig = () => {
+    console.log({getConfig: globalConfig})
+    return globalConfig;
+};