GNodes vs GModel & setting state question

[csamarchi]

Hello,

Wanted to understand a few things more clearly. Working with the Node server and the VS Code extension. I am successfully loading and parsing our YAML file, building out the GNodes and then successfully setting the state, all in our storage.ts file:

My understanding is that we build the GNodes and set our model state in the storage.ts file. Our GModelFactory picks up the GNodes from the state and then builds the GModel, to which the client will read and take it from there.

My questions are:

1. Do I need to build the GNodes in the gmodel-factory.ts file? I noticed they are being built in your example here. Does it even matter?

2. Why are we setting state in the gmodel-factory.ts if we are setting state in storage?

3. What are these 2 lines doing in this function?

        const childNodes = taskList.tasks.map(task => this.createTaskNode(task));
        const newRoot= GGraph.builder().id(taskList.id).addChildren(childNodes).build();

Do I need these if I have already created the GNodes and set it to state in the above screenshot? ^

This is all due to the following error I keep getting:

11:27:01 AM error -  [WorkflowGLSPServer] Could not process action: 'requestModel Cannot read property 'revision' of undefined
            TypeError: Cannot read property 'revision' of undefined

Any help is much appreciated!

[tortmayr]

Hi @csamarchi,

My understanding is that we build the GNodes and set our model state in the storage.ts file. Our GModelFactory picks up the GNodes from the state and then builds the GModel, to which the client will read and take it from there.

The GmodelStorage (resp. the storage.ts file) is only responsible for loading the source model and storing it in the model state. It should not generate/build any graphical elements (like GNode). Generating the graphical model from the source model is entirely in the responsibility of the GModelFactory.

The task of the GModelStorage is loading the source model (in your case from a a .yaml file) and putting it into the model state so that other services (like the GModelFactory) can use it. If you have a look at the example ModelStorage, you can see that the loadSourceModel method just reads the task list (i.e. source) model from a file and stores it in the model state. No creation of any graphical elements should be happening here.

Looking at your code snippet it seems like solution is the the source model, and modules are graphical elements generated from this source model. Right? If so, than the storage.ts file you should just read the solution and store it in the model state. The generation/building of modules should be part of your GModelFactory.

Do I need to build the GNodes in the gmodel-factory.ts file? I noticed they are being built in your example here. Does it even matter?

Yes, as mentioned above the entire graphical model including GNodes should be created in the GModelFactory. The GModelFactory is invoked after each change of the source model and creates an updated graphical model which is then sent to the client. (see also https://www.eclipse.org/glsp/documentation/gmodel/#graphical-model-factory).

Why are we setting state in the gmodel-factory.ts if we are setting state in storage?

In the storage you are setting your source model (in your case solution. The GModelFactory on the other hand sets the graphical model that corresponds to your source model.

What are these 2 lines doing in this function?
const childNodes = taskList.tasks.map(task => this.createTaskNode(task));
const newRoot= GGraph.builder().id(taskList.id).addChildren(childNodes).build();

These two lines are responsible for generating the graphical model.
The map function on arrays can be used to transform all values of the input array. For instance your code

const inputArray: Model.Input[] = [];
module.inputs.forEach(input => {
    const input= Model.Input.builder().name(input.key).value(input.value).build();
    inputsArray.push(inputs);
}

would look like this with map syntax:

const inputArray= module.inputs.map(input=> Model.Input.builder().name(input.key).value(input.value).build());

The second line creates the new graphical model root (GGraph). In your case you would probably create your module gnodes here, build a new GGraph and then update the model state with modelState.updateRoot().