@obisey/nest 0.1.34 → 0.1.36

package/prototipos/baseResolver.js

@@ -412,10 +412,9 @@ function BaseResolver(modelo) {
                         { nombre: modelo, id: item.id },
                         { nombre: planeta },
                     ],
-                }), (cache) => Promise.resolve(new Clase(JSON.parse(cache))), //Revisar
-                (resultado) => Promise.resolve(resultado ? resultado.get({ plain: true }) : null), //transformar
-                () => item.$get(planeta, { where: (0, formarwhere_1.formarWhere)(where) }), //Pedir
-                () => new Promise(async (resolve) => {
+                }), (cache) => Promise.resolve(new Clase(JSON.parse(cache))), (resultado) => Promise.resolve(resultado
+                    ? JSON.stringify(resultado.get({ plain: true }))
+                    : null), () => item.$get(planeta, { where: (0, formarwhere_1.formarWhere)(where) }), () => new Promise(async (resolve) => {
                     try {
                         let e = await this.redis.hExists(nkey, planeta);
                         if (e) {
@@ -437,11 +436,13 @@ function BaseResolver(modelo) {
                     catch (err) {
                         console.log(this.cacheManager);
                     }
-                }), //observar
-                (__, resultado) => {
-                    if (resultado)
-                        this.redis.hSet(`${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:${resultado.id}`, 'item', JSON.stringify(resultado));
-                    return this.redis.hSet(nkey, planeta, resultado ? JSON.stringify(resultado.id) : null);
+                }), (__, datos) => {
+                    if (datos) {
+                        const parsed = JSON.parse(datos);
+                        this.redis.hSet(`${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:${parsed.id}`, 'item', datos);
+                        return this.redis.hSet(nkey, planeta, String(parsed.id));
+                    }
+                    return this.redis.hSet(nkey, planeta, null);
                 });
                 if (resultado)
                     await (0, paginar_1.paginar)(this.cacheManager, IdEmpresa, pagina, planeta, resultado.get({ plain: true }));
@@ -481,10 +482,7 @@ function BaseResolver(modelo) {
                 }), (cache) => Promise.resolve(cache.map((n) => {
                     const parsed = JSON.parse(n);
                     return Clase.build(parsed, { raw: false, isNewRecord: false });
-                })), //Revisar
-                (resultado) => Promise.resolve(resultado.map((n) => n.get({ plain: true }))), //transformar
-                () => item.$get(planeta, { where: (0, formarwhere_1.formarWhere)(where) }), //Pedir
-                () => new Promise(async (resolve) => {
+                })), (resultado) => Promise.resolve(resultado.map((n) => JSON.stringify(n.get({ plain: true })))), () => item.$get(planeta, { where: (0, formarwhere_1.formarWhere)(where) }), () => new Promise(async (resolve) => {
                     try {
                         let e = await this.redis.hExists(nkey, planeta);
                         if (e) {
@@ -507,9 +505,9 @@ function BaseResolver(modelo) {
                     catch (err) {
                         console.log({ err });
                     }
-                }), //observar
-                (__, resultado) => {
-                    return Promise.all(resultado.map((n) => this.redis.hSet(pkey(n.id), 'item', JSON.stringify(n)))).then(() => this.redis.hSet(nkey, planeta, JSON.stringify(resultado.map((n) => n.id))));
+                }), (__, datos) => {
+                    const parsedItems = datos.map((s) => JSON.parse(s));
+                    return Promise.all(parsedItems.map((n, i) => this.redis.hSet(pkey(n.id), 'item', datos[i]))).then(() => this.redis.hSet(nkey, planeta, JSON.stringify(parsedItems.map((n) => n.id))));
                 });
                 await (0, paginar_1.paginar)(this.cacheManager, IdEmpresa, pagina, planeta, resultado.map((n) => n.get({ plain: true })));
                 // if (isDev)

package/prototipos/baseService.js

@@ -53,15 +53,11 @@ function BaseService(modelo) {
                     let nkey = `${key.universo ? key.universo : 'pro'}:${key.IdEmpresa}:${key.fragmentos[0].nombre}:${id}`;
                     const { resultado, cache } = await (0, cachear_1.cachear)(cacheable, this.cacheManager, (0, keyInterface_1.transformarKey)({ ...key }), (cache) => {
                         return Promise.resolve(repository.sequelize.models[(0, lodash_1.capitalize)(modelo)](JSON.parse(cache)));
-                    }, //Revisar
-                    (resultado) => {
+                    }, (resultado) => {
                         return Promise.resolve(resultado
                             ? JSON.stringify(resultado.get({ plain: true }))
                             : null);
-                    }, //transformar
-                    () => repository.findByPk(id), //Pedir
-                    () => new Promise(async (resolve) => {
-                        //observar
+                    }, () => repository.findByPk(id), () => new Promise(async (resolve) => {
                         let e = await this.redis.hExists(nkey, 'item');
                         if (e) {
                             let item = await this.redis.hGet(nkey, 'item');
@@ -70,9 +66,9 @@ function BaseService(modelo) {
                         else {
                             resolve(undefined);
                         }
-                    }), (__, resultado) => {
-                        if (resultado) {
-                            this.redis.hSet(nkey, 'item', resultado);
+                    }), (__, datos) => {
+                        if (datos) {
+                            this.redis.hSet(nkey, 'item', datos);
                         }
                         return Promise.resolve(false);
                     });
@@ -129,89 +125,42 @@ function BaseService(modelo) {
                         where,
                     }), (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 ModelClass = repository.sequelize.models[(0, lodash_1.capitalize)(modelo)];
-                        const instance = ModelClass.build(parsed, { raw: false, isNewRecord: false });
-                        console.log(`[OBISEY-NEST DESERIALIZED] ${modelo}:`, {
-                            id: instance.id,
-                            hasId: 'id' in instance,
-                        });
-                        return instance;
-                    })), //Revisar
-                    (resultado) => {
-                        console.log(`[TRANSFORMAR] ${modelo}: transforming ${resultado.length} items`);
-                        const plain = resultado.map((n) => n.get({ plain: true }));
-                        if (plain.length > 0) {
-                            console.log(`[TRANSFORMAR-FIRST] ${modelo}:`, plain[0]);
-                        }
-                        return Promise.resolve(plain);
-                    }, //transformar
-                    () => new Promise((resolve) => {
-                        repository.findAll(value).then(result => {
-                            console.log(`[PEDIR-DB] ${modelo}: found ${result.length} items from DB`);
-                            resolve(result);
-                        });
-                    }), //Pedir
-                    () => new Promise(async (resolve) => {
-                        console.log(`[OBSERVAR-START] ${modelo}: checking Redis for nkey=${nkey.substring(0, 50)}`);
+                        return ModelClass.build(parsed, { raw: false, isNewRecord: false });
+                    })), (resultado) => {
+                        return Promise.resolve(resultado.map((n) => JSON.stringify(n.get({ plain: true }))));
+                    }, () => repository.findAll(value), () => new Promise(async (resolve) => {
                         let e = await this.redis.hExists(nkey, peticion);
-                        console.log(`[OBSERVAR-EXISTS] ${modelo}: hExists result=${e}`);
                         if (e) {
                             let ids = await this.redis.hGet(nkey, peticion);
-                            console.log(`[OBSERVAR-IDS] ${modelo}: hGet returned=${ids ? ids.substring(0, 60) : 'NULL'}`);
                             if (ids) {
                                 const idArray = JSON.parse(ids);
-                                console.log(`[OBSERVAR-IDS-PARSED] ${modelo}: parsed ${idArray.length} IDs=[${idArray.join(',')}]`);
-                                Promise.all(idArray.map(async (id, idx) => {
-                                    const exists = await this.redis.hExists(pkey(id), 'item');
-                                    console.log(`[OBSERVAR-EXISTS-${idx}] ${modelo}: id=${id}, hExists(pkey(id), 'item')=${exists}`);
-                                    return exists;
-                                })).then((exists) => {
-                                    console.log(`[OBSERVAR-EXISTS-ARRAY] ${modelo}: all checks done, exists=[${exists}], includes(false)=${exists.includes(false)}`);
+                                Promise.all(idArray.map(async (id) => this.redis.hExists(pkey(id), 'item'))).then((exists) => {
                                     if (!exists.includes(false)) {
-                                        console.log(`[OBSERVAR-ALL-EXIST] ${modelo}: all items exist, fetching from Redis`);
-                                        Promise.all(idArray.map(async (id, idx) => {
-                                            const item = await this.redis.hGet(pkey(id), 'item');
-                                            console.log(`[OBSERVAR-HGET-${idx}] ${modelo}: id=${id}, hGet(pkey(id), 'item')=${item ? item.substring(0, 60) : 'NULL'}`);
-                                            return item;
-                                        })).then(items => {
-                                            console.log(`[OBSERVAR-RESOLVE-ITEMS] ${modelo}: resolving ${items.length} items from Redis`);
-                                            console.log(`[OBSERVAR-ITEMS-CONTENT] ${modelo}: [0]=${items[0] ? items[0].substring(0, 80) : 'NULL'}`);
-                                            console.log(`[OBSERVAR-ITEMS-NULL-COUNT] ${modelo}: ${items.filter(i => i === null).length} NULL items out of ${items.length}`);
-                                            resolve(items);
-                                        });
+                                        Promise.all(idArray.map(async (id) => this.redis.hGet(pkey(id), 'item'))).then(resolve);
                                     }
-                                    else {
-                                        console.log(`[OBSERVAR-INCOMPLETE] ${modelo}: some items missing. exists.includes(false)=true, fallback to DB`);
+                                    else
                                         resolve(undefined);
-                                    }
                                 });
                             }
-                            else {
-                                console.log(`[OBSERVAR-NO-IDS] ${modelo}: hGet returned null, no IDs in Redis, fallback to DB`);
+                            else
                                 resolve(undefined);
-                            }
                         }
-                        else {
-                            console.log(`[OBSERVAR-NOT-EXISTS] ${modelo}: hExists returned false, nkey not in Redis, fallback to DB`);
+                        else
                             resolve(undefined);
-                        }
-                    }), //observar
-                    (__, resultado) => {
-                        // LEGACY PATTERN: Save individual items FIRST, then save IDs
-                        return Promise.all(resultado.map((n) => this.redis.hSet(pkey(n.id || n), 'item', JSON.stringify(n)))).then(() => this.redis.hSet(nkey, peticion, JSON.stringify(resultado.map((n) => n.id || n))));
+                    }), (__, datos) => {
+                        return Promise.all(datos.map((n) => {
+                            const parsed = JSON.parse(n);
+                            return this.redis.hSet(pkey(parsed.id), 'item', n);
+                        })).then(() => this.redis.hSet(nkey, peticion, JSON.stringify(datos.map((n) => JSON.parse(n).id))));
                     });
-                    await (0, paginar_1.paginar)(this.cacheManager, key.IdEmpresa, pagina, modelo, resultado.map((n) => n.get({ plain: true })));
+                    await (0, paginar_1.paginar)(this.cacheManager, key.IdEmpresa, pagina, modelo, resultado.map((n) => JSON.stringify(n.get({ plain: true }))));
                     // if (isDev)
                     // 	console.log(
                     // 		// moment().diff(moment(tiempo), 'milliseconds', true),
                     // 		'paginacion',
                     // 		cache,
                     // 	);
-                    console.log(`[BUSCAR-TODOS-RESULT] modelo=${modelo} items=${resultado.length} cache=${cache}`);
                     resolve(resultado ? resultado : []);
                 }
                 catch (err) {
@@ -241,7 +190,6 @@ function BaseService(modelo) {
                         `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:pre${modelo}`,
                         `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:arbol:${modelo}`,
                     ];
-                    console.log(`Keys a eliminar::::`, keys);
                     await this.eliminarCache(keys, borrarSSR);
                     // imprimir(`${modelo} ${item.id} crear`)
                     // let key$ : string = transformarKey({
@@ -293,10 +241,7 @@ function BaseService(modelo) {
                         ...key,
                         include,
                         where: stringifWhere(where),
-                    }), (cache) => Promise.resolve(JSON.parse(cache)), //Revisar
-                    (resultado) => Promise.resolve(JSON.stringify(resultado)), //transformar
-                    () => repository.count({ ...value, distinct: false }), //Pedir
-                    () => new Promise(async (resolve) => {
+                    }), (cache) => Promise.resolve(JSON.parse(cache)), (resultado) => Promise.resolve(JSON.stringify(resultado)), () => repository.count({ ...value, distinct: false }), () => new Promise(async (resolve) => {
                         let e = await this.redis.hExists(nkey, peticion);
                         if (e) {
                             let item = await this.redis.hGet(nkey, peticion);
@@ -310,9 +255,8 @@ function BaseService(modelo) {
                         else {
                             resolve(undefined);
                         }
-                    }), //observar
-                    (__, resultado) => {
-                        return this.redis.hSet(nkey, peticion, resultado);
+                    }), (__, datos) => {
+                        return this.redis.hSet(nkey, peticion, datos);
                     });
                     // let key$ : string = transformarKey({ nombre : 'contar', ...key, include, where : stringifWhere(where) })
                     // const cache = await this.cacheManager.get(key$)

package/prototipos/utils/cachear.d.ts

@@ -1,4 +1,14 @@
-export declare const cachear: (cacheable: boolean, cacheManager: any, key: string, revisar: (x: any) => Promise<any>, transformar: (x: any) => Promise<any>, pedir: () => Promise<any>, observar?: (x: any) => Promise<any>, actualizar?: (x: any, datos: any) => Promise<any>) => Promise<{
-    resultado: any;
+/**
+ * Cache orchestration with two generic types:
+ *
+ * TResult = the "live" type (Sequelize instance, number, etc.)
+ * TCache  = the "serialized" type (string, string[], etc.)
+ *
+ * Symmetry:
+ *   TOWARD Redis:  TResult → transformar → TCache → actualizar → Redis
+ *   FROM   Redis:  Redis → observar → TCache → revisar → TResult
+ */
+export declare function cachear<TResult, TCache>(cacheable: boolean, cacheManager: any, key: string, revisar: (cache: TCache) => Promise<TResult>, transformar: (resultado: TResult) => Promise<TCache>, pedir: () => Promise<TResult>, observar?: (key: string) => Promise<TCache | undefined>, actualizar?: (key: string, datos: TCache) => Promise<any>): Promise<{
+    resultado: TResult;
     cache: boolean;
 }>;

package/prototipos/utils/cachear.js

@@ -1,24 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cachear = void 0;
+exports.cachear = cachear;
 const lodash_1 = require("lodash");
-// const chalk = require('chalk');
-// const log = console.log;
-// var imprimir = (texto) => log(chalk.blue(texto));
 var tiempo = 86400000;
-const cachear = (cacheable, cacheManager, key, revisar, transformar, pedir, observar = (key) => cacheManager.get(key), actualizar = (key, datos) => cacheManager.set(key, datos, 'EX', tiempo)) => {
+/**
+ * Cache orchestration with two generic types:
+ *
+ * TResult = the "live" type (Sequelize instance, number, etc.)
+ * TCache  = the "serialized" type (string, string[], etc.)
+ *
+ * Symmetry:
+ *   TOWARD Redis:  TResult → transformar → TCache → actualizar → Redis
+ *   FROM   Redis:  Redis → observar → TCache → revisar → TResult
+ */
+function cachear(cacheable, cacheManager, key, revisar, transformar, pedir, observar = (key) => cacheManager.get(key), actualizar = (key, datos) => cacheManager.set(key, datos, 'EX', tiempo)) {
     return new Promise(async (resolve) => {
         try {
             const cache = await observar(key);
             let resultado;
-            // console.log({ cache, cacheable })
             if (!(0, lodash_1.isUndefined)(cache) && ((0, lodash_1.isUndefined)(cacheable) || cacheable)) {
                 resultado = await revisar(cache);
                 resolve({ cache: true, resultado });
                 return;
             }
             resultado = await pedir();
-            // console.log({resultado})
             let datos = await transformar(resultado);
             await actualizar(key, datos);
             resolve({ cache: false, resultado });
@@ -28,5 +33,4 @@ const cachear = (cacheable, cacheManager, key, revisar, transformar, pedir, obse
             console.log({ key, err });
         }
     });
-};
-exports.cachear = cachear;
+}

package/adapters/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-"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

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

package/adapters/sequelize/index.js

@@ -1,9 +0,0 @@
-"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

@@ -1,79 +0,0 @@
-/**
- * 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

@@ -1,134 +0,0 @@
-"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/prototipos/index.d.ts

@@ -1,9 +0,0 @@
-export * from './baseService';
-export * from './baseResolver';
-export * from './baseController';
-export * from './utils/paginar';
-export * from './utils/keyInterface';
-export * from './utils/cifrado';
-export * from './utils/cachear';
-export * from './utils/activarRedis';
-export * from '../types';

package/prototipos/index.js

@@ -1,26 +0,0 @@
-"use strict";
-// src/index.ts
-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("./baseService"), exports);
-__exportStar(require("./baseResolver"), exports);
-__exportStar(require("./baseController"), exports);
-__exportStar(require("./utils/paginar"), exports);
-__exportStar(require("./utils/keyInterface"), exports);
-__exportStar(require("./utils/cifrado"), exports);
-__exportStar(require("./utils/cachear"), exports);
-__exportStar(require("./utils/activarRedis"), exports);
-__exportStar(require("../types"), exports);

package/receptor.d.ts

@@ -1,25 +0,0 @@
-import { HttpService } from '@nestjs/axios';
-import { Conexion, ConexionProps } from './conexion';
-export interface ReceptorConfig {
-    globalUrl: string;
-}
-export declare class ReceptorService {
-    private cacheManager;
-    readonly request: any;
-    private httpService;
-    private readonly config?;
-    conexiones: {
-        [key: string]: ConexionProps;
-    };
-    conexionesActivas: {
-        [key: string]: Conexion;
-    };
-    constructor(cacheManager: any, request: any, httpService: HttpService, config?: ReceptorConfig);
-    hola(): void;
-    private get globalUrl();
-    buscarConexiones(): Promise<any>;
-    buscarEmpresa(): Promise<any>;
-    buscar({ req }: {
-        req: any;
-    }, conexion: typeof Conexion, host_?: string): Promise<Conexion>;
-}