@statezero/core 0.1.0

package/dist/syncEngine/stores/operation.js

@@ -0,0 +1,224 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Operation__instances, _Operation__frozenInstances;
+import { MAX, v7 as uuidv7 } from "uuid";
+import { isNil } from 'lodash-es';
+import mitt from 'mitt';
+import { tempPkMap } from "../../flavours/django/tempPk";
+export const operationEvents = mitt();
+export const Status = {
+    CREATED: 'operation:created',
+    UPDATED: 'operation:updated',
+    CONFIRMED: 'operation:confirmed',
+    REJECTED: 'operation:rejected',
+    CLEAR: 'clear:all',
+    MUTATED: 'operation:mutated'
+};
+export const Type = {
+    CREATE: 'create',
+    UPDATE: 'update',
+    DELETE: 'delete',
+    UPDATE_INSTANCE: 'update_instance',
+    DELETE_INSTANCE: 'delete_instance',
+    GET_OR_CREATE: 'get_or_create',
+    UPDATE_OR_CREATE: 'update_or_create',
+    CHECKPOINT: 'checkpoint',
+    // Aggregation operations
+    COUNT: 'count',
+    MIN: 'min',
+    MAX: 'max',
+    AVG: 'avg',
+    SUM: 'sum',
+    AGGREGATE: 'aggregate',
+};
+export class Operation {
+    constructor(data, restore = false) {
+        _Operation__instances.set(this, void 0);
+        _Operation__frozenInstances.set(this, void 0);
+        if (!data || typeof data !== 'object') {
+            throw new Error("Operation constructor requires a data object.");
+        }
+        if (!data.type) {
+            throw new Error("Operation data must include a 'type'.");
+        }
+        if (!data.instances) {
+            throw new Error("Operation data must include 'instances'.");
+        }
+        this.operationId = data.operationId || `op_${uuidv7()}`;
+        this.type = data.type;
+        this.status = data.status || Status.CREATED;
+        this.queryset = data.queryset;
+        this.args = data.args;
+        this.doNotPropagate = data.doNotPropagate || false;
+        let ModelClass = this.queryset.ModelClass;
+        let instances = data.instances;
+        // guarantee instances is an array
+        if (!isNil(instances)) {
+            instances = Array.isArray(data.instances) ? data.instances : [data.instances];
+        }
+        // coerce to object format if its not already
+        let pkField = ModelClass.primaryKeyField;
+        if (instances.some(instance => isNil(instance) || typeof instance !== 'object' || !(pkField in instance))) {
+            throw new Error(`All operation instances must be objects with the '${pkField}' field`);
+        }
+        __classPrivateFieldSet(this, _Operation__instances, instances, "f");
+        __classPrivateFieldSet(this, _Operation__frozenInstances, instances.map(i => ModelClass.fromPk(i[ModelClass.primaryKeyField]).serialize()), "f");
+        this.timestamp = data.timestamp || Date.now();
+        if (restore)
+            return;
+        operationRegistry.register(this);
+        // Emit operation created event with the entire operation
+        operationEvents.emit(Status.CREATED, this);
+    }
+    /**
+     * Getter for instances that replaces any temporary PKs with real PKs
+     */
+    get instances() {
+        if (tempPkMap.size === 0)
+            return __classPrivateFieldGet(this, _Operation__instances, "f");
+        const ModelClass = this.queryset.ModelClass;
+        const pkField = ModelClass.primaryKeyField;
+        return __classPrivateFieldGet(this, _Operation__instances, "f").map(instance => {
+            const pk = instance[pkField];
+            if (typeof pk === 'string' && tempPkMap.has(pk.replace(/[{}]/g, ''))) {
+                // Return a new instance with the real PK
+                return {
+                    ...instance,
+                    [pkField]: tempPkMap.get(pk.replace(/[{}]/g, ''))
+                };
+            }
+            return instance;
+        });
+    }
+    /**
+     * Setter for instances
+     */
+    set instances(value) {
+        __classPrivateFieldSet(this, _Operation__instances, Array.isArray(value) ? value : [value], "f");
+    }
+    /**
+     * Getter for frozenInstances that replaces any temporary PKs with real PKs
+     */
+    get frozenInstances() {
+        if (tempPkMap.size === 0)
+            return __classPrivateFieldGet(this, _Operation__frozenInstances, "f");
+        const ModelClass = this.queryset.ModelClass;
+        const pkField = ModelClass.primaryKeyField;
+        return __classPrivateFieldGet(this, _Operation__frozenInstances, "f").map(instance => {
+            const pk = instance[pkField];
+            if (typeof pk === 'string' && tempPkMap.has(pk.replace(/[{}]/g, ''))) {
+                // Return a new instance with the real PK
+                return {
+                    ...instance,
+                    [pkField]: tempPkMap.get(pk.replace(/[{}]/g, ''))
+                };
+            }
+            return instance;
+        });
+    }
+    /**
+     * Setter for frozenInstances
+     */
+    set frozenInstances(value) {
+        __classPrivateFieldSet(this, _Operation__frozenInstances, Array.isArray(value) ? value : [value], "f");
+    }
+    /**
+     * Get primary keys of all instances in this operation
+     * Returns primary keys as simple values (not objects)
+     */
+    get instancePks() {
+        const pkField = this.queryset.ModelClass.primaryKeyField;
+        return this.instances.map(instance => instance[pkField]);
+    }
+    /**
+     * Update this operation's status and emit an event
+     * @param {string} status - New status ('confirmed', 'rejected', etc.)
+     * @param {Array|Object|null} [instances=null] - New instances for the operation
+     */
+    updateStatus(status, instances = null) {
+        this.status = status;
+        this.timestamp = Date.now();
+        if (instances !== null) {
+            this.instances = Array.isArray(instances) ? instances : [instances];
+        }
+        operationEvents.emit(status, this);
+    }
+    /**
+     * Updates this operation with new data and emits the appropriate event
+     * @param {Object} newData - New data to update the operation with
+     * @returns {Operation} - Returns this operation instance for chaining
+     */
+    mutate(newData) {
+        // Ensure instances is always an array
+        if (newData.instances && !Array.isArray(newData.instances)) {
+            newData.instances = [newData.instances];
+        }
+        // Use Object.assign to update all properties at once
+        Object.assign(this, newData);
+        // Update timestamp
+        this.timestamp = Date.now();
+        // Emit the mutated event with the updated operation
+        operationEvents.emit(Status.MUTATED, this);
+        return this;
+    }
+}
+_Operation__instances = new WeakMap(), _Operation__frozenInstances = new WeakMap();
+class OperationRegistry {
+    constructor() {
+        this._operations = new Map();
+    }
+    /**
+     * Registers a pre-constructed Operation instance in the registry.
+     * Ensures the operationId is unique within the registry.
+     * Throws an Error if the operationId already exists.
+     *
+     * @param {Operation} operation - The fully instantiated Operation object to register.
+     * @throws {Error} If the input is not a valid operation object or if an operation with the same operationId already exists.
+     */
+    register(operation) {
+        if (!(operation instanceof Operation)) {
+            throw new Error("OperationRegistry.register requires an Operation object.");
+        }
+        // Ensure the ID is unique before registering
+        if (this._operations.has(operation.operationId)) {
+            // Throw an error if the ID is already used.
+            console.warn(`OperationId ${operation.operationId} is already used, overriding existing operation!`);
+        }
+        // Register the provided operation object
+        this._operations.set(operation.operationId, operation);
+    }
+    /**
+     * Retrieves an operation by its ID.
+     * @param {string} operationId - The ID of the operation.
+     * @returns {Operation | undefined} The operation instance or undefined if not found.
+     */
+    get(operationId) {
+        return this._operations.get(operationId);
+    }
+    /**
+     * Checks if an operation with the given ID exists in the registry.
+     * @param {string} operationId - The ID of the operation to check.
+     * @returns {boolean} True if the operation exists, false otherwise.
+     */
+    has(operationId) {
+        return this._operations.has(operationId);
+    }
+    /**
+     * Clears all operations from the registry.
+     */
+    clear() {
+        console.log("OperationRegistry: Clearing all operations.");
+        this._operations.clear();
+        operationEvents.emit(Status.CLEAR);
+    }
+}
+export const operationRegistry = new OperationRegistry();

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

@@ -0,0 +1,8 @@
+/**
+ * Initialize the operation event handler system by setting up event listeners
+ */
+export function initEventHandler(): void;
+/**
+ * Clean up by removing all event listeners
+ */
+export function cleanupEventHandler(): void;

package/dist/syncEngine/stores/operationEventHandlers.js

@@ -0,0 +1,239 @@
+import { operationEvents, Status, Type } from './operation.js';
+import { modelStoreRegistry } from '../registries/modelStoreRegistry.js';
+import { querysetStoreRegistry } from '../registries/querysetStoreRegistry.js';
+import { metricRegistry } from '../registries/metricRegistry.js';
+import { getFingerprint } from './utils.js';
+import { QuerySet } from '../../flavours/django/querySet.js';
+import { isEqual, isNil } from 'lodash-es';
+import hash from 'object-hash';
+/**
+ * Returns querysets that have the same nodes as any ancestor of the specific queryset
+ * @param {QuerySet} queryset
+ * @returns {Map<QuerySet, Store>}
+ */
+function relatedQuerysets(queryset) {
+    // Collect ancestor nodes for comparison
+    let ancestorNodes = [];
+    let current = queryset;
+    while (current) {
+        ancestorNodes.push(current.nodes);
+        current = current.__parent;
+    }
+    const modelClass = queryset.ModelClass;
+    const result = new Map();
+    Array.from(querysetStoreRegistry._stores.entries()).forEach(([queryset, store]) => {
+        if (store.modelClass !== modelClass)
+            return;
+        try {
+            if (ancestorNodes.some(nodes => isEqual(nodes, store.queryset.nodes))) {
+                result.set(store.queryset, store);
+            }
+        }
+        catch (e) {
+            console.warn('Error comparing nodes for related querysets', e);
+        }
+    });
+    return result;
+}
+/**
+ * Returns querysets that contain any of the specified instances
+ * @param {Operation} operation - The operation containing instances to check
+ * @returns {Map<QuerySet, Store>}
+ */
+function querysetsContainingInstances(operation) {
+    const ModelClass = operation.queryset.ModelClass;
+    const pkField = ModelClass.primaryKeyField;
+    const instancePks = new Set(operation.instances
+        .filter(instance => instance && typeof instance === 'object' && pkField in instance)
+        .map(instance => instance[pkField]));
+    if (instancePks.size === 0) {
+        return new Map();
+    }
+    const result = new Map();
+    Array.from(querysetStoreRegistry._stores.entries()).forEach(([queryset, store]) => {
+        if (store.modelClass !== ModelClass)
+            return;
+        try {
+            // Check if this queryset contains any of the instances
+            const renderedPks = new Set(store.render(false)); // Get without optimistic updates
+            const hasIntersection = [...instancePks].some(pk => renderedPks.has(pk));
+            if (hasIntersection) {
+                result.set(store.queryset, store);
+            }
+        }
+        catch (e) {
+            console.warn('Error checking queryset for instances', e);
+        }
+    });
+    return result;
+}
+/**
+ * Process an operation in the model store
+ *
+ * @param {Operation} operation - The operation to process
+ * @param {string} actionType - The action to perform ('add', 'update', 'confirm', 'reject')
+ */
+function processModelStore(operation, actionType) {
+    const ModelClass = operation.queryset.ModelClass;
+    const modelStore = modelStoreRegistry.getStore(ModelClass);
+    if (!modelStore)
+        return;
+    switch (actionType) {
+        case 'add':
+            modelStore.addOperation(operation);
+            break;
+        case 'update':
+            modelStore.updateOperation(operation);
+            break;
+        case 'confirm':
+            modelStore.confirm(operation);
+            break;
+        case 'reject':
+            modelStore.reject(operation);
+            break;
+    }
+}
+/**
+ * Process an operation in the queryset stores based on operation type
+ * Uses different routing strategies based on the operation type
+ *
+ * @param {Operation} operation - The operation to process
+ * @param {string} actionType - The action to perform ('add', 'update', 'confirm', 'reject')
+ */
+function processQuerysetStores(operation, actionType) {
+    const ModelClass = operation.queryset.ModelClass;
+    const queryset = operation.queryset;
+    // Apply the appropriate action to a single queryset store
+    const applyAction = (store) => {
+        switch (actionType) {
+            case 'add':
+                store.addOperation(operation);
+                break;
+            case 'update':
+                store.updateOperation(operation);
+                break;
+            case 'confirm':
+                store.confirm(operation);
+                break;
+            case 'reject':
+                store.reject(operation);
+                break;
+        }
+    };
+    let querysetStoreMap;
+    // Different routing strategies based on operation type
+    switch (operation.type) {
+        case Type.CREATE:
+        case Type.GET_OR_CREATE:
+        case Type.UPDATE_OR_CREATE:
+            // For creates, route to related querysets (they might want to include the new item)
+            querysetStoreMap = relatedQuerysets(queryset);
+            break;
+        case Type.UPDATE:
+        case Type.UPDATE_INSTANCE:
+        case Type.DELETE:
+        case Type.DELETE_INSTANCE:
+            // For updates and deletes, only route to querysets that actually contain the instances
+            querysetStoreMap = querysetsContainingInstances(operation);
+            break;
+        case Type.CHECKPOINT:
+            // For checkpoints, route to querysets that contain the instances
+            querysetStoreMap = querysetsContainingInstances(operation);
+            break;
+        default:
+            // For other operation types, use the existing related querysets logic
+            querysetStoreMap = relatedQuerysets(queryset);
+            break;
+    }
+    Array.from(querysetStoreMap.values()).forEach(applyAction);
+}
+/**
+ * Process an operation in the metric stores based on operation type
+ *
+ * @param {Operation} operation - The operation to process
+ * @param {string} actionType - The action to perform ('add', 'update', 'confirm', 'reject')
+ */
+function processMetricStores(operation, actionType) {
+    const queryset = operation.queryset;
+    const ModelClass = queryset.ModelClass;
+    // For metrics, we can use a similar strategy but might be more conservative
+    // and always use related querysets since metrics are aggregations
+    const allQuerysets = Array.from(relatedQuerysets(queryset).keys());
+    let allMetricStores = new Set();
+    allQuerysets.forEach(qs => {
+        const stores = metricRegistry.getAllStoresForQueryset(qs);
+        if (stores && stores.length > 0) {
+            stores.forEach(store => allMetricStores.add(store));
+        }
+    });
+    if (!allMetricStores || allMetricStores.size === 0) {
+        return;
+    }
+    // Apply the action to each matching metric store
+    allMetricStores.forEach(store => {
+        switch (actionType) {
+            case 'add':
+                store.addOperation(operation);
+                break;
+            case 'update':
+                store.updateOperation(operation);
+                break;
+            case 'confirm':
+                store.confirm(operation);
+                break;
+            case 'reject':
+                store.reject(operation);
+                break;
+        }
+    });
+}
+/**
+ * Common processing logic for operations, handling validation and routing
+ * to the appropriate store processors
+ *
+ * @param {Operation} operation - The operation to process
+ * @param {string} actionType - The action to perform ('add', 'update', 'confirm', 'reject')
+ */
+function processOperation(operation, actionType) {
+    if (!operation || !operation.queryset || !operation.queryset.ModelClass) {
+        console.warn(`Received invalid operation in processOperation (${actionType})`, operation);
+        return;
+    }
+    if (operation.doNotPropagate) {
+        return;
+    }
+    // Process model store first
+    processModelStore(operation, actionType);
+    // Then process queryset stores with improved routing
+    processQuerysetStores(operation, actionType);
+    // Finally process metric stores
+    processMetricStores(operation, actionType);
+}
+// Define handlers as named arrow functions at the top level
+const handleOperationCreated = operation => processOperation(operation, 'add');
+const handleOperationUpdated = operation => processOperation(operation, 'update');
+const handleOperationMutated = operation => processOperation(operation, 'update');
+const handleOperationConfirmed = operation => processOperation(operation, 'confirm');
+const handleOperationRejected = operation => processOperation(operation, 'reject');
+/**
+ * Initialize the operation event handler system by setting up event listeners
+ */
+export function initEventHandler() {
+    operationEvents.on(Status.CREATED, handleOperationCreated);
+    operationEvents.on(Status.UPDATED, handleOperationUpdated);
+    operationEvents.on(Status.CONFIRMED, handleOperationConfirmed);
+    operationEvents.on(Status.REJECTED, handleOperationRejected);
+    operationEvents.on(Status.MUTATED, handleOperationMutated);
+    console.log('Operation event handler initialized');
+}
+/**
+ * Clean up by removing all event listeners
+ */
+export function cleanupEventHandler() {
+    operationEvents.off(Status.CREATED, handleOperationCreated);
+    operationEvents.off(Status.UPDATED, handleOperationUpdated);
+    operationEvents.off(Status.CONFIRMED, handleOperationConfirmed);
+    operationEvents.off(Status.REJECTED, handleOperationRejected);
+    operationEvents.off(Status.MUTATED, handleOperationMutated);
+    console.log('Operation event handler cleaned up');
+}

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

@@ -0,0 +1,32 @@
+export class QuerysetStore {
+    constructor(modelClass: any, fetchFn: any, queryset: any, initialGroundTruthPks?: null, initialOperations?: null, options?: {});
+    modelClass: any;
+    fetchFn: any;
+    queryset: any;
+    operationsMap: Map<any, any>;
+    groundTruthPks: never[];
+    isSyncing: boolean;
+    pruneThreshold: any;
+    qsCache: Cache;
+    get cacheKey(): any;
+    onHydrated(hydratedData: any): void;
+    setCache(result: any): void;
+    clearCache(): void;
+    get operations(): any[];
+    get pkField(): any;
+    get groundTruthSet(): Set<never>;
+    _emitRenderEvent(): void;
+    addOperation(operation: any): Promise<void>;
+    updateOperation(operation: any): Promise<true | undefined>;
+    confirm(operation: any): Promise<void>;
+    reject(operation: any): Promise<void>;
+    setGroundTruth(groundTruthPks: any): Promise<void>;
+    setOperations(operations: any): Promise<void>;
+    getTrimmedOperations(): any[];
+    getInflightOperations(): any[];
+    prune(): void;
+    render(optimistic?: boolean, fromCache?: boolean): any[];
+    applyOperation(operation: any, currentPks: any): any;
+    sync(): Promise<void>;
+}
+import { Cache } from '../cache/cache.js';