@eclipse-glsp/server 1.1.0-RC05

package/src/common/features/model/gmodel-index.ts

@@ -0,0 +1,195 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { GEdge, GModelElement, GModelElementConstructor, GModelRoot, GNode } from '@eclipse-glsp/graph';
+import { TypeGuard } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { getOrThrow, GLSPServerError } from '../../utils/glsp-server-error';
+
+/**
+ * Is used to index all child elements of a {@link GModelRoot} by their id. Offers a set
+ * of query methods to retrieve indexed elements.
+ */
+@injectable()
+export class GModelIndex {
+    protected idToElement: Map<string, GModelElement>;
+    protected typeToElements: Map<string, GModelElement[]>;
+
+    constructor() {
+        this.idToElement = new Map();
+        this.typeToElements = new Map();
+    }
+
+    clear(): void {
+        this.idToElement.clear();
+        this.typeToElements.clear();
+    }
+
+    indexRoot(root: GModelRoot): void {
+        this.clear();
+        this.doIndex(root);
+    }
+
+    protected doIndex(element: GModelElement): void {
+        if (this.idToElement.has(element.id)) {
+            throw new GLSPServerError('Duplicate ID in model: ' + element.id);
+        }
+        this.idToElement.set(element.id, element);
+        const typeSet = this.typeToElements.get(element.type) ?? [];
+        typeSet.push(element);
+        this.typeToElements.set(element.type, typeSet);
+        (element.children ?? []).forEach(child => {
+            this.doIndex(child);
+            // Double check wether the parent reference of the child is set correctly
+            if (!child.parent) {
+                child.parent = element;
+            }
+        });
+    }
+
+    find(elementId: string, predicate?: (test: GModelElement) => boolean): GModelElement | undefined {
+        const element = this.idToElement.get(elementId);
+        if (element && predicate ? predicate(element) : true) {
+            return element;
+        }
+        return undefined;
+    }
+
+    findByClass<G extends GModelElement>(elementTypeId: string, constructor: GModelElementConstructor<G>): G | undefined {
+        const element = this.find(elementTypeId);
+        if (element && element instanceof constructor) {
+            return element;
+        }
+        return undefined;
+    }
+
+    /**
+     * Returns an optional {@link GModelElement} by its elementId.
+     *
+     * @param elementId The id of the requested {@link GModelElement}.
+     * @returns An optional instance of the {@link GModelElement}.
+     */
+    get(elementId: string): GModelElement {
+        return getOrThrow(this.find(elementId), `Could not retrieve element with id: '${elementId}'`);
+    }
+
+    /**
+     * Returns a set of {@link GModelElement} instances by a Collection of elementIds.
+     *
+     * @param elementIds The ids to request the {@link GModelElement} from an array of elementIds.
+     * @returns A set of {@link GModelElement}s.
+     */
+    getAll(elementIds: string[]): GModelElement[] {
+        return elementIds.map(id => this.idToElement.get(id)).filter(element => element) as GModelElement[];
+    }
+
+    /**
+     * Returns all elements of the type constructor contained in the {@link GModelRoot}.
+     *
+     * @type Type of the elements to be returned.
+     * @param constructor The class of which the returned elements should be instances.
+     * @returns A set containing the elements of type constructor.
+     */
+    getAllByClass<G extends GModelElement>(constructor: GModelElementConstructor<G>): G[] {
+        return Array.from(this.idToElement.values()).filter(element => element instanceof constructor) as G[];
+    }
+
+    /**
+     * Returns a list of all {@link GModelElement} ids contained in this instance of the GModelIndex.
+     *
+     * @returns A list of elementIds.
+     */
+    allIds(): string[] {
+        return Array.from(this.idToElement.keys());
+    }
+
+    /**
+     * Returns all elements of a type {@link GModelRoot}.
+     *
+     * @param type   Type of the elements to be returned.
+     * @returns A set containing the elements of the given type.
+     */
+    getElements(type: string): GModelElement[] {
+        return this.typeToElements.get(type) ?? [];
+    }
+
+    /**
+     * Returns the current amount of type occurrences in this instance of the GModelIndex.
+     *
+     * @param eClass The EClass to be counted in this instance of the GModelIndex.
+     *
+     * @returns The amount of type occurrences.
+     */
+    typeCount(type: string): number {
+        return this.getElements(type).length;
+    }
+
+    /**
+     * Returns all incoming edges for a node.
+     *
+     * @param node The node where the edges are connected.
+     *
+     * @returns All incoming edges.
+     */
+    getIncomingEdges(node: GNode): GEdge[] {
+        return this.getAllEdges().filter(edge => edge.targetId === node.id);
+    }
+
+    /**
+     * Returns all outgoing edges for a node.
+     *
+     * @param node The node where the edges are connected.
+     *
+     * @returns All outgoing edges.
+     */
+    getOutgoingEdges(node: GModelElement): GEdge[] {
+        return this.getAllEdges().filter(edge => edge.sourceId === node.id);
+    }
+
+    /**
+     * Returns all edges in the index.
+     *
+     * @returns All edges in the index.
+     */
+    getAllEdges(): GEdge[] {
+        return this.getAllByClass(GEdge);
+    }
+
+    /**
+     * Returns the first element matching the given {@link TypeGuard} starting element with the
+     * given id and walking up the parent hierarchy.
+     *
+     * @param elementId The element to start the search from
+     * @param guard The typeguard which the element should match
+     * @return The first matching element or `undefined`.
+     */
+    findParentElement<T extends GModelElement>(elementId: string, guard: TypeGuard<T>): T | undefined {
+        const element = this.get(elementId);
+        return element ? this._findElement(element, guard) : undefined;
+    }
+
+    protected _findElement<T>(element: GModelElement, guard: TypeGuard<T>): T | undefined {
+        if (!element) {
+            return undefined;
+        }
+        if (guard(element)) {
+            return element;
+        }
+        if (element instanceof GModelRoot) {
+            return undefined;
+        }
+        return this._findElement(element.parent, guard);
+    }
+}

package/src/common/features/model/gmodel-serializer.spec.ts

@@ -0,0 +1,141 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { GEdge, getDefaultMapping, GGraph, GNode } from '@eclipse-glsp/graph';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import { DiagramConfiguration } from '../../diagram/diagram-configuration';
+import * as mock from '../../test/mock-util';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+import { Logger } from '../../utils/logger';
+import { DefaultGModelSerializer } from './gmodel-serializer';
+
+class TestNode extends GNode {
+    foo(): void {
+        // should not be serialized to schema
+    }
+}
+
+let testRootSchema: any;
+
+let testNodeSchema: any;
+
+let testNodeSchemaWithParent: any;
+
+describe('test DefaultGModelSerializer', () => {
+    const container = new Container();
+    const diagramConfiguration = new mock.StubDiagramConfiguration();
+    diagramConfiguration['typeMapping'] = getDefaultMapping();
+    diagramConfiguration.typeMapping.set('node', TestNode);
+
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new mock.StubLogger());
+            bind(DiagramConfiguration).toConstantValue(diagramConfiguration);
+        })
+    );
+
+    const serializer = container.resolve(DefaultGModelSerializer);
+
+    beforeEach(() => {
+        testRootSchema = {
+            id: 'graph',
+            type: 'graph',
+            children: [
+                { id: 'node1', type: 'node', position: { x: 5, y: 10 } },
+                { id: 'node2', type: 'node', position: { x: 15, y: 5 } },
+                { id: 'edge1', type: 'edge', sourceId: 'node1', targetId: 'node2' }
+            ]
+        };
+        testNodeSchema = { id: 'node1', type: 'node', position: { x: 5, y: 10 }, children: [], cssClasses: [] };
+        testNodeSchemaWithParent = {
+            id: 'node1',
+            type: 'node',
+            position: { x: 5, y: 10 },
+            children: [],
+            cssClasses: [],
+            parent: new GNode()
+        };
+    });
+
+    it('createElement - unregistered type', () => {
+        testNodeSchema['type'] = 'notRegistered';
+        expect(() => serializer.createElement(testNodeSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createElement - with root schema', () => {
+        expect(() => serializer.createElement(testRootSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createElement - with node schema', () => {
+        const node = serializer.createElement(testNodeSchema);
+        expect(node).to.be.an.instanceOf(TestNode);
+        expect(node).to.be.deep.include(testNodeSchema);
+        expect((node as TestNode).foo).to.not.be.undefined;
+    });
+
+    it('createElement- with sub type of registered schema', () => {
+        testNodeSchema.type = 'node:rectangular';
+        const node = serializer.createElement(testNodeSchema);
+        expect(node).to.be.an.instanceOf(TestNode);
+        expect(node).to.be.deep.include(testNodeSchema);
+        expect((node as TestNode).foo).to.not.be.undefined;
+    });
+
+    it('createElement - with parent', () => {
+        const parent = new GNode();
+        const child = serializer.createElement(testNodeSchema, parent);
+        expect(child).to.be.an.instanceOf(TestNode);
+        expect(child).to.be.deep.include(testNodeSchemaWithParent);
+        expect(child.parent).to.be.equal(parent);
+    });
+
+    it('createRoot - unregistered type', () => {
+        testRootSchema['type'] = 'notRegistered';
+        expect(() => serializer.createRoot(testNodeSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createRoot - with child schema ', () => {
+        expect(() => serializer.createRoot(testNodeSchema)).to.throw(GLSPServerError);
+    });
+
+    it('createRoot - with registered root schema', () => {
+        const root = serializer.createRoot(testRootSchema);
+        expect(root).to.be.an.instanceOf(GGraph);
+        expect(root.children.length).to.be.equal(3);
+        const node1 = root.children[0];
+        expect(node1).to.be.an.instanceOf(TestNode);
+        const node2 = root.children[1];
+        expect(node2).to.be.an.instanceOf(TestNode);
+        expect(root.children[2]).to.be.an.instanceOf(GEdge);
+        const edge = root.children[2] as GEdge;
+        expect(edge.sourceId).to.be.equal(node1.id);
+        expect(edge.targetId).to.be.equal(node2.id);
+    });
+
+    it('createSchema- unregistered type', () => {
+        expect(() => serializer.createRoot({ id: 'id', type: 'unregistered' })).to.throw(GLSPServerError);
+    });
+
+    it('createSchema- with node', () => {
+        const testNode = new TestNode();
+        testNode.position = { x: 5, y: 10 };
+        testNode.size = { width: 10, height: 100 };
+        testNode.layoutOptions = { ['my']: 'Options' };
+        const schema = serializer.createSchema(testNode);
+        delete (testNode as Partial<TestNode>).foo;
+        expect(schema).to.be.deep.include(testNode);
+    });
+});

package/src/common/features/model/gmodel-serializer.ts

@@ -0,0 +1,175 @@
+/********************************************************************************
+ * Copyright (c) 2017-2023 TypeFox and other
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+/* Derived from sprotty (https://github.com/eclipse/sprotty/blob/master/packages/sprotty/src/base/model/smodel-factory.ts) */
+import { GModelElement, GModelElementConstructor, GModelElementSchema, GModelRoot, GModelRootSchema } from '@eclipse-glsp/graph';
+import { SModelElementSchema, SModelRootSchema } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { DiagramConfiguration } from '../../diagram/diagram-configuration';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+
+export const GModelSerializer = Symbol('GModelSerializer');
+
+/**
+ * The `GModelSerializer` is used to transform a graphical model received as serializable JSON schema into the ES6-class based
+ * model representation and vice versa. It has to be invoked for whenever a graphical model is received in JSON format
+ * (i.e. by the GLSP client) to derive the corresponding class based model which is used internally by the GLSP server. In addition,
+ * it has to be invoked before the graphical model is sent based to the client. This is necessary to resolve the parent-child cycles
+ * inside of the graphical model which ensures that the model is serializable.
+ */
+export interface GModelSerializer {
+    /**
+     * Transform the given {@link GModelRootSchema} into its {@link GModelRoot} representation.
+     * @throws An error if the received element cannot be transformed into a {@link GModelRoot}.
+     * @param schema The root schema that should be transformed.
+     * @returns The transformed {@link GModelRoot}.
+     */
+    createRoot(schema: GModelRootSchema): GModelRoot;
+
+    /**
+     * Transform the given {@link GModelRootSchema} into its {@link GModelElement} representation.
+     * @throws An error if the received element cannot be transformed into a {@link GModelElement}.
+     * @param schema The element schema that should be transformed.
+     * @returns The transformed {@link GModelElement}.
+     */
+    createElement(schema: GModelElementSchema, parent?: GModelElement): GModelElement;
+
+    /**
+     * Transforms the given {@link GModelElement} into its serializable {@link GModelElementSchema} representation.
+     * @param element The element that should be serialized.
+     * @returns The transformed {@link GModelElementSchema}.
+     */
+    createSchema(element: GModelElement): GModelElementSchema;
+
+    /**
+     * The set of reserved property keys that should be excluded from serialization. Typically
+     * this set contains at least the `children` and `parent` keys to avoid parent-child cycles.
+     */
+    reservedKeys: string[];
+}
+
+@injectable()
+export class DefaultGModelSerializer implements GModelSerializer {
+    @inject(DiagramConfiguration) protected diagramConfiguration: DiagramConfiguration;
+
+    reservedKeys = ['children', 'parent', 'index', 'source', 'target'];
+    createRoot(schema: SModelElementSchema): GModelRoot {
+        const constructor = this.getConfiguredConstructor(schema);
+        if (constructor) {
+            const element = new constructor();
+            if (!(element instanceof GModelRoot)) {
+                throw new GLSPServerError(`Element with type '${schema.type}' is expected to be a GModelRoot!`);
+            }
+            return this.initializeRoot(element, schema);
+        }
+        throw new GLSPServerError(`No constructor is configured in DiagramConfiguration for type ${schema.type}`);
+    }
+
+    getConfiguredConstructor(schema: SModelElementSchema): GModelElementConstructor | undefined {
+        let key = schema.type;
+        while (!this.diagramConfiguration.typeMapping.has(key)) {
+            const i = key.lastIndexOf(':');
+            if (i > 0) {
+                key = key.substring(0, i);
+            } else {
+                return undefined;
+            }
+        }
+
+        const constructor = this.diagramConfiguration.typeMapping.get(key)!;
+        if (key !== schema.type) {
+            this.diagramConfiguration.typeMapping.set(key, constructor);
+        }
+        return constructor;
+    }
+
+    createElement(schema: SModelElementSchema, parent?: GModelElement): GModelElement {
+        const constructor = this.getConfiguredConstructor(schema);
+        if (constructor) {
+            const element = new constructor();
+            if (element instanceof GModelRoot) {
+                throw new GLSPServerError(
+                    `Element with type '${schema.type}' is a GModelRoot! 'createElement()' is expected to only create child elements!`
+                );
+            }
+            return this.initializeChild(element, schema, parent);
+        }
+        throw new GLSPServerError(`No constructor is configured in DiagramConfiguration for type ${schema.type}`);
+    }
+
+    createSchema(element: GModelElement): SModelElementSchema {
+        const schema = {};
+        for (const key in element) {
+            if (!this.isReserved(element, key)) {
+                const value: any = (element as any)[key];
+                if (typeof value !== 'function') {
+                    (schema as any)[key] = value;
+                }
+            }
+        }
+        (schema as any)['children'] = (element.children ?? []).map(child => this.createSchema(child));
+
+        return schema as SModelElementSchema;
+    }
+
+    protected initializeRoot(root: GModelRoot, schema: SModelRootSchema): GModelRoot {
+        this.initializeParent(root, schema);
+        return root;
+    }
+
+    protected initializeElement(element: GModelElement, schema: SModelElementSchema): GModelElement {
+        for (const key in schema) {
+            if (!this.isReserved(element, key)) {
+                const value = (schema as any)[key];
+                if (typeof value !== 'function') {
+                    (element as any)[key] = value;
+                }
+            }
+        }
+        return element;
+    }
+
+    protected initializeChild(child: GModelElement, schema: SModelElementSchema, parent?: GModelElement): GModelElement {
+        this.initializeParent(child, schema);
+        if (parent) {
+            child.parent = parent;
+        }
+        return child;
+    }
+
+    protected initializeParent(parent: GModelElement, schema: SModelElementSchema): GModelElement {
+        this.initializeElement(parent, schema);
+        if (schema.children) {
+            parent.children = schema.children.map(childSchema => this.createElement(childSchema, parent));
+        }
+
+        return parent;
+    }
+
+    protected isReserved(element: GModelElement, propertyName: string): boolean {
+        if (this.reservedKeys.indexOf(propertyName) >= 0) {
+            return true;
+        }
+        let obj = element;
+        do {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, propertyName);
+            if (descriptor !== undefined) {
+                return descriptor.get !== undefined;
+            }
+            obj = Object.getPrototypeOf(obj);
+        } while (obj);
+        return false;
+    }
+}

package/src/common/features/model/model-state.ts

@@ -0,0 +1,98 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { GModelRoot } from '@eclipse-glsp/graph';
+import { EditMode } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ClientId } from '../../di/service-identifiers';
+import { GModelIndex } from './gmodel-index';
+import { GModelSerializer } from './gmodel-serializer';
+
+export const ModelState = Symbol('ModelState');
+
+export interface ModelState {
+    set<P>(key: string, property: P): void;
+    setAll(properties: Record<string, unknown>): void;
+    get<P>(key: string, guard?: (object: unknown) => object is P): P | undefined;
+    clear(key: string): void;
+    readonly root: GModelRoot;
+    updateRoot(newRoot: GModelRoot): void;
+    editMode: string;
+    sourceUri?: string;
+    clientId: string;
+    readonly isReadonly: boolean;
+    readonly index: GModelIndex;
+}
+
+export const SOURCE_URI_ARG = 'sourceUri';
+
+@injectable()
+export class DefaultModelState implements ModelState {
+    @inject(GModelIndex)
+    readonly index: GModelIndex;
+
+    @inject(GModelSerializer)
+    protected serializer: GModelSerializer;
+
+    @inject(ClientId)
+    readonly clientId: string;
+
+    protected properties = new Map<string, any>();
+
+    protected _root: GModelRoot;
+
+    editMode = EditMode.EDITABLE;
+
+    set<P>(key: string, property: P): void {
+        this.properties.set(key, property);
+    }
+
+    setAll(properties: Record<string, unknown>): void {
+        Object.keys(properties).forEach(key => this.properties.set(key, properties[key]));
+    }
+
+    get<P>(key: string, guard?: (object: unknown) => object is P): P | undefined {
+        const result = this.properties.get(key);
+        if (!guard) {
+            return result as P;
+        }
+        return guard(result) ? result : undefined;
+    }
+
+    get sourceUri(): string | undefined {
+        return this.get(SOURCE_URI_ARG);
+    }
+
+    clear(key: string): void {
+        this.properties.delete(key);
+    }
+
+    get isReadonly(): boolean {
+        return this.editMode === EditMode.READONLY;
+    }
+
+    public get root(): GModelRoot {
+        return this._root;
+    }
+
+    protected set root(root: GModelRoot) {
+        this._root = root;
+    }
+
+    updateRoot(newRoot: GModelRoot): void {
+        this.root = newRoot;
+        this.index.indexRoot(newRoot);
+    }
+}