Ramda js: obiektyw dla obiektów głęboko zagnieżdżonych z zagnieżdżonymi tablicami obiektów

Question

Korzystając z Ramda.js (i soczewek), chcę zmodyfikować obiekt JavaScript poniżej, aby zmienić "NAME: VERSION1" na "NAME: VERSION2" dla obiektu, który ma ID = "/ 1/B/i".

Chcę użyć soczewki, ponieważ chcę po prostu zmienić jedną głęboko zagnieżdżoną wartość, ale w przeciwnym razie zachować całą strukturę bez zmian.

Nie chcę używać lensIndex, ponieważ nigdy nie wiem, w jakiej kolejności są tablice, więc zamiast tego chcę "znaleźć" obiekt w tablicy, szukając jego pól "id".

Czy mogę to zrobić z soczewkami, czy powinienem zrobić to w inny sposób?

{ 
    "id": "/1", 
    "groups": [ 
    { 
     "id": "/1/A", 
     "apps": [ 
     { 
      "id": "/1/A/i", 
      "more nested data skipped to simplify the example": {} 
     } 
     ] 
    }, 
    { 
     "id": "/1/B", 
     "apps": [ 
     { "id": "/1/B/n", "container": {} }, 
     { 
      "id": "/1/B/i", 

      "container": { 
      "docker": { 
       "image": "NAME:VERSION1", 
       "otherStuff": {} 
      } 
      } 
     } 
     ] 
    } 

    ] 
} 

Answer 1

Powinno to być możliwe poprzez stworzenie soczewki, która pasuje do obiektu za pomocą identyfikatora, który może następnie zostać skomponowany z innymi soczewkami, aby przejść do pola obrazu.

Na początek możemy stworzyć soczewkę, która skupi się na elemencie tablicy, który pasuje do jakiegoś predykatu (uwaga: to będzie tylko prawidłowy obiektyw, jeśli zagwarantuje się dopasowanie co najmniej jednego elementu listy)

//:: (a -> Boolean) -> Lens [a] a 
const lensMatching = pred => (toF => entities => { 
    const index = R.findIndex(pred, entities); 
    return R.map(entity => R.update(index, entity, entities), 
       toF(entities[index])); 
}); 

Należy pamiętać, że jesteśmy ręcznie konstruowaniu obiektywu tutaj zamiast używać R.lens zapisać powielania znalezienie indeks elementu, który pasuje do predykat.

Po uzyskaniu tej funkcji możemy skonstruować soczewkę pasującą do danego identyfikatora.

//:: String -> Lens [{ id: String }] { id: String } 
const lensById = R.compose(lensMatching, R.propEq('id')) 

A potem możemy skomponować wszystkie soczewki razem kierować pola zdjęcia

const imageLens = R.compose(
    R.lensProp('groups'), 
    lensById('/1/B'), 
    R.lensProp('apps'), 
    lensById('/1/B/i'), 
    R.lensPath(['container', 'docker', 'image']) 
) 

które mogą być wykorzystane do aktualizacji obiektu data tak:

set(imageLens, 'NAME:VERSION2', data) 

można było potem wykonaj krok dalej, jeśli chcesz i zadeklaruj obiektyw, który koncentruje się na wersji ciągów obrazów.

const vLens = R.lens(
    R.compose(R.nth(1), R.split(':')), 
    (version, str) => R.replace(/:.*/, ':' + version, str) 
) 

set(vLens, 'v2', 'NAME:v1') // 'NAME:v2' 

ten może być następnie dołączony do składu imageLens kierować wersji w obrębie całego obiektu.

const verLens = compose(imageLens, vLens); 
set(verLens, 'VERSION2', data); 

Answer 2

Oto jedno rozwiązanie:

const updateDockerImageName = 
R.over(R.lensProp('groups'), 
     R.map(R.over(R.lensProp('apps'), 
        R.map(R.when(R.propEq('id', '/1/B/i'), 
           R.over(R.lensPath(['container', 'docker', 'image']), 
             R.replace(/^NAME:VERSION1$/, 'NAME:VERSION2'))))))); 

To może być rozłożona na mniejsze funkcje, oczywiście. :)