@fjell/lib-sequelize 4.4.0 → 4.4.2

package/dist/index.cjs

@@ -0,0 +1,1279 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Library = require('@fjell/lib');
+const deepmerge = require('deepmerge');
+const Logging = require('@fjell/logging');
+const core = require('@fjell/core');
+const sequelize = require('sequelize');
+
+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 SCOPE_SEQUELIZE = 'sequelize';
+const createCoordinate = (kta, scopes)=>{
+    const coordinate = Library__namespace.createCoordinate(kta, [
+        SCOPE_SEQUELIZE,
+        ...scopes || []
+    ]);
+    return coordinate;
+};
+
+/* eslint-disable @typescript-eslint/no-unused-vars */ /* eslint-disable no-undefined */ const clean = (obj)=>{
+    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
+};
+//Recursive implementation of jSON.stringify;
+const general.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(general.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 + general.stringifyJSON(keyValOut, visited));
+            }
+        });
+        return '{' + arrOfKeyVals + '}';
+    }
+    return '';
+};
+
+const DEFAULT_OPTIONS = {
+    deleteOnRemove: false,
+    references: [],
+    aggregations: []
+};
+const createOptions = (libOptions)=>{
+    const options = Library__namespace.createOptions(libOptions);
+    return deepmerge(DEFAULT_OPTIONS, clean(options));
+};
+
+const logger$1.default = Logging.getLogger('@fjell/lib-sequelize');
+
+const logger$c = logger$1.default.get('lib-sequelize', 'Definition');
+function createDefinition(kta, scopes, libOptions) {
+    logger$c.debug('createDefinition', {
+        kta,
+        scopes,
+        libOptions
+    });
+    const coordinate = createCoordinate(kta, scopes);
+    const options = createOptions(libOptions);
+    const definition = Library__namespace.createDefinition(coordinate, options);
+    return {
+        ...definition,
+        options
+    };
+}
+
+const logger$b = logger$1.default.get('sequelize', 'QueryBuilder');
+const addDeleteQuery = (options, model)=>{
+    logger$b.default('Adding Delete Query', {
+        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$b.default('Adding Event Queries', {
+        options,
+        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$b.default('Adding Reference Queries', {
+        options,
+        references
+    });
+    Object.keys(references).forEach((key)=>{
+        logger$b.default('Adding Reference Query', {
+            key,
+            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];
+            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);
+    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);
+    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$b.default('build', {
+        itemQuery
+    });
+    let options = {
+        where: {}
+    };
+    if (itemQuery.compoundCondition) {
+        logger$b.default('Adding Conditions', {
+            compoundCondition: 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$b.default('Limiting to', {
+            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 targetType = kta[targetIndex];
+    const associationPath = `$${associationParts.join('.')}.${targetType}Id$`;
+    // 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$a = logger$1.default.get('sequelize', 'KeyMaster');
+// Helper function to extract location key value from item
+const extractLocationKeyValue = (model, item, locatorType, kta)=>{
+    logger$a.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
+        // Try to get the value from the loaded relationship object
+        const relationshipObject = item[locatorType];
+        if (relationshipObject && typeof relationshipObject.id !== 'undefined') {
+            return relationshipObject.id;
+        }
+        // If the relationship object isn't loaded, we might need to look at the foreign key field
+        // This handles cases where we have the foreign key but not the full object
+        const foreignKeyField = `${locatorType}Id`;
+        if (typeof item[foreignKeyField] !== 'undefined' && item[foreignKeyField] !== null) {
+            return item[foreignKeyField];
+        }
+        throw new Error(`Unable to extract location key for '${locatorType}'. Neither the relationship object nor direct foreign key is available.`);
+    }
+};
+const removeKey = (item)=>{
+    logger$a.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$a.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$a.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 buildReference = async (item, referenceDefinition, registry)=>{
+    // 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");
+    }
+    // Create a PriKey using the column value from item
+    const priKey = {
+        kt: referenceDefinition.kta[0],
+        pk: item[referenceDefinition.column]
+    };
+    // Get the referenced item using the Library.Operations get method
+    const 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;
+};
+
+const buildAggregation = async (item, aggregationDefinition, registry)=>{
+    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(', ')}`);
+    }
+    // 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)=>{
+            item[aggregationDefinition.property] = result;
+            return item;
+        });
+    } else {
+        // For one-to-many relationship, use the all operation
+        return libraryInstance.operations.all({}, location).then((results)=>{
+            item[aggregationDefinition.property] = results;
+            return item;
+        });
+    }
+};
+
+const logger$9 = 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$9.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$9.default('Removing Events', {
+        item
+    });
+    delete item.events;
+    return item;
+};
+
+const logger$8 = logger$1.default.get('sequelize', 'RowProcessor');
+const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry)=>{
+    logger$8.default('Processing Row', {
+        row
+    });
+    let item = row.get({
+        plain: true
+    });
+    logger$8.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
+    item = addKey(row, item, keyTypes);
+    item = populateEvents(item);
+    logger$8.default('Key Added to Item: %s', general.stringifyJSON(item.key));
+    if (referenceDefinitions && referenceDefinitions.length > 0) {
+        for (const referenceDefinition of referenceDefinitions){
+            logger$8.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
+            item = await buildReference(item, referenceDefinition, registry);
+        }
+    }
+    if (aggregationDefinitions && aggregationDefinitions.length > 0) {
+        for (const aggregationDefinition of aggregationDefinitions){
+            logger$8.default('Processing Aggregation for %s from %s', item.key.kt, general.stringifyJSON(aggregationDefinition.kta));
+            item = await buildAggregation(item, aggregationDefinition, registry);
+        }
+    }
+    logger$8.default('Processed Row: %j', general.stringifyJSON(item));
+    return item;
+};
+
+const logger$7 = logger$1.default.get('sequelize', 'ops', 'all');
+const all.getAllOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
+    //#region Query
+    const all = async (itemQuery, locations)=>{
+        logger$7.default('All', {
+            itemQuery,
+            locations
+        });
+        const loc = locations || [];
+        // SQ Libs don't support locations
+        if (loc.length > 1) {
+            throw new Error('Not implemented for more than one location key');
+        }
+        // We have the model here?
+        // @ts-ignore
+        const model = models[0];
+        // We have the model here?
+        const options = buildQuery(itemQuery, model);
+        // If this has a location array, we need to add a where clause
+        if (loc.length === 1) {
+            const locKeyType = loc[0].kt;
+            if (model.associations[locKeyType]) {
+                const association = model.associations[locKeyType];
+                options.where = {
+                    ...options.where,
+                    [association.foreignKey]: {
+                        [sequelize.Op.eq]: loc[0].lk
+                    }
+                };
+            } else {
+                logger$7.error('Location key type not found in sequelize model association for: %s', locKeyType);
+                throw new Error('Location key type not found in model');
+            }
+        }
+        logger$7.default('Configured this Item Query', {
+            itemQuery,
+            options
+        });
+        const matchingItems = await model.findAll(options);
+        // this.logger.default('Matching Items', { matchingItems });
+        // TODO: Move this Up!
+        return await Promise.all(matchingItems.map(async (row)=>{
+            const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry);
+            return core.validateKeys(processedRow, coordinate.kta);
+        }));
+    };
+    return all;
+};
+
+const logger$6 = logger$1.default.get('sequelize', 'ops', 'create');
+// Helper function to validate hierarchical chain exists
+async function validateHierarchicalChain(models, locKey, kta) {
+    // 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`);
+    }
+}
+const getCreateOperation = (models, definition, registry)=>{
+    const create = async (item, options)=>{
+        logger$6.default('Create', {
+            item,
+            options
+        });
+        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);
+        for (const key of Object.keys(itemData)){
+            if (!modelAttributes[key]) {
+                throw new Error(`Attribute '${key}' does not exist on model ${model.name}`);
+            }
+        }
+        // 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 errorMessage = `Composite key locator '${locKey.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.isDirect) {
+                        directLocations.push(locKey);
+                    } else {
+                        hierarchicalLocations.push(locKey);
+                    }
+                }
+                // Set direct foreign keys
+                for (const locKey of directLocations){
+                    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 errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
+                    logger$6.error(errorMessage, {
+                        locations: options.locations,
+                        kta
+                    });
+                    throw new Error(errorMessage);
+                }
+                if (relationshipInfo.isDirect) {
+                    directLocations.push(locKey);
+                } else {
+                    hierarchicalLocations.push(locKey);
+                }
+            }
+            // Set direct foreign keys
+            for (const locKey of directLocations){
+                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
+        const createdRecord = await model.create(itemData);
+        // Add key and events
+        const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
+        return core.validateKeys(processedRecord, kta);
+    };
+    return create;
+};
+
+const logger$5 = 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$5.default('Find', {
+            finder,
+            finderParams,
+            locations
+        });
+        // 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) {
+                const results = await finderMethod(finderParams, locations);
+                if (results && results.length > 0) {
+                    return 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);
+                    }));
+                } else {
+                    return [];
+                }
+            } else {
+                logger$5.error(`Finder %s not found`, finder);
+                throw new Error(`Finder ${finder} not found`);
+            }
+        } else {
+            logger$5.error(`No finders have been defined for this lib`);
+            throw new Error(`No finders found`);
+        }
+    };
+    return find;
+};
+
+const logger$4 = 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$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 getGetOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
+    const { kta } = coordinate;
+    const get = async (key)=>{
+        logger$4.default('Get', {
+            key
+        });
+        if (!core.isValidItemKey(key)) {
+            logger$4.error('Key for Get is not a valid ItemKey: %j', key);
+            throw new Error('Key for Get is not a valid ItemKey');
+        }
+        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
+            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$4.default('Composite key query', {
+                queryOptions
+            });
+            item = await model.findOne(queryOptions);
+        }
+        if (!item) {
+            throw new Library.NotFoundError('get', coordinate, key);
+        } else {
+            return core.validateKeys(await processRow(item, kta, references, aggregations, registry), kta);
+        }
+    };
+    return get;
+};
+
+const logger$3 = logger$1.default.get('sequelize', 'ops', 'one');
+const getOneOperation = (models, definition, registry)=>{
+    const one = async (itemQuery, locations = [])=>{
+        logger$3.default('One', {
+            itemQuery,
+            locations
+        });
+        const items = await all.getAllOperation(models, definition, registry)(itemQuery, locations);
+        if (items.length > 0) {
+            return items[0];
+        } else {
+            return null;
+        }
+    };
+    return one;
+};
+
+const logger$2 = 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$2.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)=>{
+        logger$2.default('Remove', {
+            key
+        });
+        if (!core.isValidItemKey(key)) {
+            logger$2.error('Key for Remove is not a valid ItemKey: %j', key);
+            throw new Error('Key for Remove is not a valid ItemKey');
+        }
+        // @ts-ignore
+        const model = models[0];
+        let item;
+        let returnItem;
+        logger$2.debug('remove: %s', core.abbrevIK(key));
+        if (core.isPriKey(key)) {
+            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$2.default('Composite key query', {
+                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
+            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) {
+            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');
+        }
+        return returnItem;
+    };
+    return remove;
+};
+
+const logger$1 = logger$1.default.get('sequelize', 'ops', 'update');
+const getUpdateOperation = (models, definition, registry)=>{
+    const { options: { references, aggregations } } = definition;
+    const update = async (key, item)=>{
+        const { coordinate } = definition;
+        const { kta } = coordinate;
+        logger$1.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;
+            response = await model.findByPk(priKey.pk);
+        } else if (core.isComKey(key)) {
+            var _comKey_loc_, _comKey_loc_1;
+            const comKey = key;
+            // Find the model by using both of the identifiers.
+            response = await model.findOne({
+                where: {
+                    [(comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_ = comKey.loc[0]) === null || _comKey_loc_ === void 0 ? void 0 : _comKey_loc_.kt) + 'Id']: comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_1 = comKey.loc[0]) === null || _comKey_loc_1 === void 0 ? void 0 : _comKey_loc_1.lk,
+                    id: comKey === null || comKey === void 0 ? void 0 : comKey.pk
+                }
+            });
+        }
+        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$1.default('Response: %s', general.stringifyJSON(response));
+            logger$1.default('Update Properties: %s', general.stringifyJSON(updateProps));
+            // Update the object
+            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);
+            return returnItem;
+        } else {
+            throw new Library.NotFoundError('update', coordinate, key);
+        }
+    };
+    return update;
+};
+
+const createOperations = (models, definition, registry)=>{
+    const operations = {};
+    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;
+};
+
+function createInstance$2(keyTypes, models, libOptions = {}, scopes = [], registry) {
+    const definition = createDefinition(keyTypes, scopes, libOptions);
+    const operations = createOperations(models, definition, registry);
+    return {
+        definition,
+        operations: Library__namespace.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+function createInstance$1(keyTypes, models, libOptions = {}, scopes = [], registry) {
+    const definition = createDefinition(keyTypes, scopes, libOptions);
+    const operations = createOperations(models, definition, registry);
+    return {
+        definition,
+        operations: Library.Contained.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+const index$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  createInstance: createInstance$1
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const logger = logger$1.default.get('lib-sequelize', 'primary', 'instance');
+function createInstance(keyType, models, libOptions = {}, scopes = [], registry) {
+    logger.debug('createInstance', {
+        keyType,
+        models,
+        libOptions,
+        scopes
+    });
+    const definition = createDefinition([
+        keyType
+    ], scopes, libOptions);
+    const operations = createOperations(models, definition, registry);
+    return {
+        definition,
+        operations: Library.Primary.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+const index = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  createInstance
+}, Symbol.toStringTag, { value: 'Module' }));
+
+exports.Contained = index$1;
+exports.Primary = index;
+exports.SCOPE_SEQUELIZE = SCOPE_SEQUELIZE;
+exports.createCoordinate = createCoordinate;
+exports.createDefinition = createDefinition;
+exports.createInstance = createInstance$2;
+exports.createOperations = createOperations;
+exports.createOptions = createOptions;
+//# sourceMappingURL=index.cjs.map