datastake-daf 0.6.494 → 0.6.496

package/dist/services/index.js

@@ -6135,9 +6135,6 @@ class BaseHTTPService {
       timeout = 300000,
       customAxiosConfig = {}
     } = config;
-    console.log({
-      baseHTTPService: config
-    });
     this.getToken = getToken || (() => null);
     this.getHeaders = getHeaders || (() => ({}));
     this.getBaseURL = getBaseURL || (() => null);
@@ -6149,7 +6146,14 @@ class BaseHTTPService {
     // Init
     this.cancelToken = {};
     this.token = this.getToken();
-    this.setupAxios();
+    this.api = null;
+    this._axiosInitialized = false;
+  }
+  _ensureAxiosInitialized() {
+    if (!this._axiosInitialized) {
+      this.setupAxios();
+      this._axiosInitialized = true;
+    }
   }
   setupAxios() {
     const headers = {
@@ -6167,8 +6171,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);
@@ -6193,6 +6195,7 @@ class BaseHTTPService {
     }
     this.api = axios$1.create(options);
     this.setupInterceptors();
+    this._axiosInitialized = true;
   }
   async formatResponse(call) {
     try {
@@ -6213,6 +6216,8 @@ class BaseHTTPService {
     }
   }
   apiPost(options) {
+    this._ensureAxiosInitialized();
+
     // Check if there are any previous pending requests
     if (typeof this.cancelToken[options.url] != typeof undefined) {
       try {
@@ -6238,6 +6243,7 @@ class BaseHTTPService {
     }).catch(err => this.onError(err)));
   }
   apiGet(options) {
+    this._ensureAxiosInitialized();
     const token = this.getToken();
     if (token !== this.token || !token) {
       this.reloadAxios();
@@ -6257,6 +6263,7 @@ class BaseHTTPService {
     }).catch(err => this.onError(err)));
   }
   apiDelete(options) {
+    this._ensureAxiosInitialized();
     const token = this.getToken();
     if (token !== this.token || !token) {
       this.reloadAxios();
@@ -6276,6 +6283,7 @@ class BaseHTTPService {
     }).catch(err => this.onError(err)));
   }
   apiPut(options) {
+    this._ensureAxiosInitialized();
     if (typeof this.cancelToken[options.url] != typeof undefined) {
       try {
         this.cancelToken[options.url].cancel("Operation canceled due to new request.");
@@ -6300,6 +6308,7 @@ class BaseHTTPService {
     }).catch(err => this.onError(err, options.onUnauthorized)));
   }
   apiPatch(options) {
+    this._ensureAxiosInitialized();
     const token = this.getToken();
     if (token !== this.token || !token) {
       this.reloadAxios();
@@ -6392,6 +6401,36 @@ const getConfig = () => {
   return globalConfig;
 };
 
+/**
+ * Creates a lazy-loading proxy for a service class
+ * The service instance is only created when a method is first accessed
+ * This ensures that global configuration is applied before service initialization
+ * 
+ * @param {Class} ServiceClass - The service class to instantiate lazily
+ * @returns {Proxy} A proxy that creates the instance on first access
+ * 
+ * @example
+ * class MyService extends BaseService {
+ *   getData() { return this.apiGet({ url: '/data' }); }
+ * }
+ * export default createLazyService(MyService);
+ */
+function createLazyService(ServiceClass) {
+  let instance = null;
+  return new Proxy({}, {
+    get(target, prop) {
+      // Create instance on first property access
+      if (!instance) {
+        instance = new ServiceClass();
+      }
+      const value = instance[prop];
+
+      // Bind methods to maintain correct 'this' context
+      return typeof value === 'function' ? value.bind(instance) : value;
+    }
+  });
+}
+
 /**
  * Generic error handler factory for axios requests
  * Highly configurable to adapt to different project needs
@@ -6486,49 +6525,53 @@ class ErrorService {
   }
 }
 
+// In datastake-daf - src/services/BaseService.js
 class BaseService extends BaseHTTPService {
   constructor() {
-    const config = getConfig();
-    console.log({
-      baseService: config
-    });
-    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();
     }
@@ -6553,9 +6596,92 @@ class BaseService extends BaseHTTPService {
   }
 }
 
+// src/services/AdminService.js
+class AdminService extends BaseService {
+  updateCompany(id, data) {
+    return this.apiPut({
+      url: `/companies/${id}`,
+      data
+    });
+  }
+  getAccount({
+    id
+  }) {
+    return this.apiGet({
+      url: `/accounts/${id}`
+    });
+  }
+  inviteAccount(data) {
+    return this.apiPost({
+      url: `/accounts/inviteAccount`,
+      data
+    });
+  }
+  getAccounts({
+    params
+  }) {
+    return this.apiGet({
+      params,
+      url: `/accounts`
+    });
+  }
+  updateAccount({
+    data,
+    id
+  }) {
+    return this.apiPut({
+      data,
+      url: `/accounts/${id}`
+    });
+  }
+  toggleAccountStatus({
+    id
+  }) {
+    return this.apiPut({
+      url: `/accounts/suspendActivate/${id}`
+    });
+  }
+  transferAdmin({
+    userId,
+    id
+  }) {
+    return this.apiPut({
+      url: `/accounts/transfer-rights/${id}`,
+      data: {
+        userId
+      }
+    });
+  }
+  getUsers({
+    params
+  }) {
+    return this.apiGet({
+      params,
+      url: `/accounts/users`
+    });
+  }
+  impersonate({
+    id
+  }) {
+    return this.apiGet({
+      url: `/accounts/impersonate/${id}`
+    });
+  }
+  cancelInvitation({
+    token
+  }) {
+    return this.apiPut({
+      url: `/accounts/cancelInvitation/${token}`
+    });
+  }
+}
+var AdminService$1 = createLazyService(AdminService);
+
+exports.AdminService = AdminService$1;
 exports.BaseHTTPService = BaseHTTPService;
 exports.BaseService = BaseService;
 exports.ErrorHandler = ErrorHandler;
 exports.ErrorService = ErrorService;
 exports.configureServices = configureServices;
+exports.createLazyService = createLazyService;
 exports.getConfig = getConfig;

package/package.json

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

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

@@ -0,0 +1,73 @@
+// src/services/AdminService.js
+import { BaseService } from './BaseService.js';
+import { createLazyService } from './helpers/LazyService.js';
+
+class AdminService extends BaseService {
+    updateCompany(id, data) {
+        return this.apiPut({
+          url: `/companies/${id}`,
+          data,
+        });
+    }
+
+    getAccount({ id }) {
+        return this.apiGet({
+          url: `/accounts/${id}`,
+        })
+    }
+
+    inviteAccount(data) {
+        return this.apiPost({
+          url: `/accounts/inviteAccount`, 
+          data,
+        })
+    }
+
+    getAccounts({ params }) {
+        return this.apiGet({
+          params,
+          url: `/accounts`,
+        })
+    }
+
+    updateAccount({ data, id }) {
+        return this.apiPut({
+          data,
+          url: `/accounts/${id}`,
+        })
+    }
+
+    toggleAccountStatus({ id }) {
+        return this.apiPut({
+          url: `/accounts/suspendActivate/${id}`, 
+        })
+    }
+
+    transferAdmin({ userId, id }) {
+        return this.apiPut({
+          url: `/accounts/transfer-rights/${id}`,
+          data: { userId },
+        })
+    }
+
+    getUsers({ params }) {
+        return this.apiGet({
+          params,
+          url: `/accounts/users`,
+        })
+    }
+
+    impersonate({ id }) {
+        return this.apiGet({
+          url: `/accounts/impersonate/${id}`,
+        })
+    }
+
+    cancelInvitation({ token }) {
+        return this.apiPut({
+          url: `/accounts/cancelInvitation/${token}`,
+        })
+    }
+}
+
+export default createLazyService(AdminService);

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,41 +8,43 @@ import { ErrorService } from './ErrorService.js';
 
 export class BaseService extends BaseHTTPService {
   constructor() {
-    const config = getConfig();
-    console.log({baseService: config})
-    
-    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,225 +34,241 @@ 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;
-        console.log({baseHTTPService: 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();
+      
+      this.api = null;
+      this._axiosInitialized = false;
+  }
 
-        this.setupAxios();
-    }
+  _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;
+  }
 
-        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();
+      
+      // 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();
+      
+      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();
+      
+      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();
+      
+      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();
+      
+      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/LazyService.js

@@ -0,0 +1,31 @@
+/**
+ * Creates a lazy-loading proxy for a service class
+ * The service instance is only created when a method is first accessed
+ * This ensures that global configuration is applied before service initialization
+ * 
+ * @param {Class} ServiceClass - The service class to instantiate lazily
+ * @returns {Proxy} A proxy that creates the instance on first access
+ * 
+ * @example
+ * class MyService extends BaseService {
+ *   getData() { return this.apiGet({ url: '/data' }); }
+ * }
+ * export default createLazyService(MyService);
+ */
+export function createLazyService(ServiceClass) {
+    let instance = null;
+    
+    return new Proxy({}, {
+        get(target, prop) {
+            // Create instance on first property access
+            if (!instance) {
+                instance = new ServiceClass();
+            }
+            
+            const value = instance[prop];
+            
+            // Bind methods to maintain correct 'this' context
+            return typeof value === 'function' ? value.bind(instance) : value;
+        }
+    });
+}

package/src/services.js

@@ -2,7 +2,9 @@
 export { BaseHTTPService } from './@daf/services/helpers/BaseHTTPService.js';
 export { ErrorHandler } from './@daf/services/helpers/ErrorHandler.js';
 export { configureServices, getConfig } from './@daf/services/helpers/config.js';
+export { createLazyService } from './@daf/services/helpers/LazyService.js';
 
 // SERVICES
 export { BaseService } from './@daf/services/BaseService.js';
-export { ErrorService } from './@daf/services/ErrorService.js';
+export { ErrorService } from './@daf/services/ErrorService.js';
+export { default as AdminService } from './@daf/services/AdminService.js';