DEV Community: Fabian Martin

EntityFramework con PostgresSQL

Fabian Martin — Sun, 12 Nov 2023 17:30:23 +0000

Principalmente entender que EntityFramework tiene un parquete para cada una de las funciones que se necesite, en este caso usaremos 3

Paquetes

Microsoft.EntityFrameworkCore
El paquete Microsoft.EntityFrameworkCore es una biblioteca de acceso a datos para .NET Core que proporciona una API para acceder a bases de datos relacionales, NoSQL y de documentos.
Nuget page

Microsoft.EntityFrameworkCore.Tools

El paquete Microsoft.EntityFrameworkCore.Tools proporciona una serie de herramientas para el desarrollo de aplicaciones con Entity Framework Core. Estas herramientas incluyen:

Generador de modelos: Genera clases de entidad a partir de una base de datos existente.
Herramienta de migración: Crea y aplica cambios a la base de datos.
Herramienta de depuración: Ayuda a depurar problemas de acceso a datos.

Nuget page

Npgsql.EntityFrameworkCore.PostgreSQL
El paquete Npgsql.EntityFrameworkCore.PostgreSQL es un proveedor de Entity Framework Core para PostgreSQL. Esto significa que permite que las aplicaciones .NET Core accedan a bases de datos PostgreSQL utilizando Entity Framework Core.

Nuget page

Implementacion en el codigo

Para comenzar a hacer la implementacion debemos tener en cuenta lo que agregaremos, en este caso será un contexto y los modelos de las bases de datos

Context: El contexto es la principal interfaz entre tu aplicación y tu base de datos. Te permite consultar y guardar datos en tu base de datos.
Models: Los modelos en tu código representan las entidades de tu aplicación y cómo estas entidades se relacionan entre sí. En términos de bases de datos, un modelo generalmente representa una tabla.

Primeramente crearemos los modelos de nuestra aplicacion, en este caso los crearé en una carpeta llamada Models y dentro de esta carpeta irá el archivo llamado Todo.cs ya que esta será una tabla en mi base de datos, debemos crear un archivo para cada tabla (para mayor comodidad)

// Models/Todo.cs

// Importando el espacio de nombres System.ComponentModel.DataAnnotations para usar las anotaciones de datos
using System.ComponentModel.DataAnnotations;

// Define el espacio de nombres para el modelo Todos
namespace todoBackend.Models
{
    // Define la clase Todos
    public class Todos
    {
        // El atributo [Key] especifica que TodoId es la clave primaria en la base de datos
        // Guid.NewGuid() genera un nuevo identificador único cada vez que se crea un nuevo elemento Todo
        [Key]
        public Guid TodoId { get; set; } = Guid.NewGuid();

        // Propiedad string nullable para el contenido del elemento Todo
        public string? TodoContent { get; set; }

        // Propiedad boolean nullable para el estado de finalización del elemento Todo, por defecto es false
        public bool? TodoCompleted { get; set; } = false;

        // Propiedad DateTime nullable para la fecha de creación del elemento Todo, por defecto es la fecha y hora actuales
        public DateTime? TodoDateCreated { get; set; } = DateTime.Now;

        // Propiedad DateTime nullable para la última fecha de actualización del elemento Todo, por defecto es null
        public DateTime? TodoDateUpdated { get; set; } = null;

        // Propiedad DateTime nullable para la fecha de finalización del elemento Todo, por defecto es null
        public DateTime? TodoDateCompleted { get; set; } = null;
    }
}

Recuerda que este es un simple ejemplo, tu tendrás que implementar la logica como lo veas necesario en tu proyecto.

Teniendo este entendido empezaremos a agregar el contexto, en este caso crearé una carpeta llamada Data y dentro de esta carpeta irá un archivo llamado AppDbContext.cs.
En este archivo comenzaremos a colocar nuestro codigo

// Data/AppDbContext.cs

// EntityFrameworkCore para trabajar con la clase DbContext
using Microsoft.EntityFrameworkCore;
// Los modelos que tenemos en nuestro codigo
using todoBackend.Models;

// Define el espacio de nombres para el contexto de la base de datos
namespace todoBackend.Data
{
    // Define la clase AppDbContext que hereda de DbContext
    public class AppDbContext : DbContext
    {
        // Define una variable para almacenar la configuración de la aplicación
        protected readonly IConfiguration Configuration;

        // Define el constructor de la clase que toma una configuración como parámetro
        // para posteriormente asignarla a la variable Configuration
        public AppDbContext(IConfiguration configuration)
        {
            // Asigna la configuración a la variable Configuration
            Configuration = configuration;
        }

        // Este método se llama cuando se está configurando el contexto de la base de datos
        // y se utiliza para configurar las opciones de la base de datos
        protected override void OnConfiguring(DbContextOptionsBuilder options)
        {
            // Conecta a la base de datos PostgreSQL utilizando la cadena de conexión de la configuración de la aplicación
            // que se encuentra en el archivo appsettings.json
            options.UseNpgsql(Configuration.GetConnectionString("WebApiDatabase"));
        }

        // Define una propiedad para cada tabla en la base de datos
        public DbSet<Todos> Todos { get; set; }
    }
}

En nuestro appsettings.json agregaremos un nuevo atributo el cual seria WebApiDatabase, esta será la configuracion de nuestra conexion

// appsettings.json

 "ConnectionStrings": {
    "WebApiDatabase": "Host=host; Database=db; Username=postgres; Password=pass"
  }

En nuestro Program.cs agregaremos el contexto de nuestra base de datos

// Program.cs

// Agrega el DbContext al contenedor de inyección de dependencias
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("WebApiDatabase")));

Migracion

Las migraciones en Entity Framework son una forma de actualizar el esquema de una base de datos sin perder datos. Permiten a los desarrolladores realizar cambios en el modelo de datos de su aplicación sin tener que crear y aplicar manualmente las modificaciones a la base de datos.

Esta herramienta está presente en el CLI de Entity Framework, para tenerlo lo instalaremos con el siguiente comando

dotnet tool install --global dotnet-ef

El siguiente comando crea una migración inicial. Esta migración se utiliza para crear la estructura del esquema de base de datos inicial. El nombre de la migración se puede personalizar, pero por defecto es "Init", esto creará una carpeta llamada Migrations en nuestro proyecto, nosotros dejemosla quieta ya que internamente funcionará mas adelante por si sola

dotnet ef migrations add "init"

Finalmente, el siguiente comando aplica las migraciones a la base de datos. En este caso, la migración inicial que se creó en el paso anterior.

dotnet ef database update

Luego de esto podremos ver reflejada la migracion en nuestra base de datos ✅.

Uso en el codigo

Al momento de usarlo en el codigo no entraré mucho en detalles ya que simplemente depende en cada una de las necesiadades del proyecto y del programador.

En este caso agregaré las siguientes lineas, estas líneas de código establecen una conexión entre la clase TodoService y el contexto de la base de datos AppDbContext. Esta conexión es esencial para que la clase TodoService pueda interactuar con la base de datos y realizar operaciones como la recuperación, actualización o eliminación de datos relacionados con las tareas ("todos").

// Services/TodoService.cs

// Importamos nuestro contexto previamente creado
using todoBackend.Data;

// Se declara una variable miembro llamada '_context' de tipo 'AppDbContext'.
private readonly AppDbContext _context;

// Constructor de la clase 'TodoService' que toma un parámetro 'context' de tipo 'AppDbContext'.
public TodoService(AppDbContext context)
{
    // Se asigna el valor del parámetro 'context' a la variable miembro '_context'.
    _context = context;
}

Con esto ahora podremos comenzar a usar la variable _context para manejar la base de datos, es importante mencionar que para manejar las tablas debemos usar _context. <table> o en mi caso _context.Todos ya que previamente definimos la porpiedad con la siguiente linea de codigo

public DbSet<Todos> Todos { get; set; }

Si tuviera otra tabla en mis modelos tendria que definir esa propiedad.

Un servidor basico en Nodejs con Express

Fabian Martin — Sun, 12 Feb 2023 02:56:43 +0000

Teniendo conocimiento de las bases de JavaScript, lo primero que haremos será instalar express en la carpeta de nuestro proyecto, en mi caso usaré PNPM, con el comando pnpm install express, agregare un archivo server.js en el cual ira nuestra proyecto.
Por el momento la carpeta de nuestro proyecto debe lucir algo como esto:

Comenzaremos a modificar nuestro archivo server.js el cual sera la base de todo nuestro servidor.

Lo primero que haremos será requerir express:

const express = require('express')

Ya que express se encuentre requerido en una variable local en nuestro codigo, express para ser usado debemos usar la funcion express() que nos proporciona la libreria para acceder al modulo:

const app = express()

Teniendo la variable app instanciada en nuestro codigo podremos comenzar a usar las funciones que nos proporciona la libreria.
En primer lugar lo que harmeos sera inicializar el servidor, abriendo puertos, asignaremos un puerto y a la hora de correr el codigo le diremos que ya fue inicializado

// Creamos la variable para guardar el puerto y acceder a ella de una manera mas facil
const PORT = 3000

// Usamos el metodo `listen` el cual se une y escucha las conexiones en el host y el puerto especificados. 
app.listen(PORT , () => {
    console.log(`Servidor inicializado en el puerto ${PORT}`)
})

Si en este momento corremos el codigo, el abrira el puerto 3000 y nos mostrara el mensaje

Y si vamos a la URL, en este caso al ser iniciado desde nuestra maquina ser localhost:3000 nos mostrara lo siguiente.

"Cannot GET / " nos da a entender que la ruta / no fue encontrada, lo siguiente que haremos será añadirla, para esto usaremos el metodo <app>.get el cual nos brinda la opcion de añadir la ruta y darle una respuesta.

app.get("/", (req, res) => {
    res.send("Hello dev.to")
})

Esto nos enviara un texto plano que dira Hello dev.to.
Si corremos de nuevo el codigo y nos vamos a la misma direccion nos mostrara nuestro texto.

Esto es un gran paso, ya que logramos inicializar un servidor y devolver un contenido, ahora, en un entorno mas real el contenido que podriamos devolver seria una pagina estatica, un JSON, un archivo, una cookie o hasta una redireccion, en este caso responderemos un archivo JSON y una pagina estatica.

Para responder el JSON primero debemos crear un archivo JSON, por ejemplo, datos.json sera el que yo le dare, en este JSON asignare unos cuantos valores.

{
    "peliculas": [
      {
        "titulo": "The Shawshank Redemption",
        "anio": 1994
      },
      {
        "titulo": "The Godfather",
        "anio": 1972
      },
      {
        "titulo": "The Godfather: Part II",
        "anio": 1974
      },
      {
        "titulo": "The Dark Knight",
        "anio": 2008
      },
      {
        "titulo": "12 Angry Men",
        "anio": 1957
      }
    ]
  }

Ahora en nuestro codigo server.js requeriremos el archivo, primero traeremos un paquete fs el cual nos sirve para realizar tareas como leer, escribir, modificar y eliminar archivos en tu sistema.

const fs = require('fs')

Ahora leeremos el archivo datos.json que se encuentra en la carpeta de nuestro proyecto haciendo uso de la funcion readFileSync que nos brinda 'fs' y lo guadaremos en una constante para usar el archivo

const data = fs.readFileSync("data.json");

Ahora tenemos el archivo en una variable local, sin embargo esta variable aloja los bytes de ese archivo, por lo que no nos mostrara la informacion de el archivo, lo que tenemos que hacer es convertir este archivo en JSON
En JavaScript tenemos una propiedad llamada JSON, el cual cuenta con una funcion llamada parse la cual se utiliza para convertir una cadena de texto en formato JSON en un objeto JavaScript.

const jsonData = JSON.parse(data);

Luego de haberlo convertido y guardado en una variable local nueva podremos mostrarla en alguna ruta, esto lo haremos usando la misma propiedad que usamos en el ejemplo pasado

app.get("/json", (req, res) => {
    res.send(jsonData);
});

Si corremos el codigo y entramos a localhost:3000/json podremos ver:

Esto es bastante util a la hora de construir aplicaciones como APIs o Microservicios en un entorno real.

Ahora para enviar un archivo HTML es aun mas facil.

Primero haremos la web en HTML, creamos el archivo, en este caso yo le dare el nombre web.html, y le agregare el siguiente contenido.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Express Server</title>
</head>
<body>
    <h1>Hola dev.to</h1>
    <h2>Esta es la prueba de una pagina web que esta en un servidor de express</h2>
</body>
</html>

Ahora en nuestro codigo server.js requeriremos path el cual nos servira proporcionandonos una serie de funciones para trabajar con rutas de archivos de manera más fácil y consistente en diferentes sistemas operativos. Este módulo es esencial para cualquier aplicación que tenga que trabajar con archivos y rutas de archivos.

const path = require('path')

Luego usaremos <app>.use el cual nos funciona como un tipo de función de Express que permite definir middleware (funciones intermedias) que se ejecutarán en cada petición HTTP que se realice a la aplicación. Los middlewares son funciones que tienen acceso a la solicitud (req), a la respuesta (res), y a la siguiente función en la cadena de middlewares (next).
Le pasaremos la ruta, luego usaremos express.static la cual nos ayudarara a darle una web estatica a la ruta, dentro de esta funcion usaremos path para tomar el directorio actual y añadirle el nombre del archivo de nuestra web

app.use('/web', express.static(path.join(__dirname, 'web.html')));

Si corremos el codigo y vamos a localhost:3000/web`` veremos:

Podemos afirmar que ha sido redireccionado a nuestro archivo estatico.

Nuestro servidor ahora tendra las rutas
/json la cual respondera un JSON con datos.
/web el cual enviara una archivo estatico.