Unparsed Response Object For BatchGet

[julian-dotcom]

I have an array of userIds[] and want to send a batch request to my One Table DynamoDB to get all corresponding users.

Thus far, this has been my (suboptimal) approach, but it requires sending hundreds of API requests
const items = await Promise.all(userIds.map((id) => this.model.get({ id })))

Much more preferable would be to use the batchGet method, as seen in the documentation:
https://doc.onetable.io/api/table/methods/#batchget

let batch = {}
await Account.get({id: accountId}, {batch})
await User.get({id: userId}, {batch})
let results = await table.batchGet(batch)

However, the response is completely untyped and looks like a response straight from DynamoDB.

I do not want to write a type guard, as the schema is quite complicated, and a type guard would be difficult to maintain.

Does the lib provide some elegant mechanism to type check such responses?

[mobsense]

Add

{
    parse: true
}

as params to the batchGet. Can also use hidden:true to suppress hidden fields.

[julian-dotcom]

Thanks for the swift response. Unfortunately, when I set { parse: true }, the response is an empty array, similar to this post.

I also made sure that all my records have a _type property, as by this comment.

Please note that when I set { parse: false }, I do get the desire records, meaning that there is in fact data to be returned.

Do you have any other suggestions that might lead to the failure of the processing?

[mobsense]

Two suggestions:

add {log: true} so you can see the actual command being executed.

Create a debug.ts that replicates the issue so can can investigate.

[julian-dotcom]

Here is the response object, when { log: true }

Does the problem lie with the fact that "model": "_Generic"?

OneTable "batchGet" "_Generic" {
     "trace": {
         "model": "_Generic",
         "cmd": {
             "RequestItems": {
                 "table-name": {
                     "Keys": [
                         {
                             "pk": {
                                 "S": "User:d191804b-eb8b-45a8-bc23-4a3d4231acdd"
                             },
                           "sk": {
                                 "S": "User:"
                             }
                         }
                     ],
                     "ConsistentRead": false
                 }
             }
         },
         "op": "batchGet",
         "properties": {}
     }
 }

[julian-dotcom]

To clarify, when { parse: false }, I get the desire response, just unparsed.

So the problem does not lie with the DynamoDB request, but rather with the parsing.

[julian-dotcom]

I figured out the issue, I wasn't passing the model to the table:

    return new Table({
      (...)
      models: { User: UserSchema.fields }, // IMPORTANT
    });
  },

[julian-dotcom]

There is still one remaining problem.

While the response is successfully parsed, it is not type safe.

For this const items = await this.table.batchGet(batch, { parse: true });, this is the type of items: const items: {}[]

[mobsense]

Great you figured it out. Yes, you need a schema to be able to parse the response.

You wont get a batch response typed -- as the return data types are unknown at dev time.