@obisey/nest 0.1.21 → 0.1.23

package/adapters/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Adapters - Agnóstico de BD
+ *
+ * Patrón: Cada BD tiene su carpeta con adapters específicos
+ * - sequelize/ → Adapters para Sequelize ORM
+ * - drizzle/ → Adapters para Drizzle (futuro)
+ * - prisma/ → Adapters para Prisma (futuro)
+ *
+ * Cada adapter transforma PropertyDTO/RelationDTO → BD-specific config
+ */
+export * from './sequelize';

package/adapters/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Adapters - Agnóstico de BD
+ *
+ * Patrón: Cada BD tiene su carpeta con adapters específicos
+ * - sequelize/ → Adapters para Sequelize ORM
+ * - drizzle/ → Adapters para Drizzle (futuro)
+ * - prisma/ → Adapters para Prisma (futuro)
+ *
+ * Cada adapter transforma PropertyDTO/RelationDTO → BD-specific config
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sequelize"), exports);

package/adapters/sequelize/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sequelize Adapters
+ * Agnósticos de BD, específicos para Sequelize
+ */
+export { PropertyAdapter, type PropertyDTO, type SequelizeColumnConfig } from './property.adapter';

package/adapters/sequelize/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Sequelize Adapters
+ * Agnósticos de BD, específicos para Sequelize
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyAdapter = void 0;
+var property_adapter_1 = require("./property.adapter");
+Object.defineProperty(exports, "PropertyAdapter", { enumerable: true, get: function () { return property_adapter_1.PropertyAdapter; } });

package/adapters/sequelize/property.adapter.d.ts

@@ -0,0 +1,79 @@
+/**
+ * PropertyAdapter para Sequelize
+ * Maneja tipado de propiedades agnósticamente
+ *
+ * RESPUESTA BAJO:
+ * - Convertir PropertyDTO → ColumnConfig (Sequelize)
+ * - Convertir PropertyDTO → TypeScriptType
+ * - Manejar types especiales (JSON, ENUM, ARRAY)
+ *
+ * @example
+ * const prop = { name: 'email', type: 'STRING', nullable: true }
+ * const column = PropertyAdapter.column(prop)
+ * // Returns: "@Column({ type: DataType.STRING, allowNull: true, field: 'email' })"
+ */
+/**
+ * DTO que recibe el adapter (estructura de API)
+ */
+export interface PropertyDTO {
+    name: string;
+    type: 'STRING' | 'INTEGER' | 'FLOAT' | 'DECIMAL' | 'DATE' | 'BOOLEAN' | 'JSON' | 'TEXT' | 'ENUM' | 'ARRAY';
+    nullable?: boolean;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    unique?: boolean;
+    defaultValue?: string | number | boolean;
+    enumValues?: string[];
+    decimals?: number;
+    precision?: number;
+    length?: number;
+}
+/**
+ * Config que devuelve el adapter (para usar en template)
+ */
+export interface SequelizeColumnConfig {
+    decorator: string;
+    tsType: string;
+    tsFieldType: string;
+}
+/**
+ * PropertyAdapter - Transforma PropertyDTO → SequelizeColumnConfig
+ */
+export declare class PropertyAdapter {
+    /**
+     * Convierte tipo de dato API → DataType de Sequelize (string)
+     * @example 'STRING' → 'DataType.STRING'
+     */
+    private static mapToSequelizeType;
+    /**
+     * Convierte tipo de dato API → Tipo TypeScript
+     * @example 'STRING' → 'string', 'INTEGER' → 'number'
+     */
+    private static mapToTypeScriptType;
+    /**
+     * Genera el decorador @Column con todas las opciones
+     */
+    private static generateColumnDecorator;
+    /**
+     * Método principal: Convierte PropertyDTO → SequelizeColumnConfig
+     * Esto es lo que usan los templates
+     */
+    static column(prop: PropertyDTO): SequelizeColumnConfig;
+    /**
+     * Getter para solo el decorador (para templates simples)
+     */
+    static getDecorator(prop: PropertyDTO): string;
+    /**
+     * Getter para solo el tipo TypeScript
+     */
+    static getTsType(prop: PropertyDTO): string;
+    /**
+     * Getter para solo el tipo TypeScript con ?
+     */
+    static getTsFieldType(prop: PropertyDTO): string;
+}
+/**
+ * Export default para facilitar uso en templates
+ * @example <%= adapter.column(property) %>
+ */
+export default PropertyAdapter;

package/adapters/sequelize/property.adapter.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * PropertyAdapter para Sequelize
+ * Maneja tipado de propiedades agnósticamente
+ *
+ * RESPUESTA BAJO:
+ * - Convertir PropertyDTO → ColumnConfig (Sequelize)
+ * - Convertir PropertyDTO → TypeScriptType
+ * - Manejar types especiales (JSON, ENUM, ARRAY)
+ *
+ * @example
+ * const prop = { name: 'email', type: 'STRING', nullable: true }
+ * const column = PropertyAdapter.column(prop)
+ * // Returns: "@Column({ type: DataType.STRING, allowNull: true, field: 'email' })"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyAdapter = void 0;
+/**
+ * PropertyAdapter - Transforma PropertyDTO → SequelizeColumnConfig
+ */
+class PropertyAdapter {
+    /**
+     * Convierte tipo de dato API → DataType de Sequelize (string)
+     * @example 'STRING' → 'DataType.STRING'
+     */
+    static mapToSequelizeType(type, prop) {
+        const typeMap = {
+            STRING: 'DataType.STRING',
+            INTEGER: 'DataType.INTEGER',
+            FLOAT: 'DataType.FLOAT',
+            DECIMAL: `DataType.DECIMAL(${prop.precision || 10}, ${prop.decimals || 2})`,
+            DATE: 'DataType.DATE',
+            BOOLEAN: 'DataType.BOOLEAN',
+            JSON: 'DataType.JSON',
+            TEXT: 'DataType.TEXT',
+            ENUM: `DataType.ENUM(${prop.enumValues?.map((e) => `'${e}'`).join(', ') || ''})`,
+            ARRAY: 'DataType.ARRAY(DataType.STRING)', // Default array de strings
+        };
+        return typeMap[type] || 'DataType.STRING';
+    }
+    /**
+     * Convierte tipo de dato API → Tipo TypeScript
+     * @example 'STRING' → 'string', 'INTEGER' → 'number'
+     */
+    static mapToTypeScriptType(type) {
+        const typeMap = {
+            STRING: 'string',
+            INTEGER: 'number',
+            FLOAT: 'number',
+            DECIMAL: 'number',
+            DATE: 'Date',
+            BOOLEAN: 'boolean',
+            JSON: 'any',
+            TEXT: 'string',
+            ENUM: 'string',
+            ARRAY: 'string[]',
+        };
+        return typeMap[type] || 'string';
+    }
+    /**
+     * Genera el decorador @Column con todas las opciones
+     */
+    static generateColumnDecorator(prop, sequelizeType) {
+        const options = [`type: ${sequelizeType}`];
+        // Field mapping (si es distinto al nombre)
+        options.push(`field: '${prop.name}'`);
+        // Nullable
+        if (prop.nullable) {
+            options.push('allowNull: true');
+        }
+        else {
+            options.push('allowNull: false');
+        }
+        // Primary key
+        if (prop.primaryKey) {
+            options.push('primaryKey: true');
+        }
+        // Auto increment
+        if (prop.autoIncrement) {
+            options.push('autoIncrement: true');
+        }
+        // Unique
+        if (prop.unique) {
+            options.push('unique: true');
+        }
+        // Default value
+        if (prop.defaultValue !== undefined && prop.defaultValue !== null) {
+            const defaultValue = typeof prop.defaultValue === 'string' ? `'${prop.defaultValue}'` : prop.defaultValue;
+            options.push(`defaultValue: ${defaultValue}`);
+        }
+        return `@Column({ ${options.join(', ')} })`;
+    }
+    /**
+     * Método principal: Convierte PropertyDTO → SequelizeColumnConfig
+     * Esto es lo que usan los templates
+     */
+    static column(prop) {
+        const sequelizeType = this.mapToSequelizeType(prop.type, prop);
+        const tsType = this.mapToTypeScriptType(prop.type);
+        // Campo TypeScript con ? si es nullable
+        const tsFieldType = prop.nullable ? `${tsType}?` : tsType;
+        return {
+            decorator: this.generateColumnDecorator(prop, sequelizeType),
+            tsType,
+            tsFieldType,
+        };
+    }
+    /**
+     * Getter para solo el decorador (para templates simples)
+     */
+    static getDecorator(prop) {
+        const sequelizeType = this.mapToSequelizeType(prop.type, prop);
+        return this.generateColumnDecorator(prop, sequelizeType);
+    }
+    /**
+     * Getter para solo el tipo TypeScript
+     */
+    static getTsType(prop) {
+        return this.mapToTypeScriptType(prop.type);
+    }
+    /**
+     * Getter para solo el tipo TypeScript con ?
+     */
+    static getTsFieldType(prop) {
+        const tsType = this.mapToTypeScriptType(prop.type);
+        return prop.nullable ? `${tsType}?` : tsType;
+    }
+}
+exports.PropertyAdapter = PropertyAdapter;
+/**
+ * Export default para facilitar uso en templates
+ * @example <%= adapter.column(property) %>
+ */
+exports.default = PropertyAdapter;

package/conexion.d.ts

@@ -0,0 +1,25 @@
+import { Sequelize } from 'sequelize-typescript';
+/**
+ * Configuración de conexión a BD por tenant (emisor/receptor).
+ * El emisor (Global/Nucleus) expone un mapa IdEmpresa → ConexionProps.
+ */
+export interface ConexionProps {
+    nombre: string;
+    id: string | number;
+    database: string;
+    username: string;
+    password: string;
+    host: string;
+    port: number;
+    dominios?: Array<{
+        nombre: string;
+    }>;
+}
+/**
+ * Clase de conexión por tenant. El app la usa vía CONEXION_FACTORY:
+ *   { provide: CONEXION_FACTORY, useValue: (config) => new Conexion(config, [Model1, Model2, ...]) }
+ * Los providers generados (X_REPOSITORY) inyectan CONEXION_FACTORY y ReceptorService.
+ */
+export declare class Conexion extends Sequelize {
+    constructor(config: ConexionProps, models?: any[]);
+}

package/conexion.js

@@ -1,32 +1,25 @@
-// import { Sequelize } from 'sequelize-typescript';
-// interface Dominio {
-// 	nombre: string;
-// }
-// export interface ConexionProps {
-// 	nombre: string;
-// 	id: string | number;
-// 	database: string;
-// 	username: string;
-// 	password: string;
-// 	host: string;
-// 	port: number;
-// 	dominios: Dominio[];
-// }
-// export class Conexion extends Sequelize {
-// 	constructor({ host, port, username, password, database }) {
-// 		super({
-// 			dialect: 'mysql',
-// 			host,
-// 			port,
-// 			username,
-// 			password,
-// 			database,
-// 			// logging : true,
-// 			logging: false,
-// 			sync: {
-// 				force: true,
-// 				alter: true,
-// 			},
-// 		});
-// 	}
-// }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conexion = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+/**
+ * Clase de conexión por tenant. El app la usa vía CONEXION_FACTORY:
+ *   { provide: CONEXION_FACTORY, useValue: (config) => new Conexion(config, [Model1, Model2, ...]) }
+ * Los providers generados (X_REPOSITORY) inyectan CONEXION_FACTORY y ReceptorService.
+ */
+class Conexion extends sequelize_typescript_1.Sequelize {
+    constructor(config, models = []) {
+        super({
+            dialect: 'mysql',
+            host: config.host,
+            port: config.port,
+            username: config.username,
+            password: config.password,
+            database: config.database,
+            repositoryMode: true,
+            models: models.length ? models : undefined,
+            logging: false,
+        });
+    }
+}
+exports.Conexion = Conexion;

package/index.d.ts

@@ -9,7 +9,10 @@ export * from './prototipos/utils/activarRedis';
 export * from './prototipos/utils/formarInclude';
 export * from './prototipos/utils/formarorder';
 export * from './prototipos/utils/formarwhere';
+export * from './prototipos/utils/getModelId';
 export * from './assets/http-exception.filter';
 export * from './assets/tokens';
 export * from './types';
 export * from './fecha';
+export * from './conexion';
+export * from './receptor.service';

package/index.js

@@ -26,7 +26,10 @@ __exportStar(require("./prototipos/utils/activarRedis"), exports);
 __exportStar(require("./prototipos/utils/formarInclude"), exports);
 __exportStar(require("./prototipos/utils/formarorder"), exports);
 __exportStar(require("./prototipos/utils/formarwhere"), exports);
+__exportStar(require("./prototipos/utils/getModelId"), exports);
 __exportStar(require("./assets/http-exception.filter"), exports);
 __exportStar(require("./assets/tokens"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./fecha"), exports);
+__exportStar(require("./conexion"), exports);
+__exportStar(require("./receptor.service"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obisey/nest",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "NestJS utilities and base classes by Obisey",
   "main": "index.js",
   "types": "index.d.ts",
@@ -35,12 +35,15 @@
     "@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",
     "reflect-metadata": "^0.2.2",
     "sequelize": "^6.37.7",
     "sequelize-typescript": "^2.1.6",
-    "typescript": "^5.8.3",
-    "express": "^5.0.0"
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "dayjs": "^1.11.19"
   }
 }

package/prototipos/baseService.js

@@ -10,6 +10,7 @@ const cifrado_1 = require("./utils/cifrado");
 const keyInterface_1 = require("./utils/keyInterface");
 exports.redis_on = true;
 const paginar_1 = require("./utils/paginar");
+const getModelId_1 = require("./utils/getModelId");
 var isDev = false;
 var stringifWhere = (where) => (0, lodash_1.isObject)(where)
     ? JSON.stringify(Object.entries(where).reduce((ac, [a, v]) => {
@@ -127,7 +128,19 @@ function BaseService(modelo) {
                         ...key,
                         include,
                         where,
-                    }), (cache) => Promise.resolve(cache.map((n) => new repository.sequelize.models[(0, lodash_1.capitalize)(modelo)](JSON.parse(n)))), //Revisar
+                    }), (cache) => Promise.resolve(cache.map((n) => {
+                        const parsed = JSON.parse(n);
+                        console.log(`[OBISEY-NEST CACHE HIT] ${modelo}:`, {
+                            cached: parsed,
+                            modelName: (0, lodash_1.capitalize)(modelo),
+                        });
+                        const instance = new repository.sequelize.models[(0, lodash_1.capitalize)(modelo)](parsed);
+                        console.log(`[OBISEY-NEST DESERIALIZED] ${modelo}:`, {
+                            id: instance.id,
+                            hasId: 'id' in instance,
+                        });
+                        return instance;
+                    })), //Revisar
                     (resultado) => Promise.resolve(resultado.map((n) => n.get({ plain: true }))), //transformar
                     () => new Promise((resolve) => {
                         resolve(repository.findAll(value)); //Pedir
@@ -151,7 +164,7 @@ function BaseService(modelo) {
                             resolve(undefined);
                     }), //observar
                     (__, resultado) => {
-                        return this.redis.hSet(nkey, peticion, JSON.stringify(resultado.map((n) => n.id)));
+                        return this.redis.hSet(nkey, peticion, JSON.stringify(resultado.map((n) => (0, getModelId_1.getModelId)(n))));
                     });
                     await (0, paginar_1.paginar)(this.cacheManager, key.IdEmpresa, pagina, modelo, resultado.map((n) => n.get({ plain: true })));
                     // if (isDev)
@@ -160,6 +173,7 @@ function BaseService(modelo) {
                     // 		'paginacion',
                     // 		cache,
                     // 	);
+                    console.log(`[BUSCAR-TODOS-RESULT] modelo=${modelo} items=${resultado.length} cache=${cache}`);
                     resolve(resultado ? resultado : []);
                 }
                 catch (err) {

package/prototipos/utils/activarRedis.d.ts

@@ -1 +1 @@
-export declare function onRedis(datos: any, si?: boolean): any;
+export declare function onRedis(datos: any, si?: boolean): boolean;

package/prototipos/utils/formarInclude.d.ts

@@ -1,4 +1,4 @@
-export declare const formarInclude: (include: any, mapa: any, tipo: any, conexion: any, required?: boolean) => Promise<any>;
+export declare const formarInclude: (include: any, mapa: any, tipo: any, conexion: any, required?: boolean) => any;
 declare class FilterBasic {
     is: string;
 }

package/prototipos/utils/formarwhere.d.ts

@@ -1 +1 @@
-export declare const formarWhere: (where: any) => any;
+export declare const formarWhere: (where: any) => {};

package/prototipos/utils/getModelId.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Obtiene el id de una instancia Sequelize o de un objeto plano.
+ * Usa get({ plain: true }) en modelos para evitar shadowing (ej. field: 'Id').
+ */
+export declare function getModelId(instance: any): number | undefined;

package/prototipos/utils/getModelId.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelId = getModelId;
+/**
+ * Obtiene el id de una instancia Sequelize o de un objeto plano.
+ * Usa get({ plain: true }) en modelos para evitar shadowing (ej. field: 'Id').
+ */
+function getModelId(instance) {
+    if (instance == null)
+        return undefined;
+    const plain = typeof instance.get === 'function'
+        ? instance.get({ plain: true })
+        : instance;
+    const id = plain?.id ?? plain?.Id ?? plain?.['ID'];
+    const n = Number(id);
+    return Number.isNaN(n) ? undefined : n;
+}

package/receptor.service.d.ts

@@ -0,0 +1,38 @@
+import { HttpService } from '@nestjs/axios';
+import type { ConexionProps } from './conexion';
+export declare const RECEPTOR_OPTIONS = "RECEPTOR_OPTIONS";
+/** Token para inyectar la factory (config) => Conexion. El app provee: useValue: (config) => new Conexion(config, [todos los modelos]) */
+export declare const CONEXION_FACTORY = "CONEXION_FACTORY";
+export interface ReceptorServiceOptions {
+    /** URL base del emisor (Global/Nucleus), ej. http://localhost:4302 */
+    globalUrl: string;
+    /** Ruta del endpoint emisor, ej. /global/emisor */
+    emisorPath?: string;
+}
+export declare class ReceptorService {
+    private readonly request;
+    private readonly httpService;
+    private readonly options?;
+    private conexionesActivas;
+    constructor(request: any, httpService: HttpService, options?: ReceptorServiceOptions);
+    private getGlobalUrl;
+    private getEmisorPath;
+    /**
+     * Obtiene el mapa de configuraciones de BD desde el emisor (Global).
+     */
+    obtenerConfiguraciones(): Promise<Record<string, ConexionProps>>;
+    /**
+     * Resuelve IdEmpresa para el request actual (session o host → dominios).
+     */
+    obtenerIdEmpresa(data?: Record<string, ConexionProps>): Promise<string | null>;
+    /**
+     * Devuelve la conexión para el request actual. Cachea por IdEmpresa.
+     * @param req - request (opcional si ya inyectado en el servicio)
+     * @param factoryOrClass - factory (config) => T o clase new (config) => T (ej. Conexion de @obisey/nest)
+     */
+    buscar<T = any>(req: {
+        req?: any;
+        headers?: Record<string, string>;
+        session?: any;
+    }, factoryOrClass: ((config: ConexionProps) => T) | (new (config: ConexionProps) => T)): Promise<T | null>;
+}

package/receptor.service.js

@@ -0,0 +1,113 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceptorService = exports.CONEXION_FACTORY = exports.RECEPTOR_OPTIONS = void 0;
+/**
+ * ReceptorService: conexión dinámica centralizada por request.
+ * Obtiene config de BDs desde el emisor (Global/Nucleus), resuelve IdEmpresa
+ * por session o host, cachea conexiones por tenant y devuelve la Conexion
+ * para el request actual.
+ *
+ * Uso: en el provider de cada entidad dinámica:
+ *   useFactory: async (req, receptor: ReceptorService) => {
+ *     const conexion = await receptor.buscar(req, Conexion);
+ *     return { repository: conexion.getRepository(Entity), conexion };
+ *   },
+ *   inject: [REQUEST, ReceptorService],
+ */
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const axios_1 = require("@nestjs/axios");
+exports.RECEPTOR_OPTIONS = 'RECEPTOR_OPTIONS';
+/** Token para inyectar la factory (config) => Conexion. El app provee: useValue: (config) => new Conexion(config, [todos los modelos]) */
+exports.CONEXION_FACTORY = 'CONEXION_FACTORY';
+let ReceptorService = class ReceptorService {
+    constructor(request, httpService, options) {
+        this.request = request;
+        this.httpService = httpService;
+        this.options = options;
+        this.conexionesActivas = new Map();
+    }
+    getGlobalUrl() {
+        return this.options?.globalUrl ?? process.env.GLOBAL_URL ?? 'http://localhost:4302';
+    }
+    getEmisorPath() {
+        return this.options?.emisorPath ?? '/global/emisor';
+    }
+    /**
+     * Obtiene el mapa de configuraciones de BD desde el emisor (Global).
+     */
+    async obtenerConfiguraciones() {
+        const url = `${this.getGlobalUrl()}${this.getEmisorPath()}`;
+        try {
+            const res = await this.httpService.get(url).toPromise();
+            return res?.data ?? {};
+        }
+        catch (err) {
+            console.error('[ReceptorService] Error obteniendo config desde emisor:', url, err);
+            return {};
+        }
+    }
+    /**
+     * Resuelve IdEmpresa para el request actual (session o host → dominios).
+     */
+    async obtenerIdEmpresa(data) {
+        const req = this.request?.req ?? this.request;
+        let IdEmpresa = req?.session?.IdEmpresa ?? req?.headers?.['x-empresa-id'] ?? null;
+        if (IdEmpresa)
+            return String(IdEmpresa);
+        const host = req?.headers?.['host'];
+        if (!host || !data)
+            return null;
+        const key = Object.keys(data).find((k) => data[k].dominios?.some((d) => d.nombre === host));
+        return key ?? null;
+    }
+    /**
+     * Devuelve la conexión para el request actual. Cachea por IdEmpresa.
+     * @param req - request (opcional si ya inyectado en el servicio)
+     * @param factoryOrClass - factory (config) => T o clase new (config) => T (ej. Conexion de @obisey/nest)
+     */
+    async buscar(req, factoryOrClass) {
+        const data = await this.obtenerConfiguraciones();
+        const r = req?.req ?? req ?? this.request;
+        let IdEmpresa = r?.session?.IdEmpresa ?? r?.headers?.['x-empresa-id'] ?? null;
+        if (!IdEmpresa && r?.headers?.host && data) {
+            IdEmpresa = Object.keys(data).find((k) => data[k].dominios?.some((d) => d.nombre === r.headers.host)) ?? null;
+        }
+        if (!IdEmpresa)
+            return null;
+        IdEmpresa = String(IdEmpresa);
+        const cached = this.conexionesActivas.get(IdEmpresa);
+        if (cached)
+            return cached;
+        const config = data[IdEmpresa];
+        if (!config) {
+            console.warn('[ReceptorService] No hay config para IdEmpresa:', IdEmpresa);
+            return null;
+        }
+        const conn = typeof factoryOrClass === 'function' && factoryOrClass.length === 1
+            ? factoryOrClass(config)
+            : new factoryOrClass(config);
+        this.conexionesActivas.set(IdEmpresa, conn);
+        return conn;
+    }
+};
+exports.ReceptorService = ReceptorService;
+exports.ReceptorService = ReceptorService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(core_1.REQUEST)),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)(exports.RECEPTOR_OPTIONS)),
+    __metadata("design:paramtypes", [Object, axios_1.HttpService, Object])
+], ReceptorService);