@statezero/core 0.1.61 → 0.1.62

package/dist/flavours/django/makeApiCall.js

@@ -110,6 +110,19 @@ export async function makeApiCall(querySet, operationType, args = {}, operationI
             throw new Error(`API call failed: ${error.message}`);
         }
     };
-    // Queue write operations, execute read operations immediately
+    /*
+      We use p-queue for write operations to ensure that the user does not
+      try and perform a write operation using a temporary primary key that
+      exists on the local optimistic instance until the backend has replied with the
+      new primary key. This would result in a 400 Bad Request error from the backend.
+      This is effective, but does mean that write operations are queued which can lead to delays.
+      In general, this is not a problem because the UI will optimistically update the state so the
+      user does not perceive the delay, but it is something to be aware of.
+  
+      In the future, we will want to implement an approach where we specifically detect
+      if a write operation is using a temporary pk and then await for the temporary
+      pk to be replaced before proceeding with the write operation. But for now,
+      this is a simple and effective solution.
+    */
     return isWriteOperation ? apiCallQueue.add(apiCall) : apiCall();
 }

package/dist/syncEngine/stores/operationEventHandlers.js

@@ -35,6 +35,38 @@ function relatedQuerysets(queryset) {
     });
     return result;
 }
+/**
+ * Returns querysets that contain any of the specified instances
+ * @param {Operation} operation - The operation containing instances to check
+ * @returns {Map<QuerySet, Store>}
+ */
+function querysetsContainingInstances(operation) {
+    const ModelClass = operation.queryset.ModelClass;
+    const pkField = ModelClass.primaryKeyField;
+    const instancePks = new Set(operation.instances
+        .filter(instance => instance && typeof instance === 'object' && pkField in instance)
+        .map(instance => instance[pkField]));
+    if (instancePks.size === 0) {
+        return new Map();
+    }
+    const result = new Map();
+    Array.from(querysetStoreRegistry._stores.entries()).forEach(([queryset, store]) => {
+        if (store.modelClass !== ModelClass)
+            return;
+        try {
+            // Check if this queryset contains any of the instances
+            const renderedPks = new Set(store.render(false)); // Get without optimistic updates
+            const hasIntersection = [...instancePks].some(pk => renderedPks.has(pk));
+            if (hasIntersection) {
+                result.set(store.queryset, store);
+            }
+        }
+        catch (e) {
+            console.warn('Error checking queryset for instances', e);
+        }
+    });
+    return result;
+}
 /**
  * Process an operation in the model store
  *
@@ -124,9 +156,14 @@ function processQuerysetStores(operation, actionType) {
 function processMetricStores(operation, actionType) {
     const queryset = operation.queryset;
     const ModelClass = queryset.ModelClass;
-    // For metrics, we can use a similar strategy but might be more conservative
-    // and always use related querysets since metrics are aggregations
+    // For metrics, we use related querysets as the base
     const allQuerysets = Array.from(relatedQuerysets(queryset).keys());
+    // For update/delete operations, also include querysets that contain the instances
+    if (operation.type === Type.UPDATE || operation.type === Type.UPDATE_INSTANCE ||
+        operation.type === Type.DELETE || operation.type === Type.DELETE_INSTANCE) {
+        const containingQuerysets = Array.from(querysetsContainingInstances(operation).keys());
+        allQuerysets.push(...containingQuerysets);
+    }
     let allMetricStores = new Set();
     allQuerysets.forEach(qs => {
         const stores = metricRegistry.getAllStoresForQueryset(qs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statezero/core",
-  "version": "0.1.61",
+  "version": "0.1.62",
   "type": "module",
   "module": "ESNext",
   "description": "The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate",