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

package/src/breakpoint/generator/index.ts

@@ -5,110 +5,137 @@ import { isBreakable, getLogics } from '../shared/utils';
 
 import AfterStartNode from './AfterStartNode';
 import BeforeEndNode from './BeforeEndNode';
+import CallbackNode from './CallbackNode';
 import BreakpointNode from './BreakpointNode';
 
+const ANONYMOUS_FUNCTION_CONCEPT = 'AnonymousFunction';
 const START_CONCEPT = 'Start';
 const END_CONCEPT = 'End';
 
+const checkForVaribale = (node: BaseNode | any) => (key: string) => {
+  if (!node) {
+    return false;
+  }
+
+  if (VARIABLE_KEYS.includes(key)) {
+    return true;
+  }
+
+  if (node.concept === ANONYMOUS_FUNCTION_CONCEPT) {
+    return key === 'body';
+  }
+
+  return false;
+};
+
+const checkForLogic = (node: BaseNode | any) => (key: string) => {
+  const included = STACK_KEYS.includes(key);
+
+  return node && included;
+};
+
 const addBreakpointNodes = (node: BaseNode | any) => {
-    if (!node) {
-        return;
+  if (!node) {
+    return;
+  }
+
+  const wrap = (key: string) => (value: BaseNode) => {
+    if (!key) {
+      return value;
     }
 
-    const wrap = (key: string) => (value: BaseNode) => {
-        if (!key) {
-            return value;
-        }
-
-        const useful = value instanceof BaseNode;
-        const breakable = useful && isBreakable(value);
-
-        if (!useful) {
-            return value;
-        }
-
-        addBreakpointNodes(value);
-
-        if (breakable) {
-            return new BreakpointNode({ [key]: value });
-        }
-
-        switch (value.concept) {
-            case START_CONCEPT: {
-                return new AfterStartNode({ [key]: value });
-            }
-            case END_CONCEPT: {
-                return new BeforeEndNode({ [key]: value });
-            }
-            default: {
-                return value;
-            }
-        }
-    };
-
-    NODE_KEYS.forEach((key) => {
-        const { [key]: value } = node;
-
-        const isVaribale = VARIABLE_KEYS.includes(key);
-        const isStack = STACK_KEYS.includes(key);
-        const isArray = Array.isArray(value);
-
-        if (isVaribale) {
-            const warpper = wrap('variable');
-
-            if (isArray) {
-                node[key] = value.map(warpper);
-            } else {
-                node[key] = warpper(value);
-            }
-        }
-
-        if (isStack && isArray) {
-            const warpper = wrap('logic');
-
-            node[key] = value.map(warpper);
-        }
-    });
-};
+    const useful = value instanceof BaseNode;
+    const breakable = useful && isBreakable(value);
 
-const removeBreakpointNodes = (node: BaseNode | any) => {
-    if (!node) {
-        return;
+    if (!useful) {
+      return value;
     }
 
-    const getter = (value: BaseNode) => {
-        if (value instanceof BreakpointNode) {
-            value = value.variable || value.logic;
-        }
+    addBreakpointNodes(value);
 
-        if (value instanceof BaseNode) {
-            removeBreakpointNodes(value);
-        }
+    if (breakable) {
+      return new BreakpointNode({ [key]: value });
+    }
 
+    switch (value.concept) {
+      case START_CONCEPT: {
+        return new AfterStartNode({ [key]: value });
+      }
+      case END_CONCEPT: {
+        return new BeforeEndNode({ [key]: value });
+      }
+      case ANONYMOUS_FUNCTION_CONCEPT: {
+        return new CallbackNode({ [key]: value });
+      }
+      default: {
         return value;
-    };
+      }
+    }
+  };
+
+  NODE_KEYS.forEach((key) => {
+    const { [key]: value } = node;
+
+    const isVaribale = checkForVaribale(node)(key);
+    const isLogic = checkForLogic(node)(key);
+    const isArray = Array.isArray(value);
 
-    NODE_KEYS.forEach((key) => {
-        const { [key]: value } = node;
+    if (isVaribale) {
+      const warpper = wrap('variable');
 
-        if (Array.isArray(value)) {
-            node[key] = value.map(getter);
-        } else {
-            node[key] = getter(value);
-        }
-    });
+      if (isArray) {
+        node[key] = value.map(warpper);
+      } else {
+        node[key] = warpper(value);
+      }
+    }
+
+    if (isLogic && isArray) {
+      const warpper = wrap('logic');
+
+      node[key] = value.map(warpper);
+    }
+  });
+};
+
+const removeBreakpointNodes = (node: BaseNode | any) => {
+  if (!node) {
+    return;
+  }
+
+  const getter = (value: BaseNode) => {
+    if (value instanceof BreakpointNode) {
+      value = value.node;
+    }
+
+    if (value instanceof BaseNode) {
+      removeBreakpointNodes(value);
+    }
+
+    return value;
+  };
+
+  NODE_KEYS.forEach((key) => {
+    const { [key]: value } = node;
+
+    if (Array.isArray(value)) {
+      node[key] = value.map(getter);
+    } else {
+      node[key] = getter(value);
+    }
+  });
 };
 
 export const genBreakpoints = (app: App) => {
-    const logics = getLogics(app);
+  const logics = getLogics(app);
 
-    logics.forEach(addBreakpointNodes);
+  logics.forEach(addBreakpointNodes);
 };
 
 export const clearBreakpoints = (app: App) => {
-    const logics = getLogics(app);
+  const logics = getLogics(app);
 
-    logics.forEach(removeBreakpointNodes);
+  logics.forEach(removeBreakpointNodes);
 };
 
 export default genBreakpoints;

package/src/breakpoint/shared/constants.ts

@@ -1,69 +1,73 @@
+export const JSON_VOID = 'new String(\'void\')';
+
 export const VARIABLE_KEYS = [
-    'test',
-    'left',
-    'right',
-    'rights',
-    'patterns',
-    'arguments',
-    'expression',
-    'expressions',
-    'cases',
-    'each',
-    'end',
-    'link',
-    'start',
-    'anchor',
-    'keys',
-    'values',
+  'test',
+  'left',
+  'right',
+  'rights',
+  'patterns',
+  'arguments',
+  'expression',
+  'expressions',
+  'cases',
+  'each',
+  'end',
+  'link',
+  'start',
+  'anchor',
+  'keys',
+  'values',
+  'items',
 ];
 
 export const STACK_KEYS = [
-    'body',
-    'consequent',
-    'alternate',
+  'body',
+  'consequent',
+  'alternate',
 ];
 
 export const NODE_KEYS = [
-    ...VARIABLE_KEYS,
-    ...STACK_KEYS,
+  ...VARIABLE_KEYS,
+  ...STACK_KEYS,
 ];
 
 export const TRAVERSE_NODE_KEYS = [
-    'playground',
-    ...NODE_KEYS,
+  'playground',
+  ...NODE_KEYS,
 ];
 
 export const BREAKPOINT_CONCEPTS = [
-    'IfStatement',
-    'Match',
-    'SwitchStatement',
-    'ForEachStatement',
-    'WhileStatement',
-    // 'StringInterpolation',
-    'New',
-    'NewMap',
-    'NewList',
-    'NewComposite',
-    'Unparsed',
-    'CallFunction',
-    'CallLogic',
-    'CallInterface',
-    'CallAuthInterface',
-    'Assignment',
-    'BatchAssignment',
-    // 'CallConsoleLog',
-    'CallMessageShow',
-    'Destination',
-    'ExternalDestination',
-    'JSBlock',
-    // 'BinaryExpression',
-    // 'UnaryExpression',
-    // 'End',
-    // 'JSONSerialize',
-    // 'JSONDeserialize',
-    'SqlQueryComponent',
-    'OqlQueryComponent',
-    'CallQueryComponent',
+  'IfStatement',
+  'Match',
+  'SwitchStatement',
+  'ForEachStatement',
+  'WhileStatement',
+  // 'StringInterpolation',
+  'New',
+  'NewMap',
+  'NewList',
+  'NewComposite',
+  'Unparsed',
+  'CallFunction',
+  'CallLogic',
+  'CallInterface',
+  'CallConnector',
+  'CallAuthInterface',
+  'Assignment',
+  'BatchAssignment',
+  // 'CallConsoleLog',
+  'CallMessageShow',
+  'Destination',
+  'ExternalDestination',
+  'JSBlock',
+  // 'BinaryExpression',
+  // 'UnaryExpression',
+  // 'End',
+  // 'JSONSerialize',
+  // 'JSONDeserialize',
+  'SqlQueryComponent',
+  'OqlQueryComponent',
+  'CallQueryComponent',
 ];
 
 export const DEFAULT_ACTIVE_DEBUGGER = false;
@@ -79,6 +83,7 @@ export const TARGET_FRONTEND = 'Frontend';
 export const TARGET_BACKEND = 'Backend';
 
 export const EVENT_TYPE_PAGE_INFO = 'PAGE_INFO';
+export const EVENT_TYPE_RETURN_INFO = 'RETURN_INFO';
 export const EVENT_TYPE_OBJECT_INFO = 'OBJECT_INFO';
 
 export const EVENT_TYPE_SYNC_BREAKPOINTS = 'SYNC_BREAKPOINTS';
@@ -90,6 +95,7 @@ export const EVENT_TYPE_CACHE = 'CACHE';
 
 export const RESPONSE_TYPE_FRONTEND_INFO = 'FrontendInfo';
 export const RESPONSE_TYPE_OBJECT_INFO = 'ObjectInfo';
+export const RESPONSE_TYPE_RETURN_INFO = 'ReturnInfo';
 export const RESPONSE_TYPE_PAGE_INFO = 'PageInfo';
 export const RESPONSE_TYPE_DEBUG_INFO = 'DebugInfo';
 export const RESPONSE_TYPE_CONNECTION_INFO = 'ConnectionInfo';

package/src/breakpoint/shared/operations.ts

@@ -5,21 +5,21 @@ let updateCallback: Callback;
 let deleteCallback: Callback;
 
 const operators = {
-    create: (...args: any[]) => createCallback && createCallback(...args),
-    update: (...args: any[]) => updateCallback && updateCallback(...args),
-    delete: (...args: any[]) => deleteCallback && deleteCallback(...args),
+  create: (...args: any[]) => createCallback && createCallback(...args),
+  update: (...args: any[]) => updateCallback && updateCallback(...args),
+  delete: (...args: any[]) => deleteCallback && deleteCallback(...args),
 };
 
 export const setCreate = (callback: Callback) => {
-    createCallback = callback;
+  createCallback = callback;
 };
 
 export const setUpdate = (callback: Callback) => {
-    updateCallback = callback;
+  updateCallback = callback;
 };
 
 export const setDelete = (callback: Callback) => {
-    deleteCallback = callback;
+  deleteCallback = callback;
 };
 
 export default operators;