Proper Way to Combine / Consolidate GraphQL Queries in DynamoDB - Custom Amplify Resolver? - React Native about amplify-js

[chrisbonifacio]

Closing this as not a bug, but more of a question. While AppSync supports query batching, making use of it would require manually writing the graphql string. Using the client.graphql API, you can pass in a custom string to the query parameter to combine the calls into one query and thus one network call.

You can try this but it would still result in two separate operations in DynamoDB because each query maps to one can only map to one resolver which can only map to one DynamoDB operation.

Otherwise, in the Gen 2 client.models API, you would have to split up the queries into separate calls:

schema

  Message: a
    .model({
      senderId: a.string().required(),
      receiverId: a.string().required(),
      viewedTimeStamp: a.timestamp().required(),
      content: a.string().required(),
      status: a.string().required(),
      createdAt: a.datetime().required(),
    })
    .authorization((allow) => [
      allow.ownerDefinedIn("senderId"),
      allow.ownerDefinedIn("receiverId").to(["read"]),
    ])
    .secondaryIndexes((index) => [
      index("senderId").sortKeys(["viewedTimeStamp"]),
      index("receiverId").sortKeys(["viewedTimeStamp"]),
    ]),

queries

    const { data: recieveUnreadMessages } =
      await client.models.Message.listByReceiverIdAndViewedTimeStamp({
        receiverId: currentUser.userId,
        viewedTimeStamp: {
          attributeExists: false,
        },
      });

    const { data: sentUnreadMessages } =
      await client.models.Message.listBySenderIdAndViewedTimeStamp({
        senderId: currentUser.userId,
        viewedTimeStamp: {
          attributeExists: true,
        },
      });

    console.log({ recieveUnreadMessages, sentUnreadMessages });

Unfortunately DynamoDB only accepts one filter expression per Scan/Query so at least two different operations must occur.

[cwomack]

Hello again, @ChristopherGabba 👋. Appreciate you providing details on your queries, schema, and code snippet already. At first glance, it sounds like Compound Filters might be able to accomplish what you're looking for to allow your queries to be combined into a single one with and, or, and not Boolean logic. Have you tried incorporating this yet?

Also, is your viewedTimestamp: AWSDateTime within your schema intended to have both the sender AND the receiver have only 1 shared value for viewedTimestamp?

[cwomack]

@ChristopherGabba, wanted to check in and see if you're still blocked by this or had a chance to review the above comment.

[ChristopherGabba]

@cwomack I think your Compound Filters link is broken and just takes me back to this issue page. Regardless, I think I found some information on the topic. I previously was using compound filters with multiple ors and ands but ran into an issue with the limit filter. Eventually I stumbled across using the secondary @index to improve your query efficiencies, although I'm no expert on this topic. That's why I eventually made two different queries using @Index. Going back to compound filters is of course possible, but is that better than what I'm doing now as far as query efficiency (database reads / writes / etc.)?

[chrisbonifacio]

Hi @ChristopherGabba , generally leveraging secondary indexes are more efficient than using a list + compound filters because a list will trigger a Scan operation on the DynamoDB table whereas secondary indexes will perform a Query instead which is more cost effective.

Perhaps something like this might work for your use case?

Gen 2 Schema

  Message: a
    .model({
      senderId: a.id().required(),
      recieverId: a.id().required(),
      content: a.string().required(),
      status: a.string().required(),
      createdAt: a.datetime().required(),
    })
    .secondaryIndexes((index) => [
      index("senderId"),
      index("recieverId").sortKeys(["status", "createdAt"]),
    ]),

Client Query

[ChristopherGabba]

@chrisbonifacio Thanks for providing this, I actually had not looked into Gen 2's API structure.

What I'm looking for essentially is a way for me to query messages in the most efficient way possible. If that is with two different secondary index calls (as shown in my example above), then that is what I'm looking to do.

I was just wondering if there is an even more efficient way to perform my "double" query like:

clients.models.Message.listUsersByReceiverOrSenderId({
     receiverOrSenderId: "123", // this effectively queries both situations above
     senderFilter: {
         viewedTimestamp: { attributeExists: true },
     },
     receiverFilter: {
        viewedTimestamp: { attributeExists: false },
     }
})

My situation is kind of unique. Effectively, my app sends a media to the user, the user looks at that media, and then it sends that same media back with a response. So when I query the database table for the actual user on the app, I am checking to see all items that have been sent by the user, but have been responded to, OR a message that this particular user is supposed to respond to.

My end goal is just to make sure that at scale, I'm being as efficient as possible with my queries using secondary indexes etc. in order to get all of my data back to the user.