Amplify Datastore subscription cost

Question

I am trying to understand the cost of Datastore. It seems that it subscribes to all Mutations. So if there are 50 users, then each message will be send 50 times, even if it not required. As each real time mutation costs money, we will be paying unnecessary 49 times for this real time message mutation. Also , it seems to me SyncExpression doesn't have any effect on this Subscription.

I am really stuck here. It will be great of someone can clarify

Answer 1

Amplify generates the datastore boilerplate code for you, but you still need to call it. You won't pay for every user and every mutation.

You will only subscribe to a mutation (explicitly call the code to listen for changes) on a per-user basis for things that user is interested in. e.g. if you are viewing a TODO item, you'd subscribe the user to that item and they'll immediately see if someone else modify it on another device.

UPDATE Long story... I was triggering back-end computation via GraphQL by making a lambda resolver. The computation took too long and the GQL call would timeout. I updated the code so the GQL call called itself asynchronously (re-trigger the lambda), and returned immediately. Then when the long-running task completed in the spun-up lambda, I updated the a record in the database. I update the record using AppSync instead of direct GQL so it would trigger mutations, and in the react client, I listen to a mutation for the specific record that will be updated. This way, there is just 1 user listening (if they've triggered the long running action) and that user is only notified about changes to the single DB record they're interested in, and not receiving other user's updates.

I don't know if all this is applicable to your situation. The code snippets below may help you, but they're somewhat out of context.

// In amplify/backend/api/projectname/schema.graphql
type Subscription {
  onCouponWithIdUpdated(id: ID!): Coupon @aws_subscribe(mutations: ["updateCoupon"])
}


// In my useSendCoupon hook...
  // Subscribe to coupon updates
  useEffect(() => {
    if (0 === couponId) {
      return
    }
    console.log(`subscribe to coupon updates for couponId:`, couponId)
    const onCouponWithIdUpdated = /* GraphQL */ `
      subscription OnCouponWithIdUpdated($id: ID!) {
        onCouponWithIdUpdated(id: $id) {
          id
          proofLink
          owner
        }
      }
    `
    const subscription = API
      .graphql(graphqlOperation(onCouponWithIdUpdated, { id: couponId }))
      .subscribe({
        next: ({ provider, value }) => {
          const coupon = value.data.onCouponWithIdUpdated
          //console.log(`Proof Link:`, coupon.proofLink)
          setProofLinks([coupon.proofLink])
          setSendCouponState(COUPON_STATE_PREVIEW_SUCCESS)
        },
        error: error => console.warn(error)
      })
    console.log('subscribed: ', subscription)
    return () => {
      console.log(`unsubscribe to coupon updates`)
      subscription.unsubscribe()
    }
  }, [couponId])


// inside a lambda...
const updateCouponWithProof = async (authorization, couponId, proofLink) => {
    const initializeClient = () => new AWSAppSyncClient({
      url: process.env.API_XXXX_GRAPHQLAPIENDPOINTOUTPUT,
      region: process.env.REGION,
      auth: {
        type: AUTH_TYPE.AMAZON_COGNITO_USER_POOLS,
        jwtToken: authorization
      },
      disableOffline: true,
    })

    const executeMutation = async (mutation, operationName, variables) => {
      const client = initializeClient()
      try {
        const response = await client.mutate({
          mutation: gql(mutation),
          variables,
          fetchPolicy: "no-cache",
        })
        return response.data[operationName]
      } catch (err) {
        console.log("Error while trying to mutate data", err)
        throw JSON.stringify(err)
      }
    }

    const updateCoupon = /* GraphQL */ `
  mutation UpdateCoupon(
    $input: UpdateCouponInput!
    $condition: ModelCouponConditionInput
  ) {
    updateCoupon(input: $input, condition: $condition) {
      id
      proofLink
      owner
    }
  }
`
    const variables = { input: { id: couponId, proofLink } }
    try {
      return await executeMutation(updateCoupon, 'updateCoupon', variables)
    } catch (error) {
      console.log(`executeMutation error`, error)
    }
  }