Liderazgo y subirse al balcón

¿Qué es liderazgo?

Actualmente el concepto como tal de liderazgo puede variar para consideración de cada uno, como las teorías escritas por todos esos experto que transmiten sus conocimiento sobre liderazgo. La definición que más me ha gustado de Liderazgos es la siguiente: es la práctica encaminada en transformar equilibrios sociales, catalizar los mejores resultados colectivos y enfocar los esfuerzos para la movilización de personas y recursos. Si bien liderar, no es como forzar su autoridad para lograr resultados, sino que asociado colectivamente encontrar el camino hacia el objetivo, donde todos los que participan son líderes que intervienen activamente y ya hay uno que cataliza precisamente todo ese esfuerzo colectivo.

¿Cómo es eso de subir al balcón?

Yo antes no había escuchado este término, incluso cuando lo escuche para el liderazgo no encontraba una manera de relacionarlos como tal. Ahora para que nos demos cuenta que relación tiene, es que cuando aplicamos liderazgo, debemos observar que está ocurriendo, pero más allá de solo ver, debemos sentir, vivir y conocer que sucede dentro. Prácticamente el líder debe estar dentro tener problemas, aciertos, socializar con los demás, colaborar, como quien dice estar en la jugada como los demás. Pero este debe ser capaz de hacer un stop y subirse al balcón  y analizar, razonar, considerar como se encuentra el equipo, que rumbo está teniendo las actividades, entre otros elementos que afecten la labor y luego de eso volver a la jugada y plantear soluciones, opiniones, opciones y lo que se considere necesario para beneficiarnos a todos y que estamos todos de acuerdo.

¿Aplica en la realidad?

Resulta que en la realidad, por ciertos momentos podemos ser líderes como también seremos el seguidor o la seguidora. Aquí cuento un par de experiencias ocupando estos dos roles.

Actualmente vivo con mi esposa y dos de sus hermanos, pero tanto con mi esposa y yo queremos mudarnos, para evitar cierto estrés. Pero ya es un estrés externo, nos afecta la forma de vivir de nuestros vecinos y bueno la casa esta construida preciso para que nos afecte. Entonces necesitamos cambiar y fue allí cuando la aborde. Antes lo había mencionado sin éxito, pero ahora con los fundamentos correcto me tomo la razón mas otras consideraciones. En este ejemplo, fui líder dos veces, pero obviamente la segunda aprendí de que antes estaba ofuscado y no noté ciertas cosas, para tomar esa decisión. Eche un momento para atrás y volví como quien dice, a la revancha, pero ya con las herramientas adecuadas.

En mi segunda experiencia, es con un colega, donde estamos haciendo un proyecto para un cliente. Para el desarrollo del mismo, definimos unas pautas, en cual yo accedí, y además me permite desenvolverme en otras actividades. Cabe destacar que él es el contacto con el cliente y quien distribuye el dinero recibido para los dos. La situación fue que debía hacer una transferencia de conocimiento, que al final afecto mi tiempo disponible. Yo en vista de eso, traté de cerrar, pero él no entendía y quería continuar. Aquí me afectó un poco la autoridad aprendida con los años, el que te paga es quien manda. Así que no tuve remedio que seguir. Aquí claramente es mi error, realmente no supe como defender mi punto y obviamente de él tampoco, porque no fue capaz de percatar que algo afectaba la actividad.

Conclusión

Como vemos de los ejemplos anteriores, el resultado que obtenemos a la hora de liderar depende de como apliquemos nuestras habilidades de ver fuera de la caja y de darse cuenta realmente que está sucediendo ya sea desde adentro o desde afuera. El liderazgo no sale así con solo teoría y realmente hay que ponerlo bastante en práctica, además que se puede aplicar en cualquier ámbito, así como hice con mi esposa y mi compañero de trabajo. Este también se vuelve más difícil e interesante cuando hay varias personas participando, donde hay mas variedad en los puntos de vistas y de intereses.

Bueno hasta aquí esta publicación, espero les haya gustado. Sin más me despido, hasta pronto.

Estándar y buenas prácticas con NestJS Framework

Introducción

Cuando trabajamos en nuestras aplicaciones implementando NestJS, es necesario seguir unas pautas que el mismo Framework propone e igualmente para Typescript seguir unas buenas prácticas de desarrollo. En el presente tutorial vamos a transformar el proyecto NestJS que he venido desarrollando con cada publicación, aplicando prácticas correctas en el desarrollo del proyecto. Igualmente si no han visto las publicaciones anteriores, aquí pueden descargar el código con todas las implementaciones previas e igualmente revisar este enlace para la configuración con MongoDB. Para poder probar las API expuestas en el proyecto, pueden descargar está colección de Postman (aquí), que ya tiene ejemplos de como hacer las peticiones.

Que necesitamos...

• El proyecto NestJS antes mencionado.
• Base de datos MongoDB activa.
• Tener instalado NodeJS en su última versión estable.
• Tener instalado NestJS, igual revisar este enlace para su instalación.
• Tener instalado Yarn (No obligatorio).
• Tener instalado Postman e importar la colección proporcionada más arriba.

Manos a la obra

El proyecto se trata de almacenar los cursos que estoy ejecutando, próximo a ejecutar o ya finalizados. Básicamente es un CRUD de cursos. Entonces como nuestra entidad es sobre cursos debemos crear un módulo asociado a este. Eso lo hacemos con el siguiente comando:

    nest generate module courses

Con este comando nos crea una carpeta con la siguiente ruta src/courses con un archivo courses.module.ts que es la definición del módulo y en app.module.ts nos hará la importación de este nuevo modulo CoursesModule. Lo siguiente es crear un servicio, que básicamente tendrá toda nuestra lógica de negocio y que tendrá la comunicación con nuestra base de datos. Eso igualmente lo crearemos en el terminal con lo siguiente:

    nest g service courses

Fíjense que esta vez no coloque generate completo sino simplemente g, funciona exactamente igual, pero es un alias a la opción completa. Aquí nos genera dos archivos, uno donde escribiremos la lógica de negocio y otro para el testing. Entonces la primera transformación es pasar nuestra lógica de src/app.service.ts, vamos a copiar todo lo que está dentro de la clase AppService (no olvidar eliminar el contenido más adelante). Debe quedar como la siguiente imagen.

Encontraremos que falta varias importaciones, por ejemplo las interfaces. Por lo general dedicamos un archivo de interfaces por módulo, cuando son exclusivos para el mismo. En este caso crearemos una interfaces con el terminal:

    nest g interface courses/courses

Aquí pegaremos las interfaces que están por encima de la clase AppService. Como vemos a continuación.

Ahora lo siguiente es crear nuestro controlador, que es donde está todo lo que es el tratamiento de las peticiones HTTP, es decir las rutas, métodos, respuestas, validaciones y otras configuraciones para nuestra API Rest. Para crear ejecutamos el siguiente comando:

    nest g co courses

Como vemos en la siguiente instrucción, en vez de escribir controller pudimos solo escribir co, que hace la misma función, igualmente en las conclusiones indico el enlace para conocer un poco más sobre NestJS CLI. Aquí copiaremos el contenido de AppController del archivo src/app.controller.ts. Debe quedar de la siguiente manera.

Ya solo nos queda mover la carpeta src/course dentro de src/courses. Pueden ignorar que el editor les mencione corregir las importaciones, porque igualmente hay que crearlos o modificarlos en la nueva estructura. Debemos borrar todos los contenidos copiados, porque ahora con el editor y la ejecución de NestJS iremos corrigiendo las importaciones. Para los que usemos Visual Studio Code, podemos valernos de la extensión TypeScript Importer, este con colocar en código con error, podemos presionar la combinación CTRL+Space (CTRL + Barra espaciadora), nos indicará las opciones para importar automáticamente. 

Deben quedar así de limpios los archivos src/app.controller.ts y src/app.service.ts. Si nos está faltando son los archivo modules, pero eso lo hacemos al final. Ejecutemos en el terminal lo siguiente y por su cuenta pueden empezar a corregir y a importar los elementos que hacen falta, yo por aquí les mostraré los resultados para cada archivo, para que antes de que empiecen a corregir tengan una guía de los resultados.

    yarn start:dev

Cabe destacar que en courses.controller.ts ya no usaremos appService sino que estaremos usando el propio del módulo, que es en este caso courseService.

Ya por último en src/app.module.ts, vamos a copiar la línea roja y eliminar la línea verde que vemos en la siguiente imagen:

Y esta línea roja que copiamos vamos a ir al archivo src/courses/courses.module.ts y la pegamos dentro de los imports del módulo y hacemos las importaciones pertinentes, como vemos a continuación.

Con este último cambio ya debe estar funcionando nuestra aplicación. Cabe recalcar en este último cambio, es notar como se ve un modulo y que componentes contiene. Por un lado definimos que controladores y servicios gestionará nuestro módulo y que nos permitirá realizar las inyecciones de dependencia de nuestro servicios en el constructor de nuestros controladores. Igualmente están los imports, que allí puede estar los providers o módulos externos que queramos inyectar en nuestro controlador o servicios del módulo, por ejemplo cuando inyectamos de MongooseModule el schema de nuestra base de datos en nuestro servicio.

Para realizar las pruebas, de nuestras API, ahora debemos anteponer la palabra courses, debido que nuestro módulo empieza desde el módulo de Cursos. Aquí el ejemplo del GET en Postman.

Conclusión

Bien ya hemos llegado al final del tutorial, queda como tarea validar las API desde Postman, todo funcione correctamente. Como prometí, aquí les regalo el enlace de como usar NestJS CLI, para que puedan echar una ojeada de como funciona. Vean que ahora el proyecto luce un más organizado y bastante estructurado, este es el poder de aplicar el estándar y buenas prácticas de NestJS y Typescript. Sin más que decir, espero que les haya gustado la siguiente publicación, si tienen alguna duda, no duden en comentarlo. Hasta pronto.

 Conectar Proyecto NestJS con MongoDB

Introducción

Cuando estamos trabajando en nuestras aplicaciones Web, casi siempre es muy necesario tener persistencia de datos, ya sea para el registro de usuarios, los artículos para una tienda, configuraciones generales, etc. En la siguiente publicación estaré explicando como conectar nuestro proyecto hecho con el Framework NestJS hacia una base de datos MongoDB. Para este tutorial tomaré como referencia estos artículos anteriores Validaciones NestJS y Docker MongoDB, para ir armando las conexiones. Igualmente dejo por aquí en código del proyecto NestJS. También usaremos Postman aquí la JSON collection para que lo descarguen y lo puedan usar.

Que necesitaremos

Necesitaremos lo mismo que tenemos en los post anteriores, que comento a continuación:

• NodeJS en su última versión estable.

• Docker y docker-compose.

• Cliente MongoDB, puede ser NoSQLBooster (estaré usando este) o Robo3t.

• Editor de código que ustedes prefieran. Yo estaré con Visual Studio Code.

Manos a la obra

Con el proyecto anterior o ya descargado, vamos ejecutar las siguientes instrucciones en el terminal de comandos. Cabe destacar que deben estar situados en la raíz del proyecto en el terminal.

    yarn install
    yarn add @nestjs/mongoose mongoose
    yarn add -D @types/mongoose

Para este proyecto como ven, usaremos la librería mongoose que nos permitira crear modelos y las conexión a nuestra base de datos. Luego vamos a configurar nuestra DB para poder conectarnos, así cuando editemos nuestro código no haya problemas de conexión. Lo primero que haremos es modificar el docker-compose.yml, de la práctica anterior. Importante: si ya tienen el motor de base de datos configurado aparte, pueden saltarse este único paso.

    version: "3.7"

    services:
        mongo:
            image: mongo:4.4
            restart: always
            env_file: .env
            ports: 
                - 27017:27017
            volumes: 
                - bloggerdb:/data/db

    volumes: 
        bloggerdb:

La modificación que agregamos fue la adicionar el volumen para que la DB persista en nuestra PC. Ahora nos conectamos a nuestra DB y crearemos la Base de datos y el usuario que tendrá de lectura/escritura. Dejo las capturas para que le puedan hacer seguimiento.

Creación de base de datos.

"devnote" porque la configuración del proyecto tenemos este nombre de base de datos.

Agregar usuario de lectura y escritura (Read Write).

Modificar credenciales para que quede de esta manera. No olvidar darle "run" para que se ejecute está instrucción y cree a dicho usuario.

Ahora sí al código de NestJS, vamos a crearnos el archivo course.schema.ts en el directorio src/course y le vamos a colocar el siguiente código:

    import { Prop, Schema, SchemaFactory, SchemaOptions } from '@nestjs/mongoose';
    import { Document } from 'mongoose';
    import { State } from 'src/app.service';

    @Schema({
        collection: 'courses',
    })
    class CourseModel extends Document {
        @Prop({
            type: String,
            required: true,
        })
        name: string;

        @Prop({
            type: String,
            required: true,
            enum: [ 'completed', 'progress', 'wait' ]
        })
        state: State;
    }

    const CourseSchema = SchemaFactory.createForClass(CourseModel);

    export {
        CourseModel, 
        CourseSchema
    }

Aquí básicamente indicamos que la colección a usar es courses y tendrá dos propiedades name y state, donde los dos son requeridos y para state tiene solo 3 valores posibles con la propiedad de mongoose enum. Nota: Como usamos Typescript, podemos agregar la implementación de la interface ICourse, agréguenlo si ustedes desean.

En lo siguiente es editar el archivo app.module.ts, debe quedar muy parecido a lo siguiente:

    import { Module } from '@nestjs/common';
    import { AppController } from './app.controller';
    import { AppService } from './app.service';
    import { ConfigModule } from '@nestjs/config';
    import { MongooseModule } from '@nestjs/mongoose';
    import { CourseModel, CourseSchema } from './course/course-schema';

    function getConectionMongo(): string {
        return `mongodb://${process.env.DB_USER}:${process.env.DB_PASSWORD}@localhost/${process.env.DB_DATABASE}`;
    }

    @Module({
        imports: [
            ConfigModule.forRoot({
                envFilePath: process.env.NODE_ENV
                    ? `.${process.env.NODE_ENV}.env`
                    : '.development.env',
            }),
            MongooseModule.forRoot(getConectionMongo(), {
                useNewUrlParser: true,
            }),
            MongooseModule.forFeature([{ name: CourseModel.name, schema: CourseSchema }]),
        ],
        controllers: [AppController],
        providers: [AppService],
    })
    export class AppModule {}

Aquí aprovechamos la configuración del process.env para obtener las credenciales y nombre de la base de datos a conectar, igualmente la uri que coloco aquí es precisamente como lo menciona la documentación. Y luego también importamos el modelo a nuestro modulo, cabe destacar que si siguiéramos el estándar de NestJS, deberíamos haber creado un modulo de courses, cuestión que haré en la siguiente publicación. Ya por último les dejo como quedó el código de app.service.ts que es donde haremos el uso de nuestro modelo CourseModel.

    import { Injectable } from '@nestjs/common';
    import { InjectModel } from '@nestjs/mongoose';
    import { Model } from 'mongoose';
    import { CourseModel } from './course/course-schema';

    // Recomendación pasar enum e interfaces a archivos dedicados a tal fin
    export enum State {
        wait,
        progress,
        completed
    }

    export interface ICourseKey {
        // id:number;
        _id:string;
    }

    export interface ICourseAttributes {
        name: string;
        state: State;
    }

    export interface ICourse extends ICourseKey, ICourseAttributes {}

    @Injectable()
    export class AppService {
    
        constructor(@InjectModel(CourseModel.name) private courseModel: Model<CourseModel>) {}

        // private courses: ICourse[] = [];

        async getCourses(): Promise<ICourse[]> {
            // return this.courses;
            return this.courseModel.find({});
        }

        async findCourse(id: number): Promise<ICourse> {
            // return this.courses.find(item => item.id == <number>id);
            return {
                _id: 'mientras',
                name: 'Curse',
                state: State.progress,
            };
        }

        async createCourse(course: ICourseAttributes): Promise<ICourse> {
            /*
                const idNext = (this.courses.length)? this.courses[this.courses.length - 1].id + 1: 1
                const newLength = this.courses.push({ id:idNext, ...course })
                return this.courses[newLength - 1]
            */
            const createdCourse = new this.courseModel(course);
            return createdCourse.save();
        }

        async updateCourse(id: number, course: ICourseAttributes): Promise<ICourse> {
            /*
                const updateIndex: number = this.courses.findIndex(
                    item => item.id == <number>id,
                );
                this.courses[updateIndex].name = course.name;
                this.courses[updateIndex].state = course.state;

                return this.courses[updateIndex];
            */
            return {
                _id: 'mientras',
                name: 'Curse',
                state: State.progress
            }
        }

        async deleteCourse(id: number): Promise<ICourse> {
            /*
                const startIndex: number = this.courses.findIndex(item => item.id === id);
                const deleteCourse = this.courses.splice(startIndex, 1);

                return deleteCourse[0];
            */
            return {
                _id: 'mientras',
                name: 'Curse',
                state: State.progress,
            };
        }
    }

Donde ya dejo funcionando createCourse y getCourses,  para que ustedes puedan completar los demás. Ya un poco detallando que se hizo, el ICourseKey ya no tiene un parámetro number sino de tipo string y el atributo ahora es _id, más que todo porque MongoDB funciona este atributo como llave primaria. Se hizo la inyección de CourseModel para la interacción con está colección a través del modelo. También se removió el atributo privado courses que era donde se alojaba nuestra base de datos temporal. Ahora les muestro los resultados de los métodos que ya están listos en el Postman y en base de datos.

Creación del curso desde Postman.

Documento creado con el Post. No olvidar refrescar la DB para ver los cambios.

Obtener listado de cursos.

Aquí damos por terminado este tutorial, ya que les queda bastante práctica para resolver los otros métodos, además que ya aprendimos a conectarnos a nuestra Base de datos de MongoDB. En una próxima publicación si mostraremos como se debe distribuir los módulos para que no tengamos todo sobre app module y tomando en cuenta las buenas prácticas que nos menciona el framework NestJS. No siendo más, me despido, espero sus comentarios hasta pronto.