Pointer.fetch(includeKeys:....) doesn't include keys?

[project-saf]

Just wanted to check whether the below function is working as intended.

     /**
     Fetches the `ParseObject` *asynchronously* and executes the given callback block.
     - parameter includeKeys: The name(s) of the key(s) to include. Use `["*"]` to include
     all keys.
     - parameter options: A set of header options sent to the server. Defaults to an empty set.
     - parameter callbackQueue: The queue to return to after completion. Default
     value of .main.
     - parameter completion: The block to execute when completed.
     It should have the following argument signature: `(Result<T, ParseError>)`.
     - note: The default cache policy for this method is `.reloadIgnoringLocalCacheData`. If a developer
     desires a different policy, it should be inserted in `options`.
    */
    func fetch(includeKeys: [String]? = nil,
               options: API.Options = [],
               callbackQueue: DispatchQueue = .main,
               completion: @escaping (Result<T, ParseError>) -> Void) {
        Task {
            var options = options
            options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
            let path = API.Endpoint.object(className: className, objectId: objectId)
            await API.NonParseBodyCommand<NoBody, T>(method: .GET,
                                               path: path) { (data) -> T in
                try ParseCoding.jsonDecoder().decode(T.self, from: data)
            }.execute(options: options,
                      callbackQueue: callbackQueue,
                      completion: completion)
        }
    }

It looks like the parameter includeKeys is not actually being used in the function, and so isn't fetching the contents of any nested objects.

For example's sake, I have the following structs:

struct User: ParseObject {
    {...} // Other properties
    var metadata: Pointer<Metadata>?
}

struct Metadata: ParseObject {
    {...} // Other properties
    var school: School?
}

struct School: ParseObject {
    {...} // Other properties
    var name: String?
}

So I should be able to do the following:

let query = User.query("username" == "somePerson")
Task {
    guard let user = try? await query.first(),
          let meta = try? await user.metadata?.fetch(includeKeys: ["school"])
    else { return }
    let school = meta.school
    print(school?.name)
}

but unfortunately it shows up as nil
If I forcefully fetch (i.e. meta.school?.fetch()), it correctly prints out the school name.

[cbaker6]

Nice find! It looks like it was missed. Can you open a pull request with the fix? The code you highlighted needs “params” like

Parse-Swift/Sources/ParseSwift/API/API+Command.swift

Lines 496 to 504 in 5f2c5f4

	var params: [String: String]?
	if let includeParams = include {
	params = ["include": "\(Set(includeParams))"]
	}
	return API.Command<V, V>(
	method: .GET,
	path: object.endpoint,
	params: params

can you also add test cases here https://github.com/netreconlab/Parse-Swift/blob/main/Tests/ParseSwiftTests/ParsePointerTests.swift

[project-saf]

I've adjusted the code to account for it!
I'll be honest, I have no idea how to write tests (it's on my to-do list), so I'm a little out of my depth on that one. I'll have a play around to see if I can get the hang of it before I submit the PR

[project-saf]

Am struggling a little with the tests.

I can't add a property such as:

struct GameScore: ParseObject {
        //: These are required by ParseObject
        var objectId: String?
        var createdAt: Date?
        var updatedAt: Date?
        var ACL: ParseACL?
        var originalData: Data?

        //: Your own properties
        var points: Int
        var other: Pointer<GameScore>?
        var others: [Pointer<GameScore>]?
        var score: GameScore? <------NEW
        

        //: a custom initializer
        init() {
            self.points = 5
        }

        init(points: Int) {
            self.points = points
        }
    }

as this gives the error Value type 'ParsePointerTests.GameScore' cannot have a stored property that recursively contains it

But I also couldn't create a new struct like:

struct GameScore: ParseObject {
        //: These are required by ParseObject
        var objectId: String?
        var createdAt: Date?
        var updatedAt: Date?
        var ACL: ParseACL?
        var originalData: Data?

        //: Your own properties
        var points: Int
        var other: Pointer<GameScore>?
        var others: [Pointer<GameScore>]?
        var game: Game?
        

        //: a custom initializer
        init() {
            self.points = 5
        }

        init(points: Int) {
            self.points = points
        }
    }
    
    struct Game: ParseObject {
        //: These are required by ParseObject
        var objectId: String?
        var createdAt: Date?
        var updatedAt: Date?
        var ACL: ParseACL?
        var originalData: Data?
        
        //: Your own properties
        var points: Int
        

        //: a custom initializer
        init() {
            self.points = 5
        }

        init(points: Int) {
            self.points = points
        }
    }

as I get an error of

testIncludeKeysFetch(): failed - Should encode/decode. Error keyNotFound(CodingKeys(stringValue: "points", intValue: nil), Swift.DecodingError.Context(codingPath: [CodingKeys(stringValue: "game", intValue: nil)], debugDescription: "No value associated with key CodingKeys(stringValue: \"points\", intValue: nil) (\"points\").", underlyingError: nil))

I was trying to follow the same methodology as testFetch().
I will put a pause on this for the moment, but I'll submit the pull request for the fix; it just won't have the tests.

[project-saf]

#129

[cbaker6]

The problem:

as this gives the error Value type 'ParsePointerTests.GameScore' cannot have a stored property that recursively contains it

is answered here: #109 (comment)

[project-saf]

Yeah I thought as much, which is why I tried to adjust the struct to include Pointers, but then ran into other issues.
Hoping to get time to look into this more later in the year :)