@eclipse-glsp-examples/workflow-server 0.9.0-next.5ce3b9a.1 → 0.9.0-next.82d6d28.20

package/src/graph-extension.ts

@@ -30,7 +30,7 @@ import { ModelTypes } from './util/model-types';
 export class ActivityNode extends GNode {
     nodeType: string;
 
-    static builder(): ActivityNodeBuilder {
+    static override builder(): ActivityNodeBuilder {
         return new ActivityNodeBuilder(ActivityNode);
     }
 }
@@ -48,7 +48,7 @@ export class TaskNode extends GNode {
     taskType: string;
     references: string;
 
-    static builder(): TaskNodeBuilder {
+    static override builder(): TaskNodeBuilder {
         return new TaskNodeBuilder(TaskNode).layout('vbox').addArgs(ArgsUtil.cornerRadius(5));
     }
 }
@@ -75,20 +75,12 @@ export class TaskNodeBuilder<T extends TaskNode = TaskNode> extends GNodeBuilder
     }
 
     children(): this {
-        this.proxy.children.push(this.createCompartment());
         return this;
     }
 
-    protected createCompartment(): GCompartment {
-        const layoutOptions: Args = {};
-        return new GCompartmentBuilder(GCompartment)
-            .type(ModelTypes.COMP_HEADER)
-            .id(this.proxy.id + '_header')
-            .layout('hbox')
-            .addLayoutOptions(layoutOptions)
-            .add(this.createCompartmentIcon())
-            .add(this.createCompartmentHeader())
-            .build();
+    override build(): T {
+        this.layout('hbox').addLayoutOption('paddingRight', 10).add(this.createCompartmentIcon()).add(this.createCompartmentHeader());
+        return super.build();
     }
 
     protected createCompartmentHeader(): GLabel {
@@ -100,20 +92,9 @@ export class TaskNodeBuilder<T extends TaskNode = TaskNode> extends GNodeBuilder
     }
 
     protected createCompartmentIcon(): GCompartment {
-        return new GCompartmentBuilder(GCompartment)
-            .type(ModelTypes.ICON)
+        return GCompartment.builder()
             .id(this.proxy.id + '_icon')
-            .layout('stack')
-            .addLayoutOptions({ hAlign: 'center', resizeContainer: false })
-            .add(this.createCompartmentIconLabel())
-            .build();
-    }
-
-    protected createCompartmentIconLabel(): GLabel {
-        return new GLabelBuilder(GLabel)
-            .type(ModelTypes.LABEL_ICON)
-            .id(this.proxy.id + '_ticon')
-            .text(`${this.proxy.taskType.toUpperCase().charAt(0)}`)
+            .type(ModelTypes.ICON)
             .build();
     }
 }
@@ -121,7 +102,7 @@ export class TaskNodeBuilder<T extends TaskNode = TaskNode> extends GNodeBuilder
 export class WeightedEdge extends GEdge {
     probability?: string;
 
-    static builder(): WeightedEdgeBuilder {
+    static override builder(): WeightedEdgeBuilder {
         return new WeightedEdgeBuilder(WeightedEdge).type(ModelTypes.WEIGHTED_EDGE);
     }
 }
@@ -136,7 +117,7 @@ export class WeightedEdgeBuilder<E extends WeightedEdge = WeightedEdge> extends
 export class Category extends ActivityNode {
     name: string;
 
-    static builder(): CategoryNodeBuilder {
+    static override builder(): CategoryNodeBuilder {
         return new CategoryNodeBuilder(Category)
             .layout('vbox')
             .addLayoutOptions({ hAlign: 'center', hGrab: false, vGrab: false })

package/src/handler/create-activity-node-handler.ts

@@ -13,21 +13,21 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point, Args, GNode, GModelState, ORIGIN_POINT } from '@eclipse-glsp/server-node';
-import { CreateWorkflowNodeOperationHandler } from './create-workflow-node-operation-handler';
+import { CreateNodeOperation, GNode, Point } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
 import { ActivityNode, ActivityNodeBuilder } from '../graph-extension';
 import { ModelTypes } from '../util/model-types';
+import { CreateWorkflowNodeOperationHandler } from './create-workflow-node-operation-handler';
 
 @injectable()
 export abstract class CreateActivityNodeHandler extends CreateWorkflowNodeOperationHandler {
-    createNode(relativeLocation: Point | undefined, args: Args | undefined): GNode | undefined {
-        return this.builder(relativeLocation, this.modelState).build();
+    createNode(operation: CreateNodeOperation, relativeLocation?: Point): GNode | undefined {
+        return this.builder(relativeLocation).build();
     }
 
-    protected builder(point: Point | undefined, modelState: GModelState): ActivityNodeBuilder {
+    protected builder(point: Point | undefined): ActivityNodeBuilder {
         return ActivityNode.builder()
-            .position(point ?? ORIGIN_POINT)
+            .position(point ?? Point.ORIGIN)
             .type(this.elementTypeIds[0])
             .nodeType(ModelTypes.toNodeType(this.elementTypeIds[0]));
     }

package/src/handler/create-automated-task-handler.ts

@@ -13,18 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ModelTypes } from '../util/model-types';
-import { CreateTaskHandler } from './create-task-handler';
+import { Point } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
-import { Point, GModelState } from '@eclipse-glsp/server-node';
 import { TaskNodeBuilder } from '../graph-extension';
+import { ModelTypes } from '../util/model-types';
+import { CreateTaskHandler } from './create-task-handler';
 
 @injectable()
 export class CreateAutomatedTaskHandler extends CreateTaskHandler {
     elementTypeIds = [ModelTypes.AUTOMATED_TASK];
     label = 'Automated Task';
 
-    protected builder(point: Point | undefined, modelState: GModelState): TaskNodeBuilder {
-        return super.builder(point, modelState).addCssClass('automated');
+    protected override builder(point: Point | undefined): TaskNodeBuilder {
+        return super.builder(point).addCssClass('automated');
     }
 }

package/src/handler/create-category-handler.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point, Args, GNode, GModelState, ORIGIN_POINT } from '@eclipse-glsp/server-node';
+import { ArgsUtil, CreateNodeOperation, GNode, Point } from '@eclipse-glsp/server-node';
 import { Category, CategoryNodeBuilder } from '../graph-extension';
 import { ModelTypes } from '../util/model-types';
 import { CreateWorkflowNodeOperationHandler } from './create-workflow-node-operation-handler';
@@ -22,15 +22,16 @@ export class CreateCategoryHandler extends CreateWorkflowNodeOperationHandler {
     elementTypeIds = [ModelTypes.CATEGORY];
     label = 'Category';
 
-    createNode(relativeLocation: Point | undefined, args: Args | undefined): GNode | undefined {
-        return this.builder(relativeLocation, this.modelState).build();
+    createNode(operation: CreateNodeOperation, relativeLocation?: Point): GNode | undefined {
+        return this.builder(relativeLocation).build();
     }
 
-    protected builder(point: Point | undefined, modelState: GModelState): CategoryNodeBuilder {
+    protected builder(point: Point | undefined): CategoryNodeBuilder {
         return Category.builder()
             .type(this.elementTypeIds[0])
-            .position(point ?? ORIGIN_POINT)
+            .position(point ?? Point.ORIGIN)
             .name(this.label.replace(' ', '') + this.modelState.index.getAllByClass(Category).length)
+            .addArgs(ArgsUtil.cornerRadius(5))
             .children();
     }
 }

package/src/handler/create-decision-node-handler.ts

@@ -13,18 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ModelTypes } from '../util/model-types';
+import { Point } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
-import { CreateActivityNodeHandler } from './create-activity-node-handler';
-import { GModelState, Point } from '@eclipse-glsp/server-node';
 import { ActivityNodeBuilder } from '../graph-extension';
+import { ModelTypes } from '../util/model-types';
+import { CreateActivityNodeHandler } from './create-activity-node-handler';
 
 @injectable()
 export class CreateDecisionNodeHandler extends CreateActivityNodeHandler {
     elementTypeIds = [ModelTypes.DECISION_NODE];
     label = 'Decision Node';
 
-    protected builder(point: Point | undefined, modelState: GModelState): ActivityNodeBuilder {
-        return super.builder(point, modelState).addCssClass('decision');
+    protected override builder(point?: Point): ActivityNodeBuilder {
+        return super.builder(point).addCssClass('decision');
     }
 }

package/src/handler/create-edge-handler.ts

@@ -13,13 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { CreateEdgeOperationHandler, DefaultTypes, GEdge, GEdgeBuilder, GModelElement, GModelState } from '@eclipse-glsp/server-node';
+import { DefaultTypes, GEdge, GEdgeBuilder, GModelCreateEdgeOperationHandler, GModelElement } from '@eclipse-glsp/server-node';
 
-export class CreateEdgeHandler extends CreateEdgeOperationHandler {
+export class CreateEdgeHandler extends GModelCreateEdgeOperationHandler {
     label = 'Edge';
     elementTypeIds = [DefaultTypes.EDGE];
 
-    createEdge(source: GModelElement, target: GModelElement, modelState: GModelState): GEdge | undefined {
+    createEdge(source: GModelElement, target: GModelElement): GEdge | undefined {
         return new GEdgeBuilder(GEdge).sourceId(source.id).targetId(target.id).build();
     }
 }

package/src/handler/create-fork-or-join-node-handler.ts

@@ -13,14 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point, GModelState } from '@eclipse-glsp/server-node';
-import { CreateActivityNodeHandler } from './create-activity-node-handler';
+import { Point } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
 import { ActivityNodeBuilder } from '../graph-extension';
+import { CreateActivityNodeHandler } from './create-activity-node-handler';
 
 @injectable()
 export abstract class CreateForkOrJoinNodeHandler extends CreateActivityNodeHandler {
-    protected builder(point: Point | undefined, modelState: GModelState): ActivityNodeBuilder {
-        return super.builder(point, modelState).addCssClass('forkOrJoin').size(10, 50);
+    protected override builder(point: Point | undefined): ActivityNodeBuilder {
+        return super.builder(point).addCssClass('forkOrJoin').size(10, 50);
     }
 }

package/src/handler/create-manual-task-handler.ts

@@ -13,18 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ModelTypes } from '../util/model-types';
-import { CreateTaskHandler } from './create-task-handler';
+import { Point } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
-import { Point, GModelState } from '@eclipse-glsp/server-node';
 import { TaskNodeBuilder } from '../graph-extension';
+import { ModelTypes } from '../util/model-types';
+import { CreateTaskHandler } from './create-task-handler';
 
 @injectable()
 export class CreateManualTaskHandler extends CreateTaskHandler {
     elementTypeIds = [ModelTypes.MANUAL_TASK];
     label = 'Manual Task';
 
-    protected builder(point: Point | undefined, modelState: GModelState): TaskNodeBuilder {
-        return super.builder(point, modelState).addCssClass('manual');
+    protected override builder(point: Point | undefined): TaskNodeBuilder {
+        return super.builder(point).addCssClass('manual');
     }
 }

package/src/handler/create-merge-node-handler.ts

@@ -13,18 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ModelTypes } from '../util/model-types';
+import { Point } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
-import { CreateActivityNodeHandler } from './create-activity-node-handler';
-import { GModelState, Point } from '@eclipse-glsp/server-node';
 import { ActivityNodeBuilder } from '../graph-extension';
+import { ModelTypes } from '../util/model-types';
+import { CreateActivityNodeHandler } from './create-activity-node-handler';
 
 @injectable()
 export class CreateMergeNodeHandler extends CreateActivityNodeHandler {
     elementTypeIds = [ModelTypes.MERGE_NODE];
     label = 'Merge Node';
 
-    protected builder(point: Point | undefined, modelState: GModelState): ActivityNodeBuilder {
-        return super.builder(point, modelState).addCssClass('merge');
+    protected override builder(point: Point | undefined): ActivityNodeBuilder {
+        return super.builder(point).addCssClass('merge');
     }
 }

package/src/handler/create-task-handler.ts

@@ -13,22 +13,22 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { CreateWorkflowNodeOperationHandler } from './create-workflow-node-operation-handler';
+import { Point } from '@eclipse-glsp/protocol';
+import { CreateNodeOperation, GNode } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
-import { Args, ORIGIN_POINT, Point } from '@eclipse-glsp/protocol';
-import { GModelState, GNode } from '@eclipse-glsp/server-node';
 import { TaskNode, TaskNodeBuilder } from '../graph-extension';
 import { ModelTypes } from '../util/model-types';
+import { CreateWorkflowNodeOperationHandler } from './create-workflow-node-operation-handler';
 
 @injectable()
 export abstract class CreateTaskHandler extends CreateWorkflowNodeOperationHandler {
-    createNode(relativeLocation: Point | undefined, args: Args | undefined): GNode | undefined {
-        return this.builder(relativeLocation, this.modelState).build();
+    createNode(operation: CreateNodeOperation, relativeLocation?: Point): GNode | undefined {
+        return this.builder(relativeLocation).build();
     }
 
-    protected builder(point: Point | undefined, modelState: GModelState): TaskNodeBuilder {
+    protected builder(point: Point | undefined): TaskNodeBuilder {
         return TaskNode.builder()
-            .position(point ?? ORIGIN_POINT)
+            .position(point ?? Point.ORIGIN)
             .addCssClass('task')
             .name(this.label.replace(' ', '') + this.modelState.index.getAllByClass(TaskNode).length)
             .type(this.elementTypeIds[0])

package/src/handler/create-weighted-edge-handler.ts

@@ -13,15 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { CreateEdgeOperationHandler, GEdge, GModelElement, GModelState } from '@eclipse-glsp/server-node';
+import { GEdge, GModelCreateEdgeOperationHandler, GModelElement } from '@eclipse-glsp/server-node';
 import { WeightedEdge } from '../graph-extension';
 import { ModelTypes } from '../util/model-types';
 
-export class CreateWeightedEdgeHandler extends CreateEdgeOperationHandler {
+export class CreateWeightedEdgeHandler extends GModelCreateEdgeOperationHandler {
     elementTypeIds = [ModelTypes.WEIGHTED_EDGE];
     label = 'Weighted edge';
 
-    createEdge(source: GModelElement, target: GModelElement, modelState: GModelState): GEdge | undefined {
+    createEdge(source: GModelElement, target: GModelElement): GEdge | undefined {
         return WeightedEdge.builder().sourceId(source.id).targetId(target.id).probability('medium').addCssClass('medium').build();
     }
 }

package/src/handler/create-workflow-node-operation-handler.ts

@@ -15,27 +15,27 @@
  ********************************************************************************/
 import {
     CreateNodeOperation,
-    CreateNodeOperationHandler,
     GCompartment,
+    GModelCreateNodeOperationHandler,
     GModelElement,
-    GModelState,
+    ModelState,
     Point
 } from '@eclipse-glsp/server-node';
-import { injectable, inject } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { Category } from '../graph-extension';
 import { ModelTypes } from '../util/model-types';
 import { GridSnapper } from './grid-snapper';
 
 @injectable()
-export abstract class CreateWorkflowNodeOperationHandler extends CreateNodeOperationHandler {
-    @inject(GModelState)
-    protected modelState: GModelState;
+export abstract class CreateWorkflowNodeOperationHandler extends GModelCreateNodeOperationHandler {
+    @inject(ModelState)
+    protected override modelState: ModelState;
 
-    getLocation(operation: CreateNodeOperation): Point | undefined {
+    override getLocation(operation: CreateNodeOperation): Point | undefined {
         return GridSnapper.snap(operation.location);
     }
 
-    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
+    override getContainer(operation: CreateNodeOperation): GModelElement | undefined {
         const container = super.getContainer(operation);
 
         if (container instanceof Category) {

package/src/labeledit/workflow-label-edit-validator.ts

@@ -13,14 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement, GModelState, LabelEditValidator, ValidationStatus } from '@eclipse-glsp/server-node';
+import { GModelElement, LabelEditValidator, ModelState, ValidationStatus } from '@eclipse-glsp/server-node';
 import { inject, injectable } from 'inversify';
 import { TaskNode } from '../graph-extension';
 
 @injectable()
 export class WorkflowLabelEditValidator implements LabelEditValidator {
-    @inject(GModelState)
-    protected modelState: GModelState;
+    @inject(ModelState)
+    protected modelState: ModelState;
 
     validate(label: string, element: GModelElement): ValidationStatus {
         if (label.length < 1) {

package/src/{workflow-model-index.ts → layout/workflow-layout-configurator.ts}

@@ -13,19 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GEdge, GModelIndex } from '@eclipse-glsp/server-node';
+import { AbstractLayoutConfigurator, LayoutOptions } from '@eclipse-glsp/layout-elk';
+import { GGraph } from '@eclipse-glsp/server-node';
 import { injectable } from 'inversify';
-import { ModelTypes } from './util/model-types';
 
 @injectable()
-export class WorkflowModelIndex extends GModelIndex {
-    getAllEdges(): GEdge[] {
-        const edges: GEdge[] = super.getAllEdges();
-        this.getElements(ModelTypes.WEIGHTED_EDGE).forEach(weighted => {
-            if (weighted instanceof GEdge) {
-                edges.push(weighted);
-            }
-        });
-        return edges;
+export class WorkflowLayoutConfigurator extends AbstractLayoutConfigurator {
+    protected override graphOptions(graph: GGraph): LayoutOptions | undefined {
+        return {
+            'elk.algorithm': 'layered'
+        };
     }
 }

package/src/marker/workflow-model-validator.ts

@@ -13,14 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement, Marker, ModelValidator, GModelState, MarkerKind, GCompartment, GLabel } from '@eclipse-glsp/server-node';
+import { GCompartment, GLabel, GModelElement, Marker, MarkerKind, ModelState, ModelValidator } from '@eclipse-glsp/server-node';
 import { inject, injectable } from 'inversify';
 import { ActivityNode, TaskNode } from '../graph-extension';
 
 @injectable()
 export class WorkflowModelValidator implements ModelValidator {
-    @inject(GModelState)
-    protected readonly modelState: GModelState;
+    @inject(ModelState)
+    protected readonly modelState: ModelState;
 
     validate(elements: GModelElement[]): Marker[] {
         const markers: Marker[] = [];

package/src/model/workflow-navigation-target-resolver.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { NavigationTarget } from '@eclipse-glsp/protocol';
-import { GModelState } from '@eclipse-glsp/server-node';
+import { ModelState } from '@eclipse-glsp/server-node';
 import { NavigationTargetResolution } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-resolution';
 import { NavigationTargetResolver } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-resolver';
 import { inject, injectable } from 'inversify';
@@ -22,8 +22,8 @@ import { TaskNode } from '../graph-extension';
 
 @injectable()
 export class WorkflowNavigationTargetResolver extends NavigationTargetResolver {
-    @inject(GModelState)
-    protected readonly modelState: GModelState;
+    @inject(ModelState)
+    protected readonly modelState: ModelState;
 
     async resolve(navigationTarget: NavigationTarget): Promise<NavigationTargetResolution> {
         if (navigationTarget.args && navigationTarget.args['name']) {

package/src/provider/abstract-next-or-previous-navigation-target-provider.ts

@@ -14,17 +14,17 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { Args, EditorContext, NavigationTarget } from '@eclipse-glsp/protocol';
+import { GEdge, ModelState } from '@eclipse-glsp/server-node';
 import { NavigationTargetProvider } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-provider';
 import { inject, injectable } from 'inversify';
-import { GEdge, GModelState } from '@eclipse-glsp/server-node';
 import { TaskNode } from '../graph-extension';
 
 @injectable()
 export abstract class AbstractNextOrPreviousNavigationTargetProvider implements NavigationTargetProvider {
     abstract targetTypeId: string;
 
-    @inject(GModelState)
-    protected readonly modelState: GModelState;
+    @inject(ModelState)
+    protected readonly modelState: ModelState;
 
     getTargets(editorContext: EditorContext): NavigationTarget[] {
         const sourceUri = this.modelState.sourceUri;

package/src/provider/node-documentation-navigation-target-provider.ts

@@ -14,18 +14,18 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { Args, EditorContext, NavigationTarget } from '@eclipse-glsp/protocol';
-import { GModelState } from '@eclipse-glsp/server-node';
+import { ModelState } from '@eclipse-glsp/server-node';
+import { JsonOpenerOptions } from '@eclipse-glsp/server-node/lib/features/navigation/json-opener-options';
 import { NavigationTargetProvider } from '@eclipse-glsp/server-node/lib/features/navigation/navigation-target-provider';
 import { inject, injectable } from 'inversify';
 import { TaskNode } from '../graph-extension';
-import { JsonOpenerOptions } from '@eclipse-glsp/server-node/lib/features/navigation/json-opener-options';
 
 @injectable()
 export class NodeDocumentationNavigationTargetProvider implements NavigationTargetProvider {
     targetTypeId = 'documentation';
 
-    @inject(GModelState)
-    protected readonly modelState: GModelState;
+    @inject(ModelState)
+    protected readonly modelState: ModelState;
 
     getTargets(editorContext: EditorContext): NavigationTarget[] {
         if (editorContext.selectedElementIds.length === 1) {

package/src/provider/workflow-command-palette-action-provider.ts

@@ -21,10 +21,9 @@ import {
     DefaultTypes,
     DeleteElementOperation,
     GModelElement,
-    GModelState,
     GNode,
     LabeledAction,
-    ORIGIN_POINT,
+    ModelState,
     Point
 } from '@eclipse-glsp/server-node';
 import { inject, injectable } from 'inversify';
@@ -33,8 +32,8 @@ import { ModelTypes } from '../util/model-types';
 
 @injectable()
 export class WorkflowCommandPaletteActionProvider extends CommandPaletteActionProvider {
-    @inject(GModelState)
-    protected modelState: GModelState;
+    @inject(ModelState)
+    protected override modelState: ModelState;
 
     getPaletteActions(selectedElementIds: string[], selectedElements: GModelElement[], position: Point, args?: Args): LabeledAction[] {
         const actions: LabeledAction[] = [];
@@ -43,28 +42,33 @@ export class WorkflowCommandPaletteActionProvider extends CommandPaletteActionPr
         }
         const index = this.modelState.index;
         // Create actions
+        const location = position ?? Point.ORIGIN;
         actions.push(
-            new LabeledAction(
-                'Create Automated Task',
-                [new CreateNodeOperation(ModelTypes.AUTOMATED_TASK, position ?? ORIGIN_POINT)],
-                'fa-plus-square'
-            ),
-            new LabeledAction(
-                'Create Manual Task',
-                [new CreateNodeOperation(ModelTypes.MANUAL_TASK, position ?? ORIGIN_POINT)],
-                'fa-plus-square'
-            ),
-            new LabeledAction(
-                'Create Merge Node',
-                [new CreateNodeOperation(ModelTypes.MERGE_NODE, position ?? ORIGIN_POINT)],
-                'fa-plus-square'
-            ),
-            new LabeledAction(
-                'Create Decision Node',
-                [new CreateNodeOperation(ModelTypes.DECISION_NODE, position ?? ORIGIN_POINT)],
-                'fa-plus-square'
-            ),
-            new LabeledAction('Create Category', [new CreateNodeOperation(ModelTypes.CATEGORY, position ?? ORIGIN_POINT)], 'fa-plus-square')
+            {
+                label: 'Create Automated Task',
+                actions: [CreateNodeOperation.create(ModelTypes.AUTOMATED_TASK, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Manual Task',
+                actions: [CreateNodeOperation.create(ModelTypes.MANUAL_TASK, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Merge Node',
+                actions: [CreateNodeOperation.create(ModelTypes.MERGE_NODE, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Decision Node',
+                actions: [CreateNodeOperation.create(ModelTypes.DECISION_NODE, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Category',
+                actions: [CreateNodeOperation.create(ModelTypes.CATEGORY, { location })],
+                icon: 'fa-plus-square'
+            }
         );
         // Create edge action between two nodes
         if (selectedElements.length === 1) {
@@ -89,16 +93,14 @@ export class WorkflowCommandPaletteActionProvider extends CommandPaletteActionPr
             }
         }
         // Delete action
-        if (selectedElements.length === 1) {
-            actions.push(new LabeledAction('Delete', [new DeleteElementOperation(selectedElementIds)], 'fa-minus-square'));
-        } else if (selectedElements.length > 1) {
-            actions.push(new LabeledAction('Delete All', [new DeleteElementOperation(selectedElementIds)], 'fa-minus-square'));
-        }
+
+        const label = selectedElementIds.length === 1 ? 'Delete' : 'Delete All';
+        actions.push({ label, actions: [DeleteElementOperation.create(selectedElementIds)], icon: 'fa-minus-square' });
 
         return actions;
     }
 
-    private createEdgeActions(source: GNode, targets: GNode[]): LabeledAction[] {
+    protected createEdgeActions(source: GNode, targets: GNode[]): LabeledAction[] {
         const actions: LabeledAction[] = [];
         targets.forEach(node => actions.push(this.createEdgeAction(`Create Edge to ${this.getLabel(node)}`, source, node)));
         targets.forEach(node =>
@@ -107,15 +109,31 @@ export class WorkflowCommandPaletteActionProvider extends CommandPaletteActionPr
         return actions;
     }
 
-    private createWeightedEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
-        return new LabeledAction(label, [new CreateEdgeOperation(ModelTypes.WEIGHTED_EDGE, source.id, node.id)], 'fa-plus-square');
+    protected createWeightedEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
+        return {
+            label,
+            actions: [
+                CreateEdgeOperation.create({
+                    elementTypeId: ModelTypes.WEIGHTED_EDGE,
+                    sourceElementId: source.id,
+                    targetElementId: node.id
+                })
+            ],
+            icon: 'fa-plus-square'
+        };
     }
 
-    private createEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
-        return new LabeledAction(label, [new CreateEdgeOperation(DefaultTypes.EDGE, source.id, node.id)], 'fa-plus-square');
+    protected createEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
+        return {
+            label,
+            actions: [
+                CreateEdgeOperation.create({ elementTypeId: DefaultTypes.EDGE, sourceElementId: source.id, targetElementId: node.id })
+            ],
+            icon: 'fa-plus-square'
+        };
     }
 
-    private getLabel(node: GNode): string {
+    protected getLabel(node: GNode): string {
         if (node instanceof TaskNode) {
             return node.name;
         }