@fjell/lib-sequelize 4.3.4 → 4.4.1

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,23 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('../logger.cjs');
+
+const logger = logger$1.default.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;
+};
+
+exports.getCreateOperation = getCreateOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/ops/find.cjs

@@ -0,0 +1,45 @@
+'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 logger = logger$1.default.get('sequelize', 'ops', 'find');
+const getFindOperation = (models, definition, registry)=>{
+    const { options: { finders, references, aggregations } } = definition;
+    const find = async (finder, finderParams, locations)=>{
+        logger.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 RowProcessor.processRow(row, definition.coordinate.kta, references, aggregations, registry);
+                        return core.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;
+};
+
+exports.getFindOperation = getFindOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/ops/get.cjs

@@ -0,0 +1,49 @@
+'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 Library = require('@fjell/lib');
+
+const logger = logger$1.default.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 (!core.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 (core.isPriKey(itemKey)) {
+            item = await model.findByPk(itemKey.pk);
+        } else if (core.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 Library.NotFoundError('get', coordinate, key);
+        } else {
+            return core.validateKeys(await RowProcessor.processRow(item, kta, references, aggregations, registry), kta);
+        }
+    };
+    return get;
+};
+
+exports.getGetOperation = getGetOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/ops/one.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('../logger.cjs');
+const all = require('./all.cjs');
+
+const logger = logger$1.default.get('sequelize', 'ops', 'one');
+const getOneOperation = (models, definition, registry)=>{
+    const one = async (itemQuery, locations = [])=>{
+        logger.default('One', {
+            itemQuery,
+            locations
+        });
+        const items = await all.getAllOperation(models, definition, registry)(itemQuery, locations);
+        if (items.length > 0) {
+            return items[0];
+        } else {
+            return null;
+        }
+    };
+    return one;
+};
+
+exports.getOneOperation = getOneOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/ops/remove.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const EventCoordinator = require('../EventCoordinator.cjs');
+const KeyMaster = require('../KeyMaster.cjs');
+const logger$1 = require('../logger.cjs');
+
+const logger = logger$1.default.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 (!core.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', core.abbrevIK(key));
+        if (core.isPriKey(key)) {
+            item = await model.findByPk(key.pk);
+        } else if (core.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 = KeyMaster.addKey(returnItem, kta);
+            returnItem = EventCoordinator.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 = KeyMaster.addKey(returnItem, kta);
+            returnItem = EventCoordinator.populateEvents(returnItem);
+        } else {
+            throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
+        }
+        return returnItem;
+    };
+    return remove;
+};
+
+exports.getRemoveOperation = getRemoveOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/ops/update.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const EventCoordinator = require('../EventCoordinator.cjs');
+const KeyMaster = require('../KeyMaster.cjs');
+const logger$1 = require('../logger.cjs');
+const RowProcessor = require('../RowProcessor.cjs');
+const general = require('../util/general.cjs');
+const Library = require('@fjell/lib');
+
+const logger = logger$1.default.get('sequelize', 'ops', 'update');
+const getUpdateOperation = (models, definition, registry)=>{
+    const { options: { references, aggregations } } = definition;
+    const update = async (key, item)=>{
+        const { coordinate } = definition;
+        const { kta } = coordinate;
+        logger.debug('update: %s, %j', core.abbrevIK(key), item);
+        // Find the object we're updating
+        // @ts-ignore
+        const model = models[0];
+        let response;
+        if (core.isPriKey(key)) {
+            // Find the model by using the PK
+            const priKey = key;
+            response = await model.findByPk(priKey.pk);
+        } else if (core.isComKey(key)) {
+            var _comKey_loc_, _comKey_loc_1;
+            const comKey = key;
+            // Find the model by using both of the identifiers.
+            response = await model.findOne({
+                where: {
+                    [(comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_ = comKey.loc[0]) === null || _comKey_loc_ === void 0 ? void 0 : _comKey_loc_.kt) + 'Id']: comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_1 = comKey.loc[0]) === null || _comKey_loc_1 === void 0 ? void 0 : _comKey_loc_1.lk,
+                    id: comKey === null || comKey === void 0 ? void 0 : comKey.pk
+                }
+            });
+        }
+        if (response) {
+            // Remove the key and events
+            let updateProps = KeyMaster.removeKey(item);
+            updateProps = EventCoordinator.removeEvents(item);
+            logger.default('Response: %s', general.stringifyJSON(response));
+            logger.default('Update Properties: %s', general.stringifyJSON(updateProps));
+            // Update the object
+            response = await response.update(updateProps);
+            // Populate the key and events
+            const processedItem = await RowProcessor.processRow(response, kta, references, aggregations, registry);
+            const returnItem = core.validateKeys(processedItem, kta);
+            return returnItem;
+        } else {
+            throw new Library.NotFoundError('update', coordinate, key);
+        }
+    };
+    return update;
+};
+
+exports.getUpdateOperation = getUpdateOperation;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/primary/Instance.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Library = require('@fjell/lib');
+const Definition = require('../Definition.cjs');
+const Operations = require('../Operations.cjs');
+const logger$1 = require('../logger.cjs');
+
+const logger = logger$1.default.get('lib-sequelize', 'primary', 'instance');
+function createInstance(keyType, models, libOptions = {}, scopes = [], registry) {
+    logger.debug('createInstance', {
+        keyType,
+        models,
+        libOptions,
+        scopes
+    });
+    const definition = Definition.createDefinition([
+        keyType
+    ], scopes, libOptions);
+    const operations = Operations.createOperations(models, definition, registry);
+    return {
+        definition,
+        operations: Library.Primary.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+exports.createInstance = createInstance;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/primary/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/util/general.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+/* eslint-disable @typescript-eslint/no-unused-vars */ /* eslint-disable no-undefined */ const clean = (obj)=>{
+    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
+};
+//Recursive implementation of jSON.stringify;
+const stringifyJSON = function(obj, visited = new Set()) {
+    const arrOfKeyVals = [];
+    const arrVals = [];
+    let objKeys = [];
+    /*********CHECK FOR PRIMITIVE TYPES**********/ if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null) return '' + obj;
+    else if (typeof obj === 'string') return '"' + obj + '"';
+    /*********DETECT CIRCULAR REFERENCES**********/ if (obj instanceof Object && visited.has(obj)) {
+        return '"(circular)"';
+    } else if (Array.isArray(obj)) {
+        //check for empty array
+        if (obj[0] === undefined) return '[]';
+        else {
+            // Add array to visited before processing its elements
+            visited.add(obj);
+            obj.forEach(function(el) {
+                arrVals.push(stringifyJSON(el, visited));
+            });
+            return '[' + arrVals + ']';
+        }
+    } else if (obj instanceof Object) {
+        // Add object to visited before processing its properties
+        visited.add(obj);
+        //get object keys
+        objKeys = Object.keys(obj);
+        //set key output;
+        objKeys.forEach(function(key) {
+            const keyOut = '"' + key + '":';
+            const keyValOut = obj[key];
+            //skip functions and undefined properties
+            if (keyValOut instanceof Function || keyValOut === undefined) return; // Skip this entry entirely instead of pushing an empty string
+            else if (typeof keyValOut === 'string') arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
+            else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null) arrOfKeyVals.push(keyOut + keyValOut);
+            else if (keyValOut instanceof Object) {
+                arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));
+            }
+        });
+        return '{' + arrOfKeyVals + '}';
+    }
+    return '';
+};
+
+exports.clean = clean;
+exports.stringifyJSON = stringifyJSON;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhbC5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/AggregationBuilder.js

@@ -0,0 +1,27 @@
+import { ikToLKA } from '@fjell/core';
+
+const buildAggregation = async (item, aggregationDefinition, registry)=>{
+    const location = 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;
+        });
+    }
+};
+
+export { buildAggregation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRpb25CdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/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/es/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/es/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 || 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;
+};
+
+export { populateEvents, removeEvents };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXZlbnRDb29yZGluYXRvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/Instance.js

@@ -0,0 +1,17 @@
+import * as Library 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: Library.wrapOperations(operations, definition, registry),
+        models,
+        registry
+    };
+}
+
+export { createInstance };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/KeyMaster.js

@@ -0,0 +1,86 @@
+import LibLogger from './logger.js';
+
+const logger = LibLogger.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;
+};
+
+export { addKey, removeKey };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=