@statezero/core 0.2.37 → 0.2.38

package/dist/syncEngine/stores/metricStore.js

@@ -1,222 +0,0 @@
-import { Cache } from '../cache/cache.js';
-import { MetricStrategyFactory } from "../metrics/metricOptCalcs.js";
-import hash from 'object-hash';
-import { isNil, isEmpty, isEqual } from 'lodash-es';
-import { metricEventEmitter } from './reactivity.js';
-import { Status } from './operation.js';
-/**
- * Store for managing a single metric with optimistic updates
- */
-export class MetricStore {
-    constructor(metricType, modelClass, queryset, field = null, ast = null, fetchFn) {
-        this.metricType = metricType;
-        this.modelClass = modelClass;
-        this.queryset = queryset;
-        this.field = field;
-        this.ast = ast;
-        this.fetchFn = fetchFn;
-        this.groundTruthValue = null;
-        this.isSyncing = false;
-        this.strategy = MetricStrategyFactory.getStrategy(metricType, modelClass);
-        // Store operations related to this metric
-        this.operations = [];
-        // Keep track of which operations have been confirmed
-        this.confirmedOps = new Set();
-        // Initialize cache with AST-specific key
-        this.metricCache = new Cache("metric-store-cache", {}, this.onHydrated.bind(this));
-        // Initialize _lastCalculatedValue
-        this._lastCalculatedValue = null;
-    }
-    reset() {
-        this.groundTruthValue = null;
-        this._lastCalculatedValue = null;
-        this.operations = [];
-        this.confirmedOps = new Set();
-        this.isSyncing = false;
-        this.clearCache();
-    }
-    get cacheKey() {
-        return `${this.modelClass.configKey}::${this.modelClass.modelName}::metric::${this.metricType}::${this.field || "null"}::${this.ast ? hash(this.ast) : "global"}`;
-    }
-    /**
-     * Add an operation to this metric store
-     * @param {Operation} operation - The operation to add
-     */
-    addOperation(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Check if operation already exists to avoid duplicates
-        const existingIndex = this.operations.findIndex((op) => op.operationId === operation.operationId);
-        if (existingIndex !== -1) {
-            // Update existing operation instead of adding a duplicate
-            this.operations[existingIndex] = operation;
-        }
-        else {
-            // Add to our operations list
-            this.operations.push(operation);
-        }
-        // Trigger a render to update the metric value
-        if (!isNil(this.groundTruthValue)) {
-            this.render();
-        }
-    }
-    /**
-     * Update an operation in this metric store
-     * @param {Operation} operation - The operation to update
-     */
-    updateOperation(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Find and update the operation - use operationId not id
-        const index = this.operations.findIndex((op) => op.operationId === operation.operationId);
-        if (index !== -1) {
-            this.operations[index] = operation;
-        }
-        else {
-            // If not found, add it
-            this.operations.push(operation);
-        }
-        // Trigger a render to update the metric value
-        if (!isNil(this.groundTruthValue)) {
-            this.render();
-        }
-    }
-    /**
-     * Confirm an operation in this metric store
-     * @param {Operation} operation - The operation to confirm
-     */
-    confirm(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Update operation status in our list and mark as confirmed - use operationId not id
-        const index = this.operations.findIndex((op) => op.operationId === operation.operationId);
-        if (index !== -1) {
-            this.operations[index] = operation;
-            this.confirmedOps.add(operation.operationId);
-        }
-        // Trigger a sync to update ground truth
-        this.render();
-    }
-    /**
-     * Reject an operation in this metric store
-     * @param {Operation} operation - The operation to reject
-     */
-    reject(operation) {
-        // Only track operations for this model
-        if (operation.queryset.ModelClass !== this.modelClass) {
-            return;
-        }
-        // Remove the operation as it's now rejected - use operationId not id
-        this.operations = this.operations.filter((op) => op.operationId !== operation.operationId);
-        this.confirmedOps.delete(operation.operationId);
-        // Trigger a render to update the metric value
-        if (!isNil(this.groundTruthValue)) {
-            this.render();
-        }
-    }
-    onHydrated() {
-        if (this.groundTruthValue === null) {
-            const cached = this.metricCache.get(this.cacheKey);
-            if (!isNil(cached) && !isEmpty(cached)) {
-                console.log(`[MetricStore] Hydrated ${this.metricType} metric for ${this.modelClass.modelName} from cache`);
-                this.setGroundTruth(cached?.value);
-            }
-        }
-    }
-    setCache() {
-        let groundTruthValue = this.groundTruthValue;
-        let serializedGroundTruth = groundTruthValue?.value
-            ? groundTruthValue.value
-            : groundTruthValue;
-        this.metricCache.set(this.cacheKey, {
-            value: serializedGroundTruth,
-        });
-    }
-    clearCache() {
-        this.metricCache.delete(this.cacheKey);
-    }
-    setGroundTruth(value) {
-        // Check if the value has actually changed
-        const valueChanged = !isEqual(this.groundTruthValue, value);
-        this.groundTruthValue = value;
-        this.setCache();
-        // Only emit event if the value changed
-        if (valueChanged) {
-            metricEventEmitter.emit("metric::render", {
-                metricType: this.metricType,
-                ModelClass: this.modelClass,
-                field: this.field,
-                ast: hash(this.ast),
-                valueChanged: true,
-            });
-        }
-    }
-    /**
-     * Render the metric with current operations
-     * @returns {any} Calculated metric value
-     */
-    render() {
-        // Check if ground truth value is null
-        if (isNil(this.groundTruthValue)) {
-            console.log(`groundTruthValue is null, returning null`);
-            return null;
-        }
-        // Calculate the new value using the operations-based approach
-        const newValue = this.strategy.calculateWithOperations(this.groundTruthValue, this.operations, this.field, this.modelClass);
-        // Check if the value has actually changed
-        if (!isEqual(this._lastCalculatedValue, newValue)) {
-            this._lastCalculatedValue = newValue;
-            // Only emit event if the value changed
-            metricEventEmitter.emit("metric::render", {
-                metricType: this.metricType,
-                ModelClass: this.modelClass,
-                field: this.field,
-                ast: hash(this.ast),
-                valueChanged: true,
-            });
-        }
-        return newValue;
-    }
-    /**
-     * Sync metric with server
-     */
-    async sync() {
-        if (this.isSyncing) {
-            console.warn(`[MetricStore] Already syncing ${this.metricType} for ${this.modelClass.modelName}`);
-            return;
-        }
-        this.isSyncing = true;
-        try {
-            console.log(`[MetricStore] Syncing ${this.metricType} metric for ${this.modelClass.modelName}`);
-            // Use fetchFn to get server metric value
-            const result = await this.fetchFn({
-                metricType: this.metricType,
-                modelClass: this.modelClass,
-                field: this.field,
-                ast: this.ast,
-            });
-            // After syncing, remove all confirmed operations
-            if (this.confirmedOps.size > 0) {
-                this.operations = this.operations.filter((op) => !this.confirmedOps.has(op.operationId));
-                this.confirmedOps.clear();
-            }
-            // Update ground truth
-            this.setGroundTruth(result);
-            console.log(`[MetricStore] Synced ${this.metricType} metric with value:`, result);
-            return result;
-        }
-        catch (error) {
-            console.error(`[MetricStore] Failed to sync ${this.metricType} metric:`, error);
-            return null;
-        }
-        finally {
-            this.isSyncing = false;
-        }
-    }
-}

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

@@ -1,53 +0,0 @@
-export class ModelStore {
-    constructor(modelClass: any, fetchFn: any, initialGroundTruth?: null, initialOperations?: null, options?: {});
-    modelClass: any;
-    fetchFn: any;
-    groundTruthArray: never[];
-    operationsMap: Map<any, any>;
-    isSyncing: boolean;
-    pruneThreshold: any;
-    modelCache: Cache;
-    _lastRenderedData: Map<any, any>;
-    renderCallbacks: Set<any>;
-    _unsubscribeTempPk: Function;
-    registerRenderCallback(callback: any): () => boolean;
-    /**
-     * Load operations from data and add them to the operations map,
-     * reusing existing operations from the registry if they exist
-     */
-    _loadOperations(operationsData: any): void;
-    get cacheKey(): string;
-    onHydrated(): void;
-    setCache(result: any): void;
-    clearCache(): void;
-    updateCache(items: any, requestedPks: any): void;
-    get operations(): any[];
-    get pkField(): any;
-    addOperation(operation: any): void;
-    updateOperation(operation: any): boolean;
-    confirm(operation: any): void;
-    reject(operation: any): void;
-    setOperations(operations?: any[]): void;
-    setGroundTruth(groundTruth: any): void;
-    getGroundTruth(): never[];
-    get groundTruthPks(): never[];
-    addToGroundTruth(instances: any): void;
-    _filteredOperations(pks: any, operations: any): any;
-    _filteredGroundTruth(pks: any, groundTruthArray: any): Map<any, any>;
-    applyOperation(operation: any, currentInstances: any): any;
-    getTrimmedOperations(): any[];
-    getInflightOperations(): any[];
-    prune(): void;
-    /**
-     * Prune model instances that aren't referenced by any queryset store.
-     * This prevents unbounded cache growth from included nested models.
-     *
-     * @param {QuerysetStoreRegistry} querysetStoreRegistry - The registry to check for queryset references
-     */
-    pruneUnreferencedInstances(querysetStoreRegistry: QuerysetStoreRegistry): void;
-    render(pks?: null, optimistic?: boolean, useCache?: boolean): any;
-    _renderFromCache(pks: any): any;
-    _renderFresh(pks?: null, optimistic?: boolean): any[];
-    sync(pks?: null): Promise<void>;
-}
-import { Cache } from '../cache/cache.js';