@statezero/core 0.1.32 → 0.1.34

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

@@ -1,2 +1 @@
 export function useQueryset(querysetFactory: any): any;
-export const querysets: Map<any, any>;

package/dist/adaptors/react/composables.js

@@ -1,56 +1,4 @@
-import { useState, useEffect, useRef } from "react";
-import { syncManager } from "../../syncEngine/sync";
-import { v7 } from "uuid";
-syncManager.followAllQuerysets = false;
-export const querysets = new Map(); // Map of composableId -> queryset
-function updateSyncManager() {
-    // Get unique querysets from all active composables
-    const uniqueQuerysets = new Set(querysets.values());
-    syncManager.followedQuerysets = uniqueQuerysets;
-}
 export function useQueryset(querysetFactory) {
-    const composableIdRef = useRef(v7());
-    const lastQuerysetRef = useRef(null);
-    const lastSemanticKeyRef = useRef(null);
-    const [, forceUpdate] = useState(0);
-    // Generate the queryset
-    const result = querysetFactory();
-    const original = result?.original || result;
-    const queryset = original?.queryset || original;
-    // Update tracking if queryset changed (compare by semantic key for stability)
-    const semanticKey = queryset?.semanticKey;
-    const lastSemanticKeyRef = useRef(null);
-    useEffect(() => {
-        if (lastSemanticKeyRef.current !== semanticKey) {
-            querysets.set(composableIdRef.current, queryset);
-            updateSyncManager();
-            lastSemanticKeyRef.current = semanticKey;
-            lastQuerysetRef.current = queryset;
-        }
-    }, [semanticKey, queryset]);
-    // Cleanup on unmount
-    useEffect(() => {
-        const composableId = composableIdRef.current;
-        return () => {
-            querysets.delete(composableId);
-            updateSyncManager();
-        };
-    }, []);
-    // Force re-render when queryset updates
-    useEffect(() => {
-        if (!result)
-            return;
-        // This will be triggered by the QuerySetAdaptor when data changes
-        const handleUpdate = () => {
-            forceUpdate((x) => x + 1);
-        };
-        // Attach update listener to the wrapped queryset (unconditionally)
-        result._reactUpdateHandler = handleUpdate;
-        return () => {
-            if (result) {
-                result._reactUpdateHandler = null;
-            }
-        };
-    }, [result]);
-    return result;
+    console.warn("React environments are not currently supported");
+    return querysetFactory;
 }

package/dist/adaptors/react/index.d.ts

@@ -1,2 +1 @@
-export { useQueryset, querysets } from "./composables.js";
-export { ModelAdaptor, QuerySetAdaptor, MetricAdaptor } from "./reactivity.js";
+export { useQueryset } from "./composables.js";

package/dist/adaptors/react/index.js

@@ -1,5 +1 @@
-export { useQueryset, querysets } from "./composables.js";
-export { ModelAdaptor, QuerySetAdaptor, MetricAdaptor } from "./reactivity.js";
-// src/react-entry.js
-import { ModelAdaptor, QuerySetAdaptor, MetricAdaptor, useQueryset, querysets, } from "./adaptors/react/index.js";
-export { ModelAdaptor, QuerySetAdaptor, MetricAdaptor, useQueryset, querysets };
+export { useQueryset } from './composables.js';

package/dist/adaptors/vue/reactivity.js

@@ -57,7 +57,17 @@ export function QuerySetAdaptor(liveQuerySet, reactivityFn = reactive) {
     const cacheKey = queryset.semanticKey;
     // Check the cache first
     if (cacheKey && wrappedQuerysetCache.has(cacheKey)) {
-        return wrappedQuerysetCache.get(cacheKey);
+        const cachedWrapper = wrappedQuerysetCache.get(cacheKey);
+        // Refresh the cached wrapper with current data
+        const freshData = [...liveQuerySet];
+        if (reactivityFn === ref) {
+            cachedWrapper.value = freshData;
+        }
+        else {
+            cachedWrapper.splice(0, cachedWrapper.length);
+            cachedWrapper.push(...freshData);
+        }
+        return cachedWrapper;
     }
     const querysetAst = queryset.build();
     // Make the queryset reactive using the specified function
@@ -79,10 +89,10 @@ export function QuerySetAdaptor(liveQuerySet, reactivityFn = reactive) {
     // Subscribe to queryset events indefinitely
     querysetEventEmitter.on(eventName, renderHandler);
     /* Dont delete the innocuous looking queryset.length check. There is some weird interaction
-    with vue, where when we load an empty queryset from the cache, the reactivity completely breaks.
-    I wasted over 2 days on this bug, and it won't show up in the e2e tests because it just impacts the
-    vue reactivity. If this causes performance issues, and needs to be refactored. Make sure you understand
-    the vue reactivity interaction correctly and find a different way to fix the broken reactivity for empty querysets */
+      with vue, where when we load an empty queryset from the cache, the reactivity completely breaks.
+      I wasted over 2 days on this bug, and it won't show up in the e2e tests because it just impacts the
+      vue reactivity. If this causes performance issues, and needs to be refactored. Make sure you understand
+      the vue reactivity interaction correctly and find a different way to fix the broken reactivity for empty querysets */
     if (cacheKey && liveQuerySet && liveQuerySet.length > 0) {
         wrappedQuerysetCache.set(cacheKey, wrapper);
     }
@@ -98,7 +108,10 @@ export function MetricAdaptor(metric) {
     const cacheKey = `${configKey}::${modelName}::${metric.metricType}::${metric.field}::${hash(querysetAst)}`;
     // Check the cache first
     if (cacheKey && wrappedMetricCache.has(cacheKey)) {
-        return wrappedMetricCache.get(cacheKey);
+        const cachedWrapper = wrappedMetricCache.get(cacheKey);
+        // Refresh the cached wrapper with current metric value
+        cachedWrapper.value = metric.value;
+        return cachedWrapper;
     }
     // Create a reactive reference with the initial value
     const wrapper = ref(metric.value);
@@ -116,7 +129,7 @@ export function MetricAdaptor(metric) {
         }
     };
     // Only listen for metric render events
-    metricEventEmitter.on('metric::render', metricRenderHandler);
+    metricEventEmitter.on("metric::render", metricRenderHandler);
     // Store in cache
     if (cacheKey) {
         wrappedMetricCache.set(cacheKey, wrapper);

package/package.json

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

package/dist/adaptors/react/reactivity.d.ts

@@ -1,22 +0,0 @@
-/**
- * Adapts a model instance for React by wrapping it with event listeners
- * that trigger React re-renders when the model updates.
- *
- * @param {Object} modelInstance - An instance of a model class with static modelName and primaryKeyField
- * @returns {Object} The model instance with React update capabilities
- */
-export function ModelAdaptor(modelInstance: Object): Object;
-/**
- * Adapts a queryset for React and sets up event handling for queryset updates
- *
- * @param {Object} liveQuerySet - A LiveQueryset instance
- * @returns {Array} The reactive queryset array
- */
-export function QuerySetAdaptor(liveQuerySet: Object): any[];
-/**
- * Adapts a metric for React and sets up event handling for metric updates
- *
- * @param {Object} metric - A metric instance
- * @returns {Object} The reactive metric wrapper
- */
-export function MetricAdaptor(metric: Object): Object;

package/dist/adaptors/react/reactivity.js

@@ -1,145 +0,0 @@
-import { modelEventEmitter, querysetEventEmitter, metricEventEmitter, } from "../../syncEngine/stores/reactivity.js";
-import { initEventHandler } from "../../syncEngine/stores/operationEventHandlers.js";
-import { isEqual, isNil } from "lodash-es";
-import hash from "object-hash";
-initEventHandler(); // Initialize event handler for model events
-const wrappedQuerysetCache = new Map();
-const wrappedMetricCache = new Map();
-/**
- * Adapts a model instance for React by wrapping it with event listeners
- * that trigger React re-renders when the model updates.
- *
- * @param {Object} modelInstance - An instance of a model class with static modelName and primaryKeyField
- * @returns {Object} The model instance with React update capabilities
- */
-export function ModelAdaptor(modelInstance) {
-    const modelClass = modelInstance.constructor;
-    const modelName = modelClass.modelName;
-    const configKey = modelClass.configKey;
-    const pkField = modelClass.primaryKeyField;
-    // Create a wrapper that maintains the original instance
-    const wrapper = Object.create(modelInstance);
-    wrapper._reactUpdateHandler = null;
-    wrapper._reactVersion = 0;
-    const eventName = `${configKey}::${modelName}::render`;
-    // Handler triggers React update when this instance updates
-    const renderHandler = (eventData) => {
-        if (eventData.pk === modelInstance[pkField]) {
-            wrapper._reactVersion++;
-            if (wrapper._reactUpdateHandler) {
-                wrapper._reactUpdateHandler();
-            }
-        }
-    };
-    // Subscribe to model events indefinitely
-    modelEventEmitter.on(eventName, renderHandler);
-    // Store the cleanup function
-    wrapper._cleanup = () => {
-        modelEventEmitter.off(eventName, renderHandler);
-    };
-    return wrapper;
-}
-/**
- * Adapts a queryset for React and sets up event handling for queryset updates
- *
- * @param {Object} liveQuerySet - A LiveQueryset instance
- * @returns {Array} The reactive queryset array
- */
-export function QuerySetAdaptor(liveQuerySet) {
-    const queryset = liveQuerySet?.queryset;
-    const modelName = queryset?.ModelClass?.modelName;
-    const configKey = queryset?.ModelClass?.configKey;
-    if (isNil(queryset) || isNil(modelName)) {
-        throw new Error(`liveQuerySet ${JSON.stringify(liveQuerySet)} had null qs: ${queryset} or model: ${modelName}`);
-    }
-    // Use the semantic key if available
-    const cacheKey = queryset.semanticKey;
-    // Check the cache first
-    if (cacheKey && wrappedQuerysetCache.has(cacheKey)) {
-        return wrappedQuerysetCache.get(cacheKey);
-    }
-    const querysetAst = queryset.build();
-    // Create wrapper array that extends the live queryset
-    const wrapper = [...liveQuerySet];
-    wrapper.original = liveQuerySet;
-    wrapper._reactUpdateHandler = null;
-    wrapper._reactVersion = 0;
-    const eventName = `${configKey}::${modelName}::queryset::render`;
-    // Handler updates array and triggers React update when this queryset updates
-    const renderHandler = (eventData) => {
-        if (eventData && eventData.ast && isEqual(querysetAst, eventData.ast)) {
-            // Update the wrapper array
-            wrapper.length = 0;
-            wrapper.push(...liveQuerySet);
-            wrapper._reactVersion++;
-            // Trigger React update if handler is set
-            if (wrapper._reactUpdateHandler) {
-                wrapper._reactUpdateHandler();
-            }
-        }
-    };
-    // Subscribe to queryset events indefinitely
-    querysetEventEmitter.on(eventName, renderHandler);
-    // Store cleanup function
-    wrapper._cleanup = () => {
-        querysetEventEmitter.off(eventName, renderHandler);
-    };
-    // Cache if not empty (following Vue's pattern for stability)
-    if (cacheKey && liveQuerySet && liveQuerySet.length > 0) {
-        wrappedQuerysetCache.set(cacheKey, wrapper);
-    }
-    return wrapper;
-}
-/**
- * Adapts a metric for React and sets up event handling for metric updates
- *
- * @param {Object} metric - A metric instance
- * @returns {Object} The reactive metric wrapper
- */
-export function MetricAdaptor(metric) {
-    const queryset = metric.queryset;
-    const modelName = queryset?.ModelClass?.modelName;
-    const configKey = queryset?.ModelClass?.configKey;
-    const querysetAst = queryset.build();
-    // Create a cache key based on metric properties
-    const cacheKey = `${configKey}::${modelName}::${metric.metricType}::${metric.field}::${hash(querysetAst)}`;
-    // Check the cache first
-    if (cacheKey && wrappedMetricCache.has(cacheKey)) {
-        return wrappedMetricCache.get(cacheKey);
-    }
-    // Create a wrapper object that maintains the metric value
-    const wrapper = {
-        value: metric.value,
-        original: metric,
-        _reactUpdateHandler: null,
-        _reactVersion: 0,
-    };
-    // Single handler for metric render events
-    const metricRenderHandler = (eventData) => {
-        // Only update if this event is for our metric
-        if (eventData.metricType === metric.metricType &&
-            eventData.ModelClass === metric.queryset.ModelClass &&
-            eventData.field === metric.field &&
-            eventData.ast === hash(querysetAst) &&
-            eventData.valueChanged === true) {
-            // Update the wrapper value with the latest metric value
-            wrapper.value = metric.value;
-            wrapper._reactVersion++;
-            // Trigger React update if handler is set
-            if (wrapper._reactUpdateHandler) {
-                wrapper._reactUpdateHandler();
-            }
-        }
-    };
-    // Only listen for metric render events
-    metricEventEmitter.on("metric::render", metricRenderHandler);
-    // Store cleanup function
-    wrapper._cleanup = () => {
-        metricEventEmitter.off("metric::render", metricRenderHandler);
-    };
-    // Store in cache
-    if (cacheKey) {
-        wrappedMetricCache.set(cacheKey, wrapper);
-    }
-    return wrapper;
-}