@fjell/lib-sequelize 4.4.0 → 4.4.2

package/dist/cjs/QueryBuilder.cjs

@@ -0,0 +1,290 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const sequelize = require('sequelize');
+const logger$1 = require('./logger.cjs');
+
+const logger = logger$1.default.get('sequelize', 'QueryBuilder');
+const addDeleteQuery = (options, model)=>{
+    logger.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.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.default('Adding Reference Queries', {
+        options,
+        references
+    });
+    Object.keys(references).forEach((key)=>{
+        logger.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.default('build', {
+        itemQuery
+    });
+    let options = {
+        where: {}
+    };
+    if (itemQuery.compoundCondition) {
+        logger.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.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;
+};
+
+exports.addCompoundCondition = addCompoundCondition;
+exports.addCondition = addCondition;
+exports.buildQuery = buildQuery;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/ReferenceBuilder.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+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;
+};
+
+exports.buildReference = buildReference;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/RowProcessor.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('./logger.cjs');
+const KeyMaster = require('./KeyMaster.cjs');
+const ReferenceBuilder = require('./ReferenceBuilder.cjs');
+const AggregationBuilder = require('./AggregationBuilder.cjs');
+const general = require('./util/general.cjs');
+const EventCoordinator = require('./EventCoordinator.cjs');
+
+const logger = logger$1.default.get('sequelize', 'RowProcessor');
+const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry)=>{
+    logger.default('Processing Row', {
+        row
+    });
+    let item = row.get({
+        plain: true
+    });
+    logger.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
+    item = KeyMaster.addKey(row, item, keyTypes);
+    item = EventCoordinator.populateEvents(item);
+    logger.default('Key Added to Item: %s', general.stringifyJSON(item.key));
+    if (referenceDefinitions && referenceDefinitions.length > 0) {
+        for (const referenceDefinition of referenceDefinitions){
+            logger.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
+            item = await ReferenceBuilder.buildReference(item, referenceDefinition, registry);
+        }
+    }
+    if (aggregationDefinitions && aggregationDefinitions.length > 0) {
+        for (const aggregationDefinition of aggregationDefinitions){
+            logger.default('Processing Aggregation for %s from %s', item.key.kt, general.stringifyJSON(aggregationDefinition.kta));
+            item = await AggregationBuilder.buildAggregation(item, aggregationDefinition, registry);
+        }
+    }
+    logger.default('Processed Row: %j', general.stringifyJSON(item));
+    return item;
+};
+
+exports.processRow = processRow;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/contained/Instance.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Library = require('@fjell/lib');
+const Definition = require('../Definition.cjs');
+const Operations = require('../Operations.cjs');
+
+function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry) {
+    const definition = Definition.createDefinition(keyTypes, scopes, libOptions);
+    const operations = Operations.createOperations(models, definition, registry);
+    return {
+        definition,
+        operations: Library.Contained.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+exports.createInstance = createInstance;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/contained/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Instance = require('./Instance.cjs');
+
+
+
+exports.createInstance = Instance.createInstance;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7In0=

package/dist/cjs/index.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Coordinate = require('./Coordinate.cjs');
+const Definition = require('./Definition.cjs');
+const Instance = require('./Instance.cjs');
+const Options = require('./Options.cjs');
+const Operations = require('./Operations.cjs');
+const index = require('./contained/index.cjs');
+const index$1 = require('./primary/index.cjs');
+
+
+
+exports.SCOPE_SEQUELIZE = Coordinate.SCOPE_SEQUELIZE;
+exports.createCoordinate = Coordinate.createCoordinate;
+exports.createDefinition = Definition.createDefinition;
+exports.createInstance = Instance.createInstance;
+exports.createOptions = Options.createOptions;
+exports.createOperations = Operations.createOperations;
+exports.Contained = index;
+exports.Primary = index$1;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/logger.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const Logging = require('@fjell/logging');
+
+const LibLogger = Logging.getLogger('@fjell/lib-sequelize');
+
+exports.default = LibLogger;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7In0=

package/dist/cjs/ops/all.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const QueryBuilder = require('../QueryBuilder.cjs');
+const logger$1 = require('../logger.cjs');
+const RowProcessor = require('../RowProcessor.cjs');
+const sequelize = require('sequelize');
+
+const logger = logger$1.default.get('sequelize', 'ops', 'all');
+const getAllOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
+    //#region Query
+    const all = async (itemQuery, locations)=>{
+        logger.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 = QueryBuilder.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.error('Location key type not found in sequelize model association for: %s', locKeyType);
+                throw new Error('Location key type not found in model');
+            }
+        }
+        logger.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 RowProcessor.processRow(row, coordinate.kta, references, aggregations, registry);
+            return core.validateKeys(processedRow, coordinate.kta);
+        }));
+    };
+    return all;
+};
+
+exports.getAllOperation = getAllOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/ops/create.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const logger$1 = require('../logger.cjs');
+const RowProcessor = require('../RowProcessor.cjs');
+const EventCoordinator = require('../EventCoordinator.cjs');
+const relationshipUtils = require('../util/relationshipUtils.cjs');
+
+const logger = 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 = relationshipUtils.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.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 = EventCoordinator.extractEvents(itemData);
+        itemData = EventCoordinator.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.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.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 RowProcessor.processRow(createdRecord, kta, references, aggregations, registry);
+        return core.validateKeys(processedRecord, kta);
+    };
+    return create;
+};
+
+exports.getCreateOperation = getCreateOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=