@fjell/lib-sequelize 4.4.14 → 4.4.16

package/dist/es/ops/find.js

@@ -1,43 +0,0 @@
-import { validateKeys } from '@fjell/core';
-import LibLogger from '../logger.js';
-import { processRow } from '../RowProcessor.js';
-import { stringifyJSON } from '../util/general.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.debug(`FIND operation called on ${models[0].name} with finder '${finder}' and ${(locations === null || locations === void 0 ? void 0 : locations.length) || 0} location filters: ${(locations === null || locations === void 0 ? void 0 : locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ')) || 'none'}`);
-        logger.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
-        // 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) {
-                logger.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
-                const results = await finderMethod(finderParams, locations);
-                if (results && results.length > 0) {
-                    const processedResults = await Promise.all(results.map(async (row)=>{
-                        const processedRow = await processRow(row, definition.coordinate.kta, references, aggregations, registry);
-                        return validateKeys(processedRow, definition.coordinate.kta);
-                    }));
-                    logger.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
-                    return processedResults;
-                } else {
-                    logger.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
-                    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/ops/get.js

@@ -1,88 +0,0 @@
-import { isValidItemKey, isPriKey, isComKey, validateKeys } from '@fjell/core';
-import LibLogger from '../logger.js';
-import { processRow } from '../RowProcessor.js';
-import { NotFoundError } from '@fjell/lib';
-import { buildRelationshipPath } from '../util/relationshipUtils.js';
-import { contextManager } from '../OperationContext.js';
-import { stringifyJSON } from '../util/general.js';
-
-const logger = LibLogger.get('sequelize', 'ops', 'get');
-// Helper function to process composite key and build query options
-const processCompositeKey = (comKey, model, kta)=>{
-    const where = {
-        id: comKey.pk
-    };
-    const includes = [];
-    for (const locator of comKey.loc){
-        const relationshipInfo = buildRelationshipPath(model, locator.kt, kta);
-        if (!relationshipInfo.found) {
-            const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-            logger.error(errorMessage, {
-                key: comKey,
-                kta
-            });
-            throw new Error(errorMessage);
-        }
-        if (relationshipInfo.path) {
-            // This requires a relationship traversal
-            where[relationshipInfo.path] = locator.lk;
-            if (relationshipInfo.includes) {
-                includes.push(...relationshipInfo.includes);
-            }
-        } else {
-            // This is a direct field
-            const fieldName = `${locator.kt}Id`;
-            where[fieldName] = locator.lk;
-        }
-    }
-    const result = {
-        where
-    };
-    if (includes.length > 0) {
-        result.include = includes;
-    }
-    return result;
-};
-const getGetOperation = (models, definition, registry)=>{
-    const { coordinate, options: { references, aggregations } } = definition;
-    const { kta } = coordinate;
-    const get = async (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');
-        }
-        logger.debug(`GET operation called on ${models[0].name} with ${isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
-        logger.default(`Get configured for ${models[0].name} with ${isPriKey(key) ? 'primary' : 'composite'} key`);
-        const itemKey = key;
-        // @ts-ignore
-        const model = models[0];
-        let item;
-        if (isPriKey(itemKey)) {
-            // This is the easy case because we can just find the item by its primary key
-            logger.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
-            item = await model.findByPk(itemKey.pk);
-        } else if (isComKey(itemKey)) {
-            // This is a composite key, so we need to build a where clause based on the composite key's locators
-            const comKey = itemKey;
-            const queryOptions = processCompositeKey(comKey, model, kta);
-            logger.default('Composite key query', {
-                queryOptions
-            });
-            logger.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-            item = await model.findOne(queryOptions);
-        }
-        if (!item) {
-            throw new NotFoundError('get', coordinate, key);
-        } else {
-            // Get the current context from context manager
-            const context = contextManager.getCurrentContext();
-            const result = validateKeys(await processRow(item, kta, references, aggregations, registry, context), kta);
-            logger.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
-            return result;
-        }
-    };
-    return get;
-};
-
-export { getGetOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/ops/one.js

@@ -1,23 +0,0 @@
-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.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ') || 'none'}`);
-        logger.default(`One configured for ${models[0].name} delegating to all operation`);
-        const items = await getAllOperation(models, definition, registry)(itemQuery, locations);
-        if (items.length > 0) {
-            const result = items[0];
-            logger.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : 'unknown'}`);
-            return result;
-        } else {
-            logger.debug(`[ONE] No ${models[0].name} record found`);
-            return null;
-        }
-    };
-    return one;
-};
-
-export { getOneOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/ops/remove.js

@@ -1,110 +0,0 @@
-import { isValidItemKey, isPriKey, abbrevIK, isComKey } from '@fjell/core';
-import { populateEvents } from '../EventCoordinator.js';
-import { addKey } from '../KeyMaster.js';
-import LibLogger from '../logger.js';
-import { buildRelationshipPath } from '../util/relationshipUtils.js';
-import { stringifyJSON } from '../util/general.js';
-
-const logger = LibLogger.get('sequelize', 'ops', 'remove');
-// Helper function to process composite key and build query options
-const processCompositeKey = (comKey, model, kta)=>{
-    const where = {
-        id: comKey.pk
-    };
-    const includes = [];
-    for (const locator of comKey.loc){
-        const relationshipInfo = buildRelationshipPath(model, locator.kt, kta);
-        if (!relationshipInfo.found) {
-            const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-            logger.error(errorMessage, {
-                key: comKey,
-                kta
-            });
-            throw new Error(errorMessage);
-        }
-        if (relationshipInfo.path) {
-            // This requires a relationship traversal
-            where[relationshipInfo.path] = locator.lk;
-            if (relationshipInfo.includes) {
-                includes.push(...relationshipInfo.includes);
-            }
-        } else {
-            // This is a direct field
-            const fieldName = `${locator.kt}Id`;
-            where[fieldName] = locator.lk;
-        }
-    }
-    const result = {
-        where
-    };
-    if (includes.length > 0) {
-        result.include = includes;
-    }
-    return result;
-};
-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)=>{
-        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');
-        }
-        logger.debug(`REMOVE operation called on ${models[0].name} with ${isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
-        logger.default(`Remove configured for ${models[0].name} with ${isPriKey(key) ? 'primary' : 'composite'} key`);
-        // @ts-ignore
-        const model = models[0];
-        let item;
-        let returnItem;
-        logger.debug('remove: %s', abbrevIK(key));
-        if (isPriKey(key)) {
-            logger.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
-            item = await model.findByPk(key.pk);
-        } else if (isComKey(key)) {
-            // This is a composite key, so we need to build a where clause based on the composite key's locators
-            const comKey = key;
-            const queryOptions = processCompositeKey(comKey, model, kta);
-            logger.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
-            logger.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-            item = await model.findOne(queryOptions);
-        }
-        if (!item) {
-            throw new Error(`Item not found for removal with key: ${abbrevIK(key)}`);
-        }
-        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
-            logger.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
-            await (item === null || item === void 0 ? void 0 : item.save());
-            returnItem = item === null || item === void 0 ? void 0 : item.get({
-                plain: true
-            });
-            returnItem = addKey(item, returnItem, kta);
-            returnItem = populateEvents(returnItem);
-        } else if (options.deleteOnRemove) {
-            logger.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
-            await (item === null || item === void 0 ? void 0 : item.destroy());
-            returnItem = item === null || item === void 0 ? void 0 : item.get({
-                plain: true
-            });
-            returnItem = addKey(item, returnItem, kta);
-            returnItem = populateEvents(returnItem);
-        } else {
-            throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
-        }
-        logger.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
-        return returnItem;
-    };
-    return remove;
-};
-
-export { getRemoveOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/ops/update.js

@@ -1,116 +0,0 @@
-import { isPriKey, abbrevIK, isComKey, validateKeys } from '@fjell/core';
-import { extractEvents, removeEvents } from '../EventCoordinator.js';
-import { removeKey } from '../KeyMaster.js';
-import LibLogger from '../logger.js';
-import { processRow } from '../RowProcessor.js';
-import { NotFoundError } from '@fjell/lib';
-import { Op } from 'sequelize';
-import { buildRelationshipPath } from '../util/relationshipUtils.js';
-import { stringifyJSON } from '../util/general.js';
-
-const logger = LibLogger.get('sequelize', 'ops', 'update');
-// Helper function to merge includes avoiding duplicates
-const mergeIncludes = (existingIncludes, newIncludes)=>{
-    const mergedIncludes = [
-        ...existingIncludes
-    ];
-    for (const newInclude of newIncludes){
-        const existingIndex = mergedIncludes.findIndex((existing)=>existing.as === newInclude.as && existing.model === newInclude.model);
-        if (existingIndex === -1) {
-            mergedIncludes.push(newInclude);
-        } else if (newInclude.include && mergedIncludes[existingIndex].include) {
-            mergedIncludes[existingIndex].include = [
-                ...mergedIncludes[existingIndex].include,
-                ...newInclude.include
-            ];
-        } else if (newInclude.include) {
-            mergedIncludes[existingIndex].include = newInclude.include;
-        }
-    }
-    return mergedIncludes;
-};
-const getUpdateOperation = (models, definition, registry)=>{
-    const { options: { references, aggregations } } = definition;
-    const update = async (key, item)=>{
-        logger.debug(`UPDATE operation called on ${models[0].name} with ${isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
-        const { coordinate } = definition;
-        const { kta } = coordinate;
-        logger.debug('update: %s, %j', abbrevIK(key), item);
-        // Find the object we're updating
-        // @ts-ignore
-        const model = models[0];
-        let response;
-        if (isPriKey(key)) {
-            // Find the model by using the PK
-            const priKey = key;
-            logger.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
-            response = await model.findByPk(priKey.pk);
-        } else if (isComKey(key)) {
-            const comKey = key;
-            // Build query options for composite key with multiple location keys
-            const where = {
-                id: comKey.pk
-            };
-            const additionalIncludes = [];
-            // Process all location keys in the composite key
-            for (const locator of comKey.loc){
-                const relationshipInfo = buildRelationshipPath(model, locator.kt, kta, true);
-                if (!relationshipInfo.found) {
-                    const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-                    logger.error(errorMessage, {
-                        key: comKey,
-                        kta
-                    });
-                    throw new Error(errorMessage);
-                }
-                if (relationshipInfo.isDirect) {
-                    // Direct foreign key field
-                    const fieldName = `${locator.kt}Id`;
-                    where[fieldName] = locator.lk;
-                } else if (relationshipInfo.path) {
-                    // Hierarchical relationship requiring traversal
-                    where[relationshipInfo.path] = {
-                        [Op.eq]: locator.lk
-                    };
-                    // Add necessary includes for relationship traversal
-                    if (relationshipInfo.includes) {
-                        additionalIncludes.push(...relationshipInfo.includes);
-                    }
-                }
-            }
-            // Build final query options
-            const queryOptions = {
-                where
-            };
-            if (additionalIncludes.length > 0) {
-                queryOptions.include = mergeIncludes([], additionalIncludes);
-            }
-            logger.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
-            logger.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-            response = await model.findOne(queryOptions);
-        }
-        if (response) {
-            // Remove the key and events
-            let updateProps = removeKey(item);
-            // TODO: We need the opposite of processRow, something to step down from fjell to database.
-            updateProps = extractEvents(updateProps);
-            updateProps = removeEvents(updateProps);
-            logger.default(`Update found ${model.name} record to modify`);
-            logger.default(`Update properties configured: ${Object.keys(updateProps).join(', ')}`);
-            // Update the object
-            logger.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
-            response = await response.update(updateProps);
-            // Populate the key and events
-            const processedItem = await processRow(response, kta, references, aggregations, registry);
-            const returnItem = validateKeys(processedItem, kta);
-            logger.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
-            return returnItem;
-        } else {
-            throw new NotFoundError('update', coordinate, key);
-        }
-    };
-    return update;
-};
-
-export { getUpdateOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/primary/SequelizeLibrary.js

@@ -1,36 +0,0 @@
-import { Primary } from '@fjell/lib';
-import { createOperations } from '../Operations.js';
-import { createOptions } from '../Options.js';
-import { createCoordinate } from '../Coordinate.js';
-import LibLogger from '../logger.js';
-
-const logger = LibLogger.get('lib-sequelize', 'primary', 'instance');
-function createSequelizeLibrary(keyType, models, libOptions = {}, scopes = [], registry) {
-    logger.debug('createSequelizeLibrary', {
-        keyType,
-        models,
-        libOptions,
-        scopes
-    });
-    // Create coordinate and options separately following new pattern
-    const coordinate = createCoordinate([
-        keyType
-    ], scopes);
-    const options = createOptions(libOptions);
-    // Create operations with the new signature
-    const operations = createOperations(models, coordinate, registry, options);
-    // Wrap operations for primary pattern
-    const wrappedOperations = Primary.wrapOperations(operations, options, coordinate, registry);
-    return {
-        coordinate,
-        registry,
-        operations: wrappedOperations,
-        options,
-        models
-    };
-}
-// Legacy exports for backwards compatibility
-const createInstance = createSequelizeLibrary;
-
-export { createInstance, createSequelizeLibrary };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/primary/index.js

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

package/dist/es/util/general.js

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

package/dist/es/util/relationshipUtils.js

@@ -1,112 +0,0 @@
-/* eslint-disable indent */ /**
- * Helper function to build relationship chain includes
- */ const buildRelationshipChain = (targetModel, kta, currentIndex, targetIndex)=>{
-    // Build the association path and validate relationships exist
-    const associationParts = [];
-    const modelChain = [
-        targetModel
-    ];
-    let currentModel = targetModel;
-    // Validate that all associations exist and build model chain
-    for(let i = currentIndex + 1; i <= targetIndex; i++){
-        const intermediateType = kta[i];
-        const associationName = intermediateType;
-        if (!currentModel.associations || !currentModel.associations[associationName]) {
-            return {
-                success: false
-            };
-        }
-        associationParts.push(associationName);
-        currentModel = currentModel.associations[associationName].target;
-        modelChain.push(currentModel);
-    }
-    // Build the full association path for the target field
-    const targetPrimaryKey = currentModel.primaryKeyAttribute || 'id';
-    const associationPath = `$${associationParts.join('.')}.${targetPrimaryKey}$`;
-    // Build nested includes structure iteratively (clearer than recursion)
-    let deepestInclude = null;
-    // Build from the deepest level back to the root
-    for(let i = targetIndex; i > currentIndex; i--){
-        const currentType = kta[i];
-        const modelIndex = i - currentIndex;
-        const includeObj = {
-            model: modelChain[modelIndex],
-            as: currentType,
-            required: true
-        };
-        if (deepestInclude) {
-            includeObj.include = [
-                deepestInclude
-            ];
-        }
-        deepestInclude = includeObj;
-    }
-    const includes = deepestInclude ? [
-        deepestInclude
-    ] : [];
-    return {
-        success: true,
-        path: associationPath,
-        includes
-    };
-};
-/**
- * Helper function to build relationship path for a locator
- * @param includeIsDirect Whether to include the isDirect flag in the result
- */ const buildRelationshipPath = (targetModel, locatorType, kta, includeIsDirect = false)=>{
-    // First check if the field exists directly
-    const directFieldName = `${locatorType}Id`;
-    const attributes = targetModel.getAttributes();
-    if (attributes && attributes[directFieldName]) {
-        const result = {
-            found: true
-        };
-        if (includeIsDirect) {
-            result.isDirect = true;
-        }
-        return result;
-    }
-    // If not direct, look for relationship path
-    const targetIndex = kta.indexOf(locatorType);
-    if (targetIndex === -1) {
-        const result = {
-            found: false
-        };
-        if (includeIsDirect) {
-            result.isDirect = false;
-        }
-        return result;
-    }
-    const currentIndex = 0; // We're always looking from the base model
-    if (targetIndex <= currentIndex) {
-        const result = {
-            found: false
-        };
-        if (includeIsDirect) {
-            result.isDirect = false;
-        }
-        return result;
-    }
-    const chainResult = buildRelationshipChain(targetModel, kta, currentIndex, targetIndex);
-    if (chainResult.success) {
-        const result = {
-            found: true,
-            path: chainResult.path,
-            includes: chainResult.includes
-        };
-        if (includeIsDirect) {
-            result.isDirect = false;
-        }
-        return result;
-    }
-    const result = {
-        found: false
-    };
-    if (includeIsDirect) {
-        result.isDirect = false;
-    }
-    return result;
-};
-
-export { buildRelationshipChain, buildRelationshipPath };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsYXRpb25zaGlwVXRpbHMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9