@fjell/lib-sequelize 4.4.14 → 4.4.16

package/dist/es/KeyMaster.js

@@ -1,146 +0,0 @@
-import LibLogger from './logger.js';
-import { buildRelationshipPath } from './util/relationshipUtils.js';
-
-const logger = LibLogger.get('sequelize', 'KeyMaster');
-// Helper function to extract location key value from item
-const extractLocationKeyValue = (model, item, locatorType, kta)=>{
-    logger.default('Extracting location key value', {
-        locatorType,
-        kta
-    });
-    const relationshipInfo = buildRelationshipPath(model, locatorType, kta, true);
-    if (!relationshipInfo.found) {
-        throw new Error(`Location key '${locatorType}' cannot be resolved on model '${model.name}' or through its relationships.`);
-    }
-    if (relationshipInfo.isDirect) {
-        // Direct foreign key field
-        const foreignKeyField = `${locatorType}Id`;
-        const value = item[foreignKeyField];
-        if (typeof value === 'undefined' || value === null) {
-            throw new Error(`Direct foreign key field '${foreignKeyField}' is missing or null in item`);
-        }
-        return value;
-    } else {
-        // Need to traverse relationship hierarchy
-        // Find the path through the key type array
-        const locatorIndex = kta.indexOf(locatorType);
-        if (locatorIndex === -1) {
-            throw new Error(`Locator type '${locatorType}' not found in key type array`);
-        }
-        // Start from the current item (index 0 in kta)
-        let currentObject = item;
-        // Traverse through each intermediate relationship to reach the target
-        for(let i = 1; i < locatorIndex; i++){
-            const intermediateType = kta[i];
-            // Check if the intermediate relationship object is loaded
-            if (currentObject[intermediateType] && typeof currentObject[intermediateType] === 'object') {
-                currentObject = currentObject[intermediateType];
-            } else {
-                // Try the foreign key approach if the relationship object isn't loaded
-                const foreignKeyField = `${intermediateType}Id`;
-                if (typeof currentObject[foreignKeyField] !== 'undefined' && currentObject[foreignKeyField] !== null) {
-                    // We have the foreign key but not the loaded object, we can't traverse further
-                    throw new Error(`Intermediate relationship '${intermediateType}' is not loaded. Cannot traverse to '${locatorType}'. Either include the relationship in your query or ensure it's loaded.`);
-                }
-                throw new Error(`Intermediate relationship '${intermediateType}' is missing in the relationship chain. Expected path: ${kta.slice(0, locatorIndex + 1).join(' → ')}`);
-            }
-        }
-        // Now extract the target locator value from the current object
-        // First try to get it from the loaded relationship object
-        if (currentObject[locatorType] && typeof currentObject[locatorType] === 'object' && typeof currentObject[locatorType].id !== 'undefined') {
-            return currentObject[locatorType].id;
-        }
-        // If the relationship object isn't loaded, try the foreign key field
-        const foreignKeyField = `${locatorType}Id`;
-        if (typeof currentObject[foreignKeyField] !== 'undefined' && currentObject[foreignKeyField] !== null) {
-            return currentObject[foreignKeyField];
-        }
-        throw new Error(`Unable to extract location key for '${locatorType}'. Neither the relationship object nor direct foreign key is available. Traversal path: ${kta.slice(0, locatorIndex + 1).join(' → ')}`);
-    }
-};
-const removeKey = (item)=>{
-    logger.default('Removing Key', {
-        item
-    });
-    delete item.key;
-    return item;
-};
-// export const populateKey = <
-//   S extends string,
-//   L1 extends string = never,
-//   L2 extends string = never,
-//   L3 extends string = never,
-//   L4 extends string = never,
-//   L5 extends string = never
-// >(
-//   item: ItemProperties<S, L1, L2, L3, L4, L5>,
-//   keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>
-// ): ItemProperties<S, L1, L2, L3, L4, L5> => {
-//   if (keyTypes.length === 1) {
-//     item.key = { kt: keyTypes[0], pk: item.id };
-//     delete item.id;
-//   } else if (keyTypes.length === 2) {
-//     item.key = {
-//       kt: keyTypes[0], pk: item.id,
-//       // TODO: Shouldn't this be inspecting the model to get the primary key type?
-//       loc: [{ kt: keyTypes[1], lk: item[keyTypes[1] + 'Id'] }],
-//     };
-//     delete item.id;
-//     delete item[keyTypes[1] + 'Id'];
-//   } else {
-//     throw new Error('Not implemented');
-//   }
-//   return item;
-// }
-const addKey = (model, item, keyTypes)=>{
-    logger.default('Adding Key', {
-        item
-    });
-    const key = {};
-    const modelClass = model.constructor;
-    const primaryKeyAttr = modelClass.primaryKeyAttribute;
-    if (Array.isArray(keyTypes) && keyTypes.length > 1) {
-        const type = [
-            ...keyTypes
-        ];
-        const pkType = type.shift();
-        Object.assign(key, {
-            kt: pkType,
-            pk: item[primaryKeyAttr]
-        });
-        // Build location keys for composite key
-        const locationKeys = [];
-        for (const locatorType of type){
-            try {
-                const lk = extractLocationKeyValue(modelClass, item, locatorType, keyTypes);
-                locationKeys.push({
-                    kt: locatorType,
-                    lk
-                });
-            } catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error(`Failed to extract location key for '${locatorType}'`, {
-                    error: errorMessage,
-                    item,
-                    keyTypes
-                });
-                throw error;
-            }
-        }
-        Object.assign(key, {
-            loc: locationKeys
-        });
-    } else {
-        Object.assign(key, {
-            kt: keyTypes[0],
-            pk: item[primaryKeyAttr]
-        });
-    }
-    Object.assign(item, {
-        key
-    });
-    return item;
-};
-
-export { addKey, removeKey };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/OperationContext.js

@@ -1,155 +0,0 @@
-import LibLogger from './logger.js';
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const logger = LibLogger.get('sequelize', 'OperationContext');
-/**
- * Serialize an ItemKey to a string for use in sets and maps
- */ const serializeKey = (key)=>{
-    if ('pk' in key && 'kt' in key && !('loc' in key)) {
-        // PriKey
-        return `${key.kt}:${key.pk}`;
-    } else if ('pk' in key && 'kt' in key && 'loc' in key) {
-        // ComKey
-        const locStr = key.loc.map((l)=>`${l.kt}:${l.lk}`).join(',');
-        return `${key.kt}:${key.pk}|${locStr}`;
-    }
-    throw new Error(`Unsupported key type: ${JSON.stringify(key)}`);
-};
-/**
- * Create a new OperationContext
- */ const createOperationContext = ()=>{
-    const inProgress = new Set();
-    const cache = new Map();
-    return {
-        inProgress,
-        cache,
-        markInProgress (key) {
-            const serialized = serializeKey(key);
-            logger.default('Marking key as in progress', {
-                key,
-                serialized
-            });
-            inProgress.add(serialized);
-        },
-        markComplete (key) {
-            const serialized = serializeKey(key);
-            logger.default('Marking key as complete', {
-                key,
-                serialized
-            });
-            inProgress.delete(serialized);
-        },
-        isInProgress (key) {
-            const serialized = serializeKey(key);
-            const result = inProgress.has(serialized);
-            logger.default('Checking if key is in progress', {
-                key,
-                serialized,
-                result
-            });
-            return result;
-        },
-        getCached (key) {
-            const serialized = serializeKey(key);
-            const result = cache.get(serialized);
-            logger.default('Getting cached item', {
-                key,
-                serialized,
-                found: !!result
-            });
-            return result;
-        },
-        setCached (key, item) {
-            const serialized = serializeKey(key);
-            logger.default('Caching item', {
-                key,
-                serialized
-            });
-            cache.set(serialized, item);
-        },
-        isCached (key) {
-            const serialized = serializeKey(key);
-            const result = cache.has(serialized);
-            logger.default('Checking if key is cached', {
-                key,
-                serialized,
-                result
-            });
-            return result;
-        }
-    };
-};
-/**
- * Context Manager for sharing context across operations without changing public interfaces
- */ class ContextManager {
-    /**
-   * Set the current context for the current operation chain
-   */ setCurrentContext(context) {
-        const contextId = Math.random().toString(36).substring(7);
-        this.contexts.set(contextId, context);
-        this.currentContextId = contextId;
-        logger.default('Set current context', {
-            contextId
-        });
-        return contextId;
-    }
-    /**
-   * Get the current context if one is set
-   */ getCurrentContext() {
-        if (this.currentContextId) {
-            const context = this.contexts.get(this.currentContextId);
-            logger.default('Got current context', {
-                contextId: this.currentContextId,
-                found: !!context
-            });
-            return context;
-        }
-        return;
-    }
-    /**
-   * Clear the current context
-   */ clearCurrentContext() {
-        if (this.currentContextId) {
-            logger.default('Clearing current context', {
-                contextId: this.currentContextId
-            });
-            this.contexts.delete(this.currentContextId);
-            this.currentContextId = null;
-        }
-    }
-    /**
-   * Execute a function with a specific context set as current
-   */ async withContext(context, fn) {
-        const previousContextId = this.currentContextId;
-        this.setCurrentContext(context);
-        try {
-            return await fn();
-        } finally{
-            this.clearCurrentContext();
-            if (previousContextId) {
-                this.currentContextId = previousContextId;
-            }
-        }
-    }
-    constructor(){
-        _define_property(this, "contexts", new Map());
-        _define_property(this, "currentContextId", null);
-    }
-}
-// Global context manager instance
-const contextManager = new ContextManager();
-
-export { contextManager, createOperationContext, serializeKey };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9uQ29udGV4dC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/Operations.js

@@ -1,30 +0,0 @@
-import { getAllOperation } from './ops/all.js';
-import { getCreateOperation } from './ops/create.js';
-import { getFindOperation } from './ops/find.js';
-import { getGetOperation } from './ops/get.js';
-import { getOneOperation } from './ops/one.js';
-import { getRemoveOperation } from './ops/remove.js';
-import { getUpdateOperation } from './ops/update.js';
-
-const createOperations = (models, coordinate, registry, options)=>{
-    const operations = {};
-    // Create a definition-like object for backward compatibility with existing operation functions
-    const definition = {
-        coordinate,
-        options
-    };
-    operations.all = getAllOperation(models, definition, registry);
-    operations.one = getOneOperation(models, definition, registry);
-    operations.create = getCreateOperation(models, definition, registry);
-    operations.update = getUpdateOperation(models, definition, registry);
-    operations.get = getGetOperation(models, definition, registry);
-    operations.remove = getRemoveOperation(models, definition);
-    operations.find = getFindOperation(models, definition, registry);
-    operations.upsert = async ()=>{
-        throw new Error('Not implemented');
-    };
-    return operations;
-};
-
-export { createOperations };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/Options.js

@@ -1,23 +0,0 @@
-import * as Library from '@fjell/lib';
-
-const DEFAULT_SEQUELIZE_OPTIONS = {
-    deleteOnRemove: false,
-    references: [],
-    aggregations: []
-};
-const createOptions = (sequelizeOptions)=>{
-    // Create the base lib options
-    const baseOptions = Library.createOptions(sequelizeOptions);
-    var _sequelizeOptions_deleteOnRemove, _sequelizeOptions_references, _sequelizeOptions_aggregations;
-    // Add Sequelize-specific defaults
-    const result = {
-        ...baseOptions,
-        deleteOnRemove: (_sequelizeOptions_deleteOnRemove = sequelizeOptions === null || sequelizeOptions === void 0 ? void 0 : sequelizeOptions.deleteOnRemove) !== null && _sequelizeOptions_deleteOnRemove !== void 0 ? _sequelizeOptions_deleteOnRemove : DEFAULT_SEQUELIZE_OPTIONS.deleteOnRemove,
-        references: (_sequelizeOptions_references = sequelizeOptions === null || sequelizeOptions === void 0 ? void 0 : sequelizeOptions.references) !== null && _sequelizeOptions_references !== void 0 ? _sequelizeOptions_references : DEFAULT_SEQUELIZE_OPTIONS.references,
-        aggregations: (_sequelizeOptions_aggregations = sequelizeOptions === null || sequelizeOptions === void 0 ? void 0 : sequelizeOptions.aggregations) !== null && _sequelizeOptions_aggregations !== void 0 ? _sequelizeOptions_aggregations : DEFAULT_SEQUELIZE_OPTIONS.aggregations
-    };
-    return result;
-};
-
-export { createOptions };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/QueryBuilder.js

@@ -1,290 +0,0 @@
-import { isCondition, isPriKey, isComKey } from '@fjell/core';
-import { Op } from 'sequelize';
-import LibLogger from './logger.js';
-import { stringifyJSON } from './util/general.js';
-
-const logger = LibLogger.get('sequelize', 'QueryBuilder');
-const addDeleteQuery = (options, model)=>{
-    logger.default(`QueryBuilder adding delete query with options: ${stringifyJSON(options)}`);
-    if (model.getAttributes().deletedAt) {
-        options.where['deletedAt'] = {
-            [Op.eq]: null
-        };
-    } else if (model.getAttributes().isDeleted) {
-        options.where['isDeleted'] = {
-            [Op.eq]: false
-        };
-    }
-    return options;
-};
-const addEventQueries = (options, events, model)=>{
-    logger.default(`QueryBuilder adding event queries with options: ${stringifyJSON(options)}, events: ${stringifyJSON(events)}`);
-    Object.keys(events).forEach((key)=>{
-        if (!model.getAttributes()[`${key}At`]) {
-            throw new Error(`Event ${key} is not supported on this model, column ${key}At not found`);
-        }
-        let whereClauses = {};
-        const event = events[key];
-        if (event.start) {
-            whereClauses = {
-                ...whereClauses,
-                [Op.gte]: new Date(event.start)
-            };
-        }
-        if (event.end) {
-            whereClauses = {
-                ...whereClauses,
-                [Op.lt]: new Date(event.end)
-            };
-        }
-        if (event.by) {
-            if (!model.getAttributes()[`${key}By`]) {
-                throw new Error(`Event ${key} is not supported on this model, column ${key}By not found`);
-            }
-            whereClauses = {
-                ...whereClauses,
-                [Op.eq]: event.by
-            };
-        }
-        options.where[`${key}At`] = whereClauses;
-    });
-    return options;
-};
-// Add the references to the query
-const addReferenceQueries = (options, references, model)=>{
-    logger.default(`QueryBuilder adding reference queries with options: ${stringifyJSON(options)}, references: ${stringifyJSON(references)}`);
-    Object.keys(references).forEach((key)=>{
-        logger.default(`QueryBuilder adding reference query for key: ${key}, references: ${stringifyJSON(references)}`);
-        if (!model.getAttributes()[`${key}Id`]) {
-            throw new Error(`Reference ${key} is not supported on this model, column ${key}Id not found`);
-        }
-        if (isPriKey(references[key])) {
-            const priKey = references[key];
-            if (priKey.pk == null || priKey.pk === '' || typeof priKey.pk === 'object' && Object.keys(priKey.pk).length === 0) {
-                logger.error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`, {
-                    priKey,
-                    references
-                });
-                throw new Error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`);
-            }
-            logger.trace(`[QueryBuilder] Setting reference where clause: ${key}Id = ${stringifyJSON(priKey.pk)} (type: ${typeof priKey.pk})`);
-            options.where[`${key}Id`] = {
-                [Op.eq]: priKey.pk
-            };
-        } else if (isComKey(references[key])) {
-            throw new Error('ComKeys are not supported in Sequelize');
-        }
-    });
-    return options;
-};
-const addCompoundCondition = (options, compoundCondition, model)=>{
-    // Ensure options.where exists
-    options.where = options.where || {};
-    let compoundOp;
-    const compoundType = compoundCondition.compoundType;
-    if (compoundType === "AND") {
-        compoundOp = Op.and;
-    } else {
-        compoundOp = Op.or;
-    }
-    let conditions = {};
-    compoundCondition.conditions.forEach((condition)=>{
-        if (isCondition(condition)) {
-            conditions = addCondition(conditions, condition, model);
-        } else {
-            throw new Error('Nest Compound conditions not supported');
-        }
-    });
-    // Merge with existing where conditions instead of replacing
-    if (Object.keys(options.where).length > 0) {
-        // If there are existing conditions, wrap everything in an AND
-        options.where = {
-            [Op.and]: [
-                options.where,
-                {
-                    [compoundOp]: conditions
-                }
-            ]
-        };
-    } else {
-        // If no existing conditions, just set the compound condition
-        options.where[compoundOp] = conditions;
-    }
-    return options;
-};
-const getSequelizeOperator = (operator)=>{
-    if (operator === '==') {
-        return Op.eq;
-    } else if (operator === '<') {
-        return Op.lt;
-    } else if (operator === '>') {
-        return Op.gt;
-    } else if (operator === '<=') {
-        return Op.lte;
-    } else if (operator === '>=') {
-        return Op.gte;
-    } else if (operator === 'in') {
-        return Op.in;
-    } else {
-        throw new Error(`Operator ${operator} not supported`);
-    }
-};
-const addAssociationCondition = (conditions, condition, model)=>{
-    const [associationName, attributeName] = condition.column.split('.', 2);
-    // Check if the association exists on the model
-    if (!model.associations || !model.associations[associationName]) {
-        throw new Error(`Association ${associationName} not found on model ${model.name}`);
-    }
-    const association = model.associations[associationName];
-    const associatedModel = association.target;
-    // Check if the attribute exists on the associated model
-    if (!associatedModel.getAttributes()[attributeName]) {
-        throw new Error(`Attribute ${attributeName} not found on associated model ${associatedModel.name} for association ${associationName}`);
-    }
-    // Use Sequelize's $association.attribute$ syntax for querying associated models
-    const sequelizeAssociationColumn = `$${associationName}.${attributeName}$`;
-    const conditionOp = getSequelizeOperator(condition.operator);
-    if (condition.value == null && condition.operator !== '==' && condition.operator !== 'in') {
-        logger.error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`, {
-            condition
-        });
-        throw new Error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`);
-    }
-    logger.trace(`[QueryBuilder] Setting association condition: ${sequelizeAssociationColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
-    conditions[sequelizeAssociationColumn] = {
-        [conditionOp]: condition.value
-    };
-    return conditions;
-};
-const addAttributeCondition = (conditions, condition, model)=>{
-    const conditionColumn = condition.column;
-    if (!model.getAttributes()[conditionColumn]) {
-        throw new Error(`Condition column ${conditionColumn} not found on model ${model.name}`);
-    }
-    const conditionOp = getSequelizeOperator(condition.operator);
-    if (condition.value == null && condition.operator !== '==' && condition.operator !== 'in') {
-        logger.error(`Attribute condition for '${conditionColumn}' has undefined/null value`, {
-            condition
-        });
-        throw new Error(`Attribute condition for '${conditionColumn}' has undefined/null value`);
-    }
-    logger.trace(`[QueryBuilder] Setting attribute condition: ${conditionColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
-    conditions[conditionColumn] = {
-        [conditionOp]: condition.value
-    };
-    return conditions;
-};
-const addCondition = (conditions, condition, model)=>{
-    const conditionColumn = condition.column;
-    // Check if this is an association query (contains a dot)
-    if (conditionColumn.includes('.')) {
-        return addAssociationCondition(conditions, condition, model);
-    }
-    // Handle regular column queries
-    return addAttributeCondition(conditions, condition, model);
-};
-const collectAssociationsFromConditions = (conditions)=>{
-    const associations = new Set();
-    const processObject = (obj)=>{
-        if (typeof obj === 'object' && obj !== null) {
-            // Check string keys
-            Object.keys(obj).forEach((key)=>{
-                // Check if this is an association reference ($association.attribute$)
-                if (typeof key === 'string' && key.startsWith('$') && key.endsWith('$') && key.includes('.')) {
-                    const associationName = key.substring(1, key.indexOf('.'));
-                    associations.add(associationName);
-                }
-                // Recursively process nested objects
-                if (typeof obj[key] === 'object') {
-                    processObject(obj[key]);
-                }
-            });
-            // Also check Symbol keys (for compound conditions like Op.and, Op.or)
-            Object.getOwnPropertySymbols(obj).forEach((symbol)=>{
-                if (typeof obj[symbol] === 'object') {
-                    processObject(obj[symbol]);
-                }
-            });
-        }
-        // Handle arrays (for compound conditions that might be arrays)
-        if (Array.isArray(obj)) {
-            obj.forEach((item)=>{
-                if (typeof item === 'object') {
-                    processObject(item);
-                }
-            });
-        }
-    };
-    processObject(conditions);
-    return associations;
-};
-const addAssociationIncludes = (options, model)=>{
-    // Collect all association names used in conditions
-    const referencedAssociations = collectAssociationsFromConditions(options.where);
-    if (referencedAssociations.size > 0) {
-        options.include = options.include || [];
-        // Add each referenced association to the include array
-        referencedAssociations.forEach((associationName)=>{
-            // Check if this association is already included
-            const alreadyIncluded = options.include.some((inc)=>typeof inc === 'string' && inc === associationName || typeof inc === 'object' && inc.association === associationName);
-            if (!alreadyIncluded && model.associations && model.associations[associationName]) {
-                options.include.push({
-                    model: model.associations[associationName].target,
-                    as: associationName,
-                    required: false // Use LEFT JOIN so records without associations are still returned
-                });
-            }
-        });
-    }
-    return options;
-};
-const buildQuery = (itemQuery, model)=>{
-    logger.default(`QueryBuilder build called with itemQuery: ${stringifyJSON(itemQuery)}`);
-    let options = {
-        where: {}
-    };
-    if (itemQuery.compoundCondition) {
-        logger.default(`QueryBuilder adding conditions: ${stringifyJSON(itemQuery.compoundCondition)}`);
-        options = addCompoundCondition(options, itemQuery.compoundCondition, model);
-    }
-    // If the model has a deletedAt column, we need to add a delete query
-    if (model.getAttributes().deletedAt || model.getAttributes().isDeleted) {
-        options = addDeleteQuery(options, model);
-    }
-    if (itemQuery.refs) {
-        options = addReferenceQueries(options, itemQuery.refs, model);
-    }
-    if (itemQuery.events) {
-        options = addEventQueries(options, itemQuery.events, model);
-    }
-    // TODO: Once we start to support Aggs on the server-side, we'll need to parse agg queries
-    // Apply a limit to the result set
-    if (itemQuery.limit) {
-        logger.default(`QueryBuilder applying limit: ${itemQuery.limit}`);
-        options.limit = itemQuery.limit;
-    }
-    // Apply an offset to the result set
-    if (itemQuery.offset) {
-        options.offset = itemQuery.offset;
-    }
-    // Add orderBy to the query
-    if (itemQuery.orderBy) {
-        itemQuery.orderBy.forEach((orderBy)=>{
-            if (!model.getAttributes()[orderBy.field]) {
-                throw new Error(`Order by field ${orderBy.field} not found on model ${model.name}`);
-            }
-            options.order = [
-                [
-                    orderBy.field,
-                    orderBy.direction
-                ]
-            ];
-        });
-    }
-    // Add includes for any associations referenced in conditions
-    options = addAssociationIncludes(options, model);
-    return options;
-};
-
-export { addCompoundCondition, addCondition, buildQuery };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=