通过加/减来更新 Amplify Datastore 项目的值？

Question

I want to use datastore to update a value based on the current value stored in the database. In the documentation it shows a retail counter use case. But how are you supposed to implement this kind of set up?

A small example:

I have an inventory table which contains an item and a counter for an item:

type Inventory @model {
id: ID!
name: String!
count: Int!}

If i want to save a new Inventory I can do this:

Inventory inventory = Inventory(id,'product1',10);
Amplify.Datastore.save(inventory);

Then, I know to update i can use the Amplify.Datastore.save(inventoryUpdatedModel) with the same ID, and Amplify will update the item in storage. So far so good.

So what if I have multiple devices changing the same value as in the example?

Start: count = 10;

1: Device 1 -> Adds 5 to count (10 + 5 = 15)

2: Device 2 -> Subtracts 3 from count (10 - 3 = 7)

3: Both Devices update Datastore and read values.

Currently, only the latest value (7 in the example) is shown, where the required answer would be 12. (10+5-3 = 12)

So far ive tried:

1. Query the database just before it saves, but this has obvious concurrency issues when multiple devices are performing operations at the same time.

2. Add a new table called updateInventoryCount(inventoryID,numberToAdd), then process the data in this table one item at a time, on only one device. Balancing the value of any updates to the same ID and then removing them works actually but its nowhere near a perfect solution.

What I would love is something like Amplify.Datastore.updateValue(ID,-3); Amplify -> Takes old value, subtracts 3, updates appsync with same command

Answer 1

The direction i chose to go went like this, please feel free to let me know if i'm way off the mark!

Basically: Run a service to detect changes in a supplementary table synced with AWS, and only allow this service to change data locally, rather than allowing AWS to change your locally protected table.

PROS:

• doesn't rely on any server code at all.
• Intermittent network is fine, updates remain the same across multiple devices,
• Uses the flutter amplify api only

CONS:

• will create many more writes to AWS
• is convoluted

Make models : Couldnt get models to grab related objects directly through the codegen'd code, (even though it looks like the plumbing is there to do just that..) so im using 'table row' ID's and performing two Amplify.DataStore.query(model.classType) operations to get my local nodes' inventory and then generic ticketitem Data

type Inventory @model {
  id:ID!
  clientid: String!
  inventoryclientid: String!
  quantity:Int!
  sellprice: Float!
  ticketItemID: String!}

 type TicketItem @model {
      id:ID!
      name: String!
      buyprice: Float!
      genericnfo: String!
      }

type SyncedMutations @model {
    id:ID!
    clientid: String!
    ownerclientid: String!
    tablename: String!
    itemid: String!
    mutation: String!
    from: String!
    completed: [String]
    itemdata: String!
}

then: amplify codegen models

I also had to use selectiveSync on startup like so:

    AmplifyDataStore amplifyDataStore = AmplifyDataStore(modelProvider: 
    ModelProvider.instance, syncExpressions: [    
    DataStoreSyncExpression(SyncedMutations.classType, () => SyncedMutations.OWNERCLIENTID.eq(curClient))     
    DataStoreSyncExpression(Inventory.classType, () => Inventory.CLIENTID.eq(curClient)),
    ]);
    
      Amplify.addPlugin(amplifyDataStore);

then i set up a service on start up to subscribe and listen to events happening to the SyncedMutations table, and on any create operation, to update the local inventory table. the code is as follows (needs a clean up):

import ...

@LazySingleton()
class SyncMutationsService {
  static final SyncMutationsService _instance = SyncMutationsService._internal();
  final _clientService = locator<ClientService>();

  SyncMutationsService._internal() {
    Stream<SubscriptionEvent<SyncedMutations>> stream = Amplify.DataStore.observe(SyncedMutations.classType)
      ..listen(handleSubscription);
  }

  factory SyncMutationsService() => _instance;

  handleSubscription(SubscriptionEvent<SyncedMutations> event) async {
 if (event.eventType == EventType.create) {
    updateLocalProtectedTable(event.item);
    }
  }

  void updateLocalProtectedTable(SyncedMutations eventitem) {
    switch (eventitem.tablename) {
      case 'Inventory':
        print('Inventory table update.. ');
        updateInventoryOnEvent(eventitem);
        break;
    }
  }

  void updateInventoryOnEvent(SyncedMutations eventitem) {
    try {
      Inventory inventorydata = Inventory.fromJson(json.decode(eventitem.itemdata));

      SharedPreferencesHelper.getCurrentClientID().then((curClientID) {
        if (eventitem.completed == null || !eventitem.completed!.contains(curClientID)) {
          try {
            if (int.tryParse(eventitem.mutation) != null) {
              getCorrespondingInventoryLine(inventorydata.inventoryTicketItemID).then((oldLocalInvItem) {
                Inventory updatedInventoryItem = oldInvItem.copyWith(
                  quantity: oldLocalInvItem.quantity + int.parse(eventitem.mutation),
                );

                Amplify.DataStore.save(updatedInventoryItem).then((value) {
                  //update syncMutationLine completed client list
                  List<String> completedList = eventitem.completed ?? [];
                  completedList.add(_clientService.client.id);
                  Amplify.DataStore.save(eventitem.copyWith(completed: completedList));
                });
              });
            }
          } catch (e) {
            print('TicketItem was saved, but could not initialise stock into Inventory. ERROR: $e');
          }
        }
      });
    } catch (e) {
      print('Could not transpose inventory line data from syncMutation. ERROR: $e');
    }
  }


  Future<Inventory> getCorrespondingInventoryLine(String ticketItemID) async {
      double markup = await SharedPreferencesHelper.getBaseMarkup();

    return Amplify.DataStore.query(Inventory.classType).then((inventoryList) {
      return Amplify.DataStore.query(TicketItem.classType).then((ticketItemList) {
        TicketItem ti = ticketItemList.firstWhere((tItem) => tItem.id == ticketItemID);
        if (inventoryList.isNotEmpty) {
          return inventoryList.firstWhere((inventoryLine) => inventoryLine.inventoryTicketItemID == ticketItemID,
              orElse: () {
                return Inventory(
                    clientid: _clientService.client.id,
                    inventoryclientid: _clientService.client.id,
                    quantity: 0,
                    sellprice: markup * ti.buyprice,
                    inventoryTicketItemID: ticketItemID);
              });
        } else {
          return Inventory(
              clientid: _clientService.client.id,
              inventoryclientid: _clientService.client.id,
              quantity: 0,
              sellprice: markup * ti.buyprice,
              inventoryTicketItemID: ticketItemID);
        }
      });
    });
  }
}

Now whenever i want to adjust inventory quantities (or any other table using the same logic), i locally save directly to inventory , but then add a syncedMutations entry with the current devices' clientID which will get spawned to all the other clients changing the same information. like this:

    Inventory updatedInventoryItem = oldInventoryItem.copyWith( 
   quantity:oldInventoryItem.quantity+valueOfMutation);
    
     
                  int mutationInt = valueOfMutation; // add 10, minus 4 etc
    
                  Amplify.DataStore.save(updatedInventoryItem).then((value) {
                    Amplify.DataStore.save(SyncedMutations(
                        clientid: clientService.client.id,
                        ownerclientid: clientService.actingClient.id,
                        completed: [clientService.client.id],
                        tablename: 'Inventory',
                        itemid: oldInventoryItem.ticketItemID,
                        mutation: mutationInt.toString(),
                        from: oldInventoryItem.quantity.toString(),
                        itemdata: json.encode(updatedInventoryItem.toJson())));
                  });

so lets say i have two clients which both have intermittent network, and are not necessarily on at the same time, each device changes its own inventory as and when updates happen, then upon network connection, sends each mutation operation into the cloud to find any other device with the same clientID , syncMutations then listens to the create event and makes its own update to its local (but backed up online) version of inventory. It also then adds its own clientID to the list of clients that have become up to date.

Later you could run a test to get rid of all syncedMutations which have every client in the completed list.

I'm sure there's a better or more robust method for this but it is working as expected while keeping all the logic on device.