@fjell/lib-sequelize 4.4.11 → 4.4.12

package/README.md

@@ -0,0 +1,266 @@
+# @fjell/lib-sequelize
+
+Sequelize integration for the Fjell ecosystem providing database-specific implementations for relational databases.
+
+## New Architecture (v4.4.12+)
+
+This library now uses the new **SequelizeLibrary** architecture that extends `@fjell/lib`:
+
+```
+fjell-registry.Instance
+  ↓ extends
+fjell-lib.Library
+  ↓ extends
+fjell-lib-sequelize.SequelizeLibrary
+```
+
+## Installation
+
+```bash
+npm install @fjell/lib-sequelize @fjell/lib @fjell/registry sequelize
+```
+
+## Quick Start
+
+### New SequelizeLibrary API (v4.4.12+)
+
+```typescript
+import { createRegistry } from '@fjell/registry';
+import { createSequelizeLibrary, SequelizeLibrary } from '@fjell/lib-sequelize';
+import { User } from './models/User'; // Your Sequelize model
+
+// Create a SequelizeLibrary
+const userLibrary: SequelizeLibrary<UserItem, 'user'> = createSequelizeLibrary(
+  registry,
+  { keyType: 'user' },
+  [User], // Sequelize models
+  {
+    validators: {
+      email: (email) => email.includes('@')
+    },
+    hooks: {
+      beforeCreate: async (user) => {
+        user.createdAt = new Date();
+        return user;
+      }
+    }
+  }
+);
+
+// Use the library
+const users = await userLibrary.operations.all({});
+const newUser = await userLibrary.operations.create({
+  name: 'Alice Johnson',
+  email: 'alice@example.com'
+});
+
+// Access Sequelize-specific features
+console.log('Available models:', userLibrary.models.map(m => m.name));
+```
+
+
+
+## Features
+
+### SequelizeLibrary Extends Library
+
+The `SequelizeLibrary` interface adds:
+- **models**: Array of Sequelize model classes
+- **All Library features**: operations, options, coordinate, registry
+
+```typescript
+interface SequelizeLibrary<T, S> extends Library<T, S> {
+  models: ModelStatic<any>[];
+}
+```
+
+### Database Operations
+
+Built-in operations automatically use your Sequelize models:
+
+```typescript
+// CRUD operations use Sequelize under the hood
+await userLibrary.operations.create(userData);
+await userLibrary.operations.find({ filter: { email: 'alice@example.com' } });
+await userLibrary.operations.update(['user-123'], { name: 'Alice Smith' });
+await userLibrary.operations.remove(['user-123']);
+
+// Advanced queries
+await userLibrary.operations.all({
+  filter: { status: 'active' },
+  sort: { createdAt: -1 },
+  limit: 10
+});
+```
+
+### Model Integration
+
+Your Sequelize models are automatically integrated:
+
+```typescript
+// Define your Sequelize model
+const User = sequelize.define('User', {
+  id: { type: DataTypes.UUID, primaryKey: true },
+  name: { type: DataTypes.STRING, allowNull: false },
+  email: { type: DataTypes.STRING, unique: true }
+});
+
+// Create SequelizeLibrary with the model
+const userLibrary = createSequelizeLibrary(
+  registry,
+  { keyType: 'user' },
+  [User], // Pass your models here
+  options
+);
+
+// Operations automatically use the User model
+const users = await userLibrary.operations.all({}); // SELECT * FROM users
+```
+
+## Advanced Usage
+
+### Multiple Models
+
+```typescript
+import { User, UserProfile, UserSettings } from './models';
+
+const userLibrary = createSequelizeLibrary(
+  registry,
+  { keyType: 'user' },
+  [User, UserProfile, UserSettings], // Multiple related models
+  {
+    hooks: {
+      afterCreate: async (user) => {
+        // Automatically create profile and settings
+        await UserProfile.create({ userId: user.id });
+        await UserSettings.create({ userId: user.id });
+      }
+    }
+  }
+);
+```
+
+### Custom Operations
+
+```typescript
+import { createOperations } from '@fjell/lib-sequelize';
+
+const customOperations = createOperations([User], coordinate, registry, {
+  // Custom business logic
+  actions: {
+    activate: async (keys, params) => {
+      const user = await User.findByPk(keys[0]);
+      user.status = 'active';
+      user.activatedAt = new Date();
+      await user.save();
+      return { success: true };
+    }
+  },
+
+  // Custom analytics
+  facets: {
+    userStats: async (query, options) => {
+      const users = await User.findAll();
+      return {
+        total: users.length,
+        active: users.filter(u => u.status === 'active').length,
+        byRegion: groupBy(users, 'region')
+      };
+    }
+  }
+});
+```
+
+### Hierarchical Data
+
+Support for contained items with location hierarchies:
+
+```typescript
+// Department library with location hierarchy
+const deptLibrary = createSequelizeLibrary(
+  registry,
+  { keyType: 'department' },
+  [Department],
+  options
+);
+
+// Query departments by location
+const usDepartments = await deptLibrary.operations.all({}, ['us', 'usa']);
+const westCoastDepts = await deptLibrary.operations.all({}, ['us', 'west']);
+```
+
+## Migration Guide
+
+### From v4.4.11 and earlier
+
+1. **No breaking changes** - existing code continues to work
+2. **Optional migration** to new naming:
+
+```typescript
+// Clean Library architecture
+import { createSequelizeLibrary, SequelizeLibrary } from '@fjell/lib-sequelize';
+```
+
+3. **Benefits of the new architecture**:
+   - Clear naming that shows inheritance hierarchy
+   - Better TypeScript autocomplete and documentation
+   - Future-proof as the ecosystem evolves
+
+### Simple Setup
+
+Use the SequelizeLibrary for all new development:
+
+```typescript
+// Clean, consistent API
+const userLibrary = createSequelizeLibrary(registry, coordinate, models, options);
+const orderLibrary = createSequelizeLibrary(registry, orderCoordinate, orderModels, orderOptions);
+```
+
+## Architecture Benefits
+
+1. **Clear Inheritance**: Shows how SequelizeLibrary extends Library
+2. **Type Safety**: Full TypeScript support throughout the hierarchy
+3. **Database Focus**: SequelizeLibrary is clearly Sequelize-specific
+4. **Extensibility**: Easy to add new database-specific libraries
+5. **Clean API**: Consistent naming and patterns across all libraries
+
+## Examples
+
+See the `examples/` directory for complete working examples:
+- Basic Sequelize integration
+- Advanced business logic
+- Multi-model applications
+- Location-based data organization
+
+## TypeScript Support
+
+Full TypeScript support with proper type inference:
+
+```typescript
+import { Item } from '@fjell/core';
+
+interface User extends Item<'user'> {
+  id: string;
+  name: string;
+  email: string;
+}
+
+const userLibrary: SequelizeLibrary<User, 'user'> = createSequelizeLibrary(
+  registry,
+  { keyType: 'user' },
+  [UserModel],
+  options
+);
+
+// Full type safety
+const user: User = await userLibrary.operations.create({
+  name: 'Alice',
+  email: 'alice@example.com'
+});
+```
+
+## Next Steps
+
+- Check out `@fjell/lib-firestore` for Firestore integration
+- See `@fjell/lib` for core Library functionality
+- Read `@fjell/registry` for base coordination features

package/dist/cjs/{Instance.cjs → SequelizeLibrary.cjs}

@@ -25,12 +25,12 @@ function _interopNamespaceDefault(e) {
 
 const Library__namespace = /*#__PURE__*/_interopNamespaceDefault(Library);
 
-const logger = logger$1.default.get("Instance");
+const logger = logger$1.default.get("SequelizeLibrary");
 /**
- * Creates a new Sequelize instance that extends the fjell-lib instance
+ * Creates a new SequelizeLibrary that extends the fjell-lib Library
  * with Sequelize-specific functionality
- */ const createInstance = (registry, coordinate, models, options)=>{
-    logger.debug("createInstance", {
+ */ const createSequelizeLibrary = (registry, coordinate, models, options)=>{
+    logger.debug("createSequelizeLibrary", {
         coordinate,
         models,
         registry,
@@ -38,19 +38,19 @@ const logger = logger$1.default.get("Instance");
     });
     // Create Sequelize-specific operations
     const operations = Operations.createOperations(models, coordinate, registry, options);
-    // Create the base fjell-lib instance
-    const libInstance = Library__namespace.createInstance(registry, coordinate, operations, options);
+    // Create the base fjell-lib library
+    const libLibrary = Library__namespace.createLibrary(registry, coordinate, operations, options);
     return {
-        ...libInstance,
+        ...libLibrary,
         models
     };
 };
 /**
- * Type guard to check if an object is a Sequelize Instance
- */ const isInstance = (instance)=>{
-    return instance != null && instance.coordinate != null && instance.operations != null && instance.options != null && instance.registry != null && instance.models != null && Array.isArray(instance.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.createInstance = createInstance;
-exports.isInstance = isInstance;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+exports.createSequelizeLibrary = createSequelizeLibrary;
+exports.isSequelizeLibrary = isSequelizeLibrary;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/{InstanceFactory.cjs → SequelizeLibraryFactory.cjs}

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

package/dist/cjs/contained/{Instance.cjs → SequelizeLibrary.cjs}

@@ -7,7 +7,7 @@ const Operations = require('../Operations.cjs');
 const Options = require('../Options.cjs');
 const Coordinate = require('../Coordinate.cjs');
 
-function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry) {
+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);
@@ -23,6 +23,9 @@ function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry
         models
     };
 }
+// Legacy exports for backwards compatibility
+const createInstance = createSequelizeLibrary;
 
 exports.createInstance = createInstance;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+exports.createSequelizeLibrary = createSequelizeLibrary;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/contained/index.cjs

@@ -2,9 +2,10 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const Instance = require('./Instance.cjs');
+const SequelizeLibrary = require('./SequelizeLibrary.cjs');
 
 
 
-exports.createInstance = Instance.createInstance;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7In0=
+exports.createInstance = SequelizeLibrary.createInstance;
+exports.createSequelizeLibrary = SequelizeLibrary.createSequelizeLibrary;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OyJ9

package/dist/cjs/index.cjs

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const Definition = require('./Definition.cjs');
-const Instance = require('./Instance.cjs');
-const InstanceFactory = require('./InstanceFactory.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');
@@ -14,9 +14,9 @@ const Coordinate = require('./Coordinate.cjs');
 
 
 exports.createDefinition = Definition.createDefinition;
-exports.createInstance = Instance.createInstance;
-exports.isInstance = Instance.isInstance;
-exports.createInstanceFactory = InstanceFactory.createInstanceFactory;
+exports.createSequelizeLibrary = SequelizeLibrary.createSequelizeLibrary;
+exports.isSequelizeLibrary = SequelizeLibrary.isSequelizeLibrary;
+exports.createSequelizeLibraryFactory = SequelizeLibraryFactory.createSequelizeLibraryFactory;
 exports.createOptions = Options.createOptions;
 exports.createOperations = Operations.createOperations;
 exports.Contained = index;

package/dist/cjs/primary/{Instance.cjs → SequelizeLibrary.cjs}

@@ -9,8 +9,8 @@ const Coordinate = require('../Coordinate.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', {
+function createSequelizeLibrary(keyType, models, libOptions = {}, scopes = [], registry) {
+    logger.debug('createSequelizeLibrary', {
         keyType,
         models,
         libOptions,
@@ -33,6 +33,9 @@ function createInstance(keyType, models, libOptions = {}, scopes = [], registry)
         models
     };
 }
+// Legacy exports for backwards compatibility
+const createInstance = createSequelizeLibrary;
 
 exports.createInstance = createInstance;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+exports.createSequelizeLibrary = createSequelizeLibrary;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/primary/index.cjs

@@ -2,9 +2,10 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const Instance = require('./Instance.cjs');
+const SequelizeLibrary = require('./SequelizeLibrary.cjs');
 
 
 
-exports.createInstance = Instance.createInstance;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7In0=
+exports.createInstance = SequelizeLibrary.createInstance;
+exports.createSequelizeLibrary = SequelizeLibrary.createSequelizeLibrary;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OyJ9

package/dist/es/SequelizeLibrary.js

@@ -0,0 +1,32 @@
+import * as Library from '@fjell/lib';
+import { createOperations } from './Operations.js';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.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 = createOperations(models, coordinate, registry, options);
+    // Create the base fjell-lib library
+    const libLibrary = Library.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);
+};
+
+export { createSequelizeLibrary, isSequelizeLibrary };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/SequelizeLibraryFactory.js

@@ -0,0 +1,21 @@
+import { createSequelizeLibrary } from './SequelizeLibrary.js';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.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 createSequelizeLibrary(context.registry, coordinate, models, options);
+    };
+};
+
+export { createSequelizeLibraryFactory };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeUZhY3RvcnkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/contained/{Instance.js → SequelizeLibrary.js}

@@ -3,7 +3,7 @@ import { createOperations } from '../Operations.js';
 import { createOptions } from '../Options.js';
 import { createCoordinate } from '../Coordinate.js';
 
-function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry) {
+function createSequelizeLibrary(keyTypes, models, libOptions = {}, scopes = [], registry) {
     // Create coordinate and options separately following new pattern
     const coordinate = createCoordinate(keyTypes, scopes);
     const options = createOptions(libOptions);
@@ -19,6 +19,8 @@ function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry
         models
     };
 }
+// Legacy exports for backwards compatibility
+const createInstance = createSequelizeLibrary;
 
-export { createInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+export { createInstance, createSequelizeLibrary };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/contained/index.js

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

package/dist/es/index.js

@@ -1,6 +1,6 @@
 export { createDefinition } from './Definition.js';
-export { createInstance, isInstance } from './Instance.js';
-export { createInstanceFactory } from './InstanceFactory.js';
+export { createSequelizeLibrary, isSequelizeLibrary } from './SequelizeLibrary.js';
+export { createSequelizeLibraryFactory } from './SequelizeLibraryFactory.js';
 export { createOptions } from './Options.js';
 export { createOperations } from './Operations.js';
 import * as index from './contained/index.js';

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

@@ -5,8 +5,8 @@ import { createCoordinate } from '../Coordinate.js';
 import LibLogger from '../logger.js';
 
 const logger = LibLogger.get('lib-sequelize', 'primary', 'instance');
-function createInstance(keyType, models, libOptions = {}, scopes = [], registry) {
-    logger.debug('createInstance', {
+function createSequelizeLibrary(keyType, models, libOptions = {}, scopes = [], registry) {
+    logger.debug('createSequelizeLibrary', {
         keyType,
         models,
         libOptions,
@@ -29,6 +29,8 @@ function createInstance(keyType, models, libOptions = {}, scopes = [], registry)
         models
     };
 }
+// Legacy exports for backwards compatibility
+const createInstance = createSequelizeLibrary;
 
-export { createInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+export { createInstance, createSequelizeLibrary };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VxdWVsaXplTGlicmFyeS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/primary/index.js

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

package/dist/index.cjs

@@ -79,7 +79,7 @@ const createDefinition = (kta, scopes, libOptions)=>{
 };
 
 //Recursive implementation of jSON.stringify;
-const stringifyJSON = function(obj, visited = new Set()) {
+const general.stringifyJSON = function(obj, visited = new Set()) {
     const arrOfKeyVals = [];
     const arrVals = [];
     let objKeys = [];
@@ -94,7 +94,7 @@ const stringifyJSON = function(obj, visited = new Set()) {
             // Add array to visited before processing its elements
             visited.add(obj);
             obj.forEach(function(el) {
-                arrVals.push(stringifyJSON(el, visited));
+                arrVals.push(general.stringifyJSON(el, visited));
             });
             return '[' + arrVals + ']';
         }
@@ -112,7 +112,7 @@ const stringifyJSON = function(obj, visited = new Set()) {
             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));
+                arrOfKeyVals.push(keyOut + general.stringifyJSON(keyValOut, visited));
             }
         });
         return '{' + arrOfKeyVals + '}';
@@ -122,7 +122,7 @@ const stringifyJSON = function(obj, visited = new Set()) {
 
 const logger$g = logger$1.default.get('sequelize', 'QueryBuilder');
 const addDeleteQuery = (options, model)=>{
-    logger$g.default(`QueryBuilder adding delete query with options: ${stringifyJSON(options)}`);
+    logger$g.default(`QueryBuilder adding delete query with options: ${general.stringifyJSON(options)}`);
     if (model.getAttributes().deletedAt) {
         options.where['deletedAt'] = {
             [sequelize.Op.eq]: null
@@ -135,7 +135,7 @@ const addDeleteQuery = (options, model)=>{
     return options;
 };
 const addEventQueries = (options, events, model)=>{
-    logger$g.default(`QueryBuilder adding event queries with options: ${stringifyJSON(options)}, events: ${stringifyJSON(events)}`);
+    logger$g.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`);
@@ -169,22 +169,22 @@ const addEventQueries = (options, events, model)=>{
 };
 // Add the references to the query
 const addReferenceQueries = (options, references, model)=>{
-    logger$g.default(`QueryBuilder adding reference queries with options: ${stringifyJSON(options)}, references: ${stringifyJSON(references)}`);
+    logger$g.default(`QueryBuilder adding reference queries with options: ${general.stringifyJSON(options)}, references: ${general.stringifyJSON(references)}`);
     Object.keys(references).forEach((key)=>{
-        logger$g.default(`QueryBuilder adding reference query for key: ${key}, references: ${stringifyJSON(references)}`);
+        logger$g.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$g.error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`, {
+                logger$g.error(`Reference key '${key}' has invalid pk value: ${general.stringifyJSON(priKey.pk)}`, {
                     priKey,
                     references
                 });
-                throw new Error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`);
+                throw new Error(`Reference key '${key}' has invalid pk value: ${general.stringifyJSON(priKey.pk)}`);
             }
-            logger$g.trace(`[QueryBuilder] Setting reference where clause: ${key}Id = ${stringifyJSON(priKey.pk)} (type: ${typeof priKey.pk})`);
+            logger$g.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
             };
@@ -267,7 +267,7 @@ const addAssociationCondition = (conditions, condition, model)=>{
         });
         throw new Error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`);
     }
-    logger$g.trace(`[QueryBuilder] Setting association condition: ${sequelizeAssociationColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
+    logger$g.trace(`[QueryBuilder] Setting association condition: ${sequelizeAssociationColumn} = ${general.stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
     conditions[sequelizeAssociationColumn] = {
         [conditionOp]: condition.value
     };
@@ -285,7 +285,7 @@ const addAttributeCondition = (conditions, condition, model)=>{
         });
         throw new Error(`Attribute condition for '${conditionColumn}' has undefined/null value`);
     }
-    logger$g.trace(`[QueryBuilder] Setting attribute condition: ${conditionColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
+    logger$g.trace(`[QueryBuilder] Setting attribute condition: ${conditionColumn} = ${general.stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
     conditions[conditionColumn] = {
         [conditionOp]: condition.value
     };
@@ -356,12 +356,12 @@ const addAssociationIncludes = (options, model)=>{
     return options;
 };
 const buildQuery = (itemQuery, model)=>{
-    logger$g.default(`QueryBuilder build called with itemQuery: ${stringifyJSON(itemQuery)}`);
+    logger$g.default(`QueryBuilder build called with itemQuery: ${general.stringifyJSON(itemQuery)}`);
     let options = {
         where: {}
     };
     if (itemQuery.compoundCondition) {
-        logger$g.default(`QueryBuilder adding conditions: ${stringifyJSON(itemQuery.compoundCondition)}`);
+        logger$g.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
@@ -983,22 +983,22 @@ const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefini
         let item = row.get({
             plain: true
         });
-        logger$a.default('Adding Key to Item with Key Types: %s', stringifyJSON(keyTypes));
+        logger$a.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
         item = addKey(row, item, keyTypes);
         item = populateEvents(item);
-        logger$a.default('Key Added to Item: %s', stringifyJSON(item.key));
+        logger$a.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$a.default('Processing Reference for %s to %s', item.key.kt, stringifyJSON(referenceDefinition.kta));
+                    logger$a.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
                     item = await buildReference(item, referenceDefinition, registry, operationContext);
                 }
             }
             if (aggregationDefinitions && aggregationDefinitions.length > 0) {
                 for (const aggregationDefinition of aggregationDefinitions){
-                    logger$a.default('Processing Aggregation for %s from %s', item.key.kt, stringifyJSON(aggregationDefinition.kta));
+                    logger$a.default('Processing Aggregation for %s from %s', item.key.kt, general.stringifyJSON(aggregationDefinition.kta));
                     item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
                 }
             }
@@ -1008,7 +1008,7 @@ const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefini
             // Mark this item as complete
             operationContext.markComplete(item.key);
         }
-        logger$a.default('Processed Row: %j', stringifyJSON(item));
+        logger$a.default('Processed Row: %j', general.stringifyJSON(item));
         return item;
     });
 };
@@ -1071,11 +1071,11 @@ const all.getAllOperation = (models, definition, registry)=>{
             // Handle direct location keys (simple foreign key constraints)
             for (const locKey of directLocations){
                 if (locKey.lk === undefined || locKey.lk == null || locKey.lk === '' || typeof locKey.lk === 'object' && Object.keys(locKey.lk).length === 0) {
-                    logger$9.error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, {
+                    logger$9.error(`Location key '${locKey.kt}' has invalid lk value: ${general.stringifyJSON(locKey.lk)}`, {
                         locKey,
                         locations: loc
                     });
-                    throw new Error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
+                    throw new Error(`Location key '${locKey.kt}' has invalid lk value: ${general.stringifyJSON(locKey.lk)}`);
                 }
                 const foreignKeyField = locKey.kt + 'Id';
                 // Check if this field already has a condition from the itemQuery
@@ -1083,7 +1083,7 @@ const all.getAllOperation = (models, definition, registry)=>{
                     logger$9.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
                     continue; // Skip this location constraint to avoid conflicts
                 }
-                logger$9.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+                logger$9.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${general.stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
                 options.where[foreignKeyField] = {
                     [sequelize.Op.eq]: locKey.lk
                 };
@@ -1091,11 +1091,11 @@ const all.getAllOperation = (models, definition, registry)=>{
             // Handle hierarchical location keys (requires relationship traversal)
             for (const locKey of hierarchicalLocations){
                 if (locKey.lk === undefined || locKey.lk == null || locKey.lk === '' || typeof locKey.lk === 'object' && Object.keys(locKey.lk).length === 0) {
-                    logger$9.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, {
+                    logger$9.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${general.stringifyJSON(locKey.lk)}`, {
                         locKey,
                         locations: loc
                     });
-                    throw new Error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
+                    throw new Error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${general.stringifyJSON(locKey.lk)}`);
                 }
                 const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta);
                 if (relationshipInfo.found && relationshipInfo.path) {
@@ -1105,7 +1105,7 @@ const all.getAllOperation = (models, definition, registry)=>{
                         continue; // Skip this location constraint to avoid conflicts
                     }
                     // Add the relationship constraint using the path
-                    logger$9.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+                    logger$9.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${general.stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
                     options.where[relationshipInfo.path] = {
                         [sequelize.Op.eq]: locKey.lk
                     };
@@ -1368,7 +1368,7 @@ const getCreateOperation = (models, definition, registry)=>{
         }
         // Create the record
         try {
-            logger$8.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
+            logger$8.trace(`[CREATE] Executing ${model.name}.create() with data: ${general.stringifyJSON(itemData)}`);
             const createdRecord = await model.create(itemData);
             // Add key and events
             const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
@@ -1393,7 +1393,7 @@ const getFindOperation = (models, definition, registry)=>{
         if (finders && finders[finder]) {
             const finderMethod = finders[finder];
             if (finderMethod) {
-                logger$7.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
+                logger$7.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${general.stringifyJSON(finderParams)}, locations: ${general.stringifyJSON(locations)}`);
                 const results = await finderMethod(finderParams, locations);
                 if (results && results.length > 0) {
                     const processedResults = await Promise.all(results.map(async (row)=>{
@@ -1480,7 +1480,7 @@ const getGetOperation = (models, definition, registry)=>{
             logger$6.default('Composite key query', {
                 queryOptions
             });
-            logger$6.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+            logger$6.trace(`[GET] Executing ${model.name}.findOne() with options: ${general.stringifyJSON(queryOptions)}`);
             item = await model.findOne(queryOptions);
         }
         if (!item) {
@@ -1575,7 +1575,7 @@ registry)=>{
             const comKey = key;
             const queryOptions = processCompositeKey(comKey, model, kta);
             logger$4.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
-            logger$4.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+            logger$4.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${general.stringifyJSON(queryOptions)}`);
             item = await model.findOne(queryOptions);
         }
         if (!item) {
@@ -1693,7 +1693,7 @@ const getUpdateOperation = (models, definition, registry)=>{
                 queryOptions.include = mergeIncludes([], additionalIncludes);
             }
             logger$3.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
-            logger$3.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+            logger$3.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${general.stringifyJSON(queryOptions)}`);
             response = await model.findOne(queryOptions);
         }
         if (response) {
@@ -1705,7 +1705,7 @@ const getUpdateOperation = (models, definition, registry)=>{
             logger$3.default(`Update found ${model.name} record to modify`);
             logger$3.default(`Update properties configured: ${Object.keys(updateProps).join(', ')}`);
             // Update the object
-            logger$3.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
+            logger$3.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${general.stringifyJSON(updateProps)}`);
             response = await response.update(updateProps);
             // Populate the key and events
             const processedItem = await processRow(response, kta, references, aggregations, registry);
@@ -1739,12 +1739,12 @@ const createOperations = (models, coordinate, registry, options)=>{
     return operations;
 };
 
-const logger$2 = logger$1.default.get("Instance");
+const logger$2 = logger$1.default.get("SequelizeLibrary");
 /**
- * Creates a new Sequelize instance that extends the fjell-lib instance
+ * Creates a new SequelizeLibrary that extends the fjell-lib Library
  * with Sequelize-specific functionality
- */ const createInstance$2 = (registry, coordinate, models, options)=>{
-    logger$2.debug("createInstance", {
+ */ const createSequelizeLibrary$2 = (registry, coordinate, models, options)=>{
+    logger$2.debug("createSequelizeLibrary", {
         coordinate,
         models,
         registry,
@@ -1752,24 +1752,24 @@ const logger$2 = logger$1.default.get("Instance");
     });
     // Create Sequelize-specific operations
     const operations = createOperations(models, coordinate, registry, options);
-    // Create the base fjell-lib instance
-    const libInstance = Library__namespace.createInstance(registry, coordinate, operations, options);
+    // Create the base fjell-lib library
+    const libLibrary = Library__namespace.createLibrary(registry, coordinate, operations, options);
     return {
-        ...libInstance,
+        ...libLibrary,
         models
     };
 };
 /**
- * Type guard to check if an object is a Sequelize Instance
- */ const isInstance = (instance)=>{
-    return instance != null && instance.coordinate != null && instance.operations != null && instance.options != null && instance.registry != null && instance.models != null && Array.isArray(instance.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);
 };
 
 const logger$1 = logger$1.default.get("InstanceFactory");
 /**
- * Factory function for creating Sequelize instances
+ * Factory function for creating Sequelize libraries
  * This extends the fjell-lib pattern by adding Sequelize-specific models
- */ const createInstanceFactory = (models, options)=>{
+ */ const createSequelizeLibraryFactory = (models, options)=>{
     return (coordinate, context)=>{
         logger$1.debug("Creating Sequelize instance", {
             coordinate,
@@ -1777,11 +1777,11 @@ const logger$1 = logger$1.default.get("InstanceFactory");
             models: models.map((m)=>m.name),
             options
         });
-        return createInstance$2(context.registry, coordinate, models, options);
+        return createSequelizeLibrary$2(context.registry, coordinate, models, options);
     };
 };
 
-function createInstance$1(keyTypes, models, libOptions = {}, scopes = [], registry) {
+function createSequelizeLibrary$1(keyTypes, models, libOptions = {}, scopes = [], registry) {
     // Create coordinate and options separately following new pattern
     const coordinate = createCoordinate(keyTypes, scopes);
     const options = createOptions(libOptions);
@@ -1797,15 +1797,18 @@ function createInstance$1(keyTypes, models, libOptions = {}, scopes = [], regist
         models
     };
 }
+// Legacy exports for backwards compatibility
+const createInstance$1 = createSequelizeLibrary$1;
 
 const index$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
-  createInstance: createInstance$1
+  createInstance: createInstance$1,
+  createSequelizeLibrary: createSequelizeLibrary$1
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const logger = logger$1.default.get('lib-sequelize', 'primary', 'instance');
-function createInstance(keyType, models, libOptions = {}, scopes = [], registry) {
-    logger.debug('createInstance', {
+function createSequelizeLibrary(keyType, models, libOptions = {}, scopes = [], registry) {
+    logger.debug('createSequelizeLibrary', {
         keyType,
         models,
         libOptions,
@@ -1828,10 +1831,13 @@ function createInstance(keyType, models, libOptions = {}, scopes = [], registry)
         models
     };
 }
+// Legacy exports for backwards compatibility
+const createInstance = createSequelizeLibrary;
 
 const index = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
-  createInstance
+  createInstance,
+  createSequelizeLibrary
 }, Symbol.toStringTag, { value: 'Module' }));
 
 exports.Contained = index$1;
@@ -1839,9 +1845,9 @@ exports.Primary = index;
 exports.SCOPE_SEQUELIZE = SCOPE_SEQUELIZE;
 exports.createCoordinate = createCoordinate;
 exports.createDefinition = createDefinition;
-exports.createInstance = createInstance$2;
-exports.createInstanceFactory = createInstanceFactory;
 exports.createOperations = createOperations;
 exports.createOptions = createOptions;
-exports.isInstance = isInstance;
+exports.createSequelizeLibrary = createSequelizeLibrary$2;
+exports.createSequelizeLibraryFactory = createSequelizeLibraryFactory;
+exports.isSequelizeLibrary = isSequelizeLibrary;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/SequelizeLibrary.d.ts

@@ -0,0 +1,28 @@
+import { Item } from '@fjell/core';
+import { Coordinate } from '@fjell/registry';
+import { Registry } from './Registry';
+import { ModelStatic } from 'sequelize';
+import { Options } from './Options';
+import * as Library from '@fjell/lib';
+/**
+ * The SequelizeLibrary interface extends the fjell-lib Library
+ * and adds Sequelize-specific functionality:
+ * - models: Array of Sequelize model classes for this library
+ *
+ * @template V - The type of the data model item, extending Item
+ * @template S - The string literal type representing the model's key type
+ * @template L1-L5 - Optional string literal types for location hierarchy levels
+ */
+export interface SequelizeLibrary<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends Library.Library<V, S, L1, L2, L3, L4, L5> {
+    /** Array of Sequelize model classes associated with this library */
+    models: ModelStatic<any>[];
+}
+/**
+ * Creates a new SequelizeLibrary that extends the fjell-lib Library
+ * with Sequelize-specific functionality
+ */
+export declare const createSequelizeLibrary: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(registry: Registry, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], options: Options<V, S, L1, L2, L3, L4, L5>) => SequelizeLibrary<V, S, L1, L2, L3, L4, L5>;
+/**
+ * Type guard to check if an object is a SequelizeLibrary
+ */
+export declare const isSequelizeLibrary: (library: any) => library is SequelizeLibrary<any, any, any, any, any, any, any>;

package/dist/types/SequelizeLibraryFactory.d.ts

@@ -0,0 +1,14 @@
+import { Item } from '@fjell/core';
+import { Options } from './Options';
+import { InstanceFactory as BaseInstanceFactory } from '@fjell/registry';
+import { ModelStatic } from 'sequelize';
+/**
+ * Sequelize Library Factory type that extends the base factory
+ * to include Sequelize-specific models parameter
+ */
+export type SequelizeLibraryFactory<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = (models: ModelStatic<any>[], options: Options<V, S, L1, L2, L3, L4, L5>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;
+/**
+ * Factory function for creating Sequelize libraries
+ * This extends the fjell-lib pattern by adding Sequelize-specific models
+ */
+export declare const createSequelizeLibraryFactory: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], options: Options<V, S, L1, L2, L3, L4, L5>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;

package/dist/types/contained/SequelizeLibrary.d.ts

@@ -0,0 +1,11 @@
+import { SequelizeLibrary as AbstractSequelizeLibrary } from '../SequelizeLibrary';
+import { Item, ItemTypeArray } from '@fjell/core';
+import { ModelStatic } from 'sequelize';
+import { Registry } from '../Registry';
+import { Options } from '../Options';
+export interface SequelizeLibrary<V extends Item<S>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends AbstractSequelizeLibrary<V, S, L1, L2, L3, L4, L5> {
+    models: ModelStatic<any>[];
+}
+export declare function createSequelizeLibrary<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyTypes: ItemTypeArray<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], libOptions: Partial<Options<V, S, L1, L2, L3, L4, L5>> | undefined, scopes: string[] | undefined, registry: Registry): SequelizeLibrary<V, S, L1, L2, L3, L4, L5>;
+export declare const createInstance: typeof createSequelizeLibrary;
+export type Instance<V extends Item<S>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = SequelizeLibrary<V, S, L1, L2, L3, L4, L5>;

package/dist/types/contained/index.d.ts

@@ -1 +1 @@
-export * from './Instance';
+export * from './SequelizeLibrary';

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 export * from './Definition';
-export * from './Instance';
-export * from './InstanceFactory';
+export * from './SequelizeLibrary';
+export * from './SequelizeLibraryFactory';
 export * from './Options';
 export * from './Operations';
 export * from './Registry';

package/dist/types/primary/SequelizeLibrary.d.ts

@@ -0,0 +1,11 @@
+import { SequelizeLibrary as AbstractSequelizeLibrary } from '../SequelizeLibrary';
+import { Item } from '@fjell/core';
+import { ModelStatic } from 'sequelize';
+import { Options } from '../Options';
+import { Registry } from '../Registry';
+export interface SequelizeLibrary<V extends Item<S>, S extends string> extends AbstractSequelizeLibrary<V, S> {
+    models: ModelStatic<any>[];
+}
+export declare function createSequelizeLibrary<V extends Item<S>, S extends string>(keyType: S, models: ModelStatic<any>[], libOptions: Partial<Options<V, S>> | undefined, scopes: string[] | undefined, registry: Registry): SequelizeLibrary<V, S>;
+export declare const createInstance: typeof createSequelizeLibrary;
+export type Instance<V extends Item<S>, S extends string> = SequelizeLibrary<V, S>;

package/dist/types/primary/index.d.ts

@@ -1 +1 @@
-export * from './Instance';
+export * from './SequelizeLibrary';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjell/lib-sequelize",
-  "version": "4.4.11",
+  "version": "4.4.12",
   "license": "Apache-2.0",
   "keywords": [
     "library",
@@ -30,9 +30,9 @@
   ],
   "dependencies": {
     "@fjell/core": "^4.4.7",
-    "@fjell/lib": "^4.4.12",
+    "@fjell/lib": "^4.4.13",
     "@fjell/logging": "^4.4.7",
-    "@fjell/registry": "^4.4.7",
+    "@fjell/registry": "^4.4.11",
     "dayjs": "^1.11.13",
     "deepmerge": "^4.3.1",
     "sequelize": "^6.37.7"

package/dist/es/Instance.js

@@ -1,32 +0,0 @@
-import * as Library from '@fjell/lib';
-import { createOperations } from './Operations.js';
-import LibLogger from './logger.js';
-
-const logger = LibLogger.get("Instance");
-/**
- * Creates a new Sequelize instance that extends the fjell-lib instance
- * with Sequelize-specific functionality
- */ const createInstance = (registry, coordinate, models, options)=>{
-    logger.debug("createInstance", {
-        coordinate,
-        models,
-        registry,
-        options
-    });
-    // Create Sequelize-specific operations
-    const operations = createOperations(models, coordinate, registry, options);
-    // Create the base fjell-lib instance
-    const libInstance = Library.createInstance(registry, coordinate, operations, options);
-    return {
-        ...libInstance,
-        models
-    };
-};
-/**
- * Type guard to check if an object is a Sequelize Instance
- */ const isInstance = (instance)=>{
-    return instance != null && instance.coordinate != null && instance.operations != null && instance.options != null && instance.registry != null && instance.models != null && Array.isArray(instance.models);
-};
-
-export { createInstance, isInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/InstanceFactory.js

@@ -1,21 +0,0 @@
-import { createInstance } from './Instance.js';
-import LibLogger from './logger.js';
-
-const logger = LibLogger.get("InstanceFactory");
-/**
- * Factory function for creating Sequelize instances
- * This extends the fjell-lib pattern by adding Sequelize-specific models
- */ const createInstanceFactory = (models, options)=>{
-    return (coordinate, context)=>{
-        logger.debug("Creating Sequelize instance", {
-            coordinate,
-            registry: context.registry,
-            models: models.map((m)=>m.name),
-            options
-        });
-        return createInstance(context.registry, coordinate, models, options);
-    };
-};
-
-export { createInstanceFactory };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VGYWN0b3J5LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/types/Instance.d.ts

@@ -1,28 +0,0 @@
-import { Item } from '@fjell/core';
-import { Coordinate } from '@fjell/registry';
-import { Registry } from './Registry';
-import { ModelStatic } from 'sequelize';
-import { Options } from './Options';
-import * as Library from '@fjell/lib';
-/**
- * The Sequelize Instance interface extends the fjell-lib Instance
- * and adds Sequelize-specific functionality:
- * - models: Array of Sequelize model classes for this instance
- *
- * @template V - The type of the data model item, extending Item
- * @template S - The string literal type representing the model's key type
- * @template L1-L5 - Optional string literal types for location hierarchy levels
- */
-export interface Instance<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends Library.Instance<V, S, L1, L2, L3, L4, L5> {
-    /** Array of Sequelize model classes associated with this instance */
-    models: ModelStatic<any>[];
-}
-/**
- * Creates a new Sequelize instance that extends the fjell-lib instance
- * with Sequelize-specific functionality
- */
-export declare const createInstance: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(registry: Registry, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], options: Options<V, S, L1, L2, L3, L4, L5>) => Instance<V, S, L1, L2, L3, L4, L5>;
-/**
- * Type guard to check if an object is a Sequelize Instance
- */
-export declare const isInstance: (instance: any) => instance is Instance<any, any, any, any, any, any, any>;

package/dist/types/InstanceFactory.d.ts

@@ -1,14 +0,0 @@
-import { Item } from '@fjell/core';
-import { Options } from './Options';
-import { InstanceFactory as BaseInstanceFactory } from '@fjell/registry';
-import { ModelStatic } from 'sequelize';
-/**
- * Sequelize Instance Factory type that extends the base factory
- * to include Sequelize-specific models parameter
- */
-export type InstanceFactory<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = (models: ModelStatic<any>[], options: Options<V, S, L1, L2, L3, L4, L5>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;
-/**
- * Factory function for creating Sequelize instances
- * This extends the fjell-lib pattern by adding Sequelize-specific models
- */
-export declare const createInstanceFactory: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], options: Options<V, S, L1, L2, L3, L4, L5>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;

package/dist/types/contained/Instance.d.ts

@@ -1,9 +0,0 @@
-import { Instance as AbstractSequelizeInstance } from '../Instance';
-import { Item, ItemTypeArray } from '@fjell/core';
-import { ModelStatic } from 'sequelize';
-import { Registry } from '../Registry';
-import { Options } from '../Options';
-export interface Instance<V extends Item<S>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends AbstractSequelizeInstance<V, S, L1, L2, L3, L4, L5> {
-    models: ModelStatic<any>[];
-}
-export declare function createInstance<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyTypes: ItemTypeArray<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], libOptions: Partial<Options<V, S, L1, L2, L3, L4, L5>> | undefined, scopes: string[] | undefined, registry: Registry): Instance<V, S, L1, L2, L3, L4, L5>;

package/dist/types/primary/Instance.d.ts

@@ -1,9 +0,0 @@
-import { Instance as AbstractSequelizeInstance } from '../Instance';
-import { Item } from '@fjell/core';
-import { ModelStatic } from 'sequelize';
-import { Options } from '../Options';
-import { Registry } from '../Registry';
-export interface Instance<V extends Item<S>, S extends string> extends AbstractSequelizeInstance<V, S> {
-    models: ModelStatic<any>[];
-}
-export declare function createInstance<V extends Item<S>, S extends string>(keyType: S, models: ModelStatic<any>[], libOptions: Partial<Options<V, S>> | undefined, scopes: string[] | undefined, registry: Registry): Instance<V, S>;