@statezero/core 0.2.52 → 0.2.53

package/dist/adaptors/vue/composables.d.ts

@@ -1,2 +1,2 @@
-export function useQueryset(querysetFactory: any): import("vue").ComputedRef<any>;
+export function useQueryset(querysetFactory: any): import("vue").Ref<any, any> | import("vue").ComputedRef<any>;
 export const querysets: Map<any, any>;

package/dist/adaptors/vue/composables.js

@@ -1,6 +1,6 @@
-import { computed, getCurrentInstance, onBeforeUnmount } from 'vue';
+import { computed, isRef, getCurrentInstance, onBeforeUnmount } from 'vue';
 import { querysetStoreRegistry } from '../../syncEngine/registries/querysetStoreRegistry.js';
-import { metricRegistry } from '../../syncEngine/registries/metricRegistry.js';
+import { metricRegistry, LiveMetric } from '../../syncEngine/registries/metricRegistry.js';
 import { syncManager } from '../../syncEngine/sync.js';
 import { registerAdapterReset } from '../../reset.js';
 import { v7 } from 'uuid';
@@ -22,6 +22,12 @@ export function useQueryset(querysetFactory) {
         querysets.delete(composableId);
         updateSyncManager();
     });
+    const result = querysetFactory();
+    // Metrics: the adaptor already returns a ref(scalar) — return it directly.
+    // Wrapping in another computed would cause .value.value in templates.
+    if (isRef(result) && result.original instanceof LiveMetric) {
+        return result;
+    }
     return computed(() => {
         const result = querysetFactory();
         const original = result?.original || result;

package/dist/adaptors/vue/reactivity.js

@@ -173,7 +173,7 @@ export function MetricAdaptor(metric) {
         return wrappedMetricCache.get(cacheKey);
     }
     // Create a reactive reference with the initial value
-    const wrapper = ref(metric.value);
+    const wrapper = ref(metric.valueOf());
     wrapper.original = metric;
     // Single handler for metric render events
     const metricRenderHandler = (eventData) => {
@@ -183,9 +183,9 @@ export function MetricAdaptor(metric) {
             eventData.field === metric.field &&
             eventData.ast === hash(querysetAst) &&
             eventData.valueChanged === true) {
-            console.log(`[sz] metric update: ${modelName}.${metric.field} (${metric.metricType}) =`, metric.value);
+            console.log(`[sz] metric update: ${modelName}.${metric.field} (${metric.metricType}) =`, metric.valueOf());
             // Update the wrapper value with the latest metric value
-            wrapper.value = metric.value;
+            wrapper.value = metric.valueOf();
         }
     };
     // Only listen for metric render events

package/dist/syncEngine/cache/cache.d.ts

@@ -60,7 +60,7 @@ export class IndexedDBStore {
 }
 export class Cache {
     constructor(dbName: any, options?: {}, onHydrated?: null);
-    store: IndexedDBStore;
+    store: any;
     localMap: Map<any, any>;
     hydrate(): Promise<void>;
     get(key: any): any;

package/dist/syncEngine/cache/cache.js

@@ -288,7 +288,14 @@ export class IndexedDBStore {
 }
 export class Cache {
     constructor(dbName, options = {}, onHydrated = null) {
-        this.store = new IndexedDBStore(dbName, options);
+        // Share IndexedDBStore instances across Cache objects with the same dbName
+        if (dbConnections.has(dbName)) {
+            this.store = dbConnections.get(dbName);
+        }
+        else {
+            this.store = new IndexedDBStore(dbName, options);
+            dbConnections.set(dbName, this.store);
+        }
         this.localMap = new Map();
         // don't await - will hydrate during app setup
         this.hydrate()

package/dist/syncEngine/registries/metricRegistry.d.ts

@@ -1,6 +1,13 @@
 /**
- * LiveMetric, a simple wrapper that always returns the latest metric value
- * using a getter for the value property
+ * LiveMetric wraps a metric scalar (count, sum, etc.) and stays live.
+ *
+ * Uses valueOf()/toString() so it coerces to the scalar naturally:
+ *   count + 0    // → 5
+ *   `${count}`   // → "5"
+ *   count > 3    // → true
+ *
+ * Note: typeof returns "object" and === compares identity, not value.
+ * Use == for loose comparison, or +metric for explicit coercion.
  */
 export class LiveMetric {
     constructor(queryset: any, metricType: any, field?: null);
@@ -14,8 +21,12 @@ export class LiveMetric {
      */
     refreshFromDb(): any;
     /**
-     * Getter that always returns the current value from the store
+     * Returns the current metric value from the store.
+     * Called implicitly by JS when coercing to a primitive (arithmetic, template literals, etc.)
      */
+    valueOf(): any;
+    toString(): string;
+    /** @deprecated Use valueOf() coercion instead (e.g. +metric, `${metric}`, metric + 0) */
     get value(): any;
 }
 /**

package/dist/syncEngine/registries/metricRegistry.js

@@ -5,8 +5,15 @@ import { QueryExecutor } from '../../flavours/django/queryExecutor.js';
 import { wrapReactiveMetric } from '../../reactiveAdaptor.js';
 import hash from 'object-hash';
 /**
- * LiveMetric, a simple wrapper that always returns the latest metric value
- * using a getter for the value property
+ * LiveMetric wraps a metric scalar (count, sum, etc.) and stays live.
+ *
+ * Uses valueOf()/toString() so it coerces to the scalar naturally:
+ *   count + 0    // → 5
+ *   `${count}`   // → "5"
+ *   count > 3    // → true
+ *
+ * Note: typeof returns "object" and === compares identity, not value.
+ * Use == for loose comparison, or +metric for explicit coercion.
  */
 export class LiveMetric {
     constructor(queryset, metricType, field = null) {
@@ -26,17 +33,24 @@ export class LiveMetric {
         return store.sync(true);
     }
     /**
-     * Getter that always returns the current value from the store
+     * Returns the current metric value from the store.
+     * Called implicitly by JS when coercing to a primitive (arithmetic, template literals, etc.)
      */
-    get value() {
-        // Get the latest store from the registry
+    valueOf() {
         const store = metricRegistry.getStore(this.metricType, this.queryset, this.field);
         if (!store) {
             return null;
         }
-        // Render the current value
         return store.render();
     }
+    toString() {
+        const val = this.valueOf();
+        return val === null ? '' : String(val);
+    }
+    /** @deprecated Use valueOf() coercion instead (e.g. +metric, `${metric}`, metric + 0) */
+    get value() {
+        return this.valueOf();
+    }
 }
 /**
  * Registry to manage metric stores

package/dist/syncEngine/stores/querysetStore.js

@@ -46,11 +46,17 @@ export class QuerysetStore {
         return this.queryset.semanticKey;
     }
     onHydrated(hydratedData) {
-        if (this.groundTruthPks.length === 0 && this.operationsMap.size === 0) {
-            const cached = this.qsCache.get(this.cacheKey);
-            if (!isNil(cached) && !isEmpty(cached)) {
-                this.setGroundTruth(cached);
-            }
+        // Only use cached data if we haven't synced yet and have no ground truth.
+        // This prevents stale cache from overwriting real server data.
+        if (this.lastSync !== null)
+            return;
+        if (this.groundTruthPks.length > 0 || this.operationsMap.size > 0)
+            return;
+        const cached = this.qsCache.get(this.cacheKey);
+        if (!isNil(cached) && !isEmpty(cached)) {
+            // Set ground truth WITHOUT updating lastSync — hydration is not a real sync
+            this.groundTruthPks = Array.isArray(cached) ? cached : [];
+            this._emitRenderEvent();
         }
     }
     setCache(result) {
@@ -207,7 +213,13 @@ export class QuerysetStore {
         // If no ground truth AND hasn't been synced, render from model store
         // This handles chained optimistic filters, newly created stores, etc.
         // (If synced with empty results, that's valid ground truth)
-        const pks = this.groundTruthPks.length === 0 && this.lastSync === null
+        // Skip model store seeding for paginated querysets (offset > 0) — the model
+        // store contains items from other pages, so seeding would show wrong results.
+        const offset = this.queryset.build().serializerOptions?.offset;
+        const canSeedFromModelStore = this.groundTruthPks.length === 0
+            && this.lastSync === null
+            && !(offset != null && offset > 0);
+        const pks = canSeedFromModelStore
             ? this.renderFromModelStore()
             : this.renderFromData(optimistic);
         // Validate against model store and apply local filtering/sorting

package/package.json

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