@fjell/lib-sequelize 4.4.0 → 4.4.1

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/{contained → es/contained}/Instance.js

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

package/dist/{index.js → es/index.js}

@@ -1,7 +1,7 @@
 export { SCOPE_SEQUELIZE, createCoordinate } from './Coordinate.js';
 export { createDefinition } from './Definition.js';
 export { createInstance } from './Instance.js';
-export { createOptions, defaultOptions } from './Options.js';
+export { createOptions } from './Options.js';
 export { createOperations } from './Operations.js';
 import * as index from './contained/index.js';
 export { index as Contained };

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

@@ -5,8 +5,8 @@ import { processRow } from '../RowProcessor.js';
 import { Op } from 'sequelize';
 
 const logger = LibLogger.get('sequelize', 'ops', 'all');
-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', {
@@ -46,10 +46,13 @@ const getAllOperation = (models, definition)=>{
         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;
 };
 
 export { getAllOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{ops → es/ops}/create.js

@@ -3,7 +3,8 @@ 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)=>{
+definition, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+registry)=>{
     const create = async (item, options)=>{
         logger.default('Create', {
             item,
@@ -15,4 +16,4 @@ definition)=>{
 };
 
 export { getCreateOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{ops → es/ops}/find.js

@@ -1,8 +1,10 @@
+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)=>{
-    const { options } = definition;
+const getFindOperation = (models, definition, registry)=>{
+    const { options: { finders, references, aggregations } } = definition;
     const find = async (finder, finderParams, locations)=>{
         logger.default('Find', {
             finder,
@@ -11,10 +13,18 @@ const getFindOperation = (models, definition)=>{
         });
         // 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 (options.finders && options.finders[finder]) {
-            const finderMethod = options.finders[finder];
+        if (finders && finders[finder]) {
+            const finderMethod = finders[finder];
             if (finderMethod) {
-                return finderMethod(finderParams, locations);
+                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`);
@@ -28,4 +38,4 @@ const getFindOperation = (models, definition)=>{
 };
 
 export { getFindOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/{ops → es/ops}/get.js

@@ -4,8 +4,8 @@ import { processRow } from '../RowProcessor.js';
 import { NotFoundError } from '@fjell/lib';
 
 const logger = LibLogger.get('sequelize', 'ops', 'get');
-const getGetOperation = (models, definition)=>{
-    const { coordinate } = definition;
+const getGetOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
     const { kta } = coordinate;
     const get = async (key)=>{
         logger.default('Get', {
@@ -35,7 +35,7 @@ const getGetOperation = (models, definition)=>{
         if (!item) {
             throw new NotFoundError('get', coordinate, key);
         } else {
-            return validateKeys(processRow(item, kta), kta);
+            return validateKeys(await processRow(item, kta, references, aggregations, registry), kta);
         }
     };
     return get;

package/dist/{ops → es/ops}/one.js

@@ -2,13 +2,13 @@ import LibLogger from '../logger.js';
 import { getAllOperation } from './all.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'one');
-const getOneOperation = (models, definition)=>{
+const getOneOperation = (models, definition, registry)=>{
     const one = async (itemQuery, locations = [])=>{
         logger.default('One', {
             itemQuery,
             locations
         });
-        const items = await getAllOperation(models, definition)(itemQuery, locations);
+        const items = await getAllOperation(models, definition, registry)(itemQuery, locations);
         if (items.length > 0) {
             return items[0];
         } else {

package/dist/{ops → es/ops}/remove.js

@@ -1,10 +1,11 @@
 import { isValidItemKey, abbrevIK, isPriKey, isComKey } from '@fjell/core';
 import { populateEvents } from '../EventCoordinator.js';
-import { populateKey } from '../KeyMaster.js';
+import { addKey } from '../KeyMaster.js';
 import LibLogger from '../logger.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'remove');
-const getRemoveOperation = (models, definition)=>{
+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)=>{
@@ -46,14 +47,14 @@ const getRemoveOperation = (models, definition)=>{
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
             });
-            returnItem = populateKey(returnItem, kta);
+            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 = populateKey(returnItem, kta);
+            returnItem = addKey(returnItem, kta);
             returnItem = populateEvents(returnItem);
         } else {
             throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
@@ -64,4 +65,4 @@ const getRemoveOperation = (models, definition)=>{
 };
 
 export { getRemoveOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{ops → es/ops}/update.js

@@ -1,11 +1,14 @@
-import { abbrevIK, isPriKey, isComKey } from '@fjell/core';
-import { removeEvents, populateEvents } from '../EventCoordinator.js';
-import { removeKey, populateKey } from '../KeyMaster.js';
+import { abbrevIK, isPriKey, isComKey, validateKeys } from '@fjell/core';
+import { removeEvents } from '../EventCoordinator.js';
+import { removeKey } from '../KeyMaster.js';
 import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
+import { stringifyJSON } from '../util/general.js';
 import { NotFoundError } from '@fjell/lib';
 
 const logger = LibLogger.get('sequelize', 'ops', 'update');
-const getUpdateOperation = (models, definition)=>{
+const getUpdateOperation = (models, definition, registry)=>{
+    const { options: { references, aggregations } } = definition;
     const update = async (key, item)=>{
         const { coordinate } = definition;
         const { kta } = coordinate;
@@ -33,18 +36,13 @@ const getUpdateOperation = (models, definition)=>{
             // Remove the key and events
             let updateProps = removeKey(item);
             updateProps = removeEvents(item);
+            logger.default('Response: %s', stringifyJSON(response));
+            logger.default('Update Properties: %s', stringifyJSON(updateProps));
             // Update the object
-            response = {
-                ...response,
-                ...updateProps
-            };
-            await (response === null || response === void 0 ? void 0 : response.save());
+            response = await response.update(updateProps);
             // Populate the key and events
-            let returnItem = response === null || response === void 0 ? void 0 : response.get({
-                plain: true
-            });
-            returnItem = populateKey(returnItem, kta);
-            returnItem = populateEvents(returnItem);
+            const processedItem = await processRow(response, kta, references, aggregations, registry);
+            const returnItem = validateKeys(processedItem, kta);
             return returnItem;
         } else {
             throw new NotFoundError('update', coordinate, key);
@@ -54,4 +52,4 @@ const getUpdateOperation = (models, definition)=>{
 };
 
 export { getUpdateOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{primary → es/primary}/Instance.js

@@ -4,7 +4,7 @@ import { createOperations } from '../Operations.js';
 import LibLogger from '../logger.js';
 
 const logger = LibLogger.get('lib-sequelize', 'primary', 'instance');
-function createInstance(keyType, models, libOptions = {}, scopes = []) {
+function createInstance(keyType, models, libOptions = {}, scopes = [], registry) {
     logger.debug('createInstance', {
         keyType,
         models,
@@ -14,13 +14,14 @@ function createInstance(keyType, models, libOptions = {}, scopes = []) {
     const definition = createDefinition([
         keyType
     ], scopes, libOptions);
-    const operations = createOperations(models, definition);
+    const operations = createOperations(models, definition, registry);
     return {
         definition,
-        operations: Primary.wrapOperations(operations, definition),
-        models
+        operations: Primary.wrapOperations(operations, definition, registry),
+        models,
+        registry
     };
 }
 
 export { createInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/util/general.js

@@ -0,0 +1,47 @@
+/* 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 '';
+};
+
+export { clean, stringifyJSON };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhbC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9