@fjell/lib-sequelize 4.3.4 → 4.4.1

package/dist/es/Operations.js

@@ -0,0 +1,25 @@
+import { getAllOperation } from './ops/all.js';
+import { getCreateOperation } from './ops/create.js';
+import { getFindOperation } from './ops/find.js';
+import { getGetOperation } from './ops/get.js';
+import { getOneOperation } from './ops/one.js';
+import { getRemoveOperation } from './ops/remove.js';
+import { getUpdateOperation } from './ops/update.js';
+
+const createOperations = (models, definition, registry)=>{
+    const operations = {};
+    operations.all = getAllOperation(models, definition, registry);
+    operations.one = getOneOperation(models, definition, registry);
+    operations.create = getCreateOperation();
+    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 = ()=>{
+        throw new Error('Not implemented');
+    };
+    return operations;
+};
+
+export { createOperations };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/Options.js

@@ -0,0 +1,16 @@
+import * as Library from '@fjell/lib';
+import deepmerge from 'deepmerge';
+import { clean } from './util/general.js';
+
+const DEFAULT_OPTIONS = {
+    deleteOnRemove: false,
+    references: [],
+    aggregations: []
+};
+const createOptions = (libOptions)=>{
+    const options = Library.createOptions(libOptions);
+    return deepmerge(DEFAULT_OPTIONS, clean(options));
+};
+
+export { createOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src → es}/QueryBuilder.js

@@ -1,50 +1,70 @@
-import { isComKey, isCondition, isPriKey } from '@fjell/core';
+import { isCondition, isPriKey, isComKey } from '@fjell/core';
 import { Op } from 'sequelize';
-import LibLogger from './logger';
+import LibLogger from './logger.js';
+
 const logger = LibLogger.get('sequelize', 'QueryBuilder');
-const addDeleteQuery = (options, model) => {
-    logger.default('Adding Delete Query', { options });
+const addDeleteQuery = (options, model)=>{
+    logger.default('Adding Delete Query', {
+        options
+    });
     if (model.getAttributes().deletedAt) {
         options.where['deletedAt'] = {
             [Op.eq]: null
         };
-    }
-    else if (model.getAttributes().isDeleted) {
+    } else if (model.getAttributes().isDeleted) {
         options.where['isDeleted'] = {
             [Op.eq]: false
         };
     }
     return options;
 };
-const addEventQueries = (options, events, model) => {
-    logger.default('Adding Event Queries', { options, events });
-    Object.keys(events).forEach((key) => {
+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, [Op.gte]: new Date(event.start) };
+            whereClauses = {
+                ...whereClauses,
+                [Op.gte]: new Date(event.start)
+            };
         }
         if (event.end) {
-            whereClauses = { ...whereClauses, [Op.lt]: new Date(event.end) };
+            whereClauses = {
+                ...whereClauses,
+                [Op.lt]: new Date(event.end)
+            };
         }
         if (event.by) {
             if (!model.getAttributes()[`${key}By`]) {
                 throw new Error(`Event ${key} is not supported on this model, column ${key}By not found`);
             }
-            whereClauses = { ...whereClauses, [Op.eq]: event.by };
+            whereClauses = {
+                ...whereClauses,
+                [Op.eq]: event.by
+            };
         }
         options.where[`${key}At`] = whereClauses;
     });
     return options;
 };
 // Add the references to the query
-const addReferenceQueries = (options, references, model) => {
-    logger.default('Adding Reference Queries', { options, references });
-    Object.keys(references).forEach((key) => {
-        logger.default('Adding Reference Query', { key, references });
+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`);
         }
@@ -53,30 +73,26 @@ const addReferenceQueries = (options, references, model) => {
             options.where[`${key}Id`] = {
                 [Op.eq]: priKey.pk
             };
-        }
-        else if (isComKey(references[key])) {
+        } else if (isComKey(references[key])) {
             throw new Error('ComKeys are not supported in Sequelize');
         }
     });
     return options;
 };
-export const addCompoundCondition = (options, compoundCondition, model) => {
+const addCompoundCondition = (options, compoundCondition, model)=>{
     const where = {};
     let compoundOp;
     const compoundType = compoundCondition.compoundType;
     if (compoundType === "AND") {
         compoundOp = Op.and;
-    }
-    else {
+    } else {
         compoundOp = Op.or;
     }
-    ;
     let conditions = {};
-    compoundCondition.conditions.forEach((condition) => {
+    compoundCondition.conditions.forEach((condition)=>{
         if (isCondition(condition)) {
             conditions = addCondition(conditions, condition, model);
-        }
-        else {
+        } else {
             throw new Error('Nest Compound conditions not supported');
         }
     });
@@ -84,7 +100,7 @@ export const addCompoundCondition = (options, compoundCondition, model) => {
     options.where = where;
     return options;
 };
-export const addCondition = (conditions, condition, model) => {
+const addCondition = (conditions, condition, model)=>{
     let conditionOp;
     const conditionColumn = condition.column;
     if (!model.getAttributes()[conditionColumn]) {
@@ -92,23 +108,17 @@ export const addCondition = (conditions, condition, model) => {
     }
     if (condition.operator === '==') {
         conditionOp = Op.eq;
-    }
-    else if (condition.operator === '<') {
+    } else if (condition.operator === '<') {
         conditionOp = Op.lt;
-    }
-    else if (condition.operator === '>') {
+    } else if (condition.operator === '>') {
         conditionOp = Op.gt;
-    }
-    else if (condition.operator === '<=') {
+    } else if (condition.operator === '<=') {
         conditionOp = Op.lte;
-    }
-    else if (condition.operator === '>=') {
+    } else if (condition.operator === '>=') {
         conditionOp = Op.gte;
-    }
-    else if (condition.operator === 'in') {
+    } else if (condition.operator === 'in') {
         conditionOp = Op.in;
-    }
-    else {
+    } else {
         throw new Error(`Operator ${condition.operator} not supported`);
     }
     conditions[conditionColumn] = {
@@ -116,13 +126,17 @@ export const addCondition = (conditions, condition, model) => {
     };
     return conditions;
 };
-export const buildQuery = (itemQuery, model) => {
-    logger.default('build', { itemQuery });
+const buildQuery = (itemQuery, model)=>{
+    logger.default('build', {
+        itemQuery
+    });
     let options = {
-        where: {},
+        where: {}
     };
     if (itemQuery.compoundCondition) {
-        logger.default('Adding Conditions', { compoundCondition: 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
@@ -138,7 +152,9 @@ export const buildQuery = (itemQuery, 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 });
+        logger.default('Limiting to', {
+            limit: itemQuery.limit
+        });
         options.limit = itemQuery.limit;
     }
     // Apply an offset to the result set
@@ -147,15 +163,20 @@ export const buildQuery = (itemQuery, model) => {
     }
     // Add orderBy to the query
     if (itemQuery.orderBy) {
-        itemQuery.orderBy.forEach((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]
+                [
+                    orderBy.field,
+                    orderBy.direction
+                ]
             ];
         });
     }
     return options;
 };
-//# sourceMappingURL=QueryBuilder.js.map
+
+export { addCompoundCondition, addCondition, buildQuery };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/ReferenceBuilder.js

@@ -0,0 +1,30 @@
+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;
+};
+
+export { buildReference };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/RowProcessor.js

@@ -0,0 +1,37 @@
+import LibLogger from './logger.js';
+import { addKey } from './KeyMaster.js';
+import { buildReference } from './ReferenceBuilder.js';
+import { buildAggregation } from './AggregationBuilder.js';
+import { stringifyJSON } from './util/general.js';
+import { populateEvents } from './EventCoordinator.js';
+
+const logger = LibLogger.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', stringifyJSON(keyTypes));
+    item = addKey(item, keyTypes);
+    item = populateEvents(item);
+    logger.default('Key Added to Item: %s', stringifyJSON(item.key));
+    if (referenceDefinitions && referenceDefinitions.length > 0) {
+        for (const referenceDefinition of referenceDefinitions){
+            logger.default('Processing Reference for %s to %s', item.key.kt, stringifyJSON(referenceDefinition.kta));
+            item = await 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, stringifyJSON(aggregationDefinition.kta));
+            item = await buildAggregation(item, aggregationDefinition, registry);
+        }
+    }
+    logger.default('Processed Row: %j', stringifyJSON(item));
+    return item;
+};
+
+export { processRow };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/contained/Instance.js

@@ -0,0 +1,17 @@
+import { Contained } from '@fjell/lib';
+import { createDefinition } from '../Definition.js';
+import { createOperations } from '../Operations.js';
+
+function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry) {
+    const definition = createDefinition(keyTypes, scopes, libOptions);
+    const operations = createOperations(models, definition, registry);
+    return {
+        definition,
+        operations: Contained.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+export { createInstance };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/contained/index.js

@@ -0,0 +1,2 @@
+export { createInstance } from './Instance.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/es/index.js

@@ -0,0 +1,10 @@
+export { SCOPE_SEQUELIZE, createCoordinate } from './Coordinate.js';
+export { createDefinition } from './Definition.js';
+export { createInstance } from './Instance.js';
+export { createOptions } from './Options.js';
+export { createOperations } from './Operations.js';
+import * as index from './contained/index.js';
+export { index as Contained };
+import * as index$1 from './primary/index.js';
+export { index$1 as Primary };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OzsifQ==

package/dist/es/logger.js

@@ -0,0 +1,6 @@
+import Logging from '@fjell/logging';
+
+const LibLogger = Logging.getLogger('@fjell/lib-sequelize');
+
+export { LibLogger as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OyJ9

package/dist/{src → es}/ops/all.js

@@ -1,14 +1,18 @@
-import { validateKeys } from "@fjell/core";
-import { buildQuery } from "../QueryBuilder";
-import LibLogger from '../logger';
-import { processRow } from "../RowProcessor";
-import { Op } from "sequelize";
+import { validateKeys } from '@fjell/core';
+import { buildQuery } from '../QueryBuilder.js';
+import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
+import { Op } from 'sequelize';
+
 const logger = LibLogger.get('sequelize', 'ops', 'all');
-export const getAllOperation = (models, definition) => {
-    const { coordinate } = definition;
+const getAllOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
     //#region Query
-    const all = async (itemQuery, locations) => {
-        logger.default('All', { itemQuery, locations });
+    const all = async (itemQuery, locations)=>{
+        logger.default('All', {
+            itemQuery,
+            locations
+        });
         const loc = locations || [];
         // SQ Libs don't support locations
         if (loc.length > 1) {
@@ -30,18 +34,25 @@ export const getAllOperation = (models, definition) => {
                         [Op.eq]: loc[0].lk
                     }
                 };
-            }
-            else {
+            } 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 });
+        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 matchingItems.map((row) => validateKeys(processRow(row, coordinate.kta), coordinate.kta));
+        return await Promise.all(matchingItems.map(async (row)=>{
+            const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry);
+            return validateKeys(processedRow, coordinate.kta);
+        }));
     };
     return all;
 };
-//# sourceMappingURL=all.js.map
+
+export { getAllOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/ops/create.js

@@ -0,0 +1,19 @@
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('sequelize', 'ops', 'create');
+const getCreateOperation = (// eslint-disable-next-line @typescript-eslint/no-unused-vars
+models, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+definition, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+registry)=>{
+    const create = async (item, options)=>{
+        logger.default('Create', {
+            item,
+            options
+        });
+        throw new Error('Not implemented');
+    };
+    return create;
+};
+
+export { getCreateOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/ops/find.js

@@ -0,0 +1,41 @@
+import { validateKeys } from '@fjell/core';
+import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
+
+const logger = LibLogger.get('sequelize', 'ops', 'find');
+const getFindOperation = (models, definition, registry)=>{
+    const { options: { finders, references, aggregations } } = definition;
+    const find = async (finder, finderParams, locations)=>{
+        logger.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 validateKeys(processedRow, definition.coordinate.kta);
+                    }));
+                } else {
+                    return [];
+                }
+            } else {
+                logger.error(`Finder %s not found`, finder);
+                throw new Error(`Finder ${finder} not found`);
+            }
+        } else {
+            logger.error(`No finders have been defined for this lib`);
+            throw new Error(`No finders found`);
+        }
+    };
+    return find;
+};
+
+export { getFindOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/ops/get.js

@@ -0,0 +1,45 @@
+import { isValidItemKey, isPriKey, isComKey, validateKeys } from '@fjell/core';
+import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
+import { NotFoundError } from '@fjell/lib';
+
+const logger = LibLogger.get('sequelize', 'ops', 'get');
+const getGetOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
+    const { kta } = coordinate;
+    const get = async (key)=>{
+        logger.default('Get', {
+            key
+        });
+        if (!isValidItemKey(key)) {
+            logger.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 (isPriKey(itemKey)) {
+            item = await model.findByPk(itemKey.pk);
+        } else if (isComKey(itemKey)) {
+            var _comKey_loc_, _comKey_loc_1;
+            const comKey = itemKey;
+            // TODO: This should probably interrogate the model?
+            item = await model.findOne({
+                where: {
+                    id: comKey.pk,
+                    [(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
+                }
+            });
+        }
+        if (!item) {
+            throw new NotFoundError('get', coordinate, key);
+        } else {
+            return validateKeys(await processRow(item, kta, references, aggregations, registry), kta);
+        }
+    };
+    return get;
+};
+
+export { getGetOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/ops/one.js

@@ -0,0 +1,22 @@
+import LibLogger from '../logger.js';
+import { getAllOperation } from './all.js';
+
+const logger = LibLogger.get('sequelize', 'ops', 'one');
+const getOneOperation = (models, definition, registry)=>{
+    const one = async (itemQuery, locations = [])=>{
+        logger.default('One', {
+            itemQuery,
+            locations
+        });
+        const items = await getAllOperation(models, definition, registry)(itemQuery, locations);
+        if (items.length > 0) {
+            return items[0];
+        } else {
+            return null;
+        }
+    };
+    return one;
+};
+
+export { getOneOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/ops/remove.js

@@ -0,0 +1,68 @@
+import { isValidItemKey, abbrevIK, isPriKey, isComKey } from '@fjell/core';
+import { populateEvents } from '../EventCoordinator.js';
+import { addKey } from '../KeyMaster.js';
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('sequelize', 'ops', 'remove');
+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.default('Remove', {
+            key
+        });
+        if (!isValidItemKey(key)) {
+            logger.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.debug('remove: %s', abbrevIK(key));
+        if (isPriKey(key)) {
+            item = await model.findByPk(key.pk);
+        } else if (isComKey(key)) {
+            var _comKey_loc_, _comKey_loc_1;
+            const comKey = key;
+            item = await model.findOne({
+                where: {
+                    id: comKey.pk,
+                    [(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
+                }
+            });
+        }
+        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(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(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;
+};
+
+export { getRemoveOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=