Map an array of objects in Firestore to an a dictionary array in swift

I think the issue is at the place where you cast the businessHours:

let businessHours = dictionary["businessHours"] as? Array<BusinessHours>

The actual data seems to be an array, but of the dictionaries, containing the hours, not the BusinessHours obejcts. That's why guard fails, Restaurant init returns nil and the code fails on unwrapping.

I've found a good implementation of more general dictionary serialization in this answer, and based on that created the code example that should work for you:

  /// A protocol to signify the types you need to be dictionaty codable
  protocol DictionaryCodable: Codable {
  }
  
  /// The extension that actually implements the bi-directional dictionary encoding
  /// via JSON serialization
  extension DictionaryCodable {
    /// Returns optional dictionary if the encoding succeeds
    var dictionary: [String: Any]? {
        guard let data = try? JSONEncoder().encode(self) else {
            return nil
        }
        return try? JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any]
    }
    /// Creates the instance of self decoded from the given dictionary, or nil on failure
    static func decode(from dictionary:[String:Any]) -> Self? {
        guard let data = try? JSONSerialization.data(withJSONObject: dictionary, options: .fragmentsAllowed) else {
            return nil
        }
        return try? JSONDecoder().decode(Self.self, from: data)
    }
  }
  
  // Your structs now have no special code to serialze or deserialize,
  // but only need to conform to DictionaryCodable protocol
  
  struct BusinessHours : DictionaryCodable {
      var selected : Bool
      var thisDay : String
      var startHour : Int
      var closeHour : Int
  }

  struct Restaurant: DictionaryCodable {
      var distance: Double
      var distributionType : Int
      var businessHours : [BusinessHours]
  }

  // This is the example of a Restaurant
  
  let r1 = Restaurant(distance: 0.1, distributionType: 1, businessHours: [
    BusinessHours(selected: false, thisDay: "Sun", startHour: 10, closeHour: 23),
    BusinessHours(selected: true, thisDay: "Mon", startHour: 11, closeHour: 18),
    BusinessHours(selected: true, thisDay: "Tue", startHour: 11, closeHour: 18),
  ])
  
  // This is how it can be serialized
  guard let dictionary = r1.dictionary else {
        print("Error encoding object")
        return
  }
  
  // Check the result
  print(dictionary)

  // This is how it can be deserialized directly to the object
  guard let r2 = Restaurant.decode(from: dictionary) else {
    print("Error decoding the object")
    return
  }
  
  // Check the result
  print(r2)

To avoid app crash on force unwraps (it's still better to show no results, than crash), I would recommend slightly changing the sequence of calls you use for data retrieval from the database:

db.whereField("users", arrayContains: userId).getDocuments() { documentSnapshot, error in
  guard nil == error else {
    // We can force unwrap the error here because it definitely exists
    completion([], error!.localizedDescription)
    return
  }

    // compactMap will get rid of improperly constructed Restaurant instances,
    // it will not get executed if documentSnapshot is nil
    // you only append non-nil Restaurant instances to the restaurantArray.
    // Worst case scenario you will end up with an unchanged restaurantArray.
    restaurantArray.append(contentsOf: documentSnapshot?.documents.compactMap { restaurantDocument in
        Restaurant.decode(from: restaurantDocument.data())
    } ?? [])
}