@statezero/core 0.1.93 → 0.1.95

package/dist/core/eventReceivers.d.ts

@@ -29,6 +29,7 @@ export namespace EventType {
     let CREATE: string;
     let UPDATE: string;
     let DELETE: string;
+    let BULK_CREATE: string;
     let BULK_UPDATE: string;
     let BULK_DELETE: string;
 }

package/dist/core/eventReceivers.js

@@ -22,6 +22,7 @@ export const EventType = {
     CREATE: "create",
     UPDATE: "update",
     DELETE: "delete",
+    BULK_CREATE: "bulk_create",
     BULK_UPDATE: "bulk_update",
     BULK_DELETE: "bulk_delete",
 };

package/dist/flavours/django/makeApiCall.js

@@ -80,7 +80,7 @@ export async function makeApiCall(querySet, operationType, args = {}, operationI
     }
     // Determine if this is a write operation that needs FileObject processing
     const writeOperations = [
-        "create", "update", "delete", "update_instance", "delete_instance",
+        "create", "bulk_create", "update", "delete", "update_instance", "delete_instance",
         "get_or_create", "update_or_create"
     ];
     const isWriteOperation = writeOperations.includes(operationType);

package/dist/flavours/django/manager.d.ts

@@ -28,13 +28,6 @@ export class Manager {
      * @returns {QuerySet} A new QuerySet instance for the model.
      */
     newQuerySet(): QuerySet<any>;
-    /**
-     * Creates a new custom QuerySet instance with an initial name.
-     *
-     * @param {string} name - The initial queryset name.
-     * @returns {QuerySet} A new QuerySet instance for the model.
-     */
-    customQueryset(name: string): QuerySet<any>;
     /**
      * Retrieves a single model instance matching the provided filters.
      *
@@ -126,6 +119,13 @@ export class Manager {
      * @returns {Promise<*>} A promise that resolves to the newly created model instance.
      */
     create(data: any): Promise<any>;
+    /**
+     * Creates multiple model instances using the provided data array.
+     *
+     * @param {Array<Object>} dataList - Array of data objects to create model instances.
+     * @returns {Promise<Array<*>>} A promise that resolves to an array of newly created model instances.
+     */
+    bulkCreate(dataList: Array<Object>): Promise<Array<any>>;
     /**
      * Fetches all records using the current QuerySet.
      *

package/dist/flavours/django/manager.js

@@ -35,17 +35,6 @@ export class Manager {
     newQuerySet() {
         return new this.QuerySetClass(this.ModelClass);
     }
-    /**
-     * Creates a new custom QuerySet instance with an initial name.
-     *
-     * @param {string} name - The initial queryset name.
-     * @returns {QuerySet} A new QuerySet instance for the model.
-     */
-    customQueryset(name) {
-        return new this.QuerySetClass(this.ModelClass, {
-            initialQueryset: name
-        });
-    }
     /**
      * Retrieves a single model instance matching the provided filters.
      *
@@ -163,6 +152,15 @@ export class Manager {
     async create(data) {
         return this.newQuerySet().create(data);
     }
+    /**
+     * Creates multiple model instances using the provided data array.
+     *
+     * @param {Array<Object>} dataList - Array of data objects to create model instances.
+     * @returns {Promise<Array<*>>} A promise that resolves to an array of newly created model instances.
+     */
+    async bulkCreate(dataList) {
+        return this.newQuerySet().bulkCreate(dataList);
+    }
     /**
      * Fetches all records using the current QuerySet.
      *

package/dist/flavours/django/operationFactory.d.ts

@@ -11,6 +11,14 @@ export class OperationFactory {
      * @returns {Operation} The created operation
      */
     static createCreateOperation(queryset: QuerySet, data?: Object, operationId?: string): Operation;
+    /**
+     * Create a BULK_CREATE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Array<Object>} dataList - Array of data objects for the new instances
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createBulkCreateOperation(queryset: QuerySet, dataList?: Array<Object>, operationId?: string): Operation;
     /**
      * Create an UPDATE operation with optimistic instance updates
      * @param {QuerySet} queryset - The queryset context

package/dist/flavours/django/operationFactory.js

@@ -31,6 +31,30 @@ export class OperationFactory {
             args: { data },
         });
     }
+    /**
+     * Create a BULK_CREATE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Array<Object>} dataList - Array of data objects for the new instances
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createBulkCreateOperation(queryset, dataList = [], operationId = null) {
+        const ModelClass = queryset.ModelClass;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const opId = operationId || `${uuid7()}`;
+        // Create temp PKs for each instance
+        const instances = dataList.map((data, index) => {
+            const tempPk = createTempPk(`${opId}_${index}`);
+            return { ...data, [primaryKeyField]: tempPk };
+        });
+        return new Operation({
+            operationId: opId,
+            type: Type.BULK_CREATE,
+            instances: instances,
+            queryset: queryset,
+            args: { data: dataList },
+        });
+    }
     /**
      * Create an UPDATE operation with optimistic instance updates
      * @param {QuerySet} queryset - The queryset context

package/dist/flavours/django/queryExecutor.d.ts

@@ -101,6 +101,15 @@ export class QueryExecutor {
      * @returns {LiveThenable<Object>} The live Model instance which resolves to the created model.
      */
     static executeCreate(querySet: QuerySet, operationType?: string, args?: Object): LiveThenable<Object>;
+    /**
+     * Executes a bulk_create operation with the QuerySet.
+     *
+     * @param {QuerySet} querySet - The QuerySet to execute.
+     * @param {string} operationType - The operation type (always 'bulk_create' for this method).
+     * @param {Object} args - Additional arguments for the operation.
+     * @returns {LiveThenable<Array>} Array of live Model instances.
+     */
+    static executeBulkCreate(querySet: QuerySet, operationType?: string, args?: Object): LiveThenable<any[]>;
     /**
      * Executes an update_instance operation with the QuerySet.
      *

package/dist/flavours/django/queryExecutor.js

@@ -333,6 +333,75 @@ export class QueryExecutor {
         // 3) return the live‑thenable
         return makeLiveThenable(live, promise);
     }
+    /**
+     * Executes a bulk_create operation with the QuerySet.
+     *
+     * @param {QuerySet} querySet - The QuerySet to execute.
+     * @param {string} operationType - The operation type (always 'bulk_create' for this method).
+     * @param {Object} args - Additional arguments for the operation.
+     * @returns {LiveThenable<Array>} Array of live Model instances.
+     */
+    static executeBulkCreate(querySet, operationType = "bulk_create", args = {}) {
+        const ModelClass = querySet.ModelClass;
+        const operationId = `${uuid7()}`;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const apiCallArgs = {
+            data: args.data || [],
+        };
+        if (isNil(args.data) || !Array.isArray(args.data)) {
+            console.warn(`executeBulkCreate was called with invalid data`);
+            return Promise.resolve([]);
+        }
+        // Use factory to create operation
+        const operation = OperationFactory.createBulkCreateOperation(querySet, apiCallArgs.data, operationId);
+        // Create placeholder instances for each item
+        const liveInstances = operation.instances.map(instance => {
+            const tempPk = instance[primaryKeyField];
+            return ModelClass.fromPk(tempPk, querySet);
+        });
+        // Kick off the async call
+        const promise = makeApiCall(querySet, operationType, apiCallArgs, operationId, async (response) => {
+            const { data } = response.data;
+            const pks = Array.isArray(data) ? data : [];
+            // Set real PKs for all instances
+            pks.forEach((pk, index) => {
+                const tempPkKey = `${operationId}_${index}`;
+                setRealPk(tempPkKey, pk);
+            });
+        })
+            .then((response) => {
+            const { data, included, model_name } = response.data;
+            // Process included entities
+            processIncludedEntities(modelStoreRegistry, included, ModelClass);
+            // Get the real PKs
+            const pks = Array.isArray(data) ? data : [];
+            // Update each live instance with its real PK
+            pks.forEach((pk, index) => {
+                if (liveInstances[index]) {
+                    liveInstances[index].pk = pk;
+                }
+            });
+            // Get full entity data for all created instances
+            const entityMap = included[model_name] || {};
+            const confirmedInstances = pks.map(pk => entityMap[pk]).filter(Boolean);
+            // Confirm operation with full entity data
+            operation.mutate({
+                instances: confirmedInstances,
+                status: Status.CONFIRMED,
+            });
+            // Freeze all live instances
+            liveInstances.forEach(instance => breakThenable(instance));
+            // Also break the thenable on the array itself
+            breakThenable(liveInstances);
+            return liveInstances;
+        })
+            .catch((error) => {
+            operation.updateStatus(Status.REJECTED);
+            throw error;
+        });
+        // Return a live-thenable array
+        return makeLiveThenable(liveInstances, promise);
+    }
     /**
      * Executes an update_instance operation with the QuerySet.
      *
@@ -447,6 +516,8 @@ export class QueryExecutor {
                 return this.executeDelete(querySet, operationType, args);
             case "create":
                 return this.executeCreate(querySet, operationType, args);
+            case "bulk_create":
+                return this.executeBulkCreate(querySet, operationType, args);
             case "get_or_create":
             case "update_or_create":
                 return this.executeOrCreate(querySet, operationType, args);

package/dist/flavours/django/querySet.d.ts

@@ -194,6 +194,13 @@ export class QuerySet<T> {
      * @returns {Promise<any>} The created model instance.
      */
     create(data: Object): Promise<any>;
+    /**
+     * Creates multiple model instances using the provided data array.
+     *
+     * @param {Array<Object>} dataList - Array of data objects to create model instances.
+     * @returns {Promise<Array<any>>} A promise that resolves to an array of newly created model instances.
+     */
+    bulkCreate(dataList: Array<Object>): Promise<Array<any>>;
     /**
      * Updates records in the QuerySet.
      *

package/dist/flavours/django/querySet.js

@@ -425,6 +425,26 @@ export class QuerySet {
         }, this);
         return QueryExecutor.execute(newQs, "create", { data: serializedData });
     }
+    /**
+     * Creates multiple model instances using the provided data array.
+     *
+     * @param {Array<Object>} dataList - Array of data objects to create model instances.
+     * @returns {Promise<Array<any>>} A promise that resolves to an array of newly created model instances.
+     */
+    async bulkCreate(dataList) {
+        this.ensureNotMaterialized();
+        if (!Array.isArray(dataList)) {
+            throw new Error("bulkCreate expects an array of data objects");
+        }
+        // Serialize each data object before sending to backend
+        const serializedDataList = dataList.map(data => this._serializer.toInternal(data));
+        // Materialize for bulk create
+        const newQs = new QuerySet(this.ModelClass, {
+            ...this._getConfig(),
+            materialized: true,
+        }, this);
+        return QueryExecutor.execute(newQs, "bulk_create", { data: serializedDataList });
+    }
     /**
      * Updates records in the QuerySet.
      *

package/dist/syncEngine/stores/modelStore.js

@@ -345,6 +345,7 @@ export class ModelStore {
             let pk = instance[pkField];
             switch (operation.type) {
                 case Type.CREATE:
+                case Type.BULK_CREATE:
                     if (!currentInstances.has(pk)) {
                         currentInstances.set(pk, instance);
                     }

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

@@ -9,6 +9,7 @@ export namespace Status {
 }
 export namespace Type {
     let CREATE: string;
+    let BULK_CREATE: string;
     let UPDATE: string;
     let DELETE: string;
     let UPDATE_INSTANCE: string;

package/dist/syncEngine/stores/operation.js

@@ -25,6 +25,7 @@ export const Status = {
 };
 export const Type = {
     CREATE: 'create',
+    BULK_CREATE: 'bulk_create',
     UPDATE: 'update',
     DELETE: 'delete',
     UPDATE_INSTANCE: 'update_instance',

package/dist/syncEngine/stores/operationEventHandlers.js

@@ -7,30 +7,26 @@ 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
+ * Returns querysets that are in root mode (materialized with no materialized parent)
+ * Since filtered querysets render by filtering their parent's data, we only need
+ * to route operations to root querysets. Filtered children will see the operations
+ * when they filter their parent's rendered data.
  * @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;
-    }
+function getRootQuerysets(queryset) {
     const modelClass = queryset.ModelClass;
     const result = new Map();
-    Array.from(querysetStoreRegistry._stores.entries()).forEach(([queryset, store]) => {
+    // Route only to querysets that are in root mode
+    // Note: _stores is Map<semanticKey, Store>, so we get the queryset from store.queryset
+    Array.from(querysetStoreRegistry._stores.entries()).forEach(([semanticKey, 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);
+        // Use the graph to determine if this store is in root mode
+        const { isRoot, root } = querysetStoreRegistry.querysetStoreGraph.findRoot(store.queryset);
+        // A queryset is in root mode if isRoot=true and root is its own semantic key
+        if (isRoot && root === store.queryset.semanticKey) {
+            result.set(store.queryset, store);
         }
     });
     return result;
@@ -92,10 +88,11 @@ function processQuerysetStores(operation, actionType) {
     // Different routing strategies based on operation type
     switch (operation.type) {
         case Type.CREATE:
+        case Type.BULK_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);
+            // For creates, route to root querysets (they might want to include the new item)
+            querysetStoreMap = getRootQuerysets(queryset);
             break;
         case Type.UPDATE:
         case Type.UPDATE_INSTANCE:
@@ -109,32 +106,34 @@ function processQuerysetStores(operation, actionType) {
             querysetStoreMap = new Map();
             break;
         default:
-            // For other operation types, use the existing related querysets logic
-            querysetStoreMap = relatedQuerysets(queryset);
+            // For other operation types, use the existing root querysets logic
+            querysetStoreMap = getRootQuerysets(queryset);
             break;
     }
     Array.from(querysetStoreMap.values()).forEach(applyAction);
 }
 /**
- * Process an operation in the metric stores based on operation type
+ * Process an operation in the metric stores
+ *
+ * For metrics, we route operations UP the family tree - any metric on an ancestor
+ * queryset should receive the operation so it can check if it affects the metric.
  *
  * @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);
+    const allMetricStores = new Set();
+    // Walk up the queryset family tree and collect all metrics
+    let current = queryset;
+    while (current) {
+        const stores = metricRegistry.getAllStoresForQueryset(current);
         if (stores && stores.length > 0) {
             stores.forEach(store => allMetricStores.add(store));
         }
-    });
-    if (!allMetricStores || allMetricStores.size === 0) {
+        current = current.__parent;
+    }
+    if (allMetricStores.size === 0) {
         return;
     }
     // Apply the action to each matching metric store

package/dist/syncEngine/stores/querysetStore.js

@@ -202,7 +202,9 @@ export class QuerysetStore {
             typeof this.getRootStore === "function" &&
             !this.isTemp) {
             const { isRoot, rootStore } = this.getRootStore(this.queryset);
-            if (!isRoot && rootStore && (rootStore.lastSync || 0) >= (this.lastSync || 0)) {
+            // If we're not in root mode and have a root store, ALWAYS render from it
+            // since operations are only routed to root stores now
+            if (!isRoot && rootStore) {
                 pks = this.renderFromRoot(optimistic, rootStore);
             }
         }
@@ -247,6 +249,7 @@ export class QuerysetStore {
             let pk = instance[pkField];
             switch (operation.type) {
                 case Type.CREATE:
+                case Type.BULK_CREATE:
                     currentPks.add(pk);
                     break;
                 case Type.CHECKPOINT:

package/package.json

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