@lcap/nasl 0.3.9 → 0.3.10-beta

package/src/types/logic/BreakPoint.ts

@@ -0,0 +1,200 @@
+const { io } = require('socket.io-client');
+import { immutable, circular } from '../decorators';
+import { Vertex, LogicItem, View, Logic, config } from '..';
+import { breakpointService } from '../../service/debugger/debugger';
+class BreakPoint extends Vertex {
+    // @immutable()
+    // public lineNumberEnd: number;
+    public appId: string;
+    public logicItemId: string;
+    public componentId: string;
+    public component: View;
+    public logic: Logic;
+    public remoteBreakpointId: string;
+    public isTemporary: boolean = false;
+    public target: string; // Frontend | Backend
+    public status: string; // enabled | disabled
+    public offset: number;
+
+    public lineNumberStart: number;
+    public classIdentify: string;
+
+    @circular()
+    public logicItem: LogicItem;
+
+    constructor(source?: Partial<BreakPoint>) {
+        super();
+        source && this.assign(source);
+    }
+
+    attachSourceMap(): boolean {
+        const offset = this.offset;
+        if (this.target === 'Frontend') {
+            const sourceMap = this.component.sourceMap;
+            const map = sourceMap[this.logicItemId];
+            if (map) {
+                const node = map.node;
+                if (node.type === 'JSBlock' && offset !== 0) {
+                    this.lineNumberStart = map.from + 1 + (offset || 0);
+                } else {
+                    this.lineNumberStart = map.from + (offset || 0);
+                }
+                return true;
+            }
+        }
+
+        if (this.target === 'Backend') {
+            const sourceMap = this.logic.sourceMap;
+            const map = sourceMap[this.logicItemId];
+            if (map) {
+                this.lineNumberStart = map.lineFrom + (offset || 0);
+                this.classIdentify = map.classIdentify;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    async create({
+        appId,
+        logicItem,
+        offset,
+    }: {
+        appId: string,
+        logicItem: LogicItem,
+        offset?: number,
+    }) {
+        const vertexId = logicItem.id;
+        let logicId: string;
+        const target = logicItem.logic && logicItem.logic.view ? 'Frontend' : 'Backend';
+        if (target === 'Backend') {
+            logicId = logicItem.logic && logicItem.logic.id;
+        }
+        if (target === 'Frontend') {
+            logicId = logicItem.logic && logicItem.logic.view.id;
+        }
+        await breakpointService.setBreakPoint({
+            body: {
+                appId,
+                vertexId,
+                logicId,
+                offset,
+                status: 'Enabled',
+                target,
+            },
+        });
+        this.assign({
+            appId,
+            logicItem,
+            logicItemId: logicItem.id,
+            target,
+            componentId: logicItem.logic && logicItem.logic.view && logicItem.logic.view.id,
+            component: logicItem.logic && logicItem.logic.view,
+            logic: logicItem.logic,
+            status: 'Enabled',
+            offset,
+        });
+    }
+    /**
+        await app.debuggerClient.removeRemoteBreakPoint(bp);
+        await bp.remove();
+
+     */
+    async remove() {
+        await breakpointService.removeBreakPoint({
+            query: {
+                appId: this.appId,
+                vertexId: this.logicItemId,
+                offset: this.offset,
+            },
+        });
+        this.removeOnLogicItem();
+    }
+
+    removeOnLogicItem() {
+        const index = this.logicItem.breakPoints.findIndex((p) => p === this);
+        ~index && this.logicItem.breakPoints.splice(index, 1);
+    }
+
+    async enable() {
+        await breakpointService.updateBreakPointState({
+            query: {
+                appId: this.appId,
+                vertexId: this.logicItemId,
+                offset: this.offset,
+                status: 'Enabled',
+            },
+        });
+        this.status = 'Enabled';
+        const app = config.defaultApp;
+        if (app.debuggerClient.isConnected) {
+            this.attachSourceMap();
+            app.debuggerClient.setRemoteBreakPointRoundTrip(this);
+        }
+    }
+    async disable() {
+        await breakpointService.updateBreakPointState({
+            query: {
+                appId: this.appId,
+                vertexId: this.logicItemId,
+                offset: this.offset,
+                status: 'Disabled',
+            },
+        });
+        this.status = 'Disabled';
+        const app = config.defaultApp;
+        if (app.debuggerClient.isConnected) {
+            app.debuggerClient.removeRemoteBreakPointRoundTrip(this);
+        }
+    }
+
+    static async from(bp: BreakpointMeta) :Promise<BreakPoint> {
+        const id = bp.vertexId;
+        let logicItem = Vertex.getVertexByRef(id) as LogicItem;
+        if (!logicItem) {
+            const logic = Vertex.getVertexByRef(bp.logicId) as Logic;
+            await logic.load();
+            logicItem = Vertex.getVertexByRef(id) as LogicItem;
+        }
+
+        const breakpoint = new BreakPoint({
+            appId: bp.appId,
+            logicItem,
+            logicItemId: id,
+            target: bp.target,
+            componentId: logicItem.logic && logicItem.logic.view && logicItem.logic.view.id,
+            component: logicItem.logic && logicItem.logic.view,
+            logic: logicItem.logic,
+            status: bp.status,
+            offset: bp.offset,
+        });
+        logicItem.addBreakPointInstance(breakpoint);
+        return breakpoint;
+    }
+    // get logicItem() {
+    //     if (this._logicItem) {
+    //         return this._logicItem;
+    //     }
+    //     this._logicItem = Vertex.getVertexByRef(this.logicId);
+    //     return this._logicItem;
+    // }
+
+    // setRemoteBreakPoint(socket: io) {
+    //     debugger
+    //     socket.emit('setbreakpoint', {
+    //         componentId: this.componentId,
+    //         line: this.lineNumberStart,
+    //         id: this.id,
+    //     });
+    // }
+}
+export interface BreakpointMeta {
+    appId: string,
+    vertexId: string,
+    logicId: string,
+    offset: number,
+    status: string,
+    target: string,
+} 
+
+export default BreakPoint;