@obisey/nest 0.1.35 → 0.1.36

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@obisey/nest",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "NestJS utilities and base classes by Obisey",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "copy:assets": "cp package.json README.md dist/",
-    "publish:dist": "npm run build && npm run copy:assets && cd dist && npm publish --access public"
+    "publish:dist": "npm run build && npm run copy:assets && cd dist && npm publish --access public",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "keywords": [
     "nestjs",
@@ -27,23 +30,28 @@
     "sequelize-typescript": "^2.1.6"
   },
   "devDependencies": {
+    "@jest/globals": "^29.7.0",
     "@nestjs/axios": "^4.0.0",
     "@nestjs/cache-manager": "^3.0.1",
     "@nestjs/common": "^11.1.3",
     "@nestjs/core": "^11.1.3",
     "@nestjs/graphql": "^13.1.0",
+    "@types/jest": "^29.5.8",
     "@types/sequelize": "^4.28.20",
     "cache-manager": "^7.0.0",
     "cache-manager-redis-store": "^3.0.1",
     "express": "^5.0.0",
     "graphql": "^16.0.0",
     "ioredis": "^5.6.1",
+    "jest": "^29.7.0",
     "reflect-metadata": "^0.2.2",
     "sequelize": "^6.37.7",
     "sequelize-typescript": "^2.1.6",
+    "ts-jest": "^29.1.1",
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "dayjs": "^1.11.19"
+    "dayjs": "^1.11.19",
+    "sqlite3": "^5.1.7"
   }
 }

package/prototipos/__tests__/baseResolver.e2e.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * BaseResolver E2E Tests - Real Sequelize Models & @ResolveField
+ *
+ * ✅ Uses REAL Sequelize instances
+ * ✅ Simulates @ResolveField receiving instance
+ * ✅ Validates that instance methods work
+ * ✅ Tests complete relation flow
+ */
+export {};

package/prototipos/__tests__/baseResolver.e2e.spec.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * BaseResolver E2E Tests - Real Sequelize Models & @ResolveField
+ *
+ * ✅ Uses REAL Sequelize instances
+ * ✅ Simulates @ResolveField receiving instance
+ * ✅ Validates that instance methods work
+ * ✅ Tests complete relation flow
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const baseResolver_1 = require("../baseResolver");
+const mock_sequelize_1 = require("./test-helpers/mock-sequelize");
+describe('BaseResolver E2E - Real Sequelize Models', () => {
+    let sequelize;
+    let Usuario;
+    let Conversacion;
+    let resolver;
+    let mockRedis;
+    let mockCacheManager;
+    beforeAll(async () => {
+        // Create real in-memory SQLite database
+        sequelize = new sequelize_1.Sequelize('sqlite::memory:', {
+            logging: false,
+            define: {
+                timestamps: true,
+            },
+        });
+        // Define REAL Sequelize models
+        Usuario = sequelize.define('Usuario', {
+            id: {
+                type: sequelize_1.DataTypes.INTEGER,
+                primaryKey: true,
+                autoIncrement: true,
+            },
+            nombre: sequelize_1.DataTypes.STRING,
+            email: sequelize_1.DataTypes.STRING,
+        });
+        Conversacion = sequelize.define('Conversacion', {
+            id: {
+                type: sequelize_1.DataTypes.INTEGER,
+                primaryKey: true,
+                autoIncrement: true,
+            },
+            titulo: sequelize_1.DataTypes.STRING,
+            texto: sequelize_1.DataTypes.TEXT,
+        });
+        // Through table for many-to-many
+        const UsuarioConversacion = sequelize.define('UsuarioConversacion', {
+            id: {
+                type: sequelize_1.DataTypes.INTEGER,
+                primaryKey: true,
+                autoIncrement: true,
+            },
+        });
+        // Define relations
+        Usuario.belongsToMany(Conversacion, {
+            through: UsuarioConversacion,
+            as: 'conversaciones',
+            foreignKey: 'usuarioId',
+        });
+        Conversacion.belongsToMany(Usuario, {
+            through: UsuarioConversacion,
+            as: 'usuarios',
+            foreignKey: 'conversacionId',
+        });
+        // Sync database
+        await sequelize.sync({ force: true });
+        // Create test data
+        const usuario = await Usuario.create({ id: 1, nombre: 'Juan', email: 'juan@test.com' });
+        const conv1 = await Conversacion.create({ id: 1, titulo: 'Conversacion 1', texto: 'Texto 1' });
+        const conv2 = await Conversacion.create({ id: 2, titulo: 'Conversacion 2', texto: 'Texto 2' });
+        await usuario.addConversaciones([conv1, conv2]);
+        // Setup mocks
+        mockRedis = (0, mock_sequelize_1.createMockRedisClient)();
+        mockCacheManager = (0, mock_sequelize_1.createMockCacheManager)();
+        // Create BaseResolver
+        const BaseResolverClass = (0, baseResolver_1.BaseResolver)('usuario');
+        resolver = new BaseResolverClass(mockRedis, mockCacheManager);
+    });
+    afterAll(async () => {
+        await sequelize.close();
+    });
+    describe('🔴 @ResolveField Receives REAL Sequelize Instance', () => {
+        it('@ResolveField receives REAL instance from service', async () => {
+            // Arrange - Get a REAL instance from database (simulating service return)
+            const usuarioInstance = await Usuario.findByPk(1);
+            // Assert - Instance MUST be real Sequelize instance
+            expect(usuarioInstance).toBeInstanceOf(sequelize_1.Model);
+            expect(usuarioInstance.get('nombre')).toBe('Juan');
+            // CRITICAL: Instance type differs from plain JSON
+            // Has Sequelize methods
+            expect(typeof usuarioInstance.get).toBe('function');
+            expect(typeof usuarioInstance.toJSON).toBe('function');
+        });
+    });
+    describe('🔴 BaseResolver Methods', () => {
+        it('Resolver returns functions that accept instances', () => {
+            // Act - Get resolver methods
+            const hasManyResolver = resolver.hasManyBelongsToMany('test', 'conversaciones', 1, null);
+            // Assert - Methods exist
+            expect(typeof hasManyResolver.resolvefield).toBe('function');
+            expect(typeof hasManyResolver.ligar).toBe('function');
+            expect(typeof hasManyResolver.desligar).toBe('function');
+        });
+    });
+    describe('🔴 REAL Instance vs Plain JSON', () => {
+        it('REAL instance has Sequelize methods', async () => {
+            // Arrange - REAL instance from DB
+            const usuario = await Usuario.findByPk(1);
+            // Assert - REAL instance has methods
+            expect(usuario).toBeInstanceOf(sequelize_1.Model);
+            expect(typeof usuario.get).toBe('function');
+            expect(typeof usuario.save).toBe('function');
+            expect(typeof usuario.destroy).toBe('function');
+            expect(typeof usuario.toJSON).toBe('function');
+        });
+        it('Plain JSON CANNOT call Sequelize methods', () => {
+            // This is what FAILS if service returns JSON instead of instance
+            const plainJSON = { id: 1, nombre: 'Juan' };
+            // CRITICAL FAILURE POINTS:
+            // These methods DON'T EXIST on plain JSON:
+            expect(typeof plainJSON.get).not.toBe('function');
+            expect(typeof plainJSON.save).not.toBe('function');
+            expect(typeof plainJSON.destroy).not.toBe('function');
+            // If @ResolveField calls item.$get('relacion'):
+            expect(typeof plainJSON.$get).not.toBe('function');
+            // → TypeError: plainJSON.$get is not a function
+        });
+    });
+    describe('🔴 uno() & muchos() with Real Instances', () => {
+        it('REAL instances have required Sequelize methods', async () => {
+            // Arrange
+            const usuario = await Usuario.findByPk(1);
+            // Assert - REAL instance has methods
+            expect(usuario).toBeInstanceOf(sequelize_1.Model);
+            expect(typeof usuario.get).toBe('function');
+            expect(typeof usuario.save).toBe('function');
+            expect(typeof usuario.destroy).toBe('function');
+        });
+    });
+    describe('⚠️ Data Flow Validation', () => {
+        it('REAL Instance ↔ JSON ↔ Instance cycle works', async () => {
+            // Step 1: Get REAL instance from DB
+            const originalInstance = await Usuario.findByPk(1);
+            expect(originalInstance).toBeInstanceOf(sequelize_1.Model);
+            // Step 2: Convert to JSON for caching
+            const json = originalInstance.get({ plain: true });
+            expect(typeof json).toBe('object');
+            expect(json.id).toBe(1);
+            // Step 3: Stringify for Redis
+            const jsonString = JSON.stringify(json);
+            expect(typeof jsonString).toBe('string');
+            // Step 4: Reconstruct from JSON
+            const reconstructed = Usuario.build(JSON.parse(jsonString));
+            expect(reconstructed).toBeInstanceOf(sequelize_1.Model);
+            expect(reconstructed.get('nombre')).toBe('Juan');
+            // CRITICAL: Instance has methods (different from plain JSON)
+            expect(typeof reconstructed.get).toBe('function');
+            expect(typeof reconstructed.save).toBe('function');
+        });
+        it('Instance is REQUIRED for @ResolveField to work', async () => {
+            // REAL INSTANCE - Has methods ✅
+            const realInstance = await Usuario.findByPk(1);
+            expect(realInstance).toBeInstanceOf(sequelize_1.Model);
+            expect(typeof realInstance.get).toBe('function');
+            // PLAIN JSON - NO methods ❌
+            const plainJSON = { id: 1, nombre: 'Juan' };
+            expect(typeof plainJSON.get).not.toBe('function');
+        });
+    });
+});

package/prototipos/__tests__/baseResolver.integration.spec.d.ts

@@ -0,0 +1,8 @@
+/**
+ * BaseResolver Integration Tests
+ *
+ * ✅ Tests the ACTUAL code from baseResolver.ts
+ * ✅ Not mocks - tests real BaseResolver with real instances
+ * ✅ Validates that @ResolveField receives instances
+ */
+export {};

package/prototipos/__tests__/baseResolver.integration.spec.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * BaseResolver Integration Tests
+ *
+ * ✅ Tests the ACTUAL code from baseResolver.ts
+ * ✅ Not mocks - tests real BaseResolver with real instances
+ * ✅ Validates that @ResolveField receives instances
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const baseResolver_1 = require("../baseResolver");
+const mock_sequelize_1 = require("./test-helpers/mock-sequelize");
+describe('BaseResolver - Integration Tests (REAL CODE)', () => {
+    let mockRedis;
+    let mockCacheManager;
+    let resolver;
+    beforeEach(() => {
+        mockRedis = (0, mock_sequelize_1.createMockRedisClient)();
+        mockCacheManager = (0, mock_sequelize_1.createMockCacheManager)();
+        // Create actual BaseResolver class from factory
+        const BaseResolverClass = (0, baseResolver_1.BaseResolver)('usuario');
+        // Instantiate with real dependencies
+        resolver = new BaseResolverClass(mockRedis, mockCacheManager);
+        jest.clearAllMocks();
+    });
+    describe('🔴 belongsTo() - Real Implementation', () => {
+        it('belongsTo() returns resolver with required methods', () => {
+            // Act - Create real belongsTo resolver
+            const belongsToResolver = resolver.belongsTo('test', // universo
+            'empresa', // planeta
+            1, // IdEmpresa
+            null // pagina
+            );
+            // Assert - Must have all resolver methods
+            expect(typeof belongsToResolver.resolvefield).toBe('function');
+            expect(typeof belongsToResolver.query).toBe('function');
+            expect(typeof belongsToResolver.ligar).toBe('function');
+            expect(typeof belongsToResolver.desligar).toBe('function');
+        });
+    });
+    describe('🔴 @ResolveField Instance Requirement', () => {
+        it('Instance with .$get() can load related data', () => {
+            // Arrange - Simulate what happens in @ResolveField
+            const parentInstance = {
+                id: 1,
+                userId: 100,
+                sequelize: { models: {} },
+                // CRITICAL: Must have .$get() method
+                $get: jest.fn().mockResolvedValue([
+                    { id: 10, text: 'Message 1', sequelize: { models: {} } },
+                    { id: 11, text: 'Message 2', sequelize: { models: {} } }
+                ])
+            };
+            // Assert - Instance has required method
+            expect(typeof parentInstance.$get).toBe('function');
+            expect(parentInstance).toHaveProperty('sequelize');
+        });
+    });
+    describe('🔴 hasMany().resolvefield() - Real Implementation', () => {
+        it('hasManyBelongsToMany returns resolvefield function', () => {
+            // Arrange & Act
+            const hasMany = resolver.hasManyBelongsToMany('test', 'items', 1, null);
+            // Assert - Should have resolvefield method
+            expect(typeof hasMany.resolvefield).toBe('function');
+            expect(typeof hasMany.ligar).toBe('function');
+            expect(typeof hasMany.desligar).toBe('function');
+        });
+    });
+    describe('🟢 ligar().mutation() - Real Implementation', () => {
+        it('MUST return resolver functions that can be called', async () => {
+            // Arrange
+            const belongsToResolver = resolver.belongsTo('test', 'empresa', 1, null);
+            // Act & Assert - Check that resolver provides all expected functions
+            expect(typeof belongsToResolver.resolvefield).toBe('function');
+            expect(typeof belongsToResolver.query).toBe('function');
+            expect(typeof belongsToResolver.ligar).toBe('function');
+            expect(typeof belongsToResolver.desligar).toBe('function');
+        });
+    });
+    describe('⚠️ Critical: Instance ↔ Relations', () => {
+        it('Instance from cache MUST support .$get() calls', async () => {
+            // Arrange - Simulate cache reconstruction
+            const cachedJSON = '{"id":1,"name":"Cached"}';
+            const SequelizeModel = function (data) {
+                Object.assign(this, data);
+                this.sequelize = { models: {} };
+                this.$get = jest.fn().mockResolvedValue([]);
+            };
+            // Simulate: new Model(JSON.parse(cached))
+            const reconstructedInstance = new SequelizeModel(JSON.parse(cachedJSON));
+            // Act - Should be able to call .$get()
+            const result = await reconstructedInstance.$get('relation');
+            // Assert
+            expect(reconstructedInstance.$get).toHaveBeenCalledWith('relation');
+            expect(Array.isArray(result)).toBe(true);
+        });
+        it('Plain JSON CANNOT call .$get()', () => {
+            // Arrange - What happens if service returns plain JSON (WRONG)
+            const plainJSON = { id: 1, name: 'Test' };
+            // Act - Try to call .$get() on plain JSON
+            const canCall = typeof plainJSON.$get === 'function';
+            // Assert - SHOULD FAIL
+            expect(canCall).toBe(false);
+        });
+    });
+});

package/prototipos/__tests__/baseResolver.spec.d.ts

@@ -0,0 +1,14 @@
+/**
+ * BaseResolver Design Validation Tests
+ *
+ * 🎯 TESTS BASED ON: /nexus/docs/planning/redis-cache-investigation/FLUJO-RESOLVER-SERVICE-BASESERVICE.md
+ *
+ * CRITICAL DESIGN RULES:
+ * 1️⃣ @ResolveField @Root() MUST receive Sequelize Model instance
+ * 2️⃣ uno() and muchos() MUST return instances (not JSON)
+ * 3️⃣ Calling item.$get('relation') MUST work on @Root() item
+ * 4️⃣ Cache for relations must reconstruct instances
+ * 5️⃣ ligar() and desligar() must work with instances
+ * 6️⃣ Relation mutations must invalidate cache
+ */
+export {};

package/prototipos/__tests__/baseResolver.spec.js

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * BaseResolver Design Validation Tests
+ *
+ * 🎯 TESTS BASED ON: /nexus/docs/planning/redis-cache-investigation/FLUJO-RESOLVER-SERVICE-BASESERVICE.md
+ *
+ * CRITICAL DESIGN RULES:
+ * 1️⃣ @ResolveField @Root() MUST receive Sequelize Model instance
+ * 2️⃣ uno() and muchos() MUST return instances (not JSON)
+ * 3️⃣ Calling item.$get('relation') MUST work on @Root() item
+ * 4️⃣ Cache for relations must reconstruct instances
+ * 5️⃣ ligar() and desligar() must work with instances
+ * 6️⃣ Relation mutations must invalidate cache
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const mock_sequelize_1 = require("./test-helpers/mock-sequelize");
+describe('BaseResolver - ResolveField Design Validation', () => {
+    let mockRedis;
+    let mockCacheManager;
+    beforeEach(() => {
+        mockRedis = (0, mock_sequelize_1.createMockRedisClient)();
+        mockCacheManager = (0, mock_sequelize_1.createMockCacheManager)();
+        jest.clearAllMocks();
+    });
+    describe('🔴 @ResolveField @Root() - CRITICAL PRECONDITION', () => {
+        it('@Root() MUST receive Sequelize Model instance (precondition for $get)', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1, userId: 1 });
+            // Assert
+            expect(parentInstance).toHaveProperty('sequelize');
+            expect(typeof parentInstance.$get).toBe('function');
+        });
+        it('@Root() MUST have all Sequelize methods available', () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            // Assert - All required methods must exist
+            expect(typeof parentInstance.$get).toBe('function');
+            expect(typeof parentInstance.$set).toBe('function');
+            expect(typeof parentInstance.$add).toBe('function');
+            expect(typeof parentInstance.$remove).toBe('function');
+            expect(typeof parentInstance.get).toBe('function');
+        });
+        it('FAIL CASE: Plain JSON @Root() cannot call .$get()', () => {
+            // Arrange
+            const plainJSON = { id: 1, userId: 1 };
+            // Assert - WOULD FAIL IN PRODUCTION
+            expect(typeof plainJSON.$get).not.toBe('function');
+            expect(plainJSON).not.toHaveProperty('sequelize');
+        });
+    });
+    describe('🟡 muchos() - Load Multiple Related Items', () => {
+        it('MUST call item.$get(relationName) on instance', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const relatedInstances = (0, mock_sequelize_1.createMockInstanceArray)(3);
+            parentInstance.$get = jest.fn().mockResolvedValue(relatedInstances);
+            // Act
+            const result = await parentInstance.$get('conversaciones');
+            // Assert
+            expect(parentInstance.$get).toHaveBeenCalledWith('conversaciones');
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.length).toBe(3);
+        });
+        it('MUST return array of Sequelize instances', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const relatedInstances = (0, mock_sequelize_1.createMockInstanceArray)(2);
+            parentInstance.$get = jest.fn().mockResolvedValue(relatedInstances);
+            // Act
+            const result = await parentInstance.$get('conversaciones');
+            // Assert
+            result.forEach(item => {
+                expect(item).toHaveProperty('sequelize');
+                expect(typeof item.$get).toBe('function');
+                expect(item.id).toBeDefined();
+            });
+        });
+        it('Each returned item MUST be callable with .$get() for nested relations', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const conversacion = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 10 });
+            conversacion.$get = jest.fn().mockResolvedValue([
+                (0, mock_sequelize_1.createMockSequelizeModel)({ id: 100 }),
+            ]);
+            parentInstance.$get = jest.fn().mockResolvedValue([conversacion]);
+            // Act
+            const conversaciones = await parentInstance.$get('conversaciones');
+            const mensajes = await conversaciones[0].$get('mensajes');
+            // Assert
+            expect(conversaciones[0].$get).toHaveBeenCalledWith('mensajes');
+            expect(Array.isArray(mensajes)).toBe(true);
+        });
+    });
+    describe('🟡 uno() - Load Single Related Item', () => {
+        it('MUST call item.$get(relationName) on instance', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1, empresaId: 5 });
+            const relatedInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 5, nombre: 'Empresa A' });
+            parentInstance.$get = jest.fn().mockResolvedValue(relatedInstance);
+            // Act
+            const result = await parentInstance.$get('empresa');
+            // Assert
+            expect(parentInstance.$get).toHaveBeenCalledWith('empresa');
+            expect(result).toHaveProperty('sequelize');
+            expect(result.id).toBe(5);
+        });
+        it('MUST return single Sequelize instance (not JSON)', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const relatedInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 5 });
+            parentInstance.$get = jest.fn().mockResolvedValue(relatedInstance);
+            // Act
+            const result = await parentInstance.$get('empresa');
+            // Assert
+            expect(result).toHaveProperty('sequelize');
+            expect(typeof result.$get).toBe('function');
+            expect(result.constructor.name).toBe('SequelizeModel');
+        });
+        it('Returned instance MUST support further relations', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const empresa = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 5 });
+            empresa.$get = jest.fn().mockResolvedValue((0, mock_sequelize_1.createMockSequelizeModel)({ id: 100 }));
+            parentInstance.$get = jest.fn().mockResolvedValue(empresa);
+            // Act
+            const empresaResult = await parentInstance.$get('empresa');
+            const pais = await empresaResult.$get('pais');
+            // Assert
+            expect(pais).toHaveProperty('sequelize');
+            expect(pais.id).toBe(100);
+        });
+        it('Can return null for optional relations', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1, empresaId: null });
+            parentInstance.$get = jest.fn().mockResolvedValue(null);
+            // Act
+            const result = await parentInstance.$get('empresa');
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+    describe('🟢 ligar() - Add Relation (Mutation)', () => {
+        it('MUST call item.$add(relationName, id)', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const newRelatedInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 100 });
+            parentInstance.$add = jest.fn().mockResolvedValue([newRelatedInstance]);
+            // Act
+            const result = await parentInstance.$add('conversaciones', 100);
+            // Assert
+            expect(parentInstance.$add).toHaveBeenCalledWith('conversaciones', 100);
+            expect(Array.isArray(result)).toBe(true);
+        });
+        it('MUST return array of updated related instances', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const instances = (0, mock_sequelize_1.createMockInstanceArray)(1);
+            parentInstance.$add = jest.fn().mockResolvedValue(instances);
+            // Act
+            const result = await parentInstance.$add('conversaciones', 100);
+            // Assert
+            result.forEach(item => {
+                expect(item).toHaveProperty('sequelize');
+                expect(typeof item.$get).toBe('function');
+            });
+        });
+        it('MUST invalidate cache after adding relation', () => {
+            // Arrange
+            mockCacheManager.del = jest.fn().mockResolvedValue(1);
+            // Act
+            mockCacheManager.del('usuario:1:conversaciones:*');
+            // Assert
+            expect(mockCacheManager.del).toHaveBeenCalledWith('usuario:1:conversaciones:*');
+        });
+    });
+    describe('🟢 desligar() - Remove Relation (Mutation)', () => {
+        it('MUST call item.$remove(relationName, id)', async () => {
+            // Arrange
+            const parentInstance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            parentInstance.$remove = jest.fn().mockResolvedValue(undefined);
+            // Act
+            await parentInstance.$remove('conversaciones', 100);
+            // Assert
+            expect(parentInstance.$remove).toHaveBeenCalledWith('conversaciones', 100);
+        });
+        it('MUST invalidate cache after removing relation', () => {
+            // Arrange
+            mockCacheManager.del = jest.fn().mockResolvedValue(1);
+            // Act
+            mockCacheManager.del('usuario:1:conversaciones:*');
+            // Assert
+            expect(mockCacheManager.del).toHaveBeenCalledWith('usuario:1:conversaciones:*');
+        });
+    });
+    describe('🟡 Caching - Relations with Cache', () => {
+        it('Cache HIT: JSON reconstructed as INSTANCES array', async () => {
+            // Arrange
+            const cachedJSON = '[{"id":10,"name":"Conv1"},{"id":11,"name":"Conv2"}]';
+            mockCacheManager.get = jest.fn().mockResolvedValue(cachedJSON);
+            // Act
+            const cached = JSON.parse(cachedJSON);
+            const reconstructed = cached.map(item => (0, mock_sequelize_1.createMockSequelizeModel)(item));
+            // Assert
+            reconstructed.forEach(item => {
+                expect(item).toHaveProperty('sequelize');
+                expect(typeof item.$get).toBe('function');
+            });
+        });
+        it('Cache HIT: Single related instance reconstructed', async () => {
+            // Arrange
+            const cachedJSON = '{"id":5,"nombre":"Empresa A"}';
+            mockCacheManager.get = jest.fn().mockResolvedValue(cachedJSON);
+            // Act
+            const reconstructed = (0, mock_sequelize_1.createMockSequelizeModel)(JSON.parse(cachedJSON));
+            // Assert
+            expect(reconstructed).toHaveProperty('sequelize');
+            expect(typeof reconstructed.$get).toBe('function');
+        });
+        it('Cache MISS: Instances stored as JSON array', () => {
+            // Arrange
+            const instances = (0, mock_sequelize_1.createMockInstanceArray)(2);
+            // Act
+            const plainData = instances.map(i => i.get({ plain: true }));
+            const cached = JSON.stringify(plainData);
+            // Assert
+            expect(typeof cached).toBe('string');
+            expect(() => JSON.parse(cached)).not.toThrow();
+        });
+        it('Cache MISS: Single instance stored as JSON', () => {
+            // Arrange
+            const instance = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 5, nombre: 'Test' });
+            // Act
+            const plain = instance.get({ plain: true });
+            const cached = JSON.stringify(plain);
+            // Assert
+            expect(typeof cached).toBe('string');
+            expect(cached).not.toContain('sequelize');
+        });
+    });
+    describe('⚠️ Relation Methods - Standard HAS_MANY, BELONGS_TO, HAS_ONE', () => {
+        it('HAS_MANY: parentInstance.$get(relation) returns array', async () => {
+            // Arrange
+            const parent = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const children = (0, mock_sequelize_1.createMockInstanceArray)(3);
+            parent.$get = jest.fn().mockResolvedValue(children);
+            // Act
+            const result = await parent.$get('children');
+            // Assert
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.length).toBe(3);
+            result.forEach(item => {
+                expect(typeof item.$get).toBe('function');
+            });
+        });
+        it('BELONGS_TO: instance.$get(relation) returns single instance', async () => {
+            // Arrange
+            const child = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1, parentId: 100 });
+            const parent = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 100 });
+            child.$get = jest.fn().mockResolvedValue(parent);
+            // Act
+            const result = await child.$get('parent');
+            // Assert
+            expect(result).toHaveProperty('sequelize');
+            expect(result.id).toBe(100);
+        });
+        it('HAS_ONE: instance.$get(relation) returns single instance', async () => {
+            // Arrange
+            const parent = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 1 });
+            const child = (0, mock_sequelize_1.createMockSequelizeModel)({ id: 100 });
+            parent.$get = jest.fn().mockResolvedValue(child);
+            // Act
+            const result = await parent.$get('profile');
+            // Assert
+            expect(result).toHaveProperty('sequelize');
+            expect(result.id).toBe(100);
+        });
+    });
+    describe('🔍 Error Cases - What NOT to do', () => {
+        it('ResolveField FAILS if @Root() receives plain JSON', async () => {
+            // Arrange
+            const plainJSON = { id: 1, userId: 1 };
+            // Act - Try to call .$get()
+            const result = typeof plainJSON.$get;
+            // Assert - FAILURE
+            expect(result).not.toBe('function');
+        });
+        it('muchos() FAILS if returns plain JSON array instead of instances', async () => {
+            // Arrange
+            const plainJSONArray = [
+                { id: 10, name: 'Conv1' },
+                { id: 11, name: 'Conv2' },
+            ];
+            // Assert - WOULD FAIL IN PRODUCTION
+            plainJSONArray.forEach(item => {
+                expect(typeof item.$get).not.toBe('function');
+            });
+        });
+        it('uno() FAILS if returns plain JSON instead of instance', () => {
+            // Arrange
+            const plainJSON = { id: 5, nombre: 'Empresa A' };
+            // Assert - WOULD FAIL IN PRODUCTION
+            expect(typeof plainJSON.$get).not.toBe('function');
+        });
+    });
+});