@fjell/lib-sequelize 4.3.4 → 4.4.0

package/dist/Coordinate.js

@@ -0,0 +1,13 @@
+import * as Library from '@fjell/lib';
+
+const SCOPE_SEQUELIZE = 'sequelize';
+const createCoordinate = (kta, scopes)=>{
+    const coordinate = Library.createCoordinate(kta, [
+        SCOPE_SEQUELIZE,
+        ...scopes || []
+    ]);
+    return coordinate;
+};
+
+export { SCOPE_SEQUELIZE, createCoordinate };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29vcmRpbmF0ZS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Definition.js

@@ -0,0 +1,23 @@
+import * as Library from '@fjell/lib';
+import { createCoordinate } from './Coordinate.js';
+import { createOptions } from './Options.js';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.get('lib-sequelize', 'Definition');
+function createDefinition(kta, scopes, libOptions) {
+    logger.debug('createDefinition', {
+        kta,
+        scopes,
+        libOptions
+    });
+    const coordinate = createCoordinate(kta, scopes);
+    const options = createOptions(libOptions);
+    const definition = Library.createDefinition(coordinate, options);
+    return {
+        ...definition,
+        options
+    };
+}
+
+export { createDefinition };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVmaW5pdGlvbi5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/EventCoordinator.js

@@ -0,0 +1,30 @@
+import 'deepmerge';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.get("sequelize", "EventCoordinator");
+//#endregion
+const populateEvents = (item)=>{
+    const events = {
+        created: {
+            at: item.createdAt
+        },
+        updated: {
+            at: item.updatedAt
+        },
+        deleted: {
+            at: null
+        }
+    };
+    item.events = events;
+    return item;
+};
+const removeEvents = (item)=>{
+    logger.default('Removing Events', {
+        item
+    });
+    delete item.events;
+    return item;
+};
+
+export { populateEvents, removeEvents };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXZlbnRDb29yZGluYXRvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/Instance.js

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

package/dist/KeyMaster.js

@@ -0,0 +1,84 @@
+import LibLogger from './logger.js';
+
+const logger = LibLogger.get('sequelize', 'KeyMaster');
+const removeKey = (item)=>{
+    logger.default('Removing Key', {
+        item
+    });
+    delete item.key;
+    return item;
+};
+const populateKey = (item, keyTypes)=>{
+    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
+    });
+};
+
+export { addKey, populateKey, removeKey };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/{src/Operations.d.ts → Operations.d.ts}

@@ -1,5 +1,5 @@
-import { Item } from "@fjell/core";
+import { Item } from '@fjell/core';
+import { ModelStatic } from 'sequelize';
+import { Definition } from '@fjell/lib';
 import * as Library from "@fjell/lib";
-import { ModelStatic } from "sequelize";
-import { Definition } from "@fjell/lib";
 export declare const createOperations: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: Array<ModelStatic<any>>, definition: Definition<V, S, L1, L2, L3, L4, L5>) => Library.Operations<V, S, L1, L2, L3, L4, L5>;

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

package/dist/Options.js

@@ -0,0 +1,19 @@
+import * as Library from '@fjell/lib';
+import deepmerge from 'deepmerge';
+
+const defaultOptions = {
+    deleteOnRemove: false
+};
+const createOptions = (libOptions)=>{
+    const defaultOptions = {
+        deleteOnRemove: false
+    };
+    const options = Library.createOptions(libOptions);
+    const mergedOptions = deepmerge(defaultOptions, options);
+    return {
+        ...mergedOptions
+    };
+};
+
+export { createOptions, defaultOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src/QueryBuilder.js → 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/{src/RowProcessor.d.ts → RowProcessor.d.ts}

@@ -1,3 +1,3 @@
-import { AllItemTypeArrays, Item } from "@fjell/core";
-import { Model } from "sequelize";
+import { AllItemTypeArrays, Item } from '@fjell/core';
+import { Model } from 'sequelize';
 export declare const processRow: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(row: Model<any, any>, keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>) => Item<S, L1, L2, L3, L4, L5>;

package/dist/RowProcessor.js

@@ -0,0 +1,18 @@
+import LibLogger from './logger.js';
+import { addKey } from './KeyMaster.js';
+
+const logger = LibLogger.get('sequelize', 'RowProcessor');
+const processRow = (row, keyTypes)=>{
+    logger.default('Processing Row', {
+        row
+    });
+    const item = row.get({
+        plain: true
+    });
+    addKey(item, keyTypes);
+    logger.default('Processed Row: ' + JSON.stringify(item));
+    return item;
+};
+
+export { processRow };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/contained/Instance.js

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

package/dist/contained/index.js

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

package/dist/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, defaultOptions } 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/logger.d.ts

@@ -0,0 +1,2 @@
+declare const LibLogger: import('@fjell/logging').Logger;
+export default LibLogger;

package/dist/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/ops → ops}/all.d.ts

@@ -1,4 +1,4 @@
-import { Definition } from "../Definition";
-import { Item, ItemQuery, LocKeyArray } from "@fjell/core";
-import { ModelStatic } from "sequelize";
+import { Definition } from '../Definition';
+import { Item, ItemQuery, LocKeyArray } from '@fjell/core';
+import { ModelStatic } from 'sequelize';
 export declare const getAllOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (itemQuery: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | [] | undefined) => Promise<V[]>;

package/dist/{src/ops → 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 getAllOperation = (models, definition)=>{
     const { coordinate } = 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,22 @@ 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 matchingItems.map((row)=>validateKeys(processRow(row, coordinate.kta), coordinate.kta));
     };
     return all;
 };
-//# sourceMappingURL=all.js.map
+
+export { getAllOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{src/ops → ops}/create.d.ts

@@ -1,6 +1,6 @@
-import { ComKey, Item, LocKeyArray, PriKey, TypesProperties } from "@fjell/core";
-import { ModelStatic } from "sequelize";
-import { Definition } from "../Definition";
+import { ComKey, Item, LocKeyArray, PriKey, TypesProperties } from '@fjell/core';
+import { ModelStatic } from 'sequelize';
+import { Definition } from '../Definition';
 export declare const getCreateOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (item: TypesProperties<V, S, L1, L2, L3, L4, L5>, options?: {
     key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>;
     locations?: never;

package/dist/ops/create.js

@@ -0,0 +1,18 @@
+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)=>{
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/{src/ops → ops}/find.d.ts

@@ -1,4 +1,4 @@
-import { Item, LocKeyArray } from "@fjell/core";
-import { Definition } from "../Definition";
-import { ModelStatic } from "sequelize";
+import { Item, LocKeyArray } from '@fjell/core';
+import { Definition } from '../Definition';
+import { ModelStatic } from 'sequelize';
 export declare const getFindOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (finder: string, finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;