Can I observe database with second level deep relationships?

[StanyMiles]

Is there a way to observe database changes when I have second level relationships using GRDB? Or should I write my own SQL queries?

I have a Meal which has many MealIngredients each of them has one Ingredient
I would like to observe Meals with all deeper objects.

Here's my observation function:

func observeMealsFromDB() {
    observationCancellable = ValueObservation
      .tracking { db in
        try Meal
          .including(all: Meal.ingredients
            .including(required: MealIngredient.ingredient)
          )
          .asRequest(of: MealInfo.self)
          .fetchAll(db)
      }
      .publisher(in: databaseManager.dbQueue, scheduling: .immediate)
      .sink(
        receiveCompletion: { _ in /* ignore error */ },
        receiveValue: { [weak self] mealModels in
          self?.meals = mealModels.asMeals
        }
      )
}

struct MealInfo: Codable, FetchableRecord {
  var meal: Meal
  var ingredients: [MealIngredientInfo]
}

struct MealIngredientInfo: Codable, FetchableRecord {
  var mealIngredient: MealIngredient
  var ingredient: Ingredient
}

This is my schema with records:

func setupSchema() throws {
// unnecessary setup code is missing

      try db.create(table: "ingredient") { t in
        t.primaryKey("id", .text)
        t.column("name", .text)
          .notNull()
      }
      
      try db.create(table: "meal") { t in
        t.primaryKey("id", .text)
        t.column("name", .text)
          .notNull()
      }
 
      try db.create(table: "mealIngredient") { t in
        t.primaryKey("id", .text)
        t.column("amount", .double)
          .notNull()
        t.belongsTo("ingredient", onDelete: .cascade)
          .notNull()
        t.belongsTo("meal", onDelete: .cascade)
          .notNull()
      }
}

struct Ingredient: Codable, FetchableRecord, PersistableRecord {
  let id: String
  let name: String
}

struct Meal: Codable, FetchableRecord, PersistableRecord {
  let id: String
  let name: String  

  static let ingredients = hasMany(MealIngredient.self)
}

struct MealIngredient: Codable, FetchableRecord, PersistableRecord {
  var id: String
  var amount: Double
  var ingredientId: String
  var mealId: String

  static let ingredient = hasOne(Ingredient.self)
  static let meal = belongsTo(Meal.self)
}

[groue]

Hi @StanyMiles,

Yes, you can observe anything, with very few exceptions such as changes to the database schema itself.

If something does not behave as expected, please check the Why is ValueObservation not publishing value changes? FAQ, and report your findings!

[StanyMiles]

Thanks @groue! I've made my project work. What a nice library you have here! Love it!