@statezero/core 0.1.62 → 0.1.63

package/dist/flavours/django/makeApiCall.js

@@ -110,19 +110,6 @@ export async function makeApiCall(querySet, operationType, args = {}, operationI
             throw new Error(`API call failed: ${error.message}`);
         }
     };
-    /*
-      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.
-    */
+    // Queue write operations, execute read operations immediately
     return isWriteOperation ? apiCallQueue.add(apiCall) : apiCall();
 }

package/dist/syncEngine/stores/operationEventHandlers.js

@@ -35,38 +35,6 @@ 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
  *
@@ -156,14 +124,9 @@ function processQuerysetStores(operation, actionType) {
 function processMetricStores(operation, actionType) {
     const queryset = operation.queryset;
     const ModelClass = queryset.ModelClass;
-    // For metrics, we use related querysets as the base
+    // For metrics, we can use a similar strategy but might be more conservative
+    // and always use related querysets since metrics are aggregations
     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.62",
+  "version": "0.1.63",
   "type": "module",
   "module": "ESNext",
   "description": "The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate",