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

package/src/breakpoint/generator/BreakpointNode.ts

@@ -0,0 +1,228 @@
+import { BaseNode, Argument } from '../../concepts';
+
+import { getUniqueIdFromNode, getRealNode } from '../shared/utils';
+
+type Options = {
+    logic?: BaseNode;
+    variable?: BaseNode;
+}
+
+const MATCH_CONCEPT = 'Match';
+const MATCH_CASE_CONCEPT = 'MatchCase';
+const ASSIGNMENT_CONCEPT = 'Assignment';
+const CALL_LOGIC_CONCEPT = 'CallLogic';
+const WHILE_STATEMENT_CONCEPT = 'WhileStatement';
+
+const BEFORE_LOGIC_CONCEPTS = [
+    MATCH_CONCEPT,
+    'ForEachStatement',
+    'SwitchStatement',
+    'IfStatement',
+];
+
+const attribute = '[Symbol.for(\'breakpoint\')]';
+const parse = `(code) => eval(code)`;
+
+const callLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
+    const { _nodePath, logic, variable } = instance;
+    const node = logic || variable;
+
+    if (!node) {
+        return breaker;
+    }
+
+    const source = node as any;
+    const { concept, isViewLogic } = source;
+
+    if (concept !== CALL_LOGIC_CONCEPT) {
+        return;
+    }
+
+    const { arguments: args } = source;
+
+    const wrapper = <T extends Function>(callback: T) => {
+        if (isViewLogic) {
+            return callback();
+        }
+
+        const logic = source.getCallNode() || {};
+        const { params: logicParams } = logic;
+
+        const logicBase = logicParams || [];
+        logic.params = logicBase.concat({ name: attribute });
+
+        const result = callback();
+        logic.params = logicParams;
+
+        return result;
+    };
+
+    const breakpointExpression = new BreakpointNode();
+    const breakpointArgument = new Argument();
+    const base = args || [];
+
+    breakpointArgument.name = attribute;
+    breakpointArgument.expression = breakpointExpression as any;
+    breakpointExpression._nodePath = _nodePath;
+    source.arguments = base.concat(breakpointArgument);
+
+    const callback = () => source.toJS();
+    const code = wrapper(callback);
+    source.arguments = args;
+
+    return code;
+};
+
+const variableGenerator = (instance: BreakpointNode) => (breaker: string) => {
+    const { _nodePath, variable } = instance;
+
+    if (!variable) {
+        return;
+    }
+
+    const promise = (variable as any)?.toJS() || '';
+    return `await $breaker.generateBreakpoint('${_nodePath}', ${parse})(${promise})`;
+};
+
+const assignmentGenerator = (instance: BreakpointNode) => (breaker: string) => {
+    const { _nodePath, logic } = instance;
+
+    if (!logic) {
+        return;
+    }
+
+    const source = logic as any;
+    const { concept, right } = source;
+
+    if (concept !== ASSIGNMENT_CONCEPT) {
+        return;
+    }
+
+    const options = { variable: right };
+    const breakpointRight = new BreakpointNode(options);
+
+    breakpointRight._nodePath = _nodePath;
+    source.right = breakpointRight as any;
+
+    const code = source.toJS();
+    source.right = right;
+
+    return code;
+};
+
+const whileStatementGenerator = (instance: BreakpointNode) => (breaker: string) => {
+    const { _nodePath, logic } = instance;
+
+    if (!logic) {
+        return;
+    }
+
+    const source = logic as any;
+    const { concept, body = [] } = source;
+
+    if (concept !== WHILE_STATEMENT_CONCEPT) {
+        return;
+    }
+
+    const item = new BreakpointNode();
+    item._nodePath = _nodePath;
+    source.body = body.concat(item);
+
+    const code = source.toJS();
+    source.body = body;
+
+    return `${breaker}\n${code}`;
+};
+
+const matchCaseLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
+    const { _nodePath, logic } = instance;
+
+    if (!logic) {
+        return;
+    }
+
+    const source = logic as any;
+
+    const parentConcept = source?.parentNode?.concept;
+    const underMatch = parentConcept === MATCH_CASE_CONCEPT;
+
+    const ancestor = source.getAncestor(MATCH_CONCEPT) || {};
+    const { isExpression } = ancestor;
+
+    if (!underMatch || !isExpression) {
+        return;
+    }
+
+    const breakpoint = new BreakpointNode({ variable: source });
+    breakpoint._nodePath = _nodePath;
+
+    return breakpoint.toJS();
+};
+
+const logicGenerator = (instance: BreakpointNode) => (breaker: string) => {
+    const { logic } = instance;
+
+    if (!logic) {
+        return;
+    }
+
+    const promise = (logic as any)?.toJS() || '';
+    const { concept } = logic as any;
+
+    const shouldSetBefore = BEFORE_LOGIC_CONCEPTS.includes(concept);
+    const code = shouldSetBefore ? [breaker, promise] : [promise, breaker];
+
+    return code.join('\n');
+};
+
+// 不要更换顺序
+const generators = [
+    callLogicGenerator,
+    variableGenerator,
+    assignmentGenerator,
+    whileStatementGenerator,
+    matchCaseLogicGenerator,
+    logicGenerator,
+];
+
+export default class BreakpointNode extends BaseNode {
+    _nodePath: string = '';
+
+    variable: BaseNode = undefined;
+    logic: BaseNode = undefined;
+
+    constructor(options: Options = {}) {
+        super();
+        this.logic = options.logic;
+        this.variable = options.variable;
+
+        this.init();
+    }
+
+    init() {
+        const source = this.logic || this.variable;
+        const node = getRealNode(source);
+
+        if (!node) {
+            return;
+        }
+
+        this._nodePath = getUniqueIdFromNode(node);
+    }
+
+    toJS(): string {
+        const node = this.logic || this.variable;
+        const id = this._nodePath;
+        const breaker = id && `await $breaker.generateBreakpoint('${id}', ${parse})()`;
+
+        if (!node) {
+            return breaker;
+        }
+
+        const result = generators.reduce((result, generator) => {
+            return result || generator(this)(breaker);
+        }, '');
+
+        return result || breaker;
+    }
+}

package/src/breakpoint/generator/index.ts

@@ -0,0 +1,114 @@
+import { App, BaseNode } from '../../concepts';
+
+import { VARIABLE_KEYS, STACK_KEYS, NODE_KEYS } from '../shared/constants';
+import { isBreakable, getLogics } from '../shared/utils';
+
+import AfterStartNode from './AfterStartNode';
+import BeforeEndNode from './BeforeEndNode';
+import BreakpointNode from './BreakpointNode';
+
+const START_CONCEPT = 'Start';
+const END_CONCEPT = 'End';
+
+const addBreakpointNodes = (node: BaseNode | any) => {
+    if (!node) {
+        return;
+    }
+
+    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 removeBreakpointNodes = (node: BaseNode | any) => {
+    if (!node) {
+        return;
+    }
+
+    const getter = (value: BaseNode) => {
+        if (value instanceof BreakpointNode) {
+            value = value.variable || value.logic;
+        }
+
+        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);
+
+    logics.forEach(addBreakpointNodes);
+};
+
+export const clearBreakpoints = (app: App) => {
+    const logics = getLogics(app);
+
+    logics.forEach(removeBreakpointNodes);
+};
+
+export default genBreakpoints;

package/src/breakpoint/index.ts

@@ -0,0 +1,3 @@
+export * from './generator';
+export * from './shared';
+export * from './store';

package/src/breakpoint/shared/constants.ts

@@ -0,0 +1,95 @@
+export const VARIABLE_KEYS = [
+    'test',
+    'left',
+    'right',
+    'rights',
+    'patterns',
+    'arguments',
+    'expression',
+    'expressions',
+    'cases',
+    'each',
+    'end',
+    'start',
+];
+
+export const STACK_KEYS = [
+    'body',
+    'consequent',
+    'alternate',
+];
+
+export const NODE_KEYS = [
+    ...VARIABLE_KEYS,
+    ...STACK_KEYS,
+];
+
+export const TRAVERSE_NODE_KEYS = [
+    'playground',
+    ...NODE_KEYS,
+];
+
+export const BREAKPOINT_CONCEPTS = [
+    'IfStatement',
+    'Match',
+    'SwitchStatement',
+    'ForEachStatement',
+    'WhileStatement',
+    // 'StringInterpolation',
+    'New',
+    'NewMap',
+    'NewList',
+    'NewComposite',
+    'Unparsed',
+    'CallFunction',
+    'CallLogic',
+    'CallInterface',
+    'Assignment',
+    'BatchAssignment',
+    // 'CallConsoleLog',
+    'CallMessageShow',
+    'Destination',
+    'ExternalDestination',
+    'JSBlock',
+    // 'BinaryExpression',
+    // 'UnaryExpression',
+    // 'End',
+    // 'JSONSerialize',
+    // 'JSONDeserialize',
+    'SqlQueryComponent',
+    'OqlQueryComponent',
+    'CallQueryComponent',
+];
+
+export const EVENT_DISCONNECT = 'disconnect';
+export const EVENT_RECONNECT = 'reconnect';
+
+export const STATUS_ENABLED = 'ENABLED';
+export const STATUS_DELETED = 'DELETED';
+export const STATUS_DISABLED = 'DISABLED';
+
+export const TARGET_FRONTEND = 'Frontend';
+export const TARGET_BACKEND = 'Backend';
+
+export const EVENT_TYPE_PAGE_INFO = 'PAGE_INFO';
+export const EVENT_TYPE_OBJECT_INFO = 'OBJECT_INFO';
+
+export const EVENT_TYPE_SYNC_BREAKPOINTS = 'SYNC_BREAKPOINTS';
+export const EVENT_TYPE_BREAKPOINT = 'BREAKPOINT';
+export const EVENT_TYPE_STEP_OVER = 'STEP_OVER';
+export const EVENT_TYPE_RESOLVE = 'RESOLVE';
+export const EVENT_TYPE_PARSE = 'PARSE';
+export const EVENT_TYPE_CACHE = 'CACHE';
+
+export const RESPONSE_TYPE_FRONTEND_INFO = 'FrontendInfo';
+export const RESPONSE_TYPE_OBJECT_INFO = 'ObjectInfo';
+export const RESPONSE_TYPE_PAGE_INFO = 'PageInfo';
+export const RESPONSE_TYPE_DEBUG_INFO = 'DebugInfo';
+export const RESPONSE_TYPE_CONNECTION_INFO = 'ConnectionInfo';
+export const RESPONSE_TYPE_EXCEPTION_INFO = 'ExceptionInfo';
+
+export const CONNECTION_NAME_FRONTEND = 'Frontend';
+export const CONNECTION_NAME_BACKEND = 'Backend';
+
+export const CONNECTION_STATUS_CONNECTED = 'Connected';
+export const CONNECTION_STATUS_DISCONNECTED = 'Disconnected';

package/src/breakpoint/shared/index.ts

@@ -0,0 +1,3 @@
+export * as socket from './socket';
+export * from './constants';
+export * from './utils';

package/src/breakpoint/shared/operations.ts

@@ -0,0 +1,25 @@
+type Callback = (...args: any[]) => void;
+
+let createCallback: Callback;
+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),
+};
+
+export const setCreate = (callback: Callback) => {
+    createCallback = callback;
+};
+
+export const setUpdate = (callback: Callback) => {
+    updateCallback = callback;
+};
+
+export const setDelete = (callback: Callback) => {
+    deleteCallback = callback;
+};
+
+export default operators;