@fjell/lib-sequelize 4.4.14 → 4.4.16

package/dist/index.cjs

@@ -1,1853 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Library = require('@fjell/lib');
-const Logging = require('@fjell/logging');
-const registry = require('@fjell/registry');
-const core = require('@fjell/core');
-const sequelize = require('sequelize');
-require('deepmerge');
-
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
-  if (e) {
-    for (const k in e) {
-      if (k !== 'default') {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-const Library__namespace = /*#__PURE__*/_interopNamespaceDefault(Library);
-
-const DEFAULT_SEQUELIZE_OPTIONS = {
-    deleteOnRemove: false,
-    references: [],
-    aggregations: []
-};
-const createOptions = (sequelizeOptions)=>{
-    // Create the base lib options
-    const baseOptions = Library__namespace.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;
-};
-
-const logger$1.default = Logging.getLogger('@fjell/lib-sequelize');
-
-const logger$i = logger$1.default.get('Coordinate');
-const SCOPE_SEQUELIZE = 'sequelize';
-const createCoordinate = (kta, scopes)=>{
-    logger$i.debug('createCoordinate', {
-        kta,
-        scopes
-    });
-    const coordinate = registry.createCoordinate(kta, [
-        SCOPE_SEQUELIZE,
-        ...scopes || []
-    ]);
-    return coordinate;
-};
-
-const logger$h = logger$1.default.get('lib-sequelize', 'Definition');
-const createDefinition = (kta, scopes, libOptions)=>{
-    logger$h.debug('createDefinition', {
-        kta,
-        scopes,
-        libOptions
-    });
-    const coordinate = createCoordinate(kta, scopes);
-    const options = createOptions(libOptions);
-    return {
-        coordinate,
-        options
-    };
-};
-
-//Recursive implementation of jSON.stringify;
-const stringifyJSON = function(obj, visited = new Set()) {
-    const arrOfKeyVals = [];
-    const arrVals = [];
-    let objKeys = [];
-    /*********CHECK FOR PRIMITIVE TYPES**********/ if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null) return '' + obj;
-    else if (typeof obj === 'string') return '"' + obj + '"';
-    /*********DETECT CIRCULAR REFERENCES**********/ if (obj instanceof Object && visited.has(obj)) {
-        return '"(circular)"';
-    } else if (Array.isArray(obj)) {
-        //check for empty array
-        if (obj[0] === undefined) return '[]';
-        else {
-            // Add array to visited before processing its elements
-            visited.add(obj);
-            obj.forEach(function(el) {
-                arrVals.push(stringifyJSON(el, visited));
-            });
-            return '[' + arrVals + ']';
-        }
-    } else if (obj instanceof Object) {
-        // Add object to visited before processing its properties
-        visited.add(obj);
-        //get object keys
-        objKeys = Object.keys(obj);
-        //set key output;
-        objKeys.forEach(function(key) {
-            const keyOut = '"' + key + '":';
-            const keyValOut = obj[key];
-            //skip functions and undefined properties
-            if (keyValOut instanceof Function || keyValOut === undefined) return; // Skip this entry entirely instead of pushing an empty string
-            else if (typeof keyValOut === 'string') arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
-            else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null) arrOfKeyVals.push(keyOut + keyValOut);
-            else if (keyValOut instanceof Object) {
-                arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));
-            }
-        });
-        return '{' + arrOfKeyVals + '}';
-    }
-    return '';
-};
-
-const logger$g = logger$1.default.get('sequelize', 'QueryBuilder');
-const addDeleteQuery = (options, model)=>{
-    logger$g.default(`QueryBuilder adding delete query with options: ${stringifyJSON(options)}`);
-    if (model.getAttributes().deletedAt) {
-        options.where['deletedAt'] = {
-            [sequelize.Op.eq]: null
-        };
-    } else if (model.getAttributes().isDeleted) {
-        options.where['isDeleted'] = {
-            [sequelize.Op.eq]: false
-        };
-    }
-    return options;
-};
-const addEventQueries = (options, events, model)=>{
-    logger$g.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,
-                [sequelize.Op.gte]: new Date(event.start)
-            };
-        }
-        if (event.end) {
-            whereClauses = {
-                ...whereClauses,
-                [sequelize.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,
-                [sequelize.Op.eq]: event.by
-            };
-        }
-        options.where[`${key}At`] = whereClauses;
-    });
-    return options;
-};
-// Add the references to the query
-const addReferenceQueries = (options, references, model)=>{
-    logger$g.default(`QueryBuilder adding reference queries with options: ${stringifyJSON(options)}, references: ${stringifyJSON(references)}`);
-    Object.keys(references).forEach((key)=>{
-        logger$g.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 (core.isPriKey(references[key])) {
-            const priKey = references[key];
-            if (priKey.pk == null || priKey.pk === '' || typeof priKey.pk === 'object' && Object.keys(priKey.pk).length === 0) {
-                logger$g.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$g.trace(`[QueryBuilder] Setting reference where clause: ${key}Id = ${stringifyJSON(priKey.pk)} (type: ${typeof priKey.pk})`);
-            options.where[`${key}Id`] = {
-                [sequelize.Op.eq]: priKey.pk
-            };
-        } else if (core.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 = sequelize.Op.and;
-    } else {
-        compoundOp = sequelize.Op.or;
-    }
-    let conditions = {};
-    compoundCondition.conditions.forEach((condition)=>{
-        if (core.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 = {
-            [sequelize.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 sequelize.Op.eq;
-    } else if (operator === '<') {
-        return sequelize.Op.lt;
-    } else if (operator === '>') {
-        return sequelize.Op.gt;
-    } else if (operator === '<=') {
-        return sequelize.Op.lte;
-    } else if (operator === '>=') {
-        return sequelize.Op.gte;
-    } else if (operator === 'in') {
-        return sequelize.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$g.error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`, {
-            condition
-        });
-        throw new Error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`);
-    }
-    logger$g.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$g.error(`Attribute condition for '${conditionColumn}' has undefined/null value`, {
-            condition
-        });
-        throw new Error(`Attribute condition for '${conditionColumn}' has undefined/null value`);
-    }
-    logger$g.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$g.default(`QueryBuilder build called with itemQuery: ${stringifyJSON(itemQuery)}`);
-    let options = {
-        where: {}
-    };
-    if (itemQuery.compoundCondition) {
-        logger$g.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$g.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;
-};
-
-/* eslint-disable indent */ /**
- * Helper function to build relationship chain includes
- */ const buildRelationshipChain = (targetModel, kta, currentIndex, targetIndex)=>{
-    // Build the association path and validate relationships exist
-    const associationParts = [];
-    const modelChain = [
-        targetModel
-    ];
-    let currentModel = targetModel;
-    // Validate that all associations exist and build model chain
-    for(let i = currentIndex + 1; i <= targetIndex; i++){
-        const intermediateType = kta[i];
-        const associationName = intermediateType;
-        if (!currentModel.associations || !currentModel.associations[associationName]) {
-            return {
-                success: false
-            };
-        }
-        associationParts.push(associationName);
-        currentModel = currentModel.associations[associationName].target;
-        modelChain.push(currentModel);
-    }
-    // Build the full association path for the target field
-    const targetPrimaryKey = currentModel.primaryKeyAttribute || 'id';
-    const associationPath = `$${associationParts.join('.')}.${targetPrimaryKey}$`;
-    // Build nested includes structure iteratively (clearer than recursion)
-    let deepestInclude = null;
-    // Build from the deepest level back to the root
-    for(let i = targetIndex; i > currentIndex; i--){
-        const currentType = kta[i];
-        const modelIndex = i - currentIndex;
-        const includeObj = {
-            model: modelChain[modelIndex],
-            as: currentType,
-            required: true
-        };
-        if (deepestInclude) {
-            includeObj.include = [
-                deepestInclude
-            ];
-        }
-        deepestInclude = includeObj;
-    }
-    const includes = deepestInclude ? [
-        deepestInclude
-    ] : [];
-    return {
-        success: true,
-        path: associationPath,
-        includes
-    };
-};
-/**
- * Helper function to build relationship path for a locator
- * @param includeIsDirect Whether to include the isDirect flag in the result
- */ const relationshipUtils.buildRelationshipPath = (targetModel, locatorType, kta, includeIsDirect = false)=>{
-    // First check if the field exists directly
-    const directFieldName = `${locatorType}Id`;
-    const attributes = targetModel.getAttributes();
-    if (attributes && attributes[directFieldName]) {
-        const result = {
-            found: true
-        };
-        if (includeIsDirect) {
-            result.isDirect = true;
-        }
-        return result;
-    }
-    // If not direct, look for relationship path
-    const targetIndex = kta.indexOf(locatorType);
-    if (targetIndex === -1) {
-        const result = {
-            found: false
-        };
-        if (includeIsDirect) {
-            result.isDirect = false;
-        }
-        return result;
-    }
-    const currentIndex = 0; // We're always looking from the base model
-    if (targetIndex <= currentIndex) {
-        const result = {
-            found: false
-        };
-        if (includeIsDirect) {
-            result.isDirect = false;
-        }
-        return result;
-    }
-    const chainResult = buildRelationshipChain(targetModel, kta, currentIndex, targetIndex);
-    if (chainResult.success) {
-        const result = {
-            found: true,
-            path: chainResult.path,
-            includes: chainResult.includes
-        };
-        if (includeIsDirect) {
-            result.isDirect = false;
-        }
-        return result;
-    }
-    const result = {
-        found: false
-    };
-    if (includeIsDirect) {
-        result.isDirect = false;
-    }
-    return result;
-};
-
-const logger$f = logger$1.default.get('sequelize', 'KeyMaster');
-// Helper function to extract location key value from item
-const extractLocationKeyValue = (model, item, locatorType, kta)=>{
-    logger$f.default('Extracting location key value', {
-        locatorType,
-        kta
-    });
-    const relationshipInfo = relationshipUtils.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$f.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$f.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$f.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;
-};
-
-const logger$e = logger$1.default.get('sequelize', 'ReferenceBuilder');
-const buildReference = async (item, referenceDefinition, registry, context)=>{
-    // Check if there is more than one key type
-    if (referenceDefinition.kta.length > 1) {
-        throw new Error("The ReferenceBuilder doesn't work with more than one key type yet");
-    }
-    // Check if dependencies exist
-    if (!registry) {
-        throw new Error("This model definition has a reference definition, but the registry is not present");
-    }
-    // Find the Library.Instance for the key type
-    const library = registry.get(referenceDefinition.kta);
-    if (!library) {
-        throw new Error("This model definition has a reference definition, but the dependency is not present");
-    }
-    // Check if the column value is null - if so, skip the reference
-    const columnValue = item[referenceDefinition.column];
-    if (columnValue == null) {
-        item[referenceDefinition.property] = null;
-        return item;
-    }
-    // Create a PriKey using the column value from item
-    const priKey = {
-        kt: referenceDefinition.kta[0],
-        pk: columnValue
-    };
-    let referencedItem;
-    if (context) {
-        // Check if we already have this item cached
-        if (context.isCached(priKey)) {
-            logger$e.default('Using cached reference', {
-                priKey,
-                property: referenceDefinition.property
-            });
-            referencedItem = context.getCached(priKey);
-        } else if (context.isInProgress(priKey)) {
-            logger$e.default('Circular dependency detected, creating reference placeholder', {
-                priKey,
-                property: referenceDefinition.property
-            });
-            // Create a minimal reference object with just the key to break the cycle
-            referencedItem = {
-                key: priKey
-            };
-        } else {
-            // Mark this key as in progress before loading
-            context.markInProgress(priKey);
-            try {
-                // Get the referenced item using the Library.Operations get method (context now managed internally)
-                referencedItem = await library.operations.get(priKey);
-                // Cache the result
-                context.setCached(priKey, referencedItem);
-            } finally{
-                // Always mark as complete, even if there was an error
-                context.markComplete(priKey);
-            }
-        }
-    } else {
-        // Fallback to original behavior if no context provided
-        referencedItem = await library.operations.get(priKey);
-    }
-    // TODO: In a Fjell-compliant implementation, this value should be stored in the ref property
-    // For now, we'll just populate the property directly
-    // Store the result in the property on item
-    item[referenceDefinition.property] = referencedItem;
-    return item;
-};
-
-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$d = logger$1.default.get('sequelize', 'OperationContext');
-/**
- * Serialize an ItemKey to a string for use in sets and maps
- */ const OperationContext.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 = OperationContext.serializeKey(key);
-            logger$d.default('Marking key as in progress', {
-                key,
-                serialized
-            });
-            inProgress.add(serialized);
-        },
-        markComplete (key) {
-            const serialized = OperationContext.serializeKey(key);
-            logger$d.default('Marking key as complete', {
-                key,
-                serialized
-            });
-            inProgress.delete(serialized);
-        },
-        isInProgress (key) {
-            const serialized = OperationContext.serializeKey(key);
-            const result = inProgress.has(serialized);
-            logger$d.default('Checking if key is in progress', {
-                key,
-                serialized,
-                result
-            });
-            return result;
-        },
-        getCached (key) {
-            const serialized = OperationContext.serializeKey(key);
-            const result = cache.get(serialized);
-            logger$d.default('Getting cached item', {
-                key,
-                serialized,
-                found: !!result
-            });
-            return result;
-        },
-        setCached (key, item) {
-            const serialized = OperationContext.serializeKey(key);
-            logger$d.default('Caching item', {
-                key,
-                serialized
-            });
-            cache.set(serialized, item);
-        },
-        isCached (key) {
-            const serialized = OperationContext.serializeKey(key);
-            const result = cache.has(serialized);
-            logger$d.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$d.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$d.default('Got current context', {
-                contextId: this.currentContextId,
-                found: !!context
-            });
-            return context;
-        }
-        return;
-    }
-    /**
-   * Clear the current context
-   */ clearCurrentContext() {
-        if (this.currentContextId) {
-            logger$d.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 OperationContext.contextManager = new ContextManager();
-
-const logger$c = logger$1.default.get('sequelize', 'AggregationBuilder');
-const buildAggregation = async (item, aggregationDefinition, registry, context)=>{
-    const location = core.ikToLKA(item.key);
-    // Get the library instance from the registry using the key type array
-    const libraryInstance = registry.get(aggregationDefinition.kta);
-    if (!libraryInstance) {
-        throw new Error(`Library instance not found for key type array: ${aggregationDefinition.kta.join(', ')}`);
-    }
-    // Create a cache key for this aggregation query
-    // This helps avoid running the same aggregation multiple times
-    const aggregationCacheKey = `${aggregationDefinition.kta.join('.')}_${aggregationDefinition.cardinality}_${OperationContext.serializeKey(item.key)}`;
-    if (context) {
-        // Check if this aggregation is already cached
-        if (context.cache.has(aggregationCacheKey)) {
-            const cachedResult = context.cache.get(aggregationCacheKey);
-            logger$c.default('Using cached aggregation result', {
-                aggregationCacheKey,
-                property: aggregationDefinition.property
-            });
-            item[aggregationDefinition.property] = cachedResult;
-            return item;
-        }
-    // Note: We don't check for circular dependencies here because:
-    // 1. Aggregations are location-based queries, not key-based references
-    // 2. They should be allowed to run during normal item processing
-    // 3. The main circular dependency concern is with references, not aggregations
-    }
-    // Execute aggregation within the current context to ensure context sharing
-    return OperationContext.contextManager.withContext(context || OperationContext.contextManager.getCurrentContext() || {
-        inProgress: new Set(),
-        cache: new Map()
-    }, async ()=>{
-        // Based on cardinality, use either one or all operation
-        if (aggregationDefinition.cardinality === 'one') {
-            // For one-to-one relationship, use the one operation
-            return libraryInstance.operations.one({}, location).then((result)=>{
-                if (context) {
-                    context.cache.set(aggregationCacheKey, result);
-                }
-                item[aggregationDefinition.property] = result;
-                return item;
-            });
-        } else {
-            // For one-to-many relationship, use the all operation
-            return libraryInstance.operations.all({}, location).then((results)=>{
-                if (context) {
-                    context.cache.set(aggregationCacheKey, results);
-                }
-                item[aggregationDefinition.property] = results;
-                return item;
-            });
-        }
-    });
-};
-
-const logger$b = logger$1.default.get("sequelize", "EventCoordinator");
-//#endregion
-const populateEvents = (item)=>{
-    const events = {
-        created: {
-            at: item.createdAt || null
-        },
-        updated: {
-            at: item.updatedAt || null
-        },
-        deleted: {
-            at: null
-        }
-    };
-    item.events = events;
-    return item;
-};
-const extractEvents = (item)=>{
-    logger$b.default('Extracting Events to database fields', {
-        item
-    });
-    if (item.events) {
-        var _item_events_created, _item_events_updated, _item_events_deleted;
-        if ((_item_events_created = item.events.created) === null || _item_events_created === void 0 ? void 0 : _item_events_created.at) {
-            item.createdAt = item.events.created.at;
-        }
-        if ((_item_events_updated = item.events.updated) === null || _item_events_updated === void 0 ? void 0 : _item_events_updated.at) {
-            item.updatedAt = item.events.updated.at;
-        }
-        if ((_item_events_deleted = item.events.deleted) === null || _item_events_deleted === void 0 ? void 0 : _item_events_deleted.at) {
-            item.deletedAt = item.events.deleted.at;
-        }
-    }
-    return item;
-};
-const removeEvents = (item)=>{
-    logger$b.default('Removing Events', {
-        item
-    });
-    delete item.events;
-    return item;
-};
-
-const logger$a = logger$1.default.get('sequelize', 'RowProcessor');
-const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context)=>{
-    logger$a.default('Processing Row', {
-        row
-    });
-    // Use provided context or create new one
-    const operationContext = context || createOperationContext();
-    // Process the row within the context to ensure all operations share the same context
-    return OperationContext.contextManager.withContext(operationContext, async ()=>{
-        let item = row.get({
-            plain: true
-        });
-        logger$a.default('Adding Key to Item with Key Types: %s', stringifyJSON(keyTypes));
-        item = addKey(row, item, keyTypes);
-        item = populateEvents(item);
-        logger$a.default('Key Added to Item: %s', stringifyJSON(item.key));
-        // Mark this item as in progress to detect circular references
-        operationContext.markInProgress(item.key);
-        try {
-            if (referenceDefinitions && referenceDefinitions.length > 0) {
-                for (const referenceDefinition of referenceDefinitions){
-                    logger$a.default('Processing Reference for %s to %s', item.key.kt, stringifyJSON(referenceDefinition.kta));
-                    item = await buildReference(item, referenceDefinition, registry, operationContext);
-                }
-            }
-            if (aggregationDefinitions && aggregationDefinitions.length > 0) {
-                for (const aggregationDefinition of aggregationDefinitions){
-                    logger$a.default('Processing Aggregation for %s from %s', item.key.kt, stringifyJSON(aggregationDefinition.kta));
-                    item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
-                }
-            }
-            // Cache the fully processed item
-            operationContext.setCached(item.key, item);
-        } finally{
-            // Mark this item as complete
-            operationContext.markComplete(item.key);
-        }
-        logger$a.default('Processed Row: %j', stringifyJSON(item));
-        return item;
-    });
-};
-
-const logger$9 = logger$1.default.get('sequelize', 'ops', 'all');
-// Helper function to merge includes avoiding duplicates
-const mergeIncludes$1 = (existingIncludes, newIncludes)=>{
-    const mergedIncludes = [
-        ...existingIncludes
-    ];
-    for (const newInclude of newIncludes){
-        const existingIndex = mergedIncludes.findIndex((existing)=>existing.as === newInclude.as && existing.model === newInclude.model);
-        if (existingIndex === -1) {
-            mergedIncludes.push(newInclude);
-        } else if (newInclude.include && mergedIncludes[existingIndex].include) {
-            mergedIncludes[existingIndex].include = [
-                ...mergedIncludes[existingIndex].include,
-                ...newInclude.include
-            ];
-        } else if (newInclude.include) {
-            mergedIncludes[existingIndex].include = newInclude.include;
-        }
-    }
-    return mergedIncludes;
-};
-const all.getAllOperation = (models, definition, registry)=>{
-    const { coordinate, options: { references, aggregations } } = definition;
-    //#region Query
-    const all = async (itemQuery, locations)=>{
-        var _options_include;
-        logger$9.debug(`ALL operation called on ${models[0].name} with ${(locations === null || locations === void 0 ? void 0 : locations.length) || 0} location filters: ${(locations === null || locations === void 0 ? void 0 : locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ')) || 'none'}`);
-        const loc = locations || [];
-        // @ts-ignore
-        const model = models[0];
-        // Build base query from itemQuery
-        const options = buildQuery(itemQuery, model);
-        // Handle location keys if present
-        if (loc.length > 0) {
-            const { kta } = coordinate;
-            const directLocations = [];
-            const hierarchicalLocations = [];
-            const additionalIncludes = [];
-            // Categorize location keys as direct or hierarchical
-            for (const locKey of loc){
-                const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta, true);
-                if (!relationshipInfo.found) {
-                    const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-                    logger$9.error(errorMessage, {
-                        locations: loc,
-                        kta
-                    });
-                    throw new Error(errorMessage);
-                }
-                if (relationshipInfo.isDirect) {
-                    directLocations.push(locKey);
-                } else {
-                    hierarchicalLocations.push(locKey);
-                }
-            }
-            // Handle direct location keys (simple foreign key constraints)
-            for (const locKey of directLocations){
-                if (locKey.lk === undefined || locKey.lk == null || locKey.lk === '' || typeof locKey.lk === 'object' && Object.keys(locKey.lk).length === 0) {
-                    logger$9.error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, {
-                        locKey,
-                        locations: loc
-                    });
-                    throw new Error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
-                }
-                const foreignKeyField = locKey.kt + 'Id';
-                // Check if this field already has a condition from the itemQuery
-                if (options.where[foreignKeyField]) {
-                    logger$9.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
-                    continue; // Skip this location constraint to avoid conflicts
-                }
-                logger$9.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
-                options.where[foreignKeyField] = {
-                    [sequelize.Op.eq]: locKey.lk
-                };
-            }
-            // Handle hierarchical location keys (requires relationship traversal)
-            for (const locKey of hierarchicalLocations){
-                if (locKey.lk === undefined || locKey.lk == null || locKey.lk === '' || typeof locKey.lk === 'object' && Object.keys(locKey.lk).length === 0) {
-                    logger$9.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, {
-                        locKey,
-                        locations: loc
-                    });
-                    throw new Error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
-                }
-                const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta);
-                if (relationshipInfo.found && relationshipInfo.path) {
-                    // Check if this field already has a condition from the itemQuery
-                    if (options.where[relationshipInfo.path]) {
-                        logger$9.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
-                        continue; // Skip this location constraint to avoid conflicts
-                    }
-                    // Add the relationship constraint using the path
-                    logger$9.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
-                    options.where[relationshipInfo.path] = {
-                        [sequelize.Op.eq]: locKey.lk
-                    };
-                    // Add necessary includes for the relationship traversal
-                    if (relationshipInfo.includes) {
-                        additionalIncludes.push(...relationshipInfo.includes);
-                    }
-                }
-            }
-            // Merge additional includes with existing includes
-            if (additionalIncludes.length > 0) {
-                const existingIncludes = options.include || [];
-                options.include = mergeIncludes$1(existingIncludes, additionalIncludes);
-            }
-        }
-        logger$9.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(', ') : 'none'}, includes: ${((_options_include = options.include) === null || _options_include === void 0 ? void 0 : _options_include.length) || 0}`);
-        try {
-            logger$9.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
-        } catch  {
-            // Fallback for cases where JSON.stringify fails on Sequelize operators
-            logger$9.trace(`[ALL] Executing ${model.name}.findAll() with options containing non-serializable operators (${Object.keys(options.where || {}).length} where conditions)`);
-        }
-        const matchingItems = await model.findAll(options);
-        // this.logger.default('Matching Items', { matchingItems });
-        // Get the current context from context manager
-        const context = OperationContext.contextManager.getCurrentContext();
-        // TODO: Move this Up!
-        const results = await Promise.all(matchingItems.map(async (row)=>{
-            const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry, context);
-            return core.validateKeys(processedRow, coordinate.kta);
-        }));
-        logger$9.debug(`[ALL] Returning ${results.length} ${model.name} records`);
-        return results;
-    };
-    return all;
-};
-
-const logger$8 = logger$1.default.get('sequelize', 'ops', 'create');
-// Helper function to translate PostgreSQL errors to meaningful messages
-function translateDatabaseError(error, itemData, modelName) {
-    var _error_original, _error_original1, _error_original2;
-    const originalMessage = error.message || '';
-    const errorCode = (_error_original = error.original) === null || _error_original === void 0 ? void 0 : _error_original.code;
-    const constraint = (_error_original1 = error.original) === null || _error_original1 === void 0 ? void 0 : _error_original1.constraint;
-    const detail = (_error_original2 = error.original) === null || _error_original2 === void 0 ? void 0 : _error_original2.detail;
-    logger$8.error('Database error during create operation', {
-        errorCode,
-        constraint,
-        detail,
-        originalMessage,
-        modelName,
-        itemData: JSON.stringify(itemData, null, 2)
-    });
-    // Handle specific PostgreSQL error codes
-    switch(errorCode){
-        case '23505':
-            if (constraint) {
-                return new Error(`Duplicate value violates unique constraint '${constraint}'. ${detail || ''}`);
-            }
-            return new Error(`Duplicate value detected. This record already exists. ${detail || ''}`);
-        case '23503':
-            if (constraint) {
-                return new Error(`Foreign key constraint '${constraint}' violated. Referenced record does not exist. ${detail || ''}`);
-            }
-            return new Error(`Referenced record does not exist. Check that all related records are valid. ${detail || ''}`);
-        case '23502':
-            var _error_original3;
-            const column = (_error_original3 = error.original) === null || _error_original3 === void 0 ? void 0 : _error_original3.column;
-            if (column) {
-                return new Error(`Required field '${column}' cannot be null`);
-            }
-            return new Error(`Required field is missing or null`);
-        case '23514':
-            if (constraint) {
-                return new Error(`Check constraint '${constraint}' violated. ${detail || ''}`);
-            }
-            return new Error(`Data validation failed. Check constraint violated. ${detail || ''}`);
-        case '22001':
-            return new Error(`Data too long for field. Check string lengths. ${detail || ''}`);
-        case '22003':
-            return new Error(`Numeric value out of range. Check number values. ${detail || ''}`);
-        case '42703':
-            var _error_original4;
-            const undefinedColumn = (_error_original4 = error.original) === null || _error_original4 === void 0 ? void 0 : _error_original4.column;
-            if (undefinedColumn) {
-                return new Error(`Column '${undefinedColumn}' does not exist in table '${modelName}'`);
-            }
-            return new Error(`Referenced column does not exist`);
-        case '42P01':
-            return new Error(`Table '${modelName}' does not exist`);
-        default:
-            // For unknown errors, provide the original message with context
-            return new Error(`Database error in ${modelName}.create(): ${originalMessage}. Item data: ${JSON.stringify(itemData, null, 2)}`);
-    }
-}
-// Helper function to validate hierarchical chain exists
-async function validateHierarchicalChain(models, locKey, kta) {
-    try {
-        // Find the direct parent model that contains this locator
-        const locatorIndex = kta.indexOf(locKey.kt);
-        if (locatorIndex === -1) {
-            throw new Error(`Locator type '${locKey.kt}' not found in kta array`);
-        }
-        // Get the model for this locator
-        const locatorModel = models[locatorIndex] || models[0]; // Fallback to primary model
-        // Build a query to validate the chain exists
-        const chainResult = buildRelationshipChain(locatorModel, kta, locatorIndex, kta.length - 1);
-        if (!chainResult.success) {
-            // If we can't build a chain, just validate the record exists
-            const record = await locatorModel.findByPk(locKey.lk);
-            if (!record) {
-                throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist`);
-            }
-            return;
-        }
-        // Validate that the chain exists
-        const queryOptions = {
-            where: {
-                id: locKey.lk
-            }
-        };
-        if (chainResult.includes && chainResult.includes.length > 0) {
-            queryOptions.include = chainResult.includes;
-        }
-        const record = await locatorModel.findOne(queryOptions);
-        if (!record) {
-            throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist or chain is invalid`);
-        }
-    } catch (error) {
-        // Add context to validation errors
-        if (error.original) {
-            throw translateDatabaseError(error, {
-                locKey,
-                kta
-            }, locKey.kt);
-        }
-        throw error;
-    }
-}
-const getCreateOperation = (models, definition, registry)=>{
-    const create = async (item, options)=>{
-        logger$8.debug(`CREATE operation called on ${models[0].name} with ${(options === null || options === void 0 ? void 0 : options.key) ? `key: pk=${options.key.pk}, loc=[${core.isComKey(options.key) ? options.key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ') : ''}]` : (options === null || options === void 0 ? void 0 : options.locations) ? `locations: ${options.locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ')}` : 'no constraints'}`);
-        logger$8.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
-        const { coordinate, options: { references, aggregations } } = definition;
-        const { kta } = coordinate;
-        // Get the primary model (first model in array)
-        const model = models[0];
-        const modelAttributes = model.getAttributes();
-        // Validate that all item attributes exist on the model
-        let itemData = {
-            ...item
-        };
-        // TODO: We need the opposite of processRow, something to step down from fjell to database.
-        itemData = extractEvents(itemData);
-        itemData = removeEvents(itemData);
-        // Validate that all item attributes exist on the model
-        const invalidAttributes = [];
-        for (const key of Object.keys(itemData)){
-            if (!modelAttributes[key]) {
-                invalidAttributes.push(key);
-            }
-        }
-        if (invalidAttributes.length > 0) {
-            const availableAttributes = Object.keys(modelAttributes).join(', ');
-            throw new Error(`Invalid attributes for model '${model.name}': [${invalidAttributes.join(', ')}]. ` + `Available attributes: [${availableAttributes}]. ` + `Item data: ${JSON.stringify(itemData, null, 2)}`);
-        }
-        // Handle key options
-        // If a key is supplied, assume its contents are to be assigned to the appropriate ids.
-        // For most cases this will be null as key generation is often through autoIncrement.
-        // If this is a CItem then the locations will be present.
-        if (options === null || options === void 0 ? void 0 : options.key) {
-            const key = options.key;
-            if (core.isPriKey(key)) {
-                // Set the primary key
-                itemData.id = key.pk;
-            } else if (core.isComKey(key)) {
-                // Set primary key
-                itemData.id = key.pk;
-                // Process location keys - only set direct foreign keys, validate hierarchical chains
-                const comKey = key;
-                const directLocations = [];
-                const hierarchicalLocations = [];
-                // Categorize location keys as direct or hierarchical
-                for (const locKey of comKey.loc){
-                    const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta, true);
-                    if (!relationshipInfo.found) {
-                        const associations = model.associations ? Object.keys(model.associations) : [];
-                        const errorMessage = `Composite key locator '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships. ` + `Available associations: [${associations.join(', ')}]. ` + `KTA: [${kta.join(', ')}]. ` + `Composite key: ${JSON.stringify(comKey, null, 2)}`;
-                        logger$8.error(errorMessage, {
-                            key: comKey,
-                            kta,
-                            associations
-                        });
-                        throw new Error(errorMessage);
-                    }
-                    if (relationshipInfo.isDirect) {
-                        directLocations.push(locKey);
-                    } else {
-                        hierarchicalLocations.push(locKey);
-                    }
-                }
-                // Set direct foreign keys
-                for (const locKey of directLocations){
-                    if (locKey.lk == null || locKey.lk === '') {
-                        logger$8.error(`Composite key location '${locKey.kt}' has undefined/null lk value`, {
-                            locKey,
-                            key: comKey
-                        });
-                        throw new Error(`Composite key location '${locKey.kt}' has undefined/null lk value`);
-                    }
-                    const foreignKeyField = locKey.kt + 'Id';
-                    itemData[foreignKeyField] = locKey.lk;
-                }
-                // Validate hierarchical chains exist
-                for (const locKey of hierarchicalLocations){
-                    await validateHierarchicalChain(models, locKey, kta);
-                }
-            }
-        }
-        // Handle locations options
-        // This is the most frequent way relationship ids will be set
-        if (options === null || options === void 0 ? void 0 : options.locations) {
-            const directLocations = [];
-            const hierarchicalLocations = [];
-            // Categorize location keys as direct or hierarchical
-            for (const locKey of options.locations){
-                const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta, true);
-                if (!relationshipInfo.found) {
-                    const associations = model.associations ? Object.keys(model.associations) : [];
-                    const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships. ` + `Available associations: [${associations.join(', ')}]. ` + `KTA: [${kta.join(', ')}]. ` + `Locations: ${JSON.stringify(options.locations, null, 2)}`;
-                    logger$8.error(errorMessage, {
-                        locations: options.locations,
-                        kta,
-                        associations
-                    });
-                    throw new Error(errorMessage);
-                }
-                if (relationshipInfo.isDirect) {
-                    directLocations.push(locKey);
-                } else {
-                    hierarchicalLocations.push(locKey);
-                }
-            }
-            // Set direct foreign keys
-            for (const locKey of directLocations){
-                if (locKey.lk == null || locKey.lk === '') {
-                    logger$8.error(`Location option '${locKey.kt}' has undefined/null lk value`, {
-                        locKey,
-                        locations: options.locations
-                    });
-                    throw new Error(`Location option '${locKey.kt}' has undefined/null lk value`);
-                }
-                const foreignKeyField = locKey.kt + 'Id';
-                itemData[foreignKeyField] = locKey.lk;
-            }
-            // Validate hierarchical chains exist
-            for (const locKey of hierarchicalLocations){
-                await validateHierarchicalChain(models, locKey, kta);
-            }
-        }
-        // Create the record
-        try {
-            logger$8.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
-            const createdRecord = await model.create(itemData);
-            // Add key and events
-            const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
-            const result = core.validateKeys(processedRecord, kta);
-            logger$8.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
-            return result;
-        } catch (error) {
-            throw translateDatabaseError(error, itemData, model.name);
-        }
-    };
-    return create;
-};
-
-const logger$7 = logger$1.default.get('sequelize', 'ops', 'find');
-const getFindOperation = (models, definition, registry)=>{
-    const { options: { finders, references, aggregations } } = definition;
-    const find = async (finder, finderParams, locations)=>{
-        logger$7.debug(`FIND operation called on ${models[0].name} with finder '${finder}' and ${(locations === null || locations === void 0 ? void 0 : locations.length) || 0} location filters: ${(locations === null || locations === void 0 ? void 0 : locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ')) || 'none'}`);
-        logger$7.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
-        // Note that we execute the createFinders function here because we want to make sure we're always getting the
-        // most up to date methods.
-        if (finders && finders[finder]) {
-            const finderMethod = finders[finder];
-            if (finderMethod) {
-                logger$7.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
-                const results = await finderMethod(finderParams, locations);
-                if (results && results.length > 0) {
-                    const processedResults = await Promise.all(results.map(async (row)=>{
-                        const processedRow = await processRow(row, definition.coordinate.kta, references, aggregations, registry);
-                        return core.validateKeys(processedRow, definition.coordinate.kta);
-                    }));
-                    logger$7.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
-                    return processedResults;
-                } else {
-                    logger$7.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
-                    return [];
-                }
-            } else {
-                logger$7.error(`Finder %s not found`, finder);
-                throw new Error(`Finder ${finder} not found`);
-            }
-        } else {
-            logger$7.error(`No finders have been defined for this lib`);
-            throw new Error(`No finders found`);
-        }
-    };
-    return find;
-};
-
-const logger$6 = logger$1.default.get('sequelize', 'ops', 'get');
-// Helper function to process composite key and build query options
-const processCompositeKey$1 = (comKey, model, kta)=>{
-    const where = {
-        id: comKey.pk
-    };
-    const includes = [];
-    for (const locator of comKey.loc){
-        const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta);
-        if (!relationshipInfo.found) {
-            const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-            logger$6.error(errorMessage, {
-                key: comKey,
-                kta
-            });
-            throw new Error(errorMessage);
-        }
-        if (relationshipInfo.path) {
-            // This requires a relationship traversal
-            where[relationshipInfo.path] = locator.lk;
-            if (relationshipInfo.includes) {
-                includes.push(...relationshipInfo.includes);
-            }
-        } else {
-            // This is a direct field
-            const fieldName = `${locator.kt}Id`;
-            where[fieldName] = locator.lk;
-        }
-    }
-    const result = {
-        where
-    };
-    if (includes.length > 0) {
-        result.include = includes;
-    }
-    return result;
-};
-const getGetOperation = (models, definition, registry)=>{
-    const { coordinate, options: { references, aggregations } } = definition;
-    const { kta } = coordinate;
-    const get = async (key)=>{
-        if (!core.isValidItemKey(key)) {
-            logger$6.error('Key for Get is not a valid ItemKey: %j', key);
-            throw new Error('Key for Get is not a valid ItemKey');
-        }
-        logger$6.debug(`GET operation called on ${models[0].name} with ${core.isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
-        logger$6.default(`Get configured for ${models[0].name} with ${core.isPriKey(key) ? 'primary' : 'composite'} key`);
-        const itemKey = key;
-        // @ts-ignore
-        const model = models[0];
-        let item;
-        if (core.isPriKey(itemKey)) {
-            // This is the easy case because we can just find the item by its primary key
-            logger$6.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
-            item = await model.findByPk(itemKey.pk);
-        } else if (core.isComKey(itemKey)) {
-            // This is a composite key, so we need to build a where clause based on the composite key's locators
-            const comKey = itemKey;
-            const queryOptions = processCompositeKey$1(comKey, model, kta);
-            logger$6.default('Composite key query', {
-                queryOptions
-            });
-            logger$6.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-            item = await model.findOne(queryOptions);
-        }
-        if (!item) {
-            throw new Library.NotFoundError('get', coordinate, key);
-        } else {
-            // Get the current context from context manager
-            const context = OperationContext.contextManager.getCurrentContext();
-            const result = core.validateKeys(await processRow(item, kta, references, aggregations, registry, context), kta);
-            logger$6.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
-            return result;
-        }
-    };
-    return get;
-};
-
-const logger$5 = logger$1.default.get('sequelize', 'ops', 'one');
-const getOneOperation = (models, definition, registry)=>{
-    const one = async (itemQuery, locations = [])=>{
-        logger$5.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ') || 'none'}`);
-        logger$5.default(`One configured for ${models[0].name} delegating to all operation`);
-        const items = await all.getAllOperation(models, definition, registry)(itemQuery, locations);
-        if (items.length > 0) {
-            const result = items[0];
-            logger$5.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : 'unknown'}`);
-            return result;
-        } else {
-            logger$5.debug(`[ONE] No ${models[0].name} record found`);
-            return null;
-        }
-    };
-    return one;
-};
-
-const logger$4 = logger$1.default.get('sequelize', 'ops', 'remove');
-// Helper function to process composite key and build query options
-const processCompositeKey = (comKey, model, kta)=>{
-    const where = {
-        id: comKey.pk
-    };
-    const includes = [];
-    for (const locator of comKey.loc){
-        const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta);
-        if (!relationshipInfo.found) {
-            const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-            logger$4.error(errorMessage, {
-                key: comKey,
-                kta
-            });
-            throw new Error(errorMessage);
-        }
-        if (relationshipInfo.path) {
-            // This requires a relationship traversal
-            where[relationshipInfo.path] = locator.lk;
-            if (relationshipInfo.includes) {
-                includes.push(...relationshipInfo.includes);
-            }
-        } else {
-            // This is a direct field
-            const fieldName = `${locator.kt}Id`;
-            where[fieldName] = locator.lk;
-        }
-    }
-    const result = {
-        where
-    };
-    if (includes.length > 0) {
-        result.include = includes;
-    }
-    return result;
-};
-const getRemoveOperation = (models, definition, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-registry)=>{
-    const { coordinate, options } = definition;
-    const { kta } = coordinate;
-    const remove = async (key)=>{
-        if (!core.isValidItemKey(key)) {
-            logger$4.error('Key for Remove is not a valid ItemKey: %j', key);
-            throw new Error('Key for Remove is not a valid ItemKey');
-        }
-        logger$4.debug(`REMOVE operation called on ${models[0].name} with ${core.isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
-        logger$4.default(`Remove configured for ${models[0].name} with ${core.isPriKey(key) ? 'primary' : 'composite'} key`);
-        // @ts-ignore
-        const model = models[0];
-        let item;
-        let returnItem;
-        logger$4.debug('remove: %s', core.abbrevIK(key));
-        if (core.isPriKey(key)) {
-            logger$4.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
-            item = await model.findByPk(key.pk);
-        } else if (core.isComKey(key)) {
-            // This is a composite key, so we need to build a where clause based on the composite key's locators
-            const comKey = key;
-            const queryOptions = processCompositeKey(comKey, model, kta);
-            logger$4.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
-            logger$4.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-            item = await model.findOne(queryOptions);
-        }
-        if (!item) {
-            throw new Error(`Item not found for removal with key: ${core.abbrevIK(key)}`);
-        }
-        const isDeletedAttribute = model.getAttributes().isDeleted;
-        const deletedAtAttribute = model.getAttributes().deletedAt;
-        if (isDeletedAttribute || deletedAtAttribute) {
-            if (model.getAttributes().isDeleted) {
-                item.isDeleted = true;
-            }
-            if (model.getAttributes().deletedAt) {
-                item.deletedAt = new Date();
-            }
-            // Save the object
-            logger$4.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
-            await (item === null || item === void 0 ? void 0 : item.save());
-            returnItem = item === null || item === void 0 ? void 0 : item.get({
-                plain: true
-            });
-            returnItem = addKey(item, returnItem, kta);
-            returnItem = populateEvents(returnItem);
-        } else if (options.deleteOnRemove) {
-            logger$4.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
-            await (item === null || item === void 0 ? void 0 : item.destroy());
-            returnItem = item === null || item === void 0 ? void 0 : item.get({
-                plain: true
-            });
-            returnItem = addKey(item, returnItem, kta);
-            returnItem = populateEvents(returnItem);
-        } else {
-            throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
-        }
-        logger$4.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
-        return returnItem;
-    };
-    return remove;
-};
-
-const logger$3 = logger$1.default.get('sequelize', 'ops', 'update');
-// Helper function to merge includes avoiding duplicates
-const mergeIncludes = (existingIncludes, newIncludes)=>{
-    const mergedIncludes = [
-        ...existingIncludes
-    ];
-    for (const newInclude of newIncludes){
-        const existingIndex = mergedIncludes.findIndex((existing)=>existing.as === newInclude.as && existing.model === newInclude.model);
-        if (existingIndex === -1) {
-            mergedIncludes.push(newInclude);
-        } else if (newInclude.include && mergedIncludes[existingIndex].include) {
-            mergedIncludes[existingIndex].include = [
-                ...mergedIncludes[existingIndex].include,
-                ...newInclude.include
-            ];
-        } else if (newInclude.include) {
-            mergedIncludes[existingIndex].include = newInclude.include;
-        }
-    }
-    return mergedIncludes;
-};
-const getUpdateOperation = (models, definition, registry)=>{
-    const { options: { references, aggregations } } = definition;
-    const update = async (key, item)=>{
-        logger$3.debug(`UPDATE operation called on ${models[0].name} with ${core.isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
-        const { coordinate } = definition;
-        const { kta } = coordinate;
-        logger$3.debug('update: %s, %j', core.abbrevIK(key), item);
-        // Find the object we're updating
-        // @ts-ignore
-        const model = models[0];
-        let response;
-        if (core.isPriKey(key)) {
-            // Find the model by using the PK
-            const priKey = key;
-            logger$3.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
-            response = await model.findByPk(priKey.pk);
-        } else if (core.isComKey(key)) {
-            const comKey = key;
-            // Build query options for composite key with multiple location keys
-            const where = {
-                id: comKey.pk
-            };
-            const additionalIncludes = [];
-            // Process all location keys in the composite key
-            for (const locator of comKey.loc){
-                const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta, true);
-                if (!relationshipInfo.found) {
-                    const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-                    logger$3.error(errorMessage, {
-                        key: comKey,
-                        kta
-                    });
-                    throw new Error(errorMessage);
-                }
-                if (relationshipInfo.isDirect) {
-                    // Direct foreign key field
-                    const fieldName = `${locator.kt}Id`;
-                    where[fieldName] = locator.lk;
-                } else if (relationshipInfo.path) {
-                    // Hierarchical relationship requiring traversal
-                    where[relationshipInfo.path] = {
-                        [sequelize.Op.eq]: locator.lk
-                    };
-                    // Add necessary includes for relationship traversal
-                    if (relationshipInfo.includes) {
-                        additionalIncludes.push(...relationshipInfo.includes);
-                    }
-                }
-            }
-            // Build final query options
-            const queryOptions = {
-                where
-            };
-            if (additionalIncludes.length > 0) {
-                queryOptions.include = mergeIncludes([], additionalIncludes);
-            }
-            logger$3.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
-            logger$3.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-            response = await model.findOne(queryOptions);
-        }
-        if (response) {
-            // Remove the key and events
-            let updateProps = removeKey(item);
-            // TODO: We need the opposite of processRow, something to step down from fjell to database.
-            updateProps = extractEvents(updateProps);
-            updateProps = removeEvents(updateProps);
-            logger$3.default(`Update found ${model.name} record to modify`);
-            logger$3.default(`Update properties configured: ${Object.keys(updateProps).join(', ')}`);
-            // Update the object
-            logger$3.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
-            response = await response.update(updateProps);
-            // Populate the key and events
-            const processedItem = await processRow(response, kta, references, aggregations, registry);
-            const returnItem = core.validateKeys(processedItem, kta);
-            logger$3.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
-            return returnItem;
-        } else {
-            throw new Library.NotFoundError('update', coordinate, key);
-        }
-    };
-    return update;
-};
-
-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 = 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;
-};
-
-const logger$2 = logger$1.default.get("SequelizeLibrary");
-/**
- * Creates a new SequelizeLibrary that extends the fjell-lib Library
- * with Sequelize-specific functionality
- */ const createSequelizeLibrary$2 = (registry, coordinate, models, options)=>{
-    logger$2.debug("createSequelizeLibrary", {
-        coordinate,
-        models,
-        registry,
-        options
-    });
-    // Create Sequelize-specific operations
-    const operations = createOperations(models, coordinate, registry, options);
-    // Create the base fjell-lib library
-    const libLibrary = Library__namespace.createLibrary(registry, coordinate, operations, options);
-    return {
-        ...libLibrary,
-        models
-    };
-};
-/**
- * Type guard to check if an object is a SequelizeLibrary
- */ const isSequelizeLibrary = (library)=>{
-    return library != null && library.coordinate != null && library.operations != null && library.options != null && library.registry != null && library.models != null && Array.isArray(library.models);
-};
-
-const logger$1 = logger$1.default.get("InstanceFactory");
-/**
- * Factory function for creating Sequelize libraries
- * This extends the fjell-lib pattern by adding Sequelize-specific models
- */ const createSequelizeLibraryFactory = (models, options)=>{
-    return (coordinate, context)=>{
-        logger$1.debug("Creating Sequelize instance", {
-            coordinate,
-            registry: context.registry,
-            models: models.map((m)=>m.name),
-            options
-        });
-        return createSequelizeLibrary$2(context.registry, coordinate, models, options);
-    };
-};
-
-function createSequelizeLibrary$1(keyTypes, models, libOptions = {}, scopes = [], registry) {
-    // Create coordinate and options separately following new pattern
-    const coordinate = createCoordinate(keyTypes, scopes);
-    const options = createOptions(libOptions);
-    // Create operations with the new signature
-    const operations = createOperations(models, coordinate, registry, options);
-    // Wrap operations for contained pattern
-    const wrappedOperations = Library.Contained.wrapOperations(operations, options, coordinate, registry);
-    return {
-        coordinate,
-        registry,
-        operations: wrappedOperations,
-        options,
-        models
-    };
-}
-// Legacy exports for backwards compatibility
-const createInstance$1 = createSequelizeLibrary$1;
-
-const index$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-  __proto__: null,
-  createInstance: createInstance$1,
-  createSequelizeLibrary: createSequelizeLibrary$1
-}, Symbol.toStringTag, { value: 'Module' }));
-
-const logger = logger$1.default.get('lib-sequelize', 'primary', 'instance');
-function createSequelizeLibrary(keyType, models, libOptions = {}, scopes = [], registry) {
-    logger.debug('createSequelizeLibrary', {
-        keyType,
-        models,
-        libOptions,
-        scopes
-    });
-    // Create coordinate and options separately following new pattern
-    const coordinate = createCoordinate([
-        keyType
-    ], scopes);
-    const options = createOptions(libOptions);
-    // Create operations with the new signature
-    const operations = createOperations(models, coordinate, registry, options);
-    // Wrap operations for primary pattern
-    const wrappedOperations = Library.Primary.wrapOperations(operations, options, coordinate, registry);
-    return {
-        coordinate,
-        registry,
-        operations: wrappedOperations,
-        options,
-        models
-    };
-}
-// Legacy exports for backwards compatibility
-const createInstance = createSequelizeLibrary;
-
-const index = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-  __proto__: null,
-  createInstance,
-  createSequelizeLibrary
-}, Symbol.toStringTag, { value: 'Module' }));
-
-exports.Contained = index$1;
-exports.Primary = index;
-exports.SCOPE_SEQUELIZE = SCOPE_SEQUELIZE;
-exports.createCoordinate = createCoordinate;
-exports.createDefinition = createDefinition;
-exports.createOperations = createOperations;
-exports.createOptions = createOptions;
-exports.createSequelizeLibrary = createSequelizeLibrary$2;
-exports.createSequelizeLibraryFactory = createSequelizeLibraryFactory;
-exports.isSequelizeLibrary = isSequelizeLibrary;
-//# sourceMappingURL=index.cjs.map