Homelab, Linux, JS & ABAP (~˘▾˘)~

## [JavaScript] Itereate through array of nested objects and delete specific objects

```[
{
"NodeId": 1,
"HierarchyLevel": 1,
"type": "folder",
"nodes": [
{
"NodeId": 2,
"HierarchyLevel": 2,
"type": "folder",
"nodes": [
{
"NodeId": 3,
"HierarchyLevel": 3,
"type": "category"
}
]
},
{
"NodeId": 4,
"HierarchyLevel": 2,
"type": "category",
"nodes": [
{
"NodeId": 5,
"HierarchyLevel": 3,
"type": "file"
}
]
}
]
},
{
"NodeId": 6,
"HierarchyLevel": 1,
"type": "folder",
"nodes": [
{
"NodeId": 7,
"HierarchyLevel": 2,
"type": "category"
}
]
}
]
```

My task was to get rid of every Node which has no subnodes of type file at the last level of the hierachy. So for this example the result I needed was an array containing only the nodes 1,2,4,5.
Of course in reality the nested structure was way more complex. My approach was a recursive function which checks every element’s type and nodes length property and calls itself if there are any subnodes. Also it is recommended to loop backwards through the array while deleting from it.

```
const removeEmptyNodes = nodes => {
for (let i = nodes.length - 1; i > -1; i--) {
const n = nodes[i]
//call function recursive to go deeper through the nested structure
if (n.nodes) removeEmptyNodes(n.nodes)
//remove element if it's not a file and has no subnodes
if (n.type !== 'file' && (!n.nodes || n.nodes.length === 0)) nodes.splice(i, 1)
}
}

// nodes contains the array data from above
removeEmptyNodes(nodes)
```

## [JavaScript] Copy an array of objects to a new array without any object references

The user tim-montague posted a great overview on the different deep copy techniques on stackoverflow:

In my case I had an array of objects which I wanted to copy without reference, therefore I used the option in the middle.

```const copy = JSON.parse(JSON.stringify(myArray))

# Another way using ES6 Syntax
const copy = myArray.map(object => ({ ...object }))
```

## [nodejs] Parsing multipart/mixed response (containing a file stream)

Recently I had to consume an API which returned multipart/mixed data. A response looked like this:

```--Boundary_0000000000001
Content-Type: application/octet-stream
Content-Disposition: attachment; filename"test.pdf"

%PDF-1.7
%�������
1 0 obj
...
%%EOF

--Boundary_0000000000001
Content-Type: application/json

{"data":[]}
--Boundary_0000000000001--

```

There are some node packages for parsing multipart responses, but most can only handle multipart/formData and not multipart/mixed. The most recommended package for multipart/mixed is Dicer, but to be honest, I wasn’t sure how to use it properly. Therefore, I built my own parser. Luckily the user idbehold provided a function to parse a response string into a json object here. To get it working, I just had to change the regex expressions in the split function. The most important step is to convert the data from the arrayBuffer to a String in binary encoding before parsing.

Also, I wrote two helper functions. The first one to parse the boundary string from the Content-Type and the second one to parse the filename from the Content-Dispositon Header of your response.

```module.exports = new class multipartMixedParser {

parse(boundary, buffer) {
const body = buffer.toString('binary') //toString encodes to utf-8 as default, this would lead to corrupted pdf's
return body.split(boundary).reduce((parts, part) => {
if (part && part !== '--\r\n') {
console.log({ body })
parts.push({
body: body,
}, {})
})
}
return parts
}, [])
}

//example: multipart/mixed;boundary=Boundary_0000000000001 -> --Boundary_0000000000001
return '--' + contentType.split("=")[1].split(";")[0]
}

getFileNameFromContentDisposition(cd) {
//example: 'attachment; filename="example.pdf"' -> example.pdf
return cd.slice(
cd.indexOf('"') + 1,
cd.lastIndexOf('"')
)
}

}
```

And that’s how I’m calling the API and using the multipartMixedParser Class to parse the response. The API I was using is expecting a file as formData and is also returning a file (as part of the multipart/mixed response).
It’s important to get the buffer from the response. If you would use `response.getText()` it would convert the data to an utf-8 encoded string which will lead to corrupted files.

Please note, I’m using node-fetch. When using Axios, the response object will look different.

```const btoa = require('btoa')
const FormData = require('form-data')
const fetch = require('node-fetch')
const multipartMixedParser = require('./multipartMixedParser')

function callAPI(file) {

const form = new FormData()
form.append('file', file.content, {
contentType: file.mediaType,
filename: file.fileName
})

}

const url = /my/api/path

try {
const response = await fetch(url, {
method: 'POST',
body: form
})
if (!response.ok) throw new Error(response.statusText)

//parse the response
const buffer = await response.buffer()

const result = multipartMixedParser.parse(boundary, buffer)

// in my case I only returned the file content as buffer and filename
return {
fileContent: Buffer.from(result[0].body, 'binary'),