@statezero/core 0.1.2 → 0.1.3-9.1

package/dist/syncEngine/stores/querysetStore.js

@@ -1,18 +1,24 @@
 import { Operation, Status, Type, operationRegistry } from './operation.js';
 import { querysetEventEmitter } from './reactivity.js';
-import { isNil, isEmpty, trim } from 'lodash-es';
+import { isNil, isEmpty, trim, isEqual } from 'lodash-es';
 import { replaceTempPks, containsTempPk } from '../../flavours/django/tempPk.js';
 import { modelStoreRegistry } from '../registries/modelStoreRegistry.js';
 import { processIncludedEntities } from '../../flavours/django/makeApiCall.js';
 import hash from 'object-hash';
 import { Cache } from '../cache/cache.js';
+import { filter } from "../../filtering/localFiltering.js";
+import { mod } from 'mathjs';
 export class QuerysetStore {
     constructor(modelClass, fetchFn, queryset, initialGroundTruthPks = null, initialOperations = null, options = {}) {
         this.modelClass = modelClass;
         this.fetchFn = fetchFn;
         this.queryset = queryset;
         this.isSyncing = false;
+        this.lastSync = null;
+        this.needsSync = false;
+        this.isTemp = options.isTemp || false;
         this.pruneThreshold = options.pruneThreshold || 10;
+        this.getRootStore = options.getRootStore || null;
         this.groundTruthPks = initialGroundTruthPks || [];
         this.operationsMap = new Map();
         if (Array.isArray(initialOperations)) {
@@ -22,7 +28,12 @@ export class QuerysetStore {
                 this.operationsMap.set(op.operationId, op);
             }
         }
-        this.qsCache = new Cache('queryset-cache', {}, this.onHydrated.bind(this));
+        this.qsCache = new Cache("queryset-cache", {}, this.onHydrated.bind(this));
+        this._lastRenderedPks = null;
+        this.renderCallbacks = new Set();
+        this._rootUnregister = null;
+        this._currentRootStore = null;
+        this._ensureRootRegistration();
     }
     // Caching
     get cacheKey() {
@@ -40,7 +51,7 @@ export class QuerysetStore {
     setCache(result) {
         let nonTempPks = [];
         result.forEach((pk) => {
-            if (typeof pk === 'string' && containsTempPk(pk)) {
+            if (typeof pk === "string" && containsTempPk(pk)) {
                 pk = replaceTempPks(pk);
                 if (isNil(pk) || isEmpty(trim(pk))) {
                     return;
@@ -64,7 +75,22 @@ export class QuerysetStore {
         return new Set(this.groundTruthPks);
     }
     _emitRenderEvent() {
-        querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+        const newPks = this.render(true, false);
+        // 1. Always notify direct child stores to trigger their own re-evaluation.
+        //    They will perform their own check to see if their own results have changed.
+        this.renderCallbacks.forEach((callback) => {
+            try {
+                callback();
+            }
+            catch (error) {
+                console.warn("Error in render callback:", error);
+            }
+        });
+        // 2. Only emit the global event for UI components if the final list of PKs has actually changed.
+        if (!isEqual(newPks, this._lastRenderedPks)) {
+            this._lastRenderedPks = newPks; // Update the cache with the new state
+            querysetEventEmitter.emit(`${this.modelClass.configKey}::${this.modelClass.modelName}::queryset::render`, { ast: this.queryset.build(), ModelClass: this.modelClass });
+        }
     }
     async addOperation(operation) {
         this.operationsMap.set(operation.operationId, operation);
@@ -93,9 +119,7 @@ export class QuerysetStore {
         this._emitRenderEvent();
     }
     async setGroundTruth(groundTruthPks) {
-        this.groundTruthPks = Array.isArray(groundTruthPks)
-            ? groundTruthPks
-            : [];
+        this.groundTruthPks = Array.isArray(groundTruthPks) ? groundTruthPks : [];
         this._emitRenderEvent();
     }
     async setOperations(operations) {
@@ -109,10 +133,10 @@ export class QuerysetStore {
     }
     getTrimmedOperations() {
         const cutoff = Date.now() - 1000 * 60 * 2;
-        return this.operations.filter(op => op.timestamp > cutoff);
+        return this.operations.filter((op) => op.timestamp > cutoff);
     }
     getInflightOperations() {
-        return this.operations.filter(operation => operation.status != Status.CONFIRMED &&
+        return this.operations.filter((operation) => operation.status != Status.CONFIRMED &&
             operation.status != Status.REJECTED);
     }
     prune() {
@@ -120,20 +144,68 @@ export class QuerysetStore {
         this.setGroundTruth(renderedPks);
         this.setOperations(this.getInflightOperations());
     }
+    registerRenderCallback(callback) {
+        this.renderCallbacks.add(callback);
+        return () => this.renderCallbacks.delete(callback);
+    }
+    _ensureRootRegistration() {
+        if (this.isTemp)
+            return;
+        const { isRoot, rootStore } = this.getRootStore(this.queryset);
+        // If the root store hasn't changed, nothing to do
+        if (this._currentRootStore === rootStore) {
+            return;
+        }
+        // Root store changed - clean up old registration if it exists
+        if (this._rootUnregister) {
+            this._rootUnregister();
+            this._rootUnregister = null;
+        }
+        // Set up new registration if we're derived and have a root store
+        if (!isRoot && rootStore) {
+            this._rootUnregister = rootStore.registerRenderCallback(() => {
+                this._emitRenderEvent();
+            });
+        }
+        // Update current root store reference (could be null now)
+        this._currentRootStore = rootStore;
+    }
+    /**
+     * Helper to validate PKs against the model store and apply local filtering/sorting.
+     * This is the core of the rendering logic.
+     * @private
+     */
+    _getValidatedAndFilteredPks(pks) {
+        // 1. Convert PKs to instances, filtering out any that are null (deleted).
+        const instances = Array.from(pks)
+            .map((pk) => this.modelClass.fromPk(pk, this.queryset))
+            .filter((instance) => modelStoreRegistry.getEntity(this.modelClass, instance.pk) !== null);
+        // 2. Apply the queryset's AST (filters, ordering) to the validated instances.
+        const ast = this.queryset.build();
+        const finalPks = filter(instances, ast, this.modelClass, false); // false = return PKs
+        return finalPks;
+    }
     render(optimistic = true, fromCache = false) {
+        this._ensureRootRegistration();
         if (fromCache) {
             const cachedResult = this.qsCache.get(this.cacheKey);
             if (Array.isArray(cachedResult)) {
                 return cachedResult;
             }
         }
-        const renderedPks = this.groundTruthSet;
-        for (const op of this.operations) {
-            if (op.status !== Status.REJECTED && (optimistic || op.status === Status.CONFIRMED)) {
-                this.applyOperation(op, renderedPks);
+        let pks;
+        if (this.getRootStore &&
+            typeof this.getRootStore === "function" &&
+            !this.isTemp) {
+            const { isRoot, rootStore } = this.getRootStore(this.queryset);
+            if (!isRoot && rootStore) {
+                pks = this.renderFromRoot(optimistic, rootStore);
             }
         }
-        let result = Array.from(renderedPks);
+        if (isNil(pks)) {
+            pks = this.renderFromData(optimistic);
+        }
+        let result = this._getValidatedAndFilteredPks(pks);
         let limit = this.queryset.build().serializerOptions?.limit;
         if (limit) {
             result = result.slice(0, limit);
@@ -141,12 +213,30 @@ export class QuerysetStore {
         this.setCache(result);
         return result;
     }
+    renderFromRoot(optimistic = true, rootStore) {
+        let renderedPks = rootStore.render(optimistic);
+        let renderedData = renderedPks.map((pk) => {
+            return this.modelClass.fromPk(pk, this.queryset);
+        });
+        let ast = this.queryset.build();
+        let result = filter(renderedData, ast, this.modelClass, false);
+        return result;
+    }
+    renderFromData(optimistic = true) {
+        const renderedPks = this.groundTruthSet;
+        for (const op of this.operations) {
+            if (op.status !== Status.REJECTED &&
+                (optimistic || op.status === Status.CONFIRMED)) {
+                this.applyOperation(op, renderedPks);
+            }
+        }
+        let result = Array.from(renderedPks);
+        return result;
+    }
     applyOperation(operation, currentPks) {
         const pkField = this.pkField;
         for (const instance of operation.instances) {
-            if (!instance ||
-                typeof instance !== 'object' ||
-                !(pkField in instance)) {
+            if (!instance || typeof instance !== "object" || !(pkField in instance)) {
                 console.warn(`[QuerysetStore ${this.modelClass.modelName}] Skipping instance in operation ${operation.operationId} due to missing PK '${String(pkField)}' or invalid format.`);
                 continue;
             }
@@ -175,23 +265,44 @@ export class QuerysetStore {
             console.warn(`[QuerysetStore ${id}] Already syncing, request ignored.`);
             return;
         }
+        // Check if we're delegating to a root store
+        if (this.getRootStore &&
+            typeof this.getRootStore === "function" &&
+            !this.isTemp) {
+            const { isRoot, rootStore } = this.getRootStore(this.queryset);
+            if (!isRoot && rootStore) {
+                // We're delegating to a root store - don't sync, just mark as needing sync
+                console.log(`[${id}] Delegating to root store, marking sync needed.`);
+                this.needsSync = true;
+                this.lastSync = null; // Clear last sync since we're not actually syncing
+                this.setOperations(this.getInflightOperations());
+                return;
+            }
+        }
+        // We're in independent mode - proceed with normal sync
         this.isSyncing = true;
         console.log(`[${id}] Starting sync...`);
         try {
             const response = await this.fetchFn({
                 ast: this.queryset.build(),
-                modelClass: this.modelClass
+                modelClass: this.modelClass,
             });
             const { data, included } = response;
+            if (isNil(data)) {
+                return;
+            }
             console.log(`[${id}] Sync fetch completed. Received: ${JSON.stringify(data)}.`);
             // Persists all the instances (including nested instances) to the model store
             processIncludedEntities(modelStoreRegistry, included, this.modelClass);
             this.setGroundTruth(data);
             this.setOperations(this.getInflightOperations());
+            this.lastSync = Date.now();
+            this.needsSync = false;
             console.log(`[${id}] Sync completed.`);
         }
         catch (e) {
             console.error(`[${id}] Failed to sync ground truth:`, e);
+            this.needsSync = true; // Mark as needing sync on error
         }
         finally {
             this.isSyncing = false;

package/dist/syncEngine/sync.d.ts

@@ -15,10 +15,15 @@ export class SyncManager {
     followedModels: Map<any, any>;
     followAllQuerysets: boolean;
     followedQuerysets: Map<any, any>;
+    periodicSyncTimer: NodeJS.Timeout | null;
     /**
      * Initialize event handlers for all event receivers
      */
     initialize(): void;
+    startPeriodicSync(): void;
+    syncStaleQuerysets(): void;
+    isStoreFollowed(registry: any, semanticKey: any): boolean;
+    cleanup(): void;
     followModel(registry: any, modelClass: any): void;
     unfollowModel(registry: any, modelClass: any): void;
     manageRegistry(registry: any): void;

package/dist/syncEngine/sync.js

@@ -58,6 +58,7 @@ export class SyncManager {
         // Map of querysets to keep synced
         this.followAllQuerysets = true;
         this.followedQuerysets = new Map();
+        this.periodicSyncTimer = null;
     }
     /**
      * Initialize event handlers for all event receivers
@@ -74,13 +75,68 @@ export class SyncManager {
                 receiver.addModelEventHandler(this.handleEvent.bind(this));
             }
         });
+        this.startPeriodicSync();
+    }
+    startPeriodicSync() {
+        if (this.periodicSyncTimer)
+            return;
+        try {
+            const config = getConfig();
+            const intervalSeconds = config.periodicSyncIntervalSeconds;
+            // If null or undefined, don't start periodic sync
+            if (!intervalSeconds) {
+                console.log("[SyncManager] Periodic sync disabled (set to null)");
+                return;
+            }
+            const intervalMs = intervalSeconds * 1000;
+            this.periodicSyncTimer = setInterval(() => {
+                this.syncStaleQuerysets();
+            }, intervalMs);
+            console.log(`[SyncManager] Periodic sync started: ${intervalSeconds}s intervals`);
+        }
+        catch (error) {
+            // If no config, don't start periodic sync by default
+            console.log("[SyncManager] No config found, periodic sync disabled by default");
+        }
+    }
+    syncStaleQuerysets() {
+        let syncedCount = 0;
+        // Sync all followed querysets - keep it simple
+        const querysetRegistry = this.registries.get("QuerysetStoreRegistry");
+        if (querysetRegistry) {
+            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) {
+                    store.sync();
+                    syncedCount++;
+                }
+            }
+        }
+        if (syncedCount > 0) {
+            console.log(`[SyncManager] Periodic sync: ${syncedCount} stores synced`);
+        }
+    }
+    isStoreFollowed(registry, semanticKey) {
+        const followingQuerysets = registry.followingQuerysets.get(semanticKey);
+        if (!followingQuerysets)
+            return false;
+        return [...followingQuerysets].some((queryset) => {
+            return this.isQuerysetFollowed(queryset);
+        });
+    }
+    cleanup() {
+        if (this.periodicSyncTimer) {
+            clearInterval(this.periodicSyncTimer);
+            this.periodicSyncTimer = null;
+        }
     }
     followModel(registry, modelClass) {
         const models = this.followedModels.get(registry) || new Set();
         this.followedModels.set(registry, models);
         if (models.has(modelClass))
             return;
-        const alreadyFollowed = [...this.followedModels.values()].some(set => set.has(modelClass));
+        const alreadyFollowed = [...this.followedModels.values()].some((set) => set.has(modelClass));
         models.add(modelClass);
         if (!alreadyFollowed) {
             getEventReceiver(modelClass.configKey)?.subscribe(modelClass.modelName, this.handleEvent);
@@ -91,7 +147,7 @@ export class SyncManager {
         if (!models)
             return;
         models.delete(modelClass);
-        const stillFollowed = [...this.followedModels.values()].some(set => set.has(modelClass));
+        const stillFollowed = [...this.followedModels.values()].some((set) => set.has(modelClass));
         if (!stillFollowed) {
             getEventReceiver(modelClass.configKey)?.unsubscribe(modelClass.modelName, this.handleEvent);
         }
@@ -104,10 +160,10 @@ export class SyncManager {
         this.registries.delete(registry.constructor.name);
     }
     isQuerysetFollowed(queryset) {
+        const activeSemanticKeys = new Set([...this.followedQuerysets].map((qs) => qs.semanticKey));
         let current = queryset;
-        // All followed querysets and their descendents get updated
         while (current) {
-            if (this.followedQuerysets.has(current)) {
+            if (activeSemanticKeys.has(current.semanticKey)) {
                 return true;
             }
             current = current.__parent;
@@ -127,7 +183,7 @@ export class SyncManager {
                 const followingQuerysets = registry.followingQuerysets.get(semanticKey);
                 if (followingQuerysets) {
                     // Use some() to break early when we find a match
-                    const shouldSync = [...followingQuerysets].some(queryset => {
+                    const shouldSync = [...followingQuerysets].some((queryset) => {
                         return this.isQuerysetFollowed(queryset);
                     });
                     if (shouldSync) {

package/package.json

@@ -1,123 +1,126 @@
-{
-  "name": "@statezero/core",
-  "version": "0.1.2",
-  "type": "module",
-  "module": "ESNext",
-  "description": "The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "statezero": "dist/cli/index.js"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    },
-    "./cli": {
-      "import": "./dist/cli/index.js",
-      "require": "./dist/cli/index.js"
-    },
-    "./react": {
-      "import": "./dist/react-entry.js",
-      "require": "./dist/react-entry.js"
-    },
-    "./vue": {
-      "import": "./dist/vue-entry.js",
-      "require": "./dist/vue-entry.js"
-    }
-  },
-  "scripts": {
-    "test": "vitest run --config=vitest.base.config.ts",
-    "test:e2e": "vitest run --config=vitest.sequential.config.ts tests/e2e",
-    "generate:test-apps": "ts-node scripts/generate-test-apps.js",
-    "test:adaptors": "playwright test tests/adaptors",
-    "test:coverage": "vitest run --coverage",
-    "build": "tsc",
-    "parse-queries": "node scripts/perfect-query-parser.js",
-    "sync-models": "node src/cli/index.js sync-models",
-    "sync-models:dev": "npx cross-env NODE_ENV=test npm run sync-models",
-    "clean": "npx rimraf dist",
-    "prepare": "npm run clean && npm run build",
-    "prepublishOnly": "npm run clean && npm run build"
-  },
-  "keywords": [
-    "typescript",
-    "orm",
-    "backend",
-    "frontend",
-    "database",
-    "sql",
-    "django",
-    "sqlalchemy",
-    "react",
-    "vue",
-    "svelte"
-  ],
-  "author": "Robert Herring <robert.herring@resipilot.com>",
-  "license": "SEE LICENSE IN LICENSE",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/state-zero/statezero-client.git"
-  },
-  "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
-  ],
-  "homepage": "https://www.statezero.dev",
-  "dependencies": {
-    "axios": "^1.7.9",
-    "cli-progress": "^3.12.0",
-    "cosmiconfig": "^9.0.0",
-    "cosmiconfig-typescript-loader": "^6.1.0",
-    "date-fns": "^4.1.0",
-    "dotenv": "^16.4.7",
-    "fs-extra": "^11.3.0",
-    "handlebars": "^4.7.8",
-    "idb": "^8.0.2",
-    "inquirer": "^12.4.2",
-    "lodash-es": "^4.17.21",
-    "luxon": "^3.6.1",
-    "mathjs": "^14.4.0",
-    "mitt": "^3.0.1",
-    "mobx": "^6.13.7",
-    "mobx-utils": "^6.1.0",
-    "object-hash": "^3.0.0",
-    "openapi-typescript": "^6.7.1",
-    "p-queue": "^8.1.0",
-    "pusher-js": "^8.4.0",
-    "rfdc": "^1.4.1",
-    "sift": "^17.1.3",
-    "superjson": "^2.2.2",
-    "uuid": "^11.1.0",
-    "yargs": "^17.7.2",
-    "zod": "^3.24.2"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.50.1",
-    "@types/cli-progress": "^3.11.6",
-    "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.13.1",
-    "@types/react": "^18.3.18",
-    "@types/yargs": "^17.0.32",
-    "@vitest/coverage-v8": "^3.0.5",
-    "fake-indexeddb": "^6.0.0",
-    "fast-glob": "^3.3.3",
-    "react": "^18.2.0",
-    "rimraf": "^5.0.5",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5",
-    "vue": "^3.2.0"
-  },
-  "publishConfig": {
-    "access": "restricted"
-  },
-  "bugs": {
-    "url": "https://github.com/state-zero/statezero-client/issues"
-  },
-  "directories": {
-    "test": "tests"
-  }
-}
+{
+  "name": "@statezero/core",
+  "version": "0.1.39.1",
+  "type": "module",
+  "module": "ESNext",
+  "description": "The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "statezero": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./cli": {
+      "import": "./dist/cli/index.js",
+      "require": "./dist/cli/index.js"
+    },
+    "./react": {
+      "import": "./dist/react-entry.js",
+      "require": "./dist/react-entry.js"
+    },
+    "./vue": {
+      "import": "./dist/vue-entry.js",
+      "require": "./dist/vue-entry.js"
+    }
+  },
+  "scripts": {
+    "test": "vitest run --config=vitest.base.config.ts",
+    "test:e2e": "vitest run --config=vitest.sequential.config.ts tests/e2e",
+    "generate:test-apps": "ts-node scripts/generate-test-apps.js",
+    "test:adaptors": "playwright test tests/adaptors",
+    "test:coverage": "vitest run --coverage",
+    "build": "tsc",
+    "parse-queries": "node scripts/perfect-query-parser.js",
+    "sync": "node src/cli/index.js sync",
+    "sync:dev": "npx cross-env NODE_ENV=test npm run sync",
+    "sync-models": "node src/cli/index.js sync-models",
+    "sync-models:dev": "npx cross-env NODE_ENV=test npm run sync-models",
+    "sync-actions": "node src/cli/index.js sync-actions",
+    "sync-actions:dev": "npx cross-env NODE_ENV=test npm run sync-actions",
+    "clean": "npx rimraf dist",
+    "prepare": "npm run clean && npm run build",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "typescript",
+    "orm",
+    "backend",
+    "frontend",
+    "database",
+    "sql",
+    "django",
+    "sqlalchemy",
+    "react",
+    "vue",
+    "svelte"
+  ],
+  "author": "Robert Herring <robert.herring@resipilot.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/state-zero/statezero-client.git"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "homepage": "https://www.statezero.dev",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "cli-progress": "^3.12.0",
+    "cosmiconfig": "^9.0.0",
+    "cosmiconfig-typescript-loader": "^6.1.0",
+    "date-fns": "^4.1.0",
+    "dotenv": "^16.4.7",
+    "fs-extra": "^11.3.0",
+    "graphlib": "^2.1.8",
+    "handlebars": "^4.7.8",
+    "idb": "^8.0.2",
+    "inquirer": "^12.4.2",
+    "lodash-es": "^4.17.21",
+    "luxon": "^3.6.1",
+    "mathjs": "^14.4.0",
+    "mitt": "^3.0.1",
+    "object-hash": "^3.0.0",
+    "openapi-typescript": "^6.7.1",
+    "p-queue": "^8.1.0",
+    "pusher-js": "^8.4.0",
+    "rfdc": "^1.4.1",
+    "sift": "^17.1.3",
+    "superjson": "^2.2.2",
+    "uuid": "^11.1.0",
+    "yargs": "^17.7.2",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.50.1",
+    "@types/cli-progress": "^3.11.6",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.13.1",
+    "@types/react": "^18.3.18",
+    "@types/yargs": "^17.0.32",
+    "@vitest/coverage-v8": "^3.0.5",
+    "fake-indexeddb": "^6.0.0",
+    "fast-glob": "^3.3.3",
+    "react": "^18.2.0",
+    "rimraf": "^5.0.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5",
+    "vue": "^3.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/state-zero/statezero-client/issues"
+  },
+  "directories": {
+    "test": "tests"
+  }
+}

package/readme.md

@@ -192,7 +192,7 @@ npm install https://github.com/state-zero/statezero-client
 ### Generate TypeScript Models
 
 ```bash
-npx statezero sync-models
+npx statezero sync
 ```
 
 ## Why Choose StateZero Over...