@lcap/nasl 3.2.0-beta.3 → 3.3.0-alpha

package/src/breakpoint/shared/socket.ts

@@ -1,52 +1,57 @@
 import io, { Socket } from 'socket.io-client';
 
 import {
-    EVENT_DISCONNECT,
-    EVENT_RECONNECT,
-    TARGET_BACKEND,
-    TARGET_FRONTEND,
-    EVENT_TYPE_BREAKPOINT,
-    EVENT_TYPE_PAGE_INFO,
-    EVENT_TYPE_OBJECT_INFO,
-    RESPONSE_TYPE_FRONTEND_INFO,
-    RESPONSE_TYPE_OBJECT_INFO,
-    RESPONSE_TYPE_PAGE_INFO,
+  JSON_VOID,
+  EVENT_DISCONNECT,
+  EVENT_RECONNECT,
+  TARGET_BACKEND,
+  TARGET_FRONTEND,
+  EVENT_TYPE_BREAKPOINT,
+  EVENT_TYPE_PAGE_INFO,
+  EVENT_TYPE_OBJECT_INFO,
+  EVENT_TYPE_RETURN_INFO,
+  RESPONSE_TYPE_FRONTEND_INFO,
+  RESPONSE_TYPE_OBJECT_INFO,
+  RESPONSE_TYPE_RETURN_INFO,
+  RESPONSE_TYPE_PAGE_INFO,
 } from './constants';
 
+import { toStringVoid } from './utils';
+
 type RequestData = {
-    target?: string,
-    operation?: {
-        eventType?: string,
-        path?: string,
-        threadId?: number,
-        breakpointStatus?: string,
-        frontendInfo?: any,
-        breakpoint?: {
-            path?: string,
-            breakpointStatus?: string,
-        },
-        [key: string]: any,
+  target?: string,
+  operation?: {
+    eventType?: string,
+    path?: string,
+    threadId?: number,
+    breakpointStatus?: string,
+    frontendInfo?: any,
+    breakpoint?: {
+      path?: string,
+      breakpointStatus?: string,
     },
+    [key: string]: any,
+  },
 };
 
 type ResponseData = {
-    type?: string,
-    data?: {
-        path?: string,
-        eventType?: string,
-        pageNum?: number,
-        pageSize?: number,
-        uniqueId?: number,
-        threadId?: number,
-        requestId?: number,
-        connectionName?: string,
-        connectionStatus?: string,
-        exceptionMsg?: string,
-        variables?: any,
-        variable?: any,
-        beacon?: any,
-        result?: any,
-    },
+  type?: string,
+  data?: {
+    path?: string,
+    eventType?: string,
+    pageNum?: number,
+    pageSize?: number,
+    uniqueId?: number,
+    threadId?: number,
+    requestId?: number,
+    connectionName?: string,
+    connectionStatus?: string,
+    exceptionMsg?: string,
+    variables?: any,
+    variable?: any,
+    beacon?: any,
+    result?: any,
+  },
 };
 
 type Getter = () => Record<string, any>;
@@ -63,264 +68,313 @@ const path = '/debug/context';
 const nativeTypes = [EVENT_DISCONNECT, EVENT_RECONNECT];
 
 const callback = (result: ResponseData = {}) => {
-    const { type, data = {} } = result;
-    const { eventType } = data;
+  const { type, data = {} } = result;
+  const { eventType } = data;
 
-    if (!type) {
-        return;
-    }
+  if (!type) {
+    return;
+  }
 
-    const key = type === RESPONSE_TYPE_FRONTEND_INFO ? eventType : type;
+  const key = type === RESPONSE_TYPE_FRONTEND_INFO ? eventType : type;
 
-    if (!key) {
-        return;
-    }
+  if (!key) {
+    return;
+  }
 
-    const { [key]: listeners = [] } = store;
+  const { [key]: listeners = [] } = store;
 
-    listeners.forEach((listener) => listener(data));
+  listeners.forEach((listener) => listener(data));
 };
 
 const register = (socket: Socket) => {
-    socket && nativeTypes.forEach((type) => {
-        socket.on(type, () => callback({ type }));
-    });
+  socket && nativeTypes.forEach((type) => {
+    socket.on(type, () => callback({ type }));
+  });
 };
 
 export const isConnected = () => socket && socket.connected;
 
 export const connect = (appId = '') => {
-    if (socket) {
-        return;
-    }
-
-    if (!appId) {
-        return;
-    }
-
-    const query = { appId };
-    const extraHeaders = query;
-
-    const transportOptions = {
-        polling: { extraHeaders },
-    };
-
-    socket = io(namespace, {
-        transports: ['websocket'],
-        reconnectionAttempts: 5,
-        transportOptions,
-        path,
-        query,
-    });
-
-    socket.on(socketType, callback);
-    register(socket);
-
-    return new Promise((resolve, reject) => {
-        socket.on('connect', () => resolve(socket));
-
-        socket.on('error', reject);
-        socket.on('connect_error', reject);
-        socket.on('connect_timeout', reject);
-        socket.on(EVENT_DISCONNECT, reject);
-    });
+  if (socket) {
+    return;
+  }
+
+  if (!appId) {
+    return;
+  }
+
+  const query = { appId };
+  const extraHeaders = query;
+
+  const transportOptions = {
+    polling: { extraHeaders },
+  };
+
+  socket = io(namespace, {
+    transports: ['websocket'],
+    reconnectionAttempts: 5,
+    transportOptions,
+    path,
+    query,
+  });
+
+  socket.on(socketType, callback);
+  register(socket);
+
+  return new Promise((resolve, reject) => {
+    socket.on('connect', () => resolve(socket));
+
+    socket.on('error', reject);
+    socket.on('connect_error', reject);
+    socket.on('connect_timeout', reject);
+    socket.on(EVENT_DISCONNECT, reject);
+  });
 };
 
 export const disconnect = () => {
-    socket && socket.disconnect();
-    socket = null;
+  socket && socket.disconnect();
+  socket = null;
 
-    callback({ type: EVENT_DISCONNECT });
+  callback({ type: EVENT_DISCONNECT });
 };
 
 export const off = (type: string, listener: Listner) => {
-    const { [type]: listeners = [] } = store;
-    store[type] = listeners.filter((item) => item !== listener);
+  const { [type]: listeners = [] } = store;
+  store[type] = listeners.filter((item) => item !== listener);
 };
 
 export const on = (type: string, listener: Listner) => {
-    const { [type]: listeners = [] } = store;
-    store[type] = listeners.concat(listener);
+  const { [type]: listeners = [] } = store;
+  store[type] = listeners.concat(listener);
 
-    return () => off(type, listener);
+  return () => off(type, listener);
 };
 
 export const emit = (data: RequestData = {}) => {
-    if (!socket) {
-        return;
-    }
+  if (!socket) {
+    return;
+  }
 
-    socket.emit(socketType, data);
+  socket.emit(socketType, data);
 };
 
 let getter: Getter = () => ({});
 
-const getBackenPolyfill = () => getter && getter();
+const getPolyfill = () => getter && getter();
 
-export const setBackendPolyfillGetter = (rookie: Getter) => {
-    getter = rookie || getter;
+export const setPolyfillGetter = (rookie: Getter) => {
+  getter = rookie || getter;
 };
 
 const isUsefulArray = (array: any[] = []) => array.every((item) => item !== undefined);
 const isDifferentArray = (a: any[] = [], b: any[] = []) => {
-    const length = Math.max(a.length, b.length);
+  const length = Math.max(a.length, b.length);
 
-    for (let i = 0; i < length; i += 1) {
-        if (a[i] !== b[i]) {
-            return true;
-        }
+  for (let i = 0; i < length; i += 1) {
+    if (a[i] !== b[i]) {
+      return true;
     }
+  }
 
-    return false;
+  return false;
 };
 
 const tick = (time = 5000) => (...args: Parameters<typeof on>) => new Promise((resolve) => {
-    // eslint-disable-next-line
-    let un: ReturnType<typeof on>;
-    // eslint-disable-next-line
-    let timer: ReturnType<typeof setTimeout>;
-    const [type, listener] = args;
-
-    const callback: typeof listener = async (...rest) => {
-        const result = listener && await listener(...rest);
-
-        if (result === undefined) {
-            return;
-        }
-
-        un();
-        resolve(result);
-        timer && clearTimeout(timer);
-    };
-
-    un = on(type, callback);
-    timer = setTimeout(un, time);
+  // eslint-disable-next-line
+  let un: ReturnType<typeof on>;
+  // eslint-disable-next-line
+  let timer: ReturnType<typeof setTimeout>;
+  const [type, listener] = args;
+
+  const callback: typeof listener = async (...rest) => {
+    const result = listener && await listener(...rest);
+
+    if (result === undefined) {
+      return;
+    }
+
+    un();
+    resolve(result);
+    timer && clearTimeout(timer);
+  };
+
+  un = on(type, callback);
+  timer = setTimeout(un, time);
 });
 
 const tickers = [
-    (data: RequestData = {}) => {
-        const { operation = {} } = data;
-        const {
-            eventType,
-            pageNum: requestPageNum,
-            pageSize: requestPageSize,
-            uniqueId: requestUniqueId,
-        } = operation;
-
-        if (eventType !== EVENT_TYPE_PAGE_INFO) {
-            return;
-        }
-
-        const requestValues = [requestPageNum, requestPageSize, requestUniqueId];
-        const useful = isUsefulArray(requestValues);
-
-        if (!useful) {
-            return;
-        }
-
-        return tick()(RESPONSE_TYPE_PAGE_INFO, (data = {}) => {
-            const {
-                variable,
-                pageNum: responsePageNum,
-                pageSize: responsePageSize,
-                uniqueId: responseUniqueId,
-            } = data;
-
-            if (!variable) {
-                return;
-            }
-
-            const responseValues = [responsePageNum, responsePageSize, responseUniqueId];
-            const different = isDifferentArray(responseValues, requestValues);
-
-            return different ? undefined : variable;
-        });
-    },
-    (data: RequestData = {}) => {
-        const { operation = {} } = data;
-        const { eventType, uniqueId: requestUniqueId } = operation;
+  (data: RequestData = {}) => {
+    const { operation = {} } = data;
+    const {
+      eventType,
+      pageNum: requestPageNum,
+      pageSize: requestPageSize,
+      uniqueId: requestUniqueId,
+    } = operation;
+
+    if (eventType !== EVENT_TYPE_PAGE_INFO) {
+      return;
+    }
 
-        if (eventType !== EVENT_TYPE_OBJECT_INFO) {
-            return;
-        }
+    const requestValues = [requestPageNum, requestPageSize, requestUniqueId];
+    const useful = isUsefulArray(requestValues);
 
-        const requestValues = [requestUniqueId];
-        const useful = isUsefulArray(requestValues);
+    if (!useful) {
+      return;
+    }
 
-        if (!useful) {
-            return;
-        }
+    return tick()(RESPONSE_TYPE_PAGE_INFO, (data = {}) => {
+      const {
+        variable,
+        pageNum: responsePageNum,
+        pageSize: responsePageSize,
+        uniqueId: responseUniqueId,
+      } = data;
 
-        return tick()(RESPONSE_TYPE_OBJECT_INFO, (data = {}) => {
-            const {
-                variable,
-                uniqueId: responseUniqueId,
-            } = data;
+      if (!variable) {
+        return;
+      }
 
-            if (!variable) {
-                return;
-            }
+      const responseValues = [responsePageNum, responsePageSize, responseUniqueId];
+      const different = isDifferentArray(responseValues, requestValues);
 
-            const responseValues = [responseUniqueId];
-            const different = isDifferentArray(responseValues, requestValues);
+      return different ? undefined : variable;
+    });
+  },
+  (data: RequestData = {}) => {
+    const { operation = {} } = data;
+    const { eventType, uniqueId: requestUniqueId } = operation;
 
-            return different ? undefined : variable;
-        });
-    },
-];
+    if (eventType !== EVENT_TYPE_OBJECT_INFO) {
+      return;
+    }
 
-export const emitToBackend = (operation: RequestData['operation'] = {}) => {
-    const backendPolyfill = getBackenPolyfill() || {};
-    operation = { ...backendPolyfill, ...operation };
+    const requestValues = [requestUniqueId];
+    const useful = isUsefulArray(requestValues);
 
-    const { threadId, eventType } = operation;
-    const data = { target: TARGET_BACKEND, operation };
+    if (!useful) {
+      return;
+    }
+
+    return tick()(RESPONSE_TYPE_OBJECT_INFO, (data = {}) => {
+      const {
+        variable,
+        uniqueId: responseUniqueId,
+      } = data;
 
-    if (!threadId && eventType !== EVENT_TYPE_BREAKPOINT) {
+      if (!variable) {
         return;
+      }
+
+      const responseValues = [responseUniqueId];
+      const different = isDifferentArray(responseValues, requestValues);
+
+      return different ? undefined : variable;
+    });
+  },
+  (data: RequestData = {}) => {
+    const { operation = {} } = data;
+    const {
+      eventType,
+      path: requestPath,
+      uniqueId: requestUniqueId = 0,
+      pageNum: requestPageNum = 0,
+      pageSize: requestPageSize = 0,
+    } = operation;
+
+    if (eventType !== EVENT_TYPE_RETURN_INFO) {
+      return;
+    }
+
+    const requestValues = [requestPath, requestUniqueId, requestPageNum, requestPageSize];
+    const useful = isUsefulArray(requestValues);
+
+    if (!useful) {
+      return;
     }
 
-    emit(data);
+    return tick()(RESPONSE_TYPE_RETURN_INFO, (data = {}) => {
+      const {
+        variable,
+        path: responsePath,
+        uniqueId: responseUniqueId = 0,
+        pageNum: responsePageNum = 0,
+        pageSize: responsePageSize = 0,
+      } = data;
 
-    return tickers.reduce((result, ticker) => result || ticker(data), undefined);
+      if (!variable) {
+        return;
+      }
+
+      const responseValues = [responsePath, responseUniqueId, responsePageNum, responsePageSize];
+      const different = isDifferentArray(responseValues, requestValues);
+
+      return different ? undefined : variable;
+    });
+  },
+];
+
+export const emitToBackend = (operation: RequestData['operation'] = {}) => {
+  const backendPolyfill = getPolyfill() || {};
+  operation = { ...backendPolyfill, ...operation };
+
+  const { threadId, eventType } = operation;
+  const data = { target: TARGET_BACKEND, operation };
+
+  if (!threadId && eventType !== EVENT_TYPE_BREAKPOINT) {
+    return;
+  }
+
+  emit(data);
+
+  return tickers.reduce((result, ticker) => result || ticker(data), undefined);
 };
 
 let uId = 0;
 
 export const getBeacon = () => uId++;
 
+const reviver = (key: string, value: any) => {
+  if (value === JSON_VOID) {
+    value = toStringVoid();
+  }
+
+  return value;
+};
+
 export const emitToFrontend = (operation: RequestData['operation'] = {}) => {
-    const beacon = getBeacon();
+  const beacon = getBeacon();
+  const { scopeId } = getPolyfill() || {};
 
-    const data = {
-        target: TARGET_FRONTEND,
-        operation: { beacon, ...operation },
-    };
+  const data = {
+    target: TARGET_FRONTEND,
+    operation: { beacon, scopeId, ...operation },
+  };
 
-    emit(data);
+  emit(data);
 
-    const { eventType } = operation;
+  const { eventType } = operation;
 
-    if (!eventType) {
-        return;
-    }
+  if (!eventType) {
+    return;
+  }
 
-    return tick()(eventType, (data = {}) => {
-        const { beacon: responseBeacon, result = 'null' } = data;
+  return tick()(eventType, (data = {}) => {
+    const { beacon: responseBeacon, result = 'null' } = data;
 
-        if (responseBeacon !== beacon) {
-            return;
-        }
+    if (responseBeacon !== beacon) {
+      return;
+    }
 
-        let value;
+    let value;
 
-        try {
-            value = JSON.parse(result);
-        } catch (error) {
-            value = 'null';
-            console.error(error);
-        }
+    try {
+      value = JSON.parse(result, reviver);
+    } catch (error) {
+      value = 'null';
+      console.error(error);
+    }
 
-        return value;
-    });
+    return value;
+  });
 };