@statezero/core 0.2.29 → 0.2.31

package/dist/flavours/django/makeApiCall.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Wraps a promise with a timeout.
+ * @param {Promise} promise - The promise to wrap
+ * @param {number} ms - Timeout in milliseconds (default: 30000)
+ * @returns {Promise} - Resolves with promise result or rejects on timeout
+ */
+export function withTimeout(promise: Promise<any>, ms?: number): Promise<any>;
 /**
  * Process included entities from a response and register them in the model store.
  * Uses the model registry to find the appropriate model class for each entity type.
@@ -18,6 +25,12 @@ export function processIncludedEntities(modelStoreRegistry: ModelStoreRegistry,
  * @param {string} operationId - A unique id for the operation
  * @param {Function} beforeExit - Optional callback before returning
  * @param {string} canonicalId - Optional canonical_id for cache sharing
+ * @param {Object} options - Additional options
+ * @param {string} options.namespace - Queue namespace ('default' for app ops, 'sync' for background sync)
+ * @param {number} options.timeout - Timeout in ms (default: no timeout)
  * @returns {Promise<Object>} The API response.
  */
-export function makeApiCall(querySet: QuerySet, operationType: string, args: Object | undefined, operationId: string, beforeExit?: Function, canonicalId?: string): Promise<Object>;
+export function makeApiCall(querySet: QuerySet, operationType: string, args: Object | undefined, operationId: string, beforeExit?: Function, canonicalId?: string, options?: {
+    namespace: string;
+    timeout: number;
+}): Promise<Object>;

package/dist/flavours/django/makeApiCall.js

@@ -5,7 +5,27 @@ import { replaceTempPks } from './tempPk.js';
 import { parseStateZeroError, MultipleObjectsReturned, DoesNotExist } from './errors.js';
 import { FileObject } from './files.js';
 import { querysetStoreRegistry } from '../../syncEngine/registries/querysetStoreRegistry.js';
-const apiCallQueue = new PQueue({ concurrency: 1 });
+// Namespace-based queues: separate queues for different operation types
+// This prevents sync operations from blocking user-initiated app operations
+const queues = new Map();
+function getQueue(namespace = 'default') {
+    if (!queues.has(namespace)) {
+        queues.set(namespace, new PQueue({ concurrency: 1 }));
+    }
+    return queues.get(namespace);
+}
+/**
+ * Wraps a promise with a timeout.
+ * @param {Promise} promise - The promise to wrap
+ * @param {number} ms - Timeout in milliseconds (default: 30000)
+ * @returns {Promise} - Resolves with promise result or rejects on timeout
+ */
+export function withTimeout(promise, ms = 30000) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Request timeout after ${ms}ms`)), ms)),
+    ]);
+}
 /**
  * Process included entities from a response and register them in the model store.
  * Uses the model registry to find the appropriate model class for each entity type.
@@ -64,9 +84,13 @@ export function processIncludedEntities(modelStoreRegistry, included, ModelClass
  * @param {string} operationId - A unique id for the operation
  * @param {Function} beforeExit - Optional callback before returning
  * @param {string} canonicalId - Optional canonical_id for cache sharing
+ * @param {Object} options - Additional options
+ * @param {string} options.namespace - Queue namespace ('default' for app ops, 'sync' for background sync)
+ * @param {number} options.timeout - Timeout in ms (default: no timeout)
  * @returns {Promise<Object>} The API response.
  */
-export async function makeApiCall(querySet, operationType, args = {}, operationId, beforeExit = null, canonicalId = null) {
+export async function makeApiCall(querySet, operationType, args = {}, operationId, beforeExit = null, canonicalId = null, options = {}) {
+    const { namespace = 'default', timeout } = options;
     const ModelClass = querySet.ModelClass;
     const config = configInstance.getConfig();
     const backend = config.backendConfigs[ModelClass.configKey];
@@ -133,5 +157,9 @@ export async function makeApiCall(querySet, operationType, args = {}, operationI
         }
     };
     // Queue write operations, execute read operations immediately
-    return isWriteOperation ? apiCallQueue.add(apiCall) : apiCall();
+    // Use namespace-based queues to separate sync ops from app ops
+    const queue = getQueue(namespace);
+    const queuedCall = isWriteOperation ? queue.add(apiCall) : apiCall();
+    // Apply timeout if specified
+    return timeout ? withTimeout(queuedCall, timeout) : queuedCall;
 }

package/dist/syncEngine/registries/querysetStoreRegistry.js

@@ -184,7 +184,8 @@ export class QuerysetStoreRegistry {
             };
             const response = await makeApiCall(queryset, 'list', payload, null, // operationId
             null, // beforeExit
-            canonical_id // canonical_id for caching
+            canonical_id, // canonical_id for caching
+            { namespace: 'sync', timeout: 30000 } // Sync ops on separate queue
             );
             return response.data;
         };
@@ -211,6 +212,7 @@ export class QuerysetStoreRegistry {
         if (this._tempStores.has(queryset)) {
             store = this._tempStores.get(queryset);
             store.isTemp = false; // Promote to permanent store
+            store.registerWithModelStore(); // Register for model store changes now that it's permanent
             this._stores.set(semanticKey, store);
             this.syncManager.followModel(this, queryset.ModelClass);
         }
@@ -218,6 +220,7 @@ export class QuerysetStoreRegistry {
         else if (!this._stores.has(semanticKey)) {
             store = this.getStore(queryset);
             store.isTemp = false;
+            store.registerWithModelStore(); // Register for model store changes now that it's permanent
             this._stores.set(semanticKey, store);
             this.syncManager.followModel(this, queryset.ModelClass);
         }
@@ -249,12 +252,14 @@ export class QuerysetStoreRegistry {
             if (this._tempStores.has(queryset)) {
                 store = this._tempStores.get(queryset);
                 store.isTemp = false; // Promote to permanent store
+                store.registerWithModelStore(); // Register for model store changes now that it's permanent
                 this._stores.set(semanticKey, store);
             }
             else {
                 // Create a new permanent store
                 store = this.getStore(queryset);
                 store.isTemp = false;
+                store.registerWithModelStore(); // Register for model store changes now that it's permanent
                 this._stores.set(semanticKey, store);
             }
         }

package/dist/syncEngine/stores/querysetStore.d.ts

@@ -32,6 +32,11 @@ export class QuerysetStore {
     getInflightOperations(): any[];
     prune(): void;
     registerRenderCallback(callback: any): () => boolean;
+    /**
+     * Register this store with the model store for change notifications.
+     * Called when a temp store is promoted to permanent.
+     */
+    registerWithModelStore(): void;
     /**
      * Helper to validate PKs against the model store and apply local filtering/sorting.
      * This is the core of the rendering logic.

package/dist/syncEngine/stores/querysetStore.js

@@ -31,10 +31,14 @@ export class QuerysetStore {
         this._lastRenderedPks = null;
         this.renderCallbacks = new Set();
         // Register for model store changes to re-render when model data changes
-        const modelStore = modelStoreRegistry.getStore(this.modelClass);
-        this._modelStoreUnregister = modelStore.registerRenderCallback(() => {
-            this._emitRenderEvent();
-        });
+        // Only register permanent stores - temp stores are transient and should not
+        // accumulate callbacks (causes reactivity cascade when Vue creates new querysets)
+        if (!this.isTemp) {
+            const modelStore = modelStoreRegistry.getStore(this.modelClass);
+            this._modelStoreUnregister = modelStore.registerRenderCallback(() => {
+                this._emitRenderEvent();
+            });
+        }
     }
     // Caching
     get cacheKey() {
@@ -150,6 +154,18 @@ export class QuerysetStore {
         this.renderCallbacks.add(callback);
         return () => this.renderCallbacks.delete(callback);
     }
+    /**
+     * Register this store with the model store for change notifications.
+     * Called when a temp store is promoted to permanent.
+     */
+    registerWithModelStore() {
+        if (this._modelStoreUnregister)
+            return; // Already registered
+        const modelStore = modelStoreRegistry.getStore(this.modelClass);
+        this._modelStoreUnregister = modelStore.registerRenderCallback(() => {
+            this._emitRenderEvent();
+        });
+    }
     /**
      * Helper to validate PKs against the model store and apply local filtering/sorting.
      * This is the core of the rendering logic.

package/dist/syncEngine/sync.d.ts

@@ -22,15 +22,13 @@ export class SyncManager {
     debounceMs: number;
     maxWaitMs: number;
     batchStartTime: number | null;
-    /** @type {PQueue} */
-    syncQueue: PQueue;
     withTimeout(promise: any, ms: any): Promise<any>;
     /**
      * Initialize event handlers for all event receivers
      */
     initialize(): void;
     startPeriodicSync(): void;
-    syncStaleQuerysets(): void;
+    syncStaleQuerysets(): Promise<void>;
     pruneUnreferencedModels(): void;
     isStoreFollowed(registry: any, semanticKey: any): boolean;
     cleanup(): void;
@@ -45,5 +43,4 @@ export class SyncManager {
     processMetrics(event: any): void;
     processModels(event: any): void;
 }
-import PQueue from "p-queue";
 export const syncManager: SyncManager;

package/dist/syncEngine/sync.js

@@ -8,7 +8,6 @@ import { metricRegistry, MetricRegistry } from "./registries/metricRegistry.js";
 import { getModelClass, getConfig } from "../config.js";
 import { isNil } from "lodash-es";
 import { QuerysetStore } from "./stores/querysetStore.js";
-import PQueue from "p-queue";
 import { v7 as uuidv7 } from "uuid";
 export class EventPayload {
     constructor(data) {
@@ -96,9 +95,6 @@ export class SyncManager {
         this.debounceMs = 100; // Wait for rapid events to settle
         this.maxWaitMs = 2000; // Maximum time to hold events
         this.batchStartTime = null;
-        // SyncQueue
-        /** @type {PQueue} */
-        this.syncQueue = new PQueue({ concurrency: 1 });
     }
     withTimeout(promise, ms) {
         // If no timeout specified, use 2x the periodic sync interval, or 30s as fallback
@@ -156,8 +152,7 @@ export class SyncManager {
             console.log("[SyncManager] No config found, periodic sync disabled by default");
         }
     }
-    syncStaleQuerysets() {
-        let syncedCount = 0;
+    async syncStaleQuerysets() {
         const querysetRegistry = this.registries.get(QuerysetStoreRegistry);
         if (!querysetRegistry)
             return;
@@ -165,16 +160,18 @@ export class SyncManager {
         const operationId = `periodic-sync-${uuidv7()}`;
         // Get dbSynced keys (followed querysets)
         const dbSyncedKeys = new Set([...this.followedQuerysets].map(qs => qs.semanticKey));
+        // Collect all stores to sync
+        const storesToSync = [];
         for (const [semanticKey, store] of querysetRegistry._stores.entries()) {
-            // Only sync if this store is actually being followed
             const isFollowed = this.isStoreFollowed(querysetRegistry, semanticKey);
             if (this.followAllQuerysets || isFollowed) {
-                this.syncQueue.add(() => this.withTimeout(querysetRegistry.groupSync(store.queryset, operationId, dbSyncedKeys)));
-                syncedCount++;
+                storesToSync.push(store);
             }
         }
-        if (syncedCount > 0) {
-            console.log(`[SyncManager] Periodic sync: ${syncedCount} stores pushed to the sync queue`);
+        if (storesToSync.length > 0) {
+            console.log(`[SyncManager] Periodic sync: syncing ${storesToSync.length} stores`);
+            // Run all groupSync calls in parallel - they coordinate via shared promise cache
+            await Promise.all(storesToSync.map(store => querysetRegistry.groupSync(store.queryset, operationId, dbSyncedKeys)));
         }
         // Prune unreferenced model instances
         this.pruneUnreferencedModels();
@@ -310,15 +307,16 @@ export class SyncManager {
                 }
             }
         }
+        if (storesToSync.length === 0)
+            return;
         // Sync all relevant stores for this model
         console.log(`[SyncManager] Syncing ${storesToSync.length} queryset stores for ${representativeEvent.model}`);
         // Generate operationId for this batch - querysets in same chain will coordinate
         const operationId = `remote-event-${uuidv7()}`;
         // Get dbSynced keys (followed querysets)
         const dbSyncedKeys = new Set([...this.followedQuerysets].map(qs => qs.semanticKey));
-        storesToSync.forEach((store) => {
-            this.syncQueue.add(() => this.withTimeout(registry.groupSync(store.queryset, operationId, dbSyncedKeys)));
-        });
+        // Run all groupSync calls in parallel - they coordinate via shared promise cache
+        Promise.all(storesToSync.map(store => registry.groupSync(store.queryset, operationId, dbSyncedKeys)));
     }
     processMetrics(event) {
         const registry = this.registries.get(MetricRegistry);
@@ -380,7 +378,7 @@ export class SyncManager {
         });
         if (pksToSync.length > 0) {
             console.log(`[SyncManager] Syncing ${pksToSync.length} nested-only PKs for ${event.model}: ${pksToSync}`);
-            this.syncQueue.add(() => this.withTimeout(modelStore.sync(pksToSync)));
+            modelStore.sync(pksToSync);
         }
     }
 }

package/package.json

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