@addev-be/ui 0.1.26 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addev-be/ui",
-  "version": "0.1.26",
+  "version": "0.2.1",
   "type": "module",
   "scripts": {
     "watch": "tsc -b --watch",

package/src/services/HttpService.ts

@@ -0,0 +1,80 @@
+import { Config } from '../config';
+import { Request } from './base';
+import { trimEnd } from 'lodash';
+import { v4 } from 'uuid';
+
+export class HttpService {
+  private static instance: HttpService;
+  private config: Config;
+  private promises: {
+    [id: string]: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      resolve: (value: any) => void;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      reject: (reason?: any) => void;
+    };
+  } = {};
+
+  constructor(config: Config) {
+    HttpService.instance = this;
+    this.config = config;
+  }
+
+  public static getInstance() {
+    return HttpService.instance;
+  }
+
+  public sendRequest<TReq, TRes>(name: string, data: TReq) {
+    const id = v4();
+    const promise = new Promise<TRes>((resolve, reject) => {
+      const request: Request = { id, name, data };
+      this.promises[id] = { resolve, reject };
+      console.log('[HTTP] Sending request:', request);
+      fetch(`${trimEnd(this.config.httpServerUrl, '/')}/${name}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(request),
+      })
+        .then(async (response) => {
+          if (!response.ok) {
+            throw new Error('HTTP request failed');
+          }
+          const body = await response.text();
+          this.parseMessage(body);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+    return promise;
+  }
+
+  private parseMessage(message: string) {
+    try {
+      const response = JSON.parse(message);
+      if (!response.id) {
+        throw new Error('Received message is not valid');
+      }
+      if (this.promises[response.id]) {
+        console.log('[HTTP] Received response:', response);
+        if (
+          typeof response.data?.status === 'number' &&
+          response.data.status < 0
+        ) {
+          this.promises[response.id].reject(new Error(response.data.message));
+        } else {
+          this.promises[response.id].resolve(response.data);
+        }
+        delete this.promises[response.id];
+      } else {
+        console.log('[HTTP] Received request:', response);
+        // TODO : Implement request handling
+        throw new Error('Not yet implemented');
+      }
+    } catch (error) {
+      console.error('[HTTP] Error parsing message:', error);
+    }
+  }
+}

package/src/services/advancedRequests.ts

@@ -1,4 +1,4 @@
-import { useRequestHandler } from './hooks';
+import { useWebSocketRequestHandler } from './hooks';
 
 export type FieldDTO<T extends string = string> = {
   fieldName?: T;
@@ -93,9 +93,9 @@ export type AdvancedRequestFieldDTO =
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const useAdvancedRequestHandler = <T = any>() =>
-  useRequestHandler<AdvancedRequestDTO, AdvancedResponseDTO<T>>(
+  useWebSocketRequestHandler<AdvancedRequestDTO, AdvancedResponseDTO<T>>(
     'AdvancedRequest'
   );
 
 export const useRawAdvancedRequestHandler = () =>
-  useRequestHandler<AdvancedRequestDTO, string>('RawAdvancedRequest');
+  useWebSocketRequestHandler<AdvancedRequestDTO, string>('RawAdvancedRequest');

package/src/services/hooks.ts

@@ -1,13 +1,23 @@
+import { HttpService } from './HttpService';
 import { WebSocketService } from './WebSocketService';
 import { useCallback } from 'react';
 
-export const useRequestHandler = <TReq, TRes>(
+export const useWebSocketRequestHandler = <TReq, TRes>(
   name: string
-): ((data: TReq) => Promise<TRes>) => {
-  return useCallback(
+): ((data: TReq) => Promise<TRes>) =>
+  useCallback(
     (data: TReq) => {
       return WebSocketService.getInstance().sendRequest<TReq, TRes>(name, data);
     },
     [name]
   );
-};
+
+export const useHttpRequestHandler = <TReq, TRes>(
+  name: string
+): ((data: TReq) => Promise<TRes>) =>
+  useCallback(
+    (data: TReq) => {
+      return HttpService.getInstance().sendRequest<TReq, TRes>(name, data);
+    },
+    [name]
+  );

package/src/services/sqlRequests.ts

@@ -1,4 +1,4 @@
-import { useRequestHandler } from './hooks';
+import { useWebSocketRequestHandler } from './hooks';
 
 export type FieldDTO<T extends string = string> = {
   fieldName?: T;
@@ -91,6 +91,8 @@ type SqlRequestHandler<T> = (
 export const useSqlRequestHandler = <T = any>(
   name: string
 ): [SqlRequestHandler<T>, SqlRequestHandler<{ Id: string }>] => [
-  useRequestHandler<SqlRequestDTO, SqlResponseDTO<T>>(name),
-  useRequestHandler<SqlRequestDTO, SqlResponseDTO<{ Id: string }>>(name),
+  useWebSocketRequestHandler<SqlRequestDTO, SqlResponseDTO<T>>(name),
+  useWebSocketRequestHandler<SqlRequestDTO, SqlResponseDTO<{ Id: string }>>(
+    name
+  ),
 ];