@statezero/core 0.2.29 → 0.2.30

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;
         };

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.30",
   "type": "module",
   "module": "ESNext",
   "description": "The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate",