@statezero/core 0.1.0

package/dist/flavours/django/model.js

@@ -0,0 +1,253 @@
+import { Manager } from './manager.js';
+import { ValidationError } from './errors.js';
+import { modelStoreRegistry } from '../../syncEngine/registries/modelStoreRegistry.js';
+import { isNil } from 'lodash-es';
+import { QueryExecutor } from './queryExecutor';
+import { wrapReactiveModel } from '../../reactiveAdaptor.js';
+import { DateParsingHelpers } from './dates.js';
+/**
+ * A constructor for a Model.
+ *
+ * @typedef {Function} ModelConstructor
+ * @param {any} data - Data to initialize the model.
+ * @returns {Model}
+ *
+ * @property {Manager} objects - The model's manager.
+ * @property {string} configKey - The configuration key.
+ * @property {string} modelName - The model name.
+ * @property {string} primaryKeyField - The primary key field (default 'id').
+ */
+/**
+ * Base Model class with integrated API implementation.
+ *
+ * @abstract
+ */
+export class Model {
+    constructor(data = {}) {
+        // Initialize internal data store
+        this._data = data;
+        this._pk = data[this.constructor.primaryKeyField] || undefined;
+        this.__version = 0;
+        return wrapReactiveModel(this);
+    }
+    touch() {
+        this.__version++;
+    }
+    /**
+     * Returns the primary key of the model instance.
+     *
+     * @returns {number|undefined} The primary key.
+     */
+    get pk() {
+        return this._pk;
+    }
+    /**
+     * Sets the primary key of the model instance.
+     *
+     * @param {number|undefined} value - The new primary key value.
+     */
+    set pk(value) {
+        this._pk = value;
+        this.touch();
+    }
+    /**
+     * Instantiate from pk using queryset scoped singletons
+     */
+    static fromPk(pk, querySet) {
+        let qsId = querySet ? querySet.__uuid : '';
+        let key = `${qsId}__${this.configKey}__${this.modelName}__${pk}`;
+        if (!this.instanceCache.has(key)) {
+            const instance = new this();
+            instance.pk = pk;
+            this.instanceCache.set(key, instance);
+        }
+        return this.instanceCache.get(key);
+    }
+    /**
+     * Gets a field value from the internal data store
+     *
+     * @param {string} field - The field name
+     * @returns {any} The field value
+     */
+    getField(field) {
+        // Access the reactive __version property to establish dependency for vue integration
+        const trackVersion = this.__version;
+        const ModelClass = this.constructor;
+        if (ModelClass.primaryKeyField === field)
+            return this._pk;
+        // check local overrides
+        let value = this._data[field];
+        // if its not been overridden, get it from the store
+        if (isNil(value) && !isNil(this._pk)) {
+            let storedValue = modelStoreRegistry.getEntity(ModelClass, this._pk);
+            if (storedValue)
+                value = storedValue[field]; // if stops null -> undefined
+        }
+        // relationship fields need special handling
+        if (ModelClass.relationshipFields.has(field) && value) {
+            // fetch the stored value
+            let fieldInfo = ModelClass.relationshipFields.get(field);
+            // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
+            let relPkField = fieldInfo.ModelClass().primaryKeyField;
+            switch (fieldInfo.relationshipType) {
+                case 'many-to-many':
+                    // value is an array
+                    if (!Array.isArray(value) && value)
+                        throw new Error(`Data corruption: m2m field for ${ModelClass.modelName} stored as ${value}`);
+                    // set each pk to the full model object for that pk
+                    value = value.map(pk => fieldInfo.ModelClass().fromPk(pk));
+                    break;
+                case 'one-to-one':
+                case 'foreign-key':
+                    // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
+                    if (!isNil(value))
+                        value = fieldInfo.ModelClass().fromPk(value);
+                    break;
+            }
+        }
+        return value;
+    }
+    /**
+     * Sets a field value in the internal data store
+     *
+     * @param {string} field - The field name
+     * @param {any} value - The field value to set
+     */
+    setField(field, value) {
+        const ModelClass = this.constructor;
+        if (ModelClass.primaryKeyField === field) {
+            this._pk = value;
+        }
+        else {
+            this._data[field] = value;
+        }
+    }
+    /**
+     * Validates that the provided data object only contains keys
+     * defined in the model's allowed fields. Supports nested fields
+     * using double underscore notation (e.g., author__name).
+     *
+     * @param {Object} data - The object to validate.
+     * @throws {ValidationError} If an unknown key is found.
+     */
+    static validateFields(data) {
+        if (isNil(data))
+            return;
+        const allowedFields = this.fields;
+        for (const key of Object.keys(data)) {
+            if (key === 'repr' || key === 'type')
+                continue;
+            // Handle nested fields by splitting on double underscore
+            // and taking just the base field name
+            const baseField = key.split('__')[0];
+            if (!allowedFields.includes(baseField)) {
+                let errorMsg = `Invalid field: ${baseField}. Allowed fields are: ${allowedFields.join(', ')}`;
+                console.error(errorMsg);
+                throw new ValidationError(errorMsg);
+            }
+        }
+    }
+    /**
+     * Serializes a field value for API transmission
+     *
+     * @param {string} field - The field name
+     * @returns {any} The serialized field value
+     */
+    serializeField(field) {
+        const ModelClass = this.constructor;
+        if (ModelClass.primaryKeyField === field)
+            return this._pk;
+        // check local overrides
+        let value = this._data[field];
+        // if it's not been overridden, get it from the store
+        if (isNil(value) && !isNil(this._pk)) {
+            let storedValue = modelStoreRegistry.getEntity(ModelClass, this._pk);
+            if (storedValue)
+                value = storedValue[field];
+        }
+        return value;
+    }
+    /**
+     * Serializes the model instance.
+     *
+     * By default, it returns all enumerable own properties.
+     * Subclasses should override this to return specific keys.
+     *
+     * @returns {Object} The serialized model data.
+     */
+    serialize() {
+        const serialized = {};
+        const ModelClass = this.constructor;
+        // Include all fields defined in the model
+        for (const field of ModelClass.fields) {
+            serialized[field] = this.serializeField(field);
+        }
+        return serialized;
+    }
+    /**
+     * Saves the model instance by either creating a new record or updating an existing one.
+     *
+     * @returns {Promise<Model>} A promise that resolves to the updated model instance.
+     */
+    async save() {
+        const ModelClass = this.constructor;
+        const pkField = ModelClass.primaryKeyField;
+        const querySet = !this.pk ? ModelClass.objects.newQuerySet() : ModelClass.objects.filter({ [pkField]: this.pk });
+        const data = this.serialize();
+        let instance;
+        if (!this.pk) {
+            // Create new instance
+            instance = await QueryExecutor.execute(querySet, 'create', { data });
+        }
+        else {
+            // Update existing instance
+            instance = await QueryExecutor.execute(querySet, 'update_instance', { data });
+        }
+        this._pk = instance.pk;
+        this._data = {};
+        return this;
+    }
+    /**
+     * Deletes the instance from the database.
+     *
+     * Returns a tuple with the number of objects deleted and an object mapping
+     * model names to the number of objects deleted, matching Django's behavior.
+     *
+     * @returns {Promise<[number, Object]>} A promise that resolves to the deletion result.
+     * @throws {Error} If the instance has not been saved (no primary key).
+     */
+    async delete() {
+        if (!this.pk) {
+            throw new Error('Cannot delete unsaved instance');
+        }
+        const ModelClass = this.constructor;
+        const pkField = ModelClass.primaryKeyField;
+        const querySet = ModelClass.objects.filter({ [pkField]: this.pk });
+        // Pass the instance data with primary key as the args
+        const args = { [pkField]: this.pk };
+        const result = await QueryExecutor.execute(querySet, 'delete_instance', args);
+        // result -> [deletedCount, { [modelName]: deletedCount }];
+        return result;
+    }
+    /**
+     * Refreshes the model instance with data from the database.
+     *
+     * @returns {Promise<void>} A promise that resolves when the instance has been refreshed.
+     * @throws {Error} If the instance has not been saved (no primary key).
+     */
+    async refreshFromDb() {
+        if (!this.pk) {
+            throw new Error('Cannot refresh unsaved instance');
+        }
+        const ModelClass = this.constructor;
+        const fresh = await ModelClass.objects.get({ [ModelClass.primaryKeyField]: this.pk });
+        // clear the current data and fresh data will flow
+        this._data = {};
+    }
+}
+/**
+ * Creates a new Model instance.
+ *
+ * @param {any} [data={}] - The data for initialization.
+ */
+Model.instanceCache = new Map();

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

@@ -0,0 +1,65 @@
+/**
+ * Factory for creating Operation instances with consistent behavior
+ * across QueryExecutor and hotpath event handling
+ */
+export class OperationFactory {
+    /**
+     * Create a CREATE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} data - The data for the new instance
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createCreateOperation(queryset: QuerySet, data?: Object, operationId?: string): Operation;
+    /**
+     * Create an UPDATE operation with optimistic instance updates
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} data - The update data
+     * @param {Object} filter - Optional filter for the update
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createUpdateOperation(queryset: QuerySet, data?: Object, filter?: Object, operationId?: string): Operation;
+    /**
+     * Create a DELETE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createDeleteOperation(queryset: QuerySet, operationId?: string): Operation;
+    /**
+     * Create an UPDATE_INSTANCE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} data - The update data
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createUpdateInstanceOperation(queryset: QuerySet, data?: Object, operationId?: string): Operation;
+    /**
+     * Create a DELETE_INSTANCE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} instanceData - The instance to delete (object with PK)
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createDeleteInstanceOperation(queryset: QuerySet, instanceData: Object, operationId?: string): Operation;
+    /**
+     * Create a GET_OR_CREATE operation with local filtering logic
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} lookup - The lookup criteria
+     * @param {Object} defaults - The default values for creation
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createGetOrCreateOperation(queryset: QuerySet, lookup?: Object, defaults?: Object, operationId?: string): Operation;
+    /**
+     * Create an UPDATE_OR_CREATE operation with local filtering logic
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} lookup - The lookup criteria
+     * @param {Object} defaults - The default values for creation/update
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createUpdateOrCreateOperation(queryset: QuerySet, lookup?: Object, defaults?: Object, operationId?: string): Operation;
+}
+import { Operation } from '../../syncEngine/stores/operation';

package/dist/flavours/django/operationFactory.js

@@ -0,0 +1,216 @@
+import { Operation, Type, Status } from '../../syncEngine/stores/operation';
+import { v7 as uuid7 } from 'uuid';
+import { createTempPk } from './tempPk.js';
+import { getRequiredFields, pickRequiredFields, processQuery } from '../../filtering/localFiltering.js';
+import { evaluateExpression } from './f.js';
+import { modelStoreRegistry } from '../../syncEngine/registries/modelStoreRegistry.js';
+import { querysetStoreRegistry } from '../../syncEngine/registries/querysetStoreRegistry.js';
+import { isNil } from 'lodash-es';
+/**
+ * Factory for creating Operation instances with consistent behavior
+ * across QueryExecutor and hotpath event handling
+ */
+export class OperationFactory {
+    /**
+     * Create a CREATE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} data - The data for the new instance
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createCreateOperation(queryset, data = {}, operationId = null) {
+        const ModelClass = queryset.ModelClass;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const opId = operationId || `${uuid7()}`;
+        const tempPk = createTempPk(opId);
+        return new Operation({
+            operationId: opId,
+            type: Type.CREATE,
+            instances: [{ ...data, [primaryKeyField]: tempPk }],
+            queryset: queryset,
+            args: { data },
+        });
+    }
+    /**
+     * Create an UPDATE operation with optimistic instance updates
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} data - The update data
+     * @param {Object} filter - Optional filter for the update
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createUpdateOperation(queryset, data = {}, filter = null, operationId = null) {
+        const ModelClass = queryset.ModelClass;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const store = querysetStoreRegistry.getStore(queryset);
+        const querysetPks = store.render();
+        const opId = operationId || `${uuid7()}`;
+        // Create optimistic instances with F expression evaluation
+        const optimisticInstances = querysetPks.map(pk => {
+            const instance = modelStoreRegistry.getEntity(ModelClass, pk);
+            const updatedInstance = { ...instance };
+            updatedInstance[primaryKeyField] = pk;
+            for (const [key, value] of Object.entries(data)) {
+                if (value && typeof value === 'object' && value.__f_expr) {
+                    const evaluatedValue = evaluateExpression(value, instance);
+                    if (evaluatedValue !== null) {
+                        updatedInstance[key] = evaluatedValue;
+                    }
+                    else {
+                        updatedInstance[key] = instance[key];
+                    }
+                }
+                else {
+                    updatedInstance[key] = value;
+                }
+            }
+            return updatedInstance;
+        });
+        return new Operation({
+            operationId: opId,
+            type: Type.UPDATE,
+            instances: optimisticInstances,
+            queryset: queryset,
+            args: { filter, data },
+        });
+    }
+    /**
+     * Create a DELETE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createDeleteOperation(queryset, operationId = null) {
+        const ModelClass = queryset.ModelClass;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const store = querysetStoreRegistry.getStore(queryset);
+        const querysetPks = store.render();
+        const opId = operationId || `${uuid7()}`;
+        const instances = querysetPks.map((pk) => ({ [primaryKeyField]: pk }));
+        return new Operation({
+            operationId: opId,
+            type: Type.DELETE,
+            instances: instances,
+            queryset: queryset,
+            args: {},
+        });
+    }
+    /**
+     * Create an UPDATE_INSTANCE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} data - The update data
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createUpdateInstanceOperation(queryset, data = {}, operationId = null) {
+        const ModelClass = queryset.ModelClass;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const store = querysetStoreRegistry.getStore(queryset);
+        const querysetPks = store.render();
+        const opId = operationId || `${uuid7()}`;
+        const instances = querysetPks.map(pk => ({ ...data, [primaryKeyField]: pk }));
+        return new Operation({
+            operationId: opId,
+            type: Type.UPDATE_INSTANCE,
+            instances: instances,
+            queryset: queryset,
+            args: { data },
+        });
+    }
+    /**
+     * Create a DELETE_INSTANCE operation
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} instanceData - The instance to delete (object with PK)
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createDeleteInstanceOperation(queryset, instanceData, operationId = null) {
+        const opId = operationId || `${uuid7()}`;
+        return new Operation({
+            operationId: opId,
+            type: Type.DELETE_INSTANCE,
+            instances: [instanceData],
+            queryset: queryset,
+            args: instanceData,
+        });
+    }
+    /**
+     * Create a GET_OR_CREATE operation with local filtering logic
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} lookup - The lookup criteria
+     * @param {Object} defaults - The default values for creation
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createGetOrCreateOperation(queryset, lookup = {}, defaults = {}, operationId = null) {
+        const ModelClass = queryset.ModelClass;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const opId = operationId || `${uuid7()}`;
+        // Get all current instances from the store for local filtering
+        const modelStore = modelStoreRegistry.getStore(ModelClass);
+        const allInstances = modelStore.render();
+        // Create a queryset filter for the lookup criteria
+        const lookupFilter = { ...lookup };
+        const lookupQuerySet = new queryset.constructor(ModelClass).filter(lookupFilter);
+        const lookupQuery = lookupQuerySet.build();
+        // Use local filtering to find matching instances
+        const requiredPaths = getRequiredFields(lookupQuery, ModelClass);
+        const prunedData = allInstances.map(inst => pickRequiredFields(requiredPaths, ModelClass.fromPk(inst[primaryKeyField], queryset)));
+        const matchingPks = processQuery(prunedData, lookupQuery, ModelClass);
+        // Find the corresponding instances
+        const matchingInstances = allInstances.filter(inst => matchingPks.includes(inst[primaryKeyField]));
+        const isCreatingNew = matchingInstances.length === 0;
+        const effectiveType = isCreatingNew ? Type.CREATE : Type.UPDATE;
+        // Create the instance data
+        const instanceData = isCreatingNew
+            ? { ...lookup, ...defaults, [primaryKeyField]: opId }
+            : matchingInstances[0];
+        return new Operation({
+            operationId: opId,
+            type: effectiveType,
+            instances: [instanceData],
+            queryset: queryset,
+            args: { lookup, defaults },
+        });
+    }
+    /**
+     * Create an UPDATE_OR_CREATE operation with local filtering logic
+     * @param {QuerySet} queryset - The queryset context
+     * @param {Object} lookup - The lookup criteria
+     * @param {Object} defaults - The default values for creation/update
+     * @param {string} [operationId] - Optional operation ID (for hotpath events)
+     * @returns {Operation} The created operation
+     */
+    static createUpdateOrCreateOperation(queryset, lookup = {}, defaults = {}, operationId = null) {
+        const ModelClass = queryset.ModelClass;
+        const primaryKeyField = ModelClass.primaryKeyField;
+        const opId = operationId || `${uuid7()}`;
+        // Get all current instances from the store for local filtering
+        const modelStore = modelStoreRegistry.getStore(ModelClass);
+        const allInstances = modelStore.render();
+        // Create a queryset filter for the lookup criteria
+        const lookupFilter = { ...lookup };
+        const lookupQuerySet = new queryset.constructor(ModelClass).filter(lookupFilter);
+        const lookupQuery = lookupQuerySet.build();
+        // Use local filtering to find matching instances
+        const requiredPaths = getRequiredFields(lookupQuery, ModelClass);
+        const prunedData = allInstances.map(inst => pickRequiredFields(requiredPaths, ModelClass.fromPk(inst[primaryKeyField], queryset)));
+        const matchingPks = processQuery(prunedData, lookupQuery, ModelClass);
+        // Find the corresponding instances
+        const matchingInstances = allInstances.filter(inst => matchingPks.includes(inst[primaryKeyField]));
+        const isCreatingNew = matchingInstances.length === 0;
+        const isUpdating = !isCreatingNew;
+        const effectiveType = isCreatingNew ? Type.CREATE : Type.UPDATE;
+        // Create the instance data
+        const instanceData = isCreatingNew
+            ? { ...lookup, ...defaults, [primaryKeyField]: opId }
+            : { ...matchingInstances[0], ...defaults };
+        return new Operation({
+            operationId: opId,
+            type: effectiveType,
+            instances: [instanceData],
+            queryset: queryset,
+            args: { lookup, defaults },
+        });
+    }
+}

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

@@ -0,0 +1,70 @@
+/**
+ * Minimal type definitions for field lookups.
+ *
+ * @template T
+ * @typedef {Object.<string, any>} FieldLookup
+ */
+/**
+ * Minimal type definitions for object lookups.
+ *
+ * @template T
+ * @typedef {Object.<string, any>} ObjectLookup
+ */
+/**
+ * Django-specific Q helper type.
+ *
+ * A QCondition is either a partial object of type T or a combination
+ * of partial field and object lookups.
+ *
+ * @template T
+ * @typedef {Partial<T> | (Partial<FieldLookup<T>> & Partial<ObjectLookup<T>>)} QCondition
+ */
+/**
+ * Django-specific Q helper type representing a logical grouping of conditions.
+ *
+ * @template T
+ * @typedef {Object} QObject
+ * @property {'AND'|'OR'} operator - The logical operator.
+ * @property {Array<QCondition<T>|QObject<T>>} conditions - An array of conditions or nested Q objects.
+ */
+/**
+ * Creates a Q object for combining conditions.
+ *
+ * @template T
+ * @param {'AND'|'OR'} operator - The operator to combine conditions.
+ * @param {...(QCondition<T>|QObject<T>)} conditions - The conditions to combine.
+ * @returns {QObject<T>} The combined Q object.
+ */
+export function Q<T>(operator: "AND" | "OR", ...conditions: (QCondition<T> | QObject<T>)[]): QObject<T>;
+/**
+ * Minimal type definitions for field lookups.
+ */
+export type FieldLookup<T> = {
+    [x: string]: any;
+};
+/**
+ * Minimal type definitions for object lookups.
+ */
+export type ObjectLookup<T> = {
+    [x: string]: any;
+};
+/**
+ * Django-specific Q helper type.
+ *
+ * A QCondition is either a partial object of type T or a combination
+ * of partial field and object lookups.
+ */
+export type QCondition<T> = Partial<T> | (Partial<FieldLookup<T>> & Partial<ObjectLookup<T>>);
+/**
+ * Django-specific Q helper type representing a logical grouping of conditions.
+ */
+export type QObject<T> = {
+    /**
+     * - The logical operator.
+     */
+    operator: "AND" | "OR";
+    /**
+     * - An array of conditions or nested Q objects.
+     */
+    conditions: Array<QCondition<T> | QObject<T>>;
+};

package/dist/flavours/django/q.js

@@ -0,0 +1,43 @@
+/**
+ * Minimal type definitions for field lookups.
+ *
+ * @template T
+ * @typedef {Object.<string, any>} FieldLookup
+ */
+/**
+ * Minimal type definitions for object lookups.
+ *
+ * @template T
+ * @typedef {Object.<string, any>} ObjectLookup
+ */
+/**
+ * Django-specific Q helper type.
+ *
+ * A QCondition is either a partial object of type T or a combination
+ * of partial field and object lookups.
+ *
+ * @template T
+ * @typedef {Partial<T> | (Partial<FieldLookup<T>> & Partial<ObjectLookup<T>>)} QCondition
+ */
+/**
+ * Django-specific Q helper type representing a logical grouping of conditions.
+ *
+ * @template T
+ * @typedef {Object} QObject
+ * @property {'AND'|'OR'} operator - The logical operator.
+ * @property {Array<QCondition<T>|QObject<T>>} conditions - An array of conditions or nested Q objects.
+ */
+/**
+ * Creates a Q object for combining conditions.
+ *
+ * @template T
+ * @param {'AND'|'OR'} operator - The operator to combine conditions.
+ * @param {...(QCondition<T>|QObject<T>)} conditions - The conditions to combine.
+ * @returns {QObject<T>} The combined Q object.
+ */
+export function Q(operator, ...conditions) {
+    return {
+        operator,
+        conditions,
+    };
+}