@itsmworkbench/dependentdata NPM

Dependent Data

This is a constant problem in guis

e.g.

I have a list of parameters
I have a list of tasks which is dependent on the parameters and one is selected
I have a list of services which is dependent on the tasks and the parameters and one is selected

Then

When I change the service it's no major impact
When I change the task I need to undefined the service and reload the allowed list
When I change the parameters I need to undefine the task and service and reload the allowed task

I really want this declarative! Because it's messy. And because I want to be able to do this multiple times in multiple projects

Now we have several aspects to consider problems

Expressing it
- How do we say 'what to do if it's changed
- How do we express equality?
Doing it

Expressing it

How do we express the relationship
How do we express equality

const paramsI = nameAndStringDI ( lensToParams ) // This told us how to calculate the hash and where the item is
const taskListI = stringArrayDI ( lensToTaskList )
const taskI = string ( lensToTask )
const serviceListI = stringArrayDI ( lensToServiceList )
const serviceI = string ( lensToTask )

dependent ( dis, taskListI, loadTaskList, paramsI ) //so nuke the value if the params change
dependent ( dis, taskI, nuke, taskListI,  paramsI )
dependent ( dis, serviceListI, nuke, taskI )
dependent ( dis, serviceI, loadServiceList, serviceListI ) //skipped the redundancy

Now that is very clean to express the dependencies

BUT!!!

how do we say the following
- the task list should be emptied if the params change, then the list loaded
- the service list should be emptied if the params or task change, then the list loaded
It seems there are multiple concerns
- What to do if it's changed 'nuke it' being the usual thing
- Do I have enough information to go and get the data?
- Should I go and get the data?
- Other consideration
  - It takes time to fetch data and we don't really want to fetch it twice.
  - It can 'go wrong' when we fetch it. how do we handle those errors

const paramsI = nameAndStringDI ( lensToParams ) // This told us how to calculate the hash and where the item is

function taskListI<S> () { // Can easily have helper methods to make this
  return {
    type: stringArray,
    optional: Optional<S, string[]>,
    dependentOn: paramsI,
    whenUpstreamChanges: 'nuke',
    load: loadTaskList
  }
}

function taskI<S> () {
  return {
    type: string,
    optional: Optional<S, string>,
    dependentOn: [ paramsI, taskListI ],
    whenUpstreamChanges: 'nuke',
    load: undefined
  }
}

function serviceListI<S> () {
  return {
    type: stringArray,
    optional: Optional<S, string[]>,
    dependentOn: [ paramsI, taskListI, taskI ],
    whenUpstreamChanges: 'nuke',
    load: loadServiceList
  }
}

function serviceI<S> () {
  return {
    type: string,
    optional: Optional<S, string>,
    dependentOn: [ serviceListI ],
    whenUpstreamChanges: 'nuke'
  }
}

With helper methods

const paramsI = nameAndStringDI ( lensToParams ) // This told us how to calculate the hash and where the item is
const taskListI = stringArrayDI ( lensToTaskList )
const taskI = string ( lensToTask )
const serviceListI = stringArrayDI ( lensToServiceList )
const serviceI = string ( lensToTask )

loadableDependent ( dis, taskListI, loadTaskList, paramsI ) //so nuke the value if the params change
dependent ( dis, taskI,  taskListI,  paramsI )
loadableDependent ( dis, serviceListI,  taskI )
dependent ( dis, serviceI, loadServiceList, serviceListI ) //skipped the redundancy

Doing it

For the doing it, I think I'll just have the idea of a hash and if the hash changes the value has changed. That hash might be an array of tags or a string...shouldn't really matter.

Clearly we need a dependency tree. Do we need to hierarchically sort it? Or do we just keep changing? Hierarchical sorting is inevitable I think if we have more projects... it allows checks earlier with nicer message. Probably don't need at first.