@lcap/nasl 2.22.0-beta.5 → 3.0.0-beta.1

package/src/breakpoint/shared/socket.ts

@@ -0,0 +1,326 @@
+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,
+} from './constants';
+
+type RequestData = {
+    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 Getter = () => Record<string, any>;
+type Listner = (source: ResponseData['data']) => void;
+
+let socket: Socket;
+const store: Record<string, Listner[]> = {};
+
+const socketType = 'debug';
+
+const namespace = '/debug/ide';
+const path = '/debug/context';
+
+const nativeTypes = [EVENT_DISCONNECT, EVENT_RECONNECT];
+
+const callback = (result: ResponseData = {}) => {
+    const { type, data = {} } = result;
+    const { eventType } = data;
+
+    if (!type) {
+        return;
+    }
+
+    const key = type === RESPONSE_TYPE_FRONTEND_INFO ? eventType : type;
+
+    if (!key) {
+        return;
+    }
+
+    const { [key]: listeners = [] } = store;
+
+    listeners.forEach((listener) => listener(data));
+};
+
+const register = (socket: Socket) => {
+    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);
+    });
+};
+
+export const disconnect = () => {
+    socket && socket.disconnect();
+    socket = null;
+
+    callback({ type: EVENT_DISCONNECT });
+};
+
+export const off = (type: string, listener: Listner) => {
+    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);
+
+    return () => off(type, listener);
+};
+
+export const emit = (data: RequestData = {}) => {
+    if (!socket) {
+        return;
+    }
+
+    socket.emit(socketType, data);
+};
+
+let getter: Getter = () => ({});
+
+const getBackenPolyfill = () => getter && getter();
+
+export const setBackendPolyfillGetter = (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);
+
+    for (let i = 0; i < length; i += 1) {
+        if (a[i] !== b[i]) {
+            return true;
+        }
+    }
+
+    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);
+});
+
+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;
+
+        if (eventType !== EVENT_TYPE_OBJECT_INFO) {
+            return;
+        }
+
+        const requestValues = [requestUniqueId];
+        const useful = isUsefulArray(requestValues);
+
+        if (!useful) {
+            return;
+        }
+
+        return tick()(RESPONSE_TYPE_OBJECT_INFO, (data = {}) => {
+            const {
+                variable,
+                uniqueId: responseUniqueId,
+            } = data;
+
+            if (!variable) {
+                return;
+            }
+
+            const responseValues = [responseUniqueId];
+            const different = isDifferentArray(responseValues, requestValues);
+
+            return different ? undefined : variable;
+        });
+    },
+];
+
+export const emitToBackend = (operation: RequestData['operation'] = {}) => {
+    const backendPolyfill = getBackenPolyfill() || {};
+    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++;
+
+export const emitToFrontend = (operation: RequestData['operation'] = {}) => {
+    const beacon = getBeacon();
+
+    const data = {
+        target: TARGET_FRONTEND,
+        operation: { beacon, ...operation },
+    };
+
+    emit(data);
+
+    const { eventType } = operation;
+
+    if (!eventType) {
+        return;
+    }
+
+    return tick()(eventType, (data = {}) => {
+        const { beacon: responseBeacon, result = 'null' } = data;
+
+        if (responseBeacon !== beacon) {
+            return;
+        }
+
+        let value;
+
+        try {
+            value = JSON.parse(result);
+        } catch (error) {
+            value = 'null';
+            console.error(error);
+        }
+
+        return value;
+    });
+};

package/src/breakpoint/shared/utils.ts

@@ -0,0 +1,195 @@
+import { App, View, ViewElement, BaseNode } from '../../concepts';
+
+import { TRAVERSE_NODE_KEYS, BREAKPOINT_CONCEPTS } from './constants';
+
+type Callback = (node: BaseNode) => void;
+
+type HistoryInApp = {
+    _historyIndex?: number,
+    _historyList?: Array<{
+        list?: Array<{
+            action?: 'delete' | 'create' | 'update',
+            object?: null | Record<string, any>,
+            oldObject?: null | Record<string, any>,
+        }>,
+    }>,
+};
+
+const neatKeys = [
+    'breakpoint',
+    'offsetX',
+    'offsetY',
+];
+
+export const isAppDirty = (app: HistoryInApp = {}) => {
+    if (!app) {
+        return false;
+    }
+
+    const {
+        _historyIndex = 0,
+        _historyList = [],
+    } = app;
+
+    const historyList = _historyList.slice(0, _historyIndex);
+
+    return historyList.some((item = {}) => {
+        const { list = [] } = item;
+
+        return list.some((current = {}) => {
+            const { action, oldObject } = current;
+
+            if (action !== 'update') {
+                return true;
+            }
+
+            if (!oldObject) {
+                return false;
+            }
+
+            const keys = Object.keys(oldObject);
+            const filter = (key: string) => !neatKeys.includes(key);
+            const dirtyKeys = keys.filter(filter);
+
+            return dirtyKeys.length > 0;
+        });
+    });
+};
+
+export const getRealNode = (node: BaseNode): BaseNode => {
+    if (!node) {
+        return;
+    }
+
+    const { concept, object } = (node as any);
+
+    if (concept === 'MemberExpression') {
+        return getRealNode(object as BaseNode);
+    }
+
+    return node;
+};
+
+const unbrakableAncestors = [
+    'BindAttribute',
+    'CallAuthInterface',
+];
+
+export const isBreakable = (node: BaseNode): Boolean => {
+    node = getRealNode(node);
+
+    if (!node) {
+        return false;
+    }
+
+    const { concept } = node;
+
+    const ancestor = unbrakableAncestors.some((ancestor) => node.getAncestor(ancestor));
+
+    if (ancestor) {
+        return false;
+    }
+
+    return BREAKPOINT_CONCEPTS.includes(concept);
+};
+
+export const getUniqueIdFromNode = (node: BaseNode) => node && node.nodePath;
+
+export const getLogics = (app: App) => {
+    if (!app) {
+        return [];
+    }
+
+    const { logics = [], frontends = [] } = app;
+
+    let result = logics;
+
+    const forViewElement = (viewElement: ViewElement) => {
+        if (!viewElement) {
+            return;
+        }
+
+        const {
+            children: viewElementChildren = [],
+            bindEvents: viewElementBindEvents = [],
+        } = viewElement;
+
+        viewElementBindEvents.forEach((bindEvent) => {
+            const { logics: bindEventLogics = [] } = bindEvent;
+
+            result = result.concat(bindEventLogics);
+        });
+
+        viewElementChildren.forEach(forViewElement);
+    };
+
+    const forView = (view: View) => {
+        if (!view) {
+            return;
+        }
+
+        const {
+            logics: viewLogics = [],
+            elements: viewElements = [],
+            children: viewChildren = [],
+            bindEvents: viewBindEvents = [],
+        } = view;
+
+        result = result.concat(viewLogics);
+
+        viewBindEvents.forEach((bindEvent) => {
+            const { logics: bindEventLogics = [] } = bindEvent;
+
+            result = result.concat(bindEventLogics);
+        });
+
+        viewElements.forEach(forViewElement);
+        viewChildren.forEach(forView);
+    };
+
+    frontends.forEach((frontend) => {
+        const { views = [] } = frontend;
+
+        views.forEach(forView);
+    });
+
+    return result;
+};
+
+const hadBreakpoint = (node: BaseNode) => {
+    if (node instanceof BaseNode) {
+        return node.breakpoint;
+    }
+
+    return false;
+};
+
+export const traverseBreakpointOnNode = (node: (BaseNode | any), callback: Callback) => {
+    if (!node) {
+        return;
+    }
+
+    const operate = (item: BaseNode) => hadBreakpoint(item) && callback(item);
+    const forEach = (item: BaseNode) => {
+        operate(item);
+        traverseBreakpointOnNode(item, callback);
+    };
+
+    operate(node);
+    TRAVERSE_NODE_KEYS.forEach((key) => {
+        const { [key]: value } = node;
+        const array = Array.isArray(value) ? value : [value];
+
+        array.forEach(forEach);
+    });
+};
+
+export const traverseBreakpointOnApp = (app: App, callback: Callback) => {
+    if (!app) {
+        return;
+    }
+
+    const logics = getLogics(app);
+
+    logics.forEach((logic) => traverseBreakpointOnNode(logic, callback));
+};