@obisey/nest 0.1.35 → 0.1.37

package/prototipos/__tests__/cachear-types.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Type-Safe Cachear Usage Examples
+ *
+ * Validates the <TResult, TCache> generic design:
+ * - TResult = live type (Sequelize instance, number, etc.)
+ * - TCache  = serialized type (string, string[], etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const cachear_1 = require("../utils/cachear");
+describe('Cachear - Type Safety with <TResult, TCache>', () => {
+    let sequelize;
+    let Usuario;
+    beforeAll(async () => {
+        sequelize = new sequelize_1.Sequelize('sqlite::memory:', { logging: false });
+        Usuario = sequelize.define('Usuario', {
+            id: { type: sequelize_1.DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            nombre: sequelize_1.DataTypes.STRING,
+        });
+        await sequelize.sync();
+        await Usuario.create({ id: 1, nombre: 'Juan' });
+    });
+    afterAll(async () => {
+        await sequelize.close();
+    });
+    describe('Single item: <Model, string>', () => {
+        it('buscarXid pattern: TResult=Model, TCache=string', async () => {
+            const mockCacheManager = {
+                get: jest.fn().mockResolvedValue(null),
+                set: jest.fn(),
+            };
+            const result = await (0, cachear_1.cachear)(true, mockCacheManager, 'test-key', (cache) => Promise.resolve(Usuario.build(JSON.parse(cache), { raw: false, isNewRecord: false })), (resultado) => Promise.resolve(JSON.stringify(resultado.get({ plain: true }))), () => Usuario.findByPk(1), () => mockCacheManager.get('test-key'), (key, datos) => mockCacheManager.set(key, datos));
+            expect(result.resultado).toBeDefined();
+            expect(typeof result.resultado.get).toBe('function');
+        });
+        it('cache HIT path: revisar reconstructs instance', async () => {
+            const cachedJson = JSON.stringify({ id: 1, nombre: 'Juan' });
+            const mockCacheManager = {
+                get: jest.fn().mockResolvedValue(cachedJson),
+                set: jest.fn(),
+            };
+            const result = await (0, cachear_1.cachear)(true, mockCacheManager, 'test-key', (cache) => Promise.resolve(Usuario.build(JSON.parse(cache), { raw: false, isNewRecord: false })), (resultado) => Promise.resolve(JSON.stringify(resultado.get({ plain: true }))), () => Usuario.findByPk(1), () => mockCacheManager.get('test-key'), (key, datos) => mockCacheManager.set(key, datos));
+            expect(result.cache).toBe(true);
+            expect(typeof result.resultado.get).toBe('function');
+        });
+    });
+    describe('Array items: <Model[], string[]>', () => {
+        it('buscarTodos pattern: TResult=Model[], TCache=string[]', async () => {
+            const mockCacheManager = {
+                get: jest.fn().mockResolvedValue(null),
+                set: jest.fn(),
+            };
+            const mockRepository = {
+                findAll: jest.fn().mockResolvedValue([
+                    Usuario.build({ id: 1, nombre: 'Juan' }),
+                ]),
+            };
+            const result = await (0, cachear_1.cachear)(true, mockCacheManager, 'usuarios:all', (cache) => Promise.resolve(cache.map((n) => Usuario.build(JSON.parse(n), { raw: false, isNewRecord: false }))), (resultado) => Promise.resolve(resultado.map((n) => JSON.stringify(n.get({ plain: true })))), () => mockRepository.findAll(), () => mockCacheManager.get('usuarios:all'), (key, datos) => mockCacheManager.set(key, datos));
+            expect(Array.isArray(result.resultado)).toBe(true);
+            result.resultado.forEach(item => {
+                expect(typeof item.get).toBe('function');
+            });
+        });
+    });
+    describe('Number: <number, string>', () => {
+        it('contar pattern: TResult=number, TCache=string', async () => {
+            const mockCacheManager = {
+                get: jest.fn().mockResolvedValue(null),
+                set: jest.fn(),
+            };
+            const mockRepository = {
+                count: jest.fn().mockResolvedValue(42),
+            };
+            const result = await (0, cachear_1.cachear)(true, mockCacheManager, 'count-key', (cache) => Promise.resolve(JSON.parse(cache)), (resultado) => Promise.resolve(JSON.stringify(resultado)), () => mockRepository.count(), () => mockCacheManager.get('count-key'), (key, datos) => mockCacheManager.set(key, datos));
+            expect(result.resultado).toBe(42);
+        });
+    });
+});

package/prototipos/__tests__/graphql-flow.e2e.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GraphQL Flow E2E Test
+ *
+ * ✅ Reproduces EXACT production flow:
+ * GraphQL Query → Resolver → Service → BaseService → ResolveField → Relation loading
+ *
+ * ✅ THIS TEST SHOULD FAIL if item.$get is not callable
+ */
+export {};

package/prototipos/__tests__/graphql-flow.e2e.spec.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * GraphQL Flow E2E Test
+ *
+ * ✅ Reproduces EXACT production flow:
+ * GraphQL Query → Resolver → Service → BaseService → ResolveField → Relation loading
+ *
+ * ✅ THIS TEST SHOULD FAIL if item.$get is not callable
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const baseService_1 = require("../baseService");
+const baseResolver_1 = require("../baseResolver");
+const mock_sequelize_1 = require("./test-helpers/mock-sequelize");
+describe('GraphQL Flow E2E - paginacionUsuario with empresas', () => {
+    let sequelize;
+    let Usuario;
+    let Empresa;
+    let usuarioService;
+    let usuarioResolver;
+    let mockRedis;
+    let mockCacheManager;
+    beforeAll(async () => {
+        // Setup real database
+        sequelize = new sequelize_1.Sequelize('sqlite::memory:', { logging: false });
+        // Define 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,
+        });
+        Empresa = sequelize.define('Empresa', {
+            id: { type: sequelize_1.DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            nombre: sequelize_1.DataTypes.STRING,
+        });
+        // Define relations
+        Usuario.belongsToMany(Empresa, {
+            through: 'UsuarioEmpresa',
+            as: 'empresas',
+            foreignKey: 'usuarioId',
+        });
+        Empresa.belongsToMany(Usuario, {
+            through: 'UsuarioEmpresa',
+            as: 'usuarios',
+            foreignKey: 'empresaId',
+        });
+        await sequelize.sync();
+        // Create test data
+        const emp1 = await Empresa.create({ id: 1, nombre: 'Empresa A' });
+        const emp2 = await Empresa.create({ id: 2, nombre: 'Empresa B' });
+        const user1 = await Usuario.create({ id: 381, nombre: 'Juan', email: 'juan@test.com' });
+        const user2 = await Usuario.create({ id: 382, nombre: 'Maria', email: 'maria@test.com' });
+        await user1.addEmpresas([emp1, emp2]);
+        await user2.addEmpresas([emp1]);
+        // Setup mocks
+        mockRedis = (0, mock_sequelize_1.createMockRedisClient)();
+        mockCacheManager = (0, mock_sequelize_1.createMockCacheManager)();
+        // Create real service and resolver
+        const BaseServiceClass = (0, baseService_1.BaseService)('usuario');
+        usuarioService = new BaseServiceClass(mockRedis, mockCacheManager);
+        const BaseResolverClass = (0, baseResolver_1.BaseResolver)('usuario');
+        usuarioResolver = new BaseResolverClass(mockRedis, mockCacheManager);
+    });
+    afterAll(async () => {
+        await sequelize.close();
+    });
+    describe('🔴 GraphQL Query: paginacionUsuario', () => {
+        it('REPRODUCES: paginacionUsuario(pagina: 2, limite: 100)', async () => {
+            // Arrange - Setup mock repository
+            const mockRepository = {
+                sequelize,
+                findAll: jest.fn(async (options) => {
+                    return Usuario.findAll(options);
+                }),
+                count: jest.fn(async () => Usuario.count()),
+            };
+            mockCacheManager.get = jest.fn().mockResolvedValue(null);
+            mockRedis.hExists = jest.fn().mockResolvedValue(false);
+            mockRedis.hSet = jest.fn();
+            // Act 1: Call buscarTodos (simulating resolver calling service)
+            const paginationResult = await usuarioService.buscarTodos({
+                value: { cacheable: false },
+                key: {
+                    universo: 'starconsole',
+                    IdEmpresa: 1,
+                    fragmentos: [{ nombre: 'usuario' }],
+                    tipo: 'query',
+                },
+                Clase: Usuario,
+                repository: mockRepository,
+            });
+            // Assert 1: Should return items
+            expect(paginationResult).toBeDefined();
+            // THIS IS THE CRITICAL PART - if items are JSON, the next step fails
+            const items = paginationResult?.items || paginationResult;
+            expect(Array.isArray(items)).toBe(true);
+            // Act 2: For each item, load empresas (simulating @ResolveField)
+            // THIS IS WHERE IT FAILS IN PRODUCTION: item.$get is not a function
+            if (Array.isArray(items) && items.length > 0) {
+                const firstItem = items[0];
+                // THIS IS THE LINE THAT FAILS IN PRODUCTION
+                // At baseResolver.js:486 -> item.$get is not a function
+                expect(typeof firstItem.get).toBe('function'); // Item must be instance
+                // Try to load relation (would call $get in real code)
+                if (typeof firstItem.$get === 'function') {
+                    const empresas = await firstItem.$get('empresas');
+                    expect(Array.isArray(empresas)).toBe(true);
+                    expect(empresas.length).toBeGreaterThan(0);
+                }
+                else {
+                    // THIS IS WHAT FAILS IN PRODUCTION:
+                    throw new Error('item.$get is not a function - ' +
+                        'item is JSON plano, not Sequelize instance');
+                }
+            }
+        });
+        it('CRITICAL: Each item in paginacionUsuario MUST be Sequelize instance', async () => {
+            // Arrange
+            const mockRepository = {
+                sequelize,
+                findAll: jest.fn(async (options) => {
+                    return Usuario.findAll(options);
+                }),
+                count: jest.fn(async () => Usuario.count()),
+            };
+            mockCacheManager.get = jest.fn().mockResolvedValue(null);
+            mockRedis.hExists = jest.fn().mockResolvedValue(false);
+            // Act
+            const result = await usuarioService.buscarTodos({
+                value: { cacheable: false },
+                key: {
+                    universo: 'starconsole',
+                    IdEmpresa: 1,
+                    fragmentos: [{ nombre: 'usuario' }],
+                    tipo: 'query',
+                },
+                Clase: Usuario,
+                repository: mockRepository,
+            });
+            const items = result?.items || result;
+            // Assert - Each item MUST be instance
+            if (Array.isArray(items)) {
+                items.forEach((item, idx) => {
+                    try {
+                        // THIS IS WHAT FAILS IN PRODUCTION
+                        expect(item).toBeInstanceOf(sequelize_1.Model);
+                        expect(typeof item.get).toBe('function');
+                        expect(typeof item.$get).toBe('function');
+                    }
+                    catch (e) {
+                        throw new Error(`Item ${idx} is not Sequelize instance. ` +
+                            `Error at: baseResolver.js:486 -> item.$get is not a function`);
+                    }
+                });
+            }
+        });
+    });
+    describe('⚠️ Production Error Simulation', () => {
+        it('DETECTS: item.$get is not a function (the actual error)', async () => {
+            // This simulates what happens in production
+            const items = [
+                { id: 381, nombre: 'Juan', empresas: [] }, // ❌ JSON plano
+            ];
+            const firstItem = items[0];
+            // THIS SHOULD FAIL (like in production):
+            try {
+                if (typeof firstItem.$get !== 'function') {
+                    throw new TypeError('item.$get is not a function');
+                }
+            }
+            catch (err) {
+                expect(err.message).toContain('item.$get is not a function');
+                // ✅ Test DETECTS the problem
+            }
+        });
+        it('PREVENTS: With proper instance, $get works', async () => {
+            // Get real instance
+            const usuario = await Usuario.findByPk(381);
+            // THIS SHOULD WORK:
+            expect(typeof usuario.$get).toBe('function');
+            // Can load relations
+            const empresas = await usuario.$get('empresas');
+            expect(Array.isArray(empresas)).toBe(true);
+        });
+    });
+    describe('📊 Comparison: What Works vs What Fails', () => {
+        it('WORKS: Service returns Sequelize instances', async () => {
+            const mockRepository = {
+                sequelize,
+                findAll: jest.fn(async (options) => {
+                    return Usuario.findAll(options);
+                }),
+                count: jest.fn(async () => Usuario.count()),
+            };
+            mockCacheManager.get = jest.fn().mockResolvedValue(null);
+            mockRedis.hExists = jest.fn().mockResolvedValue(false);
+            const result = await usuarioService.buscarTodos({
+                value: { cacheable: false },
+                key: {
+                    universo: 'starconsole',
+                    IdEmpresa: 1,
+                    fragmentos: [{ nombre: 'usuario' }],
+                    tipo: 'query',
+                },
+                Clase: Usuario,
+                repository: mockRepository,
+            });
+            const items = result?.items || result;
+            // ✅ WORKS
+            if (Array.isArray(items) && items[0]) {
+                expect(typeof items[0].$get).toBe('function');
+                expect(typeof items[0].get).toBe('function');
+            }
+        });
+        it('FAILS: Service returns JSON plano', () => {
+            // Simulate wrong implementation
+            const wrongResult = [
+                { id: 381, nombre: 'Juan', email: 'juan@test.com' }, // ❌ JSON
+            ];
+            // ❌ FAILS
+            expect(typeof wrongResult[0].$get).not.toBe('function');
+            // This is the error in production:
+            // await wrongResult[0].$get('empresas') → TypeError!
+        });
+    });
+    describe('🎯 Summary: GraphQL Flow Validation', () => {
+        it('Full flow: Query → Service → Relation loading works only with instances', async () => {
+            // Step 1: Query paginacionUsuario
+            const mockRepository = {
+                sequelize,
+                findAll: jest.fn(async (options) => Usuario.findAll(options)),
+                count: jest.fn(async () => Usuario.count()),
+            };
+            mockCacheManager.get = jest.fn().mockResolvedValue(null);
+            mockRedis.hExists = jest.fn().mockResolvedValue(false);
+            // Step 2: Service returns items
+            const result = await usuarioService.buscarTodos({
+                value: { cacheable: false },
+                key: {
+                    universo: 'starconsole',
+                    IdEmpresa: 1,
+                    fragmentos: [{ nombre: 'usuario' }],
+                    tipo: 'query',
+                },
+                Clase: Usuario,
+                repository: mockRepository,
+            });
+            const items = result?.items || result;
+            // Step 3: For @ResolveField empresas
+            if (Array.isArray(items)) {
+                for (const item of items) {
+                    // This is where production fails:
+                    // If item is JSON: TypeError: item.$get is not a function
+                    // If item is instance: ✅ Works
+                    if (typeof item.$get === 'function') {
+                        // ✅ WORKS - item is instance
+                        const empresas = await item.$get('empresas');
+                        expect(Array.isArray(empresas)).toBe(true);
+                    }
+                    else {
+                        // ❌ FAILS - item is JSON
+                        throw new Error('Cannot load empresas: item.$get is not a function\n' +
+                            'This is the exact error from production:\n' +
+                            'baseResolver.js:486 -> item.$get is not a function');
+                    }
+                }
+            }
+        });
+    });
+});

package/prototipos/__tests__/test-helpers/mock-sequelize.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Mock Sequelize Model Factory
+ * Creates fake Sequelize instances with all required methods for testing
+ */
+export interface MockSequelizeOptions {
+    [key: string]: any;
+}
+/**
+ * Creates a mock Sequelize Model instance
+ * ✅ Has sequelize property (marks it as instance)
+ * ✅ Has .get() method
+ * ✅ Has .$get(), .$set(), .$add(), .$remove() methods
+ * ✅ Can be used with JSON.stringify/parse cycle
+ */
+export declare function createMockSequelizeModel(data?: MockSequelizeOptions): any;
+/**
+ * Mock Cache Manager for testing caching behavior
+ * Simulates cache-manager operations
+ */
+export declare const createMockCacheManager: () => {
+    get: jest.Mock<any, any, any>;
+    set: jest.Mock<any, any, any>;
+    del: jest.Mock<any, any, any>;
+    reset: jest.Mock<any, any, any>;
+    hget: jest.Mock<any, any, any>;
+    hset: jest.Mock<any, any, any>;
+    hdel: jest.Mock<any, any, any>;
+    keys: jest.Mock<any, any, any>;
+};
+/**
+ * Mock Redis Client for testing Redis operations
+ * Simulates redis client operations
+ */
+export declare const createMockRedisClient: () => {
+    connect: jest.Mock<any, any, any>;
+    disconnect: jest.Mock<any, any, any>;
+    get: jest.Mock<any, any, any>;
+    set: jest.Mock<any, any, any>;
+    del: jest.Mock<any, any, any>;
+    hget: jest.Mock<any, any, any>;
+    hset: jest.Mock<any, any, any>;
+    hdel: jest.Mock<any, any, any>;
+    hExists: jest.Mock<any, any, any>;
+    expire: jest.Mock<any, any, any>;
+    flushDb: jest.Mock<any, any, any>;
+    ping: jest.Mock<any, any, any>;
+    keys: jest.Mock<any, any, any>;
+};
+/**
+ * Mock Sequelize Repository for testing database operations
+ */
+export declare const createMockRepository: (Model?: any) => {
+    sequelize: {
+        models: {
+            Usuario: any;
+            Empresa: any;
+            Conversacion: any;
+        };
+        define: jest.Mock<any, any, any>;
+    };
+    findByPk: jest.Mock<any, any, any>;
+    findAll: jest.Mock<any, any, any>;
+    findOne: jest.Mock<any, any, any>;
+    create: jest.Mock<any, any, any>;
+    update: jest.Mock<any, any, any>;
+    destroy: jest.Mock<any, any, any>;
+    count: jest.Mock<any, any, any>;
+    findAndCountAll: jest.Mock<any, any, any>;
+};
+/**
+ * Helper to simulate cache hit with JSON data
+ * Used to test: JSON → Sequelize Instance reconstruction
+ */
+export declare function simulateCacheHit(data: any): string;
+/**
+ * Helper to simulate cache miss (null)
+ * Used to test: Database → Service → Cache path
+ */
+export declare function simulateCacheMiss(): null;
+/**
+ * Helper to create instance array for pagination tests
+ */
+export declare function createMockInstanceArray(count: number, baseId?: number): any[];

package/prototipos/__tests__/test-helpers/mock-sequelize.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Mock Sequelize Model Factory
+ * Creates fake Sequelize instances with all required methods for testing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockRepository = exports.createMockRedisClient = exports.createMockCacheManager = void 0;
+exports.createMockSequelizeModel = createMockSequelizeModel;
+exports.simulateCacheHit = simulateCacheHit;
+exports.simulateCacheMiss = simulateCacheMiss;
+exports.createMockInstanceArray = createMockInstanceArray;
+/**
+ * Creates a mock Sequelize Model instance
+ * ✅ Has sequelize property (marks it as instance)
+ * ✅ Has .get() method
+ * ✅ Has .$get(), .$set(), .$add(), .$remove() methods
+ * ✅ Can be used with JSON.stringify/parse cycle
+ */
+function createMockSequelizeModel(data = {}) {
+    const instance = {
+        ...data,
+        // 🔴 CRITICAL: sequelize property marks this as a Sequelize instance
+        sequelize: {
+            models: {},
+            define: jest.fn(),
+        },
+        // Instance methods
+        get: jest.fn((options) => {
+            if (options?.plain) {
+                const { sequelize, ...plainData } = instance;
+                return plainData;
+            }
+            return instance;
+        }),
+        // Relation methods - Critical for @ResolveField
+        $get: jest.fn(),
+        $set: jest.fn(),
+        $add: jest.fn(),
+        $remove: jest.fn(),
+        // Persistence methods
+        save: jest.fn(function () {
+            return Promise.resolve(this);
+        }),
+        destroy: jest.fn(function () {
+            return Promise.resolve();
+        }),
+        reload: jest.fn(function () {
+            return Promise.resolve(this);
+        }),
+        // Helper to mark as JSON for serialization tests
+        constructor: {
+            name: 'SequelizeModel',
+        },
+    };
+    return instance;
+}
+/**
+ * Mock Cache Manager for testing caching behavior
+ * Simulates cache-manager operations
+ */
+const createMockCacheManager = () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn(),
+    reset: jest.fn(),
+    hget: jest.fn(),
+    hset: jest.fn(),
+    hdel: jest.fn(),
+    keys: jest.fn(),
+});
+exports.createMockCacheManager = createMockCacheManager;
+/**
+ * Mock Redis Client for testing Redis operations
+ * Simulates redis client operations
+ */
+const createMockRedisClient = () => ({
+    connect: jest.fn().mockResolvedValue(undefined),
+    disconnect: jest.fn().mockResolvedValue(undefined),
+    get: jest.fn().mockResolvedValue(null),
+    set: jest.fn().mockResolvedValue('OK'),
+    del: jest.fn().mockResolvedValue(1),
+    hget: jest.fn().mockResolvedValue(null),
+    hset: jest.fn().mockResolvedValue('OK'),
+    hdel: jest.fn().mockResolvedValue(1),
+    hExists: jest.fn().mockResolvedValue(false),
+    expire: jest.fn().mockResolvedValue(1),
+    flushDb: jest.fn().mockResolvedValue('OK'),
+    ping: jest.fn().mockResolvedValue('PONG'),
+    keys: jest.fn().mockResolvedValue([]), // ← Redis.keys() for cache invalidation
+});
+exports.createMockRedisClient = createMockRedisClient;
+/**
+ * Mock Sequelize Repository for testing database operations
+ */
+const createMockRepository = (Model = createMockSequelizeModel()) => ({
+    sequelize: {
+        models: {
+            'Usuario': Model,
+            'Empresa': Model,
+            'Conversacion': Model,
+        },
+        define: jest.fn(),
+    },
+    findByPk: jest.fn(),
+    findAll: jest.fn(),
+    findOne: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    destroy: jest.fn(),
+    count: jest.fn(),
+    findAndCountAll: jest.fn(),
+});
+exports.createMockRepository = createMockRepository;
+/**
+ * Helper to simulate cache hit with JSON data
+ * Used to test: JSON → Sequelize Instance reconstruction
+ */
+function simulateCacheHit(data) {
+    return JSON.stringify(data);
+}
+/**
+ * Helper to simulate cache miss (null)
+ * Used to test: Database → Service → Cache path
+ */
+function simulateCacheMiss() {
+    return null;
+}
+/**
+ * Helper to create instance array for pagination tests
+ */
+function createMockInstanceArray(count, baseId = 1) {
+    return Array.from({ length: count }, (_, i) => createMockSequelizeModel({
+        id: baseId + i,
+        name: `Item${baseId + i}`,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    }));
+}

package/prototipos/baseResolver.d.ts

@@ -17,13 +17,13 @@ export declare function BaseResolver(modelo: string): {
             desligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, borrarSSR?: boolean) => Promise<boolean>;
         };
         hasManyBelongsToMany(universo: any, planeta: any, IdEmpresa: any, pagina?: any): {
-            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
+            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any[]>;
             query: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
             ligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, through?: any, borrarSSR?: boolean) => Promise<boolean>;
             desligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, borrarSSR?: boolean) => Promise<boolean>;
         };
         nodo(universo: any, planeta: any, IdEmpresa: any, pagina?: any): {
-            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
+            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any[]>;
             query: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
             ligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, through: any, borrarSSR?: boolean) => Promise<boolean>;
             desligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, borrarSSR?: boolean) => Promise<boolean>;
@@ -40,7 +40,7 @@ export declare function BaseResolver(modelo: string): {
             arbol: (item: any, where: any, cacheable: any, Clase: any) => Promise<void>;
             preResolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
             preQuery: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
-            subResolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
+            subResolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any[]>;
             subQuery: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
             ligar: (IdModelo: any, IdPlaneta: any, borrarSSR: any) => Promise<void>;
             desligar: (IdModelo: any, IdPlaneta: any, borrarSSR: any) => Promise<void>;
@@ -68,7 +68,7 @@ export declare function BaseResolver(modelo: string): {
             Clase: any;
             tipo: any;
             relacion: any;
-        }, pagina?: any): Promise<any>;
+        }, pagina?: any): Promise<any[]>;
         ligar({ universo, servicio, alias, IdPlaneta, IdModelo, tipo, planeta, through, borrarSSR, }: {
             universo: any;
             servicio: any;
@@ -108,13 +108,13 @@ export declare function BaseResolver(modelo: string): {
             desligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, borrarSSR?: boolean) => Promise<boolean>;
         };
         hasManyBelongsToMany(universo: any, planeta: any, IdEmpresa: any, pagina?: any): {
-            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
+            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any[]>;
             query: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
             ligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, through?: any, borrarSSR?: boolean) => Promise<boolean>;
             desligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, borrarSSR?: boolean) => Promise<boolean>;
         };
         nodo(universo: any, planeta: any, IdEmpresa: any, pagina?: any): {
-            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
+            resolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any[]>;
             query: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
             ligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, through: any, borrarSSR?: boolean) => Promise<boolean>;
             desligar: (servicio: any, alias: any, IdModelo: any, IdPlaneta: any, borrarSSR?: boolean) => Promise<boolean>;
@@ -131,7 +131,7 @@ export declare function BaseResolver(modelo: string): {
             arbol: (item: any, where: any, cacheable: any, Clase: any) => Promise<void>;
             preResolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
             preQuery: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
-            subResolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any>;
+            subResolvefield: (item: any, where: any, cacheable: any, Clase: any) => Promise<any[]>;
             subQuery: (servicio: any, IdModelo: any, Clase: any) => Promise<any>;
             ligar: (IdModelo: any, IdPlaneta: any, borrarSSR: any) => Promise<void>;
             desligar: (IdModelo: any, IdPlaneta: any, borrarSSR: any) => Promise<void>;
@@ -159,7 +159,7 @@ export declare function BaseResolver(modelo: string): {
             Clase: any;
             tipo: any;
             relacion: any;
-        }, pagina?: any): Promise<any>;
+        }, pagina?: any): Promise<any[]>;
         ligar({ universo, servicio, alias, IdPlaneta, IdModelo, tipo, planeta, through, borrarSSR, }: {
             universo: any;
             servicio: any;