@fjell/lib-sequelize 4.3.4 → 4.4.1

package/dist/cjs/AggregationBuilder.cjs

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

package/dist/cjs/Coordinate.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Library = require('@fjell/lib');
+
+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;
+};
+
+exports.SCOPE_SEQUELIZE = SCOPE_SEQUELIZE;
+exports.createCoordinate = createCoordinate;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29vcmRpbmF0ZS5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/Definition.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Library = require('@fjell/lib');
+const Coordinate = require('./Coordinate.cjs');
+const Options = require('./Options.cjs');
+const logger$1 = require('./logger.cjs');
+
+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 logger = logger$1.default.get('lib-sequelize', 'Definition');
+function createDefinition(kta, scopes, libOptions) {
+    logger.debug('createDefinition', {
+        kta,
+        scopes,
+        libOptions
+    });
+    const coordinate = Coordinate.createCoordinate(kta, scopes);
+    const options = Options.createOptions(libOptions);
+    const definition = Library__namespace.createDefinition(coordinate, options);
+    return {
+        ...definition,
+        options
+    };
+}
+
+exports.createDefinition = createDefinition;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVmaW5pdGlvbi5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/EventCoordinator.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('deepmerge');
+const logger$1 = require('./logger.cjs');
+
+const logger = 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 removeEvents = (item)=>{
+    logger.default('Removing Events', {
+        item
+    });
+    delete item.events;
+    return item;
+};
+
+exports.populateEvents = populateEvents;
+exports.removeEvents = removeEvents;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXZlbnRDb29yZGluYXRvci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/Instance.cjs

@@ -0,0 +1,40 @@
+'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 _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);
+
+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__namespace.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+exports.createInstance = createInstance;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/KeyMaster.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('./logger.cjs');
+
+const logger = logger$1.default.get('sequelize', 'KeyMaster');
+const removeKey = (item)=>{
+    logger.default('Removing Key', {
+        item
+    });
+    delete item.key;
+    return item;
+};
+// export const populateKey = <
+//   S extends string,
+//   L1 extends string = never,
+//   L2 extends string = never,
+//   L3 extends string = never,
+//   L4 extends string = never,
+//   L5 extends string = never
+// >(
+//   item: ItemProperties<S, L1, L2, L3, L4, L5>,
+//   keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>
+// ): ItemProperties<S, L1, L2, L3, L4, L5> => {
+//   if (keyTypes.length === 1) {
+//     item.key = { kt: keyTypes[0], pk: item.id };
+//     delete item.id;
+//   } else if (keyTypes.length === 2) {
+//     item.key = {
+//       kt: keyTypes[0], pk: item.id,
+//       // TODO: Shouldn't this be inspecting the model to get the primary key type?
+//       loc: [{ kt: keyTypes[1], lk: item[keyTypes[1] + 'Id'] }],
+//     };
+//     delete item.id;
+//     delete item[keyTypes[1] + 'Id'];
+//   } else {
+//     throw new Error('Not implemented');
+//   }
+//   return item;
+// }
+const addKey = (item, keyTypes)=>{
+    logger.default('Adding Key', {
+        item
+    });
+    const key = {};
+    if (Array.isArray(keyTypes) && keyTypes.length > 1) {
+        const type = [
+            ...keyTypes
+        ];
+        const pkType = type.shift();
+        Object.assign(key, {
+            kt: pkType,
+            pk: item.id
+        });
+        // TODO: This is really just for primary items
+        if (type.length === 1) {
+            // TODO: This should be looking at the model to get the primary key of the reference item or association
+            const locKeyTypeId = type[0] + 'Id';
+            Object.assign(key, {
+                loc: [
+                    {
+                        kt: type[0],
+                        lk: item[locKeyTypeId]
+                    }
+                ]
+            });
+        } else if (type.length === 2) {
+            throw new Error('Not implemented');
+        } else if (type.length === 3) {
+            throw new Error('Not implemented');
+        } else if (type.length === 4) {
+            throw new Error('Not implemented');
+        } else if (type.length === 5) {
+            throw new Error('Not implemented');
+        }
+    } else {
+        Object.assign(key, {
+            kt: keyTypes[0],
+            pk: item.id
+        });
+    }
+    Object.assign(item, {
+        key
+    });
+    return item;
+};
+
+exports.addKey = addKey;
+exports.removeKey = removeKey;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/Operations.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const all = require('./ops/all.cjs');
+const create = require('./ops/create.cjs');
+const find = require('./ops/find.cjs');
+const get = require('./ops/get.cjs');
+const one = require('./ops/one.cjs');
+const remove = require('./ops/remove.cjs');
+const update = require('./ops/update.cjs');
+
+const createOperations = (models, definition, registry)=>{
+    const operations = {};
+    operations.all = all.getAllOperation(models, definition, registry);
+    operations.one = one.getOneOperation(models, definition, registry);
+    operations.create = create.getCreateOperation();
+    operations.update = update.getUpdateOperation(models, definition, registry);
+    operations.get = get.getGetOperation(models, definition, registry);
+    operations.remove = remove.getRemoveOperation(models, definition);
+    operations.find = find.getFindOperation(models, definition, registry);
+    operations.upsert = ()=>{
+        throw new Error('Not implemented');
+    };
+    return operations;
+};
+
+exports.createOperations = createOperations;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/Options.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Library = require('@fjell/lib');
+const deepmerge = require('deepmerge');
+const general = require('./util/general.cjs');
+
+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_OPTIONS = {
+    deleteOnRemove: false,
+    references: [],
+    aggregations: []
+};
+const createOptions = (libOptions)=>{
+    const options = Library__namespace.createOptions(libOptions);
+    return deepmerge(DEFAULT_OPTIONS, general.clean(options));
+};
+
+exports.createOptions = createOptions;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/QueryBuilder.cjs

@@ -0,0 +1,188 @@
+'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)=>{
+    const 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');
+        }
+    });
+    where[compoundOp] = conditions;
+    options.where = where;
+    return options;
+};
+const addCondition = (conditions, condition, model)=>{
+    let conditionOp;
+    const conditionColumn = condition.column;
+    if (!model.getAttributes()[conditionColumn]) {
+        throw new Error(`Condition column ${conditionColumn} not found on model ${model.name}`);
+    }
+    if (condition.operator === '==') {
+        conditionOp = sequelize.Op.eq;
+    } else if (condition.operator === '<') {
+        conditionOp = sequelize.Op.lt;
+    } else if (condition.operator === '>') {
+        conditionOp = sequelize.Op.gt;
+    } else if (condition.operator === '<=') {
+        conditionOp = sequelize.Op.lte;
+    } else if (condition.operator === '>=') {
+        conditionOp = sequelize.Op.gte;
+    } else if (condition.operator === 'in') {
+        conditionOp = sequelize.Op.in;
+    } else {
+        throw new Error(`Operator ${condition.operator} not supported`);
+    }
+    conditions[conditionColumn] = {
+        [conditionOp]: condition.value
+    };
+    return conditions;
+};
+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
+                ]
+            ];
+        });
+    }
+    return options;
+};
+
+exports.addCompoundCondition = addCompoundCondition;
+exports.addCondition = addCondition;
+exports.buildQuery = buildQuery;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

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(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