@fjell/lib-sequelize 4.4.14 → 4.4.16

package/dist/cjs/QueryBuilder.cjs

@@ -1,296 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const core = require('@fjell/core');
-const sequelize = require('sequelize');
-const logger$1 = require('./logger.cjs');
-const general = require('./util/general.cjs');
-
-const logger = logger$1.default.get('sequelize', 'QueryBuilder');
-const addDeleteQuery = (options, model)=>{
-    logger.default(`QueryBuilder adding delete query with options: ${general.stringifyJSON(options)}`);
-    if (model.getAttributes().deletedAt) {
-        options.where['deletedAt'] = {
-            [sequelize.Op.eq]: null
-        };
-    } else if (model.getAttributes().isDeleted) {
-        options.where['isDeleted'] = {
-            [sequelize.Op.eq]: false
-        };
-    }
-    return options;
-};
-const addEventQueries = (options, events, model)=>{
-    logger.default(`QueryBuilder adding event queries with options: ${general.stringifyJSON(options)}, events: ${general.stringifyJSON(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,
-                [sequelize.Op.gte]: new Date(event.start)
-            };
-        }
-        if (event.end) {
-            whereClauses = {
-                ...whereClauses,
-                [sequelize.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,
-                [sequelize.Op.eq]: event.by
-            };
-        }
-        options.where[`${key}At`] = whereClauses;
-    });
-    return options;
-};
-// Add the references to the query
-const addReferenceQueries = (options, references, model)=>{
-    logger.default(`QueryBuilder adding reference queries with options: ${general.stringifyJSON(options)}, references: ${general.stringifyJSON(references)}`);
-    Object.keys(references).forEach((key)=>{
-        logger.default(`QueryBuilder adding reference query for key: ${key}, references: ${general.stringifyJSON(references)}`);
-        if (!model.getAttributes()[`${key}Id`]) {
-            throw new Error(`Reference ${key} is not supported on this model, column ${key}Id not found`);
-        }
-        if (core.isPriKey(references[key])) {
-            const priKey = references[key];
-            if (priKey.pk == null || priKey.pk === '' || typeof priKey.pk === 'object' && Object.keys(priKey.pk).length === 0) {
-                logger.error(`Reference key '${key}' has invalid pk value: ${general.stringifyJSON(priKey.pk)}`, {
-                    priKey,
-                    references
-                });
-                throw new Error(`Reference key '${key}' has invalid pk value: ${general.stringifyJSON(priKey.pk)}`);
-            }
-            logger.trace(`[QueryBuilder] Setting reference where clause: ${key}Id = ${general.stringifyJSON(priKey.pk)} (type: ${typeof priKey.pk})`);
-            options.where[`${key}Id`] = {
-                [sequelize.Op.eq]: priKey.pk
-            };
-        } else if (core.isComKey(references[key])) {
-            throw new Error('ComKeys are not supported in Sequelize');
-        }
-    });
-    return options;
-};
-const addCompoundCondition = (options, compoundCondition, model)=>{
-    // Ensure options.where exists
-    options.where = options.where || {};
-    let compoundOp;
-    const compoundType = compoundCondition.compoundType;
-    if (compoundType === "AND") {
-        compoundOp = sequelize.Op.and;
-    } else {
-        compoundOp = sequelize.Op.or;
-    }
-    let conditions = {};
-    compoundCondition.conditions.forEach((condition)=>{
-        if (core.isCondition(condition)) {
-            conditions = addCondition(conditions, condition, model);
-        } else {
-            throw new Error('Nest Compound conditions not supported');
-        }
-    });
-    // Merge with existing where conditions instead of replacing
-    if (Object.keys(options.where).length > 0) {
-        // If there are existing conditions, wrap everything in an AND
-        options.where = {
-            [sequelize.Op.and]: [
-                options.where,
-                {
-                    [compoundOp]: conditions
-                }
-            ]
-        };
-    } else {
-        // If no existing conditions, just set the compound condition
-        options.where[compoundOp] = conditions;
-    }
-    return options;
-};
-const getSequelizeOperator = (operator)=>{
-    if (operator === '==') {
-        return sequelize.Op.eq;
-    } else if (operator === '<') {
-        return sequelize.Op.lt;
-    } else if (operator === '>') {
-        return sequelize.Op.gt;
-    } else if (operator === '<=') {
-        return sequelize.Op.lte;
-    } else if (operator === '>=') {
-        return sequelize.Op.gte;
-    } else if (operator === 'in') {
-        return sequelize.Op.in;
-    } else {
-        throw new Error(`Operator ${operator} not supported`);
-    }
-};
-const addAssociationCondition = (conditions, condition, model)=>{
-    const [associationName, attributeName] = condition.column.split('.', 2);
-    // Check if the association exists on the model
-    if (!model.associations || !model.associations[associationName]) {
-        throw new Error(`Association ${associationName} not found on model ${model.name}`);
-    }
-    const association = model.associations[associationName];
-    const associatedModel = association.target;
-    // Check if the attribute exists on the associated model
-    if (!associatedModel.getAttributes()[attributeName]) {
-        throw new Error(`Attribute ${attributeName} not found on associated model ${associatedModel.name} for association ${associationName}`);
-    }
-    // Use Sequelize's $association.attribute$ syntax for querying associated models
-    const sequelizeAssociationColumn = `$${associationName}.${attributeName}$`;
-    const conditionOp = getSequelizeOperator(condition.operator);
-    if (condition.value == null && condition.operator !== '==' && condition.operator !== 'in') {
-        logger.error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`, {
-            condition
-        });
-        throw new Error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`);
-    }
-    logger.trace(`[QueryBuilder] Setting association condition: ${sequelizeAssociationColumn} = ${general.stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
-    conditions[sequelizeAssociationColumn] = {
-        [conditionOp]: condition.value
-    };
-    return conditions;
-};
-const addAttributeCondition = (conditions, condition, model)=>{
-    const conditionColumn = condition.column;
-    if (!model.getAttributes()[conditionColumn]) {
-        throw new Error(`Condition column ${conditionColumn} not found on model ${model.name}`);
-    }
-    const conditionOp = getSequelizeOperator(condition.operator);
-    if (condition.value == null && condition.operator !== '==' && condition.operator !== 'in') {
-        logger.error(`Attribute condition for '${conditionColumn}' has undefined/null value`, {
-            condition
-        });
-        throw new Error(`Attribute condition for '${conditionColumn}' has undefined/null value`);
-    }
-    logger.trace(`[QueryBuilder] Setting attribute condition: ${conditionColumn} = ${general.stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
-    conditions[conditionColumn] = {
-        [conditionOp]: condition.value
-    };
-    return conditions;
-};
-const addCondition = (conditions, condition, model)=>{
-    const conditionColumn = condition.column;
-    // Check if this is an association query (contains a dot)
-    if (conditionColumn.includes('.')) {
-        return addAssociationCondition(conditions, condition, model);
-    }
-    // Handle regular column queries
-    return addAttributeCondition(conditions, condition, model);
-};
-const collectAssociationsFromConditions = (conditions)=>{
-    const associations = new Set();
-    const processObject = (obj)=>{
-        if (typeof obj === 'object' && obj !== null) {
-            // Check string keys
-            Object.keys(obj).forEach((key)=>{
-                // Check if this is an association reference ($association.attribute$)
-                if (typeof key === 'string' && key.startsWith('$') && key.endsWith('$') && key.includes('.')) {
-                    const associationName = key.substring(1, key.indexOf('.'));
-                    associations.add(associationName);
-                }
-                // Recursively process nested objects
-                if (typeof obj[key] === 'object') {
-                    processObject(obj[key]);
-                }
-            });
-            // Also check Symbol keys (for compound conditions like Op.and, Op.or)
-            Object.getOwnPropertySymbols(obj).forEach((symbol)=>{
-                if (typeof obj[symbol] === 'object') {
-                    processObject(obj[symbol]);
-                }
-            });
-        }
-        // Handle arrays (for compound conditions that might be arrays)
-        if (Array.isArray(obj)) {
-            obj.forEach((item)=>{
-                if (typeof item === 'object') {
-                    processObject(item);
-                }
-            });
-        }
-    };
-    processObject(conditions);
-    return associations;
-};
-const addAssociationIncludes = (options, model)=>{
-    // Collect all association names used in conditions
-    const referencedAssociations = collectAssociationsFromConditions(options.where);
-    if (referencedAssociations.size > 0) {
-        options.include = options.include || [];
-        // Add each referenced association to the include array
-        referencedAssociations.forEach((associationName)=>{
-            // Check if this association is already included
-            const alreadyIncluded = options.include.some((inc)=>typeof inc === 'string' && inc === associationName || typeof inc === 'object' && inc.association === associationName);
-            if (!alreadyIncluded && model.associations && model.associations[associationName]) {
-                options.include.push({
-                    model: model.associations[associationName].target,
-                    as: associationName,
-                    required: false // Use LEFT JOIN so records without associations are still returned
-                });
-            }
-        });
-    }
-    return options;
-};
-const buildQuery = (itemQuery, model)=>{
-    logger.default(`QueryBuilder build called with itemQuery: ${general.stringifyJSON(itemQuery)}`);
-    let options = {
-        where: {}
-    };
-    if (itemQuery.compoundCondition) {
-        logger.default(`QueryBuilder adding conditions: ${general.stringifyJSON(itemQuery.compoundCondition)}`);
-        options = addCompoundCondition(options, itemQuery.compoundCondition, model);
-    }
-    // If the model has a deletedAt column, we need to add a delete query
-    if (model.getAttributes().deletedAt || model.getAttributes().isDeleted) {
-        options = addDeleteQuery(options, model);
-    }
-    if (itemQuery.refs) {
-        options = addReferenceQueries(options, itemQuery.refs, model);
-    }
-    if (itemQuery.events) {
-        options = addEventQueries(options, itemQuery.events, 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(`QueryBuilder applying limit: ${itemQuery.limit}`);
-        options.limit = itemQuery.limit;
-    }
-    // Apply an offset to the result set
-    if (itemQuery.offset) {
-        options.offset = itemQuery.offset;
-    }
-    // Add orderBy to the query
-    if (itemQuery.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
-                ]
-            ];
-        });
-    }
-    // Add includes for any associations referenced in conditions
-    options = addAssociationIncludes(options, model);
-    return options;
-};
-
-exports.addCompoundCondition = addCompoundCondition;
-exports.addCondition = addCondition;
-exports.buildQuery = buildQuery;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/ReferenceBuilder.cjs

@@ -1,76 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const logger$1 = require('./logger.cjs');
-
-const logger = logger$1.default.get('sequelize', 'ReferenceBuilder');
-const buildReference = async (item, referenceDefinition, registry, context)=>{
-    // 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");
-    }
-    // Check if the column value is null - if so, skip the reference
-    const columnValue = item[referenceDefinition.column];
-    if (columnValue == null) {
-        item[referenceDefinition.property] = null;
-        return item;
-    }
-    // Create a PriKey using the column value from item
-    const priKey = {
-        kt: referenceDefinition.kta[0],
-        pk: columnValue
-    };
-    let referencedItem;
-    if (context) {
-        // Check if we already have this item cached
-        if (context.isCached(priKey)) {
-            logger.default('Using cached reference', {
-                priKey,
-                property: referenceDefinition.property
-            });
-            referencedItem = context.getCached(priKey);
-        } else if (context.isInProgress(priKey)) {
-            logger.default('Circular dependency detected, creating reference placeholder', {
-                priKey,
-                property: referenceDefinition.property
-            });
-            // Create a minimal reference object with just the key to break the cycle
-            referencedItem = {
-                key: priKey
-            };
-        } else {
-            // Mark this key as in progress before loading
-            context.markInProgress(priKey);
-            try {
-                // Get the referenced item using the Library.Operations get method (context now managed internally)
-                referencedItem = await library.operations.get(priKey);
-                // Cache the result
-                context.setCached(priKey, referencedItem);
-            } finally{
-                // Always mark as complete, even if there was an error
-                context.markComplete(priKey);
-            }
-        }
-    } else {
-        // Fallback to original behavior if no context provided
-        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;
-};
-
-exports.buildReference = buildReference;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/RowProcessor.cjs

@@ -1,56 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const logger$1 = require('./logger.cjs');
-const KeyMaster = require('./KeyMaster.cjs');
-const ReferenceBuilder = require('./ReferenceBuilder.cjs');
-const AggregationBuilder = require('./AggregationBuilder.cjs');
-const general = require('./util/general.cjs');
-const EventCoordinator = require('./EventCoordinator.cjs');
-const OperationContext = require('./OperationContext.cjs');
-
-const logger = logger$1.default.get('sequelize', 'RowProcessor');
-const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context)=>{
-    logger.default('Processing Row', {
-        row
-    });
-    // Use provided context or create new one
-    const operationContext = context || OperationContext.createOperationContext();
-    // Process the row within the context to ensure all operations share the same context
-    return OperationContext.contextManager.withContext(operationContext, async ()=>{
-        let item = row.get({
-            plain: true
-        });
-        logger.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
-        item = KeyMaster.addKey(row, item, keyTypes);
-        item = EventCoordinator.populateEvents(item);
-        logger.default('Key Added to Item: %s', general.stringifyJSON(item.key));
-        // Mark this item as in progress to detect circular references
-        operationContext.markInProgress(item.key);
-        try {
-            if (referenceDefinitions && referenceDefinitions.length > 0) {
-                for (const referenceDefinition of referenceDefinitions){
-                    logger.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
-                    item = await ReferenceBuilder.buildReference(item, referenceDefinition, registry, operationContext);
-                }
-            }
-            if (aggregationDefinitions && aggregationDefinitions.length > 0) {
-                for (const aggregationDefinition of aggregationDefinitions){
-                    logger.default('Processing Aggregation for %s from %s', item.key.kt, general.stringifyJSON(aggregationDefinition.kta));
-                    item = await AggregationBuilder.buildAggregation(item, aggregationDefinition, registry, operationContext);
-                }
-            }
-            // Cache the fully processed item
-            operationContext.setCached(item.key, item);
-        } finally{
-            // Mark this item as complete
-            operationContext.markComplete(item.key);
-        }
-        logger.default('Processed Row: %j', general.stringifyJSON(item));
-        return item;
-    });
-};
-
-exports.processRow = processRow;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/SequelizeLibrary.cjs

@@ -1,56 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Library = require('@fjell/lib');
-const Operations = require('./Operations.cjs');
-const logger$1 = require('./logger.cjs');
-
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
-  if (e) {
-    for (const k in e) {
-      if (k !== 'default') {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-const Library__namespace = /*#__PURE__*/_interopNamespaceDefault(Library);
-
-const logger = logger$1.default.get("SequelizeLibrary");
-/**
- * Creates a new SequelizeLibrary that extends the fjell-lib Library
- * with Sequelize-specific functionality
- */ const createSequelizeLibrary = (registry, coordinate, models, options)=>{
-    logger.debug("createSequelizeLibrary", {
-        coordinate,
-        models,
-        registry,
-        options
-    });
-    // Create Sequelize-specific operations
-    const operations = Operations.createOperations(models, coordinate, registry, options);
-    // Create the base fjell-lib library
-    const libLibrary = Library__namespace.createLibrary(registry, coordinate, operations, options);
-    return {
-        ...libLibrary,
-        models
-    };
-};
-/**
- * Type guard to check if an object is a SequelizeLibrary
- */ const isSequelizeLibrary = (library)=>{
-    return library != null && library.coordinate != null && library.operations != null && library.options != null && library.registry != null && library.models != null && Array.isArray(library.models);
-};
-
-exports.createSequelizeLibrary = createSequelizeLibrary;
-exports.isSequelizeLibrary = isSequelizeLibrary;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/SequelizeLibraryFactory.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const SequelizeLibrary = require('./SequelizeLibrary.cjs');
-const logger$1 = require('./logger.cjs');
-
-const logger = logger$1.default.get("InstanceFactory");
-/**
- * Factory function for creating Sequelize libraries
- * This extends the fjell-lib pattern by adding Sequelize-specific models
- */ const createSequelizeLibraryFactory = (models, options)=>{
-    return (coordinate, context)=>{
-        logger.debug("Creating Sequelize instance", {
-            coordinate,
-            registry: context.registry,
-            models: models.map((m)=>m.name),
-            options
-        });
-        return SequelizeLibrary.createSequelizeLibrary(context.registry, coordinate, models, options);
-    };
-};
-
-exports.createSequelizeLibraryFactory = createSequelizeLibraryFactory;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeUZhY3RvcnkuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/contained/SequelizeLibrary.cjs

@@ -1,31 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Library = require('@fjell/lib');
-const Operations = require('../Operations.cjs');
-const Options = require('../Options.cjs');
-const Coordinate = require('../Coordinate.cjs');
-
-function createSequelizeLibrary(keyTypes, models, libOptions = {}, scopes = [], registry) {
-    // Create coordinate and options separately following new pattern
-    const coordinate = Coordinate.createCoordinate(keyTypes, scopes);
-    const options = Options.createOptions(libOptions);
-    // Create operations with the new signature
-    const operations = Operations.createOperations(models, coordinate, registry, options);
-    // Wrap operations for contained pattern
-    const wrappedOperations = Library.Contained.wrapOperations(operations, options, coordinate, registry);
-    return {
-        coordinate,
-        registry,
-        operations: wrappedOperations,
-        options,
-        models
-    };
-}
-// Legacy exports for backwards compatibility
-const createInstance = createSequelizeLibrary;
-
-exports.createInstance = createInstance;
-exports.createSequelizeLibrary = createSequelizeLibrary;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/contained/index.cjs

@@ -1,11 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const SequelizeLibrary = require('./SequelizeLibrary.cjs');
-
-
-
-exports.createInstance = SequelizeLibrary.createInstance;
-exports.createSequelizeLibrary = SequelizeLibrary.createSequelizeLibrary;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OyJ9

package/dist/cjs/index.cjs

@@ -1,26 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Definition = require('./Definition.cjs');
-const SequelizeLibrary = require('./SequelizeLibrary.cjs');
-const SequelizeLibraryFactory = require('./SequelizeLibraryFactory.cjs');
-const Options = require('./Options.cjs');
-const Operations = require('./Operations.cjs');
-const index = require('./contained/index.cjs');
-const index$1 = require('./primary/index.cjs');
-const Coordinate = require('./Coordinate.cjs');
-
-
-
-exports.createDefinition = Definition.createDefinition;
-exports.createSequelizeLibrary = SequelizeLibrary.createSequelizeLibrary;
-exports.isSequelizeLibrary = SequelizeLibrary.isSequelizeLibrary;
-exports.createSequelizeLibraryFactory = SequelizeLibraryFactory.createSequelizeLibraryFactory;
-exports.createOptions = Options.createOptions;
-exports.createOperations = Operations.createOperations;
-exports.Contained = index;
-exports.Primary = index$1;
-exports.SCOPE_SEQUELIZE = Coordinate.SCOPE_SEQUELIZE;
-exports.createCoordinate = Coordinate.createCoordinate;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/logger.cjs

@@ -1,10 +0,0 @@
-'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=