• when the ready state is open call send on socket

• send data to the server

• Create a new document from OASDocument client - we will be sending the invocation of one of the methods form the document class

• when a user clicks the save button they can save their work

• yaml file will be saved and the state will update to reflect changes

• maybe have an indicator of a successful save

• After all of the nodes have been placed a user can click a button to download the code generated from the yaml file
• When the download button is clicked state data is saved to DB(later)
• Update state to refected the obj has been downloaded
• Code will be contained in a zip file(?) or whatever is easier

• New project started when app is opened
• new project is added to the state obj

• When a node is added to the canvas a user should be able to connect nodes with edges

react flow edges

• each newly generated edge should update the elements object with the correct data ie. the edge target should match the node id it is pointing to

• There should not be any hanging edges ie a user can only add an edge if there is a node to point it to

• check if the element is a node or an edge

• when a new project is created a user should see buttons to add nodes to the canvas

• when a node button is clicked a user can add which kind of node it is or there is a button for each kind of node(middleware, route etc)

• Each node should be added to the elements obj in state

• user should be able to click the node

• when the user clicks node the data should appear in the sidebar as JSON

The current implementation of oauth stores the access token in the local storage. This isn't secure and we need to refactor to use jwt, bcrypt, and create a session token with expiry which will be added to the authState.

Inbound requests from the client to authenticated server routes will need to check the authState on the client side before allowing the request.

I was thinking through our implementation on the Save feature and I think we can optimize the UX to make it a bit more intuitive.

Here's what I'm thinking:
We should persist the elements in local storage with a 'rigflo-project' key immediately on first render and update local storage every time the elements are updated.

This avoids the user having to actually click 'save' and us having to deal with dynamic key names.

On that initial render we can just check if the 'rigflo-project' key exists and if so we load those elements.

With this approach we can refactor the Save button to the Share functionality in the other ticket I made.

We can then take the modal markup from the Save button and implement into the Push to Github button so we can let the user name the repo we are going to create for them.

• Create a button that will open a modal/form that a user can add the info, version, title etc to YAML file

• A new project should be saved successfully - or move to another view(?)

• A user can delete a project by clicking a button

• The project will be removed from state and the YAML file data will be deleted

• maybe add a modal saying it was successfully deleted

• Node should be removed from state

• yaml file should update as well

https://reactjs.org/docs/context.html#reactcreatecontext

ServerNode
PathNode

if there is an error when connecting sub-nodes show an error message

when you drag a node it the coordinates should update in the json

• When a node is created a user can edit the information passed to that node (will this be a modal/ dropdown)

• Add button to edit details

• add button to save details

• state/yaml should update accordingly