using decodable to capture array of nested objects in single line

I managed to find a solution for your problem.

Considering following is sample json

let jsonString = """
{
     "name": "xxxx",
     "title": "xxxxxxx",
     "assets": [
        {
          "items": [
            {
              "id": "id11",
              "desc": "desc11"
            },            {
              "id": "id12",
            },            {
              "desc": "desc13"
            }]
        },{
          "items": [
            {
              "id": "id21",
              "desc": "desc21"
            },            {
              "id": "id22",
            },            {
              "desc": "desc23"
            }]
        }]
}
"""

Your structures will look as below

struct Media: Codable {
    let id,desc: String?
    enum CodingKeys: String, CodingKey {
        case id,desc
    }
}

struct Response: Decodable {
    let name,title: String?
    let items: [Media]?
    enum CodingKeys: String, CodingKey {
        case name,title,items
        case assets = "assets"
    }
    // Decoding
    init(from decoder: Decoder) throws {

        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decode(String.self, forKey: .name)
        title = try container.decode(String.self, forKey: .title)

        // Here as the assets contains array of object which has a key as items and then again consist of a array of Media we need to decode as below
        let assets = try container.decode([[String:[Media]]].self, forKey: .assets)

        // At this stage will get assets with a array of array so we first map and retrive the items and then reduce them to one single array
        items = assets.compactMap{$0[CodingKeys.items.rawValue]}.reduce([], +)
    }
}

At the end it's time to use it as follows

let data = jsonString.data(using: .utf8)!
let myResponse = try! JSONDecoder().decode(Response.self, from: data)

Now you can access the data as below

myResponse.name
myResponse.title
myResponse.items

Hope this basic code helps you to achieve what you want to do. And then you can go ahead and do more nested parsing(s).

I would like to thanks Nic Laughter for such a detailed article; by referring which I managed to come with above solution.

You can try this:

struct Response: Decodable {
  let name, title: String
  let assets: [Assets]
}

struct Assets: Decodable {
 let items: [Items]
}

struct Items: Decodable {
  let id, desc: String
}

Then you can just decode it like this:

guard let response = try? JSONDecoder().decode(Response.self, from: data) else { print("Response not parsed"); return }