only objectId is being sent out?

[jaysonng]

Was there a change in the last update of the server that only sends out the objectId of the object instead of the whole object?

my previous xcode tests where I received the whole object now only returns the objectId of the object and everything else is nil.

I'm trying to figure out if I made a mistake somewhere when I was working with Codable but seems like all my structs are affected.

Am I now only receiving a Pointer to the object I need even though I did all the preprocessing server side?

Test ({"objectId":"yMzqHQwyhB"})
  - originalData: nil
  ▿ objectId: Optional("yMzqHQwyhB")
    - some: "yMzqHQwyhB"
  - createdAt: nil
  - updatedAt: nil
  - ACL: nil
  - name: nil
  - test1: nil

sample CloudCode result dump.

from what I gather, the server is only spitting out Pointers at this from ParseHookResponse even if I feed it a whole object.

[jaysonng]

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encodeIfPresent(objectId, forKey: .objectId)
        try container.encodeIfPresent(createdAt, forKey: .createdAt)
        try container.encodeIfPresent(updatedAt, forKey: .updatedAt)
        try container.encodeIfPresent(ACL, forKey: .ACL)
        try container.encodeIfPresent(name, forKey: .name)
        print("ENCODE TEST - name:", name ?? "nil")
    }
    

▿ ENCODE TEST - name: jayson2

encode works well, I can see on debug that my custom encode is being run and being passed to ParseHookResponse.

but somewhere between that and me receiving the response in my xcode unit test, it becomes a pointer. 

[jaysonng]

is it default behavior for Parse-Server-Swift to send out only Pointer objects? I've confirmed that I do only get points on the client side

Optional("{\"result\":{\"__type\":\"Pointer\",\"className\":\"Test\",\"objectId\":\"yMzqHQwyhB\"}}")
  - some: "{\"result\":{\"__type\":\"Pointer\",\"className\":\"Test\",\"objectId\":\"yMzqHQwyhB\"}}"

[cbaker6]

I'm not sure I understand the context of your problem, maybe parse-community/parse-server#8646 and the encodeParseObjectInCloudFunction option has something to do with it? This change was released in server 6.4.0

[jaysonng]

thanks for that.

Can you suggest to me some options I can look into to get a whole object back from Parse-Server-Swift?

[cbaker6]

I still don’t understand the problem you are running into and what you are trying to accomplish. You can look into changing the encoder as I mentioned before here: #65 (comment). Maybe this PR is what cause your problem: #71

[jaysonng]

so this time around i'm still working with cloudcode but I'm now sending out data from Parse-Server-Swift and only getting a Pointer - again, because any full queried object I pass into ParseHookResponse(success:) is converted to a Pointer.

So basically the simplest query I do, calling a query on an object like so -

/// Get  object by Id
    /// - Parameter objectId: Required: objectId (String) of the Object.
    ///
    /// - Returns: Found object.
    internal func getTById<T, P>(req: Request, paramsType: P.Type) async throws -> ParseHookResponse<T> where T: ParseObject, P: ParamsObjectIdable {
        
        if let error: ParseHookResponse<T> = checkHeaders(req) { return error }
        var parseRequest = try req.content.decode(HookFuncReq<User, P>.self)
        let params = parseRequest.parameters
        let options = try parseRequest.options(req)
        if parseRequest.user != nil {
            parseRequest = try await parseRequest.hydrateUser(options: options, request: req)
        }
        
        // Check Required Params
        guard let objectId = params.objectId else {
            return ParseHookResponse(error: .missingObjectId)
        }
        
        do {
            
            let object = try await T.query("objectId" == objectId)
                .includeAll()
                .first(options: options)
            dump(object)
            print("🧪 Returning hook response now")
            return ParseHookResponse(success: object)
            
        } catch {
            print("Error: \(error)")
            return ParseHookResponse(error: .other, message: "\(error)")
        }
        
    }

Running a simple func like this with .includeAll() would still return just a Pointer with none of the data I hoped to retrieve.

My goal is to have all my processing done in the cloud. especially for trickier processing for objects with child objects and checks.

So on my tests, even though technically a success since I got a success response back, the JSON I get is basically empty.

Successfully retrieved: "<nil>|⭕️" with ObjectId "ZC1ROXgDOG"
▿ BusogFood ({"objectId":"ZC1ROXgDOG"})
  - originalData: nil
  ▿ objectId: Optional("ZC1ROXgDOG")
    - some: "ZC1ROXgDOG"
  - createdAt: nil
  - updatedAt: nil
  - ACL: nil
  - name: nil
  - lokality: nil
  - description: nil
  - section: nil
  - price: nil
  - tag: nil
  - tagName: nil
  - currency: nil
  - addedBy: nil
  - weight: nil

I hope that was clear on what I'm trying to do. I'm hoping down the line to not have to maintain different code bases to do the same thing as my app needs a web base as well and hopefully Android support too.

It would be good for me to have each of these SDK just call the same cloud code and get the same Response. So that's why I'm starting with a simple query to get a full object but I'm already stuck.

I understand that I could do simple calls like this in the client side and not via cloudcode, but when it gets more complex, wouldn't it be better to have it all up in the cloud having the server do all the processing?

thanks for reading through that. :)

[cbaker6]

What happens when you change the encoder as mentioned in #80 (reply in thread). Specifically, changing to User.getJSONEncoder() on

parse-server-swift/Sources/ParseServerSwift/Parse.swift

Line 56 in c5d5b5c

ContentConfiguration.global.use(encoder: User.getEncoder(), for: .json)

[jaysonng]

hi! yes so it does look like that PR causes the problem. Looking at it, it does correspond to what I've traced that ParseEncoder is causing my issue and going back to .getJSONEncoder() fixes it for me.

With that said, is there a way for us to make it a choice on what encoder to use? or maybe have the choice in ParseEncoder to not return Pointers?

[jaysonng]

so basically I've been just been returning Response objects instead of ParseHookResponse objects to get all of the json data to send out to my client side instead of just getting Pointer objects if I use ParseHookResponse.

What am I losing out on by doing that? What advantages does ParseHookResponse give over normal json Response object?

What I'm doing now is wrapping the ParseHookResponse in a custom func that converts it into a Response object

func makeHookJSONResponse<T: Encodable>(_ hookResponse: ParseHookResponse<T>) throws -> Response {
    let encoder = User.getJSONEncoder()
    let data = try encoder.encode(hookResponse)

    var buffer = ByteBufferAllocator().buffer(capacity: data.count)
    buffer.writeBytes(data)

    let response = Response(status: .ok)
    response.headers.add(name: .contentType, value: "application/json")
    response.body = .init(buffer: buffer)

    return response
}

then that get's sent out down the line. so instead of returning ParseHookResponse objects, I return a Response object.

            let hookResponse = ParseHookResponse(success: testObject)
            return try makeHookJSONResponse(hookResponse)

[cbaker6]

I’m not sure, you will have to compare the full response sent to the server for both. I see you are setting the header on your custom json response, so if you have to rebuild the whole header from scratch, you could be missing a lot based on your server configuration. There are also times when the server wants pointers and won't accept full objects; in those cases, I don’t believe your current json response will work.

If your code is working for you, maybe you aren’t missing anything essential.