How to chain .including to eagerly load a three level hierarchy?

[tahic-himzo]

Hey folks! I have the following models that are in a relationship of:

1 Program has x Routines
1 Routine has y Sessions
1 Session has z Sets

I want to load the entire Program eagerly into the following model:

struct FullProgram: Decodable, FetchableRecord {
    var program: Program
    var routines: [FullRoutine]
}

struct FullRoutine: Decodable, FetchableRecord {
    var routine: Routine
    var sessions: [FullSession]
}

struct FullSession: Decodable, FetchableRecord {
    var session: ProgrammedSession
    var sets: [ProgrammedSet]
}

These are my record types:

Program:

struct Program: Identifiable, Hashable, Equatable, Codable, FetchableRecord, MutablePersistableRecord {
    var id: String
    [...]

    static let routines = hasMany(Routine.self)
    var routines: QueryInterfaceRequest<Routine> { request(for: Program.routines) }

Routine:

struct Routine: Identifiable, Equatable, Codable, FetchableRecord, MutablePersistableRecord {
    var id: String
    var programId: String
    [...]
    
    static let program = belongsTo(Program.self)
    var program: QueryInterfaceRequest<Program> { request(for: Routine.program) }
    
    static let sessions = hasMany(ProgrammedSession.self)
    var sessions: QueryInterfaceRequest<ProgrammedSession> { request(for: Routine.sessions) }

ProgrammedSession:

struct ProgrammedSession: Identifiable, Equatable, Codable, FetchableRecord, MutablePersistableRecord {
    var id: String
    [...]
    var routineId: String
    
    static let routine = belongsTo(Routine.self)
    var routine: QueryInterfaceRequest<Routine> { request(for: ProgrammedSession.routine) }

    static let sets = hasMany(ProgrammedSet.self)
    var sets: QueryInterfaceRequest<ProgrammedSet> { request(for: ProgrammedSession.sets) }

ProgrammedSet:

struct ProgrammedSet: Identifiable, Equatable, Codable, FetchableRecord, MutablePersistableRecord{
    var id: String
    var programmedSessionId: String
    [...]
    
    static let session = belongsTo(ProgrammedSession.self)
    var session: QueryInterfaceRequest<ProgrammedSession> { request(for: ProgrammedSet.session) }

What i have is:

Program
  .filter(id: programId)
  .including(all: Program.routines.including(all: Routine.sessions.including(all: ProgrammedSession.sets)))
  .asRequest(of: FullProgram.self)
  .fetchOne(db)

But i get the following error:

Swift.DecodingError.keyNotFound(CodingKeys(stringValue: "sessions", intValue: nil), 
Swift.DecodingError.Context(codingPath: [], debugDescription: "No such key: routine or sessions", underlyingError: nil))

It works well if I only load one level, like this:

struct FullProgram: Decodable, FetchableRecord {
    var program: Program
    var routines: [Routine]
}

[...]
Program
  .filter(id: programId)
  .including(all: Program.routines)
  .asRequest(of: FullProgram.self)
  .fetchOne(db)

I am doing this so I can create an editable user copy of a read-only template program, so I want to create a copy of the entire hierarchy with new IDs and some minor modifications, like changing some enum values. I know I can also just load them in multiple steps, but I would like to do it one go for the sake of simplicity. Loading them in multiple steps is my Plan B if I can't sort this issue out.

Can anyone help? I sadly couldn't find a related thread through the search!
If there is a better way to solve the problem I'm facing, please let me know 🙏

Thanks in advance!

[tahic-himzo]

Solved the problem from a different angle by going for a request model of

struct FullProgrammedSet: Decodable, FetchableRecord {
    var programmedSet: ProgrammedSet
    var programmedSession: ProgrammedSession
    var programmedProgression: ProgrammedProgression
    var routine: Routine
}

and this query:

try! appDatabase.reader.read { db in
  try! ProgrammedSet
      .including(required: ProgrammedSet.session
          .including(required: ProgrammedSession.routine)
          .including(required: ProgrammedSession.programmedProgression)
      )
      .asRequest(of: FullProgrammedSet.self)
      .fetchOne(db)
}